Named freeze scopes for serializable reactive state
Some checks failed
Build and Deploy / build-and-deploy (push) Has been cancelled
Some checks failed
Build and Deploy / build-and-deploy (push) Has been cancelled
Replace raw CEK state serialization with named freeze scopes.
A freeze scope collects signals registered within it. On freeze,
signal values are serialized to SX. On thaw, values are restored.
- freeze-scope: scoped effect delimiter for signal collection
- freeze-signal: register a signal with a name in the current scope
- cek-freeze-scope / cek-thaw-scope: freeze/thaw by scope name
- freeze-to-sx / thaw-from-sx: full SX text round-trip
- cek-freeze-all / cek-thaw-all: batch operations
Also: register boolean?, symbol?, keyword? predicates in both
Python and JS platforms with proper var aliases.
Demo: counter + name input with Freeze/Thaw buttons.
Frozen SX: {:name "demo" :signals {:count 5 :name "world"}}
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
This commit is contained in:
@@ -1034,163 +1034,98 @@
|
||||
val)))
|
||||
|
||||
|
||||
|
||||
;; --------------------------------------------------------------------------
|
||||
;; 13. CEK state serialization — freeze and resume computation
|
||||
;; 13. Freeze scopes — named serializable state boundaries
|
||||
;; --------------------------------------------------------------------------
|
||||
;;
|
||||
;; Serialize a CEK state to an s-expression. The result can be:
|
||||
;; - Printed as text (sx-serialize)
|
||||
;; - Stored, transmitted, content-addressed
|
||||
;; - Parsed back (sx-parse) and resumed (cek-run)
|
||||
;; A freeze scope collects signals registered within it. On freeze,
|
||||
;; their current values are serialized to SX. On thaw, values are
|
||||
;; restored. Multiple named scopes can coexist independently.
|
||||
;;
|
||||
;; Native functions serialize as (primitive "name") — looked up on resume.
|
||||
;; Lambdas serialize as (lambda (params) body closure-env).
|
||||
;; Environments serialize as dicts of their visible bindings.
|
||||
;; Uses the scoped effects system: scope-push!/scope-pop!/context.
|
||||
;;
|
||||
;; Usage:
|
||||
;; (freeze-scope "editor"
|
||||
;; (let ((doc (signal "hello")))
|
||||
;; (freeze-signal "doc" doc)
|
||||
;; ...))
|
||||
;;
|
||||
;; (cek-freeze-scope "editor") → {:name "editor" :signals {:doc "hello"}}
|
||||
;; (cek-thaw-scope "editor" frozen-data) → restores signal values
|
||||
|
||||
(define primitive-name :effects []
|
||||
(fn (f)
|
||||
;; For lambdas, use lambda-name. For native callables, check common names.
|
||||
(if (lambda? f)
|
||||
(lambda-name f)
|
||||
;; Native function — try common primitive names
|
||||
(let ((result nil)
|
||||
(names (list "+" "-" "*" "/" "=" "<" ">" "<=" ">=" "not" "and" "or"
|
||||
"str" "len" "first" "rest" "nth" "list" "cons" "append"
|
||||
"map" "filter" "reduce" "for-each" "some" "every?"
|
||||
"get" "keys" "dict" "dict?" "has-key?" "assoc"
|
||||
"empty?" "nil?" "number?" "string?" "list?"
|
||||
"type-of" "identity" "inc" "dec" "mod"
|
||||
"join" "split" "slice" "contains?" "starts-with?"
|
||||
"upper" "lower" "trim" "replace" "format")))
|
||||
(for-each (fn (name)
|
||||
(when (and (nil? result) (primitive? name) (identical? f (get-primitive name)))
|
||||
(set! result name)))
|
||||
names)
|
||||
result))))
|
||||
;; Registry of freeze scopes: name → list of {name signal} entries
|
||||
(define freeze-registry (dict))
|
||||
|
||||
(define cek-serialize-value :effects []
|
||||
(fn (val)
|
||||
(cond
|
||||
(nil? val) nil
|
||||
(number? val) val
|
||||
(string? val) val
|
||||
(boolean? val) val
|
||||
(symbol? val) val
|
||||
(keyword? val) val
|
||||
(list? val) (map cek-serialize-value val)
|
||||
(lambda? val) (list (make-symbol "lambda")
|
||||
(lambda-params val)
|
||||
(lambda-body val))
|
||||
(callable? val) (list (make-symbol "primitive")
|
||||
(or (primitive-name val) "?"))
|
||||
(dict? val) (cek-serialize-env val)
|
||||
:else (str val))))
|
||||
;; Register a signal in the current freeze scope
|
||||
(define freeze-signal :effects [mutation]
|
||||
(fn (name sig)
|
||||
(let ((scope-name (context "sx-freeze-scope" nil)))
|
||||
(when scope-name
|
||||
(let ((entries (or (get freeze-registry scope-name) (list))))
|
||||
(append! entries (dict "name" name "signal" sig))
|
||||
(dict-set! freeze-registry scope-name entries))))))
|
||||
|
||||
(define cek-serialize-env :effects []
|
||||
(fn (env)
|
||||
(let ((result (dict))
|
||||
(ks (keys env)))
|
||||
(for-each (fn (k)
|
||||
(dict-set! result k (cek-serialize-value (get env k))))
|
||||
ks)
|
||||
result)))
|
||||
;; Freeze scope delimiter — collects signals registered within body
|
||||
(define freeze-scope :effects [mutation]
|
||||
(fn (name body-fn)
|
||||
(scope-push! "sx-freeze-scope" name)
|
||||
;; Initialize empty entry list for this scope
|
||||
(dict-set! freeze-registry name (list))
|
||||
(cek-call body-fn nil)
|
||||
(scope-pop! "sx-freeze-scope")
|
||||
nil))
|
||||
|
||||
(define cek-serialize-frame :effects []
|
||||
(fn (frame)
|
||||
(let ((result (dict))
|
||||
(ks (keys frame)))
|
||||
(for-each (fn (k)
|
||||
(let ((v (get frame k)))
|
||||
(dict-set! result k
|
||||
(cond
|
||||
(= k "type") v
|
||||
(= k "tag") v
|
||||
(= k "f") (cek-serialize-value v)
|
||||
(= k "env") (cek-serialize-env v)
|
||||
(= k "evaled") (map cek-serialize-value v)
|
||||
(= k "remaining") v ;; unevaluated exprs stay as-is
|
||||
(= k "results") (map cek-serialize-value v)
|
||||
(= k "raw-args") v
|
||||
(= k "current-item") (cek-serialize-value v)
|
||||
(= k "name") v
|
||||
(= k "update-fn") (cek-serialize-value v)
|
||||
(= k "first-render") v
|
||||
:else (cek-serialize-value v)))))
|
||||
ks)
|
||||
result)))
|
||||
;; Freeze a named scope → SX dict of signal values
|
||||
(define cek-freeze-scope :effects []
|
||||
(fn (name)
|
||||
(let ((entries (or (get freeze-registry name) (list)))
|
||||
(signals-dict (dict)))
|
||||
(for-each (fn (entry)
|
||||
(dict-set! signals-dict
|
||||
(get entry "name")
|
||||
(signal-value (get entry "signal"))))
|
||||
entries)
|
||||
(dict "name" name "signals" signals-dict))))
|
||||
|
||||
(define cek-freeze :effects []
|
||||
(fn (state)
|
||||
(dict
|
||||
"phase" (get state "phase")
|
||||
"control" (get state "control")
|
||||
"value" (cek-serialize-value (get state "value"))
|
||||
"env" (cek-serialize-env (get state "env"))
|
||||
"kont" (map cek-serialize-frame (get state "kont")))))
|
||||
;; Freeze all scopes
|
||||
(define cek-freeze-all :effects []
|
||||
(fn ()
|
||||
(map (fn (name) (cek-freeze-scope name))
|
||||
(keys freeze-registry))))
|
||||
|
||||
;; Deserialize: reconstruct a runnable CEK state from frozen SX.
|
||||
;; Native functions are looked up by name in the current PRIMITIVES.
|
||||
;; Thaw a named scope — restore signal values from frozen data
|
||||
(define cek-thaw-scope :effects [mutation]
|
||||
(fn (name frozen)
|
||||
(let ((entries (or (get freeze-registry name) (list)))
|
||||
(values (get frozen "signals")))
|
||||
(when values
|
||||
(for-each (fn (entry)
|
||||
(let ((sig-name (get entry "name"))
|
||||
(sig (get entry "signal"))
|
||||
(val (get values sig-name)))
|
||||
(when (not (nil? val))
|
||||
(reset! sig val))))
|
||||
entries)))))
|
||||
|
||||
(define cek-thaw-value :effects []
|
||||
(fn (val)
|
||||
(cond
|
||||
(nil? val) nil
|
||||
(number? val) val
|
||||
(string? val) val
|
||||
(boolean? val) val
|
||||
(symbol? val) val
|
||||
(keyword? val) val
|
||||
;; (primitive "name") → look up native function
|
||||
(and (list? val) (not (empty? val))
|
||||
(symbol? (first val))
|
||||
(= (symbol-name (first val)) "primitive"))
|
||||
(get-primitive (nth val 1))
|
||||
;; (lambda (params) body) → reconstruct Lambda
|
||||
(and (list? val) (not (empty? val))
|
||||
(symbol? (first val))
|
||||
(= (symbol-name (first val)) "lambda"))
|
||||
(make-lambda (nth val 1) (nth val 2) (dict))
|
||||
(list? val) (map cek-thaw-value val)
|
||||
(dict? val) (cek-thaw-env val)
|
||||
:else val)))
|
||||
;; Thaw all scopes from a list of frozen scope dicts
|
||||
(define cek-thaw-all :effects [mutation]
|
||||
(fn (frozen-list)
|
||||
(for-each (fn (frozen)
|
||||
(cek-thaw-scope (get frozen "name") frozen))
|
||||
frozen-list)))
|
||||
|
||||
(define cek-thaw-env :effects []
|
||||
(fn (frozen-env)
|
||||
(let ((result (make-env)))
|
||||
(for-each (fn (k)
|
||||
(env-set! result k (cek-thaw-value (get frozen-env k))))
|
||||
(keys frozen-env))
|
||||
result)))
|
||||
;; Serialize a frozen scope to SX text
|
||||
(define freeze-to-sx :effects []
|
||||
(fn (name)
|
||||
(sx-serialize (cek-freeze-scope name))))
|
||||
|
||||
;; Restore from SX text
|
||||
(define thaw-from-sx :effects [mutation]
|
||||
(fn (sx-text)
|
||||
(let ((parsed (sx-parse sx-text)))
|
||||
(when (not (empty? parsed))
|
||||
(let ((frozen (first parsed)))
|
||||
(cek-thaw-scope (get frozen "name") frozen))))))
|
||||
|
||||
(define cek-thaw-frame :effects []
|
||||
(fn (frozen-frame)
|
||||
(let ((result (dict))
|
||||
(ks (keys frozen-frame)))
|
||||
(for-each (fn (k)
|
||||
(let ((v (get frozen-frame k)))
|
||||
(dict-set! result k
|
||||
(cond
|
||||
(= k "type") v
|
||||
(= k "tag") v
|
||||
(= k "f") (cek-thaw-value v)
|
||||
(= k "env") (cek-thaw-env v)
|
||||
(= k "evaled") (map cek-thaw-value v)
|
||||
(= k "remaining") v
|
||||
(= k "results") (map cek-thaw-value v)
|
||||
(= k "raw-args") v
|
||||
(= k "current-item") (cek-thaw-value v)
|
||||
(= k "name") v
|
||||
(= k "update-fn") (cek-thaw-value v)
|
||||
(= k "first-render") v
|
||||
:else (cek-thaw-value v)))))
|
||||
ks)
|
||||
result)))
|
||||
|
||||
(define cek-thaw :effects []
|
||||
(fn (frozen)
|
||||
(dict
|
||||
"phase" (get frozen "phase")
|
||||
"control" (get frozen "control")
|
||||
"value" (cek-thaw-value (get frozen "value"))
|
||||
"env" (cek-thaw-env (get frozen "env"))
|
||||
"kont" (map cek-thaw-frame (get frozen "kont")))))
|
||||
|
||||
Reference in New Issue
Block a user