Add set stdlib function for immutable data path updates (94)

Runtime helpers:
- src/runtime.ts: Added kSet for JavaScript and k_set for Ruby
- docker/init.sql: Added elo_set PostgreSQL function

Bindings:
- src/bindings/javascript.ts: Registered set with helperCall('kSet')
- src/bindings/ruby.ts: Registered set using k_set helper
- src/bindings/sql.ts: Registered set using elo_set function

Tests:
- test/fixtures/datapath-set.elo: 12 acceptance tests covering:
  - Basic value setting
  - Nested path creation (.user.name)
  - Mixed array/object creation (.foo.0.bar)
  - Array index extension with nulls
  - Error cases (setting on wrong types)

Documentation:
- README.md: Added set to data navigation features
- web/src/pages/stdlib.astro: Added set to Tuple section

Usage:
  set({}, .name, 'Alice')           // => {name: 'Alice'}
  set({}, .user.name, 'Bob')        // => {user: {name: 'Bob'}}
  set({}, .foo.0.bar, 12)           // => {foo: [{bar: 12}]}
  set({items: [1, 2, 3]}, .items.1, 99)  // => {items: [1, 99, 3]}

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: claude

.claude/tasks/done/94-fetch-and-xxx.md

@@ -0,0 +1,32 @@
+## Problem to solve
+
+We can easily extract a value from a data structure with `fetch`.
+It should be as easy to set/replace a value somewhere in that datastructure
+with a datapath and a replacement value.
+
+## Idea
+
+- Find a name for that function (`set` or find something better)
+- Provide an implementation/compilation such that whatever the path, the
+  value is set, creating necessary tuples/list in the structure (and only
+  failing if a conflict occurs)
+
+## Example
+
+```elo
+assert({} |> set(.foo.0.bar, 12) == { foo: [{ bar: 12 }] })
+```
+
+```elo
+assertFails([] |> set(.foo.0.bar, 12))
+```
+
+## Todo
+
+- Find a name
+- Implement
+- Complete Learn (?) / Reference (?) / Stdlib (!)
+- If you modify examples on website, maintain tracking unit/acceptance tests
+  accordingly
+- If you modify the table of contents on the website, make sure burger menu is
+  kept in sync

README.md

@@ -48,7 +48,7 @@ See also the Related work section below.
   - Objects: `{name: 'Alice', age: 30}`
   - Arrays: `[1, 2, 3]`, `['a', 'b']`, `[1, 'mixed', true, null]`
   - DataPaths: `.x.y.z`, `.items.0.name` (for navigating data structures)
-- **Data navigation**: `fetch(data, .path)` for safe access with null handling
+- **Data navigation**: `fetch(data, .path)` for safe access with null handling, `set(data, .path, value)` for immutable updates
 - **Parentheses** for grouping
 - **Multi-target compilation**:
   - Ruby (using `**` for power, `&&`/`||`/`!` for boolean logic, `Date.parse()`, `DateTime.parse()`, `ActiveSupport::Duration.parse()`)

docker/init.sql

@@ -112,3 +112,65 @@ EXCEPTION WHEN OTHERS THEN
   RAISE EXCEPTION '.: expected Data, got %', pg_typeof(v);
 END;
 $$ LANGUAGE plpgsql IMMUTABLE;
