perform goal expansion in call/N (#788, #797)

src/clause_types.rs

@@ -863,7 +863,7 @@ impl ClauseType {
     pub fn name(&self) -> ClauseName {
         match self {
             &ClauseType::BuiltIn(ref built_in) => built_in.name(),
-            &ClauseType::CallN => clause_name!("call"),
+            &ClauseType::CallN => clause_name!("$call"),
             &ClauseType::Inlined(ref inlined) => clause_name!(inlined.name()),
             &ClauseType::Op(ref name, ..) => name.clone(),
             &ClauseType::Named(ref name, ..) => name.clone(),
@@ -882,7 +882,7 @@ impl ClauseType {
                     .unwrap_or_else(|| {
                         if let Some(spec) = spec {
                             ClauseType::Op(name, spec, CodeIndex::default())
-                        } else if name.as_str() == "call" {
+                        } else if name.as_str() == "$call" {
                             ClauseType::CallN
                         } else {
                             ClauseType::Named(name, arity, CodeIndex::default())

src/lib/builtins.pl

@@ -4,9 +4,10 @@
                      abolish/1, asserta/1, assertz/1,
                      at_end_of_stream/0, at_end_of_stream/1,
                      atom_chars/2, atom_codes/2, atom_concat/3,
-                     atom_length/2, bagof/3, catch/3, char_code/2,
+                     atom_length/2, bagof/3, call/1, call/2, call/3,
-                     clause/2, close/1, close/2, current_input/1,
+                     call/4, call/5, call/6, call/7, call/8, call/9,
-                     current_output/1, current_op/3,
+                     catch/3, char_code/2, clause/2, close/1, close/2,
+                     current_input/1, current_output/1, current_op/3,
                      current_predicate/1, current_prolog_flag/2,
                      fail/0, false/0, findall/3, findall/4,
                      flush_output/0, flush_output/1, get_byte/1,
@@ -38,6 +39,30 @@ true.
 
 false :- '$fail'.
 
+
+% These are stub versions of call/{1-9} defined for bootstrapping.
+% Once Scryer is bootstrapped, each is replaced with a version that
+% uses expand_goal to pass the expanded goal along to '$call'.
+
+call(G) :- '$call'(G).
+
+call(G, A) :- '$call'(G, A).
+
+call(G, A, B) :- '$call'(G, A, B).
+
+call(G, A, B, C) :- '$call'(G, A, B, C).
+
+call(G, A, B, C, D) :- '$call'(G, A, B, C, D).
+
+call(G, A, B, C, D, E) :- '$call'(G, A, B, C, D, E).
+
+call(G, A, B, C, D, E, F) :- '$call'(G, A, B, C, D, E, F).
+
+call(G, A, B, C, D, E, F, G) :- '$call'(G, A, B, C, D, E, F, G).
+
+call(G, A, B, C, D, E, F, G, H) :- '$call'(G, A, B, C, D, E, F, G, H).
+
+
 Module : Predicate :-
     ( atom(Module) ->
       '$module_call'(Module, Predicate)

src/lib/ops_and_meta_predicates.pl

@@ -125,3 +125,5 @@
 :- meta_predicate call(61, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?).
 :- meta_predicate call(62, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?).
 :- meta_predicate call(63, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?).
+:- meta_predicate call(64, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?).
+:- meta_predicate call(65, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?).

src/loader.pl

@@ -18,14 +18,14 @@
 
 
 '$print_message_and_fail'(Error, Culprit) :-
-%    writeq(error(Error, Culprit)),
+    %    writeq(error(Error, Culprit)),
-%    nl,
+    %    nl,
     '$fail'.
 
 expand_term(Term, ExpandedTerm) :-
-    (  catch(user:term_expansion(Term, ExpandedTerm0),
+    (  catch('$call'(user:term_expansion(Term, ExpandedTerm0)),
              E,
-             loader:'$print_message_and_fail'(E, user:term_expansion)) ->
+             '$call'(loader:'$print_message_and_fail'(E, user:term_expansion))) ->
        (  var(ExpandedTerm0) ->
           error:instantiation_error(term_expansion/2)
        ;  ExpandedTerm0 = [_|_] ->
@@ -50,9 +50,9 @@ term_expansion_list([Term|Terms], ExpandedTermsHead, ExpandedTermsTail) :-
 
 
 goal_expansion(Goal, Module, ExpandedGoal) :-
-    (  catch(Module:goal_expansion(Goal, ExpandedGoal0),
+    (  catch('$call'(Module:goal_expansion(Goal, ExpandedGoal0)),
              E,
-             loader:'$print_message_and_fail'(E, Module:goal_expansion)) ->
+             '$call'(loader:'$print_message_and_fail'(E, Module:goal_expansion))) ->
        (  var(ExpandedGoal0) ->
           error:instantiation_error(goal_expansion/2)
        ;  goal_expansion(ExpandedGoal0, Module, ExpandedGoal)
@@ -195,8 +195,7 @@ compile_dispatch_or_clause(Term, Evacuable, VNs) :-
 compile_dispatch((:- Declaration), Evacuable, _VNs) :-
     (  var(Declaration) ->
        instantiation_error(load/1)
-    ;
+    ;  compile_declaration(Declaration, Evacuable)
-       compile_declaration(Declaration, Evacuable)
     ).
 compile_dispatch(term_expansion(Term, Terms), Evacuable, VNs) :-
     '$add_term_expansion_clause'(term_expansion(Term, Terms), Evacuable, VNs).
@@ -345,6 +344,12 @@ extract_predicate_property(Property, PropertyType) :-
     ;  functor(Property, PropertyType, _)
     ).
 
+load_context(Module) :-
+    (  prolog_load_context(module, Module) ->
+       true
+    ;  Module = user
+    ).
+
 predicate_property(Callable, Property) :-
     (  var(Callable) ->
        instantiation_error(load/1)
@@ -355,10 +360,7 @@ predicate_property(Callable, Property) :-
        check_predicate_property(PropertyType, Module, Name, Arity, Property)
     ;  functor(Callable, Name, Arity),
        extract_predicate_property(Property, PropertyType),
-       (  prolog_load_context(module, Module) ->
+       load_context(Module),
-          true
-       ;  Module = user
-       ),
        check_predicate_property(PropertyType, Module, Name, Arity, Property)
     ).
 
@@ -498,3 +500,710 @@ thread_goals(Goals0, Goals1, Hole, Functor) :-
        ;  Goals1 =.. [Functor, Goals0, Hole]
        )
     ).
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%
+% call/{1-64} with dynamic goal expansion.
+%
+% The program used to generate the call/N predicates:
+%
+%
+% :- use_module(library(between)).
+% :- use_module(library(error)).
+% :- use_module(library(lists)).
+% :- use_module(library(format)).
+%
+% call_form_generator(N) :-
+%     length(Args, N),
+%     CallHead =.. [call, G | Args],
+%     N1 is N + 1,
+%     Form = (CallHead :- (  var(G) ->
+%                            instantiation_error(call/N1)
+%                         ;  call_clause(G, Args, N1, G0) ->
+%                            '$call'(G0)
+%                         ;  type_error(callable, G, call/N1)
+%                         )),
+%     portray_clause(Form).
+%
+% generate_call_forms :-
+%     between(1, 64, N),
+%     call_form_generator(N),
+%     nl,
+%     false.
+%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+
+call_clause(M:G1, G0) :-
+    functor(G1, F, _),
+    atom(F),
+    atom(M),
+    F \== [],
+    !,
+    expand_goal(M:G1, M, G0).
+
+% The '$call' functor is an escape hatch from goal expansion. So far,
+% it is used only to avoid infinite recursion into expand_goal/3.
+
+call_clause('$call'(G), G0) :-
+    (  var(G),
+       instantiation_error(call/1)
+    ;  G = M:G1,
+       !,
+       functor(G1, F, _),
+       atom(F),
+       atom(M),
+       F \== [],
+       G0 = M:G1
+    ;  !,
+       functor(G, F, _),
+       atom(F),
+       F \== [],
+       load_context(M),
+       G0 = M:G
+    ).
+
+call_clause(G, G0) :-
+    functor(G, F, _),
+    atom(F),
+    F \== [],
+    load_context(M),
+    expand_goal(M:G, M, G0).
+
+
+call(G) :-
+    (  var(G) ->
+       instantiation_error(call/1)
+    ;  call_clause(G, G0) ->
+       '$call'(G0)
+    ;  type_error(callable, G, call/1)
+    ).
+
+
+call_clause(M:G1, Args, _, G0) :-
+    atom(M),
+    G1 =.. [F | As],
+    atom(F),
+    F \== [],
+    !,
+    append(As, Args, As1),
+    G2 =.. [F | As1],
+    expand_goal(M:G2, M, G0).
+
+call_clause('$call'(G1), Args, N, G0) :-
+    (  var(G1),
+       instantiation_error(call/N)
+    ;  G1 = M:G2,
+       !,
+       atom(M),
+       G2 =.. [F | As],
+       atom(F),
+       F \== [],
+       append(As, Args, As1),
+       G3 =.. [F | As1],
+       G0 = M:G3
+    ;  !,
+       G1 =.. [F | As],
+       atom(F),
+       F \== [],
+       load_context(M),
+       append(As, Args, As1),
+       G2 =.. [F | As1],
+       G0 = M:G2
+    ).
+
+call_clause(G, Args, _, G0) :-
+    G =.. [F | As],
+    atom(F),
+    F \== [],
+    load_context(M),
+    append(As, Args, As1),
+    G2 =.. [F | As1],
+    expand_goal(M:G2, M, G0).
+
+
+call(A,B) :-
+    (  var(A) ->
+       instantiation_error(call/2)
+    ;  (  call_clause(A,[B],2,C) ->
+          '$call'(C)
+       ;  type_error(callable,A,call/2)
+       )
+    ).
+
+call(A,B,C) :-
+    (  var(A) ->
+       instantiation_error(call/3)
+    ;  (  call_clause(A,[B,C],3,D) ->
+          '$call'(D)
+       ;  type_error(callable,A,call/3)
+       )
+    ).
+
+call(A,B,C,D) :-
+    (  var(A) ->
+       instantiation_error(call/4)
+    ;  (  call_clause(A,[B,C,D],4,E) ->
+          '$call'(E)
+       ;  type_error(callable,A,call/4)
+       )
+    ).
+
+call(A,B,C,D,E) :-
+    (  var(A) ->
+       instantiation_error(call/5)
+    ;  (  call_clause(A,[B,C,D,E],5,F) ->
+          '$call'(F)
+       ;  type_error(callable,A,call/5)
+       )
+    ).
+
+call(A,B,C,D,E,F) :-
+    (  var(A) ->
+       instantiation_error(call/6)
+    ;  (  call_clause(A,[B,C,D,E,F],6,G) ->
+          '$call'(G)
+       ;  type_error(callable,A,call/6)
+       )
+    ).
+
+call(A,B,C,D,E,F,G) :-
+    (  var(A) ->
+       instantiation_error(call/7)
+    ;  (  call_clause(A,[B,C,D,E,F,G],7,H) ->
+          '$call'(H)
+       ;  type_error(callable,A,call/7)
+       )
+    ).
+
+call(A,B,C,D,E,F,G,H) :-
+    (  var(A) ->
+       instantiation_error(call/8)
+    ;  (  call_clause(A,[B,C,D,E,F,G,H],8,I) ->
+          '$call'(I)
+       ;  type_error(callable,A,call/8)
+       )
+    ).
+
+call(A,B,C,D,E,F,G,H,I) :-
+    (  var(A) ->
+       instantiation_error(call/9)
+    ;  (  call_clause(A,[B,C,D,E,F,G,H,I],9,J) ->
+          '$call'(J)
+       ;  type_error(callable,A,call/9)
+       )
+    ).
+
+call(A,B,C,D,E,F,G,H,I,J) :-
+    (  var(A) ->
+       instantiation_error(call/10)
+    ;  (  call_clause(A,[B,C,D,E,F,G,H,I,J],10,K) ->
+          '$call'(K)
+       ;  type_error(callable,A,call/10)
+       )
+    ).
+
+call(A,B,C,D,E,F,G,H,I,J,K) :-
+    (  var(A) ->
+       instantiation_error(call/11)
+    ;  (  call_clause(A,[B,C,D,E,F,G,H,I,J,K],11,L) ->
+          '$call'(L)
+       ;  type_error(callable,A,call/11)
+       )
+    ).
+
+call(A,B,C,D,E,F,G,H,I,J,K,L) :-
+    (  var(A) ->
+       instantiation_error(call/12)
+    ;  (  call_clause(A,[B,C,D,E,F,G,H,I,J,K,L],12,M) ->
+          '$call'(M)
+       ;  type_error(callable,A,call/12)
+       )
+    ).
+
+call(A,B,C,D,E,F,G,H,I,J,K,L,M) :-
+    (  var(A) ->
+       instantiation_error(call/13)
+    ;  (  call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M],13,N) ->
+          '$call'(N)
+       ;  type_error(callable,A,call/13)
+       )
+    ).
+
+call(A,B,C,D,E,F,G,H,I,J,K,L,M,N) :-
+    (  var(A) ->
+       instantiation_error(call/14)
+    ;  (  call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N],14,O) ->
+          '$call'(O)
+       ;  type_error(callable,A,call/14)
+       )
+    ).
+
+call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O) :-
+    (  var(A) ->
+       instantiation_error(call/15)
+    ;  (  call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O],15,P) ->
+          '$call'(P)
+       ;  type_error(callable,A,call/15)
+       )
+    ).
+
+call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P) :-
+    (  var(A) ->
+       instantiation_error(call/16)
+    ;  (  call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P],16,Q) ->
+          '$call'(Q)
+       ;  type_error(callable,A,call/16)
+       )
+    ).
+
+call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q) :-
+    (  var(A) ->
+       instantiation_error(call/17)
+    ;  (  call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q],17,R) ->
+          '$call'(R)
+       ;  type_error(callable,A,call/17)
+       )
+    ).
+
+call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R) :-
+    (  var(A) ->
+       instantiation_error(call/18)
+    ;  (  call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R],18,S) ->
+          '$call'(S)
+       ;  type_error(callable,A,call/18)
+       )
+    ).
+
+call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S) :-
+    (  var(A) ->
+       instantiation_error(call/19)
+    ;  (  call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S],19,T) ->
+          '$call'(T)
+       ;  type_error(callable,A,call/19)
+       )
+    ).
+
+call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T) :-
+    (  var(A) ->
+       instantiation_error(call/20)
+    ;  (  call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T],20,U) ->
+          '$call'(U)
+       ;  type_error(callable,A,call/20)
+       )
+    ).
+
+call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U) :-
+    (  var(A) ->
+       instantiation_error(call/21)
+    ;  (  call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U],21,V) ->
+          '$call'(V)
+       ;  type_error(callable,A,call/21)
+       )
+    ).
+
+call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V) :-
+    (  var(A) ->
+       instantiation_error(call/22)
+    ;  (  call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V],22,W) ->
+          '$call'(W)
+       ;  type_error(callable,A,call/22)
+       )
+    ).
+
+call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W) :-
+    (  var(A) ->
+       instantiation_error(call/23)
+    ;  (  call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W],23,X) ->
+          '$call'(X)
+       ;  type_error(callable,A,call/23)
+       )
+    ).
+
+call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X) :-
+    (  var(A) ->
+       instantiation_error(call/24)
+    ;  (  call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X],24,Y) ->
+          '$call'(Y)
+       ;  type_error(callable,A,call/24)
+       )
+    ).
+
+call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y) :-
+    (  var(A) ->
+       instantiation_error(call/25)
+    ;  (  call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y],25,Z) ->
+          '$call'(Z)
+       ;  type_error(callable,A,call/25)
+       )
+    ).
+
+call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z) :-
+    (  var(A) ->
+       instantiation_error(call/26)
+    ;  (  call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z],26,A1) ->
+          '$call'(A1)
+       ;  type_error(callable,A,call/26)
+       )
+    ).
+
+call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1) :-
+    (  var(A) ->
+       instantiation_error(call/27)
+    ;  (  call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1],27,B1) ->
+          '$call'(B1)
+       ;  type_error(callable,A,call/27)
+       )
+    ).
+
+call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1) :-
+    (  var(A) ->
+       instantiation_error(call/28)
+    ;  (  call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1],28,C1) ->
+          '$call'(C1)
+       ;  type_error(callable,A,call/28)
+       )
+    ).
+
+call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1) :-
+    (  var(A) ->
+       instantiation_error(call/29)
+    ;  (  call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1],29,D1) ->
+          '$call'(D1)
+       ;  type_error(callable,A,call/29)
+       )
+    ).
+
+call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1) :-
+    (  var(A) ->
+       instantiation_error(call/30)
+    ;  (  call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1],30,E1) ->
+          '$call'(E1)
+       ;  type_error(callable,A,call/30)
+       )
+    ).
+
+call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1) :-
+    (  var(A) ->
+       instantiation_error(call/31)
+    ;  (  call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1],31,F1) ->
+          '$call'(F1)
+       ;  type_error(callable,A,call/31)
+       )
+    ).
+
+call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1) :-
+    (  var(A) ->
+       instantiation_error(call/32)
+    ;  (  call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1],32,G1) ->
+          '$call'(G1)
+       ;  type_error(callable,A,call/32)
+       )
+    ).
+
+call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1) :-
+    (  var(A) ->
+       instantiation_error(call/33)
+    ;  (  call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1],33,H1) ->
+          '$call'(H1)
+       ;  type_error(callable,A,call/33)
+       )
+    ).
+
+call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1) :-
+    (  var(A) ->
+       instantiation_error(call/34)
+    ;  (  call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1],34,I1) ->
+          '$call'(I1)
+       ;  type_error(callable,A,call/34)
+       )
+    ).
+
+call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1) :-
+    (  var(A) ->
+       instantiation_error(call/35)
+    ;  (  call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1],35,J1) ->
+          '$call'(J1)
+       ;  type_error(callable,A,call/35)
+       )
+    ).
+
+call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1) :-
+    (  var(A) ->
+       instantiation_error(call/36)
+    ;  (  call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1],36,K1) ->
+          '$call'(K1)
+       ;  type_error(callable,A,call/36)
+       )
+    ).
+
+call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1) :-
+    (  var(A) ->
+       instantiation_error(call/37)
+    ;  (  call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1],37,L1) ->
+          '$call'(L1)
+       ;  type_error(callable,A,call/37)
+       )
+    ).
+
+call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1) :-
+    (  var(A) ->
+       instantiation_error(call/38)
+    ;  (  call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1],38,M1) ->
+          '$call'(M1)
+       ;  type_error(callable,A,call/38)
+       )
+    ).
+
+call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1) :-
+    (  var(A) ->
+       instantiation_error(call/39)
+    ;  (  call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1],39,N1) ->
+          '$call'(N1)
+       ;  type_error(callable,A,call/39)
+       )
+    ).
+
+call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1) :-
+    (  var(A) ->
+       instantiation_error(call/40)
+    ;  (  call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1],40,O1) ->
+          '$call'(O1)
+       ;  type_error(callable,A,call/40)
+       )
+    ).
+
+call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1) :-
+    (  var(A) ->
+       instantiation_error(call/41)
+    ;  (  call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1],41,P1) ->
+          '$call'(P1)
+       ;  type_error(callable,A,call/41)
+       )
+    ).
+
+call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1) :-
+    (  var(A) ->
+       instantiation_error(call/42)
+    ;  (  call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1],42,Q1) ->
+          '$call'(Q1)
+       ;  type_error(callable,A,call/42)
+       )
+    ).
+
+call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1) :-
+    (  var(A) ->
+       instantiation_error(call/43)
+    ;  (  call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1],43,R1) ->
+          '$call'(R1)
+       ;  type_error(callable,A,call/43)
+       )
+    ).
+
+call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1) :-
+    (  var(A) ->
+       instantiation_error(call/44)
+    ;  (  call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1],44,S1) ->
+          '$call'(S1)
+       ;  type_error(callable,A,call/44)
+       )
+    ).
+
+call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1) :-
+    (  var(A) ->
+       instantiation_error(call/45)
+    ;  (  call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1],45,T1) ->
+          '$call'(T1)
+       ;  type_error(callable,A,call/45)
+       )
+    ).
+
+call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1) :-
+    (  var(A) ->
+       instantiation_error(call/46)
+    ;  (  call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1],46,U1) ->
+          '$call'(U1)
+       ;  type_error(callable,A,call/46)
+       )
+    ).
+
+call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1) :-
+    (  var(A) ->
+       instantiation_error(call/47)
+    ;  (  call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1],47,V1) ->
+          '$call'(V1)
+       ;  type_error(callable,A,call/47)
+       )
+    ).
+
+call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1) :-
+    (  var(A) ->
+       instantiation_error(call/48)
+    ;  (  call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1],48,W1) ->
+          '$call'(W1)
+       ;  type_error(callable,A,call/48)
+       )
+    ).
+
+call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1,W1) :-
+    (  var(A) ->
+       instantiation_error(call/49)
+    ;  (  call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1,W1],49,X1) ->
+          '$call'(X1)
+       ;  type_error(callable,A,call/49)
+       )
+    ).
+
+call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1,W1,X1) :-
+    (  var(A) ->
+       instantiation_error(call/50)
+    ;  (  call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1,W1,X1],50,Y1) ->
+          '$call'(Y1)
+       ;  type_error(callable,A,call/50)
+       )
+    ).
+
+call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1,W1,X1,Y1) :-
+    (  var(A) ->
+       instantiation_error(call/51)
+    ;  (  call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1,W1,X1,Y1],51,Z1) ->
+          '$call'(Z1)
+       ;  type_error(callable,A,call/51)
+       )
+    ).
+
+call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1,W1,X1,Y1,Z1) :-
+    (  var(A) ->
+       instantiation_error(call/52)
+    ;  (  call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1,W1,X1,Y1,Z1],52,A2) ->
+          '$call'(A2)
+       ;  type_error(callable,A,call/52)
+       )
+    ).
+
+call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1,W1,X1,Y1,Z1,A2) :-
+    (  var(A) ->
+       instantiation_error(call/53)
+    ;  (  call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1,W1,X1,Y1,Z1,A2],53,B2) ->
+          '$call'(B2)
+       ;  type_error(callable,A,call/53)
+       )
+    ).
+
+call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1,W1,X1,Y1,Z1,A2,B2) :-
+    (  var(A) ->
+       instantiation_error(call/54)
+    ;  (  call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1,W1,X1,Y1,Z1,A2,B2],54,C2) ->
+          '$call'(C2)
+       ;  type_error(callable,A,call/54)
+       )
+    ).
+
+call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1,W1,X1,Y1,Z1,A2,B2,C2) :-
+    (  var(A) ->
+       instantiation_error(call/55)
+    ;  (  call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1,W1,X1,Y1,Z1,A2,B2,C2],55,D2) ->
+          '$call'(D2)
+       ;  type_error(callable,A,call/55)
+       )
+    ).
+
+call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1,W1,X1,Y1,Z1,A2,B2,C2,D2) :-
+    (  var(A) ->
+       instantiation_error(call/56)
+    ;  (  call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1,W1,X1,Y1,Z1,A2,B2,C2,D2],56,E2) ->
+          '$call'(E2)
+       ;  type_error(callable,A,call/56)
+       )
+    ).
+
+call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1,W1,X1,Y1,Z1,A2,B2,C2,D2,E2) :-
+    (  var(A) ->
+       instantiation_error(call/57)
+    ;  (  call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1,W1,X1,Y1,Z1,A2,B2,C2,D2,E2],57,F2) ->
+          '$call'(F2)
+       ;  type_error(callable,A,call/57)
+       )
+    ).
+
+call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1,W1,X1,Y1,Z1,A2,B2,C2,D2,E2,F2) :-
+    (  var(A) ->
+       instantiation_error(call/58)
+    ;  (  call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1,W1,X1,Y1,Z1,A2,B2,C2,D2,E2,F2],58,G2) ->
+          '$call'(G2)
+       ;  type_error(callable,A,call/58)
+       )
+    ).
+
+call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1,W1,X1,Y1,Z1,A2,B2,C2,D2,E2,F2,G2) :-
+    (  var(A) ->
+       instantiation_error(call/59)
+    ;  (  call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1,W1,X1,Y1,Z1,A2,B2,C2,D2,E2,F2,G2],59,H2) ->
+          '$call'(H2)
+       ;  type_error(callable,A,call/59)
+       )
+    ).
+
+call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1,W1,X1,Y1,Z1,A2,B2,C2,D2,E2,F2,G2,H2) :-
+    (  var(A) ->
+       instantiation_error(call/60)
+    ;  (  call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1,W1,X1,Y1,Z1,A2,B2,C2,D2,E2,F2,G2,H2],60,I2) ->
+          '$call'(I2)
+       ;  type_error(callable,A,call/60)
+       )
+    ).
+
+call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1,W1,X1,Y1,Z1,A2,B2,C2,D2,E2,F2,G2,H2,I2) :-
+    (  var(A) ->
+       instantiation_error(call/61)
+    ;  (  call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1,W1,X1,Y1,Z1,A2,B2,C2,D2,E2,F2,G2,H2,I2],61,J2) ->
+          '$call'(J2)
+       ;  type_error(callable,A,call/61)
+       )
+    ).
+
+call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1,W1,X1,Y1,Z1,A2,B2,C2,D2,E2,F2,G2,H2,I2,J2) :-
+    (  var(A) ->
+       instantiation_error(call/62)
+    ;  (  call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1,W1,X1,Y1,Z1,A2,B2,C2,D2,E2,F2,G2,H2,I2,J2],62,K2) ->
+          '$call'(K2)
+       ;  type_error(callable,A,call/62)
+       )
+    ).
+
+call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1,W1,X1,Y1,Z1,A2,B2,C2,D2,E2,F2,G2,H2,I2,J2,K2) :-
+    (  var(A) ->
+       instantiation_error(call/63)
+    ;  (  call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1,W1,X1,Y1,Z1,A2,B2,C2,D2,E2,F2,G2,H2,I2,J2,K2],63,L2) ->
+          '$call'(L2)
+       ;  type_error(callable,A,call/63)
+       )
+    ).
+
+call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1,W1,X1,Y1,Z1,A2,B2,C2,D2,E2,F2,G2,H2,I2,J2,K2,L2) :-
+    (  var(A) ->
+       instantiation_error(call/64)
+    ;  (  call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1,W1,X1,Y1,Z1,A2,B2,C2,D2,E2,F2,G2,H2,I2,J2,K2,L2],64,M2) ->
+          '$call'(M2)
+       ;  type_error(callable,A,call/64)
+       )
+    ).
+
+call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1,W1,X1,Y1,Z1,A2,B2,C2,D2,E2,F2,G2,H2,I2,J2,K2,L2,M2) :-
+    (  var(A) ->
+       instantiation_error(call/65)
+    ;  (  call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1,W1,X1,Y1,Z1,A2,B2,C2,D2,E2,F2,G2,H2,I2,J2,K2,L2,M2],65,N2) ->
+          '$call'(N2)
+       ;  type_error(callable,A,call/65)
+       )
+    ).
+
+call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1,W1,X1,Y1,Z1,A2,B2,C2,D2,E2,F2,G2,H2,I2,J2,K2,L2,M2) :-
+    (  var(A) ->
+       instantiation_error(call/65)
+    ;  (  call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1,W1,X1,Y1,Z1,A2,B2,C2,D2,E2,F2,G2,H2,I2,J2,K2,L2,M2],65,N2) ->
+          '$call'(N2)
+       ;  type_error(callable,A,call/65)
+       )
+    ).

