Now this is pretty cool in that it allows bidirectionality, or running predicates “in reverse”. To generate lists of length 3, you can write
length(L, 3). But it also means that if you want to get the length a list plus one, you can’t do that in one expression, you have to writelength(List, Out), X is Out+1.
i quoted this text above from the Article. ( I am probably not aware of many possibilities of swi-prolog because I only work with it a few years )
but the answer to the above maybe only a question of taste.
concerning this: length(List, Out), X is Out+1`.
in the Old V-prolog the length predicate syntax was like this : length( List , Out )
in the new V-prolog syntax the predicate is like this: Out = length( List )
( old syntax is not allowed anymore )
because of this new syntax you can now write : X is length( List ) + 1.
because of this possible nesting you get shorter code. but in my opinion if you continue deeper nesting in the same fashion the whole becomes unreadable
( not easy to read ) because you mix procedural syntax to much inside logic syntax. In the new syntax you can ofcourse still write this:
Out = length( List ) , X is Out + 1 .
for me as coming from V-prolog it was very new that in swi-prolog you can basically call any predicate inside the arguments of another predicate,
( like in for example setup_call_cleanup( ,,_) ) .
In the recent past i had to read swi-prolog code created by another programmer where everything was nested like this almost up to 5 ,6 , levels deep, and in my opinion this code was completely impossible to read, and to modify and to use and to change.
as last point i post here an image of a complete other (new) Language called metta ( which i think still dont understand because i cant understand certain constructs, let and let_star ) but this language is actually Prolog in a LISP -(S-expression ) syntax, and they also want bidirectional variabel instantiation.
Everything in this language is nested nested nested to unlimited levels, and I
personally find that very hard to read. I prefer prolog predicates even if that takes (a lot) more code. Also the swi-prolog construct if then else ( with → and ; ) i find very odd , though i can get used to it .
In this Image of this metta language They introduced the let and let_star statement which makes the total of code impossible to read, because it is
possibly a consequence of ( again ) inserting Procedural thinking Inside logical thinking which is just never desirable
