coconut-develop 3.1.2.post0.dev1__tar.gz → 3.1.2.post0.dev2__tar.gz

coconut-develop-3.1.2.post0.dev2/PKG-INFO

@@ -0,0 +1,141 @@
+Metadata-Version: 2.1
+Name: coconut-develop
+Version: 3.1.2.post0.dev2
+Summary: Simple, elegant, Pythonic functional programming.
+Home-page: http://coconut-lang.org
+Author: Evan Hubinger
+Author-email: evanjhub@gmail.com
+License: Apache 2.0
+Description: |logo| Coconut
+        ==============
+        
+        ..
+            <insert toctree here>
+        
+        .. |logo| image:: https://github.com/evhub/coconut/raw/gh-pages/favicon-32x32.png
+        
+        .. image:: https://opencollective.com/coconut/backers/badge.svg
+            :alt: Backers on Open Collective
+            :target: #backers
+        .. image:: https://opencollective.com/coconut/sponsors/badge.svg
+            :alt: Sponsors on Open Collective
+            :target: #sponsors
+        .. image:: https://badges.gitter.im/evhub/coconut.svg
+            :alt: Join the chat at https://gitter.im/evhub/coconut
+            :target: https://gitter.im/evhub/coconut?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge
+        
+        Coconut (`coconut-lang.org`__) is a variant of Python_ that **adds on top of Python syntax** new features for simple, elegant, Pythonic **functional programming**.
+        
+        __ Coconut_
+        .. _Coconut: http://coconut-lang.org/
+        
+        Coconut is developed on GitHub_ and hosted on PyPI_. Installing Coconut is as easy as opening a command prompt and entering::
+        
+            pip install coconut
+        
+        To help you get started, check out these links for more information about Coconut:
+        
+        - Tutorial_: If you're new to Coconut, a good place to start is Coconut's **tutorial**.
+        - Documentation_: If you're looking for info about a specific feature, check out Coconut's **documentation**.
+        - `Online Interpreter`_: If you want to try Coconut in your browser, check out Coconut's **online interpreter**.
+        - FAQ_: If you have general questions about Coconut—like who Coconut is built for and whether or not you should use it—Coconut's frequently asked questions are often the best place to start.
+        - `Create a New Issue <https://github.com/evhub/coconut/issues/new>`_: If you're having a problem with Coconut, creating a new issue detailing the problem will allow it to be addressed as soon as possible.
+        - Gitter_: For any questions, concerns, or comments about anything Coconut-related, ask around at Coconut's Gitter, a GitHub-integrated chat room for Coconut developers.
+        - Releases_: Want to know what's been added in recent Coconut versions? Check out the release log for all the new features and fixes.
+        
+        .. _Python: https://www.python.org/
+        .. _PyPI: https://pypi.python.org/pypi/coconut
+        .. _Tutorial: http://coconut.readthedocs.io/en/latest/HELP.html
+        .. _Documentation: http://coconut.readthedocs.io/en/latest/DOCS.html
+        .. _`Online Interpreter`: https://cs121-team-panda.github.io/coconut-interpreter
+        .. _FAQ: http://coconut.readthedocs.io/en/latest/FAQ.html
+        .. _GitHub: https://github.com/evhub/coconut
+        .. _Gitter: https://gitter.im/evhub/coconut
+        .. _Releases: https://github.com/evhub/coconut/releases
+        
+        Credits
+        +++++++
+        
+        Contributors
+        ------------
+        
+        This project exists thanks to all the people who contribute! `Become a contributor`__.
+        
+        .. image:: https://opencollective.com/coconut/contributors.svg?width=890&button=false
+            :target: https://github.com/evhub/coconut/graphs/contributors
+        
+        __ Contributor_
+        .. _Contributor: http://coconut.readthedocs.io/en/develop/CONTRIBUTING.html
+        
+        Backers
+        -------
+        
+        Thank you to all our backers! `Become a backer`__.
+        
+        .. image:: https://opencollective.com/coconut/backers.svg?width=890
+            :target: https://opencollective.com/coconut#backers
+        
+        __ Backer_
+        .. _Backer: https://opencollective.com/coconut#backer
+        
+        Sponsors
+        --------
+        
+        Support Coconut by becoming a sponsor. Your logo will show up here with a link to your website. `Become a sponsor`__.
+        
+        .. image:: https://opencollective.com/XX/sponsor/0/avatar.svg
+            :target: https://opencollective.com/coconut/sponsor/0/website
+        
+        __ Sponsor_
+        .. _Sponsor: https://opencollective.com/coconut#sponsor
+        
+Keywords: functional,programming,language,compiler,pattern,pattern-matching,algebraic,data type,data types,lambda,lambdas,lazy,evaluation,lazy list,lazy lists,tail,recursion,call,recursive,recursive_iterator,infix,function,composition,compose,partial,application,currying,curry,pipeline,pipe,unicode,operator,operators,frozenset,literal,syntax,destructuring,assignment,fold,datamaker,prepattern,iterator,generator,none,coalesce,coalescing,statement,lru_cache,memoization,backport,typing,embed,PEP 622,overrides,islice,itertools,functools,TYPE_CHECKING,Expected,breakpoint,help,reduce,takewhile,dropwhile,tee,count,makedata,consume,process_map,thread_map,addpattern,recursive_generator,fmap,starmap,reiterable,scan,groupsof,memoize,zip_longest,override,flatten,ident,call,safe_call,flip,const,lift,lift_apart,all_equal,collectby,mapreduce,multi_enumerate,cartesian_product,multiset,cycle,windowsof,and_then,and_then_await,async_map,py_chr,py_dict,py_hex,py_input,py_int,py_map,py_object,py_oct,py_open,py_print,py_range,py_str,py_super,py_zip,py_filter,py_reversed,py_enumerate,py_raw_input,py_xrange,py_repr,py_breakpoint,py_min,py_max,_namedtuple_of,reveal_type,reveal_locals,MatchError,CoconutWarning,__fmap__,__iter_getitem__,data,match,case,cases,where,addpattern,then,operator,type,copyclosure,λ
+Platform: UNKNOWN
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development
+Classifier: Topic :: Software Development :: Code Generators
+Classifier: Topic :: Software Development :: Compilers
+Classifier: Topic :: Software Development :: Interpreters
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Utilities
+Classifier: Environment :: Console
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 2.6
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.2
+Classifier: Programming Language :: Python :: 3.3
+Classifier: Programming Language :: Python :: 3.4
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Other
+Classifier: Programming Language :: Other Scripting Engines
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Framework :: IPython
+Classifier: Framework :: Jupyter
+Classifier: Typing :: Typed
+Provides-Extra: kernel
+Provides-Extra: watch
+Provides-Extra: mypy
+Provides-Extra: pyright
+Provides-Extra: xonsh
+Provides-Extra: numpy
+Provides-Extra: jupyter
+Provides-Extra: jupyterlab
+Provides-Extra: jupytext
+Provides-Extra: all
+Provides-Extra: ipython
+Provides-Extra: docs
+Provides-Extra: tests
+Provides-Extra: dev

