% File : APPLIC.PL % Author : Lawrence Byrd + Richard A. O'Keefe % Updated: 4 August 1984 and Ken Johnson 11-8-87 % Purpose: Various "function" application routines based on apply/2. % Needs : append/3 from listut.pl:-public apply/2, callable/1, checkand/2, checklist/2, convlist/3, exclude/3, mapand/3, maplist/3, some/2, somechk/2, sublist/3.:-mode apply(+, +), callable(?), checkand(+, +), checklist(+, +), convlist(+, +, ?), exclude(+, +, ?), mapand(+, ?, ?), maplist(+, ?, ?), some(+, ?), somechk(+, +), sublist(+, +, ?). % Operator declaration ued below:-op(920,xfy,&). % Used for conjunction % apply(Pred, Args) % is the key to this whole module. It is basically a variant of call/1 % (see the Dec-10 Prolog V3.43 manual) where some of the arguments may % be already in the Pred, and the rest are passed in the list of Args. % Thus apply(foo, [X,Y]) is the same as call(foo(X,Y)), % and apply(foo(X), [Y]) is also the same as call(foo(X,Y)). % BEWARE: any goal given to apply is handed off to call/1, which is the % Prolog *interpreter*, so if you want to apply compiled predicates you % MUST have :- public declarations for them. The ability to pass goals % around with some of their (initial) arguments already filled in is % what makes apply/2 so useful. Don't bother compiling anything that % uses apply heavily, the compiler won't be able to help much. LISP % has the same problem. Later Prolog systems may have a simpler link % between compiled and interpreted code, or may fuse compilation and % interpretation, so apply/2 may come back into its own. At the moment, % apply and the routines based on it are not well thought of. apply(Pred, Args):-( atom(Pred), Goal =.. [Pred|Args] ; % compound(Pred) Pred =.. OldList, append(OldList, Args, NewList), Goal =.. NewList ), !, call(Goal). % callable(Term) % succeeds when Term is something that it would make sense to give to % call/1 or apply/2. That is, Term must be an atom or a compound term; % variables and integers are out. callable(Term):-nonvar(Term), functor(Term, FunctionSymbol, _), atom(FunctionSymbol). % checkand(Pred, Conjunction) % succeeds when Pred(Conjunct) succeeds for every Conjunct in the % Conjunction. All the *and predicates in this module assume that % a&b&c&d is parsed as a&(b&(c&d)), and that the "null" conjunction % is 'true'. It is possible for this predicate, and most of the % others, to backtrack and try alternative solutions. If you do not % want that to happen, copying one of these predicates and putting a % cut in the suggested place will produce a tail-recursive version. % The cuts in the *and predicates are there because "non-and" is % defined by exclusion; they cannot be assigned types. checkand(_, true):-!. checkand(Pred, A&B):-!, apply(Pred, [A]), checkand(Pred, B). checkand(Pred, A):-apply(Pred, [A]). % checklist(Pred, List) % suceeds when Pred(Elem) succeeds for each Elem in the List. % In InterLisp, this is EVERY. It is also MAPC. checklist(_, []). checklist(Pred, [Head|Tail]):-apply(Pred, [Head]), checklist(Pred, Tail). % mapand(Rewrite, OldConj, NewConj) % succeeds when Rewrite is able to rewrite each conjunct of OldConj, % and combines the results into NewConj. mapand(_, true, true):-!. mapand(Pred, Old&Olds, New&News):-!, apply(Pred, [Old,New]), mapand(Pred, Olds, News). mapand(Pred, Old, New):-apply(Pred, [Old,New]). % maplist(Pred, OldList, NewList) % succeeds when Pred(Old,New) succeeds for each corresponding % Old in OldList, New in NewList. In InterLisp, this is MAPCAR. % It is also MAP2C. Isn't bidirectionality wonderful? maplist(_, [], []). maplist(Pred, [Old|Olds], [New|News]):-apply(Pred, [Old,New]), maplist(Pred, Olds, News). % convlist(Rewrite, OldList, NewList) % is a sort of hybrid of maplist/3 and sublist/3. % Each element of NewList is the image under Rewrite of some % element of OldList, and order is preserved, but elements of % OldList on which Rewrite is undefined (fails) are not represented. % Thus if foo(X,Y) :- integer(X), Y is X+1. % then convlist(foo, [1,a,0,joe(99),101], [2,1,102]). convlist(_, [], []). convlist(Pred, [Old|Olds], NewList):-apply(Pred, [Old,New]), !, NewList = [New|News], convlist(Pred, Olds, News). convlist(Pred, [_|Olds], News):-convlist(Pred, Olds, News). % exclude(Pred, List, SubList) % succeeds when SubList is the SubList of List containing all the % elements for which Pred(Elem) is *false*. That is, it removes % all the elements satisfying Pred. Efficiency would be somewhat % improved if the List argument came first, but this argument order % was copied from the older sublist/3 predicate, and let's face it, % apply/2 isn't stupendously efficient itself. exclude(_, [], []). exclude(Pred, [Head|List], SubList):-apply(Pred, [Head]), !, exclude(Pred, List, SubList). exclude(Pred, [Head|List], [Head|SubList]):-exclude(Pred, List, SubList). % some(Pred, List) % succeeds when Pred(Elem) succeeds for some Elem in List. It will % try all ways of proving Pred for each Elem, and will try each Elem % in the List. somechk/2 is to some/2 as memberchk/2 is to member/2; % you are more likely to want somechk with its single solution. % In InterLisp this is SOME. some(Pred, [Head|_]):-apply(Pred, [Head]). some(Pred, [_|Tail]):-some(Pred, Tail). somechk(Pred, [Head|_]):-apply(Pred, [Head]), !. somechk(Pred, [_|Tail]):-somechk(Pred, Tail). % sublist(Pred, List, SubList) % succeeds when SubList is the sub-sequence of the List containing all % the Elems of List for which Pred(Elem) succeeds. sublist(_, [], []). sublist(Pred, [Head|List], SubList):-apply(Pred, [Head]), !, SubList = [Head|Rest], sublist(Pred, List, Rest). sublist(Pred, [_|List], SubList):-sublist(Pred, List, SubList).