eyeprolog 1.5.61 → 1.5.62

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.5.61",
+  "version": "1.5.62",
   "description": "EyeProlog turns facts and rules into answers and proofs.",
   "type": "module",
   "main": "./index.js",

package/src/lib/error.pl

@@ -21,34 +21,39 @@
 %  raise site: the raise sites throw with [] and this wrapper prepends its
 %  element, so contexts stay proper lists and compose with any enclosing
 %  call_with_error_context/2 (issue #98).
+%  The context is named in exactly one place -- error__must_be_throw/1 -- so no
+%  raise site hands one over (issue #98). It is a throw helper rather than a
+%  call_with_error_context/2 wrapper because wrapping a Prolog goal in catch/3
+%  costs a child Solver on every call, and must_be/2 succeeds almost always.
 must_be(Type, Term) :-
-    call_with_error_context(
-        ( var(Type) -> instantiation_error
-        ; error__must_be(Type, Term)
-        ),
-        predicate-must_be/2).
+    ( var(Type) -> error__must_be_throw(instantiation_error)
+    ; error__must_be(Type, Term)
+    ).
+
+error__must_be_throw(Formal) :-
+    throw(error(Formal, [predicate-must_be/2])).
 
 error__must_be(integer, Term) :- !,
-    ( var(Term) -> instantiation_error
+    ( var(Term) -> error__must_be_throw(instantiation_error)
     ; integer(Term) -> true
-    ; type_error(integer, Term)
+    ; error__must_be_throw(type_error(integer, Term))
     ).
 error__must_be(atom, Term) :- !,
-    ( var(Term) -> instantiation_error
+    ( var(Term) -> error__must_be_throw(instantiation_error)
     ; atom(Term) -> true
-    ; type_error(atom, Term)
+    ; error__must_be_throw(type_error(atom, Term))
     ).
 error__must_be(number, Term) :- !,
-    ( var(Term) -> instantiation_error
+    ( var(Term) -> error__must_be_throw(instantiation_error)
     ; number(Term) -> true
-    ; type_error(number, Term)
+    ; error__must_be_throw(type_error(number, Term))
     ).
 error__must_be(var, Term) :- !,
     ( var(Term) -> true
     ; throw(error(uninstantiation_error(Term), []))
     ).
 error__must_be(ground, Term) :- !,
-    ( ground(Term) -> true ; instantiation_error ).
+    ( ground(Term) -> true ; error__must_be_throw(instantiation_error) ).
 error__must_be(acyclic, Term) :- !,
     ( acyclic_term(Term) -> true ; type_error(acyclic_term, Term) ).
 error__must_be(list, Term) :- !,
@@ -56,23 +61,23 @@ error__must_be(list, Term) :- !,
 error__must_be(list(Type), Term) :- !,
     error__proper_list_of(Term, Type).
 error__must_be(pair, Term) :- !,
-    ( var(Term) -> instantiation_error
+    ( var(Term) -> error__must_be_throw(instantiation_error)
     ; Term = _-_ -> true
-    ; type_error(pair, Term)
+    ; error__must_be_throw(type_error(pair, Term))
     ).
 error__must_be(not_less_than_zero, Term) :- !,
     must_be(integer, Term),
     ( Term >= 0 -> true ; domain_error(not_less_than_zero, Term) ).
 error__must_be(Type, Term) :-
-    ( var(Term) -> instantiation_error
-    ; type_error(Type, Term)
+    ( var(Term) -> error__must_be_throw(instantiation_error)
+    ; error__must_be_throw(type_error(Type, Term))
     ).
 
 error__proper_list([]) :- !.
 error__proper_list([_|Tail]) :- !, error__proper_list(Tail).
 error__proper_list(Term) :-
-    ( var(Term) -> instantiation_error
-    ; type_error(list, Term)
+    ( var(Term) -> error__must_be_throw(instantiation_error)
+    ; error__must_be_throw(type_error(list, Term))
     ).
 
 error__proper_list_of([], _) :- !.
@@ -80,7 +85,7 @@ error__proper_list_of([Head|Tail], Type) :- !,
     must_be(Type, Head),
     error__proper_list_of(Tail, Type).
 error__proper_list_of(Term, _) :-
-    ( var(Term) -> instantiation_error
+    ( var(Term) -> error__must_be_throw(instantiation_error)
     ; type_error(list, Term)
     ).
 

package/src/lib/random.pl

@@ -10,7 +10,7 @@
 :- module(random, [maybe/0, maybe/1, maybe/2, random/1, random/3, random_integer/3, set_random/1]).
 
 :- use_module(library(iso_ext), [bb_get/2, bb_put/2]).
-:- use_module(library(error), [call_with_error_context/2, instantiation_error/0, type_error/2]).
+
 
 maybe :-
     random_integer(0, 2, 0).
@@ -31,7 +31,7 @@ random(Value) :-
 %  Context declared once per predicate instead of at each raise site, so the
 %  raise sites throw with [] and contexts stay proper composable lists.
 random_integer(Lower, Upper, R) :-
-    call_with_error_context(random__check_integer_range(Lower, Upper), predicate-random_integer/3),
+    random__check_integer_range(Lower, Upper),
     Lower < Upper,
     random__current_seed(Seed0),
     random(Seed0, _, Seed),
@@ -39,28 +39,31 @@ random_integer(Lower, Upper, R) :-
     R is Lower + Seed mod (Upper - Lower).
 
 set_random(Seed) :-
-    call_with_error_context(random__set_seed(Seed), predicate-set_random/1).
+    random__set_seed(Seed).
+
+random__throw(Formal, Predicate) :-
+    throw(error(Formal, [predicate-Predicate])).
 
 random__check_integer_range(Lower, Upper) :-
-    ( var(Lower) -> instantiation_error
-    ; var(Upper) -> instantiation_error
+    ( var(Lower) -> random__throw(instantiation_error, random_integer/3)
+    ; var(Upper) -> random__throw(instantiation_error, random_integer/3)
     ; integer(Lower) -> true
-    ; type_error(integer, Lower)
+    ; random__throw(type_error(integer, Lower), random_integer/3)
     ),
     ( integer(Upper) -> true
-    ; type_error(integer, Upper)
+    ; random__throw(type_error(integer, Upper), random_integer/3)
     ).
 
 random__set_seed(Seed) :-
-    ( var(Seed) -> instantiation_error
+    ( var(Seed) -> random__throw(instantiation_error, set_random/1)
     ; Seed = seed(S) ->
-        ( var(S) -> instantiation_error
+        ( var(S) -> random__throw(instantiation_error, set_random/1)
         ; integer(S) ->
             random__random_normalize_seed(S, Normalized),
             bb_put('$random_seed', Normalized)
-        ; type_error(integer, S)
+        ; random__throw(type_error(integer, S), set_random/1)
         )
-    ; type_error(random_state, Seed)
+    ; random__throw(type_error(random_state, Seed), set_random/1)
     ).
 
 random__current_seed(Seed) :- bb_get('$random_seed', Seed), !.

package/test/regression/cases-regression.mjs

@@ -4510,6 +4510,24 @@ answer(Result) :- countdown(2048, Result), Result = 2048.
         assertIncludes(repl.stdout, 'throw(foo)', 'non-error ball keeps the wrapper');
       },
     },
+    {
+      // must_be/2 is called constantly by library code, so its context must be
+      // supplied without a catch/3 frame: wrapping a Prolog goal in catch/3
+      // costs a child Solver per call and made the suite ~35% slower.
+      name: 'must_be/2 does not pay for a catch frame on success',
+      run: () => {
+        const input = '%% goal: answer(X)\n' +
+          'loop(0) :- !.\nloop(N) :- must_be(integer, N), M is N - 1, loop(M).\n' +
+          'answer(ok) :- loop(20000).\n';
+        const started = Date.now();
+        const result = runCli(['-'], { input });
+        const elapsed = Date.now() - started;
+        assertEqual(result.status, 0, `exit status; stderr=${result.stderr}`);
+        assertIncludes(result.stdout, 'answer(ok)', 'loop completes');
+        // Generous bound: the catch/3 wrapper made this roughly 2x slower.
+        if (elapsed >= 20000) throw new Error(`20k must_be/2 calls took ${elapsed}ms`);
+      },
+    },
     {
       // Issue #99: the context element must be a pair, as in Scryer and
       // Trealla, and predicate contexts use the predicate-F/A convention.