omlish 0.0.0.dev411__py3-none-any.whl → 0.0.0.dev413__py3-none-any.whl

omlish/lite/maysyncs.py

@@ -4,24 +4,20 @@
 A system for writing a python function once which can then be effectively used in both sync and async contexts -
 including IO, under any (or no) event loop.
 
-Where an 'async fn' returns an 'awaitable', a 'maysync fn' returns a 'maywaitable', which is an object with two
-nullary methods:
-
- - `def s()` - to be called in sync contexts
- - `async def a()` - to be called in async and maysync contexts
+Where an 'async fn' returns an 'awaitable', a 'maysync fn' returns a 'maywaitable', which may be `await`'ed in async or
+maysync contexts, or passed to `run_maysync` to be run sync.
 
 For example, a maysync function `m_inc_int(x: int) -> int` would be used as such:
 
- - `assert m_inc_int(5).s() == 6` in sync contexts
- - `assert await m_inc_int(5).a() == 6` in async and maysync contexts
+ - `run_maysync(m_inc_int(5)) == 6` in sync contexts
+ - `assert await m_inc_int(5) == 6` in async and maysync contexts
 
 Maysync fns may be constructed in two ways: either using `make_maysync`, providing an equivalent pair of sync and async
-functions, or using the `@maysync` decorator to wrap a 'maysync flavored' async function. 'Maysync flavored' async
-functions are ones which only call other maysync functions through their 'maysync context' - that is, they  use the 'a'
-methods on maywaitables - for example: `await m_foo().a()` - and the maysync machinery will ultimately call the
-appropriate 'leaf' sync or async functions. Being regular python functions they are free to call whatever they like -
-for example doing sync IO - but the point is to, ideally, route all IO through maysync functions such that the maysync
-code is fully efficiently usable in any context.
+functions, or writing an 'maysync flavored' async python function. 'Maysync flavored' async functions are ones which
+only call (await on) other maysync functions - the maysync machinery will ultimately call the appropriate 'leaf' sync or
+async functions. Being regular python functions they are free to call whatever they like - for example doing sync IO -
+but the point is to, ideally, route all IO through maysync functions such that the maysync code is fully efficiently
+usable in any context.
 
 Internally, it's not really correct to say that there is 'no event loop' in the maysync context - rather, each
 'entrypoint' call to a maysync fn runs within its own tiny event loop.
@@ -37,9 +33,13 @@ TODO:
   - works down to 3.8
  - make_maysync_from_sync can run with asyncio.run_in_thread
  - make_maysync_from_async can run with asyncio.run_soon
+
+TODO OVERHAUL:
+ - no more sync/async context, just one Context, and it means sync
+ - make FpMaywaitable *not reusable*
+  - `cannot reuse already awaited coroutine`
 """
 import abc
-import functools
 import inspect
 import sys
 import threading
@@ -47,16 +47,10 @@ import typing as ta
 
 
 T = ta.TypeVar('T')
-T_co = ta.TypeVar('T_co', covariant=True)
-
 O = ta.TypeVar('O')
-O_co = ta.TypeVar('O_co', covariant=True)
-
 I = ta.TypeVar('I')
-I_contra = ta.TypeVar('I_contra', contravariant=True)
 
 _MaysyncX = ta.TypeVar('_MaysyncX')
-
 _MaysyncRS = ta.TypeVar('_MaysyncRS')
 _MaysyncRA = ta.TypeVar('_MaysyncRA')
 
@@ -64,329 +58,214 @@ _MaysyncRA = ta.TypeVar('_MaysyncRA')
 ##
 
 
-class Maywaitable(ta.Protocol[T_co]):
-    """
-    The maysync version of `Awaitable[T]`. Non-generator maysync functions return a `Maywaitable`, with the following
-    nullary methods:
-
-     - `def s()` - to be called in sync contexts
-     - `async def a()` - to be called in async and maysync contexts
-
-    Only the proper method should be called in each context.
-    """
-
-    def s(self) -> T_co:
-        ...
-
-    def a(self) -> ta.Awaitable[T_co]:
-        ...
-
-
-class MaysyncGenerator(ta.Protocol[O_co, I_contra]):
-    """
-    The maysync version of `AsyncGenerator[O, I]`. Generator maysync functions return a `MaysyncGenerator`, with the
-    following methods:
-
-     - `def s()` - to be called in sync contexts
-     - `async def a()` - to be called in async and maysync contexts
-
-    Only the proper method should be called in each context.
-    """
-
-    def s(self) -> ta.Generator[O_co, I_contra, None]:
-        ...
-
-    def a(self) -> ta.AsyncGenerator[O_co, I_contra]:
-        ...
-
-
-# The maysync equivalent of an async function
-MaysyncFn = ta.Callable[..., Maywaitable[T]]  # ta.TypeAlias  # omlish-amalg-typing-no-move
-
-# The maysync equivalent of an async generator function
-MaysyncGeneratorFn = ta.Callable[..., MaysyncGenerator[O, I]]  # ta.TypeAlias  # omlish-amalg-typing-no-move
-
-
-class Maysync_(abc.ABC):  # noqa
-    """
-    Abstract base class for maysync objects - either MaysyncFn's or MaysyncGeneratorFn's.
+class AnyMaysyncFn(abc.ABC, ta.Generic[_MaysyncRS, _MaysyncRA]):  # noqa
+    def __init__(
+            self,
+            s: ta.Callable[..., _MaysyncRS],
+            a: ta.Callable[..., _MaysyncRA],
+    ) -> None:
+        if s is None:
+            raise TypeError(s)
+        if a is None:
+            raise TypeError(a)
+        self._s, self._a = s, a
 
