PyPI - coconut-develop - Versions diffs - 3.1.0.post0.dev7__tar.gz → 3.1.0.post0.dev9__tar.gz - Mend

coconut-develop 3.1.0.post0.dev7tar.gz → 3.1.0.post0.dev9tar.gz

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (89) hide show

{coconut-develop-3.1.0.post0.dev7 → coconut-develop-3.1.0.post0.dev9}/DOCS.md RENAMED Viewed

@@ -1320,11 +1320,10 @@ data Empty() from Tree
 data Leaf(n) from Tree
 data Node(l, r) from Tree
-def depth(Tree()) = 0
-addpattern def depth(Tree(n)) = 1
-addpattern def depth(Tree(l, r)) = 1 + max([depth(l), depth(r)])
+case def depth:
+    match(Tree()) = 0
+    match(Tree(n)) = 1
+    match(Tree(l, r)) = 1 + max(depth(l), depth(r))
 Empty() |> depth |> print
 Leaf(5) |> depth |> print
@@ -1340,26 +1339,26 @@ def duplicate_first([x] + xs as l) =
 ```
 _Showcases head-tail splitting, one of the most common uses of pattern-matching, where a `+ <var>` (or `:: <var>` for any iterable) at the end of a list or tuple literal can be used to match the rest of the sequence._
-```
-def sieve([head] :: tail) =
-    [head] :: sieve(n for n in tail if n % head)
-addpattern def sieve((||)) = []
+```coconut
+case def sieve:
+    match([head] :: tail) =
+        [head] :: sieve(n for n in tail if n % head)
+    match((||)) = []
 ```
 _Showcases how to match against iterators, namely that the empty iterator case (`(||)`) must come last, otherwise that case will exhaust the whole iterator before any other pattern has a chance to match against it._
-```
+```coconut
 def odd_primes(p=3) =
     (p,) :: filter(=> _ % p != 0, odd_primes(p + 2))
 def primes() =
     (2,) :: odd_primes()
-def twin_primes(_ :: [p, (.-2) -> p] :: ps) =
-    [(p, p+2)] :: twin_primes([p + 2] :: ps)
-addpattern def twin_primes() =  # type: ignore
-    twin_primes(primes())
+case def twin_primes:
+    match(_ :: [p, (.-2) -> p] :: ps) =
+        [(p, p+2)] :: twin_primes([p + 2] :: ps)
+    match() =
+        twin_primes(primes())
 twin_primes()$[:5] |> list |> print
 ```
@@ -1522,15 +1521,14 @@ data Empty()
 data Leaf(n)
 data Node(l, r)
-def size(Empty()) = 0
-addpattern def size(Leaf(n)) = 1
-addpattern def size(Node(l, r)) = size(l) + size(r)
+case def size:
+    match(Empty()) = 0
+    match(Leaf(n)) = 1
+    match(Node(l, r)) = size(l) + size(r)
 size(Node(Empty(), Leaf(10))) == 1
 ```
-_Showcases the algebraic nature of `data` types when combined with pattern-matching._
+_Showcases the use of pattern-matching to deconstruct `data` types._
 ```coconut
 data vector(*pts):
@@ -2523,6 +2521,58 @@ range(5) |> last_two |> print
 _Can't be done without a long series of checks at the top of the function. See the compiled code for the Python syntax._
+### `case` Functions
+For easily defining a pattern-matching function with many different cases, Coconut provides the `case def` syntax based on Coconut's [`case`](#case) syntax. The basic syntax is
+```
+case def <name>:
+    match(<arg>, <arg>, ... [if <cond>]):
+        <body>
+    match(<arg>, <arg>, ... [if <cond>]):
+        <body>
+    ...
+```
+where the patterns in each `match` are checked in sequence until a match is found and the body under that match is executed, or a [`MatchError`](#matcherror) is raised. Each `match(...)` statement is effectively treated as a separate pattern-matching function signature that is checked independently, as if they had each been defined separately and then combined with [`addpattern`](#addpattern).
+Any individual body can also be defined with [assignment function syntax](#assignment-functions) such that
+```
+case def <name>:
+    match(<arg>, <arg>, ... [if <cond>]) = <body>
+```
+is equivalent to
+```
+case def <name>:
+    match(<arg>, <arg>, ... [if <cond>]): return <body>
+```
+`case` function definition can also be combined with `async` functions, [`copyclosure` functions](#copyclosure-functions), and [`yield` functions](#explicit-generators). The various keywords in front of the `def` can be put in any order.
+`case def` also allows for easily providing type annotations for pattern-matching functions. To add type annotations, inside the body of the `case def`, instead of just `match(...)` statements, include some `type(...)` statements as well, which will compile into [`typing.overload`](https://docs.python.org/3/library/typing.html#overload) declarations. The syntax is
+```
+case def <name>[<type vars>]:
+    type(<arg>: <type>, <arg>: <type>, ...) -> <type>
+    type(<arg>: <type>, <arg>: <type>, ...) -> <type>
+    ...
+```
+which can be interspersed with the `match(...)` statements.
+##### Example
+**Coconut:**
+```coconut
+case def my_min[T]:
+    type(x: T, y: T) -> T
+    match(x, y if x <= y) = x
+    match(x, y) = y
+    type(xs: T[]) -> T
+    match([x]) = x
+    match([x] + xs) = my_min(x, my_min(xs))
+```
+**Python:**
+_Can't be done without a long series of checks for each pattern-matching. See the compiled code for the Python syntax._
 ### `addpattern` Functions
 Coconut provides the `addpattern def` syntax as a shortcut for the full
@@ -2533,10 +2583,12 @@ match def func(...):
 ```
 syntax using the [`addpattern`](#addpattern) decorator.
-Additionally, `addpattern def` will act just like a normal [`match def`](#pattern-matching-functions) if the function has not previously been defined, allowing for `addpattern def` to be used for each case rather than requiring `match def` for the first case and `addpattern def` for future cases.
 If you want to put a decorator on an `addpattern def` function, make sure to put it on the _last_ pattern function.
+For complex multi-pattern functions, it is generally recommended to use [`case def`](#case-functions) over `addpattern def` in most situations.
+_Deprecated: `addpattern def` will act just like a normal [`match def`](#pattern-matching-functions) if the function has not previously been defined. This will show a [`CoconutWarning`](#coconutwarning) and is not recommended._
 ##### Example
 **Coconut:**
@@ -2954,7 +3006,7 @@ depth: 1
 Takes one argument that is a [pattern-matching function](#pattern-matching-functions), and returns a decorator that adds the patterns in the existing function to the new function being decorated, where the existing patterns are checked first, then the new. `addpattern` also supports a shortcut syntax where the new patterns can be passed in directly.
 Roughly equivalent to:
-```
+```coconut_python
 def _pattern_adder(base_func, add_func):
     def add_pattern_func(*args, **kwargs):
         try:
@@ -2992,7 +3044,7 @@ print_type()  # appears to work
 print_type(1) # TypeError: print_type() takes 0 positional arguments but 1 was given
 ```
-This can be fixed by using either the `match` or `addpattern` keyword. For example:
+This can be fixed by using either the `match` keyword. For example:
 ```coconut
 match def print_type():
     print("Received no arguments.")
@@ -3343,6 +3395,10 @@ Additionally, if you are using [view patterns](#match), you might need to raise
 In some cases where there are multiple Coconut packages installed at the same time, there may be multiple `MatchError`s defined in different packages. Coconut can perform some magic under the hood to make sure that all these `MatchError`s will seamlessly interoperate, but only if all such packages are compiled in [`--package` mode rather than `--standalone` mode](#compilation-modes).
+### `CoconutWarning`
+`CoconutWarning` is the [`Warning`](https://docs.python.org/3/library/exceptions.html#Warning) subclass used for all runtime Coconut warnings; see [`warnings`](https://docs.python.org/3/library/warnings.html).
 ### Generic Built-In Functions

{coconut-develop-3.1.0.post0.dev7 → coconut-develop-3.1.0.post0.dev9}/HELP.md RENAMED Viewed

@@ -379,7 +379,7 @@ def factorial(n):
 ```
 By making use of the [Coconut `addpattern` syntax](./DOCS.md#addpattern), we can take that from three indentation levels down to one. Take a look:
-```
+```coconut
 def factorial(0) = 1
 addpattern def factorial(int() as n if n > 0) =

{coconut-develop-3.1.0.post0.dev7 → coconut-develop-3.1.0.post0.dev9}/PKG-INFO RENAMED Viewed

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: coconut-develop
-Version: 3.1.0.post0.dev7
+Version: 3.1.0.post0.dev9
 Summary: Simple, elegant, Pythonic functional programming.
 Home-page: http://coconut-lang.org
 Author: Evan Hubinger
@@ -89,7 +89,7 @@ Description: |logo| Coconut
         __ 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,λ
+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

{coconut-develop-3.1.0.post0.dev7 → coconut-develop-3.1.0.post0.dev9}/__coconut__/__init__.pyi RENAMED Viewed

@@ -239,6 +239,11 @@ def scan(
 _coconut_scan = scan
+class CoconutWarning(Warning):
+    pass
+_coconut_CoconutWarning = CoconutWarning
 class MatchError(Exception):
     """Pattern-matching error. Has attributes .pattern, .value, and .message."""
     pattern: _t.Optional[_t.Text]
@@ -279,30 +284,30 @@ def call(
     _y: _U,
     _z: _V,
 ) -> _W: ...
-# @_t.overload
-# def call(
-#     _func: _t.Callable[_t.Concatenate[_T, _P], _U],
-#     _x: _T,
-#     *args: _t.Any,
-#     **kwargs: _t.Any,
-# ) -> _U: ...
-# @_t.overload
-# def call(
-#     _func: _t.Callable[_t.Concatenate[_T, _U, _P], _V],
-#     _x: _T,
-#     _y: _U,
-#     *args: _t.Any,
-#     **kwargs: _t.Any,
-# ) -> _V: ...
-# @_t.overload
-# def call(
-#     _func: _t.Callable[_t.Concatenate[_T, _U, _V, _P], _W],
-#     _x: _T,
-#     _y: _U,
-#     _z: _V,
-#     *args: _t.Any,
-#     **kwargs: _t.Any,
-# ) -> _W: ...
+@_t.overload
+def call(
+    _func: _t.Callable[_t.Concatenate[_T, _P], _U],
+    _x: _T,
+    *args: _t.Any,
+    **kwargs: _t.Any,
+) -> _U: ...
+@_t.overload
+def call(
+    _func: _t.Callable[_t.Concatenate[_T, _U, _P], _V],
+    _x: _T,
+    _y: _U,
+    *args: _t.Any,
+    **kwargs: _t.Any,
+) -> _V: ...
+@_t.overload
+def call(
+    _func: _t.Callable[_t.Concatenate[_T, _U, _V, _P], _W],
+    _x: _T,
+    _y: _U,
+    _z: _V,
+    *args: _t.Any,
+    **kwargs: _t.Any,
+) -> _W: ...
 @_t.overload
 def call(
     _func: _t.Callable[..., _T],
@@ -316,6 +321,7 @@ def call(
     """
     ...
+# call = _coconut.operator.call
 _coconut_tail_call = call
 of = _deprecated("use call instead")(call)

{coconut-develop-3.1.0.post0.dev7 → coconut-develop-3.1.0.post0.dev9}/coconut/__coconut__.pyi RENAMED Viewed

@@ -1,2 +1,2 @@
 from __coconut__ import *
-from __coconut__ import _coconut_tail_call, _coconut_tco, _coconut_call_set_names, _coconut_handle_cls_kwargs, _coconut_handle_cls_stargs, _namedtuple_of, _coconut, _coconut_Expected, _coconut_MatchError, _coconut_SupportsAdd, _coconut_SupportsMinus, _coconut_SupportsMul, _coconut_SupportsPow, _coconut_SupportsTruediv, _coconut_SupportsFloordiv, _coconut_SupportsMod, _coconut_SupportsAnd, _coconut_SupportsXor, _coconut_SupportsOr, _coconut_SupportsLshift, _coconut_SupportsRshift, _coconut_SupportsMatmul, _coconut_SupportsInv, _coconut_Expected, _coconut_MatchError, _coconut_iter_getitem, _coconut_base_compose, _coconut_forward_compose, _coconut_back_compose, _coconut_forward_star_compose, _coconut_back_star_compose, _coconut_forward_dubstar_compose, _coconut_back_dubstar_compose, _coconut_pipe, _coconut_star_pipe, _coconut_dubstar_pipe, _coconut_back_pipe, _coconut_back_star_pipe, _coconut_back_dubstar_pipe, _coconut_none_pipe, _coconut_none_star_pipe, _coconut_none_dubstar_pipe, _coconut_bool_and, _coconut_bool_or, _coconut_none_coalesce, _coconut_minus, _coconut_map, _coconut_partial, _coconut_complex_partial, _coconut_get_function_match_error, _coconut_base_pattern_func, _coconut_addpattern, _coconut_sentinel, _coconut_assert, _coconut_raise, _coconut_mark_as_match, _coconut_reiterable, _coconut_self_match_types, _coconut_dict_merge, _coconut_exec, _coconut_comma_op, _coconut_arr_concat_op, _coconut_mk_anon_namedtuple, _coconut_matmul, _coconut_py_str, _coconut_flatten, _coconut_multiset, _coconut_back_none_pipe, _coconut_back_none_star_pipe, _coconut_back_none_dubstar_pipe, _coconut_forward_none_compose, _coconut_back_none_compose, _coconut_forward_none_star_compose, _coconut_back_none_star_compose, _coconut_forward_none_dubstar_compose, _coconut_back_none_dubstar_compose, _coconut_call_or_coefficient, _coconut_in, _coconut_not_in, _coconut_attritemgetter, _coconut_if_op
+from __coconut__ import _coconut_tail_call, _coconut_tco, _coconut_call_set_names, _coconut_handle_cls_kwargs, _coconut_handle_cls_stargs, _namedtuple_of, _coconut, _coconut_Expected, _coconut_MatchError, _coconut_SupportsAdd, _coconut_SupportsMinus, _coconut_SupportsMul, _coconut_SupportsPow, _coconut_SupportsTruediv, _coconut_SupportsFloordiv, _coconut_SupportsMod, _coconut_SupportsAnd, _coconut_SupportsXor, _coconut_SupportsOr, _coconut_SupportsLshift, _coconut_SupportsRshift, _coconut_SupportsMatmul, _coconut_SupportsInv, _coconut_Expected, _coconut_MatchError, _coconut_iter_getitem, _coconut_base_compose, _coconut_forward_compose, _coconut_back_compose, _coconut_forward_star_compose, _coconut_back_star_compose, _coconut_forward_dubstar_compose, _coconut_back_dubstar_compose, _coconut_pipe, _coconut_star_pipe, _coconut_dubstar_pipe, _coconut_back_pipe, _coconut_back_star_pipe, _coconut_back_dubstar_pipe, _coconut_none_pipe, _coconut_none_star_pipe, _coconut_none_dubstar_pipe, _coconut_bool_and, _coconut_bool_or, _coconut_none_coalesce, _coconut_minus, _coconut_map, _coconut_partial, _coconut_complex_partial, _coconut_get_function_match_error, _coconut_base_pattern_func, _coconut_addpattern, _coconut_sentinel, _coconut_assert, _coconut_raise, _coconut_mark_as_match, _coconut_reiterable, _coconut_self_match_types, _coconut_dict_merge, _coconut_exec, _coconut_comma_op, _coconut_arr_concat_op, _coconut_mk_anon_namedtuple, _coconut_matmul, _coconut_py_str, _coconut_flatten, _coconut_multiset, _coconut_back_none_pipe, _coconut_back_none_star_pipe, _coconut_back_none_dubstar_pipe, _coconut_forward_none_compose, _coconut_back_none_compose, _coconut_forward_none_star_compose, _coconut_back_none_star_compose, _coconut_forward_none_dubstar_compose, _coconut_back_none_dubstar_compose, _coconut_call_or_coefficient, _coconut_in, _coconut_not_in, _coconut_attritemgetter, _coconut_if_op, _coconut_CoconutWarning

{coconut-develop-3.1.0.post0.dev7 → coconut-develop-3.1.0.post0.dev9}/coconut/compiler/compiler.py RENAMED Viewed

@@ -2390,6 +2390,7 @@ else:
 try:
     {addpattern_decorator} = _coconut_addpattern({func_name}) {type_ignore}
 except _coconut.NameError:
+    _coconut.warnings.warn("Deprecated use of 'addpattern def {func_name}' with no prior 'match def {func_name}'", _coconut_CoconutWarning)
     {addpattern_decorator} = lambda f: f
                     """,
                     add_newline=True,
@@ -2557,33 +2558,25 @@ def {mock_var}({mock_paramdef}):
         # handle typed case def functions (must happen before decorators are cleared out)
         type_code = None
         if typed_case_def:
+            internal_assert(len(all_type_defs) not in (0, 2), "invalid typed case def all_type_defs", all_type_defs)
             if undotted_name is not None:
                 all_type_defs = [
                     "def " + def_name + assert_remove_prefix(type_def, "def " + func_name)
                     for type_def in all_type_defs
                 ]
-            type_code = (
-                self.deferred_code_proc(type_param_code)
-                + "\n".join(
-                    ("@_coconut.typing.overload\n" if len(all_type_defs) > 1 else "")
+            type_def_lines = []
+            for i, type_def in enumerate(all_type_defs):
+                type_def_lines.append(
+                    ("@_coconut.typing.overload\n" if i < len(all_type_defs) - 1 else "")
                     + decorators
                     + self.deferred_code_proc(type_def)
-                    for type_def in all_type_defs
-                )
-            )
-            if len(all_type_defs) > 1:
-                type_code += "\n" + decorators + handle_indentation("""
-def {def_name}(*_coconut_args, **_coconut_kwargs):
-    return {any_type_ellipsis}
-                """).format(
-                    def_name=def_name,
-                    any_type_ellipsis=self.any_type_ellipsis(),
                 )
             if undotted_name is not None:
-                type_code += "\n{func_name} = {def_name}".format(
+                type_def_lines.append("{func_name} = {def_name}".format(
                     func_name=func_name,
                     def_name=def_name,
-                )
+                ))
+            type_code = self.deferred_code_proc(type_param_code) + "\n".join(type_def_lines)
         # handle dotted function definition
         if undotted_name is not None:
@@ -3919,11 +3912,13 @@ if not {check_var}:
                 typed_params, typed_ret = case_toks
                 all_type_defs.append(handle_indentation("""
 def {name}{typed_params}{typed_ret}
+    {docstring}
     return {ellipsis}
                 """).format(
                     name=name,
                     typed_params=typed_params,
                     typed_ret=typed_ret,
+                    docstring=docstring if docstring is not None else "",
                     ellipsis=self.any_type_ellipsis(),
                 ))
             else:
@@ -3931,6 +3926,16 @@ def {name}{typed_params}{typed_ret}
         if type_param_code and not all_type_defs:
             raise CoconutDeferredSyntaxError("type parameters in case def but no type declaration cases", loc)
+        if len(all_type_defs) > 1:
+            all_type_defs.append(handle_indentation("""
+def {name}(*_coconut_args, **_coconut_kwargs):
+    {docstring}
+    return {ellipsis}
+            """).format(
+                name=name,
+                docstring=docstring if docstring is not None else "",
+                ellipsis=self.any_type_ellipsis(),
+            ))
         func_code = handle_indentation("""
 def {name}({match_func_paramdef}):

{coconut-develop-3.1.0.post0.dev7 → coconut-develop-3.1.0.post0.dev9}/coconut/compiler/grammar.py RENAMED Viewed

@@ -2256,6 +2256,7 @@ class Grammar(object):
         op_tfpdef = unsafe_typedef_default | condense(setname + Optional(default))
         op_funcdef_arg = setname | condense(lparen.suppress() + op_tfpdef + rparen.suppress())
         op_funcdef_name = unsafe_backtick.suppress() + funcname_typeparams + unsafe_backtick.suppress()
+        op_funcdef_name_tokens = unsafe_backtick.suppress() + funcname_typeparams_tokens + unsafe_backtick.suppress()
         op_funcdef = attach(
             Group(Optional(op_funcdef_arg))
             + op_funcdef_name
@@ -2359,7 +2360,10 @@ class Grammar(object):
         base_case_funcdef = Forward()
         base_case_funcdef_ref = (
             keyword("def").suppress()
-            + Group(funcname_typeparams_tokens)
+            + Group(
+                funcname_typeparams_tokens
+                | op_funcdef_name_tokens
+            )
             + colon.suppress()
             - newline.suppress()
             - indent.suppress()

{coconut-develop-3.1.0.post0.dev7 → coconut-develop-3.1.0.post0.dev9}/coconut/compiler/header.py RENAMED Viewed

@@ -641,7 +641,7 @@ for _coconut_varname in dir(MatchError):
     #  (extra_format_dict is to keep indentation levels matching)
     extra_format_dict = dict(
         # when anything is added to this list it must also be added to *both* __coconut__ stub files
-        underscore_imports="{tco_comma}{call_set_names_comma}{handle_cls_args_comma}_namedtuple_of, _coconut, _coconut_Expected, _coconut_MatchError, _coconut_SupportsAdd, _coconut_SupportsMinus, _coconut_SupportsMul, _coconut_SupportsPow, _coconut_SupportsTruediv, _coconut_SupportsFloordiv, _coconut_SupportsMod, _coconut_SupportsAnd, _coconut_SupportsXor, _coconut_SupportsOr, _coconut_SupportsLshift, _coconut_SupportsRshift, _coconut_SupportsMatmul, _coconut_SupportsInv, _coconut_iter_getitem, _coconut_base_compose, _coconut_forward_compose, _coconut_back_compose, _coconut_forward_star_compose, _coconut_back_star_compose, _coconut_forward_dubstar_compose, _coconut_back_dubstar_compose, _coconut_pipe, _coconut_star_pipe, _coconut_dubstar_pipe, _coconut_back_pipe, _coconut_back_star_pipe, _coconut_back_dubstar_pipe, _coconut_none_pipe, _coconut_none_star_pipe, _coconut_none_dubstar_pipe, _coconut_bool_and, _coconut_bool_or, _coconut_none_coalesce, _coconut_minus, _coconut_map, _coconut_partial, _coconut_complex_partial, _coconut_get_function_match_error, _coconut_base_pattern_func, _coconut_addpattern, _coconut_sentinel, _coconut_assert, _coconut_raise, _coconut_mark_as_match, _coconut_reiterable, _coconut_self_match_types, _coconut_dict_merge, _coconut_exec, _coconut_comma_op, _coconut_arr_concat_op, _coconut_mk_anon_namedtuple, _coconut_matmul, _coconut_py_str, _coconut_flatten, _coconut_multiset, _coconut_back_none_pipe, _coconut_back_none_star_pipe, _coconut_back_none_dubstar_pipe, _coconut_forward_none_compose, _coconut_back_none_compose, _coconut_forward_none_star_compose, _coconut_back_none_star_compose, _coconut_forward_none_dubstar_compose, _coconut_back_none_dubstar_compose, _coconut_call_or_coefficient, _coconut_in, _coconut_not_in, _coconut_attritemgetter, _coconut_if_op".format(**format_dict),
+        underscore_imports="{tco_comma}{call_set_names_comma}{handle_cls_args_comma}_namedtuple_of, _coconut, _coconut_Expected, _coconut_MatchError, _coconut_SupportsAdd, _coconut_SupportsMinus, _coconut_SupportsMul, _coconut_SupportsPow, _coconut_SupportsTruediv, _coconut_SupportsFloordiv, _coconut_SupportsMod, _coconut_SupportsAnd, _coconut_SupportsXor, _coconut_SupportsOr, _coconut_SupportsLshift, _coconut_SupportsRshift, _coconut_SupportsMatmul, _coconut_SupportsInv, _coconut_iter_getitem, _coconut_base_compose, _coconut_forward_compose, _coconut_back_compose, _coconut_forward_star_compose, _coconut_back_star_compose, _coconut_forward_dubstar_compose, _coconut_back_dubstar_compose, _coconut_pipe, _coconut_star_pipe, _coconut_dubstar_pipe, _coconut_back_pipe, _coconut_back_star_pipe, _coconut_back_dubstar_pipe, _coconut_none_pipe, _coconut_none_star_pipe, _coconut_none_dubstar_pipe, _coconut_bool_and, _coconut_bool_or, _coconut_none_coalesce, _coconut_minus, _coconut_map, _coconut_partial, _coconut_complex_partial, _coconut_get_function_match_error, _coconut_base_pattern_func, _coconut_addpattern, _coconut_sentinel, _coconut_assert, _coconut_raise, _coconut_mark_as_match, _coconut_reiterable, _coconut_self_match_types, _coconut_dict_merge, _coconut_exec, _coconut_comma_op, _coconut_arr_concat_op, _coconut_mk_anon_namedtuple, _coconut_matmul, _coconut_py_str, _coconut_flatten, _coconut_multiset, _coconut_back_none_pipe, _coconut_back_none_star_pipe, _coconut_back_none_dubstar_pipe, _coconut_forward_none_compose, _coconut_back_none_compose, _coconut_forward_none_star_compose, _coconut_back_none_star_compose, _coconut_forward_none_dubstar_compose, _coconut_back_none_dubstar_compose, _coconut_call_or_coefficient, _coconut_in, _coconut_not_in, _coconut_attritemgetter, _coconut_if_op, _coconut_CoconutWarning".format(**format_dict),
         import_typing=pycondition(
             (3, 5),
             if_ge='''
@@ -865,6 +865,21 @@ def async_map(*args, **kwargs):
                 "{_coconut_}zip".format(**format_dict): "zip",
             },
         ),
+        def_call=pycondition(
+            (3, 11),
+            if_ge=r'''
+call = _coconut.operator.call
+            ''',
+            if_lt=r'''
+def call(_coconut_f{comma_slash}, *args, **kwargs):
+    """Function application operator function.
+    Equivalent to:
+        def call(f, /, *args, **kwargs) = f(*args, **kwargs).
+    """
+    return _coconut_f(*args, **kwargs)
+            '''.format(**format_dict),
+        ),
     )
     format_dict.update(extra_format_dict)

{coconut-develop-3.1.0.post0.dev7 → coconut-develop-3.1.0.post0.dev9}/coconut/compiler/templates/header.py_template RENAMED Viewed

@@ -136,6 +136,10 @@ def _coconut_xarray_to_numpy(obj):
         return obj.to_dataframe().to_numpy()
     else:
         return obj.to_numpy()
+class CoconutWarning(Warning{comma_object}):
+    """Exception class used for all Coconut warnings."""
+    __slots__ = ()
+_coconut_CoconutWarning = CoconutWarning
 class MatchError(_coconut_baseclass, Exception):
     """Pattern-matching error. Has attributes .pattern, .value, and .message."""{COMMENT.no_slots_to_allow_setattr_below}
     max_val_repr_len = 500
@@ -1439,7 +1443,7 @@ def addpattern(base_func, *add_funcs, **kwargs):
     """
     allow_any_func = kwargs.pop("allow_any_func", False)
     if not allow_any_func and not _coconut.getattr(base_func, "_coconut_is_match", False):
-        _coconut.warnings.warn("Possible misuse of addpattern with non-pattern-matching function " + _coconut.repr(base_func) + " (pass allow_any_func=True to dismiss)", stacklevel=2)
+        _coconut.warnings.warn("Possible misuse of addpattern with non-pattern-matching function " + _coconut.repr(base_func) + " (pass allow_any_func=True to dismiss)", _coconut_CoconutWarning, 2)
     if kwargs:
         raise _coconut.TypeError("addpattern() got unexpected keyword arguments " + _coconut.repr(kwargs))
     if add_funcs:
@@ -1709,13 +1713,7 @@ def ident(x, **kwargs):
     if side_effect is not None:
         side_effect(x)
     return x
-def call(_coconut_f{comma_slash}, *args, **kwargs):
-    """Function application operator function.
-    Equivalent to:
-        def call(f, /, *args, **kwargs) = f(*args, **kwargs).
-    """
-    return _coconut_f(*args, **kwargs)
+{def_call}
 def safe_call(_coconut_f{comma_slash}, *args, **kwargs):
     """safe_call is a version of call that catches any Exceptions and
     returns an Expected containing either the result or the error.

{coconut-develop-3.1.0.post0.dev7 → coconut-develop-3.1.0.post0.dev9}/coconut/constants.py RENAMED Viewed

@@ -287,10 +287,10 @@ match_set_name_var = reserved_prefix + "_match_set_name"
 openindent = "\u204b"  # reverse pilcrow
 closeindent = "\xb6"  # pilcrow
 strwrapper = "\u25b6"  # black right-pointing triangle
-errwrapper = "\u24d8"  # circled letter i
 early_passthrough_wrapper = "\u2038"  # caret
 lnwrapper = "\u2021"  # double dagger
 unwrapper = "\u23f9"  # stop square
+errwrapper = "\u24d8"  # circled letter i
 tempsep = "\u22ee"  # vertical ellipsis
 funcwrapper = "def:"
@@ -309,12 +309,16 @@ str_chars = "'\""  # string open/close chars
 # together should include all the constants defined above
 delimiter_symbols = tuple(open_chars + close_chars + str_chars) + (
     strwrapper,
-    errwrapper,
     early_passthrough_wrapper,
     unwrapper,
+    "`",
+    ":",
+    ",",
+    ";",
 ) + indchars + comment_chars
 reserved_compiler_symbols = delimiter_symbols + (
     reserved_prefix,
+    errwrapper,
     tempsep,
     funcwrapper,
 )
@@ -835,6 +839,7 @@ must_use_specific_target_builtins = (
 coconut_exceptions = (
     "MatchError",
+    "CoconutWarning",
 )
 highlight_builtins = coconut_specific_builtins + interp_only_builtins + python_builtins

{coconut-develop-3.1.0.post0.dev7 → coconut-develop-3.1.0.post0.dev9}/coconut/root.py RENAMED Viewed

@@ -26,7 +26,7 @@ import sys as _coconut_sys
 VERSION = "3.1.0"
 VERSION_NAME = None
 # False for release, int >= 1 for develop
-DEVELOP = 7
+DEVELOP = 9
 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.dev7 → coconut-develop-3.1.0.post0.dev9}/coconut/tests/main_test.py RENAMED Viewed

@@ -174,8 +174,10 @@ ignore_last_lines_with = (
     "DeprecationWarning: The distutils package is deprecated",
     "from distutils.version import LooseVersion",
     ": SyntaxWarning: 'int' object is not ",
+    ": CoconutWarning: Deprecated use of ",
     " assert_raises(",
     "Populating initial parsing cache",
+    "_coconut.warnings.warn(",
 )
 kernel_installation_msg = (
@@ -681,7 +683,7 @@ def run(
     assert use_run_arg + run_directory < 2
     if manage_cache and "--no-cache" not in args:
-        args += ["--no-cache"]
+        args = ["--no-cache"] + args
     if agnostic_target is None:
         agnostic_args = args

{coconut-develop-3.1.0.post0.dev7 → coconut-develop-3.1.0.post0.dev9}/coconut/tests/src/cocotest/agnostic/primary_2.coco RENAMED Viewed

@@ -458,6 +458,7 @@ def primary_test_2() -> bool:
     assert min((), default=10) == 10 == max((), default=10)
     assert py_min(3, 4) == 3 == py_max(2, 3)
     assert len(zip()) == 0 == len(zip_longest())  # type: ignore
+    assert CoconutWarning `issubclass` Warning
     with process_map.multiple_sequential_calls():  # type: ignore
         assert map((+), range(3), range(4)$[:-1], strict=True) |> list == [0, 2, 4] == process_map((+), range(3), range(4)$[:-1], strict=True) |> list  # type: ignore

{coconut-develop-3.1.0.post0.dev7 → coconut-develop-3.1.0.post0.dev9}/coconut/tests/src/cocotest/agnostic/suite.coco RENAMED Viewed

@@ -10,6 +10,7 @@ from .util import operator CONST
 from .util import operator “
 from .util import operator ”
 from .util import operator !
+from .util import operator <>
 operator lol
 operator ++
@@ -152,9 +153,11 @@ def suite_test() -> bool:
     assert -4 == neg_square_u(2) ≠ 4 ∩ 0 ≤ neg_square_u(0) ≤ 0
     assert is_null(null1())
     assert is_null(null2())
-    assert empty() |> depth_1 == 0 == empty() |> depth_2
-    assert leaf(5) |> depth_1 == 1 == leaf(5) |> depth_2
-    assert node(leaf(2), node(empty(), leaf(3))) |> depth_1 == 3 == node(leaf(2), node(empty(), leaf(3))) |> depth_2
+    for depth in (depth_1, depth_2, depth_3):
+        assert empty() |> depth == 0  # type: ignore
+        assert leaf(5) |> depth == 1  # type: ignore
+        assert node(leaf(2), node(empty(), leaf(3))) |> depth == 3  # type: ignore
+    assert size(node(empty(), leaf(10))) == 1 == size_(node(empty(), leaf(10)))
     assert maybes(5, square, plus1) == 26
     assert maybes(None, square, plus1) is None
     assert square <| 2 == 4
@@ -870,7 +873,7 @@ forward 2""") == 900
     assert split1_comma(",") == ("", "")
     assert split1_comma("abcd") == ("abcd", "")
     assert primes()$[:5] |> tuple == (2, 3, 5, 7, 11)
-    assert twin_primes()$[:5] |> list == [(3, 5), (5, 7), (11, 13), (17, 19), (29, 31)]
+    assert twin_primes()$[:5] |> list == [(3, 5), (5, 7), (11, 13), (17, 19), (29, 31)] == twin_primes_()$[:5] |> list
     assert stored_default(2) == [2, 1] == stored_default_cls()(2)
     assert stored_default(2) == [2, 1, 2, 1] == stored_default_cls()(2)
     if sys.version_info >= (3,):  # naive namespace classes don't work on py2
@@ -1088,6 +1091,7 @@ forward 2""") == 900
     assert [1, 2, 3] |> reduce_with_init$(+) == 6 == (1, 2, 3) |> iter |> reduce_with_init$((+), init=0)
     assert min(1, 2) == 1 == my_min(1, 2)
     assert min([1, 2]) == 1 == my_min([1, 2])
+    assert 3 <> 4
     with process_map.multiple_sequential_calls():  # type: ignore
         assert process_map(tuple <.. (|>)$(to_sort), qsorts) |> list == [to_sort |> sorted |> tuple] * len(qsorts)

{coconut-develop-3.1.0.post0.dev7 → coconut-develop-3.1.0.post0.dev9}/coconut/tests/src/cocotest/agnostic/util.coco RENAMED Viewed

@@ -245,6 +245,12 @@ addpattern def (float(x))! = 0.0 if x else 1.0  # type: ignore
 addpattern def x! if x = False  # type: ignore
 addpattern def x! = True  # type: ignore
+operator <>
+case def <>:
+    match(x, y if x < y) = True
+    match(x, y if x > y) = True
+    match(x, y) = False
 # Type aliases:
 if sys.version_info >= (3, 5) or TYPE_CHECKING:
     type list_or_tuple = list | tuple
@@ -787,6 +793,20 @@ def depth_2(t):
     match tree(l=l, r=r) in t:
         return 1 + max([depth_2(l), depth_2(r)])
+case def depth_3:
+    match(tree()) = 0
+    match(tree(n=n)) = 1
+    match(tree(l=l, r=r)) = 1 + max(depth_3(l), depth_3(r))
+def size(empty()) = 0
+addpattern def size(leaf(n)) = 1  # type: ignore
+addpattern def size(node(l, r)) = size(l) + size(r)  # type: ignore
+case def size_:
+    match(empty()) = 0
+    match(leaf(n)) = 1
+    match(node(l, r)) = size_(l) + size_(r)
 class Tree
 data Node(*children) from Tree
 data Leaf(elem) from Tree
@@ -1940,6 +1960,12 @@ def twin_primes(_ :: [p, (.-2) -> p] :: ps) =
 addpattern def twin_primes() =  # type: ignore
     twin_primes(primes())
+case def twin_primes_:
+    match(_ :: [p, (.-2) -> p] :: ps) =
+        [(p, p+2)] :: twin_primes_([p + 2] :: ps)
+    match() =
+        twin_primes_(primes())
 # class matching
 class HasElems:

{coconut-develop-3.1.0.post0.dev7 → coconut-develop-3.1.0.post0.dev9}/coconut/tests/src/extras.coco RENAMED Viewed

@@ -1,4 +1,5 @@
 import os
+import sys
 from collections.abc import Sequence
 os.environ["COCONUT_USE_COLOR"] = "False"
@@ -14,6 +15,7 @@ from coconut.constants import (
     PYPY,
 )  # type: ignore
 from coconut._pyparsing import USE_COMPUTATION_GRAPH  # type: ignore
+from coconut.terminal import logger
 from coconut.exceptions import (
     CoconutSyntaxError,
     CoconutStyleError,
@@ -325,7 +327,8 @@ def g(x) = x
     return True
-def test_convenience() -> bool:
+def test_api() -> bool:
+    assert not logger.enable_colors(sys.stdout)
     if IPY:
         import coconut.highlighter  # noqa # type: ignore
@@ -733,7 +736,7 @@ def test_extras() -> bool:
     print(".")  # newline bc we print stuff after this
     assert test_setup_none() is True  # ...
     print(".")  # ditto
-    assert test_convenience() is True  # ....
+    assert test_api() is True  # ....
     # everything after here uses incremental parsing, so it must come last
     print(".", end="")
     assert test_incremental() is True  # .....