Skip to content

Releases: evhub/coconut

v2.1.1 [The Spanish Inquisition]

14 Nov 01:32
fb4540e
Compare
Choose a tag to compare

v2.1.1 is a relatively small release on top of v2.1.0 primarily releasing now to provide Python 3.11 support, though v2.1.1 also has a couple of exciting new features, primarily Coconut's new type parameter syntax. See Coconut's documentation for more information on all of the features listed below.

Bugfixes:

  • #682: Coconut no longer errors out on Python 3.11.

Major changes:

  • #677: New type parameter syntax following PEP 695! For example: type a generic function as def ident[T](x: T) -> T = x.

Minor changes:

  • #679: Error and logging output is now colored on terminals that support it.
  • #678: Non-mypy type checkers should now have an easier time type-checking Coconut code.
  • #680: New async (...) -> ... and (..., **P) -> ... enhanced type annotation constructs for Callables following PEP 677.
  • #644: f = async def x -> x async statement lambda syntax now supported.
  • #624: x |> (.+1) syntax now produces better optimized compiled Python.
  • #681: case/match syntax now deprecated on --strict in favor of Python 3.10 match/case syntax.

v2.1.0 [The Spanish Inquisition]

25 Oct 03:13
Compare
Choose a tag to compare

Though a small release relative to v2.0.0, v2.1.0 includes a couple of pretty exciting changes, most notably custom operators and substantial performance improvements. See Coconut's documentation for more information on all of the features listed below.

Major changes:

  • #4, #674: Coconut now supports custom operators! See the documentation for more information on how to declare, define, and use custom operators.
  • #147: Very substantial performance improvements (up to 100x) when compiling small quantities of code (e.g. at the interpreter, in Jupyter notebooks, when using xonsh, etc.). Compile times for large files should be unchanged.
  • #673: New multi_enumerate built-in for enumerating multi-dimensional arrays (e.g. numpy arrays).

Minor changes:

  • #385: Universalized imports no longer trigger mypy errors.
  • xonsh support updated to the latest xonsh version, should now be enabled by default without requiring xonsh install coconut, and should now be substantially faster.
  • #672: New in <expr> pattern for easier containment checking in pattern-matching.
  • #556: Coconut now respects NOQA/noqa comments when showing warnings for unused imports in --strict mode.

v2.0.0 [How Not to Be Seen]

26 Sep 04:11
Compare
Choose a tag to compare

Coconut v2 is here! This is Coconut's first ever major version release since Coconut was first published, and it comes with some breaking changes, detailed below. Care has been taken to keep v2 as backwards-compatible as possible, but Python 3.10 adding pattern-matching of its own that conflicted with some of Coconut's old pattern-matching rules meant that breaking changes were going to be inevitable to ensure full compatibility.

Additionally, v2 introduces some pretty major new features such as multidimensional array literal/concatenation syntax! Check it all out below and see Coconut's documentation for more information on all of the features listed.

Breaking changes:

  • #605: Coconut pattern-matching is now fully unified with Python 3.10 pattern-matching: pattern-matching always works the same way regardless of where it is used, always uses Python 3.10 rules, but also always supports all additional Coconut pattern-matching features. Some implications of this:
    • Coconut now fully supports class patterns everywhere, including in pattern-matching function definition and destructuring assignment.
    • As a result, x is int type-checking syntax is now deprecated in favor of using the int(x) class pattern. For cases where there is no rewriting as a class pattern, x `isinstance` int syntax is also supported.
    • Pattern-matching for dictionaries has been changed so that {"a": a} now matches a dictionary with at least "a" as a key rather than exactly "a" as its only key to be consistent with Python 3.10. Coconut will warn if such syntax is detected and suggest the explicit {"a": a, **_} or {"a": a, **{}} syntax instead.
  • #639: Coconut data types no longer support adding or multiplying them like tuples unless explicitly added via __add__/__mul__ methods.
  • #623: fmap over a Mapping (e.g. dict) now does a normal map instead of a starmap. Thus, you'll need to do fmap$(def ((k, v)) -> (new_k, new_v)) instead of fmap$((k, v) -> (new_k, new_v)). Old behavior can also be recovered with fmap$(starmap_over_mappings=True).
  • #615: ($[]) spelling for the iterator slicing operator function has been removed in favor of .$[] and the normal getitem operator has been added as .[].
  • #613: Precedence of the function composition operator .. has been lowered such that f x .. g y is now equivalent to (f x) .. (g y) rather than ((f x) .. g) y.
  • #635: initializer keyword argument in scan changed to initial to match the function signature of reduce.