+
+-- Set a value at a path in JSONB, creating intermediate structures as needed
+CREATE OR REPLACE FUNCTION elo_set(data JSONB, path TEXT[], value JSONB) RETURNS JSONB AS $$
+DECLARE
+  seg TEXT;
+  rest TEXT[];
+  next_default JSONB;
+  existing JSONB;
+  arr JSONB;
+  obj JSONB;
+  i INTEGER;
+  arr_len INTEGER;
+BEGIN
+  IF array_length(path, 1) IS NULL OR array_length(path, 1) = 0 THEN
+    RETURN value;
+  END IF;
+
+  seg := path[1];
+  rest := path[2:];
+
+  -- Determine what default structure to create for next level
+  IF array_length(rest, 1) IS NULL OR array_length(rest, 1) = 0 THEN
+    next_default := 'null'::jsonb;
+  ELSIF rest[1] ~ '^\d+$' THEN
+    next_default := '[]'::jsonb;
+  ELSE
+    next_default := '{}'::jsonb;
+  END IF;
+
+  -- Is this an array index?
+  IF seg ~ '^\d+$' THEN
+    i := seg::INTEGER;
+    IF data IS NOT NULL AND jsonb_typeof(data) != 'null' AND jsonb_typeof(data) != 'array' THEN
+      RAISE EXCEPTION 'cannot set array index on non-array';
+    END IF;
+    arr := COALESCE(NULLIF(data, 'null'::jsonb), '[]'::jsonb);
+    arr_len := jsonb_array_length(arr);
+    -- Extend array with nulls if needed
+    WHILE arr_len <= i LOOP
+      arr := arr || 'null'::jsonb;
+      arr_len := arr_len + 1;
+    END LOOP;
+    existing := arr->i;
+    IF existing IS NULL OR jsonb_typeof(existing) = 'null' THEN
+      existing := next_default;
+    END IF;
+    arr := jsonb_set(arr, ARRAY[i::TEXT], elo_set(existing, rest, value));
+    RETURN arr;
+  ELSE
+    -- Object key
+    IF data IS NOT NULL AND jsonb_typeof(data) != 'null' AND jsonb_typeof(data) = 'array' THEN
+      RAISE EXCEPTION 'cannot set object key on array';
+    END IF;
+    obj := COALESCE(NULLIF(data, 'null'::jsonb), '{}'::jsonb);
+    existing := obj->seg;
+    IF existing IS NULL OR jsonb_typeof(existing) = 'null' THEN
+      existing := next_default;
+    END IF;
+    RETURN jsonb_set(obj, ARRAY[seg], elo_set(existing, rest, value));
+  END IF;
+END;
+$$ LANGUAGE plpgsql IMMUTABLE;

src/bindings/javascript.ts

