Higher-order predicates

Author(s): Daniel Cabeza, Manuel Carro, Edison Mera.

This library implements a few basic higher-order predicates. These add functionality to the basic higher-order functionality of Ciao. Examples of the latter are:

Using pred(1):

  list(L, functor(_,2))
  list(L, >(0))

Using pred(2):


Usage and interface

Documentation on exports

PREDICATE

Meta-predicate with arguments: map(?,(pred 2),?).
General properties: map(A,B,C)
  • If the following properties should hold at call time:
    (term_basic:= /2)term_basic:A=[1,3,2]
    (term_basic:= /2)term_basic:B=arg(f(a,b,c,d)) then the following properties should hold upon exit:
    (term_basic:= /2)term_basic:C=[a,c,b] then the following properties should hold globally:
    (native_props:not_fails/1)All the calls of the form map(A,B,C) do not fail.
    (native_props:is_det/1)All calls of the form map(A,B,C) are deterministic.
map(A,B,C)
  • If the following properties should hold at call time:
    (term_basic:= /2)term_basic:A=[1,3,2]
    (term_basic:= /2)term_basic:B=nth([a,b,c,d]) then the following properties should hold upon exit:
    (term_basic:= /2)term_basic:C=[a,c,b] then the following properties should hold globally:
    (native_props:not_fails/1)All the calls of the form map(A,B,C) do not fail.
    (native_props:is_det/1)All calls of the form map(A,B,C) are deterministic.
map(A,B,C)
  • If the following properties should hold at call time:
    (term_basic:= /2)term_basic:A=[[68],[67]]
    (term_basic:= /2)term_basic:B=append([46]) then the following properties should hold upon exit:
    (term_basic:= /2)term_basic:C=[[68,46],[67,46]] then the following properties should hold globally:
    (native_props:not_fails/1)All the calls of the form map(A,B,C) do not fail.
    (native_props:is_det/1)All calls of the form map(A,B,C) are deterministic.

Usage: map(LList,Op,RList)

  • Description: Examples of use:
      map([1,3,2], arg(f(a,b,c,d)), [a,c,b]) or
      map([1,3,2], nth([a,b,c,d]), [a,c,b])
      map(["D","C"], append("."), ["D.","C."])
    

PREDICATE

Meta-predicate with arguments: map(?,(pred 3),?,?).
General properties: map(A,B,C,D)
  • If the following properties should hold at call time:
    (term_basic:= /2)term_basic:A=[1,3,2]
    (term_basic:= /2)term_basic:B=((L,[E|T],T):-arg(L,f(a,b,c,d),E))
    (term_basic:= /2)term_basic:D=[x,y] then the following properties should hold upon exit:
    (term_basic:= /2)term_basic:C=[a,c,b,x,y] then the following properties should hold globally:
    (native_props:not_fails/1)All the calls of the form map(A,B,C,D) do not fail.
    (native_props:is_det/1)All calls of the form map(A,B,C,D) are deterministic.

Usage: map(LList,Op,RList,Tail)

  • Description: DCG version of map.

PREDICATE

Meta-predicate with arguments: foldl(?,?,(pred 3),?).

Usage: foldl(List,Seed,Op,Result)

  • Description: Example of use:
    ?- foldl(["daniel","cabeza","gras"], "", 
             (”(X,Y,Z) :- append(X, " "||Y, Z)), R).
    
    R = "daniel cabeza gras " ? 
    

PREDICATE

Meta-predicate with arguments: minimum(?,(pred 2),?).

Usage: minimum(List,SmallerThan,Minimum)

  • Description: Minimum is the smaller in the nonempty list List according to the relation SmallerThan: SmallerThan(X, Y) succeeds iff X is smaller than Y.
  • The following properties should hold at call time:
    (term_typing:nonvar/1)SmallerThan is currently a term which is not a free variable.
    (basic_props:list/1)List is a list.
    (basic_props:callable/1)SmallerThan is a term which represents a goal, i.e., an atom or a structure.
    (basic_props:term/1)Minimum is any term.

PREDICATE

Meta-predicate with arguments: split(?,(pred 1),?,?).
General properties: split(A,B,C,D)
  • If the following properties should hold at call time:
    (term_basic:= /2)term_basic:A=[1,2,3,4,5,6]
    (term_basic:= /2)term_basic:B= >(4) then the following properties should hold upon exit:
    (term_basic:= /2)term_basic:C=[5,6]
    (term_basic:= /2)term_basic:D=[1,2,3,4] then the following properties should hold globally:
    (native_props:not_fails/1)All the calls of the form split(A,B,C,D) do not fail.

Usage: split(List,Condition,Left,Right)

  • Description: Divides List in two list, where Left contains the elements for which the call to Condition succeeds, and Right the remaining elements.
  • The following properties should hold at call time:
    (term_typing:nonvar/1)List is currently a term which is not a free variable.
    (term_typing:nonvar/1)Condition is currently a term which is not a free variable.
    (basic_props:list/1)List is a list.
    (basic_props:callable/1)Condition is a term which represents a goal, i.e., an atom or a structure.
    (basic_props:term/1)Left is any term.
    (basic_props:term/1)Right is any term.
  • The following properties should hold upon exit:
    (basic_props:list/1)List is a list.
    (basic_props:callable/1)Condition is a term which represents a goal, i.e., an atom or a structure.
    (basic_props:list/1)Left is a list.
    (basic_props:list/1)Right is a list.