New language features:

  • #628, #670: New multidimensional array literal and concatenation syntax! Concatenate two arrays with [a ; a], write out 2D array literals as [1, 2;; 3, 4], with the number of semicolons denoting the axis from the end on which to concatenate.
  • #258, #669: New syntax for partially applying operator functions: (.+1), (a+.), (.<|x), including support for custom operators as (. `plus` x).
  • #663: Better syntax for typing tuples: instead of x: typing.Tuple[int, str], just: x: (int; str).
  • #633: New pattern-matching for loops, allowing for arbitrary destructuring pattern-matching in for loops.
  • #622, #650: New anonymous named tuples for giving names to fields in temporary tuples. Just: (a=1, b=2).
  • #626: New syntax for using partial application to convert a keyword argument into a positional argument. Just: func$(kwd_arg=?).
  • #612: Combinators! Use lift to "lift" a function up so that its arguments become unary functions. Also: ident, flip, const, of.
  • #616, #620: New all_equal and collectby built-ins for working with iterables.
  • #124: fmap now supports asynchronous iterators.
  • #365 (thanks @ArneBachmann!): Equality checking with =<expr> has been deprecated in favor of ==<expr>; the former syntax will now raise an error in --strict mode.
  • #648: Class patterns now support a strict .attr=<match> syntax that raises an error if the attr isn't present rather than failing the match.
  • #641: Iterable destructuring patterns now support a substantially wider array of allowable destructuring constructs (e.g. [1] + x + [2] + y + [3]).
  • #603: New as x (to explicitly bind a variable) and is x (to do an identity check) pattern-matching constructs.
  • #434 (thanks @ArneBachmann!): Conditional assignment using pattern-matching; infix patterns have been improved to support a `pred` or b = <expr> syntax that binds to a if pred and b otherwise.
  • #670: jax support in fmap and multidimensional array literal/concatenation.
  • #617, #647: New comma operator function (,) for joining arguments into a tuple and new (raise) operator function for raising an exception.
  • #625: Matrix multiplication operator @ now supported on all Python versions.
  • #649 (thanks @hlizard!): Zero-argument super() now supported on all Python versions.
  • #664: Coconut will now automatically backport typing imports into typing_extensions imports when necessary.
  • #490 (thanks @pavelbraginskiy!): := assignment expressions can now be chained without parentheses.
  • #640: f-strings now supported in pattern-matching string patterns.

New compiler features:

  • #632: Substantially improved syntax error messages with much finer-grained identification of the error location.
  • #636: Coconut can now be used as a xontrib in the xonsh shell to enable Coconut syntax.
  • #658: Coconut now supports papermill.
  • #575: Better interpreter auto-completing.
  • #629 (thanks @tbsexton!): New coconut[kernel] installation option for installing only lightweight Jupyter kernel dependencies compared to the full support offered by coconut[jupyter].
  • #646: Better coconut.convenience API.

Bugfixes:

  • #638 (thanks @ivanmkc!): coconut --watch for watching files for changes to be recompiled fixed.
  • #657 (thanks @tbsexton!): Jupyter kernel compatibility with new Jupyter/IPython versions fixed.
  • #616: Iterator slicing no longer exhausts the entire iterator except when strictly necessary.
  • #631: Fixed pattern-matching on numpy arrays by registering them as Sequences.
  • #656 (thanks @hlizard!): Compilation on Windows should no longer convert names of compiled files to lowercase.
  • #627 (thanks @fakuivan!): Support for starred function arguments before positional function arguments.
  • #653 (thanks @fakuivan!): Fixed dotted names in class/data patterns.
  • #655 (thanks @hlizard!): Certain complex f-strings no longer trigger internal Coconut exceptions.
  • #667 (thanks @tom-a-horrocks!): Rare interpreter crashes fixed.

v1.6.0 [Vocational Guidance Counsellor]

06 Nov 08:26
Compare
Choose a tag to compare

Barring any necessary hotfixes, this release, v1.6.0, will be the last release on the v1.X.X branch—which means next up is Coconut v2! Coconut v2 will include substantial backwards-incompatible changes to Coconut's pattern-matching syntax, as well as likely including other backwards-incompatible changes as well.

Coconut v1.6.0 includes a substantial list of new features, many of which have been added in anticipation of Coconut v2. See Coconut's documentation for more information on all of the features and bugfixes listed below.

New language features:

  • #558, #601: Coconut now fully supports Python 3.10 pattern-matching syntax, including compiling Python 3.10 pattern-matching syntax to any Python version and mixing and matching between Python 3.10 pattern-matching and Coconut pattern-matching (including in destructuring assignment and pattern-matching function definition).
  • #566: Coconut can now specifically target Python 3.9, Python 3.10, and/or Python 3.11.
  • #425 (thanks @ExpHP for the issue!): Coconut pattern-matching now supports view patterns that allow calling a function in pattern-matching and matching on the result.
  • #607: Coconut pattern-matching now supports infix patterns that allow calling a binary boolean function in pattern-matching and matching only if the return value is truthy.
  • #570: Coconut now supports an @override built-in that, when used to decorate a method, asserts that it is overwriting some method from a base class.
  • #582, #583 (thanks @aananko for the issue!): Coconut now supports a flatten built-in for flattening one layer of an iterable of iterables.
  • #574: Coconut now supports reveal_type and reveal_locals built-ins that will print the inferred type of the contained expression when compiled with coconut --mypy.
  • #421: Coconut now supports yield def function definition syntax for explicitly specifying that you want a generator function, regardless of whether a yield actually occurs somewhere in the function.
  • #598: Coconut now supports if condition then x else y ternary syntax in addition to Python's x if condition else y ternary syntax.
  • #544: Coconut now supports the additional .[0][1] and .a.b(c) implicit partials.
  • #348 (thanks @ArneBachmann for the issue!): Pattern-matching functions now support return type annotations (though not argument type annotations).
  • #289: Coconut now supports dict, tuple, and list star and double-star unpackings across all Python versions.
  • #571 (thanks @tbsexton for the issue!): Coconut now fully supports Python 3.10 int | bool type annotation syntax, including compiling it to any Python version.
  • #572: Coconut's zip and zip_longest built-ins now supports a Python-3.10-style strict keyword argument on all Python versions.
  • #307: Coconut now supports class A(metaclass=...) syntax on all Python versions, including compiling to universal code to support Python 2.
  • #495 (thanks @pavelbraginskiy for the issue!): Coconut now supports exec as a function on all Python versions.
  • #352 (thanks @ArneBachmann for the issue!): Coconut will now compile enum imports into aenum imports on targets that don't support enum.
  • #365 (thanks @ArneBachmann for the issue!): Coconut now supports == instead of = as the prefix for equality checking in pattern-matching (this will be made mandatory in Coconut v2).
  • #576: Coconut's case syntax now allows a cases keyword to be used at the top level instead of the case keyword for clarity.
  • #603: Coconut now supports optional as x explicit name-binding syntax in pattern-matching.
  • #567: Coconut now supports in-line augmented global/nonlocal assignments.

