document v0.15.0 changes

Technologicat · Technologicat · commit d063bf9b00c5 · 2021-05-10T20:14:36.000+03:00
diff --git a/doc/features.md b/doc/features.md
@@ -81,7 +81,7 @@ For many examples, see [the unit tests](unpythonic/tests/), the docstrings of th
 
 *This document doubles as the API reference, but despite maintenance on a best-effort basis, may occasionally be out-of-date at places. In case of conflicts in documentation, believe the unit tests first; specifically the code, not necessarily the comments. Everything else (comments, docstrings and this guide) should agree with the unit tests. So if something fails to work as advertised, check what the tests say - and optionally file an issue on GitHub so that the documentation can be fixed.*
 
-**This document is up-to-date for v0.14.3.**
+**This document is up-to-date for v0.15.0.**
 
 ## Bindings
 
diff --git a/doc/macros.md b/doc/macros.md
@@ -44,7 +44,7 @@ Because in Python macro expansion occurs *at import time*, Python programs whose
 - [``envify``: make formal parameters live in an unpythonic ``env``](#envify-make-formal-parameters-live-in-an-unpythonic-env)
 
 [**Language features**](#language-features)
-- [``curry``: automatic currying for Python](#curry-automatic-currying-for-python)
+- [``autocurry``: automatic currying for Python](#autocurry-automatic-currying-for-python)
 - [``lazify``: call-by-need for Python](#lazify-call-by-need-for-python)
   - [``lazy[]`` and ``lazyrec[]`` macros](#lazy-and-lazyrec-macros)
   - [Forcing promises manually](#forcing-promises-manually)
@@ -805,7 +805,9 @@ The ``with`` block adds a few elements, but if desired, it can be refactored int
 
 To boldly go where Python without macros just won't. Changing the rules by code-walking and making significant rewrites.
 
-### ``curry``: automatic currying for Python
+### ``autocurry``: automatic currying for Python
+
+**Changed in v0.15.0.** *The macro is now named `autocurry`, to avoid shadowing the `curry` function.*
 
 ```python
 from unpythonic.syntax import macros, autocurry
@@ -903,6 +905,8 @@ Inspired by Haskell, Racket's ``(delay)`` and ``(force)``, and [lazy/racket](htt
 
 #### ``lazy[]`` and ``lazyrec[]`` macros
 
+**Changed in v0.15.0.** *Previously, the `lazy[]` macro was provided by MacroPy. Now that we use `mcpyrate`, which doesn't provide it, we provide it ourselves, in `unpythonic.syntax`. Note that a lazy value now no longer has a `__call__` operator; instead, it has a `force()` method. The utility `unpythonic.lazyutil.force` (available in the top-level namespace of `unpythonic`) abstracts away this detail.*
+
 We provide the macros ``unpythonic.syntax.lazy``, which explicitly lazifies a single expression, and ``unpythonic.syntax.lazyrec``, which can be used to lazify expressions inside container literals, recursively.
 
 Essentially, ``lazy[...]`` achieves the same result as ``memoize(lambda: ...)``, with the practical difference that a ``lazy[]`` promise ``p`` is evaluated by calling ``unpythonic.lazyutil.force(p)`` or ``p.force()``. In ``unpythonic``, the promise datatype (``unpythonic.lazyutil.Lazy``) does not have a ``__call__`` method, because the word ``force`` better conveys the intent.
@@ -919,6 +923,8 @@ The `unpythonic` containers **must be from-imported** for ``lazyrec[]`` to recog
 
 #### Forcing promises manually
 
+**Changed in v0.15.0.** *The functions `force1` and `force` now live in the top-level namespace of `unpythonic`, no longer in `unpythonic.syntax`.*
+
 This is mainly useful if you ``lazy[]`` or ``lazyrec[]`` something explicitly, and want to compute its value outside a ``with lazify`` block.
 
 We provide the functions ``force1`` and ``force``. Using ``force1``, if ``x`` is a ``lazy[]`` promise, it will be forced, and the resulting value is returned. If ``x`` is not a promise, ``x`` itself is returned, à la Racket. The function ``force``, in addition, descends into containers (recursively). When an atom ``x`` (i.e. anything that is not a container) is encountered, it is processed using ``force1``.