@@ -354,6 +354,7 @@ export function createJavaScriptBinding(): StdLib<string> {
 
   // Data path navigation
   jsLib.register('fetch', [Types.any, Types.fn], helperCall('kFetch'));
+  jsLib.register('set', [Types.any, Types.fn, Types.any], helperCall('kSet'));
 
   // Error handling
   jsLib.register('fail', [Types.string], (args, ctx) => {

src/bindings/ruby.ts

@@ -285,6 +285,13 @@ export function createRubyBinding(): StdLib<string> {
     const path = ctx.emit(args[1]);
     return `(->(d, p) { p.reduce(d) { |cur, seg| break nil if cur.nil?; seg.is_a?(Integer) ? (cur.is_a?(Array) ? cur[seg] : nil) : (cur.is_a?(Hash) ? cur[seg] : nil) } }).call(${data}, ${path})`;
   });
+  rubyLib.register('set', [Types.any, Types.fn, Types.any], (args, ctx) => {
+    ctx.requireHelper?.('k_set');
+    const data = ctx.emit(args[0]);
+    const path = ctx.emit(args[1]);
+    const value = ctx.emit(args[2]);
+    return `k_set(${data}, ${path}, ${value})`;
+  });
 
   // Error handling
   rubyLib.register('fail', [Types.string], (args, ctx) => {

src/bindings/sql.ts

@@ -278,6 +278,13 @@ export function createSQLBinding(): StdLib<string> {
     // Convert path array to text array and use jsonb #> operator
     return `(${data})::jsonb #> (${path})::text[]`;
   });
+  sqlLib.register('set', [Types.any, Types.fn, Types.any], (args, ctx) => {
+    const data = ctx.emit(args[0]);
+    const path = ctx.emit(args[1]);
+    const value = ctx.emit(args[2]);
+    // Use the elo_set function which handles path creation
+    return `elo_set((${data})::jsonb, (${path})::text[], to_jsonb(${value}))`;
+  });
 
   // Error handling - uses elo_fail() PL/pgSQL function that raises an exception
   sqlLib.register('fail', [Types.string], (args, ctx) => `elo_fail(${ctx.emit(args[0])})`);

src/runtime.ts

@@ -101,6 +101,26 @@ export const JS_HELPERS: Record<string, string> = {
     }
   }
   return current === undefined ? null : current;
+}`,
+  kSet: `function kSet(data, path, value) {
+  if (path.length === 0) return value;
+  const seg = path[0];
+  const rest = path.slice(1);
+  const nextDefault = rest.length === 0 ? null : typeof rest[0] === 'number' ? [] : {};
+  if (typeof seg === 'number') {
+    if (data !== null && data !== undefined && !Array.isArray(data)) throw new Error('cannot set array index on non-array');
+    const arr = Array.isArray(data) ? [...data] : [];
+    while (arr.length <= seg) arr.push(null);
+    const existing = arr[seg];
+    arr[seg] = kSet(existing === null || existing === undefined ? nextDefault : existing, rest, value);
+    return arr;
+  } else {
+    if (Array.isArray(data)) throw new Error('cannot set object key on array');
+    const obj = data !== null && data !== undefined && typeof data === 'object' ? {...data} : {};
+    const existing = obj[seg];
+    obj[seg] = kSet(existing === null || existing === undefined ? nextDefault : existing, rest, value);
+    return obj;
+  }
 }`,
   // Type selectors
   kInt: `function kInt(v) {
@@ -213,6 +233,26 @@ export const RUBY_HELPER_DEPS: Record<string, string[]> = {
 };
 
 export const RUBY_HELPERS: Record<string, string> = {
+  k_set: `def k_set(d, p, v)
+  return v if p.empty?
+  seg = p[0]
+  rest = p[1..]
+  next_default = rest.empty? ? nil : (rest[0].is_a?(Integer) ? [] : {})
+  if seg.is_a?(Integer)
+    raise 'cannot set array index on non-array' if !d.nil? && !d.is_a?(Array)
+    arr = d.is_a?(Array) ? d.dup : []
+    arr[seg] = nil while arr.length <= seg
+    existing = arr[seg]
+    arr[seg] = k_set(existing.nil? ? next_default : existing, rest, v)
+    arr
+  else
+    raise 'cannot set object key on array' if d.is_a?(Array)
+    obj = d.is_a?(Hash) ? d.dup : {}
+    existing = obj[seg]
+    obj[seg] = k_set(existing.nil? ? next_default : existing, rest, v)
+    obj
+  end
+end`,
   p_ok: `def p_ok(v, p) { success: true, path: p, message: '', value: v, cause: [] } end`,
   p_fail: `def p_fail(p, m = nil, c = nil) { success: false, path: p, message: m || '', value: nil, cause: c || [] } end`,
   p_any: `def p_any(v, p) p_ok(v, p) end`,

test/fixtures/datapath-set.elo

@@ -0,0 +1,12 @@
+assert(set({}, .name, 'Alice') == {name: 'Alice'})
+assert(set({name: 'Alice'}, .name, 'Bob') == {name: 'Bob'})
+assert(set({name: 'Alice'}, .age, 30) == {name: 'Alice', age: 30})
+assert(set({}, .user.name, 'Bob') == {user: {name: 'Bob'}})
+assert(set({}, .foo.0.bar, 12) == {foo: [{bar: 12}]})
+assert(set({items: [1, 2, 3]}, .items.1, 99) == {items: [1, 99, 3]})
+assert(set({items: [1]}, .items.3, 99) == {items: [1, null, null, 99]})
+assert(set(null, .x, 1) == {x: 1})
+assert(set({}, .a.b.c, 1) == {a: {b: {c: 1}}})
+assertFails(set([], .foo, 1))
+assertFails(set([1, 2, 3], .foo, 1))
+assertFails(set({foo: []}, .foo.bar, 1))