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

coconut-develop 3.1.0.post0.dev9tar.gz → 3.1.0.post0.dev10tar.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.dev9 → coconut-develop-3.1.0.post0.dev10}/DOCS.md RENAMED Viewed

@@ -543,9 +543,9 @@ a `b` c,               left (captures lambda)
   all custom operators
 ??                     left (short-circuits)
 ..>, <.., ..*>, <*..,  n/a (captures lambda)
-  ..**>, <**..
+  ..**>, <**.., etc.
 |>, <|, |*>, <*|,      left (captures lambda)
-  |**>, <**|
+  |**>, <**|, etc.
 ==, !=, <, >,
   <=, >=,
   in, not in,
@@ -1387,7 +1387,7 @@ match <value>:
 ```
 where `<pattern>` is any `match` pattern, `<value>` is the item to match against, `<cond>` is an optional additional check, and `<body>` is simply code that is executed if the header above it succeeds. Note the absence of an `in` in the `match` statements: that's because the `<value>` in `case <value>` is taking its place. If no `else` is present and no match succeeds, then the `case` statement is simply skipped over as with [`match` statements](#match) (though unlike [destructuring assignments](#destructuring-assignment)).
-Additionally, `cases` can be used as the top-level keyword instead of `match`, and in such a `case` block `match` is allowed for each case rather than `case`. _Deprecated: Coconut also supports `case` instead of `cases` as the top-level keyword for backwards-compatibility purposes._
+_Deprecated: Additionally, `cases` or `case` can be used as the top-level keyword instead of `match`, and in such a block `match` is used for each case rather than `case`._
 ##### Examples
@@ -2219,7 +2219,7 @@ quad = 5 * x**2 + 3 * x + 1
 When passing in long variable names as keyword arguments of the same name, Coconut supports the syntax
 ```
-f(...=long_variable_name)
+f(long_variable_name=)
 ```
 as a shorthand for
 ```
@@ -2228,6 +2228,8 @@ f(long_variable_name=long_variable_name)
 Such syntax is also supported in [partial application](#partial-application) and [anonymous `namedtuple`s](#anonymous-namedtuples).
+_Deprecated: Coconut also supports `f(...=long_variable_name)` as an alternative shorthand syntax._
 ##### Example
 **Coconut:**
@@ -2235,8 +2237,8 @@ Such syntax is also supported in [partial application](#partial-application) and
 really_long_variable_name_1 = get_1()
 really_long_variable_name_2 = get_2()
 main_func(
-    ...=really_long_variable_name_1,
-    ...=really_long_variable_name_2,
+    really_long_variable_name_1=,
+    really_long_variable_name_2=,
 )
 ```

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: coconut-develop
-Version: 3.1.0.post0.dev9
+Version: 3.1.0.post0.dev10
 Summary: Simple, elegant, Pythonic functional programming.
 Home-page: http://coconut-lang.org
 Author: Evan Hubinger

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

@@ -539,6 +539,7 @@ class Compiler(Grammar, pickleable_obj):
         self.add_code_before_replacements = {}
         self.add_code_before_ignore_names = {}
         self.remaining_original = None
+        self.shown_warnings = set()
     @contextmanager
     def inner_environment(self, ln=None):
@@ -556,6 +557,7 @@ class Compiler(Grammar, pickleable_obj):
         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
+        shown_warnings, self.shown_warnings = self.shown_warnings, set()
         try:
             with ComputationNode.using_overrides():
                 yield
@@ -571,6 +573,7 @@ class Compiler(Grammar, pickleable_obj):
             self.kept_lines = kept_lines
             self.num_lines = num_lines
             self.remaining_original = remaining_original
+            self.shown_warnings = shown_warnings
     @contextmanager
     def disable_checks(self):
@@ -937,11 +940,14 @@ class Compiler(Grammar, pickleable_obj):
         if self.strict:
             raise self.make_err(CoconutStyleError, *args, **kwargs)
-    def syntax_warning(self, *args, **kwargs):
+    def syntax_warning(self, message, original, loc, **kwargs):
         """Show a CoconutSyntaxWarning. Usage:
             self.syntax_warning(message, original, loc)
         """
-        logger.warn_err(self.make_err(CoconutSyntaxWarning, *args, **kwargs))
+        key = (message, loc)
+        if key not in self.shown_warnings:
+            logger.warn_err(self.make_err(CoconutSyntaxWarning, message, original, loc, **kwargs))
+            self.shown_warnings.add(key)
     def strict_err_or_warn(self, *args, **kwargs):
         """Raises an error if in strict mode, otherwise raises a warning. Usage:
@@ -2390,7 +2396,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)
+    _coconut.warnings.warn("Deprecated use of 'addpattern def {func_name}' with no pre-existing '{func_name}' function (use 'match def {func_name}' for the first definition or switch to 'case def' syntax)", _coconut_CoconutWarning)
     {addpattern_decorator} = lambda f: f
                     """,
                     add_newline=True,
@@ -2779,7 +2785,7 @@ else:
 # HANDLERS:
 # -----------------------------------------------------------------------------------------------------------------------
-    def split_function_call(self, tokens, loc):
+    def split_function_call(self, original, loc, tokens):
         """Split into positional arguments and keyword arguments."""
         pos_args = []
         star_args = []
@@ -2802,7 +2808,10 @@ else:
                     star_args.append(argstr)
                 elif arg[0] == "**":
                     dubstar_args.append(argstr)
+                elif arg[1] == "=":
+                    kwd_args.append(arg[0] + "=" + arg[0])
                 elif arg[0] == "...":
+                    self.strict_err_or_warn("'...={name}' shorthand is deprecated, use '{name}=' shorthand instead".format(name=arg[1]), original, loc)
                     kwd_args.append(arg[1] + "=" + arg[1])
                 else:
                     kwd_args.append(argstr)
@@ -2818,9 +2827,9 @@ else:
         return pos_args, star_args, kwd_args, dubstar_args
-    def function_call_handle(self, loc, tokens):
+    def function_call_handle(self, original, loc, tokens):
         """Enforce properly ordered function parameters."""
-        return "(" + join_args(*self.split_function_call(tokens, loc)) + ")"
+        return "(" + join_args(*self.split_function_call(original, loc, tokens)) + ")"
     def pipe_item_split(self, original, loc, tokens):
         """Process a pipe item, which could be a partial, an attribute access, a method call, or an expression.
@@ -2841,7 +2850,7 @@ else:
             return "expr", tokens
         elif "partial" in tokens:
             func, args = tokens
-            pos_args, star_args, kwd_args, dubstar_args = self.split_function_call(args, loc)
+            pos_args, star_args, kwd_args, dubstar_args = self.split_function_call(original, loc, args)
             return "partial", (func, join_args(pos_args, star_args), join_args(kwd_args, dubstar_args))
         elif "attrgetter" in tokens:
             name, args = attrgetter_atom_split(tokens)
@@ -3061,7 +3070,7 @@ else:
                 elif trailer[0] == "$[":
                     out = "_coconut_iter_getitem(" + out + ", " + trailer[1] + ")"
                 elif trailer[0] == "$(?":
-                    pos_args, star_args, base_kwd_args, dubstar_args = self.split_function_call(trailer[1], loc)
+                    pos_args, star_args, base_kwd_args, dubstar_args = self.split_function_call(original, loc, trailer[1])
                     has_question_mark = False
                     needs_complex_partial = False
@@ -3232,7 +3241,7 @@ while True:
         # handle classlist
         base_classes = []
         if classlist_toks:
-            pos_args, star_args, kwd_args, dubstar_args = self.split_function_call(classlist_toks, loc)
+            pos_args, star_args, kwd_args, dubstar_args = self.split_function_call(original, loc, classlist_toks)
             # check for just inheriting from object
             if (
@@ -3566,7 +3575,7 @@ def __hash__(self):
         return "".join(out)
-    def anon_namedtuple_handle(self, tokens):
+    def anon_namedtuple_handle(self, original, loc, tokens):
         """Handle anonymous named tuples."""
         names = []
         types = {}
@@ -3579,7 +3588,10 @@ def __hash__(self):
                 types[i] = typedef
             else:
                 raise CoconutInternalException("invalid anonymous named item", tok)
-            if name == "...":
+            if item == "=":
+                item = name
+            elif name == "...":
+                self.strict_err_or_warn("'...={item}' shorthand is deprecated, use '{item}=' shorthand instead".format(item=item), original, loc)
                 name = item
             names.append(name)
             items.append(item)
@@ -3924,8 +3936,11 @@ def {name}{typed_params}{typed_ret}
             else:
                 raise CoconutInternalException("invalid case_funcdef case_toks", case_toks)
+        if not all_case_code:
+            raise CoconutDeferredSyntaxError("case def with no match cases", loc)
         if type_param_code and not all_type_defs:
-            raise CoconutDeferredSyntaxError("type parameters in case def but no type declaration cases", loc)
+            raise CoconutDeferredSyntaxError("type parameters in case def but no type cases", loc)
         if len(all_type_defs) > 1:
             all_type_defs.append(handle_indentation("""
 def {name}(*_coconut_args, **_coconut_kwargs):
@@ -4267,9 +4282,20 @@ __annotations__["{name}"] = {annotation}
         else:
             raise CoconutInternalException("invalid case tokens", tokens)
-        self.internal_assert(block_kwd in ("cases", "case", "match"), original, loc, "invalid case statement keyword", block_kwd)
         if block_kwd == "case":
-            self.strict_err_or_warn("deprecated case keyword at top level in case ...: match ...: block (use Python 3.10 match ...: case ...: syntax instead)", original, loc)
+            self.strict_err_or_warn(
+                "deprecated case keyword at top level in case ...: match ...: block (use Python 3.10 match ...: case ...: syntax instead)",
+                original,
+                loc,
+            )
+        elif block_kwd == "cases":
+            self.syntax_warning(
+                "deprecated cases keyword at top level in cases ...: match ...: block (use Python 3.10 match ...: case ...: syntax instead)",
+                original,
+                loc,
+            )
+        else:
+            self.internal_assert(block_kwd == "match", original, loc, "invalid case statement keyword", block_kwd)
         check_var = self.get_temp_var("case_match_check", loc)
         match_var = self.get_temp_var("case_match_to", loc)

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

@@ -1249,11 +1249,12 @@ class Grammar(object):
         call_item = (
             unsafe_name + default
-            # ellipsis must come before namedexpr_test
-            | ellipsis_tokens + equals.suppress() + refname
-            | namedexpr_test
             | star + test
             | dubstar + test
+            | refname + equals  # new long name ellision syntax
+            | ellipsis_tokens + equals.suppress() + refname  # old long name ellision syntax
+            # must come at end
+            | namedexpr_test
         )
         function_call_tokens = lparen.suppress() + (
             # everything here must end with rparen
@@ -1303,7 +1304,7 @@ class Grammar(object):
         maybe_typedef = Optional(colon.suppress() + typedef_test)
         anon_namedtuple_ref = tokenlist(
             Group(
-                unsafe_name + maybe_typedef + equals.suppress() + test
+                unsafe_name + maybe_typedef + (equals.suppress() + test | equals)
                 | ellipsis_tokens + maybe_typedef + equals.suppress() + refname
             ),
             comma,

{coconut-develop-3.1.0.post0.dev9 → coconut-develop-3.1.0.post0.dev10}/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 = 9
+DEVELOP = 10
 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.dev9 → coconut-develop-3.1.0.post0.dev10}/coconut/tests/src/cocotest/agnostic/primary_2.coco RENAMED Viewed

@@ -313,10 +313,10 @@ def primary_test_2() -> bool:
     f.is_f = True  # type: ignore
     assert (f ..*> (+)).is_f  # type: ignore
     really_long_var = 10
-    assert (...=really_long_var) == (10,)
-    assert (...=really_long_var, abc="abc") == (10, "abc")
-    assert (abc="abc", ...=really_long_var) == ("abc", 10)
-    assert (...=really_long_var).really_long_var == 10  # type: ignore
+    assert (really_long_var=) == (10,)
+    assert (really_long_var=, abc="abc") == (10, "abc")
+    assert (abc="abc", really_long_var=) == ("abc", 10)
+    assert (really_long_var=).really_long_var == 10  # type: ignore
     n = [0]
     assert n[0] == 0
     assert_raises(-> m{{1:2,2:3}}, TypeError)

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

@@ -1055,8 +1055,8 @@ forward 2""") == 900
     assert InitAndIter(range(3)) |> fmap$((.+1), fallback_to_init=True) == InitAndIter(range(1, 4))
     assert_raises(-> InitAndIter(range(3)) |> fmap$(.+1), TypeError)
     really_long_var = 10
-    assert ret_args_kwargs(...=really_long_var) == ((), {"really_long_var": 10}) == ret_args_kwargs$(...=really_long_var)()
-    assert ret_args_kwargs(123, ...=really_long_var, abc="abc") == ((123,), {"really_long_var": 10, "abc": "abc"}) == ret_args_kwargs$(123, ...=really_long_var, abc="abc")()
+    assert ret_args_kwargs(really_long_var=) == ((), {"really_long_var": 10}) == ret_args_kwargs$(really_long_var=)()
+    assert ret_args_kwargs(123, really_long_var=, abc="abc") == ((123,), {"really_long_var": 10, "abc": "abc"}) == ret_args_kwargs$(123, really_long_var=, abc="abc")()
     assert "Coconut version of typing" in typing.__doc__
     numlist: NumList = [1, 2.3, 5]
     assert hasloc([[1, 2]]).loc[0][1] == 2 == hasloc([[1, 2]]) |> .loc[0][1]

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

@@ -240,7 +240,7 @@ operator ”
 (“) = (”) = (,) ..> map$(str) ..> "".join
 operator !
-addpattern def (int(x))! = 0 if x else 1  # type: ignore
+match def (int(x))! = 0 if x else 1  # type: ignore
 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
@@ -664,7 +664,7 @@ match def fact(n) = fact(n, 1)
 match addpattern def fact(0, acc) = acc  # type: ignore
 addpattern match def fact(n, acc) = fact(n-1, acc*n)  # type: ignore
-addpattern def factorial(0, acc=1) = acc
+match def factorial(0, acc=1) = acc
 addpattern def factorial(int() as n, acc=1 if n > 0) =  # type: ignore
     """this is a docstring"""
     factorial(n-1, acc*n)
@@ -954,12 +954,12 @@ class MySubExc(MyExc):
 class test_super_A:
     @classmethod
-    addpattern def method(cls, {'somekey': str()}) = True
+    match def method(cls, {'somekey': str()}) = True
 class test_super_B(test_super_A):
     @classmethod
-    addpattern def method(cls, {'someotherkey': int(), **rest}) =
+    match def method(cls, {'someotherkey': int(), **rest}) =
         super().method(rest)

{coconut-develop-3.1.0.post0.dev9 → coconut-develop-3.1.0.post0.dev10}/coconut/tests/src/cocotest/non_strict/non_strict_test.coco RENAMED Viewed

@@ -93,6 +93,11 @@ def non_strict_test() -> bool:
     @recursive_iterator
     def fib() = (1, 1) :: map((+), fib(), fib()$[1:])
     assert fib()$[:5] |> list == [1, 1, 2, 3, 5]
+    addpattern def args_or_kwargs(*args) = args
+    addpattern def args_or_kwargs(**kwargs) = kwargs  # type: ignore
+    assert args_or_kwargs(1, 2) == (1, 2)
+    very_long_name = 10
+    assert args_or_kwargs(short_name=5, very_long_name=) == {"short_name": 5, "very_long_name": 10}
     return True
 if __name__ == "__main__":

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

@@ -185,6 +185,15 @@ parsing failed for format string expression: 1+ (line 2)
       ^
       """.strip())
+    assert_raises(-> parse("""
+case def f[T]:
+    match(x) = x
+""".strip()), CoconutSyntaxError)
+    assert_raises(-> parse("""
+case def f[T]:
+    type(x: T) -> T
+""".strip()), CoconutSyntaxError)
     assert_raises(-> parse("(|*?>)"), CoconutSyntaxError, err_has="'|?*>'")
     assert_raises(-> parse("(|**?>)"), CoconutSyntaxError, err_has="'|?**>'")
     assert_raises(-> parse("(<?*|)"), CoconutSyntaxError, err_has="'<*?|'")
@@ -478,6 +487,11 @@ type Num = int | float""".strip())
 # Compiled Coconut: -----------------------------------------------------------
 type L[T] = list[T]""".strip())
+    assert parse("def f[T](x) = x").strip().endswith("""
+# Compiled Coconut: -----------------------------------------------------------
+def f[T](x):
+    return x""".strip())
     setup(line_numbers=False, minify=True)
     assert parse("123  # derp", "lenient") == "123# derp"