src/machine/attributed_variables.pl

@@ -51,7 +51,6 @@ call_goals_0([Module-GoalList | GoalLists]) :-
 call_goals_0([]).
 
 call_goals_1([Goal | Goals], Module) :-
-    expand_goal(Goal, Module, Goal1), % TODO: remove this when goal expansions are added to call/N.
+    call(Module:Goal),
-    call(Module:Goal1),
     call_goals_1(Goals, Module).
 call_goals_1([], _).

src/machine/load_state.rs

@@ -528,19 +528,6 @@ impl<'a> LoadState<'a> {
         }
     }
 
-    #[inline]
-    pub(super)
-    fn module_name(&self) -> ClauseName {
-        match self.compilation_target {
-            CompilationTarget::User => {
-                clause_name!("user")
-            }
-            CompilationTarget::Module(ref module_name) => {
-                module_name.clone()
-            }
-        }
-    }
-
     pub(super)
     fn add_meta_predicate_record(
         &mut self,

src/machine/loader.rs

@@ -573,6 +573,19 @@ impl CompilationTarget {
     fn take(&mut self) -> CompilationTarget {
         mem::replace(self, CompilationTarget::User)
     }
+
+    #[inline]
+    pub(super)
+    fn module_name(&self) -> ClauseName {
+        match self {
+            CompilationTarget::User => {
+                clause_name!("user")
+            }
+            CompilationTarget::Module(ref module_name) => {
+                module_name.clone()
+            }
+        }
+    }
 }
 
 pub(crate) struct Loader<'a, TermStream> {

src/machine/mod.rs

@@ -119,39 +119,6 @@ include!(concat!(env!("OUT_DIR"), "/libraries.rs"));
 
 impl Machine {
     /*
-    fn compile_special_forms(&mut self)
-    {
-        let verify_attrs_src = ListingSource::User;
-
-        match compile_special_form(
-            self,
-            Stream::from(VERIFY_ATTRS),
-            verify_attrs_src,
-        )
-        {
-            Ok(p) => {
-                self.machine_st.attr_var_init.verify_attrs_loc = p;
-            }
-            Err(_) =>
-                panic!("Machine::compile_special_forms() failed at VERIFY_ATTRS"),
-        }
-
-        let project_attrs_src = ListingSource::User;
-
-        match compile_special_form(
-            self,
-            Stream::from(PROJECT_ATTRS),
-            project_attrs_src,
-        )
-        {
-            Ok(p) => {
-                self.machine_st.attr_var_init.project_attrs_loc = p;
-            }
-            Err(e) =>
-                panic!("Machine::compile_special_forms() failed at PROJECT_ATTRS: {}", e),
-        }
-    }
-
     fn compile_scryerrc(&mut self) {
         let mut path = match dirs_next::home_dir() {
             Some(path) => path,
@@ -177,7 +144,8 @@ impl Machine {
             compile_user_module(self, file_src, rc_src);
         }
     }
-*/
+    */
+
     #[cfg(test)]
     pub fn reset(&mut self) {
         self.current_input_stream = readline::input_stream();
@@ -289,12 +257,62 @@ impl Machine {
 
         self.machine_st[temp_v!(1)] = list_addr;
 
-        // WAS:
-        // self.run_module_predicate(clause_name!("$toplevel"), (clause_name!("$repl"), 1));
-
         self.run_module_predicate(clause_name!("$toplevel"), (clause_name!("repl"), 0));
     }
 
+    fn configure_modules(&mut self) {
+        fn update_call_n_indices(loader: &Module, target_module: &mut Module) {
+            for arity in 1 .. 66 {
+                let key = (clause_name!("call"), arity);
+
+                match loader.code_dir.get(&key).cloned() {
+                    Some(src_code_index) => {
+                        let target_code_index = target_module.code_dir
+                            .entry(key.clone())
+                            .or_insert_with(|| CodeIndex::new(IndexPtr::Undefined));
+
+                        target_code_index.set(src_code_index.get());
+                    }
+                    None => {
+                        unreachable!();
+                    }
+                }
+            }
+        }
+
+        if let Some(loader) = self.indices.modules.swap_remove(&clause_name!("loader")) {
+            if let Some(builtins) = self.indices.modules.get_mut(&clause_name!("builtins")) {
+                // Import loader's exports into the builtins module so they will be
+                // implicitly included in every further module.
+                load_module(
+                    &mut builtins.code_dir,
+                    &mut builtins.op_dir,
+                    &mut builtins.meta_predicates,
+                    &CompilationTarget::Module(clause_name!("builtins")),
+                    &loader,
+                );
+
+                for export in &loader.module_decl.exports {
+                    builtins.module_decl.exports.push(export.clone());
+                }
+
+                for arity in 10 .. 66 {
+                    builtins.module_decl.exports.push(
+                        ModuleExport::PredicateKey((clause_name!("call"), arity)),
+                    );
+                }
+            }
+
+            for (_, target_module) in self.indices.modules.iter_mut() {
+                update_call_n_indices(&loader, target_module);
+            }
+
+            self.indices.modules.insert(clause_name!("loader"), loader);
+        } else {
+            unreachable!()
+        }
+    }
+
     pub fn new(user_input: Stream, user_output: Stream) -> Self
     {
         use crate::ref_thread_local::RefThreadLocal;
@@ -356,32 +374,16 @@ impl Machine {
             ),
         ).unwrap();
 
-        if let Some(loader) = wam.indices.modules.swap_remove(&clause_name!("loader")) {
+        wam.configure_modules();
-            if let Some(builtins) = wam.indices.modules.get_mut(&clause_name!("builtins")) {
-                // Import loader's exports into the builtins module so they will be
-                // implicitly included every further module.
-                load_module(
-                    &mut builtins.code_dir,
-                    &mut builtins.op_dir,
-                    &mut builtins.meta_predicates,
-                    &CompilationTarget::Module(clause_name!("builtins")),
-                    &loader,
-                );
-
-                for export in &loader.module_decl.exports {
-                    builtins.module_decl.exports.push(export.clone());
-                }
-            }
 
+        if let Some(loader) = wam.indices.modules.get(&clause_name!("loader")) {
             load_module(
                 &mut wam.indices.code_dir,
                 &mut wam.indices.op_dir,
                 &mut wam.indices.meta_predicates,
                 &CompilationTarget::User,
-                &loader,
+                loader,
             );
-
-            wam.indices.modules.insert(clause_name!("loader"), loader);
         } else {
             unreachable!()
         }

src/machine/preprocessor.rs

@@ -401,7 +401,7 @@ fn setup_meta_predicate<'a>(
             }
         Term::Clause(_, name, mut terms, _) => {
             let (name, meta_specs) = get_name_and_meta_specs(name, &mut terms)?;
-            Ok((load_state.module_name(), name, meta_specs))
+            Ok((load_state.compilation_target.module_name(), name, meta_specs))
         }
         _ => {
             Err(CompilationError::InvalidMetaPredicateDecl)