@rcrsr/rill 0.14.0 → 0.16.0

package/dist/runtime/core/values.js

@@ -35,7 +35,11 @@ export function isTypeValue(value) {
         '__rill_type' in value &&
         value.__rill_type === true);
 }
-/** Create ordered from entries array (named, preserves insertion order) */
+/**
+ * Create ordered from entries array (named, preserves insertion order).
+ * Entries may be 2-element [name, value] or 3-element [name, value, default]
+ * tuples; the third element carries a default value for `.^input` reflection.
+ */
 export function createOrdered(entries) {
     return Object.freeze({ __rill_ordered: true, entries: [...entries] });
 }
@@ -93,15 +97,112 @@ export function inferElementType(elements) {
     if (elements.length === 0)
         return { type: 'any' };
     const firstElem = elements[0];
-    const firstType = inferStructuralType(firstElem);
+    let accType = inferStructuralType(firstElem);
     for (let i = 1; i < elements.length; i++) {
         const elem = elements[i];
         const elemType = inferStructuralType(elem);
-        if (!structuralTypeEquals(firstType, elemType)) {
-            throw new RuntimeError('RILL-R002', `List elements must be the same type: expected ${formatStructuralType(firstType)}, got ${formatStructuralType(elemType)} at index ${i}`);
+        const merged = commonType(accType, elemType);
+        if (merged === null) {
+            throw new RuntimeError('RILL-R002', `List elements must be the same type: expected ${formatStructuralType(accType)}, got ${formatStructuralType(elemType)} at index ${i}`);
+        }
+        accType = merged;
+    }
+    return accType;
+}
+/**
+ * Merge uniform value types from two sides of the same compound type.
+ * Sub-case A: both carry valueType -> recurse commonType.
+ * Sub-case B: both carry structural fields -> extract value types, merge all.
+ * Returns the merged RillType on success, undefined when no uniform merge applies.
+ */
+function mergeUniformValueType(aValue, bValue, aFields, bFields) {
+    // Sub-case A: both carry valueType
+    if (aValue !== undefined && bValue !== undefined) {
+        const merged = commonType(aValue, bValue);
+        if (merged !== null)
+            return merged;
+        return undefined;
+    }
+    // Sub-case B: both carry structural fields
+    if (aFields !== undefined && bFields !== undefined) {
+        const allTypes = [
+            ...aFields.map((f) => f.type),
+            ...bFields.map((f) => f.type),
+        ];
+        if (allTypes.length === 0)
+            return undefined;
+        let merged = allTypes[0];
+        for (let i = 1; i < allTypes.length; i++) {
+            const next = commonType(merged, allTypes[i]);
+            if (next === null)
+                return undefined;
+            merged = next;
+        }
+        return merged;
+    }
+    return undefined;
+}
+/**
+ * Return the most specific shared type for two RillType values.
+ * Returns null when types are incompatible at the top level.
+ *
+ * Cascade priority:
+ * 1. Any-narrowing: if either side is `any`, return the other
+ * 2. Structural match: delegate to structuralTypeEquals; on true, return a
+ * 3. Recursive list: merge inner element types
+ * 3b. Uniform valueType: merge dict/tuple/ordered value types
+ * 4. Bare type fallback: same compound type but structural mismatch
+ * 5. Incompatible: different top-level types return null
+ */
+export function commonType(a, b) {
+    // 1. Any-narrowing
+    if (a.type === 'any')
+        return b;
+    if (b.type === 'any')
+        return a;
+    // 5. Incompatible top-level types (checked early to short-circuit)
+    if (a.type !== b.type)
+        return null;
+    // 2. Structural match
+    if (structuralTypeEquals(a, b))
+        return a;
+    // 3. Recursive list element merging
+    if (a.type === 'list' && b.type === 'list') {
+        if (a.element !== undefined && b.element !== undefined) {
+            const inner = commonType(a.element, b.element);
+            if (inner !== null)
+                return { type: 'list', element: inner };
         }
+        return { type: 'list' };
+    }
+    // 3b. Uniform valueType merging for dict/tuple/ordered
+    if (a.type === 'dict' && b.type === 'dict') {
+        const merged = mergeUniformValueType(a.valueType, b.valueType, a.fields ? Object.values(a.fields) : undefined, b.fields ? Object.values(b.fields) : undefined);
+        if (merged !== undefined)
+            return { type: 'dict', valueType: merged };
     }
-    return firstType;
+    if (a.type === 'tuple' && b.type === 'tuple') {
+        const merged = mergeUniformValueType(a.valueType, b.valueType, a.elements, b.elements);
+        if (merged !== undefined)
+            return { type: 'tuple', valueType: merged };
+    }
+    if (a.type === 'ordered' && b.type === 'ordered') {
+        const merged = mergeUniformValueType(a.valueType, b.valueType, a.fields, b.fields);
+        if (merged !== undefined)
+            return { type: 'ordered', valueType: merged };
+    }
+    // 4. Bare type fallback for compound types.
+    // The cast is safe for closure/dict/tuple/ordered (all sub-fields optional).
+    // For union, members is required by RillType but omitted here intentionally:
+    // bare union signals structural incompatibility without enumerating members.
+    if (a.type === 'closure' ||
+        a.type === 'dict' ||
+        a.type === 'tuple' ||
+        a.type === 'ordered' ||
+        a.type === 'union') {
+        return { type: a.type };
+    }
+    return null;
 }
 /** Compare two structural types for equality. */
 export function structuralTypeEquals(a, b) {
@@ -124,6 +225,15 @@ export function structuralTypeEquals(a, b) {
         return structuralTypeEquals(a.element, b.element);
     }
     if (a.type === 'dict' && b.type === 'dict') {
+        // Uniform valueType comparison (mirrors list element at line 308)
+        const aHasValue = a.valueType !== undefined;
+        const bHasValue = b.valueType !== undefined;
+        if (aHasValue || bHasValue) {
+            if (!aHasValue || !bHasValue)
+                return false;
+            return structuralTypeEquals(a.valueType, b.valueType);
+        }
+        // Structural fields comparison
         if (a.fields === undefined && b.fields === undefined)
             return true;
         if (a.fields === undefined || b.fields === undefined)
@@ -138,12 +248,29 @@ export function structuralTypeEquals(a, b) {
                 return false;
             const aField = a.fields[key];
             const bField = b.fields[key];
-            if (!structuralTypeEquals(aField, bField))
+            const aHasDefault = aField.defaultValue !== undefined;
+            const bHasDefault = bField.defaultValue !== undefined;
+            if (aHasDefault !== bHasDefault)
                 return false;
+            if (!structuralTypeEquals(aField.type, bField.type))
+                return false;
+            if (aHasDefault && bHasDefault) {
+                if (!deepEquals(aField.defaultValue, bField.defaultValue))
+                    return false;
+            }
         }
         return true;
     }
     if (a.type === 'tuple' && b.type === 'tuple') {
+        // Uniform valueType comparison (mirrors list element at line 308)
+        const aHasValue = a.valueType !== undefined;
+        const bHasValue = b.valueType !== undefined;
+        if (aHasValue || bHasValue) {
+            if (!aHasValue || !bHasValue)
+                return false;
+            return structuralTypeEquals(a.valueType, b.valueType);
+        }
+        // Structural elements comparison
         if (a.elements === undefined && b.elements === undefined)
             return true;
         if (a.elements === undefined || b.elements === undefined)
@@ -151,12 +278,31 @@ export function structuralTypeEquals(a, b) {
         if (a.elements.length !== b.elements.length)
             return false;
         for (let i = 0; i < a.elements.length; i++) {
-            if (!structuralTypeEquals(a.elements[i], b.elements[i]))
+            const aElem = a.elements[i];
+            const bElem = b.elements[i];
+            if (!structuralTypeEquals(aElem.type, bElem.type))
+                return false;
+            const aDefault = aElem.defaultValue;
+            const bDefault = bElem.defaultValue;
+            if (aDefault === undefined && bDefault === undefined)
+                continue;
+            if (aDefault === undefined || bDefault === undefined)
+                return false;
+            if (!deepEquals(aDefault, bDefault))
                 return false;
         }
         return true;
     }
     if (a.type === 'ordered' && b.type === 'ordered') {
+        // Uniform valueType comparison (mirrors list element at line 308)
+        const aHasValue = a.valueType !== undefined;
+        const bHasValue = b.valueType !== undefined;
+        if (aHasValue || bHasValue) {
+            if (!aHasValue || !bHasValue)
+                return false;
+            return structuralTypeEquals(a.valueType, b.valueType);
+        }
+        // Structural fields comparison
         if (a.fields === undefined && b.fields === undefined)
             return true;
         if (a.fields === undefined || b.fields === undefined)
@@ -166,9 +312,17 @@ export function structuralTypeEquals(a, b) {
         for (let i = 0; i < a.fields.length; i++) {
             const aField = a.fields[i];
             const bField = b.fields[i];
-            if (aField[0] !== bField[0])
+            if (aField.name !== bField.name)
                 return false;
-            if (!structuralTypeEquals(aField[1], bField[1]))
+            if (!structuralTypeEquals(aField.type, bField.type))
+                return false;
+            const aDefault = aField.defaultValue;
+            const bDefault = bField.defaultValue;
+            if (aDefault === undefined && bDefault === undefined)
+                continue;
+            if (aDefault === undefined || bDefault === undefined)
+                return false;
+            if (!deepEquals(aDefault, bDefault))
                 return false;
         }
         return true;
@@ -195,9 +349,17 @@ export function structuralTypeEquals(a, b) {
             for (let i = 0; i < a.params.length; i++) {
                 const aParam = a.params[i];
                 const bParam = b.params[i];
-                if (aParam[0] !== bParam[0])
+                if (aParam.name !== bParam.name)
+                    return false;
+                if (!structuralTypeEquals(aParam.type, bParam.type))
+                    return false;
+                const aDefault = aParam.defaultValue;
+                const bDefault = bParam.defaultValue;
+                if (aDefault === undefined && bDefault === undefined)
+                    continue;
+                if (aDefault === undefined || bDefault === undefined)
                     return false;
-                if (!structuralTypeEquals(aParam[1], bParam[1]))
+                if (!deepEquals(aDefault, bDefault))
                     return false;
             }
         }
@@ -229,23 +391,25 @@ export function inferStructuralType(value) {
     if (isTuple(value)) {
         return {
             type: 'tuple',
-            elements: value.entries.map(inferStructuralType),
+            elements: value.entries.map((e) => ({
+                type: inferStructuralType(e),
+            })),
         };
     }
     if (isOrdered(value)) {
         return {
             type: 'ordered',
-            fields: value.entries.map(([k, v]) => [k, inferStructuralType(v)]),
+            fields: value.entries.map(([k, v]) => ({
+                name: k,
+                type: inferStructuralType(v),
+            })),
         };
     }
     if (isVector(value)) {
         return { type: 'vector' };
     }
     if (isCallable(value)) {
-        const params = (value.params ?? []).map((p) => [
-            p.name,
-            p.type ?? { type: 'any' },
-        ]);
+        const params = (value.params ?? []).map((p) => paramToFieldDef(p.name, p.type ?? { type: 'any' }, p.defaultValue));
         const ret = value.returnType.structure;
         return { type: 'closure', params, ret };
     }
@@ -253,7 +417,7 @@ export function inferStructuralType(value) {
         const dict = value;
         const fields = {};
         for (const [k, v] of Object.entries(dict)) {
-            fields[k] = inferStructuralType(v);
+            fields[k] = { type: inferStructuralType(v) };
         }
         return { type: 'dict', fields };
     }
@@ -290,6 +454,11 @@ export function structuralTypeMatches(value, type) {
     if (type.type === 'dict') {
         if (!isDict(value))
             return false;
+        // Uniform value type check: every value must match valueType
+        if (type.valueType !== undefined) {
+            const vals = Object.values(value);
+            return vals.every((v) => structuralTypeMatches(v, type.valueType));
+        }
         // Absent fields sub-field: matches any dict value
         if (type.fields === undefined)
             return true;
@@ -299,9 +468,14 @@ export function structuralTypeMatches(value, type) {
             return true;
         const dict = value;
         for (const key of dictKeys) {
-            if (!(key in dict))
+            if (!(key in dict)) {
+                const field = type.fields[key];
+                if (field.defaultValue !== undefined)
+                    continue;
                 return false;
-            if (!structuralTypeMatches(dict[key], type.fields[key]))
+            }
+            const field = type.fields[key];
+            if (!structuralTypeMatches(dict[key], field.type))
                 return false;
         }
         return true;
@@ -309,15 +483,28 @@ export function structuralTypeMatches(value, type) {
     if (type.type === 'tuple') {
         if (!isTuple(value))
             return false;
+        // Uniform value type check: every entry must match valueType
+        if (type.valueType !== undefined) {
+            return value.entries.every((v) => structuralTypeMatches(v, type.valueType));
+        }
         // Absent elements sub-field: matches any tuple value
         if (type.elements === undefined)
             return true;
         if (type.elements.length === 0)
             return value.entries.length === 0;
-        if (value.entries.length !== type.elements.length)
+        // Reject if value has more entries than type elements
+        if (value.entries.length > type.elements.length)
             return false;
-        for (let i = 0; i < type.elements.length; i++) {
-            if (!structuralTypeMatches(value.entries[i], type.elements[i]))
+        // Reject if value is shorter and any trailing missing element lacks a default
+        if (value.entries.length < type.elements.length) {
+            for (let i = value.entries.length; i < type.elements.length; i++) {
+                const field = type.elements[i];
+                if (field.defaultValue === undefined)
+                    return false;
+            }
+        }
+        for (let i = 0; i < value.entries.length; i++) {
+            if (!structuralTypeMatches(value.entries[i], type.elements[i].type))
                 return false;
         }
         return true;
@@ -325,19 +512,32 @@ export function structuralTypeMatches(value, type) {
     if (type.type === 'ordered') {
         if (!isOrdered(value))
             return false;
+        // Uniform value type check: every entry value must match valueType
+        if (type.valueType !== undefined) {
+            return value.entries.every(([, v]) => structuralTypeMatches(v, type.valueType));
+        }
         // Absent fields sub-field: matches any ordered value
         if (type.fields === undefined)
             return true;
         if (type.fields.length === 0)
             return value.entries.length === 0;
-        if (value.entries.length !== type.fields.length)
+        // Reject if value has more entries than type fields
+        if (value.entries.length > type.fields.length)
             return false;
-        for (let i = 0; i < type.fields.length; i++) {
-            const [expectedName, expectedType] = type.fields[i];
+        // Reject if value is shorter and any trailing missing field lacks a default
+        if (value.entries.length < type.fields.length) {
+            for (let i = value.entries.length; i < type.fields.length; i++) {
+                const field = type.fields[i];
+                if (field.defaultValue === undefined)
+                    return false;
+            }
+        }
+        for (let i = 0; i < value.entries.length; i++) {
+            const field = type.fields[i];
             const [actualName, actualValue] = value.entries[i];
-            if (actualName !== expectedName)
+            if (actualName !== field.name)
                 return false;
-            if (!structuralTypeMatches(actualValue, expectedType))
+            if (!structuralTypeMatches(actualValue, field.type))
                 return false;
         }
         return true;
@@ -352,12 +552,12 @@ export function structuralTypeMatches(value, type) {
         if (valueParams.length !== type.params.length)
             return false;
         for (let i = 0; i < type.params.length; i++) {
-            const [expectedName, expectedType] = type.params[i];
+            const field = type.params[i];
             const param = valueParams[i];
-            if (param.name !== expectedName)
+            if (param.name !== field.name)
                 return false;
             const paramType = param.type ?? { type: 'any' };
-            if (!structuralTypeEquals(paramType, expectedType))
+            if (!structuralTypeEquals(paramType, field.type))
                 return false;
         }
         const retType = value.returnType.structure;
@@ -370,6 +570,27 @@ export function structuralTypeMatches(value, type) {
     }
     return false;
 }
+/** Build a closure param field definition from name, type, and optional default. */
+export function paramToFieldDef(name, type, defaultValue) {
+    const field = { name, type };
+    if (defaultValue !== undefined)
+        field.defaultValue = defaultValue;
+    return field;
+}
+/** Format a RillValue as a rill literal for use in type signatures. */
+function formatRillLiteral(value) {
+    if (typeof value === 'string') {
+        const escaped = value.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+        return `"${escaped}"`;
+    }
+    if (typeof value === 'number')
+        return String(value);
+    if (typeof value === 'boolean')
+        return value ? 'true' : 'false';
+    if (value === null)
+        return 'null';
+    return formatValue(value);
+}
 /** Format a structural type descriptor as a human-readable string. */
 export function formatStructuralType(type) {
     if (type.type === 'any' ||
@@ -386,30 +607,60 @@ export function formatStructuralType(type) {
         return `list(${formatStructuralType(type.element)})`;
     }
     if (type.type === 'dict') {
+        if (type.valueType !== undefined && type.fields === undefined) {
+            return `dict(${formatStructuralType(type.valueType)})`;
+        }
         if (type.fields === undefined)
             return 'dict';
         const parts = Object.keys(type.fields)
             .sort()
-            .map((k) => `${k}: ${formatStructuralType(type.fields[k])}`);
+            .map((k) => {
+            const field = type.fields[k];
+            const base = `${k}: ${formatStructuralType(field.type)}`;
+            if (field.defaultValue === undefined)
+                return base;
+            return `${base} = ${formatRillLiteral(field.defaultValue)}`;
+        });
         return `dict(${parts.join(', ')})`;
     }
     if (type.type === 'tuple') {
+        if (type.valueType !== undefined && type.elements === undefined) {
+            return `tuple(${formatStructuralType(type.valueType)})`;
+        }
         if (type.elements === undefined)
             return 'tuple';
-        const parts = type.elements.map(formatStructuralType);
+        const parts = type.elements.map((field) => {
+            const base = formatStructuralType(field.type);
+            if (field.defaultValue === undefined)
+                return base;
+            return `${base} = ${formatRillLiteral(field.defaultValue)}`;
+        });
         return `tuple(${parts.join(', ')})`;
     }
     if (type.type === 'ordered') {
+        if (type.valueType !== undefined && type.fields === undefined) {
+            return `ordered(${formatStructuralType(type.valueType)})`;
+        }
         if (type.fields === undefined)
             return 'ordered';
-        const parts = type.fields.map(([k, t]) => `${k}: ${formatStructuralType(t)}`);
+        const parts = type.fields.map((field) => {
+            const base = `${field.name}: ${formatStructuralType(field.type)}`;
+            if (field.defaultValue === undefined)
+                return base;
+            return `${base} = ${formatRillLiteral(field.defaultValue)}`;
+        });
         return `ordered(${parts.join(', ')})`;
     }
     if (type.type === 'closure') {
         if (type.params === undefined)
             return 'closure';
         const params = type.params
-            .map(([name, t]) => `${name}: ${formatStructuralType(t)}`)
+            .map((field) => {
+            const base = `${field.name}: ${formatStructuralType(field.type)}`;
+            if (field.defaultValue === undefined)
+                return base;
+            return `${base} = ${formatRillLiteral(field.defaultValue)}`;
+        })
             .join(', ');
         const ret = type.ret !== undefined ? formatStructuralType(type.ret) : 'any';
         return `|${params}| :${ret}`;
@@ -765,6 +1016,29 @@ export function rillTypeToTypeValue(type) {
         structure: type,
     });
 }
+/**
+ * Check if a type is a collection (dict, ordered, tuple) with defined
+ * fields or elements. Used to decide if an empty collection can be
+ * synthesized and hydrated.
+ */
+export function hasCollectionFields(type) {
+    return ((type.type === 'dict' && (!!type.fields || !!type.valueType)) ||
+        (type.type === 'ordered' && (!!type.fields || !!type.valueType)) ||
+        (type.type === 'tuple' && (!!type.elements || !!type.valueType)));
+}
+/**
+ * Create an empty collection value matching the given RillType.
+ * Assumes the type is dict, ordered, or tuple.
+ */
+export function emptyForType(type) {
+    if (type.type === 'dict')
+        return {};
+    if (type.type === 'ordered')
+        return createOrdered([]);
+    if (type.type === 'tuple')
+        return createTuple([]);
+    return {};
+}
 /** Check if a key name is reserved */
 export function isReservedMethod(name) {
     return RESERVED_DICT_METHODS.includes(name);
@@ -789,4 +1063,32 @@ export function isRillIterator(value) {
         return false;
     return true;
 }
-//# sourceMappingURL=values.js.map
+/**
+ * Deep copy a RillValue, producing a new independent value.
+ * Handles primitives, arrays, plain dicts, and null.
+ * Special markers (closures, tuples, ordered, vectors, type values) are returned
+ * as-is since they are immutable by contract.
+ */
+export function deepCopyRillValue(value) {
+    if (value === null || typeof value !== 'object') {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return value.map(deepCopyRillValue);
+    }
+    // Plain dict: copy recursively. Special markers (RillTuple, RillOrdered, etc.)
+    // carry __rill_* own properties and are treated as immutable; return as-is.
+    if (!('__rill_tuple' in value) &&
+        !('__rill_ordered' in value) &&
+        !('__rill_vector' in value) &&
+        !('__rill_type' in value) &&
+        !('__type' in value) &&
+        !('__rill_field_descriptor' in value)) {
+        const copy = {};
+        for (const [k, v] of Object.entries(value)) {
+            copy[k] = deepCopyRillValue(v);
+        }
+        return copy;
+    }
+    return value;
+}

package/dist/runtime/ext/builtins.d.ts

@@ -19,4 +19,3 @@ export declare const BUILTIN_METHODS: {
     bool: Record<string, RillFunction>;
     vector: Record<string, RillFunction>;
 };
-//# sourceMappingURL=builtins.d.ts.map