-    The concrete implementations are module-level implementation detail, and in general users should make a point to
-    only interact with the protocols defined above, but introspection can be necessary at times.
-    """
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}@{id(self):x}({self._s!r}, {self._a!r})'
 
     def __init_subclass__(cls, **kwargs):
-        if Maysync_ in cls.__bases__ and abc.ABC not in cls.__bases__:
-            raise TypeError(cls)
-
         super().__init_subclass__(**kwargs)
 
+        if hasattr(inspect, 'markcoroutinefunction'):
+            inspect.markcoroutinefunction(cls.__call__)
+
     class FnPair(ta.NamedTuple):
         s: ta.Callable[..., ta.Any]
         a: ta.Callable[..., ta.Any]
 
-    @abc.abstractmethod
     def fn_pair(self) -> ta.Optional[FnPair]:
-        """If this maysync object is backed by a (sync, async) pair of functions, returns the pair."""
-
-        raise NotImplementedError
+        return AnyMaysyncFn.FnPair(
+            self._s,
+            self._a,
+        )
 
-    @abc.abstractmethod
-    def cast(self):
-        pass
+    def __get__(self, instance, owner=None):
+        return self.__class__(
+            self._s.__get__(instance, owner),  # noqa
+            self._a.__get__(instance, owner),  # noqa
+        )
 
     @abc.abstractmethod
     def __call__(self, *args, **kwargs):
         raise NotImplementedError
 
 
-class MaysyncFn_(Maysync_, abc.ABC, ta.Generic[T]):  # noqa
-    @ta.final
-    def cast(self) -> MaysyncFn[T]:
-        return ta.cast('MaysyncFn[T]', self)
+class MaywaitableAlreadyConsumedError(Exception):
+    pass
 
 
-class MaysyncGeneratorFn_(Maysync_, abc.ABC, ta.Generic[O, I]):  # noqa
+class AnyMaywaitable(abc.ABC, ta.Generic[_MaysyncX]):
     @ta.final
-    def cast(self) -> MaysyncGenerator[O, I]:
-        return ta.cast('MaysyncGenerator[O, I]', self)
-
-
-##
-
-
-class _MaysyncThreadLocal(threading.local):
-    context: ta.Optional['_MaysyncContext'] = None
-
+    def __init__(
+            self,
+            x: _MaysyncX,
+            args: ta.Tuple[ta.Any, ...],
+            kwargs: ta.Mapping[str, ta.Any],
+    ) -> None:
+        self._x, self._args, self._kwargs = x, args, kwargs
 
-class _MaysyncContext(abc.ABC):
-    mode: ta.ClassVar[ta.Literal['s', 'a']]
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}@{id(self):x}({self._x!r})'
 
-    @classmethod
-    def current(cls) -> ta.Optional['_MaysyncContext']:
-        return _MaysyncThreadLocal.context
 
-    @abc.abstractmethod
-    def run(self, fn: ta.Callable[..., T], *args: ta.Any, **kwargs: ta.Any) -> T:
-        raise NotImplementedError
+##
 
 
 @ta.final
-class _SyncMaysyncContext(_MaysyncContext):
-    mode: ta.ClassVar[ta.Literal['s']] = 's'
+class MaysyncFn(AnyMaysyncFn[T, ta.Awaitable[T]], ta.Generic[T]):  # noqa
+    def __call__(self, *args, **kwargs):
+        return Maywaitable(self, args, kwargs)
 
-    def run(self, fn: ta.Callable[..., T], *args: ta.Any, **kwargs: ta.Any) -> T:
-        prev = _MaysyncThreadLocal.context
-        _MaysyncThreadLocal.context = self
 
-        ph: ta.Any = sys.get_asyncgen_hooks()
-        if ph.firstiter is not None or ph.finalizer is not None:
-            sys.set_asyncgen_hooks(firstiter=None, finalizer=None)
-        else:
-            ph = None
+@ta.final
+class Maywaitable(AnyMaywaitable[MaysyncFn[T]], ta.Awaitable[T]):
+    _d: bool = False
 
-        try:
-            return fn(*args, **kwargs)
+    def __run_maysync__(self) -> T:
+        if self._d or self._aw is not None:
+            raise MaywaitableAlreadyConsumedError(self)
 
-        finally:
-            if ph is not None:
-                sys.set_asyncgen_hooks(*ph)
-
-            _MaysyncThreadLocal.context = prev
+        self._d = True
+        return self._x._s(*self._args, **self._kwargs)  # noqa
 
+    #
 
-@ta.final
-class _AsyncMaysyncContext(_MaysyncContext):
-    mode: ta.ClassVar[ta.Literal['a']] = 'a'
+    _aw: ta.Optional[ta.Awaitable[T]] = None
 
-    def run(self, fn: ta.Callable[..., T], *args: ta.Any, **kwargs: ta.Any) -> T:
-        prev = _MaysyncThreadLocal.context
-        _MaysyncThreadLocal.context = self
+    def __await__(self) -> ta.Generator[ta.Any, None, T]:
+        if (aw := self._aw) is None:
+            if self._d:
+                raise MaywaitableAlreadyConsumedError(self)
 
-        try:
-            return fn(*args, **kwargs)
+            if _MaysyncThreadLocal.run_context is None:
+                aw = self._aw = self._x._a(*self._args, **self._kwargs)  # noqa
+            else:
+                aw = self._aw = _MaysyncFuture(self)
 
-        finally:
-            _MaysyncThreadLocal.context = prev
+        return aw.__await__()
 
 
 ##
 
 
-class _MaywaitableLike(
-    abc.ABC,
-    ta.Generic[_MaysyncX],
-):
-    """Abstract base class for the maysync versions of `Awaitable[T]` and `AsyncGenerator[O, I]`."""
+@ta.final
+class MaysyncGeneratorFn(AnyMaysyncFn, ta.Generic[O, I]):  # noqa
+    def __call__(self, *args, **kwargs):
+        return MaysyncGenerator(self, args, kwargs)
 
-    @ta.final
-    def __init__(
-            self,
-            x: _MaysyncX,
-            args: ta.Tuple[ta.Any, ...],
-            kwargs: ta.Mapping[str, ta.Any],
-    ) -> None:
-        self._x = x
-        self._args = args
-        self._kwargs = kwargs
 
-    def __repr__(self) -> str:
-        return f'{self.__class__.__name__}@{id(self):x}({self._x!r})'
+@ta.final
+class MaysyncGenerator(AnyMaywaitable[MaysyncGeneratorFn[O, I]], ta.AsyncGenerator[O, I]):
+    def _make_sg(self) -> ta.Generator[O, I, None]:
+        return self._x._s(*self._args, **self._kwargs)  # noqa
 
+    _sg: ta.Optional[ta.Generator[O, I, None]] = None
 
-class _Maywaitable(
-    _MaywaitableLike[_MaysyncX],
-    abc.ABC,
-    ta.Generic[_MaysyncX, T],
-):
-    pass
+    def _get_sg(self) -> ta.Generator[O, I, None]:
+        if (sg := self._sg) is None:
+            if self._ag is not None:
+                raise MaywaitableAlreadyConsumedError(self)
+            sg = self._sg = self._make_sg()
+        return sg
 
+    def __run_maysync__(self) -> ta.Generator[O, I, None]:
+        return (self._sg if self._sg is not None else self._get_sg())
 
-class _MaysyncGenerator(
-    _MaywaitableLike[_MaysyncX],
-    abc.ABC,
-    ta.Generic[_MaysyncX, O, I],
-):
-    pass
+    #
 
+    def _make_ag(self) -> ta.AsyncGenerator[O, I]:
+        if _MaysyncThreadLocal.run_context is None:
+            return self._x._a(*self._args, **self._kwargs)  # noqa
 
-##
+        async def inner():
+            g = self._x._s(*self._args, **self._kwargs)  # noqa
 
+            i: ta.Any = None
+            e: ta.Any = None
 
-class _FpMaysyncFnLike(
-    abc.ABC,
-    ta.Generic[_MaysyncRS, _MaysyncRA],
-):
-    """A maysync object backed by an underlying (sync, async) function pair."""
+            while True:
+                try:
+                    if e is not None:
+                        o = g.throw(e)
+                    else:
+                        o = g.send(i)
+                except StopIteration as ex:
+                    if ex.value is not None:
+                        raise TypeError(ex) from None
+                    return
 
-    def __init__(
-            self,
-            s: ta.Callable[..., _MaysyncRS],
-            a: ta.Callable[..., _MaysyncRA],
-    ) -> None:
-        if s is None:
-            raise TypeError(s)
-        if a is None:
-            raise TypeError(a)
-        self._s = s
-        self._a = a
+                i = None
+                e = None
 
-    def __repr__(self) -> str:
-        return f'{self.__class__.__name__}@{id(self):x}({self._s!r}, {self._a!r})'
+                try:
+                    i = yield o
+                except StopIteration as ex:  # noqa
+                    raise NotImplementedError  # noqa
+                except StopAsyncIteration as ex:  # noqa
+                    raise NotImplementedError  # noqa
+                except BaseException as ex:  # noqa
+                    e = ex
 
-    def fn_pair(self) -> ta.Optional[Maysync_.FnPair]:
-        return Maysync_.FnPair(
-            self._s,
-            self._a,
-        )
+        return inner()
 
-    def __get__(self, instance, owner=None):
-        return self.__class__(
-            self._s.__get__(instance, owner),  # noqa
-            self._a.__get__(instance, owner),  # noqa
-        )
+    _ag: ta.Optional[ta.AsyncGenerator[O, I]] = None
 
+    def _get_ag(self) -> ta.AsyncGenerator[O, I]:
+        if (ag := self._ag) is None:
+            if self._sg is not None:
+                raise MaywaitableAlreadyConsumedError(self)
+            ag = self._ag = self._make_ag()
+        return ag
 
-@ta.final
-class _FpMaysyncFn(
-    _FpMaysyncFnLike[T, ta.Awaitable[T]],
-    MaysyncFn_[T],
-    ta.Generic[T],
-):
-    def __call__(self, *args, **kwargs):
-        return _FpMaywaitable(self, args, kwargs)
+    def __anext__(self):
+        return (self._ag if self._ag is not None else self._get_ag()).__anext__()
 
+    def asend(self, value: I):
+        return (self._ag if self._ag is not None else self._get_ag()).asend(value)
 
-@ta.final
-class _FpMaywaitable(
-    _Maywaitable[_FpMaysyncFn[T], T],
-):
-    def s(self) -> T:
-        return self._x._s(*self._args, **self._kwargs)  # noqa
+    def athrow(self, typ, val=None, tb=None):
+        return (self._ag if self._ag is not None else self._get_ag()).athrow(typ, val, tb)
 
-    def a(self) -> ta.Awaitable[T]:
-        if _MaysyncContext.current() is not None:
-            return _MaysyncFuture(functools.partial(self._x, *self._args, **self._kwargs))  # noqa
+    def aclose(self):
+        return (self._ag if self._ag is not None else self._get_ag()).aclose()
 
-        return self._x._a(*self._args, **self._kwargs)  # noqa
+
+##
 
 
 def make_maysync_fn(
         s: ta.Callable[..., T],
         a: ta.Callable[..., ta.Awaitable[T]],
-) -> MaysyncFn[T]:
+) -> ta.Callable[..., ta.Awaitable[T]]:
     """Constructs a MaysyncFn from a (sync, async) function pair."""
 
-    return _FpMaysyncFn(s, a)
-
-
-@ta.final
-class _FpMaysyncGeneratorFn(
-    _FpMaysyncFnLike[ta.Generator[O, I, None], ta.AsyncGenerator[O, I]],
-    MaysyncGeneratorFn_[O, I],
-    ta.Generic[O, I],
-):
-    def __call__(self, *args, **kwargs):
-        return _FpMaysyncGenerator(self, args, kwargs)
-
-
-@ta.final
-class _FpMaysyncGenerator(
-    _MaysyncGenerator[_FpMaysyncGeneratorFn[O, I], O, I],
-):
-    def s(self) -> ta.Generator[O, I, None]:
-        return self._x._s(*self._args, **self._kwargs)  # noqa
-
-    def a(self) -> ta.AsyncGenerator[O, I]:
-        if (ctx := _MaysyncContext.current()) is not None and ctx.mode == 's':
-            async def inner():
-                g = self._x._s(*self._args, **self._kwargs)  # noqa
-
-                i: ta.Any = None
-                e: ta.Any = None
-
-                while True:
-                    try:
-                        if e is not None:
-                            o = g.throw(e)
-                        else:
-                            o = g.send(i)
-                    except StopIteration as ex:
-                        if ex.value is not None:
-                            raise TypeError(ex) from None
-                        return
-
-                    i = None
-                    e = None
-
-                    try:
-                        i = yield o
-                    except StopIteration as ex:  # noqa
-                        raise NotImplementedError  # noqa
-                    except StopAsyncIteration as ex:  # noqa
-                        raise NotImplementedError  # noqa
-                    except BaseException as ex:  # noqa
-                        e = ex
-
-            return inner()
-
-        return self._x._a(*self._args, **self._kwargs)  # noqa
+    return MaysyncFn(s, a)
 
 
 def make_maysync_generator_fn(
         s: ta.Callable[..., ta.Generator[O, I, None]],
         a: ta.Callable[..., ta.AsyncGenerator[O, I]],
-) -> MaysyncGeneratorFn[O, I]:
+) -> ta.Callable[..., ta.AsyncGenerator[O, I]]:
     """Constructs a MaysyncGeneratorFn from a (sync, async) generator function pair."""
 
-    return _FpMaysyncGeneratorFn(s, a)
+    return MaysyncGeneratorFn(s, a)
 
 
 @ta.overload
 def make_maysync(
         s: ta.Callable[..., T],
         a: ta.Callable[..., ta.Awaitable[T]],
-) -> MaysyncFn[T]:
+) -> ta.Callable[..., ta.Awaitable[T]]:
     ...
 
 
@@ -394,7 +273,7 @@ def make_maysync(
 def make_maysync(
         s: ta.Callable[..., ta.Generator[O, I, None]],
         a: ta.Callable[..., ta.AsyncGenerator[O, I]],
-) -> MaysyncGeneratorFn[O, I]:
+) -> ta.Callable[..., ta.AsyncGenerator[O, I]]:
     ...
 
 
@@ -405,63 +284,121 @@ def make_maysync(s, a):
     """
 
     if inspect.isasyncgenfunction(a):
-        return make_maysync_generator_fn(s, a)
+        return MaysyncGeneratorFn(s, a)
     else:
-        return make_maysync_fn(s, a)
+        return MaysyncFn(s, a)
+
+
+##
+
+
+@ta.final
+class _MaysyncThreadLocal(threading.local):
+    run_context: ta.Optional['_MaysyncRunContext'] = None
+
+
+@ta.final
+class _MaysyncRunContext:
+    def __init__(self, root: ta.Any) -> None:
+        self._root = root
+
+    def run(self, fn: ta.Callable[..., T], *args: ta.Any, **kwargs: ta.Any) -> T:
+        prev = _MaysyncThreadLocal.run_context
+        _MaysyncThreadLocal.run_context = self
+
+        ph: ta.Any = sys.get_asyncgen_hooks()
+        if ph.firstiter is not None or ph.finalizer is not None:
+            sys.set_asyncgen_hooks(firstiter=None, finalizer=None)
+        else:
+            ph = None
+
+        try:
+            return fn(*args, **kwargs)
+
+        finally:
+            if ph is not None:
+                sys.set_asyncgen_hooks(*ph)
+
+            if _MaysyncThreadLocal.run_context is not self:
+                raise RuntimeError
+            _MaysyncThreadLocal.run_context = prev
+
+
+def is_running_maysync() -> bool:
+    return _MaysyncThreadLocal.run_context is not None
 
 
 ##
 
 
-class _MgMaysyncFnLike(
-    abc.ABC,
-    ta.Generic[T],
-):
+@ta.final
+class _MaysyncFutureNotAwaitedError(RuntimeError):
+    pass
+
+
+@ta.final
+class _MaysyncFuture(ta.Generic[T]):
     def __init__(
             self,
-            mg: ta.Callable[..., T],
+            x: Maywaitable[T],
     ) -> None:
-        self._mg = mg
-
-        functools.update_wrapper(self, mg, updated=())
+        self._x = x
 
     def __repr__(self) -> str:
-        return f'{self.__class__.__name__}@{id(self):x}({self._mg!r})'
+        return f'{self.__class__.__name__}@{id(self):x}({self._x!r}, done={self.done!r})'
 
-    def fn_pair(self) -> ta.Optional[Maysync_.FnPair]:
-        return None
+    done: bool = False
+    result: T
+    error: ta.Optional[BaseException] = None
 
-    def __get__(self, instance, owner=None):
-        return self.__class__(
-            self._mg.__get__(instance, owner),  # noqa
-        )
+    def __await__(self) -> ta.Generator['_MaysyncFuture', None, T]:
+        if not self.done:
+            yield self
+        if not self.done:
+            raise _MaysyncFutureNotAwaitedError
+        if self.error is not None:
+            raise self.error
+        else:
+            return self.result
 
