From ce8e800187b3c42c7e887e15014eac1e5633ab58 Mon Sep 17 00:00:00 2001 From: Emery Hemingway Date: Mon, 24 Jul 2023 16:13:36 +0100 Subject: [PATCH] Rename Ref to Cap --- src/syndicate.nim | 14 ++--- src/syndicate/actors.nim | 84 +++++++++++++------------- src/syndicate/actors/timers.nim | 6 +- src/syndicate/capabilities.nim | 6 +- src/syndicate/dataspaces.nim | 10 ++-- src/syndicate/durings.nim | 6 +- src/syndicate/membranes.nim | 24 ++++---- src/syndicate/patterns.nim | 42 ++++++------- src/syndicate/relays.nim | 102 ++++++++++++++++---------------- src/syndicate/skeletons.nim | 23 ++++--- tests/test_chat.nim | 14 ++--- tests/test_patterns.nim | 16 ++--- tests/test_timers.nim | 2 +- 13 files changed, 175 insertions(+), 174 deletions(-) diff --git a/src/syndicate.nim b/src/syndicate.nim index 3095e48..92f73e7 100644 --- a/src/syndicate.nim +++ b/src/syndicate.nim @@ -17,7 +17,7 @@ when defined(posix): export patterns -export Actor, Assertion, Facet, Handle, Ref, Symbol, Turn, TurnAction, +export Actor, Assertion, Facet, Handle, Cap, Ref, Symbol, Turn, TurnAction, `$`, addCallback, analyse, asyncCheck, bootDataspace, facet, future, inFacet, message, newDataspace, onStop, publish, retract, replace, run, spawn, stop, unembed, unpackLiterals @@ -38,7 +38,7 @@ proc `?`*[T](val: T): Pattern {.inline.} = patterns.grab[T](val) type - Observe* = dataspace.Observe[Ref] + Observe* = dataspace.Observe[Cap] PublishProc = proc (turn: var Turn; v: Assertion; h: Handle) {.closure, gcsafe.} RetractProc = proc (turn: var Turn; h: Handle) {.closure, gcsafe.} MessageProc = proc (turn: var Turn; v: Assertion) {.closure, gcsafe.} @@ -136,7 +136,7 @@ proc wrapDuringHandler(turn, entryBody, exitBody: NimNode): NimNode = `exitBody` result = action -macro onPublish*(turn: untyped; ds: Ref; pattern: Pattern; handler: untyped) = +macro onPublish*(turn: untyped; ds: Cap; pattern: Pattern; handler: untyped) = ## Call `handler` when an assertion matching `pattern` is published at `ds`. let argCount = argumentCount(handler) @@ -148,7 +148,7 @@ macro onPublish*(turn: untyped; ds: Ref; pattern: Pattern; handler: untyped) = `handlerProc` discard observe(`turn`, `ds`, `pattern`, ClosureEntity(publishImpl: `handlerSym`)) -macro onMessage*(turn: untyped; ds: Ref; pattern: Pattern; handler: untyped) = +macro onMessage*(turn: untyped; ds: Cap; pattern: Pattern; handler: untyped) = ## Call `handler` when an message matching `pattern` is broadcasted at `ds`. let argCount = argumentCount(handler) @@ -160,7 +160,7 @@ macro onMessage*(turn: untyped; ds: Ref; pattern: Pattern; handler: untyped) = `handlerProc` discard observe(`turn`, `ds`, `pattern`, ClosureEntity(messageImpl: `handlerSym`)) -macro during*(turn: untyped; ds: Ref; pattern: Pattern; publishBody, retractBody: untyped) = +macro during*(turn: untyped; ds: Cap; pattern: Pattern; publishBody, retractBody: untyped) = ## Call `publishBody` when an assertion matching `pattern` is published to `ds` and ## call `retractBody` on retraction. Assertions that match `pattern` but are not ## convertable to the arguments of `publishBody` are silently discarded. @@ -178,7 +178,7 @@ macro during*(turn: untyped; ds: Ref; pattern: Pattern; publishBody, retractBody `callbackProc` discard observe(`turn`, `ds`, `pattern`, during(`callbackSym`)) -macro during*(turn: untyped; ds: Ref; pattern: Pattern; publishBody: untyped) = +macro during*(turn: untyped; ds: Cap; pattern: Pattern; publishBody: untyped) = ## Variant of `during` without a retract body. let argCount = argumentCount(publishBody) @@ -190,7 +190,7 @@ macro during*(turn: untyped; ds: Ref; pattern: Pattern; publishBody: untyped) = `callbackProc` discard observe(`turn`, `ds`, `pattern`, during(`callbackSym`)) -type BootProc = proc (ds: Ref; turn: var Turn) {.gcsafe.} +type BootProc = proc (ds: Cap; turn: var Turn) {.gcsafe.} proc runActor*(name: string; bootProc: BootProc) = ## Run an `Actor` to completion. diff --git a/src/syndicate/actors.nim b/src/syndicate/actors.nim index 7eb547a..d2bd59d 100644 --- a/src/syndicate/actors.nim +++ b/src/syndicate/actors.nim @@ -27,27 +27,29 @@ generateIdType(TurnId) type Oid = sturdy.Oid - Assertion* = Preserve[Ref] - Caveat = sturdy.Caveat[Ref] + Assertion* = Preserve[Cap] + Caveat = sturdy.Caveat[Cap] Attenuation = seq[Caveat] - Rewrite = sturdy.Rewrite[Ref] + Rewrite = sturdy.Rewrite[Cap] AssertionRef* = ref object - value*: Preserve[Ref] - # if the Enity methods take a Preserve[Ref] object then the generated + value*: Preserve[Cap] + # if the Enity methods take a Preserve[Cap] object then the generated # C code has "redefinition of struct" problems when orc is enabled Entity* = ref object of RootObj oid*: Oid # oid is how Entities are identified over the wire - Ref* {.unpreservable.} = ref object # TODO: rename + Cap* {.unpreservable.} = ref object relay*: Facet target*: Entity attenuation*: Attenuation + Ref* {.deprecated: "Ref was renamed to Cap".} = Cap + OutboundAssertion = ref object handle: Handle - peer: Ref + peer: Cap established: bool OutboundTable = Table[Handle, OutboundAssertion] @@ -111,7 +113,7 @@ when tracing: method publish*(e: Entity; turn: var Turn; v: AssertionRef; h: Handle) {.base, gcsafe.} = discard method retract*(e: Entity; turn: var Turn; h: Handle) {.base, gcsafe.} = discard method message*(e: Entity; turn: var Turn; v: AssertionRef) {.base, gcsafe.} = discard -method sync*(e: Entity; turn: var Turn; peer: Ref) {.base, gcsafe.} = discard +method sync*(e: Entity; turn: var Turn; peer: Cap) {.base, gcsafe.} = discard using actor: Actor @@ -133,15 +135,15 @@ proc labels(f: Facet): string = proc `$`*(f: Facet): string = "" -proc `$`*(r: Ref): string = +proc `$`*(r: Cap): string = "" proc `$`*(actor: Actor): string = "" # TODO: ambigous -proc attenuate(r: Ref; a: Attenuation): Ref = +proc attenuate(r: Cap; a: Attenuation): Cap = if a.len == 0: result = r - else: result = Ref( + else: result = Cap( relay: r.relay, target: r.target, attenuation: a & r.attenuation) @@ -149,7 +151,7 @@ proc attenuate(r: Ref; a: Attenuation): Ref = proc hash*(facet): Hash = facet.id.hash -proc hash*(r: Ref): Hash = !$(r.relay.hash !& r.target.unsafeAddr.hash) +proc hash*(r: Cap): Hash = !$(r.relay.hash !& r.target.unsafeAddr.hash) proc nextHandle(facet: Facet): Handle = result = succ(facet.actor.handleAllocator[]) @@ -163,7 +165,7 @@ proc enqueue(turn: var Turn; target: Facet; action: TurnAction) = else: turn.queues[target] = @[action] -type Bindings = Table[Preserve[Ref], Preserve[Ref]] +type Bindings = Table[Preserve[Cap], Preserve[Cap]] proc match(bindings: var Bindings; p: Pattern; v: Assertion): bool = case p.orKind @@ -181,7 +183,7 @@ proc match(bindings: var Bindings; p: Pattern; v: Assertion): bool = result = v.isEmbedded of PatternKind.Pbind: if match(bindings, p.pbind.pattern, v): - bindings[toPreserve(p.pbind.pattern, Ref)] = v + bindings[toPreserve(p.pbind.pattern, Cap)] = v result = true of PatternKind.Pand: for pp in p.pand.patterns: @@ -233,7 +235,7 @@ proc instantiate(t: Template; bindings: Bindings): Assertion = result = embed(attenuate(v.embed, t.tattenuate.attenuation)) of TemplateKind.TRef: let n = $t.tref.binding.int - try: result = bindings[toPreserve(n, Ref)] + try: result = bindings[toPreserve(n, Cap)] except KeyError: raise newException(ValueError, "unbound reference: " & n) of TemplateKind.Lit: @@ -245,11 +247,11 @@ proc instantiate(t: Template; bindings: Bindings): Assertion = for i, tt in t.tcompound.rec.fields: result[i] = instantiate(tt, bindings) of TCompoundKind.arr: - result = initSequence(t.tcompound.arr.items.len, Ref) + result = initSequence(t.tcompound.arr.items.len, Cap) for i, tt in t.tcompound.arr.items: result[i] = instantiate(tt, bindings) of TCompoundKind.dict: - result = initDictionary(Ref) + result = initDictionary(Cap) for key, tt in t.tcompound.dict.entries: result[key] = instantiate(tt, bindings) @@ -275,7 +277,7 @@ proc runRewrites*(a: Attenuation; v: Assertion): Assertion = result = examineAlternatives(stage, result) if result.isFalse: break -proc publish(turn: var Turn; r: Ref; v: Assertion; h: Handle) = +proc publish(turn: var Turn; r: Cap; v: Assertion; h: Handle) = var a = runRewrites(r.attenuation, v) if not a.isFalse: let e = OutboundAssertion( @@ -291,18 +293,18 @@ proc publish(turn: var Turn; r: Ref; v: Assertion; h: Handle) = act.enqueue.event.target.oid = r.target.oid.toPreserve act.enqueue.event.detail = trace.TurnEvent[void](orKind: TurnEventKind.assert) act.enqueue.event.detail.assert.assertion.value.value = - contract(v) do (r: Ref) -> Preserve[void]: + contract(v) do (r: Cap) -> Preserve[void]: discard act.enqueue.event.detail.assert.handle = h turn.desc.actions.add act -proc publish*(turn: var Turn; r: Ref; a: Assertion): Handle = +proc publish*(turn: var Turn; r: Cap; a: Assertion): Handle = result = turn.facet.nextHandle() publish(turn, r, a, result) -proc publish*[T](turn: var Turn; r: Ref; a: T): Handle = - publish(turn, r, toPreserve(a, Ref)) +proc publish*[T](turn: var Turn; r: Cap; a: T): Handle = + publish(turn, r, toPreserve(a, Cap)) proc retract(turn: var Turn; e: OutboundAssertion) = enqueue(turn, e.peer.relay) do (turn: var Turn): @@ -315,31 +317,31 @@ proc retract*(turn: var Turn; h: Handle) = if turn.facet.outbound.pop(h, e): turn.retract(e) -proc message*(turn: var Turn; r: Ref; v: Assertion) = +proc message*(turn: var Turn; r: Cap; v: Assertion) = var a = runRewrites(r.attenuation, v) if not a.isFalse: enqueue(turn, r.relay) do (turn: var Turn): r.target.message(turn, AssertionRef(value: a)) -proc message*[T](turn: var Turn; r: Ref; v: T) = - message(turn, r, toPreserve(v, Ref)) +proc message*[T](turn: var Turn; r: Cap; v: T) = + message(turn, r, toPreserve(v, Cap)) -proc sync(turn: var Turn; e: Entity; peer: Ref) = +proc sync(turn: var Turn; e: Entity; peer: Cap) = e.sync(turn, peer) # or turn.message(peer, true) ? -proc sync*(turn: var Turn; r, peer: Ref) = +proc sync*(turn: var Turn; r, peer: Cap) = enqueue(turn, r.relay) do (turn: var Turn): sync(turn, r.target, peer) -proc replace*[T](turn: var Turn; `ref`: Ref; h: Handle; v: T): Handle = - result = publish(turn, `ref`, v) +proc replace*[T](turn: var Turn; cap: Cap; h: Handle; v: T): Handle = + result = publish(turn, cap, v) if h != default(Handle): retract(turn, h) -proc replace*[T](turn: var Turn; `ref`: Ref; h: var Handle; v: T): Handle {.discardable.} = +proc replace*[T](turn: var Turn; cap: Cap; h: var Handle; v: T): Handle {.discardable.} = var old = h - h = publish(turn, `ref`, v) + h = publish(turn, cap, v) if old != default(Handle): retract(turn, old) h @@ -475,9 +477,9 @@ proc spawn*(name: string; turn: var Turn; bootProc: TurnAction; initialAssertion run(actor, bootProc, newOutBound) actor -proc newInertRef*(): Ref = +proc newInertCap*(): Cap = let a = bootActor("inert") do (turn: var Turn): turn.stop() - Ref(relay: a.root) + Cap(relay: a.root) proc atExit*(actor; action) = actor.exitHooks.add action @@ -532,9 +534,9 @@ proc run*(facet; action: TurnAction; zombieTurn = false) = for facet, queue in queues: for action in queue: run(facet, action) -proc run*(`ref`: Ref; action: TurnAction) = - ## Convenience proc to run a `TurnAction` in the scope of a `Ref`. - run(`ref`.relay, action) +proc run*(cap: Cap; action: TurnAction) = + ## Convenience proc to run a `TurnAction` in the scope of a `Cap`. + run(cap.relay, action) proc addCallback*(fut: FutureBase; facet: Facet; act: TurnAction) = ## Add a callback to a `Future` that will be called at a later `Turn` @@ -592,13 +594,13 @@ proc freshen*(turn: var Turn, act: TurnAction) = assert(turn.queues.len == 0, "Attempt to freshen a non-stale Turn") run(turn.facet, act) -proc newRef*(relay: Facet; e: Entity): Ref = - Ref(relay: relay, target: e) +proc newCap*(relay: Facet; e: Entity): Cap = + Cap(relay: relay, target: e) -proc newRef*(turn; e: Entity): Ref = - Ref(relay: turn.facet, target: e) +proc newCap*(turn; e: Entity): Cap = + Cap(relay: turn.facet, target: e) -proc sync*(turn, refer: Ref, cb: proc(t: Turn) {.gcsafe.}) = +proc sync*(turn, refer: Cap, cb: proc(t: Turn) {.gcsafe.}) = raiseAssert "not implemented" proc future*(actor): Future[void] = actor.future diff --git a/src/syndicate/actors/timers.nim b/src/syndicate/actors/timers.nim index 5d61bf1..324e273 100644 --- a/src/syndicate/actors/timers.nim +++ b/src/syndicate/actors/timers.nim @@ -10,11 +10,11 @@ from syndicate/protocols/dataspace import Observe export timer -type Observe = dataspace.Observe[Ref] +type Observe = dataspace.Observe[Cap] proc now: float64 = getTime().toUnixFloat() -proc spawnTimers*(turn: var Turn; ds: Ref): Actor {.discardable.} = +proc spawnTimers*(turn: var Turn; ds: Cap): Actor {.discardable.} = ## Spawn a timer actor. spawn("timer", turn) do (turn: var Turn): @@ -28,7 +28,7 @@ proc spawnTimers*(turn: var Turn; ds: Ref): Actor {.discardable.} = run(facet) do (turn: var Turn): discard publish(turn, ds, LaterThan(seconds: seconds)) -template after*(turn: var Turn; ds: Ref; dur: Duration; act: untyped) = +template after*(turn: var Turn; ds: Cap; dur: Duration; act: untyped) = ## Execute `act` after some duration of time. let later = now() + dur.inMilliseconds.float64 * 1_000.0 onPublish(turn, ds, ?LaterThan(seconds: later), act) diff --git a/src/syndicate/capabilities.nim b/src/syndicate/capabilities.nim index f0a8227..7418ec7 100644 --- a/src/syndicate/capabilities.nim +++ b/src/syndicate/capabilities.nim @@ -12,7 +12,7 @@ import hashlib/misc/blake2 import preserves import ./protocols/sturdy -from ./actors import Ref +from ./actors import Cap export `$` @@ -26,9 +26,9 @@ proc mint*[T](key: openarray[byte]; oid: Preserve[T]): SturdyRef[T] = }.toDictionary, ) -proc mint*(): SturdyRef[Ref] = +proc mint*(): SturdyRef[Cap] = var key: array[16, byte] - mint(key, toPreserve("syndicate", Ref)) + mint(key, toPreserve("syndicate", Cap)) proc attenuate*[T](r: SturdyRef[T]; caveats: seq[Caveat]): SturdyRef[T] = result = SturdyRef[T]( diff --git a/src/syndicate/dataspaces.nim b/src/syndicate/dataspaces.nim index 8bc1768..43fab06 100644 --- a/src/syndicate/dataspaces.nim +++ b/src/syndicate/dataspaces.nim @@ -8,8 +8,8 @@ import ./actors, ./protocols/dataspace, ./skeletons from ./protocols/protocol import Handle type - Assertion = Preserve[Ref] - Observe = dataspace.Observe[Ref] + Assertion = Preserve[Cap] + Observe = dataspace.Observe[Cap] Turn = actors.Turn Dataspace {.final.} = ref object of Entity @@ -34,10 +34,10 @@ method retract(ds: Dataspace; turn: var Turn; h: Handle) {.gcsafe.} = method message(ds: Dataspace; turn: var Turn; a: AssertionRef) {.gcsafe.} = ds.index.deliverMessage(turn, a.value) -proc newDataspace*(turn: var Turn): Ref = - newRef(turn, Dataspace(index: initIndex())) +proc newDataspace*(turn: var Turn): Cap = + newCap(turn, Dataspace(index: initIndex())) -type BootProc = proc (ds: Ref; turn: var Turn) {.gcsafe.} +type BootProc = proc (ds: Cap; turn: var Turn) {.gcsafe.} proc bootDataspace*(name: string; bootProc: BootProc): Actor = bootActor(name) do (turn: var Turn): diff --git a/src/syndicate/durings.nim b/src/syndicate/durings.nim index 1d51bcd..1222f92 100644 --- a/src/syndicate/durings.nim +++ b/src/syndicate/durings.nim @@ -8,7 +8,7 @@ import ./actors, ./patterns, ./protocols/dataspace from ./protocols/protocol import Handle type - Observe = dataspace.Observe[Ref] + Observe = dataspace.Observe[Cap] Turn = actors.Turn type @@ -50,5 +50,5 @@ method retract(de: DuringEntity; turn: var Turn; h: Handle) = proc during*(cb: DuringProc): DuringEntity = DuringEntity(cb: cb) -proc observe*(turn: var Turn; ds: Ref; pat: Pattern; e: Entity): Handle = - publish(turn, ds, Observe(pattern: pat, observer: newRef(turn, e))) +proc observe*(turn: var Turn; ds: Cap; pat: Pattern; e: Entity): Handle = + publish(turn, ds, Observe(pattern: pat, observer: newCap(turn, e))) diff --git a/src/syndicate/membranes.nim b/src/syndicate/membranes.nim index bb0675d..aa76ef2 100644 --- a/src/syndicate/membranes.nim +++ b/src/syndicate/membranes.nim @@ -3,43 +3,43 @@ import std/[hashes, tables] -from ./actors import Ref, hash +from ./actors import Cap, hash from ./protocols/sturdy import Oid -proc hash(r: Ref): Hash = !$(r.relay.hash !& r.target.unsafeAddr.hash) +proc hash(r: Cap): Hash = !$(r.relay.hash !& r.target.unsafeAddr.hash) type Membrane* = object - ## Bidirectional mapping between `Oid` and `Ref` values. + ## Bidirectional mapping between `Oid` and `Cap` values. ## https://synit.org/book/protocol.html#membranes byOid: Table[Oid, WireSymbol] - byRef: Table[Ref, WireSymbol] + byCap: Table[Cap, WireSymbol] WireSymbol* = ref object oid: Oid - `ref`: Ref + cap: Cap count: int proc oid*(sym: WireSymbol): Oid = sym.oid -proc `ref`*(sym: WireSymbol): Ref = sym.ref +proc cap*(sym: WireSymbol): Cap = sym.cap proc grab*(mem: Membrane; key: Oid): WireSymbol = ## Grab a `WireSymbol` from a `Membrane`. mem.byOid.getOrDefault(key) -proc grab*(mem: Membrane; key: Ref): WireSymbol = +proc grab*(mem: Membrane; key: Cap): WireSymbol = ## Grab a `WireSymbol` from a `Membrane`. - mem.byRef.getOrDefault(key) + mem.byCap.getOrDefault(key) proc drop*(mem: var Membrane; sym: WireSymbol) = ## Drop a `WireSymbol` from a `Membrane`. dec sym.count if sym.count < 1: mem.byOid.del sym.oid - mem.byRef.del sym.`ref` + mem.byCap.del sym.cap -proc newWireSymbol*(mem: var Membrane; o: Oid; r: Ref): WireSymbol = +proc newWireSymbol*(mem: var Membrane; o: Oid; r: Cap): WireSymbol = ## Allocate a `WireSymbol` at a `Membrane`. - result = WireSymbol(oid: o, `ref`: r, count: 1) + result = WireSymbol(oid: o, cap: r, count: 1) mem.byOid[result.oid] = result - mem.byRef[result.`ref`] = result + mem.byCap[result.cap] = result diff --git a/src/syndicate/patterns.nim b/src/syndicate/patterns.nim index abd88ed..9459e5b 100644 --- a/src/syndicate/patterns.nim +++ b/src/syndicate/patterns.nim @@ -5,20 +5,20 @@ import std/[algorithm, options, sequtils, tables, typetraits] import preserves import ./protocols/dataspacePatterns -from ./actors import Ref +from ./actors import Cap export dataspacePatterns.`$`, PatternKind, DCompoundKind, AnyAtomKind type - Value = Preserve[Ref] - AnyAtom = dataspacePatterns.AnyAtom[Ref] - DBind = dataspacePatterns.DBind[Ref] - DCompound = dataspacePatterns.DCompound[Ref] - DCompoundArr = dataspacePatterns.DCompoundArr[Ref] - DCompoundDict = dataspacePatterns.DCompoundDict[Ref] - DCompoundRec = dataspacePatterns.DCompoundRec[Ref] - DLit = dataspacePatterns.DLit[Ref] - Pattern* = dataspacePatterns.Pattern[Ref] + Value = Preserve[Cap] + AnyAtom = dataspacePatterns.AnyAtom[Cap] + DBind = dataspacePatterns.DBind[Cap] + DCompound = dataspacePatterns.DCompound[Cap] + DCompoundArr = dataspacePatterns.DCompoundArr[Cap] + DCompoundDict = dataspacePatterns.DCompoundDict[Cap] + DCompoundRec = dataspacePatterns.DCompoundRec[Cap] + DLit = dataspacePatterns.DLit[Cap] + Pattern* = dataspacePatterns.Pattern[Cap] iterator orderedEntries*(dict: DCompoundDict): (Value, Pattern) = ## Iterate a `DCompoundDict` in Preserves order. @@ -88,7 +88,7 @@ proc grab*[T](pr: Preserve[T]): Pattern = drop() else: DCompoundRec( - label: cast[Preserve[Ref]](pr.label), # TODO: don't cast like this + label: cast[Preserve[Cap]](pr.label), # TODO: don't cast like this fields: map[Preserve[T], Pattern](pr.fields, grab)).toPattern of pkSequence: DCompoundArr(items: map(pr.sequence, grab)).toPattern @@ -96,7 +96,7 @@ proc grab*[T](pr: Preserve[T]): Pattern = raiseAssert "cannot construct a pattern over a set literal" of pkDictionary: var dict = DCompoundDict() - for key, val in pr.pairs: dict.entries[cast[Preserve[Ref]](key)] = grab val + for key, val in pr.pairs: dict.entries[cast[Preserve[Cap]](key)] = grab val dict.toPattern of pkEmbedded: # TODO: can patterns be constructed over embedded literals? @@ -110,20 +110,20 @@ proc grab*[T](val: T): Pattern = $grab(true) == "" $grab(3.14) == "" $grab([0, 1, 2, 3]) == " ]>" - grab (toPreserve(val, Ref)) + grab (toPreserve(val, Cap)) proc patternOfType(typ: static typedesc; `bind`: static bool): Pattern = when typ is ref: patternOfType(pointerBase(typ), `bind`) elif typ.hasPreservesRecordPragma: - var rec = DCompoundRec(label: typ.recordLabel.tosymbol(Ref)) + var rec = DCompoundRec(label: typ.recordLabel.tosymbol(Cap)) for _, f in fieldPairs(default typ): add(rec.fields, patternOfType(typeof f, `bind`)) result = rec.toPattern elif typ.hasPreservesDictionaryPragma: var dict = DCompoundDict() for key, val in fieldPairs(default typ): - dict.entries[toSymbol(key, Ref)] = patternOfType(typeof val, `bind`) + dict.entries[toSymbol(key, Cap)] = patternOfType(typeof val, `bind`) dict.toPattern elif typ is tuple: var arr = DCompoundArr() @@ -191,7 +191,7 @@ proc grab*(typ: static typedesc; bindings: sink openArray[(int, Pattern)]): Patt when typ is ref: grab(pointerBase(typ), bindings) elif typ.hasPreservesRecordPragma: - var rec = DCompoundRec(label: typ.recordLabel.tosymbol(Ref)) + var rec = DCompoundRec(label: typ.recordLabel.tosymbol(Cap)) rec.fields.setLen(fieldCount typ) var i: int for _, f in fieldPairs(default typ): @@ -269,7 +269,7 @@ proc inject*(pat: Pattern; bindings: openArray[(int, Pattern)]): Pattern = var offset = 0 inject(pat, bindings, offset) -proc inject*(pat: Pattern; bindings: openArray[(Preserve[Ref], Pattern)]): Pattern = +proc inject*(pat: Pattern; bindings: openArray[(Preserve[Cap], Pattern)]): Pattern = ## Inject `bindings` into a dictionary pattern. assert pat.orKind == PatternKind.DCompound assert pat.dcompound.orKind == DCompoundKind.dict @@ -277,12 +277,12 @@ proc inject*(pat: Pattern; bindings: openArray[(Preserve[Ref], Pattern)]): Patte for (key, val) in bindings: result.dcompound.dict.entries[key] = val -proc recordPattern*(label: Preserve[Ref], fields: varargs[Pattern]): Pattern = +proc recordPattern*(label: Preserve[Cap], fields: varargs[Pattern]): Pattern = runnableExamples: from std/unittest import check import syndicate/actors, preserves check: - $recordPattern("Says".toSymbol(Ref), grab(), grab()) == + $recordPattern("Says".toSymbol(Cap), grab(), grab()) == """> >]>""" DCompoundRec(label: label, fields: fields.toSeq).toPattern @@ -298,7 +298,7 @@ type func walk(result: var Analysis; path: var Path; p: Pattern) func walk(result: var Analysis; path: var Path; key: int|Value; pat: Pattern) = - path.add(key.toPreserve(Ref)) + path.add(key.toPreserve(Cap)) walk(result, path, pat) discard path.pop @@ -318,7 +318,7 @@ func walk(result: var Analysis; path: var Path; p: Pattern) = of PatternKind.DDiscard: discard of PatternKind.DLit: result.constPaths.add(path) - result.constValues.add(p.dlit.value.toPreserve(Ref)) + result.constValues.add(p.dlit.value.toPreserve(Cap)) func analyse*(p: Pattern): Analysis = var path: Path diff --git a/src/syndicate/relays.nim b/src/syndicate/relays.nim index b3d8d46..14a5d1d 100644 --- a/src/syndicate/relays.nim +++ b/src/syndicate/relays.nim @@ -19,7 +19,7 @@ type Oid = sturdy.Oid type Value = Preserve[void] - Assertion = Preserve[Ref] + Assertion = Preserve[Cap] WireRef = sturdy.WireRef[void] Turn = actors.Turn @@ -42,7 +42,7 @@ type SyncPeerEntity = ref object of Entity relay: Relay - peer: Ref + peer: Cap handleMap: Table[Handle, Handle] e: WireSymbol @@ -51,7 +51,7 @@ type label: string relay: Relay -proc releaseRefOut(r: Relay; e: WireSymbol) = +proc releaseCapOut(r: Relay; e: WireSymbol) = r.exported.drop e method publish(spe: SyncPeerEntity; t: var Turn; a: AssertionRef; h: Handle) = @@ -64,22 +64,22 @@ method retract(se: SyncPeerEntity; t: var Turn; h: Handle) = method message(se: SyncPeerEntity; t: var Turn; a: AssertionRef) = if not se.e.isNil: - se.relay.releaseRefOut(se.e) + se.relay.releaseCapOut(se.e) message(t, se.peer, a.value) -method sync(se: SyncPeerEntity; t: var Turn; peer: Ref) = +method sync(se: SyncPeerEntity; t: var Turn; peer: Cap) = sync(t, se.peer, peer) -proc newSyncPeerEntity(r: Relay; p: Ref): SyncPeerEntity = +proc newSyncPeerEntity(r: Relay; p: Cap): SyncPeerEntity = SyncPeerEntity(relay: r, peer: p) -proc rewriteRefOut(relay: Relay; `ref`: Ref; exported: var seq[WireSymbol]): WireRef = - if `ref`.target of RelayEntity and `ref`.target.RelayEntity.relay == relay and `ref`.attenuation.len == 0: - WireRef(orKind: WireRefKind.yours, yours: WireRefYours[void](oid: `ref`.target.oid)) +proc rewriteCapOut(relay: Relay; cap: Cap; exported: var seq[WireSymbol]): WireRef = + if cap.target of RelayEntity and cap.target.RelayEntity.relay == relay and cap.attenuation.len == 0: + WireRef(orKind: WireRefKind.yours, yours: WireRefYours[void](oid: cap.target.oid)) else: - var ws = grab(relay.exported, `ref`) + var ws = grab(relay.exported, cap) if ws.isNil: - ws = newWireSymbol(relay.exported, relay.nextLocalOid, `ref`) + ws = newWireSymbol(relay.exported, relay.nextLocalOid, cap) inc relay.nextLocalOid exported.add ws WireRef( @@ -89,8 +89,8 @@ proc rewriteRefOut(relay: Relay; `ref`: Ref; exported: var seq[WireSymbol]): Wir proc rewriteOut(relay: Relay; v: Assertion): tuple[rewritten: Value, exported: seq[WireSymbol]] {.gcsafe.} = var exported: seq[WireSymbol] - result.rewritten = contract(v) do (r: Ref) -> Value: - rewriteRefOut(relay, r, exported).toPreserve + result.rewritten = contract(v) do (r: Cap) -> Value: + rewriteCapOut(relay, r, exported).toPreserve result.exported = exported proc register(relay: Relay; v: Assertion; h: Handle): tuple[rewritten: Value, exported: seq[WireSymbol]] = @@ -100,7 +100,7 @@ proc register(relay: Relay; v: Assertion; h: Handle): tuple[rewritten: Value, ex proc deregister(relay: Relay; h: Handle) = var outbound: seq[WireSymbol] if relay.outboundAssertions.pop(h, outbound): - for e in outbound: releaseRefOut(relay, e) + for e in outbound: releaseCapOut(relay, e) proc send(r: Relay; pkt: sink Packet): Future[void] = assert(not r.packetWriter.isNil, "missing packetWriter proc") @@ -141,11 +141,11 @@ method message(re: RelayEntity; turn: var Turn; msg: AssertionRef) {.gcsafe.} = if len(exported) == 0: re.send Event(orKind: EventKind.Message, message: Message(body: value)) -method sync(re: RelayEntity; turn: var Turn; peer: Ref) {.gcsafe.} = +method sync(re: RelayEntity; turn: var Turn; peer: Cap) {.gcsafe.} = var peerEntity = newSyncPeerEntity(re.relay, peer) exported: seq[WireSymbol] - discard rewriteRefOut(re.relay, turn.newRef(peerEntity), exported) + discard rewriteCapOut(re.relay, turn.newCap(peerEntity), exported) # TODO: discard? peerEntity.e = exported[0] re.send Event(orKind: EventKind.Sync) @@ -157,24 +157,24 @@ using relay: Relay facet: Facet -proc lookupLocal(relay; oid: Oid): Ref = +proc lookupLocal(relay; oid: Oid): Cap = let sym = relay.exported.grab oid - if sym.isNil: newInertRef() - else: sym.`ref` + if sym.isNil: newInertCap() + else: sym.cap -proc isInert(r: Ref): bool = +proc isInert(r: Cap): bool = r.target.isNil -proc rewriteRefIn(relay; facet; n: WireRef, imported: var seq[WireSymbol]): Ref = +proc rewriteCapIn(relay; facet; n: WireRef, imported: var seq[WireSymbol]): Cap = case n.orKind of WireRefKind.mine: var e = relay.imported.grab(n.mine.oid) if e.isNil: e = newWireSymbol( relay.imported, n.mine.oid, - newRef(facet, newRelayEntity("rewriteRefIn", relay, n.mine.oid))) + newCap(facet, newRelayEntity("rewriteCapIn", relay, n.mine.oid))) imported.add e - result = e.`ref` + result = e.cap of WireRefKind.yours: let r = relay.lookupLocal(n.yours.oid) if n.yours.attenuation.len == 0 or r.isInert: result = r @@ -187,16 +187,16 @@ proc rewriteIn(relay; facet; v: Value): var wr: WireRef if not fromPreserve(wr, pr): raiseAssert "expansion of embedded value failed" - rewriteRefIn(relay, facet, wr, imported).toPreserve(Ref) + rewriteCapIn(relay, facet, wr, imported).toPreserve(Cap) result.imported = imported proc close(r: Relay) = discard -proc dispatch*(relay: Relay; turn: var Turn; `ref`: Ref; event: Event) {.gcsafe.} = +proc dispatch*(relay: Relay; turn: var Turn; cap: Cap; event: Event) {.gcsafe.} = case event.orKind of EventKind.Assert: let (a, imported) = rewriteIn(relay, turn.facet, event.assert.assertion) - relay.inboundAssertions[event.assert.handle] = (publish(turn, `ref`, a), imported,) + relay.inboundAssertions[event.assert.handle] = (publish(turn, cap, a), imported,) of EventKind.Retract: let remoteHandle = event.retract.handle @@ -208,14 +208,14 @@ proc dispatch*(relay: Relay; turn: var Turn; `ref`: Ref; event: Event) {.gcsafe. of EventKind.Message: let (a, imported) = rewriteIn(relay, turn.facet, event.message.body) assert imported.len == 0, "Cannot receive transient reference" - turn.message(`ref`, a) + turn.message(cap, a) of EventKind.Sync: discard # TODO #[ var imported: seq[WireSymbol] - let k = relay.rewriteRefIn(turn, evenr.sync.peer, imported) - turn.sync(`ref`) do (turn: var Turn): + let k = relay.rewriteCapIn(turn, evenr.sync.peer, imported) + turn.sync(cap) do (turn: var Turn): turn.message(k, true) for e in imported: relay.imported.del e ]# @@ -233,7 +233,7 @@ proc dispatch*(relay: Relay; v: Value) {.gcsafe.} = if not r.isInert: dispatch(relay, t, r, te.event) else: - stderr.writeLine("discarding event for unknown Ref; ", te.event) + stderr.writeLine("discarding event for unknown Cap; ", te.event) of PacketKind.Error: # https://synit.org/book/protocol.html#error-packets when defined(posix): @@ -252,7 +252,7 @@ type untrusted*: bool RelayActorOptions* = object of RelayOptions initialOid*: Option[Oid] - initialRef*: Ref + initialCap*: Cap nextLocalOid*: Option[Oid] proc newRelay(turn: var Turn; opts: RelayOptions; setup: RelaySetup): Relay = @@ -263,19 +263,19 @@ proc newRelay(turn: var Turn; opts: RelayOptions; setup: RelaySetup): Relay = discard result.facet.preventInertCheck() setup(turn, result) -proc spawnRelay*(name: string; turn: var Turn; opts: RelayActorOptions; setup: RelaySetup): Future[Ref] = - var fut = newFuture[Ref]"spawnRelay" +proc spawnRelay*(name: string; turn: var Turn; opts: RelayActorOptions; setup: RelaySetup): Future[Cap] = + var fut = newFuture[Cap]"spawnRelay" discard spawn(name, turn) do (turn: var Turn): let relay = newRelay(turn, opts, setup) - if not opts.initialRef.isNil: + if not opts.initialCap.isNil: var exported: seq[WireSymbol] - discard rewriteRefOut(relay, opts.initialRef, exported) + discard rewriteCapOut(relay, opts.initialCap, exported) if opts.initialOid.isSome: var imported: seq[WireSymbol] var wr = WireRef( orKind: WireRefKind.mine, mine: WireRefMine(oid: opts.initialOid.get)) - fut.complete rewriteRefIn(relay, turn.facet, wr, imported) + fut.complete rewriteCapIn(relay, turn.facet, wr, imported) else: fut.complete(nil) opts.nextLocalOid.map do (oid: Oid): @@ -295,23 +295,23 @@ type ShutdownEntity* = ref object of Entity method retract(e: ShutdownEntity; turn: var Turn; h: Handle) = stopActor(turn) -type ConnectProc* = proc (turn: var Turn; ds: Ref) {.gcsafe.} +type ConnectProc* = proc (turn: var Turn; ds: Cap) {.gcsafe.} export Tcp when defined(posix): export Unix - proc connect*(turn: var Turn; socket: AsyncSocket; step: Preserve[Ref]; bootProc: ConnectProc) = + proc connect*(turn: var Turn; socket: AsyncSocket; step: Preserve[Cap]; bootProc: ConnectProc) = ## Relay a dataspace over an open `AsyncSocket`. ## *`bootProc` may be called multiple times for multiple remote gatekeepers.* proc socketWriter(packet: sink Packet): Future[void] = socket.send(cast[string](encode(packet))) const recvSize = 0x2000 - var shutdownRef: Ref + var shutdownCap: Cap let reenable = turn.facet.preventInertCheck() - connectionClosedRef = newRef(turn, ShutdownEntity()) + connectionClosedCap = newCap(turn, ShutdownEntity()) fut = newFuture[void]"connect" discard bootActor("socket") do (turn: var Turn): var ops = RelayActorOptions( @@ -336,18 +336,18 @@ when defined(posix): socket.recv(recvSize).addCallback(recvCb) socket.recv(recvSize).addCallback(recvCb) turn.facet.actor.atExit do (turn: var Turn): close(socket) - discard publish(turn, connectionClosedRef, true) - shutdownRef = newRef(turn, ShutdownEntity()) + discard publish(turn, connectionClosedCap, true) + shutdownCap = newCap(turn, ShutdownEntity()) addCallback(refFut) do (): let gatekeeper = read refFut run(gatekeeper.relay) do (turn: var Turn): reenable() - discard publish(turn, shutdownRef, true) + discard publish(turn, shutdownCap, true) proc duringCallback(turn: var Turn; a: Assertion; h: Handle): TurnAction = let facet = inFacet(turn) do (turn: var Turn): var - accepted: ResolvedAccepted[Ref] - rejected: Rejected[Ref] + accepted: ResolvedAccepted[Cap] + rejected: Rejected[Cap] if fromPreserve(accepted, a): bootProc(turn, accepted.responderSession) elif fromPreserve(rejected, a): @@ -357,14 +357,14 @@ when defined(posix): proc action(turn: var Turn) = stop(turn, facet) result = action - discard publish(turn, gatekeeper, Resolve[Ref]( + discard publish(turn, gatekeeper, Resolve[Cap]( step: step, - observer: newRef(turn, during(duringCallback)), + observer: newCap(turn, during(duringCallback)), )) fut.complete() asyncCheck(turn, fut) - proc connect*(turn: var Turn; transport: Tcp; step: Preserve[Ref]; bootProc: ConnectProc) = + proc connect*(turn: var Turn; transport: Tcp; step: Preserve[Cap]; bootProc: ConnectProc) = ## Relay a dataspace over TCP. ## *`bootProc` may be called multiple times for multiple remote gatekeepers.* let socket = newAsyncSocket( @@ -376,7 +376,7 @@ when defined(posix): addCallback(fut, turn) do (turn: var Turn): connect(turn, socket, step, bootProc) - proc connect*(turn: var Turn; transport: Unix; step: Preserve[Ref]; bootProc: ConnectProc) = + proc connect*(turn: var Turn; transport: Unix; step: Preserve[Cap]; bootProc: ConnectProc) = ## Relay a dataspace over a UNIX socket. ## *`bootProc` may be called multiple times for multiple remote gatekeepers.* let socket = newAsyncSocket( @@ -392,7 +392,7 @@ when defined(posix): const stdinReadSize = 128 - proc connectStdio*(ds: Ref; turn: var Turn) = + proc connectStdio*(ds: Cap; turn: var Turn) = ## Connect to an external dataspace over stdin and stdout. proc stdoutWriter(packet: sink Packet): Future[void] {.async.} = var buf = encode(packet) @@ -400,7 +400,7 @@ when defined(posix): flushFile(stdout) var opts = RelayActorOptions( packetWriter: stdoutWriter, - initialRef: ds, + initialCap: ds, initialOid: 0.Oid.some) asyncCheck spawnRelay("stdio", turn, opts) do (turn: var Turn; relay: Relay): let diff --git a/src/syndicate/skeletons.nim b/src/syndicate/skeletons.nim index f9e841e..e6b9e4d 100644 --- a/src/syndicate/skeletons.nim +++ b/src/syndicate/skeletons.nim @@ -9,9 +9,9 @@ import ./actors, ./bags, ./patterns import ./protocols/dataspacePatterns type - DCompound = dataspacePatterns.DCompound[Ref] - Pattern = dataspacePatterns.Pattern[Ref] - Value = Preserve[Ref] + DCompound = dataspacePatterns.DCompound[Cap] + Pattern = dataspacePatterns.Pattern[Cap] + Value = Preserve[Cap] Path = seq[Value] ClassKind = enum classNone, classRecord, classSequence, classDictionary Class = object @@ -61,7 +61,7 @@ type ObserverGroup = ref object # Endpoints cachedCaptures: Bag[Captures] - observers: Table[Ref, TableRef[Captures, Handle]] + observers: Table[Cap, TableRef[Captures, Handle]] Leaf = ref object cache: AssertionCache @@ -140,7 +140,6 @@ proc modify(node: Node; turn: var Turn; outerValue: Value; event: EventKind; proc walk(cont: Continuation; turn: var Turn) = modCont(cont, outerValue) - assert not cont.isEmpty() for constPaths, constValMap in cont.leafMap.pairs: let constVals = projectPaths(outerValue, constPaths) if constVals.isSome: @@ -180,7 +179,7 @@ proc modify(node: Node; turn: var Turn; outerValue: Value; event: EventKind; if event == removedEvent and nextNode.isEmpty: table.del(nextClass) - walk(node, turn, @[@[outerValue].toPreserve(Ref)]) + walk(node, turn, @[@[outerValue].toPreserve(Cap)]) proc getOrNew[A, B, C](t: var Table[A, TableRef[B, C]], k: A): TableRef[B, C] = result = t.getOrDefault(k) @@ -192,10 +191,10 @@ iterator pairs(dc: DCompound): (Value, Pattern) = case dc.orKind of DCompoundKind.rec: for i, p in dc.rec.fields: - yield (toPreserve(i, Ref), p,) + yield (toPreserve(i, Cap), p,) of DCompoundKind.arr: for i, p in dc.arr.items: - yield (toPreserve(i, Ref), p,) + yield (toPreserve(i, Cap), p,) of DCompoundKind.dict: for pair in dc.dict.entries.pairs: yield pair @@ -229,7 +228,7 @@ proc extendWalk(node: Node; popCount: Natural; stepIndex: Value; pat: Pattern; p proc extend(node: var Node; pat: Pattern): Continuation = var path: Path - extendWalk(node, 0, toPreserve(0, Ref), pat, path).nextNode.continuation + extendWalk(node, 0, toPreserve(0, Cap), pat, path).nextNode.continuation type Index* = object @@ -250,7 +249,7 @@ proc getEndpoints(leaf: Leaf; capturePaths: Paths): ObserverGroup = if captures.isSome: discard result.cachedCaptures.change(get captures, +1) -proc add*(index: var Index; turn: var Turn; pattern: Pattern; observer: Ref) = +proc add*(index: var Index; turn: var Turn; pattern: Pattern; observer: Cap) = let cont = index.root.extend(pattern) analysis = analyse pattern @@ -263,7 +262,7 @@ proc add*(index: var Index; turn: var Turn; pattern: Pattern; observer: Ref) = captureMap[capture] = publish(turn, observer, capture) endpoints.observers[observer] = captureMap -proc remove*(index: var Index; turn: var Turn; pattern: Pattern; observer: Ref) = +proc remove*(index: var Index; turn: var Turn; pattern: Pattern; observer: Cap) = let cont = index.root.extend(pattern) analysis = analyse pattern @@ -295,7 +294,7 @@ proc adjustAssertion(index: var Index; turn: var Turn; outerValue: Value; delta: let change = group.cachedCaptures.change(vs, +1) if change == cdAbsentToPresent: for (observer, captureMap) in group.observers.pairs: - captureMap[vs] = publish(turn, observer, vs.toPreserve(Ref)) + captureMap[vs] = publish(turn, observer, vs.toPreserve(Cap)) # TODO: this handle is coming from the facet? modify(index.root, turn, outerValue, addedEvent, modContinuation, modLeaf, modObserver) of cdPresentToAbsent: diff --git a/tests/test_chat.nim b/tests/test_chat.nim index 63f9e6e..da3e963 100644 --- a/tests/test_chat.nim +++ b/tests/test_chat.nim @@ -10,7 +10,7 @@ type Says {.preservesRecord: "Says".} = object who, what: string -proc readStdin(facet: Facet; ds: Ref; username: string) = +proc readStdin(facet: Facet; ds: Cap; username: string) = let file = openAsync("/dev/stdin") onStop(facet) do (turn: var Turn): close(file) close(stdin) @@ -22,7 +22,7 @@ proc readStdin(facet: Facet; ds: Ref; username: string) = readLine() readLine() -proc chat(turn: var Turn; ds: Ref; username: string) = +proc chat(turn: var Turn; ds: Cap; username: string) = during(turn, ds, ?Present) do (who: string): echo who, " joined" do: @@ -37,7 +37,7 @@ proc chat(turn: var Turn; ds: Ref; username: string) = proc main = var transport: Preserve[void] - cap: Preserve[Ref] + cap: Preserve[Cap] username = getEnv("USER") calledWithArguments = false for kind, key, val in getopt(): @@ -47,20 +47,20 @@ proc main = of "address", "transport": transport = parsePreserves(val) of "cap", "sturdy": - cap = parsePreserves(val, Ref) + cap = parsePreserves(val, Cap) of "user", "username": username = val if calledWithArguments: - runActor("chat") do (root: Ref; turn: var Turn): + runActor("chat") do (root: Cap; turn: var Turn): var unixAddr: transportAddress.Unix tcpAddr: transportAddress.Tcp if fromPreserve(unixAddr, transport): - connect(turn, unixAddr, cap) do (turn: var Turn; ds: Ref): + connect(turn, unixAddr, cap) do (turn: var Turn; ds: Cap): chat(turn, ds, username) elif fromPreserve(tcpAddr, transport): - connect(turn, tcpAddr, cap) do (turn: var Turn; ds: Ref): + connect(turn, tcpAddr, cap) do (turn: var Turn; ds: Cap): chat(turn, ds, username) main() diff --git a/tests/test_patterns.nim b/tests/test_patterns.nim index cc4bafe..f56d38a 100644 --- a/tests/test_patterns.nim +++ b/tests/test_patterns.nim @@ -5,7 +5,7 @@ import std/unittest import preserves, syndicate from syndicate/protocols/dataspace import Observe -type Observe = dataspace.Observe[Ref] +type Observe = dataspace.Observe[Cap] import ./test_schema @@ -16,9 +16,9 @@ test "patterns": let value = @["alles", "in", "ordnung"] - observer = toPreserve(Observe(pattern: inject(?Foo, { 0: ?value })), Ref) - have = capture(observerPat, observer).toPreserve(Ref).unpackLiterals - want = [value.toPreserve(Ref)].toPreserve(Ref) + observer = toPreserve(Observe(pattern: inject(?Foo, { 0: ?value })), Cap) + have = capture(observerPat, observer).toPreserve(Cap).unpackLiterals + want = [value.toPreserve(Cap)].toPreserve(Cap) check(have == want) type Record {.preservesDictionary.} = object @@ -27,10 +27,10 @@ type Record {.preservesDictionary.} = object test "dictionaries": let pat = ?Record echo pat - var source = initDictionary(Ref) - source["b".toSymbol(Ref)] = 2.toPreserve(Ref) - source["c".toSymbol(Ref)] = 3.toPreserve(Ref) - source["a".toSymbol(Ref)] = 1.toPreserve(Ref) + var source = initDictionary(Cap) + source["b".toSymbol(Cap)] = 2.toPreserve(Cap) + source["c".toSymbol(Cap)] = 3.toPreserve(Cap) + source["a".toSymbol(Cap)] = 1.toPreserve(Cap) let values = capture(pat, source) check $values == "@[1, 2, 3]" diff --git a/tests/test_timers.nim b/tests/test_timers.nim index d6d1216..6003f17 100644 --- a/tests/test_timers.nim +++ b/tests/test_timers.nim @@ -6,7 +6,7 @@ import syndicate, syndicate/actors/timers proc now: float64 = getTime().toUnixFloat() -runActor("test_timers") do (ds: Ref; turn: var Turn): +runActor("test_timers") do (ds: Cap; turn: var Turn): onPublish(turn, ds, ?LaterThan(seconds: now()+1.0)) do: stderr.writeLine "slept one second once" onPublish(turn, ds, ?LaterThan(seconds: now()+1.0)) do: