Did you know ... Search Documentation:
Predicate is/2
Availability:built-in
[ISO]-Number is +Expr
True when Number is the value to which Expr evaluates. Typically, is/2 should be used with unbound left operand. If equality is to be tested, =:=/2 should be used. For example:

?- 1 is sin(pi/2). Fails! sin(pi/2) evaluates to the float 1.0, which does not unify with the integer 1.
?- 1 =:= sin(pi/2). Succeeds as expected.

Examples

Normally used to update the value associated with a key. For example, if the value is a count that must be incremented, do

inc_count(Key, A0, A) :-
     get_assoc(Key, A0, C0, A, C), !,
     C is C0+1.
inc_count(Key, A0, A) :-
     put_assoc(Key, A0, 1, A).
Examples for scanl/N
?- scanl(plus, [1,2,3,4,5], 0, Sums).
Sums = [0, 1, 3, 6, 10, 15].

When considering the lists columns of a table, scanl/5 combines the accumulator with each row to produce the next value in the result list. We illustrate this using plus/4 which adds the accumulator with the values from the row to produce the next accumulator. We use trace/2 to illustrate how the values are combined.

plus(A,B,C,Result) :-
    Result is A+B+C.
?- trace(plus/4, exit).
%         plus/4: [exit]
?- scanl(plus, [1,2,3,4,5], [10,20,30,40,50], 0, Sums).
 T Exit: plus(1, 10, 0, 11)
 T Exit: plus(2, 20, 11, 33)
 T Exit: plus(3, 30, 33, 66)
 T Exit: plus(4, 40, 66, 110)
 T Exit: plus(5, 50, 110, 165)
Sums = [0, 11, 33, 66, 110, 165].
Tags are associated to your profile if you are logged in|Report abuse
Tags:
  • doc-needs-help
LogicalCaptain said (2020-07-14T04:55:52):0 upvotes 0 0 downvotes
Picture of user LogicalCaptain.

is/2 is arithmetic function evaluation from the original Prolog

But in SWI-Prolog you can have function evaluation also for other uses using dicts. Predicates can be associated to dicts, and they behave like function calls. This gives us function calls beyond the arithmetic evaluation of is/2. For example, for strings you can do things like this:

Define a module called string to associate functions to dicts with tag string (there is a problem in that modules are not hierarchical so you may end up with a name clash in the unique global module space, but, let's disregard this for now):

:- module(string,[]).

% This is a predicate format/3 written as a function format/2 (maybe there
% needs to be a new descriptor syntax: format///2 ?) taking a dict tagged as
% "string" and two arguments which evaluates to the value of variable Text.

S.format(Msg,Args) := Text :- with_output_to(string(Text),format(Msg,Args)).

Once the above module has been loaded, you can do things like these, which behave like a Java "static" method call (you can move args into the dict too of course):

?- X=string{}.format("Hello, ~q\n",["World"]).
X = "Hello, \"World\"\n".
?- debug(foo),debug(foo,string{}.format("Hello, ~q\n",["World"]),[]).
% Hello, "World"