Did you know ... Search Documentation:
Predicate atom_string/2
Availability:built-in
atom_string(?Atom, ?String)
Bi-directional conversion between an atom and a string. At least one of the two arguments must be instantiated. An initially uninstantiated variable on the “string side'' is always instantiated to a string. An initially uninstantiated variable on the “atom side'' is always instantiated to an atom. If both arguments are instantiated, their list-of-character representations must match, but the types are not enforced. The following all succeed: 
atom_string("x",'x').
atom_string('x',"x").
atom_string(3.1415,3.1415).
atom_string('3r2',3r2).
atom_string(3r2,'3r2').
atom_string(6r4,3r2).
Tag confusing pages with doc-needs-help|Tags are associated to your profile if you are logged in|Report abuse
Tags:
  • compare_stringy_things
  • doc-needs-help
LogicalCaptain said (2020-01-20T13:46:50):0 upvotes 0 0 downvotes
Picture of user LogicalCaptain.

This also is the "comparison operator for stringy things"

Suppose you have received a "stringy thing".

How do you compare it against a known atom while not worrying about the actual underlying type? Using this predicate!

atom_string(known,StringyThing)

will compare against atom known, doing all conversions for you!

Doc-needs-help

atom_string/2 takes anytext (as explained here), and these also succeed:

Note: Backticks is the notation for a "list of character codes" (unless Prolog is running with the 'traditional' flag):

?- X=`alpha`.
X = [97,108,112,104,97].

Then:

atom_string(`alpha`,"alpha").
atom_string("alpha",`alpha`).

Similarly for lists of characters or "chars":

?- atom_chars(hello,X),atom_string(X,hello).
X = [104,101,108,108,111].

?- atom_chars(hello,X),atom_string(hello,X).
X = [104,101,108,108,111].

Test case

Here is a Test case for illustration/documentation purposes

Note that atom_string/2 does not really behave "predicate-ly" but more like a two-sided pipeline.

Send in anything "stringy" ------>+      +---------> String equivalent of the input
                                  |      |
                   atom_string(?Atom, ?String)
Atom equivalent of the input <----+      +<------ Send in anything "stringy"
                                  |      |
                   atom_string(?Atom, ?String)
Send in anything "stringy" ------>+      +<------ Send in anything "stringy"
                                  |      |
                   atom_string(?Atom, ?String)
                                  |      |
                      "true if stringily equivalent"
                 (implies equivalence classes across types)

A generic replacement

A module providing a replacement for

with a type-information taking/providing predicate stringy_morph/4

and a replacement for all of

with a type-information taking/providing predicate stringy_charylist_morph/4

On this page:

README_stringy_morph.md

Peter Ludemann said (2018-09-23T09:13:45):0 upvotes 0 0 downvotes
Picture of user Peter Ludemann.

?- atom_string(foo, Z).

Z = "foo".

?- atom_string("foo", Z).

Z = "foo".

?- atom_string(Z, "foo").

Z = foo.

?- atom_string(Z, 'foo').

Z = foo.