-    @abc.abstractmethod  # noqa
-    def __call__(self, *args, **kwargs):
-        raise NotImplementedError
+    def s(self) -> None:
+        if self.done:
+            return
 
+        try:
+            self.result = self._x._x._s(*self._x._args, **self._x._kwargs)  # noqa
+        except BaseException as ex:  # noqa
+            self.error = ex
+        self.done = True
 
-@ta.final
-class _MgMaysyncFn(
-    _MgMaysyncFnLike[ta.Awaitable[T]],
-    MaysyncFn_[T],
-    ta.Generic[T],
-):
-    def __call__(self, *args, **kwargs):
-        return _MgMaywaitable(self, args, kwargs)
+    async def a(self) -> None:
+        if self.done:
+            return
+
+        try:
+            self.result = await self._x._x._a(*self._x._args, **self._x._kwargs)  # noqa
+        except BaseException as ex:  # noqa
+            self.error = ex
+        self.done = True
+
+
+##
 
 
 @ta.final
-class _MgMaysyncDriver:
-    def __init__(self, ctx: _MaysyncContext, mg: ta.Any) -> None:
-        self.ctx = ctx
-        self.mg = mg
+class _MaysyncDriver:
+    def __init__(
+            self,
+            ctx: _MaysyncRunContext,
+            coro: ta.Any,
+    ) -> None:
+        self.ctx, self.coro = ctx, coro
 
     value: ta.Any
 
     def __iter__(self) -> ta.Generator['_MaysyncFuture', None, None]:
         try:
