coconut-develop 3.1.0.post0.dev11__tar.gz → 3.1.0.post0.dev12__tar.gz

{coconut_develop-3.1.0.post0.dev11 → coconut-develop-3.1.0.post0.dev12}/DOCS.md

@@ -336,6 +336,7 @@ If the `--strict` (`-s` for short) flag is enabled, Coconut will perform additio
 The style issues which will cause `--strict` to throw an error are:
 
 - mixing of tabs and spaces
+- use of `"hello" "world"` implicit string concatenation (use `+` instead for clarity; Coconut will compile the `+` away)
 - use of `from __future__` imports (Coconut does these automatically)
 - inheriting from `object` in classes (Coconut does this automatically)
 - semicolons at end of lines

coconut-develop-3.1.0.post0.dev12/PKG-INFO

@@ -0,0 +1,140 @@
+Metadata-Version: 2.1
+Name: coconut-develop
+Version: 3.1.0.post0.dev12
+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: 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.0.post0.dev11 → coconut-develop-3.1.0.post0.dev12}/coconut/_pyparsing.py

@@ -39,7 +39,6 @@ from coconut.constants import (
     min_versions,
     max_versions,
     pure_python_env_var,
-    enable_pyparsing_warnings,
     use_left_recursion_if_available,
     get_bool_env_var,
     use_computation_graph_env_var,
@@ -243,8 +242,9 @@ USE_COMPUTATION_GRAPH = get_bool_env_var(
     use_computation_graph_env_var,
     default=(
         not MODERN_PYPARSING  # not yet supported
-        # commented out to minimize memory footprint when running tests:
-        # and not PYPY  # experimentally determined
+        # technically PYPY is faster without the computation graph, but
+        #  it breaks some features and balloons the memory footprint
+        # and not PYPY
     ),
 )
 
@@ -265,7 +265,7 @@ else:
 
 maybe_make_safe = getattr(_pyparsing, "maybe_make_safe", None)
 
-if enable_pyparsing_warnings:
+if DEVELOP:
     if MODERN_PYPARSING:
         _pyparsing.enable_all_warnings()
     else:

{coconut_develop-3.1.0.post0.dev11 → coconut-develop-3.1.0.post0.dev12}/coconut/api.pyi

@@ -27,7 +27,9 @@ from coconut.command.command import Command
 
 class CoconutException(Exception):
     """Coconut Exception."""
-    ...
+
+    def syntax_err(self) -> SyntaxError:
+        ...
 
 #-----------------------------------------------------------------------------------------------------------------------
 # COMMAND:

coconut-develop-3.1.0.post0.dev12/coconut/command/resources/pyrightconfig.json

@@ -0,0 +1,7 @@
+{
+  "extraPaths": [
+    "C://Users/evanj/.coconut_stubs"
+  ],
+  "pythonVersion": "3.11",
+  "reportPossiblyUnboundVariable": false
+}

{coconut_develop-3.1.0.post0.dev11 → coconut-develop-3.1.0.post0.dev12}/coconut/compiler/compiler.py

@@ -813,6 +813,7 @@ class Compiler(Grammar, pickleable_obj):
         cls.unsafe_typedef_tuple <<= attach(cls.unsafe_typedef_tuple_ref, cls.method("unsafe_typedef_tuple_handle"))
         cls.impl_call <<= attach(cls.impl_call_ref, cls.method("impl_call_handle"))
         cls.protocol_intersect_expr <<= attach(cls.protocol_intersect_expr_ref, cls.method("protocol_intersect_expr_handle"))
+        cls.and_expr <<= attach(cls.and_expr_ref, cls.method("and_expr_handle"))
 
         # these handlers just do strict/target checking
         cls.u_string <<= attach(cls.u_string_ref, cls.method("u_string_check"))
@@ -4567,18 +4568,40 @@ async with {iter_item} as {temp_var}:
             loop=loop
         )
 
-    def string_atom_handle(self, tokens):
+    def string_atom_handle(self, original, loc, tokens, allow_silent_concat=False):
         """Handle concatenation of string literals."""
         internal_assert(len(tokens) >= 1, "invalid string literal tokens", tokens)
