From 0d05ab954cc90c1afa9972367f2d4fbff10f3600 Mon Sep 17 00:00:00 2001 From: Emery Hemingway Date: Wed, 22 May 2024 05:47:39 +0200 Subject: [PATCH] Abandoned --- min_syndicate.nimble | 4 +- pkg/min_preserves.nim | 8 ++- pkg/min_syndicate.nim | 112 +++++++++++++++++++++++++++++++++++++----- 3 files changed, 109 insertions(+), 15 deletions(-) diff --git a/min_syndicate.nimble b/min_syndicate.nimble index 2d80539..209ae6b 100644 --- a/min_syndicate.nimble +++ b/min_syndicate.nimble @@ -1,9 +1,9 @@ # Package -version = "20240425" +version = "20240522" author = "Emery Hemingway" description = "Syndicate bindings for the Min language" license = "unlicense" bin = @["mindicate"] srcDir = "pkg" -requires "min >= 0.40.0", "http://git.syndicate-lang.org/ehmry/syndicate-nim.git >= 20240422" +requires "http://git.syndicate-lang.org/ehmry/syndicate-nim.git >= 20240422", "checksums", "minline >= 0.1.1 & < 0.2.0", "nimquery >= 2.0.1 & < 3.0.0", "zippy >= 0.5.6 & < 0.6.0" diff --git a/pkg/min_preserves.nim b/pkg/min_preserves.nim index 73d3b05..1fb3482 100644 --- a/pkg/min_preserves.nim +++ b/pkg/min_preserves.nim @@ -2,7 +2,7 @@ # SPDX-License-Identifier: Unlicense import - std/critbits, + std/[critbits, sequtils], min, preserves @@ -98,6 +98,12 @@ proc toPreserves*(i: In; val: MinValue): Value = of minBool: result = val.boolVal.toPreserves +proc newRecord(i: In; label: MinValue; fields: varargs[MinValue]): MinValue = + result = i.scope.newDict + result.objType = recordType + result = i.dset(result, "label", label) + result = i.dset(result, "fields", fields.toSeq.newVal) + proc preserves_module*(i: In) = let def = i.define() diff --git a/pkg/min_syndicate.nim b/pkg/min_syndicate.nim index 7051d05..b1b0c44 100644 --- a/pkg/min_syndicate.nim +++ b/pkg/min_syndicate.nim @@ -10,8 +10,14 @@ import const capType* = "syndicate-cap" dictCapType = "dict:" & capType + patternType* = "syndicate-pattern" + dictPatternType* = "dict:" & patternType -proc discardTurn(turn: var Turn) = discard +proc runForObj(q: MinValue) = + while q.obj.isNil: + syndicate.runOnce() + +proc discardTurn(turn: Turn) = discard proc newCapDict(i: In): MinValue = result = i.scope.newDict @@ -21,12 +27,50 @@ proc getCap(q: MinValue): Cap = assert q.objType == capType cast[Cap](q.obj) -proc setCap(q: MinValue; cap: Cap) = +proc set(q: MinValue; cap: Cap) = + assert q.objType == capType q.obj = addr cap[] -proc runForObj(q: MinValue) = - while q.obj.isNil: - syndicate.runOnce() +proc newDict(i: In; cap: Cap): MinValue = + result = i.newCapDict + result.set cap + +proc newDict(i: In; pat: Pattern): MinValue = + result = i.scope.newDict + result.objType = patternType + result.obj = addr pat[] + +type + MinEntity = ref object of syndicate.Entity + itr: ptr MinInterpreter + # unsafe if turns are running while the interpreter is not! + handlers: MinValue + +proc push(me: MinEntity; elems: varargs[MinValue]) = + for e in elems: me.itr[].push e + +method publish(me: MinEntity; turn: Turn; ass: AssertionRef; h: Handle) = + var + v = me.itr[].toMin ass.value + q = me.itr[].dget(me.handlers, "publish") + me.push v, h.newVal, q + +method retract(me: MinEntity; turn: Turn; h: Handle) = + var q = me.itr[].dget(me.handlers, "retract") + me.push h.newVal, q + +method message(me: MinEntity; turn: Turn; ass: AssertionRef) = + var + v = me.itr[].toMin ass.value + q = me.itr[].dget(me.handlers, "message") + me.push v, q + +method sync(me: MinEntity; turn: Turn; peer: Cap) = + var + p = me.itr[].newDict peer + q = me.itr[].dget(me.handlers, "sync") + me.push p, q + echo "MinEntity pushes sync onto stack" proc syndicate_module*(i: In) = let def = i.define() @@ -35,8 +79,8 @@ proc syndicate_module*(i: In) = let vals = i.expect("dict") dict = i.newCapDict - bootActor("dataspace") do (turn: var Turn): - dict.setCap turn.newDataspace + bootActor("dataspace") do (turn: Turn): + dict.set turn.newDataspace runForObj dict i.push dict @@ -46,7 +90,7 @@ proc syndicate_module*(i: In) = cap = vals[0].getCap pr = i.toPreserves vals[1] h = newVal 0 - cap.relay.queueTurn do (turn: var Turn): + cap.relay.queueTurn do (turn: Turn): h.intVal = publish(turn, cap, pr) while h.intVal == 0: syndicate.runOnce() @@ -57,7 +101,7 @@ proc syndicate_module*(i: In) = vals = i.expect(dictCapType, "int") cap = vals[0].getCap h = Handle vals[1].intVal - cap.relay.queueTurn do (turn: var Turn): + cap.relay.queueTurn do (turn: Turn): retract(turn, h) def.symbol("message") do (i: In): @@ -65,7 +109,7 @@ proc syndicate_module*(i: In) = var cap = vals[0].getCap pr = i.toPreserves vals[1] - cap.relay.queueTurn do (turn: var Turn): + cap.relay.queueTurn do (turn: Turn): message(turn, cap, pr) def.symbol("sync") do (i: In): @@ -73,11 +117,55 @@ proc syndicate_module*(i: In) = vals = i.expect(dictCapType) cap = vals[0].getCap var pending = true - cap.relay.queueTurn do (turn: var Turn): - sync(turn, cap) do (turn: var Turn): + cap.relay.queueTurn do (turn: Turn): + sync(turn, cap) do (turn: Turn): pending = false while pending: + echo "run a turn for sync" if not syndicate.runOnce(): raiseInvalid("failed to make sync progress") + def.symbol("to-cap") do (i: In): + let + vals = i.expect("dict") + capDict = i.newCapDict + entity = MinEntity(itr: addr i, handlers: vals[0]) + bootActor("name") do (turn: Turn): + capDict.set: + turn.newCap entity + runForObj capDict + i.push capDict + + #[ + def.symbol("pattern-discard") do (i: In): + i.push: + i.toMin Pattern(orKind: PatternKind.`discard`).toPreserves + ]# + + #[ + def.symbol("pattern-bind") do (i: In): + let vals = i.expect("'sym", "a") + var + pr = i.toPreserves vals[1] + pat = grab pr + i.push: + i.toMin pat.toPreserves + ]# + + #[ + def.symbol("pattern-any") do (i: In): + var rec = i.newRecord("_".newVal) + i.push rec + + def.symbol("pattern-bind") do (i: In): + let vals = i.expect("'sym", "a") + ]# + + #[ + def.symbol("on-message") do (i: In): + let + vals = i.expect(dictCapType, "quot") + cap = vals[0].getCap + ]# + def.finalize("syndicate")