Merge pull request #1029 from mathics/combinatorica-again

Combinatorica again

Author: rocky

mathics/builtin/control.py

@@ -10,7 +10,8 @@
 from mathics.builtin.base import Builtin, BinaryOperator
 from mathics.core.expression import Expression, Symbol, from_python
 from mathics.core.evaluation import (
-    AbortInterrupt, BreakInterrupt, ContinueInterrupt, ReturnInterrupt)
+    AbortInterrupt, BreakInterrupt, ContinueInterrupt, ReturnInterrupt,
+    WLThrowInterrupt)
 from mathics.builtin.lists import _IterationFunction
 from mathics.builtin.patterns import match
 
@@ -721,3 +722,88 @@ def apply(self, evaluation):
         'Continue[]'
 
         raise ContinueInterrupt
+
+
+class Catch(Builtin):
+    """
+    <dl>
+    <dt>'Catch[`expr`]'
+        <dd> returns the argument of the first Throw generated in the evaluation of expr.
+
+    <dt>'Catch[`expr`, `form`]'
+        <dd> returns value from the first Throw[`value`,`tag`] for which form matches `tag`.
+
+    <dt>'Catch[`expr`,`form`, `f`]'
+        <dd> returns the argument of the first `Throw` generated in the evaluation of `expr`.
+    </dl>
+
+    Exit to the enclosing Catch as soon as Throw is evaluated:
+    << Catch[r; s; Throw[t]; u; v]
+     = t
+
+    Define a function that can "throw an exception":
+    << f[x_] := If[x > 12, Throw[overflow], x!]
+     = ...
+    The result of Catch is just what is thrown by Throw:
+    << Catch[f[1] + f[15]]
+     = overflow
+    << Catch[f[1]+f[4]]
+     = 24
+
+    """
+    attributes = ("HoldAll",)
+
+    def apply1(self, expr, evaluation):
+        'Catch[expr_]'
+        try:
+            ret = expr.evaluate(evaluation)
+        except WLThrowInterrupt as e:
+            return e.value
+        return ret
+
+    def apply3(self, expr, form, f, evaluation):
+        "Catch[expr_, form_, f__:Identity]"
+        try:
+            ret = expr.evaluate(evaluation)
+        except WLThrowInterrupt as e:
+            # TODO: check that form match tag.
+            # otherwise, re-raise the exception
+            match = Expression("MatchQ", e.tag, form).evaluate(evaluation)
+            if match.is_true():
+                return Expression(f, e.value)
+            else:
+                # A plain raise hide, this path and preserves the traceback
+                # of the call that was originally given.
+                raise
+        return ret
+
+
+class Throw(Builtin):
+    """
+    <dl>
+    <dt>'Throw[`value`]'
+        <dd> stops evaluation and returns `value` as the value of the nearest enclosing Catch.
+
+    <dt>'Catch[`value`, `tag`]'
+        <dd> is caught only by `Catch[expr,form]`, where tag matches form.
+
+    </dl>
+
+     Using Throw can affect the structure of what is returned by a function:
+
+     << NestList[#^2 + 1 &, 1, 7]
+      = ...
+     << Catch[NestList[If[# > 1000, Throw[#], #^2 + 1] &, 1, 7]]
+      = 458330
+     << Throw[1]
+      = Null
+    """
+    messages = {'nocatch': 'Uncaught `1` returned to top level.', }
+
+    def apply1(self, value, evaluation):
+        'Throw[value_]'
+        raise WLThrowInterrupt(value)
+
+    def apply2(self, value, tag, evaluation):
+        'Throw[value_, tag_]'
+        raise WLThrowInterrupt(value, tag)

mathics/builtin/files.py

@@ -4793,11 +4793,11 @@ def apply(self, context, evaluation):
             evaluation.message('Needs', 'ctx', Expression(
                 'Needs', context), 1, '`')
             return
-
-        # TODO
-        # if Expression('MemberQ', context, Symbol('$Packages')).is_true():
-        #    # Already loaded
-        #    return Symbol('Null')
+        test_loaded = Expression('MemberQ', Symbol('$Packages'), context)
+        test_loaded = test_loaded.evaluate(evaluation)
+        if test_loaded.is_true():
+            # Already loaded
+            return Symbol('Null')
 
         result = Expression('Get', context).evaluate(evaluation)
 

