pyfect-dev 0.1.0__py3-none-any.whl

pyfect/schema/_struct_keys.py

@@ -0,0 +1,128 @@
+"""Struct key transformations (Effect's ``encodeKeys`` and ``extendTo``)::
+
+S.Struct(A).pipe(S.encode_keys({"a": "c"}))  # {"a": 1} <-> {"c": "1"}
+S.Struct(A).pipe(S.extend_to(B, {"c": lambda a: Some(a["a"])}))
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Mapping
+from dataclasses import replace
+from typing import Any
+
+from pyfect._equal import dedupe
+from pyfect._json_text import stringify
+from pyfect.option import Option, is_some
+from pyfect.schema import ast
+from pyfect.schema._schema import Bottom, Codec
+from pyfect.schema._struct import Struct, StructSchema
+from pyfect.schema._transform import DecodeToSchema, to_type
+from pyfect.schema.transformation import transform
+
+
+def _renamed(mapping: Mapping[str, str], value: Mapping[str, object]) -> dict[str, object]:
+    return {mapping.get(key, key): item for key, item in value.items()}
+
+
+class EncodeKeys:
+    """``encode_keys(mapping)``: apply with ``.pipe`` to a struct or class."""
+
+    __slots__ = ("_mapping",)
+
+    def __init__(self, mapping: Mapping[str, str]) -> None:
+        self._mapping = dict(mapping)
+
+    def __call__[T, RD, RE](
+        self, schema: Codec[T, Mapping[str, object], RD, RE], /
+    ) -> Bottom[T, Mapping[str, object], RD, RE]:
+        node = schema.__codec__().ast
+        encoded = ast.to_encoded(node)
+        if isinstance(encoded, ast.Class):
+            encoded = encoded.shape.encoded
+        if not isinstance(encoded, ast.Objects):
+            msg = f"encode_keys needs a struct or class, got {encoded.tag}"
+            raise TypeError(msg)
+        unknown = [key for key in self._mapping if all(p.name != key for p in encoded.properties)]
+        if unknown:
+            msg = f"Unknown keys in encode_keys mapping: {stringify(unknown)}"
+            raise ValueError(msg)
+        names = [self._mapping.get(str(p.name), p.name) for p in encoded.properties]
+        if len(dedupe(names)) != len(names):
+            msg = f"Duplicate encoded keys in {stringify(self._mapping)}"
+            raise ValueError(msg)
+        source = replace(
+            encoded,
+            properties=tuple(
+                replace(p, name=name) for p, name in zip(encoded.properties, names, strict=True)
+            ),
+        )
+        back = {encoded_name: name for name, encoded_name in self._mapping.items()}
+        renaming = transform(
+            decode=lambda value: _renamed(back, value),
+            encode=lambda value: _renamed(self._mapping, value),
+        )
+        return Bottom(ast.decode_to(source, node, renaming))
+
+
+def encode_keys(mapping: Mapping[str, str], /) -> EncodeKeys:
+    """The struct's keys renamed on the encoded side, ``{key: encoded
+    key}`` (Effect's ``encodeKeys``). Two keys encoding to one name, or a
+    mapping key that is not a field, raise ``ValueError``."""
+    return EncodeKeys(mapping)
+
+
+class ExtendTo[TD: Mapping[str, object], A: Mapping[str, object]]:
+    """``extend_to(typed_dict, derive)``: apply with ``.pipe`` to a struct."""
+
+    __slots__ = ("_derive", "_fields", "_typed_dict")
+
+    def __init__(
+        self,
+        typed_dict: type[TD],
+        derive: Mapping[str, Callable[[A], Option[object]]],
+        fields: Mapping[str, Codec[object, object, Any, Any]],
+    ) -> None:
+        self._typed_dict = typed_dict
+        self._derive = dict(derive)
+        self._fields = dict(fields)
+
+    def _decode(self, value: A) -> TD:
+        out: dict[str, object] = dict(value)
+        for key, derive in self._derive.items():
+            derived = derive(value)
+            if is_some(derived):
+                out[key] = derived.value
+        return out  # pyright: ignore[reportReturnType]  # checked by the target struct
+
+    def _encode(self, value: TD) -> A:
+        out = {key: item for key, item in value.items() if key not in self._derive}
+        return out  # pyright: ignore[reportReturnType]  # checked by the source struct
+
+    def __call__[RD, RE](
+        self, schema: StructSchema[A, RD, RE], /
+    ) -> DecodeToSchema[TD, Mapping[str, object], RD, RE]:
+        kept = {name: to_type(field) for name, field in schema.fields.items()}
+        target = Struct(self._typed_dict, **kept, **self._fields)
+        new = [key for key in target.fields if key not in kept]
+        if set(new) != set(self._derive):
+            msg = (
+                f"extend_to derives {stringify(list(self._derive))}, new keys are {stringify(new)}"
+            )
+            raise ValueError(msg)
+        transformation = transform(decode=self._decode, encode=self._encode)
+        node = ast.decode_to(schema.__codec__().ast, target.__codec__().ast, transformation)
+        return DecodeToSchema(node, schema, target)
+
+
+def extend_to[TD: Mapping[str, object], A: Mapping[str, object]](
+    typed_dict: type[TD],
+    derive: Mapping[str, Callable[[A], Option[object]]],
+    /,
+    **fields: Codec[object, object, Any, Any],
+) -> ExtendTo[TD, A]:
+    """The struct decoded into ``typed_dict``, a struct with its keys and
+    more, each new key ``derive[key](value)`` when that is ``Some``; the
+    new keys are dropped when encoding (Effect's ``extendTo``). A new key's
+    schema comes from its annotation unless given in ``fields``; ``derive``
+    must have exactly the new keys (else ``ValueError``)."""
+    return ExtendTo(typed_dict, derive, fields)

pyfect/schema/_tagged.py

@@ -0,0 +1,254 @@
+"""Tagged structs and unions (Effect's ``TaggedStruct``, ``tagDefaultOmit``,
+``toTaggedUnion`` and ``TaggedUnion``).
+
+A case of a tagged union is a schema whose values hold a literal under the
+tag key: a ``TaggedClass`` (its ``_tag`` attribute) or a struct of a
+TypedDict with a ``_tag: Literal["A"]`` key (a ``TaggedStruct``). The
+union keeps each case by its literal (``cases``, ``guards``,
+``is_any_of``); a value is matched with Python's ``match`` statement,
+which pyright checks for exhaustiveness (``case _: assert_never(shape)``)::
+
+    Shape = S.TaggedUnion(Circle, Square)  # TaggedClass cases
+    match shape:
+        case Circle(radius=r): ...
+        case Square(): ...
+
+A TypedDict case is matched on its tag alone (``case {"_tag": "Circle"}:``):
+pyright does not narrow a mapping pattern that also captures keys.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Mapping
+from dataclasses import dataclass
+from typing import (
+    Any,
+    Generic,
+    Never,
+    TypeGuard,
+    TypeVar,
+    cast,
+    get_args,
+    get_origin,
+    get_type_hints,
+    overload,
+)
+from typing import Literal as TypingLiteral
+
+from pyfect._js import js_number
+from pyfect.effect import succeed
+from pyfect.schema._constructor_default import tag
+from pyfect.schema._derive import optional_keys
+from pyfect.schema._literals import LiteralValue as LiteralInput
+from pyfect.schema._literals import Union, UnionSchema
+from pyfect.schema._middleware import with_decoding_default_key
+from pyfect.schema._parse import is_
+from pyfect.schema._schema import Codec
+from pyfect.schema._struct import Struct, StructSchema
+from pyfect.schema._transform import DecodeToSchema, to_type
+from pyfect.schema.ast import LiteralValue
+from pyfect.schema.ast._candidates import sentinels
+
+# Explicit covariant parameters: a frozen dataclass's fields would make
+# inferred ones invariant (``tests/test_schema_variance.py``).
+TD_co = TypeVar("TD_co", bound=Mapping[str, object], covariant=True)
+A_co = TypeVar("A_co", covariant=True)
+I_co = TypeVar("I_co", covariant=True)
+RD_co = TypeVar("RD_co", covariant=True)
+RE_co = TypeVar("RE_co", covariant=True)
+
+
+@dataclass(frozen=True, slots=True, eq=False)
+class TaggedStructSchema(StructSchema[TD_co, RD_co, RE_co], Generic[TD_co, RD_co, RE_co]):
+    """A struct whose ``"_tag"`` key holds ``tag``."""
+
+    tag: LiteralValue
+
+
+@overload
+def TaggedStruct[TD: Mapping[str, object]](
+    typed_dict: type[TD], /
+) -> TaggedStructSchema[TD, Never, Never]: ...
+@overload
+def TaggedStruct[TD: Mapping[str, object], RD, RE](
+    typed_dict: type[TD], /, **fields: Codec[object, object, RD, RE]
+) -> TaggedStructSchema[TD, RD, RE]: ...
+def TaggedStruct(
+    typed_dict: type[Mapping[str, object]], /, **fields: Codec[object, object, object, object]
+) -> TaggedStructSchema[Any, Any, Any]:
+    """``Struct(typed_dict, **fields)`` of a TypedDict whose ``_tag`` key
+    is one literal (``_tag: Literal["A"]``), a case of a tagged union
+    (Effect's ``TaggedStruct``); ``make`` fills the tag in (``S.tag``)
+    unless ``fields`` give the ``_tag`` schema. Any other ``_tag`` raises
+    ``TypeError``."""
+    hint = get_type_hints(typed_dict).get("_tag")
+    literals = get_args(hint) if get_origin(hint) is TypingLiteral else ()
+    if len(literals) != 1 or "_tag" in optional_keys(typed_dict):
+        raise TypeError(f'{typed_dict.__name__} needs a required "_tag" key of one literal')
+    struct = Struct(typed_dict, **{"_tag": tag(literals[0]), **fields})
+    return TaggedStructSchema(struct.ast, struct.fields, literals[0])
+
+
+def tag_default_omit[L: LiteralInput](literal: L, /) -> DecodeToSchema[L, L, Never, Never]:
+    """A ``"_tag"`` field holding ``literal``, filled in when decoding a
+    mapping without it and left out when encoding (Effect's
+    ``tagDefaultOmit``): ``S.Struct(A, _tag=S.tag_default_omit("A"))``;
+    ``make`` fills it in too (``S.tag``)."""
+    return tag(literal).pipe(with_decoding_default_key(succeed(literal), encoding_strategy="omit"))
+
+
+@dataclass(frozen=True, slots=True, eq=False)
+class TaggedUnionSchema(UnionSchema[A_co, I_co, RD_co, RE_co], Generic[A_co, I_co, RD_co, RE_co]):
+    """A union of cases told apart by the literal under ``tag``:
+    ``discriminants`` are the literals in member order, ``cases`` and
+    ``guards`` the case schema and its type guard by literal."""
+
+    tag: str
+    discriminants: tuple[LiteralValue, ...]
+    cases: Mapping[LiteralValue, Codec[A_co, I_co, RD_co, RE_co]]
+    guards: Mapping[LiteralValue, Callable[[object], TypeGuard[A_co]]]
+
+    def is_any_of[A](
+        self: TaggedUnionSchema[A, Any, Any, Any], *literals: LiteralValue
+    ) -> Callable[[A], bool]:
+        """Whether a value of the union is one of the cases of ``literals``."""
+        tag = self.tag
+
+        def test(value: A) -> bool:
+            found = _tag_of(value, tag)
+            return any(type(found) is type(lit) and found == lit for lit in literals)
+
+        return test
+
+    @overload
+    def match[A, T](
+        self: TaggedUnionSchema[A, Any, Any, Any],
+        cases: Mapping[LiteralValue, Callable[[A], T]],
+        /,
+    ) -> Callable[[A], T]: ...
+    @overload
+    def match[A, T](
+        self: TaggedUnionSchema[A, Any, Any, Any],
+        value: A,
+        cases: Mapping[LiteralValue, Callable[[A], T]],
+        /,
+    ) -> T: ...
+    def match(self, *args: Any) -> Any:
+        """``cases``' function for the case ``value`` is; given the cases
+        alone, the function of the value."""
+        if len(args) == 1:
+            cases_only = args[0]
+
+            def apply(value: Any) -> Any:
+                return cases_only[_tag_of(value, self.tag)](value)
+
+            return apply
+        value, cases = args
+        return cases[_tag_of(value, self.tag)](value)
+
+    @overload
+    def match_or_else[A, T](
+        self: TaggedUnionSchema[A, Any, Any, Any],
+        cases: Mapping[LiteralValue, Callable[[A], T]],
+        or_else: Callable[[A], T],
+        /,
+    ) -> Callable[[A], T]: ...
+    @overload
+    def match_or_else[A, T](
+        self: TaggedUnionSchema[A, Any, Any, Any],
+        value: A,
+        cases: Mapping[LiteralValue, Callable[[A], T]],
+        or_else: Callable[[A], T],
+        /,
+    ) -> T: ...
+    def match_or_else(self, *args: Any) -> Any:
+        """``match``, with ``or_else`` for a case ``cases`` leaves out."""
+        if len(args) == 2:
+            cases_only, otherwise = args
+
+            def apply(value: Any) -> Any:
+                return cases_only.get(_tag_of(value, self.tag), otherwise)(value)
+
+            return apply
+        value, cases, or_else = args
+        return cases.get(_tag_of(value, self.tag), or_else)(value)
+
+
+def _tag_of(value: object, tag: str) -> object:
+    if isinstance(value, Mapping):
+        return cast("Mapping[object, object]", value).get(tag)
+    return getattr(value, tag, None)
+
+
+def _key(literal: object) -> str | None:
+    """A literal's key as a property key (Effect's: ``1`` and ``"1"`` are
+    one key); ``None`` for a literal that is no key (a boolean, ``None``)."""
+    if isinstance(literal, str):
+        return literal
+    if isinstance(literal, int | float) and not isinstance(literal, bool):
+        return js_number(literal)
+    return None
+
+
+def _guard[A](member: Codec[A, object, object, object]) -> Callable[[object], TypeGuard[A]]:
+    test = is_(to_type(member))
+
+    def guard(value: object, /) -> TypeGuard[A]:
+        return test(value)
+
+    return guard
+
+
+class ToTaggedUnion:
+    """``to_tagged_union(tag)``: apply with ``.pipe`` to a ``UnionSchema``."""
+
+    __slots__ = ("_tag",)
+
+    def __init__(self, tag: str) -> None:
+        self._tag = tag
+
+    def __call__[A, I, RD, RE](
+        self, union: UnionSchema[A, I, RD, RE], /
+    ) -> TaggedUnionSchema[A, I, RD, RE]:
+        tag = self._tag
+        discriminants: list[LiteralValue] = []
+        cases: dict[LiteralValue, Codec[A, I, RD, RE]] = {}
+        keys: set[str] = set()
+
+        def walk(member: Codec[A, I, RD, RE]) -> None:
+            if isinstance(member, UnionSchema):
+                nested: UnionSchema[A, I, RD, RE] = member
+                for inner in nested.members:
+                    walk(inner)
+                return
+            found = [lit for key, lit in sentinels(member.__codec__().ast) if key == tag]
+            key = _key(found[0]) if found else None
+            if key is None:
+                raise ValueError("No literal or unique symbol found")
+            if key in keys:
+                raise ValueError(f"Duplicate discriminant: {key}")
+            keys.add(key)
+            discriminants.append(found[0])
+            cases[found[0]] = member
+
+        for member in union.members:
+            walk(member)
+        guards = {literal: _guard(case) for literal, case in cases.items()}
+        return TaggedUnionSchema(union.ast, union.members, tag, tuple(discriminants), cases, guards)
+
+
+def to_tagged_union(tag: str, /) -> ToTaggedUnion:
+    """The union with its cases kept by the literal each holds under
+    ``tag``, nested unions' cases included (Effect's ``toTaggedUnion``).
+    A case without a string or number literal there raises ``ValueError``,
+    as does a literal two cases share (``1`` and ``"1"`` are one)."""
+    return ToTaggedUnion(tag)
+
+
+def TaggedUnion[A = Never, I = Never, RD = Never, RE = Never](
+    *cases: Codec[A, I, RD, RE],
+) -> TaggedUnionSchema[A, I, RD, RE]:
+    """The union of ``cases`` told apart by ``"_tag"`` (Effect's
+    ``TaggedUnion``): each a ``TaggedClass``, a ``TaggedStruct`` or any
+    schema with a ``"_tag"`` literal."""
+    return to_tagged_union("_tag")(Union(*cases))

pyfect/schema/_template_literal.py

@@ -0,0 +1,172 @@
+"""``TemplateLiteral`` and ``TemplateLiteralParser``: strings made of
+ordered parts (Effect's schemas of TypeScript template literal types)::
+
+    S.TemplateLiteral("/user/", S.Number)          # "/user/123"
+    S.TemplateLiteralParser("/user/", S.FiniteFromString)
+    # decodes "/user/42" to ("/user/", 42)
+
+A part is a literal (``str``, ``int`` or ``float``, matched by its text) or
+a schema of strings, numbers or bigints (see ``ast.TemplateLiteral``).
+``TemplateLiteral`` keeps the string and rejects parts with an encoding;
+``TemplateLiteralParser`` decodes the string into a tuple with one value
+per part and takes any part whose encoded side is such a schema. Pyright
+cannot compute a template's string type nor the parser's tuple type: the
+Type is ``str`` and ``tuple[Any, ...]``.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from dataclasses import dataclass, replace
+from typing import Any, Generic, Never, TypeVar, overload
+
+from pyfect._one_or_many import one_or_many
+from pyfect.exit import Exit, Success
+from pyfect.schema import ast
+from pyfect.schema import transformation as T
+from pyfect.schema._codec_links import (
+    BIG_INT_TO_STRING,
+    FINITE_TO_STRING,
+    NUMBER_TO_STRING,
+    is_finite_number,
+    literal_to_string,
+)
+from pyfect.schema._options import ParseOptions
+from pyfect.schema._schema import Bottom, Codec, is_schema
+from pyfect.schema.ast._template_literal import (
+    TemplateLiteral as TemplateLiteralNode,
+)
+from pyfect.schema.ast._template_literal import (
+    normalize_encoded,
+    segment,
+    template_mismatch,
+)
+from pyfect.schema.issue import Issue
+
+RD_co = TypeVar("RD_co", covariant=True)
+RE_co = TypeVar("RE_co", covariant=True)
+
+type LiteralPart = str | int | float
+"""A literal part, matched by its text (``1`` by ``"1"``)."""
+type TemplateLiteralPart = Codec[Any, Any, Never, Never] | LiteralPart
+
+
+def _node(part: object) -> ast.AST:
+    if is_schema(part):
+        return part.__codec__().ast
+    return ast.Literal(part)  # pyright: ignore[reportArgumentType]
+
+
+def _nodes(parts: Sequence[object]) -> tuple[ast.AST, ...]:
+    return tuple(map(_node, parts))
+
+
+@dataclass(frozen=True, slots=True, eq=False)
+class TemplateLiteralSchema(Bottom[str, str, Never, Never]):
+    """A template literal; ``parts`` are its parts, as given."""
+
+    parts: tuple[TemplateLiteralPart, ...]
+
+
+@overload
+def TemplateLiteral(
+    parts: list[TemplateLiteralPart] | tuple[TemplateLiteralPart, ...], /
+) -> TemplateLiteralSchema: ...
+@overload
+def TemplateLiteral(*parts: TemplateLiteralPart) -> TemplateLiteralSchema: ...
+def TemplateLiteral(*parts: Any) -> TemplateLiteralSchema:
+    """The strings made of ``parts``, kept as they are (Effect's
+    ``TemplateLiteral``): ``Expected a string matching template literal
+    parts`` otherwise. The parts are given as arguments or, as in Effect,
+    as one list or tuple. A part with an encoding raises ``ValueError``
+    (use ``TemplateLiteralParser``)."""
+    parts = one_or_many(parts)
+    return TemplateLiteralSchema(TemplateLiteralNode(_nodes(parts)), parts)
+
+
+@dataclass(frozen=True, slots=True, eq=False)
+class TemplateLiteralParserSchema(
+    Bottom[tuple[Any, ...], str, RD_co, RE_co], Generic[RD_co, RE_co]
+):
+    """A template literal parser; ``parts`` are its parts, as given."""
+
+    parts: tuple[Codec[Any, Any, RD_co, RE_co] | LiteralPart, ...]
+
+
+@overload
+def TemplateLiteralParser[RD = Never, RE = Never](
+    parts: list[Codec[Any, Any, RD, RE] | LiteralPart]
+    | tuple[Codec[Any, Any, RD, RE] | LiteralPart, ...],
+    /,
+) -> TemplateLiteralParserSchema[RD, RE]: ...
+@overload
+def TemplateLiteralParser[RD = Never, RE = Never](
+    *parts: Codec[Any, Any, RD, RE] | LiteralPart,
+) -> TemplateLiteralParserSchema[RD, RE]: ...
+def TemplateLiteralParser(*parts: Any) -> TemplateLiteralParserSchema[Any, Any]:
+    """The strings made of ``parts``, decoded into a tuple of the parts'
+    values (Effect's ``TemplateLiteralParser``): a literal part gives its
+    literal, a schema part its decoded value. A part may transform (its
+    encoded side is the template's part). The split is greedy, so encoding
+    a tuple and decoding the string may give another tuple when a segment
+    holds a separator."""
+    parts = one_or_many(parts)
+    return TemplateLiteralParserSchema(template_literal_parser(_nodes(parts)), parts)
+
+
+# ------------------------------------------------------------------ the AST
+
+
+def part_from_string(node: ast.AST) -> ast.AST:
+    """``node`` read from its segment's text: a number, bigint or
+    non-string literal at its most encoded end decodes from its text
+    (Effect's ``partFromString``)."""
+    if node.encoding is not None:
+        *init, last = node.encoding
+        to = part_from_string(last.to)
+        return (
+            node
+            if to is last.to
+            else replace(node, encoding=(*init, ast.Link(to, last.transformation)))
+        )
+    match node:
+        case ast.Number():
+            link = FINITE_TO_STRING if is_finite_number(node) else NUMBER_TO_STRING
+            return replace(node, encoding=(link,))
+        case ast.BigInt():
+            return replace(node, encoding=(BIG_INT_TO_STRING,))
+        case ast.Literal() if not isinstance(node.literal, str):
+            return literal_to_string(node)
+        case ast.Union():
+            types = tuple(map(part_from_string, node.types))
+            same = all(a is b for a, b in zip(types, node.types, strict=True))
+            return node if same else replace(node, types=types)
+        case _:
+            return node
+
+
+def segments_tuple(nodes: Sequence[ast.AST]) -> ast.Arrays:
+    """A fixed tuple of ``nodes``."""
+    return ast.Arrays(tuple(ast.Element(node) for node in nodes))
+
+
+def _join(parts: tuple[str, ...]) -> str:
+    return "".join(parts)
+
+
+def template_literal_parser(parts: Sequence[ast.AST]) -> ast.Arrays:
+    """The tuple of ``parts``' values decoded from the template of their
+    encoded sides (Effect's ``templateLiteralParser``)."""
+    template = TemplateLiteralNode(normalize_encoded(parts))
+
+    def decode(text: str, options: ParseOptions) -> Exit[tuple[str, ...], Issue]:
+        segments = segment(template, text, options)
+        if segments is None:
+            return template_mismatch(text, options)
+        return Success(tuple(segments))
+
+    def encode(values: tuple[str, ...], _: ParseOptions) -> Exit[str, Issue]:
+        return Success(_join(values))
+
+    tuple_node = segments_tuple(tuple(map(part_from_string, parts)))
+    return ast.decode_to(template, tuple_node, T.transform_effect(decode=decode, encode=encode))

pyfect/schema/_to_codec_array_from_single.py

@@ -0,0 +1,115 @@
+"""``to_codec_array_from_single``: a schema whose arrays also decode from a
+single string (Effect's ``Schema.toCodecArrayFromSingle``), for query
+strings and forms, where a key given once is a string and a key given
+several times a list."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from dataclasses import dataclass, replace
+
+from pyfect.schema import ast
+from pyfect.schema import transformation as T
+from pyfect.schema._schema import Bottom, Codec
+
+
+def _to_array(value: Sequence[object] | str) -> Sequence[object]:
+    return [value] if isinstance(value, str) else value
+
+
+def _same(value: Sequence[object]) -> Sequence[object]:
+    return value
+
+
+FROM_SINGLE = T.transform(decode=_to_array, encode=_same)
+
+
+def to_codec_array_from_single[T_, E, RD, RE](
+    schema: Codec[T_, E, RD, RE], /
+) -> Bottom[T_, E, RD, RE]:
+    """``schema`` with every array (in structs, unions and arrays) also
+    decoding a single string as a one-element list; encoding is
+    unchanged. A comma-separated string is not split."""
+    return Bottom(_Walk()(schema.__codec__().ast))
+
+
+@dataclass(frozen=True, slots=True)
+class _WalkedThunk:
+    """A walked ``Suspend``'s target: marks it walked, so walking it again keeps it."""
+
+    walk: _Walk
+    source: ast.Suspend
+
+    def __call__(self) -> ast.AST:
+        return self.walk(self.source.target)
+
+
+class _Walk:
+    def __init__(self) -> None:
+        self._done: dict[int, ast.AST] = {}
+
+    def __call__(self, node: ast.AST) -> ast.AST:
+        done = self._done.get(id(node))
+        if done is not None:
+            return done
+        out = self._last_link(node)
+        self._done[id(node)] = out
+        self._done[id(out)] = out
+        return out
+
+    def _last_link(self, node: ast.AST) -> ast.AST:
+        if node.encoding is None:
+            return self._step(node)
+        *init, last = node.encoding
+        if last.transformation is FROM_SINGLE:
+            return node
+        to = self(last.to)
+        if to is last.to:
+            return node
+        return replace(node, encoding=(*init, ast.Link(to, last.transformation)))
+
+    def _step(self, node: ast.AST) -> ast.AST:
+        out = self._children(node)
+        if not isinstance(out, ast.Arrays):
+            return out
+        source = ast.Union(
+            (
+                ast.Arrays(
+                    tuple(ast.Element(ast.unknown, e.optional) for e in out.elements),
+                    tuple(ast.unknown for _ in out.rest),
+                ),
+                ast.string,
+            )
+        )
+        ensure = ast.decode_to(source, out, FROM_SINGLE)
+        return ast.optional_key(ensure) if node.optional_key else ensure
+
+    def _children(self, node: ast.AST) -> ast.AST:
+        match node:
+            case ast.Objects():
+                properties = tuple(replace(p, type=self(p.type)) for p in node.properties)
+                indexes = tuple(replace(i, type=self(i.type)) for i in node.index_signatures)
+                same = all(
+                    a.type is b.type for a, b in zip(properties, node.properties, strict=True)
+                ) and all(
+                    a.type is b.type for a, b in zip(indexes, node.index_signatures, strict=True)
+                )
+                return (
+                    node if same else replace(node, properties=properties, index_signatures=indexes)
+                )
+            case ast.Arrays():
+                return replace(
+                    node,
+                    elements=tuple(replace(e, type=self(e.type)) for e in node.elements),
+                    rest=tuple(map(self, node.rest)),
+                )
+            case ast.Union():
+                types = tuple(map(self, node.types))
+                same = all(a is b for a, b in zip(types, node.types, strict=True))
+                return node if same else replace(node, types=types)
+            case ast.Suspend() if isinstance(node.thunk, _WalkedThunk):
+                return node
+            case ast.Suspend():
+                return replace(node, thunk=_WalkedThunk(self, node))
+            case _:
+                return node