coconut-develop 3.0.2.post0.dev3__tar.gz → 3.0.2.post0.dev5__tar.gz

{coconut-develop-3.0.2.post0.dev3 → coconut-develop-3.0.2.post0.dev5}/DOCS.md

@@ -143,74 +143,77 @@ dest                destination directory for compiled files (defaults to
 ##### Optional Arguments
 
 ```
-  -h, --help            show this help message and exit
-  --and source [dest ...]
-                        add an additional source/dest pair to compile (dest is optional)
-  -v, -V, --version     print Coconut and Python version information
-  -t version, --target version
-                        specify target Python version (defaults to universal)
-  -i, --interact        force the interpreter to start (otherwise starts if no other command
-                        is given) (implies --run)
-  -p, --package         compile source as part of a package (defaults to only if source is a
-                        directory)
-  -a, --standalone, --stand-alone
-                        compile source as standalone files (defaults to only if source is a
-                        single file)
-  -l, --line-numbers, --linenumbers
-                        add line number comments for ease of debugging
-  -k, --keep-lines, --keeplines
-                        include source code in comments for ease of debugging
-  -w, --watch           watch a directory and recompile on changes
-  -r, --run             execute compiled Python
-  -n, --no-write, --nowrite
-                        disable writing compiled Python
-  -d, --display         print compiled Python
-  -q, --quiet           suppress all informational output (combine with --display to write
-                        runnable code to stdout)
-  -s, --strict          enforce code cleanliness standards
-  --no-tco, --notco     disable tail call optimization
-  --no-wrap-types, --nowraptypes
-                        disable wrapping type annotations in strings and turn off 'from
-                        __future__ import annotations' behavior
-  -c code, --code code  run Coconut passed in as a string (can also be piped into stdin)
-  -j processes, --jobs processes
-                        number of additional processes to use (defaults to 'sys') (0 is no
-                        additional processes; 'sys' uses machine default)
-  -f, --force           force re-compilation even when source code and compilation parameters
-                        haven't changed
-  --minify              reduce size of compiled Python
-  --jupyter ..., --ipython ...
-                        run Jupyter/IPython with Coconut as the kernel (remaining args passed
-                        to Jupyter)
-  --mypy ...            run MyPy on compiled Python (remaining args passed to MyPy) (implies
-                        --package)
-  --argv ..., --args ...
-                        set sys.argv to source plus remaining args for use in the Coconut
-                        script being run
-  --tutorial            open Coconut's tutorial in the default web browser
-  --docs, --documentation
-                        open Coconut's documentation in the default web browser
-  --style name          set Pygments syntax highlighting style (or 'list' to list styles)
-                        (defaults to COCONUT_STYLE environment variable if it exists,
-                        otherwise 'default')
-  --history-file path   set history file (or '' for no file) (can be modified by setting
-                        COCONUT_HOME environment variable)
-  --vi-mode, --vimode   enable vi mode in the interpreter (currently set to False) (can be
-                        modified by setting COCONUT_VI_MODE environment variable)
-  --recursion-limit limit, --recursionlimit limit
-                        set maximum recursion depth in compiler (defaults to 1920) (when
-                        increasing --recursion-limit, you may also need to increase --stack-
-                        size)
-  --stack-size kbs, --stacksize kbs
-                        run the compiler in a separate thread with the given stack size in
-                        kilobytes
-  --site-install, --siteinstall
-                        set up coconut.api to be imported on Python start
-  --site-uninstall, --siteuninstall
-                        revert the effects of --site-install
-  --verbose             print verbose debug output
-  --trace               print verbose parsing data (only available in coconut-develop)
-  --profile             collect and print timing info (only available in coconut-develop)
+-h, --help            show this help message and exit
+--and source [dest ...]
+                      add an additional source/dest pair to compile (dest is optional)
+-v, -V, --version     print Coconut and Python version information
+-t version, --target version
+                      specify target Python version (defaults to universal)
+-i, --interact        force the interpreter to start (otherwise starts if no other command
+                      is given) (implies --run)
+-p, --package         compile source as part of a package (defaults to only if source is a
+                      directory)
+-a, --standalone, --stand-alone
+                      compile source as standalone files (defaults to only if source is a
+                      single file)
+-l, --line-numbers, --linenumbers
+                      force enable line number comments (--line-numbers are enabled by
+                      default unless --minify is passed)
+--no-line-numbers, --nolinenumbers
+                      disable line number comments (opposite of --line-numbers)
+-k, --keep-lines, --keeplines
+                      include source code in comments for ease of debugging
+-w, --watch           watch a directory and recompile on changes
+-r, --run             execute compiled Python
+-n, --no-write, --nowrite
+                      disable writing compiled Python
+-d, --display         print compiled Python
+-q, --quiet           suppress all informational output (combine with --display to write
+                      runnable code to stdout)
+-s, --strict          enforce code cleanliness standards
+--no-tco, --notco     disable tail call optimization
+--no-wrap-types, --nowraptypes
+                      disable wrapping type annotations in strings and turn off 'from
+                      __future__ import annotations' behavior
+-c code, --code code  run Coconut passed in as a string (can also be piped into stdin)
+-j processes, --jobs processes
+                      number of additional processes to use (defaults to 'sys') (0 is no
+                      additional processes; 'sys' uses machine default)
+-f, --force           force re-compilation even when source code and compilation parameters
+                      haven't changed
+--minify              reduce size of compiled Python
+--jupyter ..., --ipython ...
+                      run Jupyter/IPython with Coconut as the kernel (remaining args passed
+                      to Jupyter)
+--mypy ...            run MyPy on compiled Python (remaining args passed to MyPy) (implies
+                      --package --line-numbers)
+--argv ..., --args ...
+                      set sys.argv to source plus remaining args for use in the Coconut
+                      script being run
+--tutorial            open Coconut's tutorial in the default web browser
+--docs, --documentation
+                      open Coconut's documentation in the default web browser
+--style name          set Pygments syntax highlighting style (or 'list' to list styles)
+                      (defaults to COCONUT_STYLE environment variable if it exists,
+                      otherwise 'default')
+--history-file path   set history file (or '' for no file) (can be modified by setting
+                      COCONUT_HOME environment variable)
+--vi-mode, --vimode   enable vi mode in the interpreter (currently set to False) (can be
+                      modified by setting COCONUT_VI_MODE environment variable)
+--recursion-limit limit, --recursionlimit limit
+                      set maximum recursion depth in compiler (defaults to 1920) (when
+                      increasing --recursion-limit, you may also need to increase --stack-
+                      size)
+--stack-size kbs, --stacksize kbs
+                      run the compiler in a separate thread with the given stack size in
+                      kilobytes
+--site-install, --siteinstall
+                      set up coconut.api to be imported on Python start
+--site-uninstall, --siteuninstall
+                      revert the effects of --site-install
+--verbose             print verbose debug output
+--trace               print verbose parsing data (only available in coconut-develop)
+--profile             collect and print timing info (only available in coconut-develop)
 ```
 
 #### Coconut Scripts
@@ -221,7 +224,7 @@ coconut-run <source> <args>
 ```
 as an alias for
 ```
-coconut --quiet --target sys --line-numbers --keep-lines --run <source> --argv <args>
+coconut --quiet --target sys --keep-lines --run <source> --argv <args>
 ```
 which will quietly compile and run `<source>`, passing any additional arguments to the script, mimicking how the `python` command works.
 
@@ -732,6 +735,8 @@ All function composition operators also have in-place versions (e.g. `..=`).
 
 Since all forms of function composition always call the first function in the composition (`f` in `f ..> g` and `g` in `f <.. g`) with exactly the arguments passed into the composition, all forms of function composition will preserve all metadata attached to the first function in the composition, including the function's [signature](https://docs.python.org/3/library/inspect.html#inspect.signature) and any of that function's attributes.
 
+_Note: for composing `async` functions, see [`and_then` and `and_then_await`](#and_then-and-and_then_await)._
+
 ##### Example
 
 **Coconut:**
@@ -3341,6 +3346,54 @@ res, err = safe_call(-> 1 / 0) |> fmap$(.+1)
 **Python:**
 _Can't be done without a complex `Expected` definition. See the compiled code for the Python syntax._
 
+#### `ident`
+
+**ident**(_x_, *, _side\_effect_=`None`)
+
+Coconut's `ident` is the identity function, generally equivalent to `x -> x`.
+
+`ident` also accepts one keyword-only argument, `side_effect`, which specifies a function to call on the argument before it is returned. Thus, `ident` is effectively equivalent to:
+```coconut
+def ident(x, *, side_effect=None):
+    if side_effect is not None:
+        side_effect(x)
+    return x
+```
+
+`ident` is primarily useful when writing in a point-free style (e.g. in combination with [`lift`](#lift)) or for debugging [pipes](#pipes) where `ident$(side_effect=print)` can let you see what is being piped.
+
+#### `const`
+
+**const**(_value_)
+
+Coconut's `const` simply constructs a function that, whatever its arguments, just returns the given value. Thus, `const` is equivalent to a pickleable version of
+```coconut
+def const(value) = (*args, **kwargs) -> value
+```
+
+`const` is primarily useful when writing in a point-free style (e.g. in combination with [`lift`](#lift)).
+
+#### `flip`
+
+**flip**(_func_, _nargs_=`None`)
+
+Coconut's `flip(f, nargs=None)` is a higher-order function that, given a function `f`, returns a new function with reversed argument order. If `nargs` is passed, only the first `nargs` arguments are reversed.
+
+For the binary case, `flip` works as
+```coconut
+flip(f, 2)(x, y) == f(y, x)
+```
+such that `flip$(?, 2)` implements the `C` combinator (`flip` in Haskell).
+
+In the general case, `flip` is equivalent to a pickleable version of
+```coconut
+def flip(f, nargs=None) =
+    (*args, **kwargs) -> (
+        f(*args[::-1], **kwargs) if nargs is None
+        else f(*(args[nargs-1::-1] + args[nargs:]), **kwargs)
+    )
+```
+
 #### `lift`
 
 **lift**(_func_)
@@ -3388,54 +3441,58 @@ def plus_and_times(x, y):
     return x + y, x * y
 ```
 
-#### `flip`
+#### `and_then` and `and_then_await`
 
-**flip**(_func_, _nargs_=`None`)
+Coconut provides the `and_then` and `and_then_await` built-ins for composing `async` functions. Specifically:
+* To forwards compose an async function `async_f` with a normal function `g` (such that `g` is called on the result of `await`ing `async_f`), write ``async_f `and_then` g``.
+* To forwards compose an async function `async_f` with another async function `async_g` (such that `async_g` is called on the result of `await`ing `async_f`, and then `async_g` is itself awaited), write ``async_f `and_then_await` async_g``.
+* To forwards compose a normal function `f` with an async function `async_g` (such that `async_g` is called on the result of `f`), just write `f ..> async_g`.
 
-Coconut's `flip(f, nargs=None)` is a higher-order function that, given a function `f`, returns a new function with reversed argument order. If `nargs` is passed, only the first `nargs` arguments are reversed.
+Note that all of the above will always result in the resulting composition being an `async` function.
 
-For the binary case, `flip` works as
+The built-ins are effectively equivalent to:
 ```coconut
-flip(f, 2)(x, y) == f(y, x)
-```
-such that `flip$(?, 2)` implements the `C` combinator (`flip` in Haskell).
+def and_then[**T, U, V](
+    first_async_func: async (**T) -> U,
+    second_func: U -> V,
+) -> async (**T) -> V =
+    async def (*args, **kwargs) -> (
+        first_async_func(*args, **kwargs)
+        |> await
+        |> second_func
+    )
 
-In the general case, `flip` is equivalent to a pickleable version of
-```coconut
-def flip(f, nargs=None) =
-    (*args, **kwargs) -> (
-        f(*args[::-1], **kwargs) if nargs is None
-        else f(*(args[nargs-1::-1] + args[nargs:]), **kwargs)
+def and_then_await[**T, U, V](
+    first_async_func: async (**T) -> U,
+    second_async_func: async U -> V,
+) -> async (**T) -> V =
+    async def (*args, **kwargs) -> (
+        first_async_func(*args, **kwargs)
+        |> await
+        |> second_async_func
+        |> await
     )
 ```
 
-#### `const`
+Like normal [function composition](#function-composition), `and_then` and `and_then_await` will preserve all metadata attached to the first function in the composition.
 
-**const**(_value_)
+##### Example
 
-Coconut's `const` simply constructs a function that, whatever its arguments, just returns the given value. Thus, `const` is equivalent to a pickleable version of
+**Coconut:**
 ```coconut
-def const(value) = (*args, **kwargs) -> value
+load_and_send_data = (
+    load_data_async()
+    `and_then` proc_data
+    `and_then_await` send_data
+)
 ```
 
-`const` is primarily useful when writing in a point-free style (e.g. in combination with [`lift`](#lift)).
-
-#### `ident`
-
-**ident**(_x_, *, _side\_effect_=`None`)
-
-Coconut's `ident` is the identity function, generally equivalent to `x -> x`.
-
-`ident` also accepts one keyword-only argument, `side_effect`, which specifies a function to call on the argument before it is returned. Thus, `ident` is effectively equivalent to:
-```coconut
-def ident(x, *, side_effect=None):
-    if side_effect is not None:
-        side_effect(x)
-    return x
+**Python:**
+```coconut_python
+async def load_and_send_data():
+    return await send_data(proc_data(await load_data_async()))
 ```
 
-`ident` is primarily useful when writing in a point-free style (e.g. in combination with [`lift`](#lift)) or for debugging [pipes](#pipes) where `ident$(side_effect=print)` can let you see what is being piped.
-
 ### Built-Ins for Working with Iterators
 
 ```{contents}

coconut-develop-3.0.2.post0.dev5/PKG-INFO

@@ -0,0 +1,140 @@
+Metadata-Version: 2.1
+Name: coconut-develop
+Version: 3.0.2.post0.dev5
+Summary: Simple, elegant, Pythonic functional programming.
+Home-page: http://coconut-lang.org
+Author: Evan Hubinger
+Author-email: evanjhub@gmail.com
+License: Apache 2.0
+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,infix,function,composition,compose,partial,application,currying,curry,pipeline,pipe,unicode,operator,operators,frozenset,literal,syntax,destructuring,assignment,fold,datamaker,prepattern,iterator,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,parallel_map,addpattern,recursive_iterator,concurrent_map,fmap,starmap,reiterable,scan,groupsof,memoize,zip_longest,override,flatten,ident,call,safe_call,flip,const,lift,all_equal,collectby,multi_enumerate,cartesian_product,multiset,cycle,windowsof,and_then,and_then_await,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,_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 :: 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: backports
+Provides-Extra: xonsh
+Provides-Extra: jupyter
+Provides-Extra: all
+Provides-Extra: ipython
+Provides-Extra: docs
+Provides-Extra: tests
+Provides-Extra: dev
+License-File: LICENSE.txt
+
+|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
+
+

{coconut-develop-3.0.2.post0.dev3 → coconut-develop-3.0.2.post0.dev5}/__coconut__/__init__.pyi

@@ -530,6 +530,17 @@ def _coconut_base_compose(
     ) -> _t.Callable[[_T], _t.Any]: ...
 
 
+def and_then(
+    first_async_func: _t.Callable[_P, _t.Awaitable[_U]],
+    second_func: _t.Callable[[_U], _V],
+) -> _t.Callable[_P, _t.Awaitable[_V]]: ...
+
+def and_then_await(
+    first_async_func: _t.Callable[_P, _t.Awaitable[_U]],
+    second_async_func: _t.Callable[[_U], _t.Awaitable[_V]],
+) -> _t.Callable[_P, _t.Awaitable[_V]]: ...
+
+
 # all forward/backward/none composition functions MUST be kept in sync:
 
 # @_t.overload

{coconut-develop-3.0.2.post0.dev3 → coconut-develop-3.0.2.post0.dev5}/coconut/command/cli.py

@@ -115,7 +115,13 @@ arguments.add_argument(
 arguments.add_argument(
     "-l", "--line-numbers", "--linenumbers",
     action="store_true",
-    help="add line number comments for ease of debugging",
+    help="force enable line number comments (--line-numbers are enabled by default unless --minify is passed)",
+)
+
+arguments.add_argument(
+    "--no-line-numbers", "--nolinenumbers",
+    action="store_true",
+    help="disable line number comments (opposite of --line-numbers)",
 )
 
 arguments.add_argument(
@@ -209,7 +215,7 @@ arguments.add_argument(
     "--mypy",
     type=str,
     nargs=argparse.REMAINDER,
-    help="run MyPy on compiled Python (remaining args passed to MyPy) (implies --package)",
+    help="run MyPy on compiled Python (remaining args passed to MyPy) (implies --package --line-numbers)",
 )
 
 arguments.add_argument(

{coconut-develop-3.0.2.post0.dev3 → coconut-develop-3.0.2.post0.dev5}/coconut/command/command.py

@@ -229,8 +229,10 @@ class Command(object):
             # validate general command args
             if args.stack_size and args.stack_size % 4 != 0:
                 logger.warn("--stack-size should generally be a multiple of 4, not {stack_size} (to support 4 KB pages)".format(stack_size=args.stack_size))
-            if args.mypy is not None and args.line_numbers:
-                logger.warn("extraneous --line-numbers argument passed; --mypy implies --line-numbers")
+            if args.mypy is not None and args.no_line_numbers:
+                logger.warn("using --mypy running with --no-line-numbers is not recommended; mypy error messages won't include Coconut line numbers")
+            if args.line_numbers and args.no_line_numbers:
+                raise CoconutException("cannot compile with both --line-numbers and --no-line-numbers")
             if args.site_install and args.site_uninstall:
                 raise CoconutException("cannot --site-install and --site-uninstall simultaneously")
             for and_args in getattr(args, "and") or []:
@@ -266,11 +268,20 @@ class Command(object):
                 self.argv_args = list(args.argv)
 
             # process general compiler args
+            if args.line_numbers:
+                line_numbers = True
+            elif args.no_line_numbers:
+                line_numbers = False
+            else:
+                line_numbers = (
+                    not args.minify
+                    or args.mypy is not None
+                )
             self.setup(
                 target=args.target,
                 strict=args.strict,
                 minify=args.minify,
-                line_numbers=args.line_numbers or args.mypy is not None,
+                line_numbers=line_numbers,
                 keep_lines=args.keep_lines,
                 no_tco=args.no_tco,
                 no_wrap=args.no_wrap_types,

{coconut-develop-3.0.2.post0.dev3 → coconut-develop-3.0.2.post0.dev5}/coconut/compiler/compiler.py

@@ -3499,7 +3499,7 @@ if not {check_var}:
             return "await " + await_expr
         elif self.target_info >= (3, 3):
             # we have to wrap the yield here so it doesn't cause the function to be detected as an async generator
-            return self.wrap_passthrough("(yield from " + await_expr + ")", early=True)
+            return self.wrap_passthrough("(yield from " + await_expr + ")")
         else:
             # this yield is fine because we can detect the _coconut.asyncio.From
             return "(yield _coconut.asyncio.From(" + await_expr + "))"

{coconut-develop-3.0.2.post0.dev3 → coconut-develop-3.0.2.post0.dev5}/coconut/compiler/header.py

@@ -488,6 +488,55 @@ items = _coconut.collections.Counter.viewitems
             indent=1,
             newline=True,
         ),
+        def_async_compose_call=prepare(
+            r'''
+async def __call__(self, *args, **kwargs):
+    arg = await self._coconut_func(*args, **kwargs)
+    for f, await_f in self._coconut_func_infos:
+        arg = f(arg)
+        if await_f:
+            arg = await arg
+    return arg
+            ''' if target_info >= (3, 5) else
+            pycondition(
+                (3, 5),
+                if_ge=r'''
+_coconut_call_ns = {}
+_coconut_exec("""async def __call__(self, *args, **kwargs):
+    arg = await self._coconut_func(*args, **kwargs)
+    for f, await_f in self._coconut_func_infos:
+        arg = f(arg)
+        if await_f:
+            arg = await arg
+    return arg""", _coconut_call_ns)
+__call__ = _coconut_call_ns["__call__"]
+                ''',
+                # we got the below code by compiling the above code with yield from instead of await and --target 2
+                if_lt=r'''
+@_coconut.asyncio.coroutine
+def __call__(self, *args, **kwargs):
+    to_await = _coconut.iter(self._coconut_func(*args, **kwargs))
+    while True:
+        try:
+            yield _coconut.next(to_await)
+        except _coconut.StopIteration as stop_it:
+            arg = stop_it.args[0] if _coconut.len(stop_it.args) > 0 else None
+            break
+    for f, await_f in self._coconut_func_infos:
+        arg = f(arg)
+        if await_f:
+            to_await = _coconut.iter(arg)
+            while True:
+                try:
+                    yield _coconut.next(to_await)
+                except _coconut.StopIteration as stop_it:
+                    arg = stop_it.args[0] if _coconut.len(stop_it.args) > 0 else None
+                    break
+    raise _coconut.StopIteration(arg)
+                ''',
+            ),
+            indent=1
+        ),
 
         # used in the second round
         tco_comma="_coconut_tail_call, _coconut_tco, " if not no_tco else "",