Use new dataspace patterns

src/mount_actor.nim

@@ -7,7 +7,7 @@ when not defined(linux):
   {.error: "this component only tested for Linux".}
 
 import std/oserrors
-import preserves
+import preserves, preserves/sugar
 import syndicate
 import ./schema/mountpoints
 
@@ -23,8 +23,11 @@ proc umount(target: cstring): cint {.importc, header: "<sys/mount.h>".}
 proc spawnMountActor*(turn: var Turn; ds: Cap): Actor {.discardable.} =
   spawnActor(turn, "mount_actor") do (turn: var Turn):
     let
-      targetPat = ?Observe(pattern: !Mountpoint) ?? { 1: grabLit() }
-      sourcePat = ?Observe(pattern: !Mountpoint) ?? { 0: grabLit(), 2: grabLit() }
+      targetPat = observePattern(!Mountpoint, { @[%1]: grabLit() })
+      sourcePat = observePattern(!Mountpoint, {
+          @[%0]: grabLit(),
+          @[%2]: grabLit(),
+        })
     during(turn, ds, ?:BootArgs) do (ds: Cap):
       during(turn, ds, targetPat) do (target: string):
         during(turn, ds, sourcePat) do (source: string, fsType: string):

src/syndesizer/base64_decoder.nim

@@ -3,7 +3,7 @@
 
 import std/[base64, os]
 import pkg/hashlib/misc/blake2
-import preserves, syndicate
+import preserves, preserves/sugar, syndicate
 import ../schema/config
 import ../schema/base64 as schema
 
@@ -15,21 +15,21 @@ proc spawnBase64Decoder*(turn: var Turn; root: Cap): Actor {.discardable.} =
     let tmpDir = getTempDir()
     during(turn, root, ?:Base64DecoderArguments) do (ds: Cap):
 
-      let decTextPat = ?Observe(pattern: !Base64Text) ?? { 0: grabLit() }
+      let decTextPat = observePattern(!Base64Text, { @[%0]: grabLit() })
       during(turn, ds, decTextPat) do (txt: string):
         discard publish(turn, ds, Base64Text(
             txt: txt,
             bin: cast[seq[byte]](decode(txt)),
           ))
 
-      let encTextPat = ?Observe(pattern: !Base64Text) ?? { 1: grabLit() }
+      let encTextPat = observePattern(!Base64Text, { @[%1]: grabLit() })
       during(turn, ds, encTextPat) do (bin: seq[byte]):
         discard publish(turn, ds, Base64Text(
             txt: encode(bin),
             bin: bin,
           ))
 
-      let decFilePat = ?Observe(pattern: !Base64File) ?? { 0: grabLit() }
+      let decFilePat = observePattern( !Base64File, { @[%0]: grabLit() })
       during(turn, ds, decFilePat) do (txt: string):
         var bin = decode(txt)
         var ctx = init[BLAKE2B_512]()

src/syndesizer/cache_actor.nim

@@ -30,9 +30,9 @@ method publish(cache: CacheEntity; turn: var Turn; ass: AssertionRef; h: Handle)
       stop(turn) # end this facet
 
 proc isObserve(pat: Pattern): bool =
-  pat.orKind == PatternKind.DCompound and
-    pat.dcompound.orKind == DCompoundKind.rec and
-      pat.dcompound.rec.label.isSymbol"Observe"
+  pat.orKind == PatternKind.group and
+    pat.group.type.orKind == GroupTypeKind.rec and
+      pat.group.type.rec.label.isSymbol"Observe"
 
 proc spawnCacheActor*(turn: var Turn; root: Cap): Actor =
   spawnActor(turn, "cache_actor") do (turn: var Turn):

src/syndesizer/file_system_usage.nim

@@ -2,7 +2,7 @@
 # SPDX-License-Identifier: Unlicense
 
 import std/[dirs, os, paths]
-import preserves
+import preserves, preserves/sugar
 import syndicate
 
 import ../schema/[assertions, config]
@@ -10,7 +10,7 @@ import ../schema/[assertions, config]
 proc spawnFileSystemUsageActor*(turn: var Turn; root: Cap): Actor {.discardable.} =
   spawn("file-system-usage", turn) do (turn: var Turn):
     during(turn, root, ?:FileSystemUsageArguments) do (ds: Cap):
