Change behavior of grabType

Make grabType grab a single composite value that can be converted
to the type being grabbed instead of just the fields of the type.

The old behavior is available in grabTypeFlat and the alias `?:`
still points there.

src/syndicate.nim

@@ -22,7 +22,7 @@ proc `?`*[T](val: T): Pattern {.inline.} =
   patterns.drop[T](val)
 
 proc `?:`*(typ: static typedesc): Pattern {.inline.} =
-  patterns.grabType(typ)
+  patterns.grabTypeFlat(typ)
 
 proc `?:`*(typ: static typedesc; bindings: sink openArray[(int, Pattern)]): Pattern {.inline.} =
   patterns.grab(typ, bindings)

src/syndicate/patterns.nim

@@ -109,7 +109,7 @@ proc grab*[T](x: T): Pattern {.
     deprecated: "use drop unless you wish to capture the provided value".} =
   PatternBind(pattern: drop x).toPattern
 
-proc grabType*(typ: static typedesc): Pattern =
+proc grabTypeFlat*(typ: static typedesc): Pattern =
   ## Derive a `Pattern` from type `typ`.
   ## This works for `tuple` and `object` types but in the
   ## general case will return a wildcard binding.
@@ -117,36 +117,36 @@ proc grabType*(typ: static typedesc): Pattern =
     import preserves
     from std/unittest import check
     check:
-      $grabType(array[3, int]) ==
+      $grabTypeFlat(array[3, int]) ==
         """<group <arr> {0: <bind <_>> 1: <bind <_>> 2: <bind <_>> 3: <bind <_>>}>"""
     type
       Point = tuple[x: int; y: int]
       Rect {.preservesRecord: "rect".} = tuple[a: Point; B: Point]
       ColoredRect {.preservesDictionary.} = tuple[color: string; rect: Rect]
     check:
-      $(grabType Point) ==
+      $(grabTypeFlat Point) ==
         "<group <arr> {0: <bind <_>> 1: <bind <_>>}>"
-      $(grabType Rect) ==
+      $(grabTypeFlat Rect) ==
         "<group <rec rect> {0: <group <arr> {0: <bind <_>> 1: <bind <_>>}> 1: <group <arr> {0: <bind <_>> 1: <bind <_>>}>}>"
-      $(grabType ColoredRect) ==
+      $(grabTypeFlat ColoredRect) ==
         "<group <dict> {color: <bind <_>> rect: <group <rec rect> {0: <group <arr> {0: <bind <_>> 1: <bind <_>>}> 1: <group <arr> {0: <bind <_>> 1: <bind <_>>}>}>}>"
   when typ is ref:
-    grabType(pointerBase(typ))
+    grabTypeFlat(pointerBase(typ))
   elif typ.hasPreservesRecordPragma:
     var group = PatternGroup(`type`: GroupType(orKind: GroupTypeKind.`rec`))
     group.`type`.rec.label = typ.recordLabel.toSymbol
     for _, f in fieldPairs(default typ):
-      group.entries[group.entries.len.toPreserves] = grabType(typeof f)
+      group.entries[group.entries.len.toPreserves] = grabTypeFlat(typeof f)
     group.toPattern
   elif typ.hasPreservesDictionaryPragma:
     var group = PatternGroup(`type`: GroupType(orKind: GroupTypeKind.`dict`))
     for key, val in fieldPairs(default typ):
-      group.entries[key.toSymbol] = grabType(typeof val)
+      group.entries[key.toSymbol] = grabTypeFlat(typeof val)
     group.toPattern
   elif typ is tuple:
     var group = PatternGroup(`type`: GroupType(orKind: GroupTypeKind.`arr`))
     for _, f in fieldPairs(default typ):
-      group.entries[group.entries.len.toPreserves] = grabType(typeof f)
+      group.entries[group.entries.len.toPreserves] = grabTypeFlat(typeof f)
     group.toPattern
   elif typ is array:
     var group = PatternGroup(`type`: GroupType(orKind: GroupTypeKind.`arr`))
