syndicate-nim/src/syndicate/protocols/sturdy.nim

import
  std/typetraits, preserves, std/tables, std/tables

type
  PCompoundKind* {.pure.} = enum
    `rec`, `arr`, `dict`
  PCompoundRec*[Cap] {.preservesRecord: "rec".} = ref object
    `label`*: Preserve[Cap]
    `fields`*: seq[Pattern[Cap]]

  PCompoundArr*[Cap] {.preservesRecord: "arr".} = ref object
    `items`*: seq[Pattern[Cap]]

  PCompoundDict*[Cap] {.preservesRecord: "dict".} = ref object
    `entries`*: Table[Preserve[Cap], Pattern[Cap]]

  `PCompound`*[Cap] {.preservesOr.} = ref object
    case orKind*: PCompoundKind
    of PCompoundKind.`rec`:
        `rec`*: PCompoundRec[Cap]

    of PCompoundKind.`arr`:
        `arr`*: PCompoundArr[Cap]

    of PCompoundKind.`dict`:
        `dict`*: PCompoundDict[Cap]

  
  PAnd*[Cap] {.preservesRecord: "and".} = ref object
    `patterns`*: seq[Pattern[Cap]]

  Rewrite*[Cap] {.preservesRecord: "rewrite".} = ref object
    `pattern`*: Pattern[Cap]
    `template`*: Template[Cap]

  TRef* {.preservesRecord: "ref".} = object
    `binding`*: BiggestInt

  PBind*[Cap] {.preservesRecord: "bind".} = ref object
    `pattern`*: Pattern[Cap]

  Lit*[Cap] {.preservesRecord: "lit".} = object
    `value`*: Preserve[Cap]

  TCompoundKind* {.pure.} = enum
    `rec`, `arr`, `dict`
  TCompoundRec*[Cap] {.preservesRecord: "rec".} = ref object
    `label`*: Preserve[Cap]
    `fields`*: seq[Template[Cap]]

  TCompoundArr*[Cap] {.preservesRecord: "arr".} = ref object
    `items`*: seq[Template[Cap]]

  TCompoundDict*[Cap] {.preservesRecord: "dict".} = ref object
    `entries`*: Table[Preserve[Cap], Template[Cap]]

  `TCompound`*[Cap] {.preservesOr.} = ref object
    case orKind*: TCompoundKind
    of TCompoundKind.`rec`:
        `rec`*: TCompoundRec[Cap]

    of TCompoundKind.`arr`:
        `arr`*: TCompoundArr[Cap]

    of TCompoundKind.`dict`:
        `dict`*: TCompoundDict[Cap]

  
  `PAtom`* {.preservesOr, pure.} = enum
    `Boolean`, `Float`, `Double`, `SignedInteger`, `String`, `ByteString`,
    `Symbol`
  Attenuation*[Cap] = seq[Caveat[Cap]]
  PDiscard* {.preservesRecord: "_".} = object
  
  TemplateKind* {.pure.} = enum
    `TAttenuate`, `TRef`, `Lit`, `TCompound`
  `Template`*[Cap] {.preservesOr.} = ref object
    case orKind*: TemplateKind
    of TemplateKind.`TAttenuate`:
        `tattenuate`*: TAttenuate[Cap]

    of TemplateKind.`TRef`:
        `tref`*: TRef

    of TemplateKind.`Lit`:
        `lit`*: Lit[Cap]

    of TemplateKind.`TCompound`:
        `tcompound`*: TCompound[Cap]

  
  CaveatKind* {.pure.} = enum
    `Rewrite`, `Alts`
  `Caveat`*[Cap] {.preservesOr.} = ref object
    case orKind*: CaveatKind
    of CaveatKind.`Rewrite`:
        `rewrite`*: Rewrite[Cap]

    of CaveatKind.`Alts`:
        `alts`*: Alts[Cap]

  
  PNot*[Cap] {.preservesRecord: "not".} = ref object
    `pattern`*: Pattern[Cap]

  SturdyRef*[Cap] {.preservesRecord: "ref".} = ref object
    `oid`*: Preserve[Cap]
    `caveatChain`*: seq[Attenuation[Cap]]
    `sig`*: seq[byte]

  WireRefKind* {.pure.} = enum
    `mine`, `yours`
  WireRefMine* {.preservesTuple.} = object
    `field0`* {.preservesLiteral: "0".}: tuple[]
    `oid`*: Oid

  WireRefYours*[Cap] {.preservesTuple.} = ref object
    `field0`* {.preservesLiteral: "1".}: tuple[]
    `oid`*: Oid
    `attenuation`* {.preservesTupleTail.}: seq[Caveat[Cap]]

  `WireRef`*[Cap] {.preservesOr.} = ref object
    case orKind*: WireRefKind
    of WireRefKind.`mine`:
        `mine`*: WireRefMine

    of WireRefKind.`yours`:
        `yours`*: WireRefYours[Cap]

  
  TAttenuate*[Cap] {.preservesRecord: "attenuate".} = ref object
    `template`*: Template[Cap]
    `attenuation`*: Attenuation[Cap]

  Oid* = BiggestInt
  Alts*[Cap] {.preservesRecord: "or".} = ref object
    `alternatives`*: seq[Rewrite[Cap]]

  PatternKind* {.pure.} = enum
    `PDiscard`, `PAtom`, `PEmbedded`, `PBind`, `PAnd`, `PNot`, `Lit`,
    `PCompound`
  `Pattern`*[Cap] {.preservesOr.} = ref object
    case orKind*: PatternKind
    of PatternKind.`PDiscard`:
        `pdiscard`*: PDiscard

    of PatternKind.`PAtom`:
        `patom`*: PAtom

    of PatternKind.`PEmbedded`:
        `pembedded`* {.preservesLiteral: "Embedded".}: bool

    of PatternKind.`PBind`:
        `pbind`*: PBind[Cap]

    of PatternKind.`PAnd`:
        `pand`*: PAnd[Cap]

    of PatternKind.`PNot`:
        `pnot`*: PNot[Cap]

    of PatternKind.`Lit`:
        `lit`*: Lit[Cap]

    of PatternKind.`PCompound`:
        `pcompound`*: PCompound[Cap]

  
proc `$`*[Cap](x: PCompound[Cap] | PAnd[Cap] | Rewrite[Cap] | PBind[Cap] |
    Lit[Cap] |
    TCompound[Cap] |
    Attenuation[Cap] |
    Template[Cap] |
    Caveat[Cap] |
    PNot[Cap] |
    SturdyRef[Cap] |
    WireRef[Cap] |
    TAttenuate[Cap] |
    Alts[Cap] |
    Pattern[Cap]): string =
  `$`(toPreserve(x, Cap))

proc encode*[Cap](x: PCompound[Cap] | PAnd[Cap] | Rewrite[Cap] | PBind[Cap] |
    Lit[Cap] |
    TCompound[Cap] |
    Attenuation[Cap] |
    Template[Cap] |
    Caveat[Cap] |
    PNot[Cap] |
    SturdyRef[Cap] |
    WireRef[Cap] |
    TAttenuate[Cap] |
    Alts[Cap] |
    Pattern[Cap]): seq[byte] =
  encode(toPreserve(x, Cap))

proc `$`*(x: TRef | PDiscard | Oid): string =
  `$`(toPreserve(x))

proc encode*(x: TRef | PDiscard | Oid): seq[byte] =
  encode(toPreserve(x))