Welcome to the prolog wiki!

• :- dynamic(PI) Specifies the predicates indicated by PI are dynamic. ISO
• :- multifile(PI) Specified the predicates indicated by PI may be in multiple files. ISO
• :- discontiguous(PI) Specifies the predicates indicated by PI may be defined by clauses which are not consecutive read-terms. ISO
• :- op(Priority, Specifier, Op) Alters the operator table. ISO
• :- char_conversion(In, Out) Alters the character conversion mapping. ISO
• :- initialization(T) Registers a goal for execution right before exiting Exec() or ExecContext(). ISO
• :- include(F) Loads the content of the file F as if it were there instead of this directive. ISO
• :- ensure_loaded(P) Loads the content of the file P if not loaded. ISO
• :- set_prolog_flag(Flag, Value) Alters the value for the Prolog flag. ISO

• true Always succeeds. ISO
• fail Always fails. ISO
• call(Goal) Calls Goal. ISO
• ! Cut. ISO
• P, Q Conjunction. ISO
• P; Q Disjunction. ISO
• If -> Then If-then. ISO
• If -> Then; Else If-then-else. ISO
• catch(Goal, Catcher, Recovery) Calls Goal. If an exception is raised and unifies with Catcher, calls Recovery. ISO
• throw(Ball) Raises an exception Ball. ISO

• X = Y Unifies X with Y. ISO
• unify_with_occurs_check(X, Y) Unifies X with Y with occurs check. ISO
• X \= Y Succeeds iff X and Y are not unifiable. ISO
• subsumes_term(General, Specific) Succeeds iff there's a substitution θ such that Generalθ = Specificθ and Specificθ = Specific. ISO

• var(X) Succeeds iff X is a variable. ISO
• atom(X) Succeeds iff X is an atom. ISO
• integer(X) Succeeds iff X is an integer. ISO
• float(X) Succeeds iff X is a float. ISO
• atomic(X) Succeeds iff X is neither a variable nor a compound. ISO
• compound(X) Succeeds iff X is a compound. ISO
• nonvar(X) Succeeds iff X is not a variable. ISO
• number(X) Succeeds iff X is either an integer or a float. ISO
• callable(X) Succeeds iff X is either an atom or a compound. ISO
• ground(X) Succeeds iff X is a ground term. ISO
• acyclic_term(X) Succeeds iff X is acyclic. ISO

• X @=< Y Either X == Y or X @< Y. ISO
• X == Y Equivalent to compare(=, X, Y). ISO
• X \== Y Equivalent to \+compare(=, X, Y). ISO
• X @< Y Equivalent to compare(<, X, Y). ISO
• X @> Y Equivalent to compare(>, X, Y). ISO
• X @>= Y Either X == Y or X @> Y. ISO
• compare(Order, X, Y) Compares X and Y and unifies Order with either <, =, or >. ISO
• sort(List, Sorted) Succeeds iff Sorted unifies with a sorted list of List. ISO
• keysort(Pairs, Sorted) Succeeds iff Pairs is a list of Key-Value pairs and Sorted unifies with a permutation of Pairs sorted by Key. ISO

• functor(Term, Name, Arity) Succeeds iff Term ia either a compound term of Name and Arity or an atom of Name and Arity = 0. ISO
• arg(N, Term, Arg) Succeeds iff Arg is the N-th argument of Term. ISO
• Term =.. List Succeeds iff List is a list of the functor and arguments of Term. ISO
• copy_term(Term1, Term2) Creates a copy of Term1 and unifies it with Term2. ISO
• term_variables(Term, Vars) Succeeds iff Vars is a list of variables appear in Term. ISO

• Result is Expression Evaluates Expression and unifies it with Result. ISO
  • Expression is either:

    • integer,

    • float, or

    • evaluable functors

      • X + Y
      • X - Y
      • X * Y
      • X // Y
      • X / Y
      • X rem Y
      • X mod Y
      • -X
      • abs(X)
      • sign(X)
      • float_integer_part(X)
      • float_fractional_part(X)
      • float(X)
      • floor(X)
      • truncate(X)
      • round(X)
      • ceiling(X)
      • +(X)
      • X div Y
      • X ** Y
      • sin(X)
      • cos(X)
      • atan(X)
      • exp(X)
      • log(X)
      • sqrt(X)
      • max(X, Y)
      • min(X, Y)
      • X ^ Y
      • asin(X)
      • acos(X)
      • atan2(X, Y)
      • tan(X)
      • pi
      • X >> Y
      • X << Y
      • X /\ Y
      • X \/ Y
      • \X
      • xor(X, Y)

