[Top][All Lists]

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Re: Some advice on a "simple" thing...

From: Lindsey Spratt
Subject: Re: Some advice on a "simple" thing...
Date: Wed, 09 Apr 2014 15:17:54 -0400

One of the cool things about Edinborough syntax Prolog is the use of 'operators' - they are just syntactic sugar for function terms. (Cambridge syntax prolog looks like Lisp - I don't think any implementations still exist that use this syntax.)
foo(a - b, c + d, e = f) is semantically equivalent to
foo(-(a, b), +(c, d), =(e,f))
'-(a,b)' does not have a particular interpretation in Prolog, it's meaning is determined (in this case) by what 'foo' does with it and what other clauses referencing 'foo' do with it.

Even the 'neck' operator and 'and' operators of clauses are just syntactic sugar:

foo(X) :- bar(X), baz(X).
is equivalent to
:-(foo(X), ,(bar(X), baz(X))).

(This shows the unfortunate overloading of the comma token as both an operator used for 'and' in clauses and as a term separator.)

This is how arithmetic operations are defined using the 'is' builtin. The 'is' builtin gets a nested function term that uses functors that it interprets as arithmetic operations:
X is 3 + 4 *  2 * 7.
is the same as
X is +(3, *(4, *(2, 7))).
The 'is' builtin applies common arithmetic processing to this nested structure to unify a numeric value 59 with X.

Outside of 'is' and some special comparison builtins, the functors that look like arithmetic operators have no particular semantics:
Y = 3 + 4 * 2 * 7,
(Z + W) = Y.
binds Z to '3' and W to '4 * 2 * 7'. There is no arithmetic processing done in this case.

Programmers are free to use whatever operator makes sense in the context of a particular program to identify pairs of values.

And if none of the pre-defined operators ('-', '+', '=', etc) are appropriate, you can always define your own:
:- op(&=&>, xfy, 500).
:- op(<++, yfx, 250).
foo(a &=&> b, c <++ d, e = f).
is the same as
foo(&=&>(a, b), <++(c, d), =(e, f)).

This is great fun for designing domain-specific languages in Prolog.

Lindsey Spratt

On Apr 9, 2014, at 9:07 AM, Sean Charles <address@hidden> wrote:

Some clarificaation…. a while back you helped me write a testing framework…here is the code:
get_all_tests(Tests) :-
setof(Line-Name, get_one_test(Name, Line), Tests).

get_one_test(Name, Line) :-
atom_concat('test_', _, Name),
predicate_property(Name, prolog_line(Line)).
It uses ‘pairs’ as I understand them, using the ‘-‘ to combine the key and value, so in your response, what is ‘=‘ doing in this context in the list of flags????

Just when I thouthgh I was beginning to understand! LMAO

Thanks once again,


On 9 Apr 2014, at 09:18, Daniel Diaz <address@hidden> wrote:

Hello Sean,

you can do this with your own loop or use findall like this:

flag(public, 0x0001).
flag(final, 0x0010).
flag(super, 0x0020).
flag(interface, 0x0200).
flag(abstract, 0x0400).
flag(synthetic, 0x1000).
flag(annotation, 0x2000).
flag(enum, 0x4000).

get_java_flags(Value, Flags) :-
    findall(Name, has_flag(Value, Name), Flags).

has_flag(Value, Name) :-
    flag(Name, Mask),
    Value /\ Mask =\= 0.

then call it with:

| ?- get_java_flags(0x421, Flags).

Flags = [public,super,abstract]

I have detailed a bit to be more comprehensive: the has_flag/2 predicate could be inlined inside the findall surrounding with ().

If you prefer to have the flags as a parameter pass them as a list and use member to handle backtracking (done by get_flags/3 here):

get_java_flags(Value, Flags) :-
    FlagNames = [public = 0x0001,
                final = 0x0010,
                super = 0x0020,
                interface = 0x0200,
                abstract = 0x0400,
                synthetic = 0x1000,
                annotation = 0x2000,
                enum = 0x4000],
    get_flags(FlagNames, Value, Flags).

get_flags(FlagNames, Value, Flags) :-
    findall(Name, has_flag(FlagNames, Value, Name), Flags).

has_flag(NameFlags, Value, Name) :-
    member(Name=Mask, NameFlags),
    Value /\ Mask =\= 0.


Le 09/04/2014 01:02, Sean Charles a écrit :
Hello list,

I have almost completed a predicate called ‘jread’ which parses a Java .class file into a term that will allow me to create a database of all of the methods, fields, superclass and interfaces for that class and ultimately create a database for a complete “android.jar” file of any required API level.

I am, for educational purposes and my own learning, trying to build a system like Hoogle/Hayoo for Android. I do a lot of Android and I wanted to create a sytem I can wire into Emacs/IntelliJ or anything for that matter, a simple HTTP server that can supply a list of methods that have a certain type signature using a si mple query language.  Searching by types it very very useful when using Haskell and I wanted to improve my Prolog so I figured why not do something like that in GNU Prolog? I have already started a simple HTTP library in pure GNU Prolog as well but this comes first now.

Progress so far is good…if I run it like this from a folder containing the unpacked android.jar file...

| ?- jread('javax/net/SocketFactory.class',X).

X = javaclass(super('java/lang/Object'),class('javax/net/SocketFactory'),implements([]),
returns('(Ljava/net/InetAddress;ILjava/net/InetAddress;I)Ljava/net/Socket;'),[attr(18,[0,1,0,19])])])) ? 

The place I am at now is decoding the bit flags for the class (and eventually the methods etc) into a term.

A typical value would be “1057” decimal, 0x421, this contains the flags:

ACC_PUBLIC 0x0001 Declared public; may be accessed from outside its package.
ACC_FINAL 0x0010 Declared final; no subclasses allowed.
ACC_SUPER 0x0020 Treat superclass methods specially when invoked by the invokespecial instruction.
ACC_INTERFACE 0x0200 Is an interface, not a class.
ACC_ABSTRACT 0x0400 Declared abstract; must not be instantiated.
ACC_SYNTHETIC 0x1000 Declared synthetic; not present in the source code.
ACC_ANNOTATION 0x2000 Declared as an annotation type.
ACC_ENUM 0x4000 Declared as an enum type.

So you can see that 0x421 means “ACC_PUBLIC, ACC_SUPER and ACC_ABSTRACT”. I would like to produce a term something like this:


It’s not that I don’t know how to do it or that I can’t do it but I am not sure what is the *most elegant* way to do it in Prolog! Heaven knows I have written bit shifting loops to test for flags in a dozen languages but not in Prolog.

So, there’s the challenge, what is the most elegant way to turn a list of bits into a list of atom terms. Ideally I would make the list of atoms a parameter so that I can reuse it for the other flag based values.

Consider the gauntlet thrown!   In the meantime I am continuing to research the possibilities for myself. I will of course put it all on GitHub along with my Redis client. I may even create a Redis database with the information!


Ce message a été vérifié par MailScanner pour des virus ou des polluriels et rien de suspect n'a été trouvé.

Users-prolog mailing list

reply via email to

[Prev in Thread] Current Thread [Next in Thread]