coconut-develop 3.1.2.post0.dev11__tar.gz → 3.2.0.post0.dev2__tar.gz

{coconut_develop-3.1.2.post0.dev11 → coconut_develop-3.2.0.post0.dev2}/.claude/CLAUDE.md

@@ -75,3 +75,17 @@ To add tests: write Coconut code with `assert` statements in the appropriate `.c
 ## Branches
 - `master` - Stable releases
 - `develop` - Active development (default branch for contributions)
+
+## Debugging GitHub Actions
+
+### Viewing Logs for a Specific Job
+
+When investigating a failed GitHub Actions job, use the GitHub API directly:
+
+```bash
+gh api repos/evhub/coconut/actions/jobs/{job_id}/logs
+```
+
+Replace `{job_id}` with the job ID from the URL (e.g., for `.../job/59132870840`, use `59132870840`).
+
+**Note:** The more common `gh run view {run_id} --log-failed` command doesn't work if the overall run is still in progress, even if the specific job you want has already completed. Using the API directly bypasses this limitation.

{coconut_develop-3.1.2.post0.dev11 → coconut_develop-3.2.0.post0.dev2}/.claude/settings.local.json

@@ -1,18 +1,25 @@
 {
   "permissions": {
     "allow": [
+      "WebSearch",
       "Bash(cat:*)",
+      "Bash(cd:*)",
+      "Bash(ls:*)",
+      "Bash(echo:*)",
+      "Bash(grep:*)",
+      "Bash(find:*)",
       "Bash(python:*)",
-      "Bash(xonsh:*)",
       "Bash(gh:*)",
       "Bash(pip:*)",
+      "Bash(conda:*)",
+      "Bash(xonsh:*)",
       "Bash(make test-tests:*)",
-      "WebSearch",
       "WebFetch(domain:coconut.readthedocs.io)",
       "WebFetch(domain:github.com)",
       "WebFetch(domain:peps.python.org)",
       "WebFetch(domain:pypi.org)",
-      "WebFetch(domain:discuss.python.org)"
+      "WebFetch(domain:discuss.python.org)",
+      "WebFetch(domain:doc.pypy.org)"
     ]
   }
 }

{coconut_develop-3.1.2.post0.dev11 → coconut_develop-3.2.0.post0.dev2}/DOCS.md

@@ -1593,6 +1593,76 @@ data namedpt(name `isinstance` str, x `isinstance` int, y `isinstance` int):
 _Can't be done without a series of method definitions for each data type. See the compiled code for the Python syntax._
 
 
+### `final`
+
+Coconut supports `final` declarations to mark variables as constant, preventing reassignment within the same scope. The syntax is:
+```coconut
+final <name> = <value>
+```
+
+Once a variable is declared `final`, it cannot be reassigned within that scope. Attempting to reassign a final variable will result in a compile-time error.
+
+#### Shadowing
+
+Inner scopes can freely shadow final variables from outer scopes, creating new bindings:
+```coconut
+final x = 1
+def f():
+    x = 2  # OK - creates new binding in f's scope, doesn't modify outer x
+    x = 3  # OK - x is not final in this scope
+    return x
+```
+
+You can also explicitly make the inner binding final:
+```coconut
+final x = 1
+def f():
+    final x = 2  # OK - new final binding that shadows outer x
+    return x
+```
+
+#### Usage Contexts
+
+The `final` keyword can be used in:
+- Variable assignments: `final x = 1`
+- Typed assignments: `final x: int = 1`
+- Function parameters: `def f(final x): ...`
+- For loops: `for final i in items: ...`
+- Match patterns: `case final x: ...`
+
+#### Escape Hatch
+
+To bypass final checking (e.g., for metaprogramming), prefix the variable name with a backslash:
+```coconut
+final x = 1
+\x = 2  # OK - bypasses final check
+```
+
+##### Example
+
+**Coconut:**
+```coconut
+final PI = 3.14159
+final GREETING = "Hello"
+
+def calculate_area(final radius):
+    return PI * radius ** 2
+
+# PI = 3.14  # ERROR - cannot reassign final variable 'PI'
+```
+
+**Python:**
+```python
+PI = 3.14159
+GREETING = "Hello"
+
+def calculate_area(radius):
+    return PI * radius ** 2
+
+# No compile-time enforcement - reassignment would be allowed
+```
+
+
 ### `where`
 
 Coconut's `where` statement is fairly straightforward. The syntax for a `where` statement is just

{coconut_develop-3.1.2.post0.dev11 → coconut_develop-3.2.0.post0.dev2}/HELP.md

@@ -58,7 +58,7 @@ coconut -h
 ```
 which should display Coconut's command-line help.
 
