yapyon 0.5.2__tar.gz → 0.6.0.dev0__tar.gz

{yapyon-0.5.2 → yapyon-0.6.0.dev0}/CHANGELOG.md

@@ -9,6 +9,129 @@ before it needed `pip install yapyon --pre` to be seen.
 
 ---
 
+## 0.6.0.dev0 — Unreleased
+
+Development prerelease targeting specification and grammar **v0.6** for
+merge/source composition and unfinished persistence. This section records
+unreleased work, not a publication claim.
+
+### Changed — breaking
+
+- **Ordinary collection merging (§15.2)** combines lists by whole typed
+  elements and multimaps by complete key/value pairs, instead of replacing
+  them wholesale. Equal items retain the greater per-input occurrence count,
+  not the sum. Earlier positions stay; incoming occurrences match the first
+  equal unmatched original earlier occurrence or append in incoming order.
+  A match takes the complete higher representation, including lexemes and
+  a dictionary item's key order/kind, without recursive member fusion.
+  Standalone and explicitly replaced collections keep authored repetitions.
+- **Typed merge equality** distinguishes bool, int, and float: True, 1, and
+  1.0 are different items. Same-kind values ignore incidental literal spelling;
+  dictionaries compare associations independent of entry order/key kind,
+  multimaps compare ordered entry sequences, and Templates compare delivered
+  parts and hole metadata without rendering. Ordinary expression equality
+  retains its existing numeric behavior.
+- **None yields to containers in either order**, including empty dictionaries,
+  lists, and multimaps. Compatible empty inputs yield rather than clear
+  populated collections. Other noncombining kinds take the higher whole value. Use explicit
+  field replacement to force None or an empty collection over earlier data.
+- **Copies and calls merge by eventual value kind**, not parser-node class.
+  A deferred copy/call returning a dictionary now merges by key rather than
+  replacing an earlier dictionary wholesale; returned lists/multimaps use the
+  same collection operation as literals. Unknown kinds wait for resolution
+  without executing during merge or source saving.
+
+### Added
+
+- **Field replacement:** `key:= value` discards that field's earlier value,
+  including pending computation, and uses the complete incoming RHS. It is
+  not deletion or protection from later overrides. Colon and equals are
+  separate tokens, so `key : = value` is also valid; flow newlines may separate
+  them. An annotation alone does not raise the tier of otherwise literal data,
+  and direct record normalization preserves it. Same-contribution dictionary
+  duplicates remain akan; matched dictionary keys retain earlier spelling,
+  position, and name/non-name kind, without promotion.
+- **Explicit value composition (§16.5):** `|` is the lowest-precedence value
+  operator, below logical `or`, and associates left to right across mixed block
+  and flow operands. Right grouping remains meaningful; merge is not generally
+  associative. A pipe requires at least a ledger even with literal operands.
+  The hole/call-argument reference grammar is unchanged.
+- **Faithful unfinished-source layers (§15.8):** `Tree.to_source()` retains
+  computed-key dictionaries, comprehensions with nonempty contributions,
+  collection programs, replacement intent, lexical scopes, and meaningful
+  grouping as one parseable document. It does no lookup, environment access,
+  call, cast, serialization, comprehension iteration, template rendering,
+  or runtime duplicate comparison, and leaves the source tree unchanged.
+- **Slot composition preserves sequential operations.** A labeled field's
+  complete dictionary RHS is one override contribution, not a sequence to
+  apply separately to a future filler. Saving may lift sequential slot
+  operations into surrounding dictionary layers. Literal empty overrides
+  mean no operation on any filler kind; a new replacement slot still fills
+  normally. Kind-dependent named-slot contributions retain a discoverable,
+  fillable slot rather than guessing its eventual kind or final collection
+  position.
+- The former computed-key, pending replacement-boundary, and merged-dictionary-
+  comprehension save refusals are lifted where explicit layers faithfully
+  represent their state. **A completed fill's undecided historical abstract-slot
+  obligation and an unattached slot remain save-time refusals.** A later edit
+  is not retroactive fulfillment of a prior fill's own obligation. Source
+  saving remains distinct from record emission and finished-data serializers.
+
+### Documentation
+
+- Correct README quote-reuse guidance: a hole may use the enclosing string's
+  quote mark. Correct stale identifier-only-key and bare-call reservations
+  while retaining the narrower hole-interior postfix grammar. Extend the guide
+  and tutorial with typed merging, field replacement, meaningful grouping,
+  and save/reload continuations.
+
+## 0.5.3 — 2026-10-25
+
+Built to specification **v0.5**, amended with collection construction and data
+expressions. The operator-word compatibility change is noted below.
+
+### Compatibility
+
+- Lowercase operator words have their expression meaning in the new value
+  grammar. In particular, `not(None)` is logical negation, not a call to a
+  declared function named `not`, as it could be in 0.5.2. Use a non-operator
+  declared name (the existing uppercase naming convention avoids collisions).
+  Ordinary keys/path segments keep these words as names; hole references
+  retain their separate §5.1 grammar.
+
+### Added
+
+- **Collection comprehensions (§16)** for lists, dictionaries, and multimaps,
+  in inline and block forms. One `for` clause and one optional `if`; list
+  inputs bind one item, dictionary/multimap inputs bind each key/value pair.
+  Sources and result kinds are independent. Bindings are lexical and local;
+  output is fresh typed data. Computed result keys retain exact text, dictionary
+  duplicates are akan, and multimap repeats/order are retained.
+- **Data expressions:** comparisons, membership, `is None`/`is not None`, and
+  short-circuit boolean `and`/`or`/`not`. Conditions accept True, False, and
+  None only; None counts as false. Boolean operators return booleans, not
+  arbitrary operands. Explicit `__bool__` casting is unchanged.
+- **Postfix operations on constructed values and call results**, including
+  `[dialect for dialect in choices if condition][0]` and `.__get__(0)` for an
+  optional first result. Evaluation remains eager; selecting the first item
+  does not hide later comprehension errors. Safe receiver chains retain
+  their boundary through postfix selection and explicit grouping.
+- **Nonempty inline multimaps:** `{+ key: value, key: value}` uses one leading
+  marker and ordinary comma-separated pairs. Empty remains `{+}`; block
+  entries retain their individual markers. Literal inline multimaps are records.
+- Unfinished source saving preserves comprehensions and predicates without
+  evaluating inputs, environment references, or functions. A deferred dictionary
+  comprehension merged with another nonempty dictionary contribution is refused
+  at save time because source cannot retain both layers; empty literal layers
+  remain safe. In-memory dictionaries merge normally, before retained generated
+  value bodies resolve; lists/multimaps retain whole replacement.
+- Portable conformance cases and a complete `examples/comprehensions.yap`.
+
+### Fixed
+
+- A safe call on None skips its remaining arguments before evaluating them,
+  using the existing shared call path.
+
 ## 0.5.2 — 2026-10-24
 
 Built to specification **v0.5**, amended. **No breaking changes.** Adds