{coconut-develop-3.1.2.post0.dev1 → coconut-develop-3.1.2.post0.dev2}/coconut/compiler/compiler.py

@@ -37,11 +37,11 @@ from contextlib import contextmanager
 from functools import partial, wraps
 from collections import defaultdict
 from threading import Lock
+from copy import copy
 
 from coconut._pyparsing import (
     USE_COMPUTATION_GRAPH,
     USE_CACHE,
-    USE_LINE_BY_LINE,
     ParseBaseException,
     ParseResults,
     col as getcol,
@@ -108,6 +108,7 @@ from coconut.util import (
     assert_remove_suffix,
     dictset,
     noop_ctx,
+    create_method,
 )
 from coconut.exceptions import (
     CoconutException,
@@ -155,6 +156,7 @@ from coconut.compiler.util import (
     match_in,
     transform,
     parse,
+    cached_parse,
     get_target_info_smart,
     split_leading_comments,
     compile_regex,
@@ -404,6 +406,7 @@ class Compiler(Grammar, pickleable_obj):
     """The Coconut compiler."""
     lock = Lock()
     current_compiler = None
+    computation_graph_caches = defaultdict(dict)
 
     preprocs = [
         lambda self: self.prepare,
@@ -428,7 +431,7 @@ class Compiler(Grammar, pickleable_obj):
     ]
 
     def __init__(self, *args, **kwargs):
-        """Creates a new compiler with the given parsing parameters."""
+        """Create a new compiler with the given parsing parameters."""
         self.setup(*args, **kwargs)
         self.reset()
 
@@ -464,7 +467,7 @@ class Compiler(Grammar, pickleable_obj):
         self.no_wrap = no_wrap
 
     def __reduce__(self):
-        """Return pickling information."""
+        """Get pickling information."""
         return (self.__class__, (self.target, self.strict, self.minify, self.line_numbers, self.keep_lines, self.no_tco, self.no_wrap))
 
     def get_cli_args(self):
@@ -484,12 +487,16 @@ class Compiler(Grammar, pickleable_obj):
             args.append("--no-wrap-types")
         return args
 
-    def __copy__(self):
-        """Create a new, blank copy of the compiler."""
-        cls, args = self.__reduce__()
-        return cls(*args)
-
-    copy = __copy__
+    def copy(self, snapshot=False):
+        """Create a blank copy of the compiler, or a non-blank copy if snapshot=True."""
+        if snapshot:
+            old_reduce, self.__reduce__ = self.__reduce__, create_method(object.__reduce__, self, self.__class__)
+            try:
+                return copy(self)
+            finally:
+                self.__reduce__ = old_reduce
+        else:
+            return copy(self)
 
     def genhash(self, code, package_level=-1):
         """Generate a hash from code."""
@@ -637,6 +644,8 @@ class Compiler(Grammar, pickleable_obj):
             if trim_arity:
                 self_method = _trim_arity(self_method)
             return self_method(original, loc, tokens_or_item)
+        if kwargs:
+            method.__name__ = py_str(method.__name__ + "$(" + ", ".join(str(k) + "=" + repr(v) for k, v in kwargs.items()) + ")")
         internal_assert(
             hasattr(cls_method, "ignore_arguments") is hasattr(method, "ignore_arguments")
             and hasattr(cls_method, "ignore_no_tokens") is hasattr(method, "ignore_no_tokens")
@@ -1079,18 +1088,20 @@ class Compiler(Grammar, pickleable_obj):
         """Wrap a comment."""
         return "#" + self.add_ref("comment", text) + unwrapper
 
-    def wrap_error(self, error):
+    def wrap_error(self, error_maker):
         """Create a symbol that will raise the given error in postprocessing."""
-        return errwrapper + self.add_ref("error", error) + unwrapper
+        return errwrapper + self.add_ref("error_maker", error_maker) + unwrapper
 
-    def raise_or_wrap_error(self, error):
-        """Raise if USE_COMPUTATION_GRAPH else wrap."""
+    def raise_or_wrap_error(self, *args, **kwargs):
+        """Raise or defer if USE_COMPUTATION_GRAPH else wrap."""
+        error_maker = partial(self.make_err, *args, **kwargs)
         if not USE_COMPUTATION_GRAPH:
-            return self.wrap_error(error)
+            return self.wrap_error(error_maker)
+        # differently-ordered any ofs can push these errors earlier than they should be, requiring us to defer them
         elif use_adaptive_any_of or reverse_any_of:
-            return ExceptionNode(error)
+            return ExceptionNode(error_maker)
         else:
-            raise error
+            raise error_maker()
 
     def type_ignore_comment(self):
         """Get a "type: ignore" comment."""
@@ -1357,7 +1368,7 @@ class Compiler(Grammar, pickleable_obj):
 
     def parse_line_by_line(self, init_parser, line_parser, original):
         """Apply init_parser then line_parser repeatedly."""
-        if not USE_LINE_BY_LINE:
+        if not USE_COMPUTATION_GRAPH:
             raise CoconutException("line-by-line parsing not supported", extra="run 'pip install --upgrade cPyparsing' to fix")
         with ComputationNode.using_overrides():
             ComputationNode.override_original = original
@@ -1367,14 +1378,20 @@ class Compiler(Grammar, pickleable_obj):
             while cur_loc < len(original):
                 self.remaining_original = original[cur_loc:]
                 ComputationNode.add_to_loc = cur_loc
-                results = parse(init_parser if init else line_parser, self.remaining_original, inner=False)
+                parser = init_parser if init else line_parser
+                results = cached_parse(
+                    self.computation_graph_caches[("line_by_line", parser)],
+                    parser,
+                    self.remaining_original,
+                    inner=False,
+                )
                 if len(results) == 1:
                     got_loc, = results
                 else:
                     got, got_loc = results
                     out_parts.append(got)
                 got_loc = int(got_loc)
-                internal_assert(got_loc >= cur_loc and (init or got_loc > cur_loc), "invalid line by line parse", (cur_loc, results), extra=lambda: "in: " + repr(self.remaining_original.split("\n", 1)[0]))
+                internal_assert(got_loc >= cur_loc and (init or got_loc > cur_loc), "invalid line by line parse", (cur_loc, got_loc, results), extra=lambda: "in: " + repr(self.remaining_original.split("\n", 1)[0]))
                 cur_loc = got_loc
                 init = False
         return "".join(out_parts)
@@ -2729,7 +2746,7 @@ else:
                 pre_err_line, err_line = raw_line.split(errwrapper, 1)
                 err_ref, post_err_line = err_line.split(unwrapper, 1)
                 if not ignore_errors:
-                    raise self.get_ref("error", err_ref)
+                    raise self.get_ref("error_maker", err_ref)()
                 raw_line = pre_err_line + " " + post_err_line
 
             # look for functions
@@ -4877,6 +4894,7 @@ class {protocol_var}({tokens}, _coconut.typing.Protocol): pass
 
         where_assigns = self.current_parsing_context("where")["assigns"]
         internal_assert(lambda: where_assigns is not None, "missing where_assigns")
+        print(where_assigns)
 
         where_init = "".join(body_stmts)
         where_final = main_stmt + "\n"
@@ -4976,7 +4994,8 @@ class {protocol_var}({tokens}, _coconut.typing.Protocol): pass
         if self.disable_name_check:
             return name
 
-        if assign:
+        # register non-mid-expression variable assignments inside of where statements for later mangling
+        if assign and not expr_setname:
             where_context = self.current_parsing_context("where")
             if where_context is not None:
                 where_assigns = where_context["assigns"]
@@ -5007,13 +5026,11 @@ class {protocol_var}({tokens}, _coconut.typing.Protocol): pass
                     if typevar_info["typevar_locs"].get(name, None) != loc:
                         if assign:
                             return self.raise_or_wrap_error(
-                                self.make_err(
-                                    CoconutSyntaxError,
-                                    "cannot reassign type variable '{name}'".format(name=name),
-                                    original,
-                                    loc,
-                                    extra="use explicit '\\{name}' syntax if intended".format(name=name),
-                                ),
+                                CoconutSyntaxError,
+                                "cannot reassign type variable '{name}'".format(name=name),
+                                original,
+                                loc,
+                                extra="use explicit '\\{name}' syntax if intended".format(name=name),
                             )
                         return typevars[name]
 
@@ -5044,13 +5061,11 @@ class {protocol_var}({tokens}, _coconut.typing.Protocol): pass
                 return name
             elif assign:
                 return self.raise_or_wrap_error(
-                    self.make_err(
-                        CoconutTargetError,
-                        "found Python-3-only assignment to 'exec' as a variable name",
-                        original,
-                        loc,
-                        target="3",
-                    ),
+                    CoconutTargetError,
+                    "found Python-3-only assignment to 'exec' as a variable name",
+                    original,
+                    loc,
+                    target="3",
                 )
             else:
                 return "_coconut_exec"
@@ -5063,12 +5078,10 @@ class {protocol_var}({tokens}, _coconut.typing.Protocol): pass
                 return name
         elif not escaped and name.startswith(reserved_prefix) and name not in self.operators:
             return self.raise_or_wrap_error(
-                self.make_err(
-                    CoconutSyntaxError,
-                    "variable names cannot start with reserved prefix '{prefix}' (use explicit '\\{name}' syntax if intending to access Coconut internals)".format(prefix=reserved_prefix, name=name),
-                    original,
-                    loc,
-                ),
+                CoconutSyntaxError,
+                "variable names cannot start with reserved prefix '{prefix}' (use explicit '\\{name}' syntax if intending to access Coconut internals)".format(prefix=reserved_prefix, name=name),
+                original,
+                loc,
             )
         else:
             return name
@@ -5091,7 +5104,7 @@ class {protocol_var}({tokens}, _coconut.typing.Protocol): pass
             else:
                 if always_warn:
                     kwargs["extra"] = "remove --strict to downgrade to a warning"
-                return self.raise_or_wrap_error(self.make_err(CoconutStyleError, message, original, loc, **kwargs))
+                return self.raise_or_wrap_error(CoconutStyleError, message, original, loc, **kwargs)
         elif always_warn:
             self.syntax_warning(message, original, loc)
         return tokens[0]
@@ -5132,13 +5145,13 @@ class {protocol_var}({tokens}, _coconut.typing.Protocol): pass
         self.internal_assert(len(tokens) == 1, original, loc, "invalid " + name + " tokens", tokens)
         version_info = get_target_info(version)
         if self.target_info < version_info:
-            return self.raise_or_wrap_error(self.make_err(
+            return self.raise_or_wrap_error(
                 CoconutTargetError,
                 "found Python " + ".".join(str(v) for v in version_info) + " " + name,
                 original,
                 loc,
                 target=version,
-            ))
+            )
         else:
             return tokens[0]
 

{coconut-develop-3.1.2.post0.dev1 → coconut-develop-3.1.2.post0.dev2}/coconut/compiler/grammar.py

@@ -2616,7 +2616,6 @@ class Grammar(object):
             decoratable_data_stmt,
             match_stmt,
             passthrough_stmt,
-            where_stmt,
         )
 
         flow_stmt = any_of(
@@ -2661,8 +2660,8 @@ class Grammar(object):
         stmt <<= final(
             compound_stmt
             | simple_stmt  # includes destructuring
-            # must be after destructuring due to ambiguity
-            | cases_stmt
+            | cases_stmt  # must be after destructuring due to ambiguity
+            | where_stmt  # slows down parsing when put before simple_stmt
             # at the very end as a fallback case for the anything parser
             | anything_stmt
         )
@@ -2781,8 +2780,6 @@ class Grammar(object):
                 rparen,
             ) + end_marker,
             tco_return_handle,
-            # this is the root in what it's used for, so might as well evaluate greedily
-            greedy=True,
         ))
 
         rest_of_lambda = Forward()

{coconut-develop-3.1.2.post0.dev1 → coconut-develop-3.1.2.post0.dev2}/coconut/compiler/util.py

@@ -199,6 +199,7 @@ def evaluate_tokens(tokens, **kwargs):
 
     if not USE_COMPUTATION_GRAPH:
         return tokens
+    final_evaluate_tokens.enabled = True  # special variable used by cached_parse
 
     if isinstance(tokens, ParseResults):
 
@@ -264,7 +265,7 @@ def evaluate_tokens(tokens, **kwargs):
         elif isinstance(tokens, ComputationNode):
             result = tokens.evaluate()
             if is_final and isinstance(result, ExceptionNode):
-                raise result.exception
+                result.evaluate()
             elif isinstance(result, ParseResults):
                 return make_modified_tokens(result, cls=MergeNode)
             elif isinstance(result, list):
@@ -285,7 +286,7 @@ def evaluate_tokens(tokens, **kwargs):
 
         elif isinstance(tokens, ExceptionNode):
             if is_final:
-                raise tokens.exception
+                tokens.evaluate()
             return tokens
 
         elif isinstance(tokens, DeferredNode):
@@ -320,9 +321,12 @@ def build_new_toks_for(tokens, new_toklist, unchanged=False):
     return new_toklist
 
 
+cached_trim_arity = memoize()(_trim_arity)
+
+
 class ComputationNode(object):
     """A single node in the computation graph."""
-    __slots__ = ("action", "original", "loc", "tokens")
+    __slots__ = ("action", "original", "loc", "tokens", "trim_arity")
     pprinting = False
     override_original = None
     add_to_loc = 0
@@ -338,7 +342,7 @@ class ComputationNode(object):
             cls.override_original = override_original
             cls.add_to_loc = add_to_loc
 
-    def __new__(cls, action, original, loc, tokens, ignore_no_tokens=False, ignore_one_token=False, greedy=False, trim_arity=True):
+    def __new__(cls, action, original, loc, tokens, trim_arity=True, ignore_no_tokens=False, ignore_one_token=False, greedy=False):
         """Create a ComputionNode to return from a parse action.
 
         If ignore_no_tokens, then don't call the action if there are no tokens.
@@ -349,18 +353,20 @@ class ComputationNode(object):
             return build_new_toks_for(tokens, tokens, unchanged=True)
         else:
             self = super(ComputationNode, cls).__new__(cls)
-            if trim_arity:
-                self.action = _trim_arity(action)
-            else:
-                self.action = action
-            self.original = original if self.override_original is None else self.override_original
-            self.loc = self.add_to_loc + loc
+            self.action = action
+            self.original = original
+            self.loc = loc
             self.tokens = tokens
+            self.trim_arity = trim_arity
             if greedy:
                 return self.evaluate()
             else:
                 return self
 
+    def __reduce__(self):
+        """Get pickling information."""
+        return (self.__class__, (self.action, self.original, self.loc, self.tokens, self.trim_arity))
+
     @property
     def name(self):
         """Get the name of the action."""
@@ -374,15 +380,25 @@ class ComputationNode(object):
         # note that this should never cache, since if a greedy Wrap that doesn't add to the packrat context
         #  hits the cache, it'll get the same ComputationNode object, but since it's greedy that object needs
         #  to actually be reevaluated
+        if logger.tracing and not final_evaluate_tokens.enabled:
+            logger.log_tag("cached_parse invalidated by", self)
+
+        if self.trim_arity:
+            using_action = cached_trim_arity(self.action)
+        else:
+            using_action = self.action
+        using_original = self.original if self.override_original is None else self.override_original
+        using_loc = self.loc + self.add_to_loc
         evaluated_toks = evaluate_tokens(self.tokens)
+
         if logger.tracing:  # avoid the overhead of the call if not tracing
-            logger.log_trace(self.name, self.original, self.loc, evaluated_toks, self.tokens)
+            logger.log_trace(self.name, using_original, using_loc, evaluated_toks, self.tokens)
         if isinstance(evaluated_toks, ExceptionNode):
             return evaluated_toks  # short-circuit if we got an ExceptionNode
         try:
-            result = self.action(
-                self.original,
-                self.loc,
+            result = using_action(
+                using_original,
+                using_loc,
                 evaluated_toks,
             )
         except CoconutException:
@@ -395,6 +411,7 @@ class ComputationNode(object):
                 embed(depth=2)
             else:
                 raise error
+
         out = build_new_toks_for(evaluated_toks, result)
         if logger.tracing:  # avoid the overhead if not tracing
             dropped_keys = set(self.tokens._ParseResults__tokdict.keys())
@@ -431,12 +448,16 @@ class DeferredNode(object):
 
 class ExceptionNode(object):
     """A node in the computation graph that stores an exception that will be raised upon final evaluation."""
-    __slots__ = ("exception",)
+    __slots__ = ("exception_maker",)
 
-    def __init__(self, exception):
+    def __init__(self, exception_maker):
         if not USE_COMPUTATION_GRAPH:
-            raise exception
-        self.exception = exception
+            raise exception_maker()
+        self.exception_maker = exception_maker
+
+    def evaluate(self):
+        """Raise the stored exception."""
+        raise self.exception_maker()
 
 
 class CombineToNode(Combine):
@@ -523,12 +544,17 @@ def attach(item, action, ignore_no_tokens=None, ignore_one_token=None, ignore_ar
 
 def final_evaluate_tokens(tokens):
     """Same as evaluate_tokens but should only be used once a parse is assured."""
+    if not final_evaluate_tokens.enabled:  # handled by cached_parse
+        return tokens
     result = evaluate_tokens(tokens, is_final=True)
     # clear packrat cache after evaluating tokens so error creation gets to see the cache
     clear_packrat_cache()
     return result
 
 
+final_evaluate_tokens.enabled = True
+
+
 def final(item):
     """Collapse the computation graph upon parsing the given item."""
     # evaluate_tokens expects a computation graph, so we just call add_action directly
@@ -674,17 +700,66 @@ def parse(grammar, text, inner=None, eval_parse_tree=True):
         return result
 
 
-def try_parse(grammar, text, inner=None, eval_parse_tree=True):
+def cached_parse(computation_graph_cache, grammar, text, inner=None, eval_parse_tree=True):
+    """Version of parse that caches the result when it's a pure ComputationNode."""
+    if not CPYPARSING:  # caching is only supported on cPyparsing
+        return parse(grammar, text, inner)
+
+    for (prefix, is_at_end), tokens in computation_graph_cache.items():
+        # the assumption here is that if the prior parse didn't make it to the end,
+        #  then we can freely change the text after the end of where it made it,
+        #  but if it did make it to the end, then we can't add more text after that
+        if (
+            is_at_end and text == prefix
+            or not is_at_end and text.startswith(prefix)
+        ):
+            if DEVELOP:
+                logger.record_stat("cached_parse", True)
+                logger.log_tag("cached_parse hit", (prefix, text[len(prefix):], tokens))
+            break
+    else:  # no break
+        # disable token evaluation by final() to allow us to get a ComputationNode;
+        #  this makes long parses very slow, however, so once a greedy parse action
+        #  is hit such that evaluate_tokens gets called, evaluate_tokens will set
+        #  final_evaluate_tokens.enabled back to True, which speeds up the rest of the
+        #  parse and tells us that something greedy happened so we can't cache
+        final_evaluate_tokens.enabled = False
+        try:
+            with parsing_context(inner):
+                loc, tokens = prep_grammar(grammar, for_scan=False).parseString(text, returnLoc=True)
+            if not final_evaluate_tokens.enabled:
+                prefix = text[:loc + 1]
+                is_at_end = loc >= len(text)
+                computation_graph_cache[(prefix, is_at_end)] = tokens
+        finally:
+            if DEVELOP:
+                logger.record_stat("cached_parse", False)
+                logger.log_tag(
+                    "cached_parse miss " + ("-> stored" if not final_evaluate_tokens.enabled else "(not stored)"),
+                    text,
+                    multiline=True,
+                )
+            final_evaluate_tokens.enabled = True
+
+    if eval_parse_tree:
+        tokens = unpack(tokens)
+    return tokens
+
+
+def try_parse(grammar, text, inner=None, eval_parse_tree=True, computation_graph_cache=None):
     """Attempt to parse text using grammar else None."""
     try:
-        return parse(grammar, text, inner, eval_parse_tree)
+        if computation_graph_cache is None:
+            return parse(grammar, text, inner, eval_parse_tree)
+        else:
+            return cached_parse(computation_graph_cache, grammar, text, inner, eval_parse_tree)
     except ParseBaseException:
         return None
 
 
-def does_parse(grammar, text, inner=None):
+def does_parse(grammar, text, inner=None, **kwargs):
     """Determine if text can be parsed using grammar."""
-    return try_parse(grammar, text, inner, eval_parse_tree=False)
+    return try_parse(grammar, text, inner, eval_parse_tree=False, **kwargs)
 
 
 def all_matches(grammar, text, inner=None, eval_parse_tree=True):
@@ -1370,6 +1445,8 @@ class Wrap(ParseElementEnhance):
                     with self.wrapped_context():
                         parse_loc, tokens = super(Wrap, self).parseImpl(original, loc, *args, **kwargs)
                         if self.greedy:
+                            if logger.tracing and not final_evaluate_tokens.enabled:
+                                logger.log_tag("cached_parse invalidated by", self)
                             tokens = evaluate_tokens(tokens)
                 if reparse and parse_loc is None:
                     raise CoconutInternalException("illegal double reparse in", self)

{coconut-develop-3.1.2.post0.dev1 → coconut-develop-3.1.2.post0.dev2}/coconut/constants.py

@@ -1050,7 +1050,7 @@ all_reqs = {
 
 # min versions are inclusive
 unpinned_min_versions = {
-    "cPyparsing": (2, 4, 7, 2, 4, 0),
+    "cPyparsing": (2, 4, 7, 2, 4, 1),
     ("pre-commit", "py3"): (3,),
     ("psutil", "py>=27"): (6,),
     "jupyter": (1, 1),

coconut-develop-3.1.2.post0.dev2/coconut/icoconut/coconut/kernel.json

@@ -0,0 +1,11 @@
+{
+ "argv": [
+  "python", 
+  "-m", 
+  "coconut.icoconut", 
+  "-f", 
+  "{connection_file}"
+ ], 
+ "display_name": "Coconut", 
+ "language": "coconut"
+}

{coconut-develop-3.1.2.post0.dev1 → coconut-develop-3.1.2.post0.dev2}/coconut/root.py

@@ -26,7 +26,7 @@ import sys as _coconut_sys
 VERSION = "3.1.2"
 VERSION_NAME = None
 # False for release, int >= 1 for develop
-DEVELOP = 1
+DEVELOP = 2
 ALPHA = False  # for pre releases rather than post releases
 
 assert DEVELOP is False or DEVELOP >= 1, "DEVELOP must be False or an int >= 1"

{coconut-develop-3.1.2.post0.dev1 → coconut-develop-3.1.2.post0.dev2}/coconut/terminal.py

@@ -561,7 +561,10 @@ class Logger(object):
         return item
 
     def record_stat(self, stat_name, stat_bool):
-        """Record the given boolean statistic for the given stat_name."""
+        """Record the given boolean statistic for the given stat_name.
+
+        All stats recorded here must have some printing logic added to gather_parsing_stats or log_compiler_stats.
+        Printed stats should also be added to the regex in the Makefile for getting non-informational lines."""
         self.recorded_stats[stat_name][stat_bool] += 1
 
     @contextmanager
@@ -569,6 +572,7 @@ class Logger(object):
         """Times parsing if --verbose."""
         if self.verbose:
             self.recorded_stats.pop("adaptive", None)
+            self.recorded_stats.pop("cached_parse", None)
             start_time = get_clock_time()
             try:
                 yield
@@ -584,6 +588,9 @@ class Logger(object):
                 if "adaptive" in self.recorded_stats:
                     failures, successes = self.recorded_stats["adaptive"]
                     self.printlog("\tAdaptive parsing stats:", successes, "successes;", failures, "failures")
+                if "cached_parse" in self.recorded_stats:
+                    misses, hits = self.recorded_stats["cached_parse"]
+                    self.printlog("\tComputation graph cache stats:", hits, "hits;", misses, "misses")
                 if maybe_make_safe is not None:
                     hits, misses = maybe_make_safe.stats
                     self.printlog("\tErrorless parsing stats:", hits, "errorless;", misses, "with errors")
@@ -595,10 +602,9 @@ class Logger(object):
         if self.verbose:
             self.log("Grammar init time: " + str(comp.grammar_init_time) + " secs / Total init time: " + str(get_clock_time() - first_import_time) + " secs")
             for stat_name, (no_copy, yes_copy) in self.recorded_stats.items():
-                if not stat_name.startswith("maybe_copy_"):
-                    continue
-                name = assert_remove_prefix(stat_name, "maybe_copy_")
-                self.printlog("\tGrammar copying stats (" + name + "):", no_copy, "not copied;", yes_copy, "copied")
+                if stat_name.startswith("maybe_copy_"):
+                    name = assert_remove_prefix(stat_name, "maybe_copy_")
+                    self.printlog("\tGrammar copying stats (" + name + "):", no_copy, "not copied;", yes_copy, "copied")
 
     total_block_time = defaultdict(int)
 

{coconut-develop-3.1.2.post0.dev1 → coconut-develop-3.1.2.post0.dev2}/coconut/util.py

@@ -107,6 +107,14 @@ class const(pickleable_obj):
         return self.value
 
 
+def create_method(func, obj, objtype):
+    """Universally create a new method object."""
+    if PY2:
+        return MethodType(func, obj, objtype)
+    else:
+        return MethodType(func, obj)
+
+
 class override(pickleable_obj):
     """Implementation of Coconut's @override for use within Coconut."""
     __slots__ = ("func",)
@@ -129,10 +137,7 @@ class override(pickleable_obj):
                 return self.func.__get__(obj, objtype)
         if obj is None:
             return self.func
-        if PY2:
-            return MethodType(self.func, obj, objtype)
-        else:
-            return MethodType(self.func, obj)
+        return create_method(self.func, obj, objtype)
 
     def __set_name__(self, obj, name):
         if not hasattr(super(obj, obj), name):

coconut-develop-3.1.2.post0.dev1/PKG-INFO

@@ -1,141 +0,0 @@
-Metadata-Version: 2.1
-Name: coconut-develop
-Version: 3.1.2.post0.dev1
-Summary: Simple, elegant, Pythonic functional programming.
-Home-page: http://coconut-lang.org
-Author: Evan Hubinger
-Author-email: evanjhub@gmail.com
-License: Apache 2.0
-Keywords: functional,programming,language,compiler,pattern,pattern-matching,algebraic,data type,data types,lambda,lambdas,lazy,evaluation,lazy list,lazy lists,tail,recursion,call,recursive,recursive_iterator,infix,function,composition,compose,partial,application,currying,curry,pipeline,pipe,unicode,operator,operators,frozenset,literal,syntax,destructuring,assignment,fold,datamaker,prepattern,iterator,generator,none,coalesce,coalescing,statement,lru_cache,memoization,backport,typing,embed,PEP 622,overrides,islice,itertools,functools,TYPE_CHECKING,Expected,breakpoint,help,reduce,takewhile,dropwhile,tee,count,makedata,consume,process_map,thread_map,addpattern,recursive_generator,fmap,starmap,reiterable,scan,groupsof,memoize,zip_longest,override,flatten,ident,call,safe_call,flip,const,lift,lift_apart,all_equal,collectby,mapreduce,multi_enumerate,cartesian_product,multiset,cycle,windowsof,and_then,and_then_await,async_map,py_chr,py_dict,py_hex,py_input,py_int,py_map,py_object,py_oct,py_open,py_print,py_range,py_str,py_super,py_zip,py_filter,py_reversed,py_enumerate,py_raw_input,py_xrange,py_repr,py_breakpoint,py_min,py_max,_namedtuple_of,reveal_type,reveal_locals,MatchError,CoconutWarning,__fmap__,__iter_getitem__,data,match,case,cases,where,addpattern,then,operator,type,copyclosure,λ
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: License :: OSI Approved :: Apache Software License
-Classifier: Intended Audience :: Developers
-Classifier: Topic :: Software Development
-Classifier: Topic :: Software Development :: Code Generators
-Classifier: Topic :: Software Development :: Compilers
-Classifier: Topic :: Software Development :: Interpreters
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Classifier: Topic :: Utilities
-Classifier: Environment :: Console
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 2
-Classifier: Programming Language :: Python :: 2.6
-Classifier: Programming Language :: Python :: 2.7
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.2
-Classifier: Programming Language :: Python :: 3.3
-Classifier: Programming Language :: Python :: 3.4
-Classifier: Programming Language :: Python :: 3.5
-Classifier: Programming Language :: Python :: 3.6
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Other
-Classifier: Programming Language :: Other Scripting Engines
-Classifier: Programming Language :: Python :: Implementation :: CPython
-Classifier: Programming Language :: Python :: Implementation :: PyPy
-Classifier: Framework :: IPython
-Classifier: Framework :: Jupyter
-Classifier: Typing :: Typed
-Provides-Extra: kernel
-Provides-Extra: watch
-Provides-Extra: mypy
-Provides-Extra: pyright
-Provides-Extra: xonsh
-Provides-Extra: numpy
-Provides-Extra: jupyter
-Provides-Extra: jupyterlab
-Provides-Extra: jupytext
-Provides-Extra: all
-Provides-Extra: ipython
-Provides-Extra: docs
-Provides-Extra: tests
-Provides-Extra: dev
-License-File: LICENSE.txt
-
-|logo| Coconut
-==============
-
-..
-    <insert toctree here>
-
-.. |logo| image:: https://github.com/evhub/coconut/raw/gh-pages/favicon-32x32.png
-
-.. image:: https://opencollective.com/coconut/backers/badge.svg
-    :alt: Backers on Open Collective
-    :target: #backers
-.. image:: https://opencollective.com/coconut/sponsors/badge.svg
-    :alt: Sponsors on Open Collective
-    :target: #sponsors
-.. image:: https://badges.gitter.im/evhub/coconut.svg
-    :alt: Join the chat at https://gitter.im/evhub/coconut
-    :target: https://gitter.im/evhub/coconut?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge
-
-Coconut (`coconut-lang.org`__) is a variant of Python_ that **adds on top of Python syntax** new features for simple, elegant, Pythonic **functional programming**.
-
-__ Coconut_
-.. _Coconut: http://coconut-lang.org/
-
-Coconut is developed on GitHub_ and hosted on PyPI_. Installing Coconut is as easy as opening a command prompt and entering::
-
-    pip install coconut
-
-To help you get started, check out these links for more information about Coconut:
-
-- Tutorial_: If you're new to Coconut, a good place to start is Coconut's **tutorial**.
-- Documentation_: If you're looking for info about a specific feature, check out Coconut's **documentation**.
-- `Online Interpreter`_: If you want to try Coconut in your browser, check out Coconut's **online interpreter**.
-- FAQ_: If you have general questions about Coconut—like who Coconut is built for and whether or not you should use it—Coconut's frequently asked questions are often the best place to start.
-- `Create a New Issue <https://github.com/evhub/coconut/issues/new>`_: If you're having a problem with Coconut, creating a new issue detailing the problem will allow it to be addressed as soon as possible.
-- Gitter_: For any questions, concerns, or comments about anything Coconut-related, ask around at Coconut's Gitter, a GitHub-integrated chat room for Coconut developers.
-- Releases_: Want to know what's been added in recent Coconut versions? Check out the release log for all the new features and fixes.
-
-.. _Python: https://www.python.org/
-.. _PyPI: https://pypi.python.org/pypi/coconut
-.. _Tutorial: http://coconut.readthedocs.io/en/latest/HELP.html
-.. _Documentation: http://coconut.readthedocs.io/en/latest/DOCS.html
-.. _`Online Interpreter`: https://cs121-team-panda.github.io/coconut-interpreter
-.. _FAQ: http://coconut.readthedocs.io/en/latest/FAQ.html
-.. _GitHub: https://github.com/evhub/coconut
-.. _Gitter: https://gitter.im/evhub/coconut
-.. _Releases: https://github.com/evhub/coconut/releases
-
-Credits
-+++++++
-
-Contributors
-------------
-
-This project exists thanks to all the people who contribute! `Become a contributor`__.
-
-.. image:: https://opencollective.com/coconut/contributors.svg?width=890&button=false
-    :target: https://github.com/evhub/coconut/graphs/contributors
-
-__ Contributor_
-.. _Contributor: http://coconut.readthedocs.io/en/develop/CONTRIBUTING.html
-
-Backers
--------
-
-Thank you to all our backers! `Become a backer`__.
-
-.. image:: https://opencollective.com/coconut/backers.svg?width=890
-    :target: https://opencollective.com/coconut#backers
-
-__ Backer_
-.. _Backer: https://opencollective.com/coconut#backer
-
-Sponsors
---------
-
-Support Coconut by becoming a sponsor. Your logo will show up here with a link to your website. `Become a sponsor`__.
-
-.. image:: https://opencollective.com/XX/sponsor/0/avatar.svg
-    :target: https://opencollective.com/coconut/sponsor/0/website
-
-__ Sponsor_
-.. _Sponsor: https://opencollective.com/coconut#sponsor

coconut-develop-3.1.2.post0.dev1/coconut/icoconut/coconut/kernel.json

@@ -1,11 +0,0 @@
-{
- "argv": [
-  "python",
-  "-m",
-  "coconut.icoconut",
-  "-f",
-  "{connection_file}"
- ],
- "display_name": "Coconut",
- "language": "coconut"
-}