New compiler features:

  • #586, #591 (thanks @tbsexton for the issue!): Coconut now has an official VSCode highlighting extension.
  • #587, #595 (thanks @nlipsyc for the PR!): Coconut now supports an --and src dest flag for compiling additional files/directories with the same coconut command, including splitting the compilation across multiple processes when --jobs is passed.
  • #497 (thanks @matanagasauce for the issue!): Coconut now supports a # coding: coconut header in .py files to use Coconut syntax along with a coconut --site-install command to make all such automatic compilation behavior available without first importing coconut.convenience.
  • #596, #597 (thanks @lazyprop for the PR!): Coconut now supports a --vi-mode flag and COCONUT_VI_MODE environment variable for enabling vi mode in the interpreter.
  • #386 (thanks @ArneBachmann for the issue!): Coconut will now throw more informative error messages for many common syntax errors.
  • #611: Installing all the dependencies that Coconut uses to backport old code is now be done by installing coconut[backports] rather than individually as in installing coconut[asyncio].

Bugfixes:

  • #577: As long as a dataclasses library exists at runtime, all Coconut targets now support x: int syntax for specifying the fields of a dataclass.
  • #578: Bound method are now properly tail call optimized.
  • #604: When pattern-matching fails, it should no longer make any variable assignments (though in case of a guard, the variable assignments will still occur prior to the guard being run and will persist if the guard fails).
  • #580 (thanks @leogao2 for the issue!): Coconut's parallel_map is now substantially more efficient in processing very large iterators.
  • #602: or and | in pattern-matching will no longer sometimes run duplicate checks.
  • #593: --no-wrap now disables from __future__ import annotations on Python 3.7+.
  • #334: In-place pipe operators are now optimized the same as normal pipe operators.
  • #543: Keyword-only function arguments will now raise a more informative error on unsupported targets.
  • #588 (thanks @servadestroya for the issue!): Coconut will now properly compile vanilla Python destructuring assignment in with statements.
  • #592 (thanks @servadestroya for the issue!): Coconut will now properly concatenate naked f-strings placed next to each other.
  • #519 (thanks @bj0 for the issue!): Coconut will no longer compile := operators inside of :: expressions to invalid Python.
  • #585 (thanks @Gurkenglas for the issue!): Coconut now has better handling of permission errors in Jupyter kernel installation.

Coconut v1.6.0 should also compile about 10% faster on average than Coconut v1.5.0.

v1.5.0 [Fish License]

06 Mar 06:27
f90cbaa
Compare
Choose a tag to compare

See Coconut's documentation for more information on everything listed below.

Features

  • #545: Added support for embedding a Coconut interpreter for debugging; just from coconut import embed; embed().
  • #562: All lazy lists are now reiterable.
  • #550: All enhanced built-ins are now reiterable when given an iterable.
  • #542: New None-aware pipe operators.
  • #105: New zip_longest built-in.
  • #552: Full PEP 553 (breakpoint built-in) support on all Python versions.
  • #531: Add support for = specifier in f-strings.
  • #508: Added .multiple_sequential_calls() context managers to parallel_map and concurrent_map.
  • #540: Add nb_conda_kernel support (thanks @tbsexton for reporting the issue).
  • #514, #523: Added --no-wrap flag (thanks @QuestofIranon for the PR!).
  • #547: Added Coconut homebrew installation (thanks @SeekingMeaning for making this happen!)

Bugfixes:

  • #548: Significantly improve pattern-matching performance.
  • #561: Fix Python 3.9 issues (thanks @BruceEckel for reporting the issue).
  • #551: Fix issues with new Jupyter kernel (thanks @regr4 for reporting the issue and @bj0 for finding the root cause).
  • #281: Fix coconut --jupyter calling the wrong Jupyter installation (thanks @betabrain for reporting the issue).
  • #560: Fix error on non-numeric setuptools versions (thanks @fabianhjr for the PR!).
  • #559: Fix nested f-string parsing (thanks @bjo for reporting the issue).
  • #553: Proper PEP 563 support (now Coconut doesn't wrap annotations in strings when they'll be deferred anyway).
  • #536: Fixes iterator returns on all Python versions.
  • #541: Prevent accidentally compiling to source files (thanks @dryprogrammer for reporting the issue).