-            a = self.mg.__await__()
+            a = self.coro.__await__()
             try:
                 g = iter(a)
                 try:
@@ -486,260 +423,115 @@ class _MgMaysyncDriver:
                 self.ctx.run(a.close)
 
         finally:
-            self.ctx.run(self.mg.close)
+            self.ctx.run(self.coro.close)
 
 
-@ta.final
-class _MgMaywaitable(
-    _Maywaitable[_MgMaysyncFn[T], T],
-):
-    def _driver(self, ctx: _MaysyncContext) -> _MgMaysyncDriver:
-        return _MgMaysyncDriver(ctx, self._x._mg(*self._args, **self._kwargs))  # noqa
+##
 
-    def s(self) -> T:
-        for f in (drv := self._driver(_SyncMaysyncContext())):
-            f.s()
-            del f
 
-        return drv.value
+def run_maysync_fn(
+        m: ta.Awaitable[T],
+) -> T:
+    if isinstance(m, Maywaitable):
+        return m.__run_maysync__()
 
-    def a(self) -> ta.Awaitable[T]:
-        if (ctx := _MaysyncContext.current()) is None or ctx.mode == 'a':
-            return self._x._mg(*self._args, **self._kwargs)  # noqa
+    for f in (drv := _MaysyncDriver(_MaysyncRunContext(m), m)):
+        f.s()
+        del f
 