-      var pat = ?Observe(pattern: !FileSystemUsage) ?? { 0: grab() }
+      let pat = observePattern(!FileSystemUsage, { @[%0]: grab() })
       during(turn, ds, pat) do (lit: Literal[string]):
         var ass = FileSystemUsage(path: lit.value)
         if fileExists(ass.path): ass.size = getFileSize(ass.path)

src/syndesizer/pulses.nim

@@ -2,7 +2,8 @@
 # SPDX-License-Identifier: Unlicense
 
 import std/[options, tables, times]
-import preserves, syndicate, syndicate/drivers/timers
+import preserves, preserves/sugar
+import syndicate, syndicate/drivers/timers
 
 import ../schema/[assertions, config]
 
@@ -87,7 +88,7 @@ proc spawnPulseActor*(turn: var Turn; root: Cap): Actor =
   ## Spawn an actor that retracts and re-asserts observers on
   ## a timed pulse. Requires a timer service on the `root` capability.
   spawnActor(turn, "pulse") do (turn: var Turn):
-    let grabPeriod = ?Observe(pattern: !Pulse) ?? { 0: grab() }
+    let grabPeriod = observePattern(!Pulse, { @[%0]: grab() })
     during(turn, root, ?:PulseArguments) do (ds: Cap):
       during(turn, ds, grabPeriod) do (lit: Literal[float]):
         if lit.value < 0.000_1:

src/syndesizer/xml_translator.nim

@@ -2,7 +2,7 @@
 # SPDX-License-Identifier: Unlicense
 
 import std/[options, parsexml, xmlparser, xmltree]
-import preserves, preserves/xmlhooks
+import preserves, preserves/sugar, preserves/xmlhooks
 import syndicate
 
 import ../schema/[assertions, config]
@@ -20,10 +20,11 @@ proc translatePreserves(pr: Value): XmlTranslation {.gcsafe.} =
 proc spawnXmlTranslator*(turn: var Turn; root: Cap): Actor {.discardable.} =
   spawnActor(turn, "xml-translator") do (turn: var Turn):
     during(turn, root, ?:XmlTranslatorArguments) do (ds: Cap):
-      let obsPat = ?Observe(pattern: !XmlTranslation)
-      during(turn, ds, obsPat ?? {0: grab()}) do (xs: Literal[string]):
+      let xmlPat = observePattern(!XmlTranslation, {@[%0]:grab()})
+      during(turn, ds, xmlPat) do (xs: Literal[string]):
         publish(turn, ds, translateXml(xs.value))
-      during(turn, ds, obsPat ?? {1: grab()}) do (pr: Literal[Value]):
+      let prPat = observePattern(!XmlTranslation, {@[%1]:grab()})
+      during(turn, ds, prPat) do (pr: Literal[Value]):
         publish(turn, ds, translatePreserves(pr.value))
 
 when isMainModule:

src/xslt_actor.nim

@@ -2,7 +2,7 @@
 # SPDX-License-Identifier: Unlicense
 
 import std/[os, strutils]
-import preserves, syndicate
+import preserves, preserves/sugar, syndicate
 import ./schema/[assertions, config]
 
 {.passC: staticExec("pkg-config --cflags libxslt").}
@@ -177,7 +177,7 @@ proc spawnXsltActor*(turn: var Turn; root: Cap): Actor {.discardable.} =
   spawnActor(turn, "xslt") do (turn: var Turn):
     initLibXml()
     during(turn, root, ?:XsltArguments) do (ds: Cap):
-      let sheetsPat = ?Observe(pattern: !XsltTransform) ?? {0: grab(), 1: grab()}
+      let sheetsPat = observePattern(!XsltTransform, {@[%0]: grab(), @[%1]: grab()})
       during(turn, ds, sheetsPat) do (stylesheet: Literal[string], input: Literal[string]):
         let cur = loadStylesheet(stylesheet.value)
         if cur.isNil:

syndicate_utils.nimble

@@ -1,6 +1,6 @@
 # Package
 
-version = "20240408"
+version = "20240422"
 author        = "Emery Hemingway"
 description   = "Utilites for Syndicated Actors and Synit"
 license       = "unlicense"