Text needs fixing

• This predicate takes general numbers, including non-rational integers
• It also takes lists of integers and interpretes them as list of unicode codevalues
• It also takes lists of characters (1-atom atoms) and merges them

Conversion!

Making clear the intention of using atom_string/2 by splitting its functionality:

% clause 1: just need to make sure X is nonvar (groundedness etc are checked by atom_string/2)
% clause 2: raise exception if X is a var

convert_to_string(X,Str) :- nonvar(X),!,atom_string(X,Str).
convert_to_string(X,_)   :- var(X),!,instantiation_error(X).
   
convert_to_atom(X,Atom)  :- nonvar(X),!,atom_string(Atom,X).
convert_to_atom(X,_ )    :- var(X),!,instantiation_error(X).

Yup! Those go into the toolbag!

• Code
• Tests

Hmmm...

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"

Maybe these predicates which accepts several representations of the "same thing" should be thought of as operating on equivalence classes but returning a preferred representative of the equivalence class depending on the argument, whereas verification can work with any representative of the equivalence class!

?- atom_string(foo, Z).

Z = "foo".

?- atom_string("foo", Z).

Z = "foo".

?- atom_string(Z, "foo").

Z = foo.

?- atom_string(Z, 'foo').

Z = foo.