pyfect-dev 0.1.0__py3-none-any.whl

pyfect/stream/_zip_methods.py

@@ -0,0 +1,279 @@
+"""``Stream`` methods that combine two streams: zipping them item by item,
+pairing their latest items, crossing them, merging them as their items
+come, interleaving them and racing them."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any, Never, overload
+
+from pyfect.stream._base import A_co, E_co, R_co, StreamBase, require_stream
+
+if TYPE_CHECKING:
+    from pyfect._core import Effect
+    from pyfect.channel._concurrency_methods import HaltStrategy
+    from pyfect.errors import Done
+    from pyfect.pull import Pull
+    from pyfect.result import Result
+    from pyfect.stream._stream import Stream
+
+
+class ZipMethods(StreamBase[A_co, E_co, R_co]):
+    __slots__ = ()
+
+    # --- zipping --------------------------------------------------------------
+
+    def zip[B, E2 = Never, R2 = Never](
+        self, that: Stream[B, E2, R2]
+    ) -> Stream[tuple[A_co, B], E_co | E2, R_co | R2]:
+        """Pair the items of both streams in order, pulling both at once;
+        end when either ends."""
+        require_stream(that, "that")
+        return self.zip_with(that, _pair)
+
+    def zip_with[B, C, E2 = Never, R2 = Never](
+        self, that: Stream[B, E2, R2], f: Callable[[A_co, B], C]
+    ) -> Stream[C, E_co | E2, R_co | R2]:
+        """``zip``, writing ``f(left, right)`` for each pair."""
+        from pyfect.stream import _zipping
+
+        require_stream(that, "that")
+        return _zipping.zip_with(self, that, f)
+
+    def zip_with_array[B, C, E2 = Never, R2 = Never](
+        self,
+        that: Stream[B, E2, R2],
+        f: Callable[
+            [tuple[A_co, ...], tuple[B, ...]],
+            tuple[tuple[C, ...], tuple[A_co, ...], tuple[B, ...]],
+        ],
+    ) -> Stream[C, E_co | E2, R_co | R2]:
+        """Zip chunk by chunk: ``f(left, right)`` gives the chunk to write
+        and the left and right items it left over, which the next call gets
+        before anything new is pulled from that side."""
+        from pyfect.stream import _zipping
+
+        require_stream(that, "that")
+        return _zipping.zip_with_array(self, that, f)
+
+    def zip_left[E2 = Never, R2 = Never](
+        self, that: Stream[object, E2, R2]
+    ) -> Stream[A_co, E_co | E2, R_co | R2]:
+        """``zip``, keeping the left items."""
+        require_stream(that, "that")
+        return self.zip_with(that, _left)
+
+    def zip_right[B, E2 = Never, R2 = Never](
+        self, that: Stream[B, E2, R2]
+    ) -> Stream[B, E_co | E2, R_co | R2]:
+        """``zip``, keeping the right items."""
+        require_stream(that, "that")
+        return self.zip_with(that, _right)
+
+    def zip_flatten[*Ts, B, E2 = Never, R2 = Never](
+        self: ZipMethods[tuple[*Ts], E_co, R_co], that: Stream[B, E2, R2]
+    ) -> Stream[tuple[*Ts, B], E_co | E2, R_co | R2]:
+        """``zip`` for a stream of tuples: append each right item to its
+        left tuple."""
+        require_stream(that, "that")
+        return self.zip_with(that, lambda left, right: (*left, right))
+
+    def zip_latest[B, E2 = Never, R2 = Never](
+        self, that: Stream[B, E2, R2]
+    ) -> Stream[tuple[A_co, B], E_co | E2, R_co | R2]:
+        """Once both streams have written, pair each new item with the
+        other stream's latest; end when either ends."""
+        from pyfect.stream import _zipping
+
+        require_stream(that, "that")
+        return _zipping.zip_latest_all(self, that)
+
+    def zip_latest_with[B, C, E2 = Never, R2 = Never](
+        self, that: Stream[B, E2, R2], f: Callable[[A_co, B], C]
+    ) -> Stream[C, E_co | E2, R_co | R2]:
+        """``zip_latest``, writing ``f(left, right)`` for each pair."""
+        require_stream(that, "that")
+        return self.zip_latest(that).map(lambda pair: f(*pair))
+
+    def cross[B, E2 = Never, R2 = Never](
+        self, that: Stream[B, E2, R2]
+    ) -> Stream[tuple[A_co, B], E_co | E2, R_co | R2]:
+        """Every pair of a left and a right item: ``that`` runs again for
+        each left item."""
+        require_stream(that, "that")
+        return self.cross_with(that, _pair)
+
+    def cross_with[B, C, E2 = Never, R2 = Never](
+        self, that: Stream[B, E2, R2], f: Callable[[A_co, B], C]
+    ) -> Stream[C, E_co | E2, R_co | R2]:
+        """``cross``, writing ``f(left, right)`` for each pair."""
+        from pyfect.stream._base import as_stream
+
+        require_stream(that, "that")
+        return as_stream(self).flat_map(lambda left: that.map(lambda right: f(left, right)))
+
+    # --- merging --------------------------------------------------------------
+
+    def merge[B, E2 = Never, R2 = Never](
+        self, that: Stream[B, E2, R2], *, halt_strategy: HaltStrategy = "both"
+    ) -> Stream[A_co | B, E_co | E2, R_co | R2]:
+        """Run both streams at once, writing items as either writes them.
+        The merge ends when both have ended, or just the ``"left"`` (this)
+        or ``"right"`` one, or ``"either"``; a failure of either fails it."""
+        from pyfect.stream._stream import Stream
+
+        require_stream(that, "that")
+        return Stream(self._channel.merge(that._channel, halt_strategy=halt_strategy))
+
+    def merge_effect[E2 = Never, R2 = Never](
+        self, eff: Effect[object, E2, R2]
+    ) -> Stream[A_co, E_co | E2, R_co | R2]:
+        """Run ``eff`` alongside the stream: its failure fails the stream;
+        it is interrupted when the stream ends."""
+        from pyfect._effect_args import require_effect
+        from pyfect.stream._stream import Stream
+
+        require_effect(eff, "eff")
+        return Stream(self._channel.merge_effect(eff))
+
+    def merge_result[B, E2 = Never, R2 = Never](
+        self, that: Stream[B, E2, R2]
+    ) -> Stream[Result[A_co, B], E_co | E2, R_co | R2]:
+        """``merge``, writing this stream's items as ``Ok`` and ``that``'s as
+        ``Err``."""
+        from pyfect.result import Err, Ok
+        from pyfect.stream._base import as_stream
+
+        require_stream(that, "that")
+        lefts: Stream[Result[A_co, B], E_co, R_co] = as_stream(self).map(Ok)
+        return lefts.merge(that.map(Err))
+
+    def merge_left[E2 = Never, R2 = Never](
+        self, that: Stream[object, E2, R2]
+    ) -> Stream[A_co, E_co | E2, R_co | R2]:
+        """Run ``that`` alongside for its effects, writing this stream's
+        items."""
+        require_stream(that, "that")
+        return self.merge_effect(that.run_drain())
+
+    def merge_right[B, E2 = Never, R2 = Never](
+        self, that: Stream[B, E2, R2]
+    ) -> Stream[B, E_co | E2, R_co | R2]:
+        """Run this stream alongside for its effects, writing ``that``'s
+        items."""
+        from pyfect.stream._base import as_stream
+
+        require_stream(that, "that")
+        return that.merge_effect(as_stream(self).run_drain())
+
+    # --- combining with state ---------------------------------------------------
+
+    @overload
+    def combine[B, E2, S, C, RR = Never](
+        self,
+        that: Stream[B, E2, RR],
+        initial: Callable[[], S],
+        f: Callable[[S, Pull[A_co, E_co], Pull[B, E2]], Effect[tuple[C, S], Done, RR]],
+    ) -> Stream[C, Never, R_co | RR]: ...
+    @overload
+    def combine[B, E2, S, C, EE = Never, RR = Never](
+        self,
+        that: Stream[B, E2, RR],
+        initial: Callable[[], S],
+        f: Callable[[S, Pull[A_co, E_co], Pull[B, E2]], Effect[tuple[C, S], EE | Done, RR]],
+    ) -> Stream[C, EE, R_co | RR]: ...
+    def combine(
+        self,
+        that: Stream[Any, Any, Any],
+        initial: Callable[[], Any],
+        f: Callable[[Any, Any, Any], Effect[tuple[Any, Any], Any, Any]],
+    ) -> Stream[Any, Any, Any]:
+        """Write what ``f(state, pull_left, pull_right)`` makes, threading
+        its state; ``f`` pulls single items from either side as it likes and
+        ends the stream by failing with ``Done`` (as a pull of an ended side
+        does)."""
+        from pyfect.stream._mapping import one
+        from pyfect.stream._stream import Stream
+
+        require_stream(that, "that")
+        items = self._channel.flatten_array()
+        combined = items.combine(that._channel.flatten_array(), initial, f)
+        return Stream(combined.map(one))
+
+    @overload
+    def combine_array[B, E2, S, C, RR = Never](
+        self,
+        that: Stream[B, E2, RR],
+        initial: Callable[[], S],
+        f: Callable[
+            [S, Pull[tuple[A_co, ...], E_co], Pull[tuple[B, ...], E2]],
+            Effect[tuple[tuple[C, ...], S], Done, RR],
+        ],
+    ) -> Stream[C, Never, R_co | RR]: ...
+    @overload
+    def combine_array[B, E2, S, C, EE = Never, RR = Never](
+        self,
+        that: Stream[B, E2, RR],
+        initial: Callable[[], S],
+        f: Callable[
+            [S, Pull[tuple[A_co, ...], E_co], Pull[tuple[B, ...], E2]],
+            Effect[tuple[tuple[C, ...], S], EE | Done, RR],
+        ],
+    ) -> Stream[C, EE, R_co | RR]: ...
+    def combine_array(
+        self,
+        that: Stream[Any, Any, Any],
+        initial: Callable[[], Any],
+        f: Callable[[Any, Any, Any], Effect[tuple[Any, Any], Any, Any]],
+    ) -> Stream[Any, Any, Any]:
+        """``combine`` a chunk at a time: the pulls give chunks, and ``f``
+        makes a non-empty tuple of items to write."""
+        from pyfect.stream._stream import Stream
+
+        require_stream(that, "that")
+        return Stream(self._channel.combine(that._channel, initial, f))
+
+    # --- interleaving and racing ----------------------------------------------
+
+    def interleave[B, E2 = Never, R2 = Never](
+        self, that: Stream[B, E2, R2]
+    ) -> Stream[A_co | B, E_co | E2, R_co | R2]:
+        """Alternate items from this stream and ``that``, starting here; when
+        one ends, write the rest of the other."""
+        from pyfect.stream import _zipping
+
+        require_stream(that, "that")
+        return _zipping.interleave_with(self, that, _zipping.alternating())
+
+    def interleave_with[B, EE = Never, RR = Never](
+        self, that: Stream[B, EE, RR], decider: Stream[bool, EE, RR]
+    ) -> Stream[A_co | B, E_co | EE, R_co | RR]:
+        """Take the next item from this stream when ``decider`` writes
+        ``True`` and from ``that`` when it writes ``False``, skipping a side
+        that has ended; end when both have ended or ``decider`` does."""
+        from pyfect.stream import _zipping
+
+        require_stream(that, "that")
+        require_stream(decider, "decider")
+        return _zipping.interleave_with(self, that, decider)
+
+    def race[B, E2 = Never, R2 = Never](
+        self, that: Stream[B, E2, R2]
+    ) -> Stream[A_co | B, E_co | E2, R_co | R2]:
+        """The stream that writes first; the other is interrupted."""
+        from pyfect.stream import _zipping
+
+        require_stream(that, "that")
+        return _zipping.race_all(self, that)
+
+
+def _pair[A, B](left: A, right: B) -> tuple[A, B]:
+    return (left, right)
+
+
+def _left[A](left: A, _: object) -> A:
+    return left
+
+
+def _right[B](_: object, right: B) -> B:
+    return right

pyfect/stream/_zipping.py

@@ -0,0 +1,213 @@
+"""The work behind zipping, ``zip_latest_all``, interleaving and racing
+streams."""
+# pyright: reportPrivateUsage=false
+
+from __future__ import annotations
+
+import itertools
+from collections.abc import Callable, Generator
+from typing import Any
+
+from pyfect import channel
+from pyfect._core import Effect, _Gen, _Succeed, _Suspend, _Sync
+from pyfect._fiber_all import join_all
+from pyfect.channel import Channel
+from pyfect.channel._base import end_with
+from pyfect.exit import Exit, Success
+from pyfect.latch import Latch
+from pyfect.pull import catch_done
+from pyfect.scope import CloseableScope
+from pyfect.stream._base import AnyStream
+from pyfect.stream._stream import Stream
+
+type AnyEffect = Effect[Any, Any, Any]
+type Chunk = tuple[Any, ...]
+type AnyStream_ = Stream[Any, Any, Any]
+type AnyChannel = Channel[Any, Any, Any, Any, Any, Any, Any]
+
+_ENDED: AnyEffect = end_with(None)
+
+
+# --- zipping ------------------------------------------------------------------
+
+
+def zip_with_array(
+    left: AnyStream,
+    right: AnyStream,
+    f: Callable[[Chunk, Chunk], tuple[Chunk, Chunk, Chunk]],
+) -> AnyStream_:
+    def transform(_up: AnyEffect, scope: CloseableScope, _forked: CloseableScope) -> AnyEffect:
+        def body() -> Generator[AnyEffect, Any, AnyEffect]:
+            pull_left: AnyEffect = yield left._channel.to_pull_scoped(scope)
+            pull_right: AnyEffect = yield right._channel.to_pull_scoped(scope)
+
+            def both() -> Generator[AnyEffect, Any, list[Chunk]]:
+                fiber_left = yield pull_left.fork_in(scope)
+                fiber_right = yield pull_right.fork_in(scope)
+                return (yield join_all([fiber_left, fiber_right]))
+
+            pull_both = _Gen(both)
+            held_left: Chunk = ()
+            held_right: Chunk = ()
+
+            def pull() -> Generator[AnyEffect, Any, Chunk]:
+                nonlocal held_left, held_right
+                if held_left:
+                    pair = (held_left, held_right or (yield pull_right))
+                elif held_right:
+                    pair = ((yield pull_left), held_right)
+                else:
+                    pair = tuple((yield pull_both))
+                output, held_left, held_right = f(*pair)
+                return output
+
+            return _Gen(pull)
+
+        return _Gen(body)
+
+    return Stream(channel.from_transform_bracket(transform))
+
+
+def zip_with(left: AnyStream, right: AnyStream, f: Callable[[Any, Any], Any]) -> AnyStream_:
+    from pyfect.stream._constructors import suspend
+
+    def make() -> AnyStream_:
+        # Cursors into the current chunks, so a long chunk is not copied on
+        # every pull.
+        left_index = 0
+        right_index = 0
+
+        def step(lefts: Chunk, rights: Chunk) -> tuple[Chunk, Chunk, Chunk]:
+            nonlocal left_index, right_index
+            length = min(len(lefts) - left_index, len(rights) - right_index)
+            output = tuple(f(lefts[left_index + i], rights[right_index + i]) for i in range(length))
+            left_index += length
+            right_index += length
+            left_done = left_index == len(lefts)
+            right_done = right_index == len(rights)
+            if left_done:
+                left_index = 0
+            if right_done:
+                right_index = 0
+            return output, () if left_done else lefts, () if right_done else rights
+
+        return zip_with_array(left, right, step)
+
+    return suspend(make)
+
+
+_NOTHING: Any = object()
+
+
+def zip_latest_all(*streams: AnyStream) -> AnyStream_:
+    def make() -> AnyChannel:
+        count = len(streams)
+        latest: list[Any] = [None] * count
+        emitted: set[int] = set()
+        ready = Latch()
+        empty = Latch()
+
+        def side(index: int, stream: AnyStream) -> AnyChannel:
+            def on_item(item: Any) -> AnyEffect:
+                latest[index] = item
+                if index in emitted:
+                    return _Succeed((tuple(latest),))
+                emitted.add(index)
+                if len(emitted) < count:
+                    return ready.wait().as_(_NOTHING)
+                return ready.open().as_((tuple(latest),))
+
+            # A side ending without an item makes a full tuple impossible.
+            return (
+                stream._channel.flatten_array()
+                .map_effect(on_item)
+                .filter(lambda chunk: chunk is not _NOTHING)
+                .map_done_effect(lambda _: _Succeed(None) if index in emitted else empty.open())
+            )
+
+        sides = channel.from_iterable([side(i, s) for i, s in enumerate(streams)])
+        merged = sides.merge_all(concurrency="unbounded", buffer_size=0)
+        return merged.interrupt_when(empty.wait())
+
+    return Stream(channel.suspend(make))
+
+
+# --- interleaving -------------------------------------------------------------
+
+
+def alternating() -> AnyStream_:
+    from pyfect.stream._constructors import from_iterable
+
+    return from_iterable(itertools.cycle((True, False)))
+
+
+_RETRY: Any = object()
+
+
+def interleave_with(left: AnyStream, right: AnyStream, decider: AnyStream) -> AnyStream_:
+    def transform(_up: AnyEffect, scope: CloseableScope) -> AnyEffect:
+        def body() -> Generator[AnyEffect, Any, AnyEffect]:
+            pull_decider: AnyEffect = yield decider._channel.flatten_array().to_pull_scoped(scope)
+            pull_left: AnyEffect = yield left._channel.flatten_array().to_pull_scoped(scope)
+            pull_right: AnyEffect = yield right._channel.flatten_array().to_pull_scoped(scope)
+            done = [False, False]
+
+            def ending(index: int) -> Callable[[object], AnyEffect]:
+                def end(_: object) -> AnyEffect:
+                    done[index] = True
+                    return _Succeed(_RETRY)
+
+                return end
+
+            sides = (catch_done(pull_left, ending(0)), catch_done(pull_right, ending(1)))
+
+            def pull() -> Generator[AnyEffect, Any, Chunk]:
+                while True:
+                    if done[0] and done[1]:
+                        return (yield _ENDED)
+                    use_left: bool = yield pull_decider
+                    index = 0 if use_left else 1
+                    if done[index]:
+                        continue
+                    item = yield sides[index]
+                    if item is _RETRY:
+                        continue
+                    return (item,)
+
+            return _Gen(pull)
+
+        return _Gen(body)
+
+    return Stream(channel.from_transform(transform))
+
+
+# --- racing -------------------------------------------------------------------
+
+
+def race_all(*streams: AnyStream) -> AnyStream_:
+    from pyfect._concurrency import race_all as race_effects
+
+    def transform(_up: AnyEffect, scope: CloseableScope) -> AnyEffect:
+        def make() -> AnyEffect:
+            winner: list[AnyEffect] = []
+
+            def contender(stream: AnyStream) -> AnyEffect:
+                child = scope.fork_unsafe()
+
+                def settle(ex: Exit[Any, Any]) -> AnyEffect:
+                    if isinstance(ex, Success) and not winner:
+                        winner.append(ex.value[0])
+                        return _Succeed(None)
+                    return child.close(ex)
+
+                started = stream._channel.to_pull_scoped(child).flat_map(
+                    lambda pull: pull.map(lambda chunk: (pull, chunk))
+                )
+                return started.on_exit(settle).map(lambda pair: pair[1])
+
+            race = race_effects(*(contender(s) for s in streams))
+            return _Suspend(lambda: winner[0] if winner else race)
+
+        return _Sync(make)
+
+    return Stream(channel.from_transform(transform))

pyfect/subscription_ref.py

@@ -0,0 +1,66 @@
+"""``SubscriptionRef[A]``: a ``SynchronizedRef`` that publishes every value
+it stores.
+
+``subscribe()`` gives a ``pubsub.Subscription`` for the current scope: its
+first ``take`` is the current value, then every value stored after it, in
+order. Each update stores (and publishes) once, under the ref's lock, so
+subscribers see the values in the order they were set; a ``*_some``
+update that keeps the value publishes nothing.
+
+``changes()`` is the same as a ``Stream``: the current value, then every
+later one, from a subscription made when the stream starts.
+"""
+# pyright: reportPrivateUsage=false
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Never, overload
+
+from pyfect._core import Effect, _Sync
+from pyfect._locked_ref import LockedRef
+from pyfect._unsubscripted import Unsubscripted
+from pyfect.pubsub import Atomic, PubSub, Subscription
+from pyfect.scope import Scope
+
+if TYPE_CHECKING:
+    from pyfect.stream import Stream
+
+
+class SubscriptionRef[A = Unsubscripted](LockedRef[A]):
+    __slots__ = ("_pubsub",)
+
+    def __init__(self, value: A) -> None:
+        super().__init__(value)
+        self._pubsub = PubSub(Atomic[A].unbounded(replay=1), "dropping")
+        self._pubsub.publish_unsafe(value)
+
+    @overload
+    @classmethod
+    def make[T](
+        cls: type[SubscriptionRef[Unsubscripted]], value: T
+    ) -> Effect[SubscriptionRef[T]]: ...
+    @overload
+    @classmethod
+    def make(cls, value: A) -> Effect[SubscriptionRef[A]]: ...
+    @classmethod
+    def make[T](cls, value: T) -> Effect[SubscriptionRef[T]]:
+        return _Sync(lambda: SubscriptionRef(value))
+
+    def _store(self, value: A) -> None:
+        self._value = value
+        self._pubsub.publish_unsafe(value)
+
+    def subscribe(self) -> Effect[Subscription[A], Never, Scope]:
+        """Subscribe until the current scope closes: the current value, then
+        every later one."""
+        return self._pubsub.subscribe()
+
+    def changes(self) -> Stream[A]:
+        """A stream of the current value, then every later one (Effect's
+        ``SubscriptionRef.changes``). Each run subscribes anew."""
+        from pyfect.stream import from_pubsub
+
+        return from_pubsub(self._pubsub)
+
+
+__all__ = ["SubscriptionRef"]

pyfect/synchronized_ref.py

@@ -0,0 +1,38 @@
+"""``SynchronizedRef[A]``: a ``Ref`` whose updates can run effects.
+
+Updates take turns: each holds the ref's one-permit lock from reading the
+value to storing the new one, so ``update_effect(f)`` never loses a
+concurrent update while ``f``'s effect runs. If the effect fails or is
+interrupted, the value is unchanged. ``get`` never waits. An update
+started from inside another update's effect waits forever, as in Effect.
+"""
+# pyright: reportPrivateUsage=false
+
+from __future__ import annotations
+
+from typing import overload
+
+from pyfect._core import Effect, _Sync
+from pyfect._locked_ref import LockedRef
+from pyfect._unsubscripted import Unsubscripted
+
+
+class SynchronizedRef[A = Unsubscripted](LockedRef[A]):
+    """``SynchronizedRef(value)`` is Effect's ``makeUnsafe``."""
+
+    __slots__ = ()
+
+    @overload
+    @classmethod
+    def make[T](
+        cls: type[SynchronizedRef[Unsubscripted]], value: T
+    ) -> Effect[SynchronizedRef[T]]: ...
+    @overload
+    @classmethod
+    def make(cls, value: A) -> Effect[SynchronizedRef[A]]: ...
+    @classmethod
+    def make[T](cls, value: T) -> Effect[SynchronizedRef[T]]:
+        return _Sync(lambda: SynchronizedRef(value))
+
+
+__all__ = ["SynchronizedRef"]

pyfect/take.py

@@ -0,0 +1,36 @@
+"""``Take[A, E, L]``: one stored pull result (Effect's ``Take``).
+
+A take is a non-empty tuple of items, a ``Failure`` holding the producer's
+error, or a ``Success`` holding its ``Done`` leftover. Store or send takes
+(through a queue, say) and replay them later with ``to_pull``.
+"""
+# pyright: reportPrivateUsage=false
+
+from __future__ import annotations
+
+from typing import Never
+
+from pyfect._core import Effect, _FailCause, _Succeed
+from pyfect.cause import fail
+from pyfect.errors import Done
+from pyfect.exit import Exit, Failure, Success
+from pyfect.pull import Pull
+
+type Take[A, E = Never, L = None] = tuple[A, ...] | Exit[L, E]
+"""Items (never an empty tuple), a failure, or the end with its leftover."""
+
+
+def to_pull[A = Never, E = Never, L = None](take: Take[A, E, L]) -> Pull[tuple[A, ...], E, L]:
+    """The pull step ``take`` stands for: succeed with its items, fail with
+    its failure, or end with ``Done(leftover)``."""
+    match take:
+        case Success(value):
+            return _FailCause(fail(Done(value)))
+        case Failure(cause):
+            fails: Effect[Never, E] = _FailCause(cause)
+            return fails
+        case items:
+            return _Succeed(items)
+
+
+__all__ = ["Take", "to_pull"]

pyfect/terminal/__init__.py

@@ -0,0 +1,41 @@
+"""The terminal as a service (Effect's ``Terminal``): its size, a line or
+key presses from the user, and text shown to them::
+
+    term = yield from Terminal()
+    yield from term.display("Name? ")
+    name = yield from term.read_line   # QuitError at the end of input
+
+``layer`` is standard input and output (``live(should_quit=...)`` for
+another quit key); ``TerminalService(...)`` builds one for tests.
+"""
+
+from pyfect._public import publish
+from pyfect.layer import Layer
+from pyfect.layer import sync as _layer_sync
+from pyfect.terminal._keys import decode
+from pyfect.terminal._live import live
+from pyfect.terminal._service import (
+    Key,
+    QuitError,
+    Terminal,
+    TerminalService,
+    UserInput,
+    default_should_quit,
+)
+
+layer: Layer[Terminal] = _layer_sync(Terminal, live)
+"""Standard input and output."""
+
+__all__ = [
+    "Key",
+    "QuitError",
+    "Terminal",
+    "TerminalService",
+    "UserInput",
+    "decode",
+    "default_should_quit",
+    "layer",
+    "live",
+]
+
+publish(globals())