-_Note: If you're having trouble, or if anything mentioned in this tutorial doesn't seem to work for you, feel free to [ask for help on Gitter](https://gitter.im/evhub/coconut) and somebody will try to answer your question as soon as possible._
+_Note: If you're having trouble, or if anything mentioned in this tutorial doesn't seem to work for you, feel free to [raise an issue on GitHub](https://github.com/evhub/coconut/issues/new)!_
 
 ## Starting Out
 
@@ -1163,6 +1163,6 @@ def int_map(
 
 And that's it for this tutorial! But that's hardly it for Coconut. All of the features examined in this tutorial, as well as a bunch of others, are detailed in Coconut's [documentation](./DOCS.md).
 
-Also, if you have any other questions not covered in this tutorial, feel free to ask around at Coconut's [Gitter](https://gitter.im/evhub/coconut), a GitHub-integrated chat room for Coconut developers.
+Also, if you have any other questions not covered in this tutorial, feel free to [raise an issue on GitHub](https://github.com/evhub/coconut/issues/new)!
 
 Finally, Coconut is a new, growing language, and if you'd like to get involved in the development of Coconut, all the code is available completely open-source on Coconut's [GitHub](https://github.com/evhub/coconut). Contributing is a simple as forking the code, making your changes, and proposing a pull request! See Coconuts [contributing guidelines](./CONTRIBUTING.md) for more information.

{coconut_develop-3.1.2.post0.dev11 → coconut_develop-3.2.0.post0.dev2}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: coconut-develop
-Version: 3.1.2.post0.dev11
+Version: 3.2.0.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
-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,λ
+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,final,addpattern,then,operator,type,copyclosure,λ
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: Topic :: Software Development
@@ -220,27 +220,6 @@ Requires-Dist: pytest>=7; (python_version >= "3.6" and python_version < "3.8") a
 Requires-Dist: pytest<8.1,>=8.0; python_version >= "3.8" and extra == "tests"
 Requires-Dist: pexpect>=4; extra == "tests"
 Requires-Dist: pytest_remotedata>=0.3; extra == "tests"
-Requires-Dist: ipython>=5.4; python_version < "3" and extra == "tests"
-Requires-Dist: ipython<7.10,>=7.9; (python_version >= "3" and python_version < "3.7") and extra == "tests"
-Requires-Dist: ipython>=7.34; (python_version >= "3.7" and python_version < "3.8") and extra == "tests"
-Requires-Dist: ipython>=8.12; (python_version >= "3.8" and python_version < "3.9") and extra == "tests"
-Requires-Dist: ipython>=8.18; (python_version >= "3.9" and python_version < "3.11") and extra == "tests"
-Requires-Dist: ipython>=9; python_version >= "3.11" and extra == "tests"
-Requires-Dist: ipykernel>=4.10; python_version < "3" and extra == "tests"
-Requires-Dist: ipykernel>=5.5; (python_version >= "3" and python_version < "3.8") and extra == "tests"
-Requires-Dist: ipykernel>=6; (python_version >= "3.8" and python_version < "3.10") and extra == "tests"
-Requires-Dist: ipykernel>=7; python_version >= "3.10" and extra == "tests"
-Requires-Dist: jupyter-client>=5.3; python_version < "3.5" and extra == "tests"
-Requires-Dist: jupyter-client<6.1.13,>=6.1.12; (python_version >= "3.5" and python_version < "3.6") and extra == "tests"
-Requires-Dist: jupyter-client>=7.1.2; python_version >= "3.6" and extra == "tests"
-Requires-Dist: jedi<0.18,>=0.17; python_version < "3.9" and extra == "tests"
-Requires-Dist: jedi>=0.19; python_version >= "3.9" and extra == "tests"
-Requires-Dist: pywinpty<0.6,>=0.5; (python_version < "3" and os_name == "nt") and extra == "tests"
-Requires-Dist: jupyter>=1.1; extra == "tests"
-Requires-Dist: jupyter-console>=5.2; python_version < "3.5" and extra == "tests"
-Requires-Dist: jupyter-console>=6.1; (python_version >= "3.5" and python_version < "3.7") and extra == "tests"
-Requires-Dist: jupyter-console>=6.6; python_version >= "3.7" and extra == "tests"
-Requires-Dist: papermill>=1.2; extra == "tests"
 Provides-Extra: dev
 Requires-Dist: ipython>=5.4; python_version < "3" and extra == "dev"
 Requires-Dist: ipython<7.10,>=7.9; (python_version >= "3" and python_version < "3.7") and extra == "dev"
@@ -364,8 +343,7 @@ To help you get started, check out these links for more information about Coconu
 - 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.
+- `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. Creating a new issue is also absolutely welcome as a way to ask any questions you might have about Coconut.
 - 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/
@@ -375,7 +353,6 @@ To help you get started, check out these links for more information about Coconu
 .. _`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

{coconut_develop-3.1.2.post0.dev11 → coconut_develop-3.2.0.post0.dev2}/README.rst

@@ -31,8 +31,7 @@ To help you get started, check out these links for more information about Coconu
 - 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.
+- `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. Creating a new issue is also absolutely welcome as a way to ask any questions you might have about Coconut.
 - 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/
@@ -42,7 +41,6 @@ To help you get started, check out these links for more information about Coconu
 .. _`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

{coconut_develop-3.1.2.post0.dev11 → coconut_develop-3.2.0.post0.dev2}/coconut/compiler/compiler.py

@@ -604,6 +604,7 @@ class Compiler(Grammar, pickleable_obj):
         # but always overwrite temp_vars_by_key since they store locs that will be invalidated
         self.temp_vars_by_key = {}
         self.parsing_context = defaultdict(list)
+        self.parsing_context["final_vars"].append(set())  # initialize module-level final scope
         self.name_info = defaultdict(lambda: {"imported": [], "referenced": [], "assigned": []})
         self.star_import = False
         self.kept_lines = []
@@ -634,6 +635,7 @@ class Compiler(Grammar, pickleable_obj):
         skips, self.skips = self.skips, []
         docstring, self.docstring = self.docstring, ""
         parsing_context, self.parsing_context = self.parsing_context, defaultdict(list)
+        self.parsing_context["final_vars"].append(set())  # initialize module-level final scope
         kept_lines, self.kept_lines = self.kept_lines, []
         num_lines, self.num_lines = self.num_lines, 0
         remaining_original, self.remaining_original = self.remaining_original, None
@@ -816,12 +818,22 @@ class Compiler(Grammar, pickleable_obj):
 
         # name handlers
         cls.refname <<= attach(cls.name_ref, cls.method("name_handle"))
-        cls.setname <<= attach(cls.name_ref, cls.method("name_handle", assign=True))
-        cls.classname <<= attach(
+        cls.nonfinal_setname <<= attach(cls.name_ref, cls.method("name_handle", assign=True))
+        cls.final_setname <<= attach(
+            cls.final_setname_ref,
+            cls.method("name_handle", assign=True, is_final=True),
+            greedy=True,
+        )
+        cls.nonfinal_classname <<= attach(
             cls.name_ref,
             cls.method("name_handle", assign=True, classname=True),
             greedy=True,
         )
+        cls.final_classname <<= attach(
+            cls.final_setname_ref,
+            cls.method("name_handle", assign=True, classname=True, is_final=True),
+            greedy=True,
+        )
         cls.expr_setname <<= attach(
             cls.name_ref,
             cls.method("name_handle", assign=True, expr_setname=True),
@@ -1055,7 +1067,7 @@ class Compiler(Grammar, pickleable_obj):
                 msg + " (add '# NOQA' to suppress)",
                 original,
                 loc,
-                **kwargs,
+                **kwargs  # no comma
             )
 
     @contextmanager
@@ -5015,7 +5027,7 @@ class {protocol_var}({tokens}, _coconut.typing.Protocol): pass
 
     @contextmanager
     def add_to_parsing_context(self, name, obj, callbacks_key=None):
-        """Pur the given object on the parsing context stack for the given name."""
+        """Put the given object on the parsing context stack for the given name."""
         self.parsing_context[name].append(obj)
         try:
             yield
@@ -5244,7 +5256,8 @@ class {protocol_var}({tokens}, _coconut.typing.Protocol): pass
         try:
             # handles support for class type variables
             with self.type_alias_stmt_manage():
-                yield
+                with self.add_to_parsing_context("final_vars", set()):
+                    yield
         finally:
             cls_stack.pop()
 
@@ -5257,7 +5270,8 @@ class {protocol_var}({tokens}, _coconut.typing.Protocol): pass
         try:
             # handles support for function type variables
             with self.type_alias_stmt_manage():
-                yield
+                with self.add_to_parsing_context("final_vars", set()):
+                    yield
         finally:
             if cls_context is not None:
                 cls_context["in_method"] = in_method
@@ -5283,11 +5297,15 @@ class {protocol_var}({tokens}, _coconut.typing.Protocol): pass
         ):
             yield
 
-    def name_handle(self, original, loc, tokens, assign=False, classname=False, expr_setname=False):
+    def name_handle(self, original, loc, tokens, assign=False, classname=False, expr_setname=False, is_final=False):
         """Handle the given base name."""
-        internal_assert(assign if expr_setname else True, "expr_setname should always imply assign", (expr_setname, assign))
+        if expr_setname:
+            internal_assert(assign, "expr_setname should always imply assign", (expr_setname, assign))
+        if is_final:
+            internal_assert(assign and not expr_setname, "only setnames should ever be final", (assign, is_final))
 
         name, = tokens
+
         if name.startswith("\\"):
             name = name[1:]
             escaped = True
@@ -5297,6 +5315,28 @@ class {protocol_var}({tokens}, _coconut.typing.Protocol): pass
         if self.disable_name_check:
             return name
 
+        # raise_or_wrap_error for all errors here to make sure we don't
+        #  raise spurious errors if not using the computation graph
+
+        # final variable checking
+        final_vars = self.current_parsing_context("final_vars")
+        self.internal_assert(final_vars is not None, original, loc, "no final_vars context")
+        if (
+            assign
+            and not expr_setname
+            and not escaped
+            and name in final_vars
+        ):
+            return self.raise_or_wrap_error(
+                CoconutSyntaxError,
+                "cannot reassign final variable '{name}'".format(name=name),
+                original,
+                loc,
+                extra="use explicit '\\{name}' syntax to bypass final checking".format(name=name),
+            )
+        if is_final:
+            final_vars.add(name)
+
         # 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")
@@ -5315,9 +5355,6 @@ class {protocol_var}({tokens}, _coconut.typing.Protocol): pass
             self.internal_assert(expr_setnames_context is not None, original, loc, "found expr_setname outside of has_expr_setname_manage", tokens)
             expr_setnames_context["new_names"].add(name)
 
-        # raise_or_wrap_error for all errors here to make sure we don't
-        #  raise spurious errors if not using the computation graph
-
         if not escaped:
             typevar_info = self.current_parsing_context("typevars")
             if typevar_info is not None:

{coconut_develop-3.1.2.post0.dev11 → coconut_develop-3.2.0.post0.dev2}/coconut/compiler/grammar.py

@@ -859,10 +859,16 @@ class Grammar(object):
         base_name = regex_item(base_name_regex)
 
         refname = Forward()
-        setname = Forward()
         expr_setname = Forward()
-        classname = Forward()
+        final_setname = Forward()
+        nonfinal_setname = Forward()
+        final_classname = Forward()
+        nonfinal_classname = Forward()
+
         name_ref = combine(Optional(backslash) + base_name)
+        final_setname_ref = keyword("final").suppress() + name_ref
+        setname = final_setname | nonfinal_setname
+        classname = final_classname | nonfinal_classname
         unsafe_name = combine(Optional(backslash.suppress()) + base_name)
 
         # use unsafe_name for dotted components since name should only be used for base names

{coconut_develop-3.1.2.post0.dev11 → coconut_develop-3.2.0.post0.dev2}/coconut/compiler/header.py

@@ -766,17 +766,6 @@ asyncio_Return = StopIteration
             ''',
             indent=1,
         ),
-        import_tstr=pycondition(
-            (3, 14),
-            if_lt='''
-try:
-    import tstr
-except ImportError as tstr_import_err:
-    tstr = _coconut_missing_module(tstr_import_err)
-            ''',
-            if_ge='',
-            indent=1,
-        ),
         class_amap=pycondition(
             (3, 3),
             if_lt='''

{coconut_develop-3.1.2.post0.dev11 → coconut_develop-3.2.0.post0.dev2}/coconut/compiler/templates/header.py_template

@@ -27,7 +27,10 @@ class _coconut{object}:{COMMENT.EVERYTHING_HERE_MUST_BE_COPIED_TO_STUB_FILE}
         import async_generator
     except ImportError as async_generator_import_err:
         async_generator = _coconut_missing_module(async_generator_import_err)
-{import_tstr}
+    try:
+        import tstr
+    except ImportError as tstr_import_err:
+        tstr = _coconut_missing_module(tstr_import_err)
 {import_pickle}
 {import_OrderedDict}
 {import_collections_abc}

{coconut_develop-3.1.2.post0.dev11 → coconut_develop-3.2.0.post0.dev2}/coconut/compiler/util.py

@@ -106,7 +106,7 @@ from coconut.constants import (
     pseudo_targets,
     reserved_vars,
     packrat_cache_size,
-    temp_grammar_item_ref_count,
+    min_observed_ref_count,
     indchars,
     comment_chars,
     non_syntactic_newline,
@@ -986,7 +986,13 @@ assert _value_useful == -1, "value must end with usefullness obj"
 
 def maybe_copy_elem(item, name):
     """Copy the given grammar element if it's referenced somewhere else."""
-    item_ref_count = sys.getrefcount(item) if CPYTHON and not on_new_python else float("inf")
+    item_ref_count = sys.getrefcount(item) if CPYTHON else float("inf")
+    if on_new_python:
+        temp_grammar_item_ref_count = 1
+    elif isinstance(min_observed_ref_count, dict):
+        temp_grammar_item_ref_count = min_observed_ref_count[name]
+    else:
+        temp_grammar_item_ref_count = min_observed_ref_count
     internal_assert(lambda: item_ref_count >= temp_grammar_item_ref_count, "add_action got item with too low ref count", (item, type(item), item_ref_count))
     if item_ref_count <= temp_grammar_item_ref_count:
         if DEVELOP:

{coconut_develop-3.1.2.post0.dev11 → coconut_develop-3.2.0.post0.dev2}/coconut/constants.py

@@ -26,6 +26,7 @@ import platform
 import re
 import datetime as dt
 from warnings import warn
+from collections import defaultdict
 
 # -----------------------------------------------------------------------------------------------------------------------
 # UTILITIES:
@@ -179,8 +180,8 @@ embed_on_internal_exc = get_bool_env_var("COCONUT_EMBED_ON_INTERNAL_EXC", False)
 test_computation_graph_pickling = False
 
 # should be the minimal ref count observed by maybe_copy_elem
-temp_grammar_item_ref_count = (
-    1 if PY314
+min_observed_ref_count = (
+    defaultdict(lambda: 2, attach=1) if PY314
     else 4 if PY311
     else 5
 )
@@ -441,6 +442,7 @@ reserved_vars = (
     "case",
     "cases",
     "where",
+    "final",
     "addpattern",
     "then",
     "operator",

{coconut_develop-3.1.2.post0.dev11 → coconut_develop-3.2.0.post0.dev2}/coconut/root.py

@@ -23,10 +23,10 @@ import sys as _coconut_sys
 # VERSION:
 # -----------------------------------------------------------------------------------------------------------------------
 
-VERSION = "3.1.2"
+VERSION = "3.2.0"
 VERSION_NAME = None
 # False for release, int >= 1 for develop
-DEVELOP = 11
+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"
@@ -107,6 +107,12 @@ class int(_coconut_py_int):
             return _coconut.isinstance(inst, (_coconut_py_int, _coconut_py_long))
         def __subclasscheck__(cls, subcls):
             return _coconut.issubclass(subcls, (_coconut_py_int, _coconut_py_long))
+        def __eq__(cls, other):
+            if other is _coconut_py_int or other is _coconut_py_long:
+                return True
+            return _coconut.type.__eq__(cls, other)
+        def __hash__(cls):
+            return _coconut.hash(_coconut_py_int)
 class bytes(_coconut_py_bytes):
     __slots__ = ()
     __doc__ = getattr(_coconut_py_bytes, "__doc__", "<see help(py_bytes)>")
@@ -115,6 +121,12 @@ class bytes(_coconut_py_bytes):
             return _coconut.isinstance(inst, _coconut_py_bytes)
         def __subclasscheck__(cls, subcls):
             return _coconut.issubclass(subcls, _coconut_py_bytes)
+        def __eq__(cls, other):
+            if other is _coconut_py_bytes:
+                return True
+            return _coconut.type.__eq__(cls, other)
+        def __hash__(cls):
+            return _coconut.hash(_coconut_py_bytes)
     def __new__(self, *args):
         if not args:
             return b""

{coconut_develop-3.1.2.post0.dev11 → coconut_develop-3.2.0.post0.dev2}/coconut/tests/main_test.py

@@ -824,9 +824,11 @@ def run_pyprover(**kwargs):
 def comp_prelude(args=[], **kwargs):
     """Compiles evhub/coconut-prelude."""
     call(["git", "clone", prelude_git])
-    if MYPY and not WINDOWS:
-        args.extend(["--target", "3.5", "--mypy"])
-        kwargs["check_errors"] = False
+    # disabled --mypy: was causing test_prelude to take ~5 hours due to
+    # extremely slow mypy type-checking on the coconut-prelude package
+    # if MYPY and not WINDOWS:
+    #     args.extend(["--target", "3.5", "--mypy"])
+    #     kwargs["check_errors"] = False
     call_coconut([os.path.join(prelude, "setup.coco"), "--force"] + args, **kwargs)
     call_coconut([os.path.join(prelude, "prelude-source"), os.path.join(prelude, "prelude"), "--force"] + args, **kwargs)
 

{coconut_develop-3.1.2.post0.dev11 → coconut_develop-3.2.0.post0.dev2}/coconut/tests/src/cocotest/agnostic/primary_2.coco

@@ -491,6 +491,8 @@ def primary_test_2() -> bool:
     assert reduce(function=(+), iterable=range(5), initial=-1) == 9  # type: ignore
     assert takewhile(predicate=ident, iterable=[1, 2, 1, 0, 1]) |> list == [1, 2, 1]  # type: ignore
     assert dropwhile(predicate=(not), iterable=range(5)) |> list == [1, 2, 3, 4]  # type: ignore
+    assert type(1) == int
+    assert type(b"") == bytes
     @memoize(typed=True)
     def typed_memoized_func(x):
         if x is 1:
@@ -499,12 +501,12 @@ def primary_test_2() -> bool:
             return (x, typed_memoized_func(1))
     assert typed_memoized_func(1.0) == (1.0, None)
     assert typed_memoized_func(1.0)[0] |> type == float
-    @memoize()
-    def untyped_memoized_func(x=None):
+    @memoize(memoize.RECURSIVE, typed=True)  # type: ignore
+    def recursive_typed_memoized_func(x=None):
         if x is None:
-            return (untyped_memoized_func(1), untyped_memoized_func(1.0))
+            return (recursive_typed_memoized_func(1), recursive_typed_memoized_func(1.0))
         return x
-    assert untyped_memoized_func() |> map$(type) |> tuple == (int, float)
+    assert recursive_typed_memoized_func() |> map$(type) |> tuple == (int, float)
     assert -1 ?↦ abs == 1
     assert None ?↦ abs is None
 
@@ -516,4 +518,78 @@ def primary_test_2() -> bool:
         # repeat the same thing again now that my_match_err.str has been called
         assert process_map(ident, [my_match_err]) |> list |> str == str([my_match_err])  # type: ignore
 
+    # final variable tests - valid cases
+    # 1. Simple final declaration
+    final final_x = 1
+    assert final_x == 1
+    # 2. Final parameter (no reassignment inside)
+    def final_param_func(final param) = param * 2
+    assert final_param_func(5) == 10
+    # 3. Shadowing in inner scope WITH final (allowed)
+    final final_outer1 = 1
+    def final_shadow_test1():
+        final final_outer1 = 2  # shadows with final
+        return final_outer1
+    assert final_shadow_test1() == 2
+    assert final_outer1 == 1  # outer unchanged
+    # 4. Shadowing in inner scope WITHOUT final (also allowed - creates new non-final binding)
+    final final_outer2 = 10
+    def final_shadow_test2():
+        final_outer2 = 20  # shadows without final - OK, new binding
+        final_outer2 = 30  # can reassign since it's not final in this scope
+        return final_outer2
+    assert final_shadow_test2() == 30
+    assert final_outer2 == 10  # outer unchanged
+    # 5. Function parameter shadows outer final (no final needed)
+    final final_param_shadow = 100
+    def final_param_test(final_param_shadow):  # parameter shadows outer final - OK
+        return final_param_shadow * 2
+    assert final_param_test(5) == 10
+    assert final_param_shadow == 100
+    # 6. Referencing final (read access is fine)
+    final final_readable = 42
+    final_other = final_readable + 1
+    assert final_other == 43
+    # 7. Multiple final declarations (different names)
+    final final_a = 1
+    final final_b = 2
+    assert final_a + final_b == 3
+    # 8. Final in class body (class attribute)
+    class FinalClass:
+        final class_final = 100
+    assert FinalClass.class_final == 100
+    # 9. Typed final
+    final final_typed_val: int = 999
+    assert final_typed_val == 999
+    # 10. Final in for loop (new final binding per iteration)
+    final_result = []
+    for final final_i in [1, 2, 3]:
+        final_result.append(final_i)
+    assert final_result == [1, 2, 3]
+    # 11. Escape hatch - can bypass with backslash
+    final final_escape_test = 1
+    \final_escape_test = 2  # bypasses final check
+    assert final_escape_test == 2
+    # 12. Class body assignment doesn't conflict with outer final
+    final final_class_ok = 1
+    class OkClass:
+        final_class_ok = 2  # This is a class attribute, different namespace
+    assert OkClass.final_class_ok == 2
+    assert final_class_ok == 1
+    # 13. Comprehension variables are independent (not checked for final)
+    final final_comp_var = 1
+    final_result2 = [final_comp_var for final_comp_var in [10, 20]]  # expr_setname, not checked
+    assert final_result2 == [10, 20]
+    assert final_comp_var == 1  # outer unchanged
+    # 14. Nested function shadowing
+    final final_nested = 1
+    def final_outer_fn():
+        final_nested = 2  # shadows without final - OK
+        def final_inner_fn():
+            final_nested = 3  # shadows again - OK
+            return final_nested
+        return final_inner_fn() + final_nested
+    assert final_outer_fn() == 5
+    assert final_nested == 1
+
     return True

{coconut_develop-3.1.2.post0.dev11 → coconut_develop-3.2.0.post0.dev2}/coconut/tests/src/extras.coco

@@ -10,7 +10,7 @@ from coconut.constants import (
     NUMPY,
     PY35,
     PY36,
-    PY39,
+    PY310,
     PYPY,
 )  # type: ignore
 from coconut._pyparsing import USE_COMPUTATION_GRAPH  # type: ignore
@@ -335,6 +335,18 @@ def g(x) = x
     assert parse("[def x -> (x, y) for y in range(10)]", "lenient").count("def") == 2
     assert parse("123  # derp", "lenient") == "123  # derp"
 
+    assert_raises(-> parse("final x = 1\nx = 2"), CoconutSyntaxError, err_has="final")
+    assert_raises(-> parse("final x = 1\nx += 1"), CoconutSyntaxError, err_has="final")
+    assert_raises(-> parse("final x = 1\ndel x"), CoconutSyntaxError, err_has="final")
+    assert_raises(-> parse("final x = 1\nfor x in [1]: pass"), CoconutSyntaxError, err_has="final")
+    assert_raises(-> parse("final x = 1\nwith foo() as x: pass"), CoconutSyntaxError, err_has="final")
+    assert_raises(-> parse("final e = 1\ntry: pass\nexcept E as e: pass"), CoconutSyntaxError, err_has="final")
+    assert_raises(-> parse("final os = 1\nimport os"), CoconutSyntaxError, err_has="final")
+    assert_raises(-> parse("final path = 1\nfrom os import path"), CoconutSyntaxError, err_has="final")
+    assert_raises(-> parse("def f(final x): x = 2"), CoconutSyntaxError, err_has="final")
+    assert_raises(-> parse("final x = 1\nmatch y:\n    case x: pass"), CoconutSyntaxError, err_has="final")
+    assert_raises(-> parse("final x = 1\nfinal x = 2"), CoconutSyntaxError, err_has="final")
+
     return True
 
 
@@ -768,7 +780,7 @@ def test_extras() -> bool:
     if NUMPY and PY36:
         assert test_pandas() is True  # .
     print(".", end="")
-    if NUMPY and PY39:
+    if NUMPY and PY310:
         assert test_xarray() is True # ..
     print(".")  # newline bc we print stuff after this
     assert test_setup_none() is True  # ...