v1.4.3 [Ernest Scribbler]

07 Jan 23:37
Compare
Choose a tag to compare

See Coconut's documentation for more information on everything listed below.

Bugfixes:

  • #527: Coconut once again builds properly on Python 2 (thanks @hasufell for the issue!)
  • #526: fixes = function definition returning string literals not working (thanks @vietspaceanh for the issue!)
  • attributes now work properly in implicit function application (e.g. f b.x c.y)

v1.4.2 [Ernest Scribbler]

09 Dec 07:45
e701423
Compare
Choose a tag to compare

See Coconut's documentation for more information on all of the features listed below.

Bugfixes:

  • #521: prevents Coconut from installing an incompatible version of cPyparsing by default
  • #515: prevents Coconut from installing trollius on Python 3 when doing pip install coconut[all] (thanks @DennisMitchell for the issue!)

New features:

  • #496, #506: addpattern now issues a warning if passed a non-pattern-matching function unless allow_any_func=True is passed (thanks @m-burst for the PR and @pavelbraginskiy for the issue!)
  • #517: simple implicit function application such as f x y is now supported

v1.4.1 [Ernest Scribbler]

08 Aug 00:29
850f78c
Compare
Choose a tag to compare

See Coconut's documentation for more information on all of the features listed below.

New features:

  • #465: new addpattern def shorthand syntax (thanks @MichalMarsalek for the issue!)
  • #301, #504, #505: full support for Python 3.6 f-strings on all targets including (thanks @m-burst for the PR!)
  • #323: added support for |**> kwargs pipes (thanks @ArneBachmann for the issue!)
  • #490: new (assert) operator function (thanks @arnauorriols for the issue!)
  • #503: added support for Python 3.8 positional-only arguments (thanks @pavelbraginskiy fo the issue!)
  • #483: fmap now works on numpy arrays (thanks @hoishing for the issue!)
  • #494: added support for pattern-matching in data definitions (thanks @arnauorriols for the issue!)
  • #493: added truncation for long MatchError messages (thanks @arnauorriols for the issue!)
  • #482: added support for Python 3.8 assignment expressions under --target 3.8 (thanks @terrdavis for the issue!)
  • #446, #458: data types are now hashable (thanks @m-burst for the PR!)
  • #502: addpattern, recursive_iterator, and TCO'd functions are now pickleable
  • #488: fewer __coconut__.py files are created when compiling in --package mode

Plus lots and lots of bugfixes!

v1.4.0 [Ernest Scribbler]

16 Aug 00:23
Compare
Choose a tag to compare

See Coconut's documentation for more information on all of the features listed below.

New features:

  • #320: added import hook to automatically compile imported Coconut files (thanks @ArneBachmann!)
  • #347: added where clauses
  • #270: added a memoize decorator (thanks @iamrecursion!)
  • #403: added a TYPE_CHECKING constant
  • #409: added support for M `bind` x -> y syntax
  • #419: data type equality is now typed (thanks everyone in #418!)
  • #331: support negative pattern-matching with match ... not in ...
  • #411: count now supports a step size of 0
  • #394: scan now has an initializer argument
  • #398: creating a new indented block after a colon is no longer necessary for any statement
  • #229: --strict now warns on unused imports
  • #327: interpreter now supports reload built-in (thanks, @ArneBachmann!)
  • #382: interpreter now supports compiling to arbitrary file names
  • #393: unicode operators for multiplication and matrix multiplication have been switched
  • #153: function composition precedence is now such that f..g(x) is the same as f..(g(x)) not (f..g)(x)
  • #395: built-in attributes changed to remove initial underscores

Plus lots and lots of bugfixes!

v1.3.1 [Dead Parrot]

23 Oct 23:22
Compare
Choose a tag to compare

This is a bugfix release for v1.3.0. See v1.3.0 below for all the most recently added features.

Fixes: