coconut-develop 3.1.0.post0.dev4__tar.gz → 3.1.0.post0.dev6__tar.gz

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

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

@@ -2513,7 +2513,7 @@ def {mock_var}({mock_paramdef}):
 
                 # assemble tre'd function
                 comment, rest = split_leading_comments(func_code)
-                indent, base, dedent = split_leading_trailing_indent(rest, 1)
+                indent, base, dedent = split_leading_trailing_indent(rest, max_indents=1)
                 base, base_dedent = split_trailing_indent(base)
                 docstring, base = self.split_docstring(base)
 
@@ -2673,15 +2673,19 @@ else:
                 post_def_lines = []
                 funcdef_lines = list(literal_lines(funcdef, True))
                 for i, line in enumerate(funcdef_lines):
-                    if self.def_regex.match(line):
+                    line_indent, line_base = split_leading_indent(line)
+                    if self.def_regex.match(line_base):
                         pre_def_lines = funcdef_lines[:i]
                         post_def_lines = funcdef_lines[i:]
                         break
                 internal_assert(post_def_lines, "no def statement found in funcdef", funcdef)
 
                 out.append(bef_ind)
-                out.extend(pre_def_lines)
-                out.append(self.proc_funcdef(original, loc, decorators, "".join(post_def_lines), is_async, in_method, is_stmt_lambda))
+                out += pre_def_lines
+                func_indent, func_code, func_dedent = split_leading_trailing_indent("".join(post_def_lines), symmetric=True)
+                out.append(func_indent)
+                out.append(self.proc_funcdef(original, loc, decorators, func_code, is_async, in_method, is_stmt_lambda))
+                out.append(func_dedent)
                 out.append(aft_ind)
 
             # look for add_code_before regexes
@@ -3176,7 +3180,16 @@ while True:
         """Process class definitions."""
         decorators, name, paramdefs, classlist_toks, body = tokens
 
-        out = "".join(paramdefs) + decorators + "class " + name
+        out = ""
+
+        # paramdefs are type params on >= 3.12 and type var assignments on < 3.12
+        if paramdefs:
+            if self.target_info >= (3, 12):
+                name += "[" + ", ".join(paramdefs) + "]"
+            else:
+                out += "".join(paramdefs)
+
+        out += decorators + "class " + name
 
         # handle classlist
         base_classes = []
@@ -3206,7 +3219,7 @@ while True:
 
             base_classes.append(join_args(pos_args, star_args, kwd_args, dubstar_args))
 
-        if paramdefs:
+        if paramdefs and self.target_info < (3, 12):
             base_classes.append(self.get_generic_for_typevars())
 
         if not classlist_toks and not self.target.startswith("3"):
@@ -3438,9 +3451,16 @@ def __new__(_coconut_cls, {all_args}):
         IMPORTANT: Any changes to assemble_data must be reflected in the
         definition of Expected in header.py_template.
         """
+        print(paramdefs)
         # create class
-        out = [
-            "".join(paramdefs),
+        out = []
+        if paramdefs:
+            # paramdefs are type params on >= 3.12 and type var assignments on < 3.12
+            if self.target_info >= (3, 12):
+                name += "[" + ", ".join(paramdefs) + "]"
+            else:
+                out += ["".join(paramdefs)]
+        out += [
             decorators,
             "class ",
             name,
@@ -3449,7 +3469,7 @@ def __new__(_coconut_cls, {all_args}):
         ]
         if inherit is not None:
             out += [", ", inherit]
-        if paramdefs:
+        if paramdefs and self.target_info < (3, 12):
             out += [", ", self.get_generic_for_typevars()]
         if not self.target.startswith("3"):
             out.append(", _coconut.object")
@@ -3554,7 +3574,7 @@ def __hash__(self):
             fake_mods = imp_as.split(".")
             for i in range(1, len(fake_mods)):
                 mod_name = ".".join(fake_mods[:i])
-                out.extend((
+                out += [
                     "try:",
                     openindent + mod_name,
                     closeindent + "except:",
@@ -3562,7 +3582,7 @@ def __hash__(self):
                     closeindent + "else:",
                     openindent + "if not _coconut.isinstance(" + mod_name + ", _coconut.types.ModuleType):",
                     openindent + mod_name + ' = _coconut.types.ModuleType(_coconut_py_str("' + mod_name + '"))' + closeindent * 2,
-                ))
+                ]
             out.append(".".join(fake_mods) + " = " + import_as_var)
         else:
             out.append(import_stmt(imp_from, imp, imp_as))
@@ -4560,15 +4580,21 @@ class {protocol_var}({tokens}, _coconut.typing.Protocol): pass
             return name
         else:
             name, paramdefs = tokens
-            return self.add_code_before_marker_with_replacement(name, "".join(paramdefs), add_spaces=False)
+            # paramdefs are type params on >= 3.12 and type var assignments on < 3.12
+            if self.target_info >= (3, 12):
+                return name + "[" + ", ".join(paramdefs) + "]"
+            else:
+                return self.add_code_before_marker_with_replacement(name, "".join(paramdefs), add_spaces=False)
 
     funcname_typeparams_handle.ignore_one_token = True
 
     def type_param_handle(self, original, loc, tokens):
         """Compile a type param into an assignment."""
         args = ""
+        raw_bound = None
         bound_op = None
         bound_op_type = ""
+        stars = ""
         if "TypeVar" in tokens:
             TypeVarFunc = "TypeVar"
             bound_op_type = "bound"
@@ -4576,18 +4602,24 @@ class {protocol_var}({tokens}, _coconut.typing.Protocol): pass
                 name_loc, name = tokens
             else:
                 name_loc, name, bound_op, bound = tokens
+                # raw_bound is for >=3.12, so it is for_py_typedef, but args is for <3.12, so it isn't
+                raw_bound = self.wrap_typedef(bound, for_py_typedef=True)
                 args = ", bound=" + self.wrap_typedef(bound, for_py_typedef=False)
         elif "TypeVar constraint" in tokens:
             TypeVarFunc = "TypeVar"
             bound_op_type = "constraint"
             name_loc, name, bound_op, constraints = tokens
+            # for_py_typedef is different in the two cases here as above
+            raw_bound = ", ".join(self.wrap_typedef(c, for_py_typedef=True) for c in constraints)
             args = ", " + ", ".join(self.wrap_typedef(c, for_py_typedef=False) for c in constraints)
         elif "TypeVarTuple" in tokens:
             TypeVarFunc = "TypeVarTuple"
             name_loc, name = tokens
+            stars = "*"
         elif "ParamSpec" in tokens:
             TypeVarFunc = "ParamSpec"
             name_loc, name = tokens
+            stars = "**"
         else:
             raise CoconutInternalException("invalid type_param tokens", tokens)
 
@@ -4608,8 +4640,14 @@ class {protocol_var}({tokens}, _coconut.typing.Protocol): pass
                         loc,
                     )
 
+        # on >= 3.12, return a type param
+        if self.target_info >= (3, 12):
+            return stars + name + (": " + raw_bound if raw_bound is not None else "")
+
+        # on < 3.12, return a type variable assignment
+
         kwargs = ""
-        # uncomment these lines whenever mypy adds support for infer_variance in TypeVar
+        # TODO: uncomment these lines whenever mypy adds support for infer_variance in TypeVar
         #  (and remove the warning about it in the DOCS)
         # if TypeVarFunc == "TypeVar":
         #     kwargs += ", infer_variance=True"
@@ -4640,6 +4678,7 @@ class {protocol_var}({tokens}, _coconut.typing.Protocol): pass
 
     def get_generic_for_typevars(self):
         """Get the Generic instances for the current typevars."""
+        internal_assert(self.target_info < (3, 12), "get_generic_for_typevars should only be used on targets < 3.12")
         typevar_info = self.current_parsing_context("typevars")
         internal_assert(typevar_info is not None, "get_generic_for_typevars called with no typevars")
         generics = []
@@ -4673,16 +4712,18 @@ class {protocol_var}({tokens}, _coconut.typing.Protocol): pass
             paramdefs = ()
         else:
             name, paramdefs, typedef = tokens
-        out = "".join(paramdefs)
+
+        # paramdefs are type params on >= 3.12 and type var assignments on < 3.12
         if self.target_info >= (3, 12):
-            out += "type " + name + " = " + self.wrap_typedef(typedef, for_py_typedef=True)
+            if paramdefs:
+                name += "[" + ", ".join(paramdefs) + "]"
+            return "type " + name + " = " + self.wrap_typedef(typedef, for_py_typedef=True)
         else:
-            out += self.typed_assign_stmt_handle([
+            return "".join(paramdefs) + self.typed_assign_stmt_handle([
                 name,
                 "_coconut.typing.TypeAlias",
                 self.wrap_typedef(typedef, for_py_typedef=False),
             ])
-        return out
 
     def where_item_handle(self, tokens):
         """Manage where items."""

{coconut-develop-3.1.0.post0.dev4 → coconut-develop-3.1.0.post0.dev6}/coconut/compiler/grammar.py

@@ -2718,7 +2718,8 @@ class Grammar(object):
 
         whitespace_regex = compile_regex(r"\s")
 
-        def_regex = compile_regex(r"\b((async|addpattern|copyclosure)\s+)*def\b")
+        def_regex = compile_regex(r"((async|addpattern|copyclosure)\s+)*def\b")
+
         yield_regex = compile_regex(r"\byield(?!\s+_coconut\.asyncio\.From)\b")
         yield_from_regex = compile_regex(r"\byield\s+from\b")
 

{coconut-develop-3.1.0.post0.dev4 → coconut-develop-3.1.0.post0.dev6}/coconut/compiler/templates/header.py_template

@@ -61,7 +61,7 @@ class _coconut{object}:{COMMENT.EVERYTHING_HERE_MUST_BE_COPIED_TO_STUB_FILE}
     reiterables = abc.Sequence, abc.Mapping, abc.Set
     fmappables = list, tuple, dict, set, frozenset, bytes, bytearray
     abc.Sequence.register(collections.deque)
-    Ellipsis, NotImplemented, NotImplementedError, Exception, AttributeError, ImportError, IndexError, KeyError, NameError, TypeError, ValueError, StopIteration, RuntimeError, all, any, bool, bytes, callable, chr, classmethod, complex, dict, enumerate, filter, float, frozenset, getattr, hasattr, hash, id, int, isinstance, issubclass, iter, len, list, locals, globals, map, min, max, next, object, ord, property, range, reversed, set, setattr, slice, str, sum, super, tuple, type, vars, zip, repr, print{comma_bytearray} = Ellipsis, NotImplemented, NotImplementedError, Exception, AttributeError, ImportError, IndexError, KeyError, NameError, TypeError, ValueError, StopIteration, RuntimeError, all, any, bool, bytes, callable, chr, classmethod, complex, dict, enumerate, filter, float, frozenset, getattr, hasattr, hash, id, int, isinstance, issubclass, iter, len, list, locals, globals, map, min, max, next, object, ord, property, range, reversed, set, setattr, slice, str, sum, {lstatic}super{rstatic}, tuple, type, vars, zip, {lstatic}repr{rstatic}, {lstatic}print{rstatic}{comma_bytearray}
+    Ellipsis, NotImplemented, NotImplementedError, Exception, AttributeError, ImportError, IndexError, KeyError, NameError, TypeError, ValueError, StopIteration, RuntimeError, all, any, bool, bytes, callable, chr, classmethod, complex, dict, enumerate, filter, float, frozenset, getattr, hasattr, hash, id, int, isinstance, issubclass, iter, len, list, locals, globals, map, min, max, next, object, ord, property, range, reversed, set, setattr, slice, str, sum, super, tuple, type, vars, zip, repr, print{comma_bytearray} = Ellipsis, NotImplemented, NotImplementedError, Exception, AttributeError, ImportError, IndexError, KeyError, NameError, TypeError, ValueError, StopIteration, RuntimeError, all, any, bool, bytes, callable, chr, classmethod, complex, dict, enumerate, filter, float, frozenset, getattr, hasattr, hash, id, int, isinstance, issubclass, iter, len, list, locals, globals, map, {lstatic}min{rstatic}, {lstatic}max{rstatic}, next, object, ord, property, range, reversed, set, setattr, slice, str, sum, {lstatic}super{rstatic}, tuple, type, vars, zip, {lstatic}repr{rstatic}, {lstatic}print{rstatic}{comma_bytearray}
 @_coconut.functools.wraps(_coconut.functools.partial)
 def _coconut_partial(_coconut_func, *args, **kwargs):
     partial_func = _coconut.functools.partial(_coconut_func, *args, **kwargs)

{coconut-develop-3.1.0.post0.dev4 → coconut-develop-3.1.0.post0.dev6}/coconut/compiler/util.py

@@ -1804,10 +1804,12 @@ def split_trailing_indent(inputstr, max_indents=None, handle_comments=True):
     return inputstr, "".join(reversed(indents_from_end))
 
 
-def split_leading_trailing_indent(line, max_indents=None):
+def split_leading_trailing_indent(line, symmetric=False, **kwargs):
     """Split leading and trailing indent."""
-    leading_indent, line = split_leading_indent(line, max_indents)
-    line, trailing_indent = split_trailing_indent(line, max_indents)
+    leading_indent, line = split_leading_indent(line, **kwargs)
+    if symmetric:
+        kwargs["max_indents"] = leading_indent.count(openindent)
+    line, trailing_indent = split_trailing_indent(line, **kwargs)
     return leading_indent, line, trailing_indent
 
 

{coconut-develop-3.1.0.post0.dev4 → coconut-develop-3.1.0.post0.dev6}/coconut/constants.py

@@ -93,7 +93,7 @@ MYPY = (
     PY38
     and not WINDOWS
     and not PYPY
-    # disabled until MyPy supports PEP 695
+    # TODO: disabled until MyPy supports PEP 695
     and not PY312
 )
 XONSH = (

coconut-develop-3.1.0.post0.dev6/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.0.post0.dev4 → coconut-develop-3.1.0.post0.dev6}/coconut/root.py

@@ -26,7 +26,7 @@ import sys as _coconut_sys
 VERSION = "3.1.0"
 VERSION_NAME = None
 # False for release, int >= 1 for develop
-DEVELOP = 4
+DEVELOP = 6
 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.0.post0.dev4 → coconut-develop-3.1.0.post0.dev6}/coconut/tests/main_test.py

@@ -1092,11 +1092,11 @@ if TEST_ALL:
                 if not PYPY and PY38 and not PY310:
                     install_bbopt()
 
-        def test_pyprover(self):
-            with using_paths(pyprover):
-                comp_pyprover()
-                if PY38:
-                    run_pyprover()
+        # def test_pyprover(self):
+        #     with using_paths(pyprover):
+        #         comp_pyprover()
+        #         if PY38:
+        #             run_pyprover()
 
         def test_pyston(self):
             with using_paths(pyston):

{coconut-develop-3.1.0.post0.dev4 → coconut-develop-3.1.0.post0.dev6}/coconut/tests/src/cocotest/agnostic/suite.coco

@@ -630,8 +630,10 @@ def suite_test() -> bool:
     assert dt.lam() == dt
     assert dt.comp() == (dt,)
     assert dt.N()$[:2] |> list == [(dt, 0), (dt, 1)] == dt.N_()$[:2] |> list
-    assert map(Ad().ef, range(5)) |> list == range(1, 6) |> list
-    assert Ad().ef 1 == 2
+    assert map(HasDefs().a_def, range(5)) |> list == range(1, 6) |> list
+    assert HasDefs().a_def 1 == 2
+    assert HasDefs().case_def 1 == 0
+    assert HasDefs.__annotations__.keys() |> list == ["a_def", "case_def"]
     assert store.plus1 store.one == store.two
     assert ret_locals()["my_loc"] == 1
     assert ret_globals()["my_glob"] == 1
@@ -741,7 +743,8 @@ def suite_test() -> bool:
     (-> 3) -> _ `isinstance` int = "a"  # type: ignore
     assert empty_it() |> list == [] == empty_it_of_int(1) |> list
     assert just_it(1) |> list == [1]
-    assert just_it_of_int(1) |> list == [1] == just_it_of_int_(1) |> list
+    assert just_it_of_int1(1) |> list == [1] == just_it_of_int2(1) |> list
+    assert just_it_of_int3(1) |> list == [1] == just_it_of_int4(1) |> list
     assert must_be_int(4) == 4 == must_be_int_(4)
     assert typed_plus(1, 2) == 3
     (class inh_A() `isinstance` clsA) `isinstance` object = inh_A()
@@ -1038,7 +1041,7 @@ forward 2""") == 900
     assert (+) `on` (.*2) <*| (3, 5) == 16
     assert test_super_B().method({'somekey': 'string', 'someotherkey': 42})
     assert outer_func_normal() |> map$(call) |> list == [4] * 5
-    for outer_func in (outer_func_1, outer_func_2, outer_func_3, outer_func_4, outer_func_5):
+    for outer_func in (outer_func_1, outer_func_2, outer_func_3, outer_func_4, outer_func_5, outer_func_6):
         assert outer_func() |> map$(call) |> list == range(5) |> list
     assert get_glob() == 0
     assert wrong_get_set_glob(10) == 0

{coconut-develop-3.1.0.post0.dev4 → coconut-develop-3.1.0.post0.dev6}/coconut/tests/src/cocotest/agnostic/util.coco

@@ -632,7 +632,7 @@ def factorial5(value):
     else:
         return None
     raise TypeError()
-case def factorial6[Num <: int | float]: (Num, Num) -> Num
+case def factorial6[Num: (int, float)]: (Num, Num) -> Num
     """Factorial function"""
     match (0, acc=1):
         return acc
@@ -641,7 +641,6 @@ case def factorial6[Num <: int | float]: (Num, Num) -> Num
     match (int(n), acc=...) if n < 0:
         return None
 case def factorial7[Num <: int | float]: (Num, Num) -> Num
-    """Factorial function"""
     match(0, acc=1) = acc
     match(int(n), acc=1) if n > 0 = factorial7(n - 1, acc * n)
     match(int(n), acc=...) if n < 0 = None