mathics/builtin/scoping.py

@@ -5,7 +5,7 @@
 from mathics.builtin.base import Builtin, Predefined
 from mathics.core.expression import (Expression, String, Symbol, Integer,
                                      fully_qualified_symbol_name)
-
+from mathics.core.rules import Rule
 
 def get_scoping_vars(var_list, msg_symbol='', evaluation=None):
     def message(tag, *args):
@@ -55,6 +55,54 @@ def dynamic_scoping(func, vars, evaluation):
     return result
 
 
+class With(Builtin):
+    """
+    <dl>
+
+    <dt>'With[{$x$=$x0$, $y$=$y0$, ...}, $expr$]'
+        <dd>specifies that all occurrences of the symbols $x$, $y$, ... in $expr$ should be replaced by $x0$, $y0$, ...
+    </dl>
+
+    >> n = 10
+     = 10
+    >> With[{n = 5}, n ^ 2]
+     = 25
+    >> n
+     = 10
+    >> With[{x=y}, Hold[x]]
+     = Hold[y]
+    >> Table[With[{i=j}, Hold[i]],{j,1,4}]
+     = {Hold[1], Hold[2], Hold[3], Hold[4]}
+    >> x=5; With[{x=x}, Hold[x]]
+     = Hold[5]
+    >> {Block[{x = 3}, Hold[x]], With[{x = 3}, Hold[x]]}
+     = {Hold[x], Hold[3]}
+    >> x=.; ReleaseHold /@ %
+     = {x, 3}
+    >> With[{e = y}, Function[{x,y}, e*x*y]]
+     = Function[{x$, y$}, y x$ y$]
+
+    """
+
+    attributes = ('HoldAll',)
+
+    messages = {
+        'lvsym': ("Local variable specification contains `1`, "
+                  "which is not a symbol or an assignment to a symbol."),
+        'dup': ("Duplicate local variable `1` found in local variable "
+                "specification."),
+        'lvlist': "Local variable specification `1` is not a List.",
+    }
+
+    def apply(self, vars, expr, evaluation):
+        'With[vars_, expr_]'
+
+        vars = dict(get_scoping_vars(vars, 'With', evaluation))
+        result = expr.replace_vars(vars)
+        result.evaluate(evaluation)
+        return result
+
+
 class Block(Builtin):
     """
     <dl>
@@ -570,12 +618,15 @@ class BeginPackage(Builtin):
 
     rules = {
         'BeginPackage[context_String]': '''
-             Unprotect[System`Private`$ContextPathStack];
+             Unprotect[System`Private`$ContextPathStack, System`$Packages];
              Begin[context];
              System`Private`$ContextPathStack =
                  Append[System`Private`$ContextPathStack, $ContextPath];
              $ContextPath = {context, "System`"};
-             Protect[System`Private`$ContextPathStack];
+             $Packages = If[MemberQ[System`$Packages,$Context],
+                            None,
+                            System`$Packages=Join[{$Context}, System`$Packages]];
+             Protect[System`Private`$ContextPathStack, System`$Packages];
              context
         ''',
     }

mathics/core/evaluation.py

@@ -50,6 +50,13 @@ class BreakInterrupt(EvaluationInterrupt):
 class ContinueInterrupt(EvaluationInterrupt):
     pass
 
+class WLThrowInterrupt(EvaluationInterrupt):
+    def __init__(self, value, tag=None):
+        self.tag = tag
+        self.value = value
+    
+
+
 
 def _thread_target(request, queue) -> None:
     try:
@@ -331,6 +338,18 @@ def evaluate():
                     self.exc_result = Expression("Overflow")
                 else:
                     raise
+            except WLThrowInterrupt as ti:
+                if ti.tag:
+                    self.exc_result = Expression("Hold",
+                                                 Expression("Throw",
+                                                            ti.value,
+                                                            ti.tag))
+                else:
+                    self.exc_result = Expression("Hold",
+                                                 Expression("Throw",
+                                                            ti.value
+                                                            ))
+                self.message("Throw", "nocatch", self.exc_result)
             except OverflowError:
                 self.message("General", "ovfl")
                 self.exc_result = Expression("Overflow")