{yapyon-0.5.2 → yapyon-0.6.0.dev0}/MANIFEST.in

@@ -7,6 +7,8 @@ include CHANGELOG.md
 # specification travels for the same reason, and more so: the suite says
 # whether an implementation agrees, docs/ say what it is meant to agree with.
 recursive-include tests *.py
+# Merge/source continuation acceptance uses these four unfinished documents.
+recursive-include tests/fixtures/deferred-layer-case *.tmpl *.yap
 recursive-include examples *.yap
 recursive-include docs *.md
 # The conformance cases are .yap inputs and .json sidecars, not prose, and

{yapyon-0.5.2/src/yapyon.egg-info → yapyon-0.6.0.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: yapyon
-Version: 0.5.2
+Version: 0.6.0.dev0
 Summary: Python-style typed literals with YAML-like block structure
 Author-email: Jei Blanchard <jjb@bmail.club>
 License-Expression: GPL-3.0-or-later
@@ -86,6 +86,8 @@ $ python -m yapyon expand examples/bridge.yap    # a ledger in, a record out
 - [Details](https://github.com/doctorjei/yapyon/blob/main/docs/DETAILS.md) — the long-form guide: every feature, the API, and the CLI
 - [Specification](https://github.com/doctorjei/yapyon/blob/main/docs/SPEC.md) — what yapyon bytes mean (normative)
 - [Grammar](https://github.com/doctorjei/yapyon/blob/main/docs/GRAMMAR.md) — which bytes are well-formed yapyon (normative)
+- [Collection comprehensions](docs/DETAILS.md#collection-comprehensions) — typed list, dictionary, and multimap construction
+- [Merging values](docs/DETAILS.md#merging-values) — composition, field replacement, and unfinished-source persistence
 - [Conformance corpus](https://github.com/doctorjei/yapyon/tree/main/docs/conformance) — portable test cases for a second implementation
 - [Changelog](https://github.com/doctorjei/yapyon/blob/main/CHANGELOG.md)
 
@@ -98,12 +100,49 @@ Verbose success prints `ええやん`.
 
 A document is one of four kinds (discoverable via `yapyon.tier_of()`):
 - **record**: literals only (no resolver / resolution process)
-- **ledger**: splices & calls built-ins; resolves internally
-- **template**: incorporates external data (e.g., environment variables)
+- **ledger**: splices, constructs and composes values, and calls built-ins; resolves internally
+- **template**: holds slots or `yt` strings, or reads the loading process's environment
 - **assembly**: calls functions that a **contract** declares; can be assembled from multiple files
 
 Yapyon has no ambient scope nor includes and is built to be completely auditable / verifiable.
 
+## Value composition and unfinished source
+
+The **`0.6.0.dev0` development line** adds explicit composition and faithful
+saving of unfinished layers. `|` combines complete values; `:` uses ordinary
+combination at a field, while `:=` replaces that field's complete value:
+
+```yapyon
+settings:
+  paths: ["base", "shared"]
+  reset: ["old"]
+  |
+  paths: ["shared", "new", "shared"]
+  reset:= []
+```
+
+Here `paths` becomes `["base", "shared", "new", "shared"]`, and `reset`
+becomes `[]`. Dictionaries match unique keys recursively. Lists match whole
+typed elements, and multimaps match whole key/value pairs: each equal item
+keeps the larger count from either input, not the sum. Earlier positions
+stay; unmatched incoming occurrences append, and matches take the complete
+higher representation. `True`, `1`, and `1.0` are distinct for this comparison.
+`None` yields to containers in either order; explicit `:= None` forces it.
+Quoted/computed keys never become names through merging.
+
+A pipe has the lowest value-operator precedence and associates left to right.
+Grouping matters: `a | (b | c)` need not mean `a | b | c`. Block and flow
+operands may mix. Pipes require at least a ledger, even with literal operands;
+a replacement annotation alone can remain a record. Holes retain their
+existing reference/call grammar, without pipes.
+
+`Tree.to_source()` preserves unfinished expressions, contribution order,
+replacement intent, and meaningful grouping without resolving anything.
+Save the text and parse it again to continue filling slots and composing.
+Historical fill obligations that still need computed-key comparisons and
+unattached slots remain save-time refusals; see the
+[details](docs/DETAILS.md#save-now-finish-later).
+
 ## Element References
 
 A hole names a value. `a.b` selects a **name key**; `a["b"]` can also select a quoted or computed key. Quoted keys never become names, even when their text looks like an identifier.
@@ -128,9 +167,11 @@ mind:
 | `{d[p]}` | the key *stored in* `p`, resolved in the y-string's own scope |
 | `{mm.k}` | every value filed under `k` in a multimap, in order, as a list |
 
-`{a["bar"]}` where a dot would do is a `shiran` — legal, but say `{a.bar}`.
-Because the enclosing string's delimiter ends it, quote a key with the other
-mark: `y"{a['b']}"`.
+`{a["bar"]}` where a dot would do is shiran — legal, but say `{a.bar}`.
+Either quote mark works inside a hole, including the enclosing string's own:
+`y"{a["b"]}"` and `y"{a['b']}"` are both valid. A hole is scanned before the
+string's closing delimiter is sought, following modern Python's quote-reuse
+rule.
 
 ## Relative References
 

{yapyon-0.5.2 → yapyon-0.6.0.dev0}/README.md

@@ -59,6 +59,8 @@ $ python -m yapyon expand examples/bridge.yap    # a ledger in, a record out
 - [Details](https://github.com/doctorjei/yapyon/blob/main/docs/DETAILS.md) — the long-form guide: every feature, the API, and the CLI
 - [Specification](https://github.com/doctorjei/yapyon/blob/main/docs/SPEC.md) — what yapyon bytes mean (normative)
 - [Grammar](https://github.com/doctorjei/yapyon/blob/main/docs/GRAMMAR.md) — which bytes are well-formed yapyon (normative)
+- [Collection comprehensions](docs/DETAILS.md#collection-comprehensions) — typed list, dictionary, and multimap construction
+- [Merging values](docs/DETAILS.md#merging-values) — composition, field replacement, and unfinished-source persistence
 - [Conformance corpus](https://github.com/doctorjei/yapyon/tree/main/docs/conformance) — portable test cases for a second implementation
 - [Changelog](https://github.com/doctorjei/yapyon/blob/main/CHANGELOG.md)
 
@@ -71,12 +73,49 @@ Verbose success prints `ええやん`.
 
 A document is one of four kinds (discoverable via `yapyon.tier_of()`):
 - **record**: literals only (no resolver / resolution process)
-- **ledger**: splices & calls built-ins; resolves internally
-- **template**: incorporates external data (e.g., environment variables)
+- **ledger**: splices, constructs and composes values, and calls built-ins; resolves internally
+- **template**: holds slots or `yt` strings, or reads the loading process's environment
 - **assembly**: calls functions that a **contract** declares; can be assembled from multiple files
 
 Yapyon has no ambient scope nor includes and is built to be completely auditable / verifiable.
 
+## Value composition and unfinished source
+
+The **`0.6.0.dev0` development line** adds explicit composition and faithful
+saving of unfinished layers. `|` combines complete values; `:` uses ordinary
+combination at a field, while `:=` replaces that field's complete value:
+
+```yapyon
+settings:
+  paths: ["base", "shared"]
+  reset: ["old"]
+  |
+  paths: ["shared", "new", "shared"]
+  reset:= []
+```
+
+Here `paths` becomes `["base", "shared", "new", "shared"]`, and `reset`
+becomes `[]`. Dictionaries match unique keys recursively. Lists match whole
+typed elements, and multimaps match whole key/value pairs: each equal item
+keeps the larger count from either input, not the sum. Earlier positions
+stay; unmatched incoming occurrences append, and matches take the complete
+higher representation. `True`, `1`, and `1.0` are distinct for this comparison.
+`None` yields to containers in either order; explicit `:= None` forces it.
+Quoted/computed keys never become names through merging.
+
+A pipe has the lowest value-operator precedence and associates left to right.
+Grouping matters: `a | (b | c)` need not mean `a | b | c`. Block and flow
+operands may mix. Pipes require at least a ledger, even with literal operands;
+a replacement annotation alone can remain a record. Holes retain their
+existing reference/call grammar, without pipes.
+
+`Tree.to_source()` preserves unfinished expressions, contribution order,
+replacement intent, and meaningful grouping without resolving anything.
+Save the text and parse it again to continue filling slots and composing.
+Historical fill obligations that still need computed-key comparisons and
+unattached slots remain save-time refusals; see the
+[details](docs/DETAILS.md#save-now-finish-later).
+
 ## Element References
 
 A hole names a value. `a.b` selects a **name key**; `a["b"]` can also select a quoted or computed key. Quoted keys never become names, even when their text looks like an identifier.
@@ -101,9 +140,11 @@ mind:
 | `{d[p]}` | the key *stored in* `p`, resolved in the y-string's own scope |
 | `{mm.k}` | every value filed under `k` in a multimap, in order, as a list |
 
-`{a["bar"]}` where a dot would do is a `shiran` — legal, but say `{a.bar}`.
-Because the enclosing string's delimiter ends it, quote a key with the other
-mark: `y"{a['b']}"`.
+`{a["bar"]}` where a dot would do is shiran — legal, but say `{a.bar}`.
+Either quote mark works inside a hole, including the enclosing string's own:
+`y"{a["b"]}"` and `y"{a['b']}"` are both valid. A hole is scanned before the
+string's closing delimiter is sought, following modern Python's quote-reuse
+rule.
 
 ## Relative References