305 lines
11 KiB
Nim
305 lines
11 KiB
Nim
# SPDX-FileCopyrightText: ☭ Emery Hemingway
|
|
# SPDX-License-Identifier: Unlicense
|
|
|
|
## https://git.syndicate-lang.org/syndicate-lang/syndicate-rkt/src/commit/90c4c60699069b496491b81ee63b5a45ffd638cb/syndicate/HOWITWORKS.md
|
|
|
|
import std/[assertions, hashes, options, sets, tables]
|
|
import preserves
|
|
import ./actors, ./bags, ./patterns
|
|
import ./protocols/dataspacePatterns
|
|
|
|
type
|
|
DCompound = dataspacePatterns.DCompound
|
|
Pattern = dataspacePatterns.Pattern
|
|
Path = seq[Value]
|
|
ClassKind = enum classNone, classRecord, classSequence, classDictionary
|
|
Class = object
|
|
kind: ClassKind
|
|
label: Value
|
|
arity: int
|
|
|
|
func classOf(v: Value): Class =
|
|
case v.kind
|
|
of pkRecord: Class(kind: classRecord, label: v.label, arity: v.arity)
|
|
of pkSequence: Class(kind: classSequence, arity: v.len)
|
|
of pkDictionary: Class(kind: classDictionary)
|
|
else: Class(kind: classNone)
|
|
|
|
proc classOf(p: Pattern): Class =
|
|
if p.orKind == PatternKind.DCompound:
|
|
case p.dcompound.orKind
|
|
of DCompoundKind.rec:
|
|
Class(kind: classRecord,
|
|
label: p.dcompound.rec.label,
|
|
arity: p.dcompound.rec.fields.len)
|
|
of DCompoundKind.arr:
|
|
Class(kind: classSequence, arity: p.dcompound.arr.items.len)
|
|
of DCompoundKind.dict:
|
|
Class(kind: classDictionary)
|
|
else:
|
|
Class(kind: classNone)
|
|
|
|
type
|
|
EventKind = enum addedEvent, removedEvent, messageEvent
|
|
|
|
AssertionCache = HashSet[Value]
|
|
|
|
ObserverGroup = ref object # Endpoints
|
|
cachedCaptures: Bag[Captures]
|
|
observers: Table[Cap, TableRef[Captures, Handle]]
|
|
|
|
Leaf = ref object
|
|
cache: AssertionCache
|
|
observerGroups: Table[Paths, ObserverGroup]
|
|
|
|
LeafMap = TableRef[seq[Value], Leaf]
|
|
|
|
Continuation = ref object
|
|
cache: AssertionCache
|
|
leafMap: Table[Paths, LeafMap]
|
|
|
|
func isEmpty(leaf: Leaf): bool =
|
|
leaf.cache.len == 0 and leaf.observerGroups.len == 0
|
|
|
|
func isEmpty(cont: Continuation): bool =
|
|
cont.cache.len == 0 and cont.leafMap.len == 0
|
|
|
|
type
|
|
ContinuationProc = proc (c: Continuation; v: Value) {.closure.}
|
|
LeafProc = proc (l: Leaf; v: Value) {.closure.}
|
|
ObserverProc = proc (turn: var Turn; group: ObserverGroup; vs: seq[Value]) {.closure.}
|
|
|
|
proc getLeaves(cont: Continuation; constPaths: Paths): LeafMap =
|
|
result = cont.leafMap.getOrDefault(constPaths)
|
|
if result.isNil:
|
|
new result
|
|
cont.leafMap[constPaths] = result
|
|
assert not cont.isEmpty
|
|
for ass in cont.cache:
|
|
let key = projectPaths(ass, constPaths)
|
|
if key.isSome:
|
|
var leaf = result.getOrDefault(get key)
|
|
if leaf.isNil:
|
|
new leaf
|
|
result[get key] = leaf
|
|
leaf.cache.incl(ass)
|
|
|
|
proc getLeaf(leafMap: LeafMap; constVals: seq[Value]): Leaf =
|
|
result = leafMap.getOrDefault(constVals)
|
|
if result.isNil:
|
|
new result
|
|
leafMap[constVals] = result
|
|
|
|
type
|
|
Selector = tuple[popCount: int; index: Value]
|
|
|
|
Node = ref object
|
|
continuation: Continuation
|
|
edges: Table[Selector, TableRef[Class, Node]]
|
|
|
|
func isEmpty(node: Node): bool =
|
|
node.continuation.isEmpty and node.edges.len == 0
|
|
|
|
type TermStack = seq[Value]
|
|
|
|
proc push(stack: TermStack; val: Value): Termstack =
|
|
result = stack
|
|
add(result, val)
|
|
|
|
proc pop(stack: TermStack; n: int): TermStack =
|
|
assert n <= stack.len
|
|
stack[stack.low..(stack.high-n)]
|
|
|
|
proc top(stack: TermStack): Value =
|
|
assert stack.len > 0
|
|
stack[stack.high]
|
|
|
|
proc modify(node: Node; turn: var Turn; outerValue: Value; event: EventKind;
|
|
modCont: ContinuationProc; modLeaf: LeafProc; modObs: ObserverProc) =
|
|
|
|
proc walk(cont: Continuation; turn: var Turn) =
|
|
modCont(cont, outerValue)
|
|
for constPaths, constValMap in cont.leafMap.pairs:
|
|
let constVals = projectPaths(outerValue, constPaths)
|
|
if constVals.isSome:
|
|
case event
|
|
of addedEvent, messageEvent:
|
|
let leaf = constValMap.getLeaf(get constVals)
|
|
modLeaf(leaf, outerValue)
|
|
for capturePaths, observerGroup in leaf.observerGroups.pairs:
|
|
let captures = projectPaths(outerValue, capturePaths)
|
|
if captures.isSome:
|
|
modObs(turn, observerGroup, get captures)
|
|
of removedEvent:
|
|
let leaf = constValMap.getOrDefault(get constVals)
|
|
if not leaf.isNil:
|
|
modLeaf(leaf, outerValue)
|
|
for capturePaths, observerGroup in leaf.observerGroups.pairs:
|
|
let captures = projectPaths(outerValue, capturePaths)
|
|
if captures.isSome:
|
|
modObs(turn, observerGroup, get captures)
|
|
if leaf.isEmpty:
|
|
constValMap.del(get constVals)
|
|
|
|
|
|
proc walk(node: Node; turn: var Turn; termStack: TermStack) =
|
|
walk(node.continuation, turn)
|
|
for selector, table in node.edges:
|
|
let
|
|
nextStack = pop(termStack, selector.popCount)
|
|
nextValue = step(nextStack.top, selector.index)
|
|
if nextValue.isSome:
|
|
let nextClass = classOf(get nextValue)
|
|
if nextClass.kind != classNone:
|
|
let nextNode = table.getOrDefault(nextClass)
|
|
if not nextNode.isNil:
|
|
walk(nextNode, turn, push(nextStack, get nextValue))
|
|
if event == removedEvent and nextNode.isEmpty:
|
|
table.del(nextClass)
|
|
|
|
walk(node, turn, @[@[outerValue].toPreserves])
|
|
|
|
proc getOrNew[A, B, C](t: var Table[A, TableRef[B, C]], k: A): TableRef[B, C] =
|
|
result = t.getOrDefault(k)
|
|
if result.isNil:
|
|
result = newTable[B, C]()
|
|
t[k] = result
|
|
|
|
iterator pairs(dc: DCompound): (Value, Pattern) =
|
|
case dc.orKind
|
|
of DCompoundKind.rec:
|
|
for i, p in dc.rec.fields:
|
|
yield (i.toPreserves, p,)
|
|
of DCompoundKind.arr:
|
|
for i, p in dc.arr.items:
|
|
yield (i.toPreserves, p,)
|
|
of DCompoundKind.dict:
|
|
for pair in dc.dict.entries.pairs:
|
|
yield pair
|
|
|
|
proc extendWalk(node: Node; popCount: Natural; stepIndex: Value; pat: Pattern; path: var Path): tuple[popCount: Natural, nextNode: Node] =
|
|
case pat.orKind
|
|
of PatternKind.DDiscard, PatternKind.DLit:
|
|
result = (popCount, node)
|
|
of PatternKind.DBind:
|
|
result = extendWalk(node, popCount, stepIndex, pat.dbind.pattern, path)
|
|
of PatternKind.DCompound:
|
|
let
|
|
selector: Selector = (popCount, stepIndex,)
|
|
table = node.edges.getOrNew(selector)
|
|
class = classOf pat
|
|
result.nextNode = table.getOrDefault(class)
|
|
if result.nextNode.isNil:
|
|
new result.nextNode
|
|
table[class] = result.nextNode
|
|
new result.nextNode.continuation
|
|
for a in node.continuation.cache:
|
|
var v = step(a, path)
|
|
if v.isSome and class == classOf(get v):
|
|
result.nextNode.continuation.cache.incl a
|
|
result.popCount = 0
|
|
for step, p in pat.dcompound.pairs:
|
|
add(path, step)
|
|
result = extendWalk(result.nextNode, result.popCount, step, p, path)
|
|
discard pop(path)
|
|
inc(result.popCount)
|
|
|
|
proc extend(node: var Node; pat: Pattern): Continuation =
|
|
var path: Path
|
|
extendWalk(node, 0, 0.toPreserves, pat, path).nextNode.continuation
|
|
|
|
type
|
|
Index* = object
|
|
allAssertions: Bag[Value]
|
|
root: Node
|
|
|
|
proc initIndex*(): Index =
|
|
Index(root: Node(continuation: Continuation()))
|
|
|
|
proc getEndpoints(leaf: Leaf; capturePaths: Paths): ObserverGroup =
|
|
result = leaf.observerGroups.getOrDefault(capturePaths)
|
|
if result.isNil:
|
|
new result
|
|
leaf.observerGroups[capturePaths] = result
|
|
for term in leaf.cache:
|
|
# leaf.cache would be empty if observers come before assertions
|
|
let captures = projectPaths(term, capturePaths)
|
|
if captures.isSome:
|
|
discard result.cachedCaptures.change(get captures, +1)
|
|
|
|
proc add*(index: var Index; turn: var Turn; pattern: Pattern; observer: Cap) =
|
|
let
|
|
cont = index.root.extend(pattern)
|
|
analysis = analyse pattern
|
|
constValMap = cont.getLeaves(analysis.constPaths)
|
|
leaf = constValMap.getLeaf(analysis.constValues)
|
|
endpoints = leaf.getEndpoints(analysis.capturePaths)
|
|
# TODO if endpoints.cachedCaptures.len > 0:
|
|
var captureMap = newTable[seq[Value], Handle]()
|
|
for capture in endpoints.cachedCaptures.items:
|
|
captureMap[capture] = publish(turn, observer, capture)
|
|
endpoints.observers[observer] = captureMap
|
|
|
|
proc remove*(index: var Index; turn: var Turn; pattern: Pattern; observer: Cap) =
|
|
let
|
|
cont = index.root.extend(pattern)
|
|
analysis = analyse pattern
|
|
constValMap = cont.leafMap.getOrDefault(analysis.constPaths)
|
|
if not constValMap.isNil:
|
|
let leaf = constValMap.getOrDefault(analysis.constValues)
|
|
if not leaf.isNil:
|
|
let endpoints = leaf.observerGroups.getOrDefault(analysis.capturePaths)
|
|
if not endpoints.isNil:
|
|
var captureMap: TableRef[seq[Value], Handle]
|
|
if endpoints.observers.pop(observer, captureMap):
|
|
for handle in captureMap.values: retract(turn, handle)
|
|
if endpoints.observers.len == 0:
|
|
leaf.observerGroups.del(analysis.capturePaths)
|
|
if leaf.observerGroups.len == 0:
|
|
constValMap.del(analysis.constValues)
|
|
if constValMap.len == 0:
|
|
cont.leafMap.del(analysis.constPaths)
|
|
|
|
proc adjustAssertion(index: var Index; turn: var Turn; outerValue: Value; delta: int): bool =
|
|
case index.allAssertions.change(outerValue, delta)
|
|
of cdAbsentToPresent:
|
|
result = true
|
|
proc modContinuation(c: Continuation; v: Value) =
|
|
c.cache.incl(v)
|
|
proc modLeaf(l: Leaf; v: Value) =
|
|
l.cache.incl(v)
|
|
proc modObserver(turn: var Turn; group: ObserverGroup; vs: seq[Value]) =
|
|
let change = group.cachedCaptures.change(vs, +1)
|
|
if change == cdAbsentToPresent:
|
|
for (observer, captureMap) in group.observers.pairs:
|
|
captureMap[vs] = publish(turn, observer, vs.toPreserves)
|
|
# TODO: this handle is coming from the facet?
|
|
modify(index.root, turn, outerValue, addedEvent, modContinuation, modLeaf, modObserver)
|
|
of cdPresentToAbsent:
|
|
result = true
|
|
proc modContinuation(c: Continuation; v: Value) =
|
|
c.cache.excl(v)
|
|
proc modLeaf(l: Leaf; v: Value) =
|
|
l.cache.excl(v)
|
|
proc modObserver(turn: var Turn; group: ObserverGroup; vs: seq[Value]) =
|
|
if group.cachedCaptures.change(vs, -1) == cdPresentToAbsent:
|
|
for (observer, captureMap) in group.observers.pairs:
|
|
var h: Handle
|
|
if captureMap.take(vs, h):
|
|
retract(observer.target, turn, h)
|
|
modify(index.root, turn, outerValue, removedEvent, modContinuation, modLeaf, modObserver)
|
|
else: discard
|
|
|
|
proc continuationNoop(c: Continuation; v: Value) = discard
|
|
proc leafNoop(l: Leaf; v: Value) = discard
|
|
|
|
proc add*(index: var Index; turn: var Turn; v: Value): bool =
|
|
adjustAssertion(index, turn, v, +1)
|
|
proc remove*(index: var Index; turn: var Turn; v: Value): bool =
|
|
adjustAssertion(index, turn, v, -1)
|
|
|
|
proc deliverMessage*(index: var Index; turn: var Turn; v: Value) =
|
|
proc observersCb(turn: var Turn; group: ObserverGroup; vs: seq[Value]) =
|
|
for observer in group.observers.keys: message(turn, observer, vs)
|
|
index.root.modify(turn, v, messageEvent, continuationNoop, leafNoop, observersCb)
|