-        async def inner():
-            for f in (drv := self._driver(_AsyncMaysyncContext())):
-                await f.a()
-                del f
+    return drv.value
 
-            return drv.value
 
-        return inner()
+def run_maysync_generator_fn(
+        m: ta.AsyncGenerator[O, I],
+) -> ta.Generator[O, I, None]:
+    if isinstance(m, MaysyncGenerator):
+        return m.__run_maysync__()
 
+    def inner():
+        ctx = _MaysyncRunContext(m)
 
-@ta.final
-class _MgMaysyncGeneratorFn(
-    _MgMaysyncFnLike[ta.AsyncGenerator[O, I]],
-    MaysyncGeneratorFn_[O, I],
-    ta.Generic[O, I],
-):
-    def __call__(self, *args, **kwargs):
-        return _MgMaysyncGenerator(self, args, kwargs)
-
-
-@ta.final
-class _MgMaysyncGeneratorDriver:
-    def __init__(self, ctx: _MaysyncContext, ag: ta.Any) -> None:
-        self.ctx = ctx
-        self.ag = ag
-
-    def __iter__(self) -> ta.Generator[
-        ta.Union[
-            ta.Tuple[ta.Literal['f'], '_MaysyncFuture'],
-            ta.Tuple[ta.Literal['o'], ta.Any],
-        ],
-        ta.Union[
-            ta.Tuple[ta.Any, BaseException],
-            None,
-        ],
-        None,
-    ]:
         try:
-            ai = self.ag.__aiter__()
-            try:
-                i: ta.Any = None
-                e: ta.Any = None
+            i: ta.Any = None
+            e: ta.Any = None
 
-                while True:
-                    if e is not None:
-                        coro = ai.athrow(e)
-                    else:
-                        coro = ai.asend(i)
+            while True:
+                if e is not None:
+                    coro = m.athrow(e)
+                else:
+                    coro = m.asend(i)
 
-                    i = None
-                    e = None
+                i = None
+                e = None
 
-                    for f in (drv := _MgMaysyncDriver(self.ctx, coro)):
-                        if (x := (yield ('f', f))) is not None:
-                            raise RuntimeError(x)
+                drv = _MaysyncDriver(ctx, coro)
+                di = iter(drv)
+                try:
+                    while True:
+                        try:
+                            f = next(di)
+                        except StopAsyncIteration:
+                            return
+                        except StopIteration:
+                            break
 
+                        f.s()
                         del f
 
-                    i, e = yield ('o', drv.value)  # type: ignore[misc]
-
-            finally:
-                if ai is not self.ag:
-                    for f in _MgMaysyncDriver(self.ctx, ai.aclose()):
-                        yield ('f', f)
-
-        finally:
-            for f in _MgMaysyncDriver(self.ctx, self.ag.aclose()):
-                yield ('f', f)
-
-
-@ta.final
-class _MgMaysyncGenerator(
-    _MaysyncGenerator[_MgMaysyncGeneratorFn[O, I], O, I],
-):
-    def _driver(self, ctx: _MaysyncContext) -> _MgMaysyncGeneratorDriver:
-        return _MgMaysyncGeneratorDriver(ctx, self._x._mg(*self._args, **self._kwargs))  # noqa
-
-    def s(self) -> ta.Generator[O, I, None]:
-        di = iter(self._driver(_SyncMaysyncContext()))
-
-        ie: ta.Any = None
-
-        while True:
-            try:
-                t, x = di.send(ie)
-            except StopAsyncIteration:
-                return
-            except StopIteration:
-                raise RuntimeError from None
-
-            ie = None
-
-            if t == 'f':
-                x.s()
+                finally:
+                    di.close()
 
-            elif t == 'o':
+                o = drv.value
                 try:
-                    ie = ((yield x), None)  # type: ignore[misc]
+                    i = yield o
                 except BaseException as ex:  # noqa
-                    ie = (None, ex)
-
-            else:
-                raise RuntimeError((t, x))
-
-            del x
-
-    def a(self) -> ta.AsyncGenerator[O, I]:
-        if _MaysyncContext.current() is not None:
-            return self._x._mg(*self._args, **self._kwargs)  # noqa
+                    e = ex
 