@@ -1410,12 +1409,17 @@ class descriptor_test:
         [(self, i)] :: self.N_(i=i+1)
 
 
-# Function named Ad.ef
-class Ad:
-    ef: typing.Callable
+# Annotation checking
+class HasDefs:
+    a_def: typing.Callable
+
+    @staticmethod
+    case def case_def: int -> int
+        match(0) = 1
+        match(1) = 0
 
-def Ad.ef(self, 0) = 1  # type: ignore
-addpattern def Ad.ef(self, x) = x + 1  # type: ignore
+def HasDefs.a_def(self, 0) = 1  # type: ignore
+addpattern def HasDefs.a_def(self, x) = x + 1  # type: ignore
 
 
 # Storage class
@@ -1524,12 +1528,20 @@ yield def just_it(x): yield x
 
 yield def empty_it_of_int(int() as x): pass
 
-yield match def just_it_of_int(int() as x):
+yield match def just_it_of_int1(int() as x):
     yield x
 
-match yield def just_it_of_int_(int() as x):
+match yield def just_it_of_int2(int() as x):
     yield x
 
+yield case def just_it_of_int3:
+    match(int() as x):
+        yield x
+
+case yield def just_it_of_int4:
+    match(int() as x):
+        yield x
+
 yield def num_it() -> int$[]:
     yield 5
 
