From 79c621e979d21d44054deb84abc3f3cbf1ecaa36 Mon Sep 17 00:00:00 2001
From: Emery Hemingway <ehmry@posteo.net>
Date: Fri, 19 Jan 2024 00:04:27 +0200
Subject: [PATCH] patterns: support embedded literals

---
 src/syndicate/patterns.nim | 69 +++++++++++++++++++-------------------
 tests/test_patterns.nim    |  4 +--
 2 files changed, 36 insertions(+), 37 deletions(-)

diff --git a/src/syndicate/patterns.nim b/src/syndicate/patterns.nim
index 5feb66f..430ec75 100644
--- a/src/syndicate/patterns.nim
+++ b/src/syndicate/patterns.nim
@@ -66,43 +66,42 @@ proc grab*(pr: Value): Pattern =
       $(grab parsePreserves"""<foo "bar" #"00" [0 1 2.0] {maybe: #t} <_>>""") ==
         """<rec foo [<lit "bar"> <lit #"00"> <arr [<lit 0> <lit 1> <lit 2.0>]> <dict {maybe: <lit #t>}> <_>]>"""
 
-  if pr.embedded: drop()
-  else:
-    case pr.kind
-    of pkBoolean:
-      AnyAtom(orKind: AnyAtomKind.`bool`, bool: pr.bool).toPattern
-    of pkFloat:
-      AnyAtom(orKind: AnyAtomKind.`float`, float: pr.float).toPattern
-    of pkDouble:
-      AnyAtom(orKind: AnyAtomKind.`double`, double: pr.double).toPattern
-    of pkRegister:
-      AnyAtom(orKind: AnyAtomKind.`int`, int: pr.register).toPattern
-    of pkString:
-      AnyAtom(orKind: AnyAtomKind.`string`, string: pr.string).toPattern
-    of pkByteString:
-      AnyAtom(orKind: AnyAtomKind.`bytes`, bytes: pr.bytes).toPattern
-    of pkSymbol:
-      AnyAtom(orKind: AnyAtomKind.`symbol`, symbol: pr.symbol).toPattern
-    of pkRecord:
-      if (pr.isRecord("_") and pr.arity == 0) or (pr.isRecord("bind") and pr.arity == 1):
-        drop()
-      else:
-        DCompoundRec(
-          label: pr.label,
-          fields: map[Value, Pattern](pr.fields, grab)).toPattern
-    of pkSequence:
-      DCompoundArr(items: map(pr.sequence, grab)).toPattern
-    of pkSet:
-      raiseAssert "cannot construct a pattern over a set literal"
-    of pkDictionary:
-      var dict = DCompoundDict()
-      for key, val in pr.pairs: dict.entries[key] = grab val
-      dict.toPattern
-    of pkEmbedded:
-      # TODO: can patterns be constructed over embedded literals?
+  case pr.kind
+  of pkBoolean:
+    AnyAtom(orKind: AnyAtomKind.`bool`, bool: pr.bool).toPattern
+  of pkFloat:
+    AnyAtom(orKind: AnyAtomKind.`float`, float: pr.float).toPattern
+  of pkDouble:
+    AnyAtom(orKind: AnyAtomKind.`double`, double: pr.double).toPattern
+  of pkRegister:
+    AnyAtom(orKind: AnyAtomKind.`int`, int: pr.register).toPattern
+  of pkString:
+    AnyAtom(orKind: AnyAtomKind.`string`, string: pr.string).toPattern
+  of pkByteString:
+    AnyAtom(orKind: AnyAtomKind.`bytes`, bytes: pr.bytes).toPattern
+  of pkSymbol:
+    AnyAtom(orKind: AnyAtomKind.`symbol`, symbol: pr.symbol).toPattern
+  of pkRecord:
+    if (pr.isRecord("_") and pr.arity == 0) or (pr.isRecord("bind") and pr.arity == 1):
       drop()
     else:
-      raise newException(ValueError, "cannot generate a pattern for unhandled Value type")
+      DCompoundRec(
+        label: pr.label,
+        fields: map[Value, Pattern](pr.fields, grab)).toPattern
+  of pkSequence:
+    DCompoundArr(items: map(pr.sequence, grab)).toPattern
+  of pkSet:
+    raiseAssert "cannot construct a pattern over a set literal"
+  of pkDictionary:
+    var dict = DCompoundDict()
+    for key, val in pr.pairs: dict.entries[key] = grab val
+    dict.toPattern
+  of pkEmbedded:
+    if pr.embeddedRef.isNil: drop()
+    else:
+      AnyAtom(orKind: AnyAtomKind.`embedded`, embedded: pr.embeddedRef).toPattern
+  else:
+    raise newException(ValueError, "cannot generate a pattern for unhandled Value type")
 
 proc grab*[T](x: T): Pattern =
   ## Construct a `Pattern` from value of type `T`.
diff --git a/tests/test_patterns.nim b/tests/test_patterns.nim
index 36c0150..9a557d0 100644
--- a/tests/test_patterns.nim
+++ b/tests/test_patterns.nim
@@ -82,8 +82,8 @@ suite "protocol":
 
   test "later-than":
     let
-      obsA = parsePreserves"""<Observe <rec later-than [<lit 1704113731.419243>]> #!#f>"""
-      obsB = parsePreserves"""<Observe <rec Observe [<rec rec [<lit later-than> <arr [<rec lit [<bind <_>>]>]>]> <_>]> #!#f>"""
+      obsA = parsePreserves"""<Observe <rec later-than [<lit 1704113731.419243>]> #f>"""
+      obsB = parsePreserves"""<Observe <rec Observe [<rec rec [<lit later-than> <arr [<rec lit [<bind <_>>]>]>]> <_>]> #f>"""
       patA = """<rec later-than [<lit 1704113731.419243>]>""".parsePreserves.preservesTo(Pattern).get
       patB = """<rec Observe [<rec rec [<lit later-than> <arr [<rec lit [<bind <_>>]>]>]> <_>]>""".parsePreserves.preservesTo(Pattern).get