hclang 0.17.0 → 0.17.1

package/esm/lib/frames/frame-array.js

@@ -135,6 +135,16 @@ export class FrameArray extends FrameList {
     collects() {
         return true;
     }
+    /**
+     * A fresh aggregate holding the same elements. Only the outer aggregate is
+     * new: the elements are shared, so collecting reuses them rather than
+     * copying, and `===` still finds each one.
+     */
+    collectingCopy() {
+        const result = this.copy();
+        result.data = [...this.data];
+        return result;
+    }
     apply(argument, _parameter) {
         if (!argument.is.void) {
             this.data.push(argument);

package/esm/lib/frames/frame-handle.js

@@ -7,10 +7,11 @@ import { methodEffect } from "./effect-marker.js";
  *
  * The handle's charter is that reference and nothing more. Two rules define it:
  *
- * - **Transparency.** Wrapping must not change what a value prints, equals, or
- *   exposes, so rendering, data, metadata, and array views all delegate to the
- *   target. A handle is invisible to comparison, and assignment unwraps it, so
- *   a mutation lands on the same frame it would have without the wrapper.
+ * - **Transparency.** Wrapping must not change what a value prints, equals,
+ *   exposes, or answers when applied, so rendering, data, metadata, array
+ *   views, and application all delegate to the target. A handle is invisible to
+ *   comparison, and assignment unwraps it, so a mutation lands on the same
+ *   frame it would have without the wrapper.
  * - **Caller-scoped lookup.** A handle created by symbol lookup carries that
  *   read's lexical context separately from the shared target. Local and
  *   declared-parent lookup remains live on the target, then falls back through
@@ -125,6 +126,19 @@ export class FrameHandle extends Frame {
     called_by(context, parameter) {
         return context.apply(this.target, parameter);
     }
+    /** Transparency covers application: a named aggregate collects like its literal. */
+    collects() {
+        return this.target.collects();
+    }
+    /**
+     * Applying through a name answers what applying the value would, without
+     * writing through the name. A collect lands on a fresh aggregate, so `xs 3`
+     * answers a new array and `xs` is unchanged, whether or not the name is
+     * mutable: a write goes through a mutating method or `@`, never application.
+     */
+    apply(argument, parameter) {
+        return this.target.collectingCopy().apply(argument, parameter);
+    }
     toString() {
         return this.target.toString();
     }

package/esm/lib/frames/frame.js

@@ -302,6 +302,17 @@ export class Frame extends MetaFrame {
     collects() {
         return false;
     }
+    /**
+     * The receiver a collect lands on when it must not write this frame.
+     *
+     * A literal is a fresh aggregate each time it is evaluated, so collecting
+     * into it in place is unobservable. A value reached through a name is not,
+     * so the name asks for this instead. Anything that does not collect is its
+     * own receiver.
+     */
+    collectingCopy() {
+        return this;
+    }
     /**
      * The values this frame streams when it is iterated.
      *

package/esm/lib/version.js

@@ -1 +1 @@
-export const VERSION = "0.17.0";
+export const VERSION = "0.17.1";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hclang",
-  "version": "0.17.0",
+  "version": "0.17.1",
   "description": "Homoiconic C command-line interpreter and REPL",
   "keywords": [
     "language",