• succ(X, S) Succeeds iff S is the successor of the non-negative integer X. prologue

• E1 =:= E2 Succeeds iff E1 and E2 are evaluated to EV1 and EV2 respectively and EV1 equals to EV2. ISO
• E1 =\= E2 Succeeds iff E1 and E2 are evaluated to EV1 and EV2 respectively and EV1 does not equal to EV2. ISO
• E1 < E2 Succeeds iff E1 and E2 are evaluated to EV1 and EV2 respectively and EV1 is greater than EV2. ISO
• E1 =< E2 Succeeds iff E1 and E2 are evaluated to EV1 and EV2 respectively and EV1 is greater than or equal to EV2. ISO
• E1 > E2 Succeeds iff E1 and E2 are evaluated to EV1 and EV2 respectively and EV1 is less than EV2. ISO
• E1 >= E2 Succeeds iff E1 and E2 are evaluated to EV1 and EV2 respectively and EV1 is less than or equal to EV2. ISO

• clause(Head, Body) Succeeds iff Head :- Body unifies with a clause in the DB. ISO
• current_predicate(PI) Succeeds iff the predicate indicated by PI is in the DB. ISO

• asserta(Clause) Prepends Clause to the DB. ISO
• assertz(Clause) Appends Clause to the DB. ISO
• retract(Clause) Removes a clause that unifies withClause from the DB. ISO
• abolish(PI) Removes the predicate indicated by PI from the DB. ISO
• retractall(Head) Removes all the clauses which head unifies with Head from the DB. ISO

• findall(Template, Goal, Instances) Succeeds iff Instances unifies with a list of Template for each solution of Goal. ISO
• bagof(Template, Goal, Instances) Succeeds iff Instances unifies with a bag (multiset) of Template for each solution of Goal. ISO
• setof(Template, Goal, Instances) Succeeds iff Instances unifies with a set of Template for each solution of Goal. ISO

• current_input(Stream) Succeeds iff Stream unifies with the current input stream. ISO
• current_output(Stream) Succeeds iff Stream unifies with the current output stream. ISO
• set_input(S_or_a) Sets the current input stream to the stream indicated by S_or_a which is either the stream itself or its alias. ISO
• set_output(S_or_a) Sets the current output stream to the stream indicated by S_or_a which is either the stream itself or its alias. ISO
• open(File, Mode, Stream, Options) Opens the file File in Mode with Options and unifies the stream with Stream. ISO
  • Mode is either: read, write, or append.
  • Options is a list of stream options listed below:
    • type(T) Specifies the type of the stream. T is either text (default) or binary.
    • reposition(Bool) Specifies if the stream can be repositions. Bool is either true or false.
    • alias(A) Specifies the alias for the stream. A is an atom.
    • eof_action(Action) Specifies the action that will be taken when the input stream reached to the end. Action is either:
      • error which throws an exception,
      • eof_code which returns a value indicating the end of stream (default), or
      • reset which resets the stream.
• open(File, Mode, Stream) Equivalent to open(File, Mode, Stream, []). ISO
• close(S_or_a, Options) Closes the stream indicated by S_or_a which is the stream itself or its alias. ISO
  • Options is a list of:
    • force(Bool) Specifies if an exception will be raised when it failed to close the stream. Bool is either false (default) or true.
• close(S_or_a) Equivalent to close(S_or_a, []). ISO
• flush_output(S_or_a) Sends any buffered output to the stream indicated by S_or_a which is either the stream itself or its alias. ISO
• flush_output Equivalent to current_output(S), flush_output(S). ISO
• stream_property(Stream, Property) Succeeds iff the stream Stream has the property Property. ISO
  • Property is either:
    • file_name(F)
    • mode(M)
    • input
    • output
    • alias(A)
    • position(P)
    • end_of_stream(E)
    • eof_action(A)
    • reposition(Bool)
    • type(T)