-        if any(s.endswith(")") for s in tokens):  # has .format() calls
-            return "(" + " + ".join(tokens) + ")"
-        elif any(s.startswith(("f", "rf")) for s in tokens):  # has f-strings
-            return " ".join(tokens)
+        if len(tokens) == 1:
+            return tokens[0]
         else:
-            return self.eval_now(" ".join(tokens))
+            if not allow_silent_concat:
+                self.strict_err_or_warn("found Python-style implicit string concatenation (use explicit '+' for clarity; Coconut will compile it away)", original, loc)
+            if any(s.endswith(")") for s in tokens):  # has .format() calls
+                # parens are necessary for string_atom_handle
+                return "(" + " + ".join(tokens) + ")"
+            elif any(s.startswith(("f", "rf")) for s in tokens):  # has f-strings
+                return " ".join(tokens)
+            else:
+                return self.eval_now(" ".join(tokens))
 
     string_atom_handle.ignore_one_token = True
 
+    def and_expr_handle(self, original, loc, tokens):
+        """Handle expressions that could be explicit string concatenation."""
+        item, labels = tokens[0]
+        out = [item]
+        all_items = [item]
+        is_str_concat = "IS_STR" in labels
+        for i in range(1, len(tokens), 2):
+            op, (item, labels) = tokens[i:i + 2]
+            out += [op, item]
+            all_items.append(item)
+            is_str_concat = is_str_concat and "IS_STR" in labels and op == "+"
+        if is_str_concat:
+            return self.string_atom_handle(original, loc, all_items, allow_silent_concat=True)
+        else:
+            return " ".join(out)
+
     def unsafe_typedef_tuple_handle(self, original, loc, tokens):
         """Handle Tuples in typedefs."""
         tuple_items = self.testlist_star_expr_handle(original, loc, tokens)
@@ -4595,6 +4618,8 @@ async with {iter_item} as {temp_var}:
                 out += [op, term]
         return " ".join(out)
 
+    term_handle.ignore_one_token = True
+
     def impl_call_handle(self, loc, tokens):
         """Process implicit function application or coefficient syntax."""
         internal_assert(len(tokens) >= 2, "invalid implicit call / coefficient tokens", tokens)

{coconut_develop-3.1.0.post0.dev11 → coconut-develop-3.1.0.post0.dev12}/coconut/compiler/grammar.py

@@ -119,6 +119,7 @@ from coconut.compiler.util import (
     using_fast_grammar_methods,
     disambiguate_literal,
     any_of,
+    add_labels,
 )
 
 
@@ -592,15 +593,6 @@ def join_match_funcdef(tokens):
     )
 
 
-def kwd_err_msg_handle(tokens):
-    """Handle keyword parse error messages."""
-    kwd, = tokens
-    if kwd == "def":
-        return "invalid function definition"
-    else:
-        return 'invalid use of the keyword "' + kwd + '"'
-
-
 def alt_ternary_handle(tokens):
     """Handle if ... then ... else ternary operator."""
     cond, if_true, if_false = tokens
@@ -1378,7 +1370,8 @@ class Grammar(object):
         # for known_atom, type should be known at compile time
         known_atom = (
             const_atom
-            | string_atom
+            # IS_STR is used by and_expr_handle
+            | string_atom("IS_STR")
             | list_item
             | dict_literal
             | dict_comp
@@ -1582,14 +1575,13 @@ class Grammar(object):
         # arith_expr = exprlist(term, addop)
         # shift_expr = exprlist(arith_expr, shift)
         # and_expr = exprlist(shift_expr, amp)
-        and_expr = exprlist(
-            term,
-            any_of(
-                addop,
-                shift,
-                amp,
-            ),
+        term_op = any_of(
+            addop,
+            shift,
+            amp,
         )
+        and_expr = Forward()
+        and_expr_ref = tokenlist(attach(term, add_labels), term_op, allow_trailing=False, suppress=False)
 
         protocol_intersect_expr = Forward()
         protocol_intersect_expr_ref = tokenlist(and_expr, amp_colon, allow_trailing=False)
@@ -2863,7 +2855,7 @@ class Grammar(object):
                 "misplaced '?' (naked '?' is only supported inside partial application arguments)",
             )
             | fixto(Optional(keyword("if") + skip_to_in_line(unsafe_equals)) + equals, "misplaced assignment (maybe should be '==')")
-            | attach(any_keyword_in(keyword_vars + reserved_vars), kwd_err_msg_handle)
+            | fixto(keyword("def"), "invalid function definition")
             | fixto(end_of_line, "misplaced newline (maybe missing ':')")
         )
 

{coconut_develop-3.1.0.post0.dev11 → coconut-develop-3.1.0.post0.dev12}/coconut/compiler/header.py

@@ -968,24 +968,24 @@ import os as _coconut_os
 _coconut_cached__coconut__ = _coconut_sys.modules.get({__coconut__})
 _coconut_file_dir = {coconut_file_dir}
 _coconut_pop_path = False
-if _coconut_cached__coconut__ is None or getattr(_coconut_cached__coconut__, "_coconut_header_info", None) != _coconut_header_info and _coconut_os.path.dirname(_coconut_cached__coconut__.__file__ or "") != _coconut_file_dir:
+if _coconut_cached__coconut__ is None or getattr(_coconut_cached__coconut__, "_coconut_header_info", None) != _coconut_header_info and _coconut_os.path.dirname(_coconut_cached__coconut__.__file__ or "") != _coconut_file_dir:  # type: ignore
     if _coconut_cached__coconut__ is not None:
         _coconut_sys.modules[{_coconut_cached__coconut__}] = _coconut_cached__coconut__
         del _coconut_sys.modules[{__coconut__}]
     _coconut_sys.path.insert(0, _coconut_file_dir)
     _coconut_pop_path = True
     _coconut_module_name = _coconut_os.path.splitext(_coconut_os.path.basename(_coconut_file_dir))[0]
-    if _coconut_module_name and _coconut_module_name[0].isalpha() and all(c.isalpha() or c.isdigit() for c in _coconut_module_name) and "__init__.py" in _coconut_os.listdir(_coconut_file_dir):
-        _coconut_full_module_name = str(_coconut_module_name + ".__coconut__")
+    if _coconut_module_name and _coconut_module_name[0].isalpha() and all(c.isalpha() or c.isdigit() for c in _coconut_module_name) and "__init__.py" in _coconut_os.listdir(_coconut_file_dir):  # type: ignore
+        _coconut_full_module_name = str(_coconut_module_name + ".__coconut__")  # type: ignore
         import __coconut__ as _coconut__coconut__
         _coconut__coconut__.__name__ = _coconut_full_module_name
-        for _coconut_v in vars(_coconut__coconut__).values():
-            if getattr(_coconut_v, "__module__", None) == {__coconut__}:
+        for _coconut_v in vars(_coconut__coconut__).values():  # type: ignore
+            if getattr(_coconut_v, "__module__", None) == {__coconut__}:  # type: ignore
                 try:
                     _coconut_v.__module__ = _coconut_full_module_name
                 except AttributeError:
-                    _coconut_v_type = type(_coconut_v)
-                    if getattr(_coconut_v_type, "__module__", None) == {__coconut__}:
+                    _coconut_v_type = type(_coconut_v)  # type: ignore
+                    if getattr(_coconut_v_type, "__module__", None) == {__coconut__}:  # type: ignore
                         _coconut_v_type.__module__ = _coconut_full_module_name
         _coconut_sys.modules[_coconut_full_module_name] = _coconut__coconut__
 from __coconut__ import *

{coconut_develop-3.1.0.post0.dev11 → coconut-develop-3.1.0.post0.dev12}/coconut/compiler/matching.py

@@ -639,6 +639,22 @@ if {assign_to} is _coconut_sentinel:
             elif "elem" in group:
                 group_type = "elem_matches"
                 group_contents = group
+            # must check for f_string before string, since a mixture will be tagged as both
+            elif "f_string" in group:
+                group_type = "f_string"
+                # f strings are always unicode
+                if seq_type is None:
+                    seq_type = '"'
+                elif seq_type != '"':
+                    raise CoconutDeferredSyntaxError("string literals and byte literals cannot be mixed in string patterns", self.loc)
+                for str_literal in group:
+                    if str_literal.startswith("b"):
+                        raise CoconutDeferredSyntaxError("string literals and byte literals cannot be mixed in string patterns", self.loc)
+                if len(group) == 1:
+                    str_item = group[0]
+                else:
+                    str_item = self.comp.string_atom_handle(self.original, self.loc, group, allow_silent_concat=True)
+                group_contents = (str_item, "_coconut.len(" + str_item + ")")
             elif "string" in group:
                 group_type = "string"
                 for str_literal in group:
@@ -655,16 +671,6 @@ if {assign_to} is _coconut_sentinel:
                 else:
                     str_item = self.comp.eval_now(" ".join(group))
                 group_contents = (str_item, len(self.comp.literal_eval(str_item)))
-            elif "f_string" in group:
-                group_type = "f_string"
-                # f strings are always unicode
-                if seq_type is None:
-                    seq_type = '"'
-                elif seq_type != '"':
-                    raise CoconutDeferredSyntaxError("string literals and byte literals cannot be mixed in string patterns", self.loc)
-                internal_assert(len(group) == 1, "invalid f string sequence match group", group)
-                str_item = group[0]
-                group_contents = (str_item, "_coconut.len(" + str_item + ")")
             else:
                 raise CoconutInternalException("invalid sequence match group", group)
             seq_groups.append((group_type, group_contents))
@@ -682,12 +688,12 @@ if {assign_to} is _coconut_sentinel:
                     bounded = False
                 elif gtype == "elem_matches":
                     min_len_int += len(gcontents)
-                elif gtype == "string":
-                    str_item, str_len = gcontents
-                    min_len_int += str_len
                 elif gtype == "f_string":
                     str_item, str_len = gcontents
                     min_len_strs.append(str_len)
+                elif gtype == "string":
+                    str_item, str_len = gcontents
+                    min_len_int += str_len
                 else:
                     raise CoconutInternalException("invalid sequence match group type", gtype)
             min_len = add_int_and_strs(min_len_int, min_len_strs)
@@ -711,17 +717,17 @@ if {assign_to} is _coconut_sentinel:
                     self.add_check("_coconut.len(" + head_var + ") == " + str(len(matches)))
                     self.match_all_in(matches, head_var)
             start_ind_int += len(matches)
+        elif seq_groups[0][0] == "f_string":
+            internal_assert(not iter_match, "cannot be both f string and iter match")
+            _, (str_item, str_len) = seq_groups.pop(0)
+            self.add_check(item + ".startswith(" + str_item + ")")
+            start_ind_strs.append(str_len)
         elif seq_groups[0][0] == "string":
             internal_assert(not iter_match, "cannot be both string and iter match")
             _, (str_item, str_len) = seq_groups.pop(0)
             if str_len > 0:
                 self.add_check(item + ".startswith(" + str_item + ")")
             start_ind_int += str_len
-        elif seq_groups[0][0] == "f_string":
-            internal_assert(not iter_match, "cannot be both f string and iter match")
-            _, (str_item, str_len) = seq_groups.pop(0)
-            self.add_check(item + ".startswith(" + str_item + ")")
-            start_ind_strs.append(str_len)
         if not seq_groups:
             return
         start_ind = add_int_and_strs(start_ind_int, start_ind_strs)
@@ -735,17 +741,17 @@ if {assign_to} is _coconut_sentinel:
             for i, match in enumerate(matches):
                 self.match(match, item + "[-" + str(len(matches) - i) + "]")
             last_ind_int -= len(matches)
+        elif seq_groups[-1][0] == "f_string":
+            internal_assert(not iter_match, "cannot be both f string and iter match")
+            _, (str_item, str_len) = seq_groups.pop()
+            self.add_check(item + ".endswith(" + str_item + ")")
+            last_ind_strs.append("-" + str_len)
         elif seq_groups[-1][0] == "string":
             internal_assert(not iter_match, "cannot be both string and iter match")
             _, (str_item, str_len) = seq_groups.pop()
             if str_len > 0:
                 self.add_check(item + ".endswith(" + str_item + ")")
             last_ind_int -= str_len
-        elif seq_groups[-1][0] == "f_string":
-            internal_assert(not iter_match, "cannot be both f string and iter match")
-            _, (str_item, str_len) = seq_groups.pop()
-            self.add_check(item + ".endswith(" + str_item + ")")
-            last_ind_strs.append("-" + str_len)
         if not seq_groups:
             return
         last_ind = add_int_and_strs(last_ind_int, last_ind_strs)