@@ -2059,3 +2071,12 @@ def outer_func_5() -> (() -> int)[]:
         copyclosure def inner_func() -> int = x
         funcs.append(inner_func)
     return funcs
+
+def outer_func_6():
+    funcs = []
+    for x in range(5):
+        copyclosure case def inner_func:
+            match(y) = y
+            match() = x
+        funcs.append(inner_func)
+    return funcs

{coconut-develop-3.1.0.post0.dev4 → coconut-develop-3.1.0.post0.dev6}/coconut/tests/src/cocotest/target_sys/target_sys_test.coco

@@ -48,12 +48,16 @@ def asyncio_test() -> bool:
 
     async def async_map_0(args):
         return thread_map(args[0], *args[1:])
-    async def async_map_1(args) = thread_map(args[0], *args[1:])
-    async def async_map_2([func] + iters) = thread_map(func, *iters)
-    async match def async_map_3([func] + iters) = thread_map(func, *iters)
-    match async def async_map_4([func] + iters) = thread_map(func, *iters)
+    async def async_map_1(args) = map(args[0], *args[1:])
+    async def async_map_2([func] + iters) = map(func, *iters)
+    async match def async_map_3([func] + iters) = map(func, *iters)
+    match async def async_map_4([func] + iters) = map(func, *iters)
+    async case def async_map_5:
+        match([func] + iters) = map(func, *iters)
+    case async def async_map_6:
+        match([func] + iters) = map(func, *iters)
     async def async_map_test() =
-        for async_map_ in (async_map_0, async_map_1, async_map_2, async_map_3, async_map_4):
+        for async_map_ in (async_map_0, async_map_1, async_map_2, async_map_3, async_map_4, async_map_5, async_map_6):
             assert (await ((pow$(2), range(5)) |> async_map_)) |> tuple == (1, 2, 4, 8, 16)
         True
 

{coconut-develop-3.1.0.post0.dev4 → coconut-develop-3.1.0.post0.dev6}/coconut/tests/src/extras.coco

@@ -474,8 +474,7 @@ type Num = int | float""".strip())
     assert parse("type L[T] = list[T]").strip().endswith("""
 # Compiled Coconut: -----------------------------------------------------------
 
-_coconut_typevar_T_0 = _coconut.typing.TypeVar("_coconut_typevar_T_0")
-type L = list[_coconut_typevar_T_0]""".strip())
+type L[T] = list[T]""".strip())
 
     setup(line_numbers=False, minify=True)
     assert parse("123  # derp", "lenient") == "123# derp"