Creating the #< BIP in prolog - list

Question

I'm basically trying to create 'my own' version of the #< operator in prolog, i.e. something to the tune of at_less(F1,F2), where it returns true if F1#
So some example inputs:
?- at_less(1.2,0)
yes
?-at_less(0,1.2)
no
?-at_less(f(1,2,a),f(1,2,b)).
yes
Obviously I don't want to use the #< operator, as that would be redundant :)
I can understand how one would compare two atoms, with something like
%atom_pr(+A1,+A2): A1 #< A2, where A1 and A2 are atoms.
atom_pr(L1,L2):-
atom_codes(L1,First), %atom codes for first
atom_codes(L2,Second),%atom codes for second
code_compare(First,Second). %compare the codes, return true or false
code_compare([HF|TF],[HS|TS]):-
( HF=HS ->
code_compare(TF,TS)
;
HF<HS ->
true
;
fail
).
code_compare([],X):-
true.
code_compare([],[]).
%(I understand this is probably not the most efficient way of going about this, but I'm %just beginning!)
Is there something similar I can do for all constants, rather than just atoms? Is there a command similar to atom_codes/2? If not, the only thing I can think of doing is breaking it into a great number of if -> else statements, checking to see if the first is an atom and the second isn't etc. etc., but this seems like a kinda tedious/poor method perhaps?
Thanks in advance for the help!
Edit: Thanks to the help below, I've gotten a program running that is functional (at least from what I can tell). I've put it in the code below, in case someone else wanders here. I believe it is, however, extremely inefficient, so there's plenty of room for improvement :)
%flat_pr(+F1, +F2): F1#<F2, where F1 and F2 are flat ground terms
flat_pr(F1,F2):-
( compound(F1) -> %these ifs here to check what type F1 and F2 are
( compound(F2) -> %comparing/succeeding/failing as appropriate
compound_compare(F1,F2) %(atom>integer>float>compound)
; % I believe these ifs could definitely be cut down though
( atom(F2) ->
true
;
( float(F2) ->
true
;
( integer(F2) ->
true
)
)
)
)
)
;
( atom(F1) ->
( compound(F2) ->
false
;
( atom(F2) ->
atom_pr(F1,F2)
;
( float(F2) ->
false
;
( integer(F2) ->
false
)
)
)
)
)
;
( float(F1) ->
( compound(F2) ->
false
;
( atom(F2) ->
true
;
( float(F2) ->
number_pr(F1,F2)
;
( integer(F2) ->
true
)
)
)
)
;
fail
)
;
( integer(F1) ->
( compound(F2) ->
false
;
( atom(F2) ->
true
;
( float(F2) ->
false
;
( integer(F2) ->
number_pr(F1,F2)
)
)
)
)
)
.
compound_compare(F1,F2):- %compares compounds (arity first)
functor(F1,N1,A1), %get arity
functor(F2,N2,A2),
( A1<A2 -> %compare arity
true
;
( A1>A2 ->
false
)
;
( A1=A2 -> %if arity the same
F1 =.. L1, %compound -> list
F2 =.. L2,
list_compare(L1,L2) %compare the lists
)
)
.
list_compare([],[]). %base case
list_compare([H|T],[H1|T1]):-
( flat_pr(H,H1) -> %if H#<H1
list_compare(T,T1) %compare Tails
;
false %else false
)
.
atom_pr(L1,L2):-
atom_codes(L1,First), %atom codes for first
atom_codes(L2,Second),%atom codes for second
code_compare(First,Second). %compare the codes, return true or false
number_pr(L1,L2):- %simple number comparison...straight forward
( L1=<L2 ->
true
;
fail
).
code_compare([HF|TF],[HS|TS]):- %just runs through atom codes
( HF=HS ->
code_compare(TF,TS)
;
HF<HS ->
true
;
fail
).
code_compare([],X):-
true.
code_compare([],[]).
I'd love to see ways to improve this though! Cheers

Answer 1

Not sure about BIN-Prolog but in SWI-Prolog atom_codes does the trick:
?- atom_codes('jack\&^',K).
K = [106, 97, 99, 107, 38, 94].
?- atom_codes('17.2345',K).
K = [49, 55, 46, 50, 51, 52, 53].
Update:
If you need to compare terms, 1) freeze them (see further) to make the terms ground and 2) use unif (=..) to transform a term to a list, e.g., f(1,2) becomes [f,1,2], and then for each element: a) if it is an atom or a number, then use atom_codes; b) if it is a term, apply the same procedure recursively.
Freezing ensures that the variables are compared in order of their appearance. By "freezing" I mean the following predicate taken from the classical Sterling and Shapiro's book "The Art of Prolog":
numvars('#VAR'(N),N,N1) :- N1 is N+1.
numvars(Term,N1,N2) :- nonvar(Term), functor(Term,_,N),
numvars(0,N,Term,N1,N2).
numvars(N,N,_,N1,N1).
numvars(I,N,Term,N1,N3) :- I<N, I1 is I+1,
arg(I1,Term,Arg), numvars(Arg,N1,N2),
numvars(I1,N,Term,N2,N3).
frz(A,B) :- frz(A,B,0).
frz(A,B,Min) :- copy_term(A,B), numvars(B,Min,_),!.