-        async def inner():
-            di = iter(self._driver(_AsyncMaysyncContext()))
-
-            ie: ta.Any = None
-
-            while True:
-                try:
-                    t, x = di.send(ie)
-                except StopAsyncIteration:
-                    return
-                except StopIteration:
-                    raise RuntimeError from None
-
-                ie = None
-
-                if t == 'f':
-                    await x.a()
-
-                elif t == 'o':
-                    try:
-                        ie = ((yield x), None)
-                    except BaseException as ex:  # noqa
-                        ie = (None, ex)
-
-                else:
-                    raise RuntimeError((t, x))
-
-                del x
-
-        return inner()
-
-
-def maysync_fn(
-        m: ta.Callable[..., ta.Awaitable[T]],
-) -> MaysyncFn[T]:
-    """Constructs a MaysyncFn from a 'maysync flavored' async function."""
-
-    return _MgMaysyncFn(m)
-
-
-def maysync_generator_fn(
-        m: ta.Callable[..., ta.AsyncGenerator[O, I]],
-) -> MaysyncGeneratorFn[O, I]:
-    """Constructs a MaysyncGeneratorFn from a 'maysync flavored' async generator function."""
+        finally:
+            for f in _MaysyncDriver(ctx, m.aclose()):
+                f.s()
 
-    return _MgMaysyncGeneratorFn(m)
+    return inner()
 
 
 @ta.overload
-def maysync(
-        m: ta.Callable[..., ta.Awaitable[T]],
-) -> MaysyncFn[T]:
+def run_maysync(
+        m: ta.Awaitable[T],
+) -> T:
     ...
 
 
 @ta.overload
-def maysync(
-        m: ta.Callable[..., ta.AsyncGenerator[O, I]],
-) -> MaysyncGeneratorFn[O, I]:
+def run_maysync(
+        m: ta.AsyncGenerator[O, I],
+) -> ta.Generator[O, I, None]:
     ...
 
 
-def maysync(m):
-    """
-    Constructs a MaysyncFn or MaysyncGeneratorFn from 'maysync flavored' async function or async generator function,
-    using `inspect.isasyncgenfunction` to determine the type. Usable as a decorator.
-    """
-
-    if inspect.isasyncgenfunction(m):
-        return maysync_generator_fn(m)
+def run_maysync(m):
+    if hasattr(m, '__await__'):
+        return run_maysync_fn(m)
+    elif hasattr(m, '__aiter__'):
+        return run_maysync_generator_fn(m)
     else:
-        return maysync_fn(m)
+        raise TypeError(m)
 
 
 ##
 
 
-@ta.final
-class _MaysyncFutureNotAwaitedError(RuntimeError):
-    pass
+_MAYSYNC_MARK_ATTR = '__maysync__'
 
 
-@ta.final
-class _MaysyncFuture(ta.Generic[T]):
-    def __init__(
-            self,
-            x: ta.Callable[[], Maywaitable[T]],
-    ) -> None:
-        self._x = x
+def mark_maysync(o):
+    if not callable(o) or isinstance(o, AnyMaysyncFn):
+        raise TypeError(o)
+    setattr(o, _MAYSYNC_MARK_ATTR, True)
+    return o
 
-    def __repr__(self) -> str:
-        return f'{self.__class__.__name__}@{id(self):x}({self._x!r}, done={self.done!r})'
 
-    done: bool = False
-    result: T
-    error: ta.Optional[BaseException] = None
+def is_maysync(o: ta.Any) -> bool:
+    return isinstance(o, AnyMaysyncFn) or getattr(o, _MAYSYNC_MARK_ATTR, False)
 
-    def __await__(self):
-        if not self.done:
-            yield self
-        if not self.done:
-            raise _MaysyncFutureNotAwaitedError
-        if self.error is not None:
-            raise self.error
-        else:
-            return self.result
-
-    def s(self) -> None:
-        if self.done:
-            return
-
-        try:
-            self.result = self._x().s()
-        except BaseException as ex:  # noqa
-            self.error = ex
-        self.done = True
-
-    async def a(self) -> None:
-        if self.done:
-            return
 
-        try:
-            self.result = await self._x().a()
-        except BaseException as ex:  # noqa
-            self.error = ex
-        self.done = True
+mark_maysync(AnyMaysyncFn)