• at_end_of_stream Equivalent to current_input(S), at_end_of_stream(S). ISO
• at_end_of_stream(S_or_a) Succeeds iff the stream indicated by S_or_a which is either a stream or an alias has the property either end_of_stream(at) or end_of_stream(past). ISO
• set_stream_position(S_or_a, Position) Sets the position of the stream indicated by S_or_a which is either a stream or an alias to the position Position. ISO

• get_char(S_or_a, Char) Succeeds iff Char unifies with the next character from the stream indicated by S_or_a which is either a stream or an alias. ISO
• get_char(Char) Equivalent to current_input(S), get_char(S, Char). ISO
• get_code(S_or_a, Code) Succeeds iff Char unifies with the next code from the stream indicated by S_or_a which is either a stream or an alias. ISO
• get_code(Code) Equivalent to current_input(S), get_code(S, Code). ISO
• peek_char(S_or_a, Char) Similar to get_char(S_or_a, Char) but doesn't consume the character. ISO
• peek_char(Char) Equivalent to current_input(S), peek_char(S, Char). ISO
• peek_code(S_or_a, Code) Similar to get_code(S_or_a, Code) but doesn't consume the code. ISO
• peek_code(Code) Equivalent to current_input(S), peek_code(S, Code). ISO
• put_char(S_or_a, Char) Outputs the character Char to the stream indicated by S_or_a which is either a stream or an alias. ISO
• put_char(Char) Equivalent to current_output(S), put_char(S, Char). ISO
• put_code(S_or_a, Code) Outputs the code Code to the stream indicated by S_or_a which is either a stream or an alias. ISO
• put_code(Code) Equivalent to current_output(S), put_code(S, Code). ISO
• nl(S_or_a) Outputs a newline to the stream indicated by S_or_a which is either a stream or an alias. ISO
• nl Equivalent to current_output(S), nl(S). ISO

• get_byte(S_or_a, Byte) Succeeds iff Byte unifies with the next byte from the stream indicated by S_or_a which is a stream or an alias. ISO
• get_byte(Byte) Equivalent to current_input(S), get_byte(S, Byte). ISO
• peek_byte(S_or_a, Byte) Similar to get_byte(S_or_a, Byte) but doesn't consume the byte. ISO
• peek_byte(Byte) Equivalent to current_input(S), peek_byte(S, Byte). ISO
• put_byte(S_or_a, Byte) Outputs the byte Byte to the stream indicated by S_or_a which is either a stream or an alias. ISO
• put_byte(Byte) Equivalent to current_output(S), put_byte(S, Byte). ISO

• read_term(S_or_a, Term, Options) Succeeds iff Term unifies with the next term from the stream indicated by S_or_a which is a stream or an alias. ISO
  • Options is a list of read options listed below:
    • variables(Vars) the list of variables appeared in Term
    • variable_names(VN_list) the list of A = V where A is an atom which name is the string representation of V and V is a variable appeared in Term
    • singletons(VN_list) similar to variable_names(VN_list) but those of variables that appeared once.
• read_term(Term, Options) Equivalent to current_input(S), read_term(S, Term, Options). ISO
• read(S_or_a, Term) Equivalent to read_term(S_or_a, Term, []). ISO
• read(Term) Equivalent to current_input(S), read(S, Term). ISO
• write_term(S_or_a, Term, Options) Outputs Term to the stream indicated by S_or_a which is either a stream or an alias. ISO
  • Options is a list of write options listed below:
    • quoted(Bool) Bool is either true or false. If true, atoms and functors will be quoted as needed.
    • ignore_ops(Bool) Bool is either true or false. If true, operators will be written in functional notation.
    • variable_names(VN_list) VN_list is a proper list which element is a form of A = V where A is an atom and V is a variable. Each occurrence of V will be replaced by the leftmost and unquoted A.
    • numbervars(Bool) Bool is either true or false. If true, terms '$VAR'(0), '$VAR'(1), ... will be written as A, B, ...
• write_term(Term, Options) Equivalent to current_output(S), write_term(S, Term, Options). ISO
• write(S_or_a, Term) Equivalent to write_term(S_or_a, Term, [numbervars(true)]). ISO
• write(Term) Equivalent to current_output(S), write(S, Term). ISO
• writeq(S_or_a, Term) Equivalent to write_temr(S_or_a, Term, [quoted(true), numbervars(true)]). ISO
• writeq(Term) Equivalent to current_output(S), writeq(S, Term). ISO
• write_canonical(S_or_a, Term) Equivalent to write_term(S_or_a, Term, [quoted(true), ignore_ops(true)]). ISO
• write_canonical(Term) Equivalent to current_output(S), write_canonical(S, Term). ISO
• op(Priority, Specifier, Operator) Alters the operator table. ISO
• current_op(Priority, Specifier, Operator) Succeeds iff the operator indicated by Priority, Specifier, Operator is in the operator table. ISO
• char_conversion(In, Out) Alters the character conversion mapping. ISO
• current_char_conversion(In, Out) Succeeds iff the character conversion from In to Out is in the conversion mapping. ISO

• \+Goal Succeeds iff call(Goal) fails. ISO
• once(Goal) Calls Goal but never redoes. ISO
• repeat Repeats the following code until it succeeds. ISO
• call(Closure, Arg1, ..., ArgN) N = 1..7. Succeeds iff call(Goal) where Goal is Closure with additional arguments Arg1, ..., ArgN. ISO
• false Equivalent to fail. ISO
• between(Lower, Upper, X) Succeeds iff Lower <= X <= Upper. prologue

• atom_length(Atom, Length) Succeeds iff Length is the number of runes in Atom. ISO
• atom_concat(Atom1, Atom2, Atom3) Succeeds iff Atom3 is a concatenation of Atom1 and Atom2. ISO
• sub_atom(Atom, Before, Length, After, SubAtom) Succeeds iff SubAtom is a sub atom of Atom where Before is the number of runes before SubAtom, Length is the length of SubAtom, and After is the number of runes after SubAtom. ISO
• atom_chars(Atom, List) Succeeds iff List is the list of single-rune atoms that Atom consists of. ISO
• atom_codes(Atom, List) Succeeds iff List is the list of runes that Atom consists of. ISO
• char_code(Char, Code) Succeeds iff Char is a single-rune atom which rune is Code. ISO
• number_chars(Number, List) Succeeds iff List is the list of single-rune atoms that represents Number. ISO
• number_codes(Number, List) Succeeds iff List is the list of runes that represents Number. ISO

• set_prolog_flag(Flag, Value) Sets the Prolog flag Flag to Value. ISO
  • Flag is either:
    • char_conversion Value is either on or off (default).
    • debug Value is either on or off (default).
    • unknown Value is either error (default), fail, or warning.
    • double_quotes Value is either chars (default), codes, or atom.
• current_prolog_flag(Flag, Value) Succeeds iff Value is the current value for the Prolog flag Flag. ISO
  • Flag is either:
    • bounded Value is always true.
    • max_integer Value is always 9223372036854775807.
    • min_integer Value is always -9223372036854775808.
    • integer_rounding_function Value is always toward_zero.
    • char_conversion Value is either on or off (default).
    • debug Value is either on or off (default).
    • max_arity Value is always unbounded.
    • unknown Value is either error (default), fail, or warning.
    • double_quotes Value is either chars (default), codes, or atom.
• halt(X) Exits the host program with the status code of X. ISO
• halt Equivalent to halt(0). ISO

• expand_term(In, Out) Succeeds iff Out is an expansion of the term In.
• phrase(Phrase, List, Remainder) Succeeds iff the different list List-Remainder satisfies the grammar rule Phrase.
• phrase(Phrase, List) Equivalent to phrase(Phrase, List, []).

• member(X, L) Succeeds iff X is a member of the list L. prologue
• append(Xs, Ys, Zs) Succeeds iff Zs is the concatenation of Xs and Ys. prologue
• length(List, Length) Succeeds iff Length is the length of List. prologue
• select(X, Xs, Ys) Succeeds iff X is an element of Xs and Ys is Xs with one occurence of X removed. prologue
• maplist(Goal, List1, ..., Listn) n = 1..7. Succeeds iff List1, ..., Listn are the list of the same length and call(Goal, List1_i, ..., Listn_i) succeeds for all the i-th elements of List1, ..., Listn. prologue
• nth0(N, List, Elem) Succeeds iff Elem is the N-th element of List counting from 0.
• nth1(N, List, Elem) Succeeds iff Elem is the N-th element of List counting from 1.

• consult(File) Loads Prolog program files indicated by File. File is either an atom or a list of atoms. An atom abc indicates a Prolog program file ./abc or ./abc.pl.
• [File|Files] Equivalent to consult([File|Files]).