@@ -180,6 +180,9 @@ proc dropType*(typ: static typedesc): Pattern =
   else:
     drop()
 
+proc grabType*(typ: static typedesc): Pattern =
+  PatternBind(pattern: typ.dropType).toPattern
+
 proc bindEntries(group: var PatternGroup; bindings: openArray[(int, Pattern)]) =
   ## Set `bindings` for a `group`.
   for (i, pat) in bindings: group.entries[toPreserves i] = pat
@@ -214,10 +217,10 @@ proc grabLit*(): Pattern =
     from std/unittest import check
     check:
       $grabLit() == """<group <rec lit> {0: <bind <_>>}>"""
-  grabType(dataspacePatterns.PatternLit)
+  grabTypeFlat(dataspacePatterns.PatternLit)
 
 proc grabDict*(): Pattern =
-  grabType(dataspacePatterns.GroupTypeDict)
+  grabTypeFlat(dataspacePatterns.GroupTypeDict)
 
 proc unpackLiterals*(pr: Value): Value =
   result = pr
@@ -321,7 +324,7 @@ proc depattern*(pat: Pattern; values: sink seq[Value]): Value =
     import preserves
     type Foo {.preservesRecord: "foo".} = object
       a, b: int
-    let pat = grabType Foo
+    let pat = grabTypeFlat Foo
     let val = depattern(pat, @[1.toPreserves, 5.toPreserves])
     check $val == "<foo 1 5>"
   var index: int

src/syndicate/relays.nim

@@ -324,10 +324,12 @@ when defined(posix):
     while entity.alive:
       buf[].setLen(0x1000)
       let n = read(entity.stdin, buf)
-      if n == 0:
-        stopActor(entity.facet)
-      else:
+      if n > 0:
         entity.relay.recv(buf[], 0..<n)
+      else:
+        entity.alive = false
+        if n < 0: raiseOSError(osLastError())
+    stopActor(entity.facet)
 
   proc connectTransport(turn: Turn; ds: Cap; ta: transportAddress.Stdio) =
     ## Connect to an external dataspace over stdio.
@@ -405,11 +407,12 @@ when defined(posix):
     while entity.alive:
       buf[].setLen(0x1000)
       let n = read(entity.sock, buf)
-      if n < 0: raiseOSError(osLastError())
-      elif n == 0:
-        stopActor(entity.facet)
-      else:
+      if n > 0:
         entity.relay.recv(buf[], 0..<n)
+      else:
+        entity.alive = false
+        if n < 0: raiseOSError(osLastError())
+    stopActor(entity.facet)
     # the socket closes when the actor is stopped
 
   proc boot(entity: TcpEntity; ta: transportAddress.Tcp; ds: Cap) {.asyncio.} =
@@ -422,8 +425,9 @@ when defined(posix):
 
   template spawnSocketRelay() {.dirty.} =
     proc writeConn(turn: Turn; buf: seq[byte]) =
-      discard trampoline:
-        whelp write(entity.sock, buf)
+      if entity.alive:
+        discard trampoline:
+          whelp write(entity.sock, buf)
     var ops = RelayActorOptions(
         packetWriter: writeConn,
         initialOid: 0.Oid.some,
@@ -548,7 +552,9 @@ proc connectRoute(turn: Turn; ds: Cap; route: Route; transOff: int) =
       2: ?:ResolvedAccepted,
     }
   onPublish(turn, ds, acceptPat) do (origin: Cap):
-    walk(turn, ds, origin, route, transOff, 0)
+    origin.relay.run do (turn: Turn):
+      # walk using the facet that manages the transport connection
+      walk(turn, ds, origin, route, transOff, 0)
 
 type StepCallback = proc (turn: Turn; step: Value; origin: Cap; res: Resolved) {.closure.}
 

syndicate.nimble

@@ -1,6 +1,6 @@
 # Package
 
-version = "20240430"
+version = "20240507"
 author        = "Emery Hemingway"
 description   = "Syndicated actors for conversational concurrency"
 license       = "Unlicense"