From 2b5e5611b382c9337eda310deaf800fc502f9149 Mon Sep 17 00:00:00 2001 From: Tony Garnock-Jones Date: Mon, 11 Oct 2021 12:55:45 +0200 Subject: [PATCH] Bring up to date (untested) --- Makefile | 11 + package.json | 5 +- .../schemas/examples/boxProtocol.prs | 2 +- schemas/dataspace.prs | 9 - schemas/gatekeeper.prs | 5 - schemas/protocol.prs | 14 - schemas/secure-chat-protocol.prs | 21 - schemas/simple-chat-protocol.prs | 5 - schemas/sturdy.prs | 44 -- schemas/worker.prs | 4 - src/distributed/server.ts | 34 +- src/examples/box.ts | 6 +- src/examples/client.ts | 8 +- src/examples/main.ts | 2 +- src/examples/secure-chat-client.ts | 52 +- src/examples/secure-chat-moderator.ts | 85 +-- src/examples/simple-chat.ts | 20 +- src/gen/dataspace.ts | 37 +- src/gen/dataspacePatterns.ts | 392 +++++++++++++ .../boxProtocol.ts} | 22 +- src/gen/externalProtocol.ts | 359 ++++++++++++ src/gen/gatekeeper.ts | 45 +- src/gen/genericProtocol.ts | 356 ++++++++++++ src/gen/internalProtocol.ts | 359 ++++++++++++ src/gen/protocol.ts | 291 ---------- src/gen/racketEvent.ts | 35 ++ ...chat-protocol.ts => secureChatProtocol.ts} | 106 ++-- src/gen/service.ts | 61 ++ ...chat-protocol.ts => simpleChatProtocol.ts} | 22 +- src/gen/stream.ts | 401 +++++++++++++ src/gen/sturdy.ts | 540 ++++++++++-------- src/gen/tcp.ts | 115 ++++ src/gen/timer.ts | 147 +++++ src/gen/worker.ts | 22 +- src/runtime/actor.ts | 2 + src/runtime/dataspace.ts | 103 ++-- src/runtime/rewrite.ts | 8 +- src/transport/protocol.ts | 4 +- src/transport/relay.ts | 2 +- src/transport/sturdy.ts | 4 +- 40 files changed, 2835 insertions(+), 925 deletions(-) create mode 100644 Makefile rename schemas/box-protocol.prs => protocols/schemas/examples/boxProtocol.prs (87%) delete mode 100644 schemas/dataspace.prs delete mode 100644 schemas/gatekeeper.prs delete mode 100644 schemas/protocol.prs delete mode 100644 schemas/secure-chat-protocol.prs delete mode 100644 schemas/simple-chat-protocol.prs delete mode 100644 schemas/sturdy.prs delete mode 100644 schemas/worker.prs create mode 100644 src/gen/dataspacePatterns.ts rename src/gen/{box-protocol.ts => examples/boxProtocol.ts} (60%) create mode 100644 src/gen/externalProtocol.ts create mode 100644 src/gen/genericProtocol.ts create mode 100644 src/gen/internalProtocol.ts delete mode 100644 src/gen/protocol.ts create mode 100644 src/gen/racketEvent.ts rename src/gen/{secure-chat-protocol.ts => secureChatProtocol.ts} (58%) create mode 100644 src/gen/service.ts rename src/gen/{simple-chat-protocol.ts => simpleChatProtocol.ts} (63%) create mode 100644 src/gen/stream.ts create mode 100644 src/gen/tcp.ts create mode 100644 src/gen/timer.ts diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..1c09c3a --- /dev/null +++ b/Makefile @@ -0,0 +1,11 @@ +all: + yarn run build + +clean: + yarn run clean + +pull-protocols: + git subtree pull -P protocols \ + -m 'Merge latest changes from the syndicate-protocols repository' \ + git@git.syndicate-lang.org:syndicate-lang/syndicate-protocols \ + main diff --git a/package.json b/package.json index f91d7e6..3619a15 100644 --- a/package.json +++ b/package.json @@ -10,14 +10,13 @@ "@preserves/schema": "^0.16.0" }, "scripts": { - "regenerate": "rm -rf ./src/gen && preserves-schema-ts --module Actor=./src/runtime/actor.ts --output ./src/gen './schemas/**/*.prs'", + "regenerate": "rm -rf ./src/gen && preserves-schema-ts --module EntityRef=./src/runtime/actor.ts --output ./src/gen './protocols/schemas/**/*.prs'", "regenerate:watch": "yarn regenerate --watch", - "regenerate:bundle": "preserves-schemac './schemas/**/*.prs' > novy-syndicate.schema.bundle.bin", "compile": "tsc", "compile:watch": "tsc -w", "rollup": "rollup -c", "rollup:watch": "rollup -c -w", "clean": "rm -rf lib index.js", - "build": "yarn regenerate && yarn regenerate:bundle && yarn compile && yarn rollup" + "build": "yarn regenerate && yarn compile && yarn rollup" } } diff --git a/schemas/box-protocol.prs b/protocols/schemas/examples/boxProtocol.prs similarity index 87% rename from schemas/box-protocol.prs rename to protocols/schemas/examples/boxProtocol.prs index d200d54..88df1ca 100644 --- a/schemas/box-protocol.prs +++ b/protocols/schemas/examples/boxProtocol.prs @@ -1,5 +1,5 @@ version 1 . -embeddedType Actor.Ref . +embeddedType EntityRef.Ref . BoxState = . SetBox = . diff --git a/schemas/dataspace.prs b/schemas/dataspace.prs deleted file mode 100644 index 8b61d31..0000000 --- a/schemas/dataspace.prs +++ /dev/null @@ -1,9 +0,0 @@ -version 1 . -embeddedType Actor.Ref . - -;As implemented -Observe = . - -; ;As will be implemented soon -; Observe = . -. diff --git a/schemas/gatekeeper.prs b/schemas/gatekeeper.prs deleted file mode 100644 index d8be377..0000000 --- a/schemas/gatekeeper.prs +++ /dev/null @@ -1,5 +0,0 @@ -version 1 . -embeddedType Actor.Ref . - -Resolve = . -Bind = . diff --git a/schemas/protocol.prs b/schemas/protocol.prs deleted file mode 100644 index b86a66d..0000000 --- a/schemas/protocol.prs +++ /dev/null @@ -1,14 +0,0 @@ -version 1 . -embeddedType sturdy.WireRef . - -Assertion = any . -Handle = int . -Event = Assert / Retract / Message / Sync . -Oid = int . -Turn = [TurnEvent ...]. -TurnEvent = [@oid Oid @event Event]. - -Assert = . -Retract = . -Message = . -Sync = . diff --git a/schemas/secure-chat-protocol.prs b/schemas/secure-chat-protocol.prs deleted file mode 100644 index c20c8e0..0000000 --- a/schemas/secure-chat-protocol.prs +++ /dev/null @@ -1,21 +0,0 @@ -version 1 . -embeddedType Actor.Ref . - -UserId = int . - -Join = . - -Session = @observeUsers - / @observeSpeech - / NickClaim - / Says -. - -NickClaim = . -NickClaimResponse = #t / NickConflict . - -UserInfo = . - -Says = . - -NickConflict = . diff --git a/schemas/simple-chat-protocol.prs b/schemas/simple-chat-protocol.prs deleted file mode 100644 index 987c1f4..0000000 --- a/schemas/simple-chat-protocol.prs +++ /dev/null @@ -1,5 +0,0 @@ -version 1 . -embeddedType Actor.Ref . - -Present = . -Says = . diff --git a/schemas/sturdy.prs b/schemas/sturdy.prs deleted file mode 100644 index f327884..0000000 --- a/schemas/sturdy.prs +++ /dev/null @@ -1,44 +0,0 @@ -version 1 . -embeddedType Actor.Ref . - -; Each Attenuation is a stage. The sequence of Attenuations is run RIGHT-TO-LEFT. -; That is, the newest Attenuations are at the right. -SturdyRef = . - -; An individual Attenuation is run RIGHT-TO-LEFT. -; That is, the newest Caveats are at the right. -Attenuation = [Caveat ...]. - -; embodies 1st-party caveats over assertion structure, but nothing else -; can add 3rd-party caveats and richer predicates later -Caveat = Rewrite / Alts . -Rewrite = . -Alts = . - -Oid = int . -WireRef = @mine [0 @oid Oid] / @yours [1 @oid Oid @attenuation Caveat ...]. - -;--------------------------------------------------------------------------- - -ConstructorSpec = CRec / CArr / CDict . -CRec = . -CArr = . -CDict = . - -Lit = . - -Pattern = PDiscard / PAtom / PEmbedded / PBind / PAnd / PNot / Lit / PCompound . -PDiscard = <_>. -PAtom = =Boolean / =Float / =Double / =SignedInteger / =String / =ByteString / =Symbol . -PEmbedded = =Embedded . -PBind = . -PAnd = . -PNot = . -PCompound = . -PCompoundMembers = { any: Pattern ...:... }. - -Template = TAttenuate / TRef / Lit / TCompound . -TAttenuate = . -TRef = . -TCompound = . -TCompoundMembers = { any: Template ...:... }. diff --git a/schemas/worker.prs b/schemas/worker.prs deleted file mode 100644 index e35abd9..0000000 --- a/schemas/worker.prs +++ /dev/null @@ -1,4 +0,0 @@ -version 1 . -embeddedType Actor.Ref . - -Instance = . diff --git a/src/distributed/server.ts b/src/distributed/server.ts index fb5ec0c..4b46397 100644 --- a/src/distributed/server.ts +++ b/src/distributed/server.ts @@ -1,14 +1,14 @@ -import { Actor, Handle, Turn } from '../runtime/actor.js'; -import { Dataspace, during, observe } from '../runtime/dataspace.js'; +import { Actor, Handle, Ref, Turn } from '../runtime/actor.js'; +import { Dataspace, during, observe, P } from '../runtime/dataspace.js'; import { Relay, spawnRelay } from '../transport/relay.js'; import * as net from 'net'; import { mint, sturdyEncode, validate } from '../transport/sturdy.js'; import { KEY_LENGTH } from '../transport/cryptography.js'; import { attenuate } from '../runtime/rewrite.js'; -import { Bytes, embed, is } from '@preserves/core'; -import { Attenuation, fromSturdyRef, _val } from '../gen/sturdy.js'; -import { $bind, Bind, fromBind, toBind, toResolve } from '../gen/gatekeeper.js'; +import { Bytes, embed, Embedded } from '@preserves/core'; +import { Attenuation, fromSturdyRef } from '../gen/sturdy.js'; +import { $bind, Bind, fromBind, toResolve } from '../gen/gatekeeper.js'; new Actor(t => { t.activeFacet.preventInertCheck(); @@ -44,18 +44,18 @@ new Actor(t => { if (a === void 0) return null; const r = a.sturdyref; let facet = t.facet(t => { - observe(t, ds, $bind, during(async (t, b0) => { - const b = toBind(b0); - if (b === void 0) return null; - if (!is(r.oid, b.oid)) return null; - if (!await validate(r, b.key)) return null; - const cavs: Attenuation = []; - r.caveatChain.forEach(cs => cavs.push(... cs)); - const attenuated_ds = attenuate(b.target, ... cavs); - let replyHandle: Handle | undefined; - t.freshen(t => replyHandle = t.assert(a.observer, embed(attenuated_ds))); - return t => t.retract(replyHandle); - })); + observe(t, ds, P.rec($bind, P.lit(r.oid), P.bind('key'), P.bind('target')), + during(async (t, bindings) => { + const [key, embeddedTarget] = bindings as [Bytes, Embedded]; + const target = embeddedTarget.embeddedValue; + if (!await validate(r, key)) return null; + const cavs: Attenuation = []; + r.caveatChain.forEach(cs => cavs.push(... cs)); + const attenuated_ds = attenuate(target, ... cavs); + let replyHandle: Handle | undefined; + t.freshen(t => replyHandle = t.assert(a.observer, embed(attenuated_ds))); + return t => t.retract(replyHandle); + })); }); return t => t.stop(facet); })), diff --git a/src/examples/box.ts b/src/examples/box.ts index afdaccf..a657ea6 100644 --- a/src/examples/box.ts +++ b/src/examples/box.ts @@ -1,6 +1,6 @@ import { Embedded } from "@preserves/core"; -import { BoxState, $SetBox, fromBoxState } from "../gen/box-protocol.js"; -import { fromObserve, Observe } from "../gen/dataspace.js"; +import { BoxState, $SetBox, fromBoxState } from "../gen/examples/boxProtocol.js"; +import { fromObserve, Observe, P } from "../runtime/dataspace.js"; import { Assertion, Handle, Ref, Turn } from "../runtime/actor.js"; let startTime = Date.now(); @@ -18,7 +18,7 @@ export default function (t: Turn, arg: Assertion) { } setValue(t, 0); t.assert(ds, fromObserve(Observe({ - label: $SetBox, + pattern: P.rec($SetBox, P.bind('newValue', P.discard())), observer: t.ref({ message(t: Turn, [newValue]: [number]): void { // console.log(`Box ${t.actor.id}: got ${newValue}`); diff --git a/src/examples/client.ts b/src/examples/client.ts index 06891b4..45d31db 100644 --- a/src/examples/client.ts +++ b/src/examples/client.ts @@ -1,6 +1,6 @@ import { Embedded } from "@preserves/core"; -import { $BoxState, fromSetBox, SetBox } from "../gen/box-protocol.js"; -import { fromObserve, Observe } from "../gen/dataspace.js"; +import { $BoxState, fromSetBox, SetBox } from "../gen/examples/boxProtocol.js"; +import { fromObserve, Observe, P } from "../runtime/dataspace.js"; import { Assertion, Ref, Turn } from "../runtime/actor.js"; export default function (t: Turn, ds_p: Embedded) { @@ -8,7 +8,7 @@ export default function (t: Turn, ds_p: Embedded) { console.log('Spawning Client'); let count = 0; t.assert(ds, fromObserve(Observe({ - label: $BoxState, + pattern: P.rec($BoxState, P.bind('currentValue', P.discard())), observer: t.ref({ assert(t: Turn, [currentValue]: [number]): void { // console.log(`Client ${t.actor.id}: got ${currentValue}`); @@ -17,7 +17,7 @@ export default function (t: Turn, ds_p: Embedded) { }) }))); t.assert(ds, fromObserve(Observe({ - label: $BoxState, + pattern: P.rec($BoxState, P.discard()), observer: t.ref({ assert(_t: Turn, _assertion: Assertion): void { count++; diff --git a/src/examples/main.ts b/src/examples/main.ts index d1f07eb..b13fedd 100644 --- a/src/examples/main.ts +++ b/src/examples/main.ts @@ -2,7 +2,7 @@ import { Actor, Assertion, Turn } from '../runtime/actor.js'; import { Dictionary, embed } from '@preserves/core'; import { Dataspace } from '../runtime/dataspace.js'; import { _embedded, attenuate, CRec, Lit, Pattern, PCompound, rfilter, ConstructorSpec } from '../runtime/rewrite.js'; -import { $BoxState, $SetBox } from '../gen/box-protocol.js'; +import { $BoxState, $SetBox } from '../gen/examples/boxProtocol.js'; import { $Observe } from '../gen/dataspace.js'; import { spawnWorker } from '../worker/index.js'; import path from 'path'; diff --git a/src/examples/secure-chat-client.ts b/src/examples/secure-chat-client.ts index 51b715a..4bbccdb 100644 --- a/src/examples/secure-chat-client.ts +++ b/src/examples/secure-chat-client.ts @@ -1,16 +1,17 @@ -import { $joinedUser, $says, $user, asJoin, asSays, asUserInfo, fromNickClaim, fromSays, NickClaim, Says, UserId } from "../gen/secure-chat-protocol.js"; -import { during, observe } from "../runtime/dataspace.js"; +import { $joinedUser, $says, $user, fromNickClaim, fromSays, NickClaim, Says, UserId } from "../gen/secureChatProtocol.js"; +import { during, observe, P } from "../runtime/dataspace.js"; import { Assertion, Ref, Turn } from "../runtime/actor.js"; import { attachReadline } from './readline.js'; import { Embedded } from "@preserves/core"; export default function (t: Turn, ds_ptr: Embedded) { const ds = ds_ptr.embeddedValue; - observe(t, ds, $joinedUser, during(async (t, j0) => { - const j = asJoin(j0); - const facet = t.facet(t => runSession(t, j.uid, j.handle)); - return t => t.stop(facet); - })); + observe(t, ds, P.rec($joinedUser, P.bind('uid', P.discard()), P.bind('handle', P.discard())), + during(async (t, bindings) => { + let [uid, handle] = bindings as [UserId, Ref]; + const facet = t.facet(t => runSession(t, uid, handle)); + return t => t.stop(facet); + })); } function runSession(t: Turn, uid: UserId, session: Ref) { @@ -39,25 +40,26 @@ function runSession(t: Turn, uid: UserId, session: Ref) { updateUsername(t, 'user' + process.pid); const users = new Map(); - observe(t, session, $user, during(async (_t, ui0) => { - const ui = asUserInfo(ui0); - const oldName = users.get(ui.uid); - console.log(oldName === void 0 - ? `${ui.name} arrived` - : `${oldName} changed name to ${ui.name}`); - users.set(ui.uid, ui.name); - return (_t) => { - if (users.get(ui.uid) === ui.name) { - console.log(`${ui.name} departed`); - users.delete(ui.uid); - } - }; - })); + observe(t, session, P.rec($user, P.bind('uid', P.discard()), P.bind('name', P.discard())), + during(async (_t, bindings) => { + let [uid, name] = bindings as [UserId, string]; + const oldName = users.get(uid); + console.log(oldName === void 0 + ? `${name} arrived` + : `${oldName} changed name to ${name}`); + users.set(uid, name); + return (_t) => { + if (users.get(uid) === name) { + console.log(`${name} departed`); + users.delete(uid); + } + }; + })); - observe(t, session, $says, { - message(_t: Turn, u0: Assertion): void { - const u = asSays(u0); - console.log(`${users.get(u.who) ?? ``}: ${u.what}`); + observe(t, session, P.rec($says, P.bind('who', P.discard()), P.bind('what', P.discard())), { + message(_t: Turn, bindings: Assertion): void { + let [who, what] = bindings as [UserId, string]; + console.log(`${users.get(who) ?? ``}: ${what}`); }, }); diff --git a/src/examples/secure-chat-moderator.ts b/src/examples/secure-chat-moderator.ts index 5159181..f370b3a 100644 --- a/src/examples/secure-chat-moderator.ts +++ b/src/examples/secure-chat-moderator.ts @@ -7,14 +7,13 @@ import { NickConflict, UserId, UserInfo, - asNickClaim, fromJoin, fromNickConflict, fromUserInfo, -} from "../gen/secure-chat-protocol.js"; +} from "../gen/secureChatProtocol.js"; import { Assertion, Handle, Ref, Turn } from "../runtime/actor.js"; -import { observe, during, $Observe, asObserve, Dataspace } from "../runtime/dataspace.js"; -import { attenuate, rfilter, pRec, pEmbedded, pString, pLit } from "../runtime/rewrite.js"; +import { observe, during, $Observe, Dataspace, P, $rec, $compound } from "../runtime/dataspace.js"; +import { attenuate, rfilter, pRec, pEmbedded, pString, pLit, pDiscard } from "../runtime/rewrite.js"; import { attenuate as sturdyAttenuate, KEY_LENGTH, sturdyEncode, fromSturdyRef, mint } from "../transport/sturdy.js"; import { Bind, fromBind } from "../gen/gatekeeper.js"; import { Bytes, Embedded } from "@preserves/core"; @@ -28,7 +27,11 @@ export default function (t: Turn, gatekeeperDs_ptr: Embedded) { const chatKey = new Bytes(KEY_LENGTH); t.assert(gatekeeperDs, fromBind(Bind({ oid: chatOid, key: chatKey, target: ds }))); mint(chatOid, chatKey).then(async r => { - r = await sturdyAttenuate(r, rfilter(pRec($Observe, pLit($joinedUser), pEmbedded()))); + r = await sturdyAttenuate(r, rfilter(pRec($Observe, + pRec($compound, + pRec($rec, pLit($joinedUser), pLit(2)), + pDiscard()), + pEmbedded()))); console.log(fromSturdyRef(r).asPreservesText()); console.log(sturdyEncode(fromSturdyRef(r)).toHex()); }); @@ -36,39 +39,45 @@ export default function (t: Turn, gatekeeperDs_ptr: Embedded) { const nicks = new Map(); let nextUserId: UserId = 0; - observe(t, ds, $Observe, during(async (t, o0) => { - const o = asObserve(o0); - if (o.label !== $joinedUser) return null; + observe(t, ds, P.rec($Observe, + P.rec($compound, + P.rec($rec, P.lit($joinedUser), P.lit(2)), + P.discard()), + P.bind('observer', P.discard())), + during(async (t, bindings) => { + const [embeddedObserver] = bindings as [Embedded]; + const observer = embeddedObserver.embeddedValue; - const uid: UserId = nextUserId++; - const f = t.facet(t => { - t.assert(o.observer, fromJoin(Join({ - uid, - handle: attenuate(ds, rfilter( - pRec($Observe, pLit($user), pEmbedded()), - pRec($Observe, pLit($says), pEmbedded()), - pRec($claimNick, pLit(uid), pString(), pEmbedded()), - pRec($says, pLit(uid), pString()))), - }))); - let infoHandle: Handle | undefined; - let nick: string | undefined; - observe(t, ds, $claimNick, { - assert(t: Turn, c0: Assertion): void { - const c = asNickClaim(c0); - if (c.uid !== uid) return; - if (nicks.has(c.name)) { - t.message(c.k, fromNickConflict(NickConflict())); - } else { - t.message(c.k, true); - if (nick !== void 0) nicks.delete(nick); - infoHandle = t.replace(ds, infoHandle, fromUserInfo(UserInfo(c))); - nick = c.name; - nicks.set(nick, uid); - } - } - }); - }); + const uid: UserId = nextUserId++; + const f = t.facet(t => { + t.assert(observer, fromJoin(Join({ + uid, + handle: attenuate(ds, rfilter( + pRec($Observe, pLit($user), pEmbedded()), + pRec($Observe, pLit($says), pEmbedded()), + pRec($claimNick, pLit(uid), pString(), pEmbedded()), + pRec($says, pLit(uid), pString()))), + }))); + let infoHandle: Handle | undefined; + let nick: string | undefined; + observe(t, ds, P.rec($claimNick, P.lit(uid), P.bind('name'), P.bind('k')), { + assert(t: Turn, bindings: Assertion): void { + const [name, embeddedK] = bindings as [string, Embedded]; + const k = embeddedK.embeddedValue; + if (nicks.has(name)) { + t.message(k, fromNickConflict(NickConflict())); + } else { + t.message(k, true); + if (nick !== void 0) nicks.delete(nick); + infoHandle = t.replace(ds, infoHandle, + fromUserInfo(UserInfo({ uid, name }))); + nick = name; + nicks.set(nick, uid); + } + } + }); + }); - return t => t.stop(f); - })); + return t => t.stop(f); + })); } diff --git a/src/examples/simple-chat.ts b/src/examples/simple-chat.ts index a8c61d7..7fcad57 100644 --- a/src/examples/simple-chat.ts +++ b/src/examples/simple-chat.ts @@ -1,5 +1,5 @@ -import { $Present, $Says, asPresent, asSays, fromPresent, fromSays, Present, Says } from "../gen/simple-chat-protocol.js"; -import { during, observe } from "../runtime/dataspace.js"; +import { $Present, $Says, fromPresent, fromSays, Present, Says } from "../gen/simpleChatProtocol.js"; +import { during, observe, P } from "../runtime/dataspace.js"; import { Assertion, Handle, Ref, Turn } from "../runtime/actor.js"; import { attachReadline } from './readline.js'; import { Embedded } from "@preserves/core"; @@ -16,16 +16,16 @@ export default function (t: Turn, ds_ptr: Embedded) { } updateUsername(t, 'user' + process.pid); - observe(t, ds, $Present, during(async (_t, e0) => { - const e = asPresent(e0); - console.log(`${e.username} arrived`); - return (_t) => console.log(`${e.username} departed`); + observe(t, ds, P.rec($Present, P.bind('username')), during(async (_t, bindings) => { + const [username] = bindings as [string]; + console.log(`${username} arrived`); + return (_t) => console.log(`${username} departed`); })); - observe(t, ds, $Says, { - message(_t: Turn, u0: Assertion): void { - const u = asSays(u0); - console.log(`${u.who}: ${u.what}`); + observe(t, ds, P.rec($Says, P.bind('who'), P.bind('what')), { + message(_t: Turn, bindings: Assertion): void { + const [who, what] = bindings as [string, string]; + console.log(`${who}: ${what}`); }, }); diff --git a/src/gen/dataspace.ts b/src/gen/dataspace.ts index 276f4fb..ab90c12 100644 --- a/src/gen/dataspace.ts +++ b/src/gen/dataspace.ts @@ -1,40 +1,49 @@ import * as _ from "@preserves/core"; -import * as _i_Actor from "../runtime/actor"; +import * as _i_EntityRef from "../runtime/actor"; +import * as _i_dataspacePatterns from "./dataspacePatterns"; export const $Observe = Symbol.for("Observe"); -export type _embedded = _i_Actor.Ref; +export type _embedded = _i_EntityRef.Ref; -export type _val = _.Value<_embedded>; - -export type Observe = {"label": symbol, "observer": _embedded}; +export type Observe<_embedded = _i_EntityRef.Ref> = {"pattern": _i_dataspacePatterns.Pattern<_embedded>, "observer": _embedded}; -export function Observe({label, observer}: {label: symbol, observer: _embedded}): Observe {return {"label": label, "observer": observer};} +export function Observe<_embedded = _i_EntityRef.Ref>( + {pattern, observer}: {pattern: _i_dataspacePatterns.Pattern<_embedded>, observer: _embedded} +): Observe<_embedded> {return {"pattern": pattern, "observer": observer};} -export function asObserve(v: _val): Observe { +export function asObserve<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): Observe<_embedded> { let result = toObserve(v); if (result === void 0) throw new TypeError(`Invalid Observe: ${_.stringify(v)}`); return result; } -export function toObserve(v: _val): undefined | Observe { - let result: undefined | Observe; - if (_.Record.isRecord<_val, _.Tuple<_val>, _embedded>(v)) { +export function toObserve<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | Observe<_embedded> { + let result: undefined | Observe<_embedded>; + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { let _tmp0: (null) | undefined; _tmp0 = _.is(v.label, $Observe) ? null : void 0; if (_tmp0 !== void 0) { - let _tmp1: (symbol) | undefined; - _tmp1 = typeof v[0] === 'symbol' ? v[0] : void 0; + let _tmp1: (_i_dataspacePatterns.Pattern<_embedded>) | undefined; + _tmp1 = _i_dataspacePatterns.toPattern(v[0]); if (_tmp1 !== void 0) { let _tmp2: (_embedded) | undefined; _tmp2 = _.isEmbedded<_embedded>(v[1]) ? v[1].embeddedValue : void 0; - if (_tmp2 !== void 0) {result = {"label": _tmp1, "observer": _tmp2};}; + if (_tmp2 !== void 0) {result = {"pattern": _tmp1, "observer": _tmp2};}; }; }; }; return result; } -export function fromObserve(_v: Observe): _val {return _.Record($Observe, [_v["label"], _.embed(_v["observer"])]);} +export function fromObserve<_embedded = _i_EntityRef.Ref>(_v: Observe<_embedded>): _.Value<_embedded> { + return _.Record( + $Observe, + [ + _i_dataspacePatterns.fromPattern<_embedded>(_v["pattern"]), + _.embed(_v["observer"]) + ] + ); +} diff --git a/src/gen/dataspacePatterns.ts b/src/gen/dataspacePatterns.ts new file mode 100644 index 0000000..783b0bb --- /dev/null +++ b/src/gen/dataspacePatterns.ts @@ -0,0 +1,392 @@ +import * as _ from "@preserves/core"; +import * as _i_EntityRef from "../runtime/actor"; + +export const $_ = Symbol.for("_"); +export const $arr = Symbol.for("arr"); +export const $bind = Symbol.for("bind"); +export const $compound = Symbol.for("compound"); +export const $dict = Symbol.for("dict"); +export const $lit = Symbol.for("lit"); +export const $rec = Symbol.for("rec"); + +export type _embedded = _i_EntityRef.Ref; + +export type Pattern<_embedded = _i_EntityRef.Ref> = ( + {"_variant": "DDiscard", "value": DDiscard} | + {"_variant": "DBind", "value": DBind<_embedded>} | + {"_variant": "DLit", "value": DLit<_embedded>} | + {"_variant": "DCompound", "value": DCompound<_embedded>} +); + +export type DDiscard = null; + +export type DBind<_embedded = _i_EntityRef.Ref> = {"name": symbol, "pattern": Pattern<_embedded>}; + +export type DLit<_embedded = _i_EntityRef.Ref> = {"value": _.Value<_embedded>}; + +export type DCompound<_embedded = _i_EntityRef.Ref> = ( + { + "_variant": "rec", + "ctor": CRec<_embedded>, + "members": _.KeyedDictionary, _embedded> + } | + { + "_variant": "arr", + "ctor": CArr, + "members": _.KeyedDictionary, _embedded> + } | + { + "_variant": "dict", + "ctor": CDict, + "members": _.KeyedDictionary<_.Value<_embedded>, Pattern<_embedded>, _embedded> + } +); + +export type CRec<_embedded = _i_EntityRef.Ref> = {"label": _.Value<_embedded>, "arity": number}; + +export type CArr = {"arity": number}; + +export type CDict = null; + + +export namespace Pattern { + export function DDiscard<_embedded = _i_EntityRef.Ref>(value: DDiscard): Pattern<_embedded> {return {"_variant": "DDiscard", "value": value};}; + export function DBind<_embedded = _i_EntityRef.Ref>(value: DBind<_embedded>): Pattern<_embedded> {return {"_variant": "DBind", "value": value};}; + export function DLit<_embedded = _i_EntityRef.Ref>(value: DLit<_embedded>): Pattern<_embedded> {return {"_variant": "DLit", "value": value};}; + export function DCompound<_embedded = _i_EntityRef.Ref>(value: DCompound<_embedded>): Pattern<_embedded> {return {"_variant": "DCompound", "value": value};}; +} + +export function DDiscard(): DDiscard {return null;} + +export function DBind<_embedded = _i_EntityRef.Ref>({name, pattern}: {name: symbol, pattern: Pattern<_embedded>}): DBind<_embedded> {return {"name": name, "pattern": pattern};} + +export function DLit<_embedded = _i_EntityRef.Ref>(value: _.Value<_embedded>): DLit<_embedded> {return {"value": value};} + +export namespace DCompound { + export function rec<_embedded = _i_EntityRef.Ref>( + {ctor, members}: { + ctor: CRec<_embedded>, + members: _.KeyedDictionary, _embedded> + } + ): DCompound<_embedded> {return {"_variant": "rec", "ctor": ctor, "members": members};}; + export function arr<_embedded = _i_EntityRef.Ref>( + {ctor, members}: {ctor: CArr, members: _.KeyedDictionary, _embedded>} + ): DCompound<_embedded> {return {"_variant": "arr", "ctor": ctor, "members": members};}; + export function dict<_embedded = _i_EntityRef.Ref>( + {ctor, members}: { + ctor: CDict, + members: _.KeyedDictionary<_.Value<_embedded>, Pattern<_embedded>, _embedded> + } + ): DCompound<_embedded> {return {"_variant": "dict", "ctor": ctor, "members": members};}; +} + +export function CRec<_embedded = _i_EntityRef.Ref>({label, arity}: {label: _.Value<_embedded>, arity: number}): CRec<_embedded> {return {"label": label, "arity": arity};} + +export function CArr(arity: number): CArr {return {"arity": arity};} + +export function CDict(): CDict {return null;} + +export function asPattern<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): Pattern<_embedded> { + let result = toPattern(v); + if (result === void 0) throw new TypeError(`Invalid Pattern: ${_.stringify(v)}`); + return result; +} + +export function toPattern<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | Pattern<_embedded> { + let _tmp0: (DDiscard) | undefined; + let result: undefined | Pattern<_embedded>; + _tmp0 = toDDiscard(v); + if (_tmp0 !== void 0) {result = {"_variant": "DDiscard", "value": _tmp0};}; + if (result === void 0) { + let _tmp1: (DBind<_embedded>) | undefined; + _tmp1 = toDBind(v); + if (_tmp1 !== void 0) {result = {"_variant": "DBind", "value": _tmp1};}; + if (result === void 0) { + let _tmp2: (DLit<_embedded>) | undefined; + _tmp2 = toDLit(v); + if (_tmp2 !== void 0) {result = {"_variant": "DLit", "value": _tmp2};}; + if (result === void 0) { + let _tmp3: (DCompound<_embedded>) | undefined; + _tmp3 = toDCompound(v); + if (_tmp3 !== void 0) {result = {"_variant": "DCompound", "value": _tmp3};}; + }; + }; + }; + return result; +} + +export function fromPattern<_embedded = _i_EntityRef.Ref>(_v: Pattern<_embedded>): _.Value<_embedded> { + switch (_v._variant) { + case "DDiscard": {return fromDDiscard<_embedded>(_v.value);}; + case "DBind": {return fromDBind<_embedded>(_v.value);}; + case "DLit": {return fromDLit<_embedded>(_v.value);}; + case "DCompound": {return fromDCompound<_embedded>(_v.value);}; + }; +} + +export function asDDiscard<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): DDiscard { + let result = toDDiscard(v); + if (result === void 0) throw new TypeError(`Invalid DDiscard: ${_.stringify(v)}`); + return result; +} + +export function toDDiscard<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | DDiscard { + let result: undefined | DDiscard; + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { + let _tmp0: (null) | undefined; + _tmp0 = _.is(v.label, $_) ? null : void 0; + if (_tmp0 !== void 0) {result = null;}; + }; + return result; +} + +export function fromDDiscard<_embedded = _i_EntityRef.Ref>(_v: DDiscard): _.Value<_embedded> {return _.Record($_, []);} + +export function asDBind<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): DBind<_embedded> { + let result = toDBind(v); + if (result === void 0) throw new TypeError(`Invalid DBind: ${_.stringify(v)}`); + return result; +} + +export function toDBind<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | DBind<_embedded> { + let result: undefined | DBind<_embedded>; + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { + let _tmp0: (null) | undefined; + _tmp0 = _.is(v.label, $bind) ? null : void 0; + if (_tmp0 !== void 0) { + let _tmp1: (symbol) | undefined; + _tmp1 = typeof v[0] === 'symbol' ? v[0] : void 0; + if (_tmp1 !== void 0) { + let _tmp2: (Pattern<_embedded>) | undefined; + _tmp2 = toPattern(v[1]); + if (_tmp2 !== void 0) {result = {"name": _tmp1, "pattern": _tmp2};}; + }; + }; + }; + return result; +} + +export function fromDBind<_embedded = _i_EntityRef.Ref>(_v: DBind<_embedded>): _.Value<_embedded> {return _.Record($bind, [_v["name"], fromPattern<_embedded>(_v["pattern"])]);} + +export function asDLit<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): DLit<_embedded> { + let result = toDLit(v); + if (result === void 0) throw new TypeError(`Invalid DLit: ${_.stringify(v)}`); + return result; +} + +export function toDLit<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | DLit<_embedded> { + let result: undefined | DLit<_embedded>; + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { + let _tmp0: (null) | undefined; + _tmp0 = _.is(v.label, $lit) ? null : void 0; + if (_tmp0 !== void 0) { + let _tmp1: (_.Value<_embedded>) | undefined; + _tmp1 = v[0]; + if (_tmp1 !== void 0) {result = {"value": _tmp1};}; + }; + }; + return result; +} + +export function fromDLit<_embedded = _i_EntityRef.Ref>(_v: DLit<_embedded>): _.Value<_embedded> {return _.Record($lit, [_v["value"]]);} + +export function asDCompound<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): DCompound<_embedded> { + let result = toDCompound(v); + if (result === void 0) throw new TypeError(`Invalid DCompound: ${_.stringify(v)}`); + return result; +} + +export function toDCompound<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | DCompound<_embedded> { + let result: undefined | DCompound<_embedded>; + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { + let _tmp0: (null) | undefined; + _tmp0 = _.is(v.label, $compound) ? null : void 0; + if (_tmp0 !== void 0) { + let _tmp1: (CRec<_embedded>) | undefined; + _tmp1 = toCRec(v[0]); + if (_tmp1 !== void 0) { + let _tmp2: (_.KeyedDictionary, _embedded>) | undefined; + _tmp2 = void 0; + if (_.Dictionary.isDictionary<_embedded>(v[1])) { + _tmp2 = new _.KeyedDictionary(); + for (const [_tmp4, _tmp3] of v[1]) { + let _tmp5: (number) | undefined; + _tmp5 = typeof _tmp4 === 'number' ? _tmp4 : void 0; + if (_tmp5 !== void 0) { + let _tmp6: (Pattern<_embedded>) | undefined; + _tmp6 = toPattern(_tmp3); + if (_tmp6 !== void 0) {_tmp2.set(_tmp5, _tmp6); continue;}; + }; + _tmp2 = void 0; + break; + }; + }; + if (_tmp2 !== void 0) {result = {"_variant": "rec", "ctor": _tmp1, "members": _tmp2};}; + }; + }; + }; + if (result === void 0) { + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { + let _tmp7: (null) | undefined; + _tmp7 = _.is(v.label, $compound) ? null : void 0; + if (_tmp7 !== void 0) { + let _tmp8: (CArr) | undefined; + _tmp8 = toCArr(v[0]); + if (_tmp8 !== void 0) { + let _tmp9: (_.KeyedDictionary, _embedded>) | undefined; + _tmp9 = void 0; + if (_.Dictionary.isDictionary<_embedded>(v[1])) { + _tmp9 = new _.KeyedDictionary(); + for (const [_tmp11, _tmp10] of v[1]) { + let _tmp12: (number) | undefined; + _tmp12 = typeof _tmp11 === 'number' ? _tmp11 : void 0; + if (_tmp12 !== void 0) { + let _tmp13: (Pattern<_embedded>) | undefined; + _tmp13 = toPattern(_tmp10); + if (_tmp13 !== void 0) {_tmp9.set(_tmp12, _tmp13); continue;}; + }; + _tmp9 = void 0; + break; + }; + }; + if (_tmp9 !== void 0) {result = {"_variant": "arr", "ctor": _tmp8, "members": _tmp9};}; + }; + }; + }; + if (result === void 0) { + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { + let _tmp14: (null) | undefined; + _tmp14 = _.is(v.label, $compound) ? null : void 0; + if (_tmp14 !== void 0) { + let _tmp15: (CDict) | undefined; + _tmp15 = toCDict(v[0]); + if (_tmp15 !== void 0) { + let _tmp16: (_.KeyedDictionary<_.Value<_embedded>, Pattern<_embedded>, _embedded>) | undefined; + _tmp16 = void 0; + if (_.Dictionary.isDictionary<_embedded>(v[1])) { + _tmp16 = new _.KeyedDictionary(); + for (const [_tmp18, _tmp17] of v[1]) { + let _tmp19: (_.Value<_embedded>) | undefined; + _tmp19 = _tmp18; + if (_tmp19 !== void 0) { + let _tmp20: (Pattern<_embedded>) | undefined; + _tmp20 = toPattern(_tmp17); + if (_tmp20 !== void 0) {_tmp16.set(_tmp19, _tmp20); continue;}; + }; + _tmp16 = void 0; + break; + }; + }; + if (_tmp16 !== void 0) {result = {"_variant": "dict", "ctor": _tmp15, "members": _tmp16};}; + }; + }; + }; + }; + }; + return result; +} + +export function fromDCompound<_embedded = _i_EntityRef.Ref>(_v: DCompound<_embedded>): _.Value<_embedded> { + switch (_v._variant) { + case "rec": { + return _.Record( + $compound, + [ + fromCRec<_embedded>(_v["ctor"]), + new _.Dictionary<_embedded>( + _.Array.from(_v["members"].entries()).map(([k, v]) => [k, fromPattern<_embedded>(v)]) + ) + ] + ); + }; + case "arr": { + return _.Record( + $compound, + [ + fromCArr<_embedded>(_v["ctor"]), + new _.Dictionary<_embedded>( + _.Array.from(_v["members"].entries()).map(([k, v]) => [k, fromPattern<_embedded>(v)]) + ) + ] + ); + }; + case "dict": { + return _.Record( + $compound, + [ + fromCDict<_embedded>(_v["ctor"]), + new _.Dictionary<_embedded>( + _.Array.from(_v["members"].entries()).map(([k, v]) => [k, fromPattern<_embedded>(v)]) + ) + ] + ); + }; + }; +} + +export function asCRec<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): CRec<_embedded> { + let result = toCRec(v); + if (result === void 0) throw new TypeError(`Invalid CRec: ${_.stringify(v)}`); + return result; +} + +export function toCRec<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | CRec<_embedded> { + let result: undefined | CRec<_embedded>; + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { + let _tmp0: (null) | undefined; + _tmp0 = _.is(v.label, $rec) ? null : void 0; + if (_tmp0 !== void 0) { + let _tmp1: (_.Value<_embedded>) | undefined; + _tmp1 = v[0]; + if (_tmp1 !== void 0) { + let _tmp2: (number) | undefined; + _tmp2 = typeof v[1] === 'number' ? v[1] : void 0; + if (_tmp2 !== void 0) {result = {"label": _tmp1, "arity": _tmp2};}; + }; + }; + }; + return result; +} + +export function fromCRec<_embedded = _i_EntityRef.Ref>(_v: CRec<_embedded>): _.Value<_embedded> {return _.Record($rec, [_v["label"], _v["arity"]]);} + +export function asCArr<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): CArr { + let result = toCArr(v); + if (result === void 0) throw new TypeError(`Invalid CArr: ${_.stringify(v)}`); + return result; +} + +export function toCArr<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | CArr { + let result: undefined | CArr; + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { + let _tmp0: (null) | undefined; + _tmp0 = _.is(v.label, $arr) ? null : void 0; + if (_tmp0 !== void 0) { + let _tmp1: (number) | undefined; + _tmp1 = typeof v[0] === 'number' ? v[0] : void 0; + if (_tmp1 !== void 0) {result = {"arity": _tmp1};}; + }; + }; + return result; +} + +export function fromCArr<_embedded = _i_EntityRef.Ref>(_v: CArr): _.Value<_embedded> {return _.Record($arr, [_v["arity"]]);} + +export function asCDict<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): CDict { + let result = toCDict(v); + if (result === void 0) throw new TypeError(`Invalid CDict: ${_.stringify(v)}`); + return result; +} + +export function toCDict<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | CDict { + let result: undefined | CDict; + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { + let _tmp0: (null) | undefined; + _tmp0 = _.is(v.label, $dict) ? null : void 0; + if (_tmp0 !== void 0) {result = null;}; + }; + return result; +} + +export function fromCDict<_embedded = _i_EntityRef.Ref>(_v: CDict): _.Value<_embedded> {return _.Record($dict, []);} + diff --git a/src/gen/box-protocol.ts b/src/gen/examples/boxProtocol.ts similarity index 60% rename from src/gen/box-protocol.ts rename to src/gen/examples/boxProtocol.ts index b47affc..61bd149 100644 --- a/src/gen/box-protocol.ts +++ b/src/gen/examples/boxProtocol.ts @@ -1,12 +1,10 @@ import * as _ from "@preserves/core"; -import * as _i_Actor from "../runtime/actor"; +import * as _i_EntityRef from "../../runtime/actor"; export const $BoxState = Symbol.for("BoxState"); export const $SetBox = Symbol.for("SetBox"); -export type _embedded = _i_Actor.Ref; - -export type _val = _.Value<_embedded>; +export type _embedded = _i_EntityRef.Ref; export type BoxState = {"value": number}; @@ -17,15 +15,15 @@ export function BoxState(value: number): BoxState {return {"value": value};} export function SetBox(value: number): SetBox {return {"value": value};} -export function asBoxState(v: _val): BoxState { +export function asBoxState<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): BoxState { let result = toBoxState(v); if (result === void 0) throw new TypeError(`Invalid BoxState: ${_.stringify(v)}`); return result; } -export function toBoxState(v: _val): undefined | BoxState { +export function toBoxState<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | BoxState { let result: undefined | BoxState; - if (_.Record.isRecord<_val, _.Tuple<_val>, _embedded>(v)) { + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { let _tmp0: (null) | undefined; _tmp0 = _.is(v.label, $BoxState) ? null : void 0; if (_tmp0 !== void 0) { @@ -37,17 +35,17 @@ export function toBoxState(v: _val): undefined | BoxState { return result; } -export function fromBoxState(_v: BoxState): _val {return _.Record($BoxState, [_v["value"]]);} +export function fromBoxState<_embedded = _i_EntityRef.Ref>(_v: BoxState): _.Value<_embedded> {return _.Record($BoxState, [_v["value"]]);} -export function asSetBox(v: _val): SetBox { +export function asSetBox<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): SetBox { let result = toSetBox(v); if (result === void 0) throw new TypeError(`Invalid SetBox: ${_.stringify(v)}`); return result; } -export function toSetBox(v: _val): undefined | SetBox { +export function toSetBox<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | SetBox { let result: undefined | SetBox; - if (_.Record.isRecord<_val, _.Tuple<_val>, _embedded>(v)) { + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { let _tmp0: (null) | undefined; _tmp0 = _.is(v.label, $SetBox) ? null : void 0; if (_tmp0 !== void 0) { @@ -59,5 +57,5 @@ export function toSetBox(v: _val): undefined | SetBox { return result; } -export function fromSetBox(_v: SetBox): _val {return _.Record($SetBox, [_v["value"]]);} +export function fromSetBox<_embedded = _i_EntityRef.Ref>(_v: SetBox): _.Value<_embedded> {return _.Record($SetBox, [_v["value"]]);} diff --git a/src/gen/externalProtocol.ts b/src/gen/externalProtocol.ts new file mode 100644 index 0000000..f7bd4b2 --- /dev/null +++ b/src/gen/externalProtocol.ts @@ -0,0 +1,359 @@ +import * as _ from "@preserves/core"; +import * as _i_sturdy from "./sturdy"; + +export const $assert = Symbol.for("assert"); +export const $error = Symbol.for("error"); +export const $message = Symbol.for("message"); +export const $retract = Symbol.for("retract"); +export const $sync = Symbol.for("sync"); + +export type _embedded = _i_sturdy.WireRef; + +export type Packet<_embedded = _i_sturdy.WireRef> = ( + {"_variant": "Turn", "value": Turn<_embedded>} | + {"_variant": "Error", "value": Error<_embedded>} +); + +export type Error<_embedded = _i_sturdy.WireRef> = {"message": string, "detail": _.Value<_embedded>}; + +export type Assertion<_embedded = _i_sturdy.WireRef> = _.Value<_embedded>; + +export type Handle = number; + +export type Event<_embedded = _i_sturdy.WireRef> = ( + {"_variant": "Assert", "value": Assert<_embedded>} | + {"_variant": "Retract", "value": Retract} | + {"_variant": "Message", "value": Message<_embedded>} | + {"_variant": "Sync", "value": Sync<_embedded>} +); + +export type Oid = number; + +export type Turn<_embedded = _i_sturdy.WireRef> = Array>; + +export type TurnEvent<_embedded = _i_sturdy.WireRef> = {"oid": Oid, "event": Event<_embedded>}; + +export type Assert<_embedded = _i_sturdy.WireRef> = {"assertion": Assertion<_embedded>, "handle": Handle}; + +export type Retract = {"handle": Handle}; + +export type Message<_embedded = _i_sturdy.WireRef> = {"body": Assertion<_embedded>}; + +export type Sync<_embedded = _i_sturdy.WireRef> = {"peer": _embedded}; + + +export namespace Packet { + export function Turn<_embedded = _i_sturdy.WireRef>(value: Turn<_embedded>): Packet<_embedded> {return {"_variant": "Turn", "value": value};}; + export function Error<_embedded = _i_sturdy.WireRef>(value: Error<_embedded>): Packet<_embedded> {return {"_variant": "Error", "value": value};}; +} + +export function Error<_embedded = _i_sturdy.WireRef>({message, detail}: {message: string, detail: _.Value<_embedded>}): Error<_embedded> {return {"message": message, "detail": detail};} + +export function Assertion<_embedded = _i_sturdy.WireRef>(value: _.Value<_embedded>): Assertion<_embedded> {return value;} + +export function Handle(value: number): Handle {return value;} + +export namespace Event { + export function Assert<_embedded = _i_sturdy.WireRef>(value: Assert<_embedded>): Event<_embedded> {return {"_variant": "Assert", "value": value};}; + export function Retract<_embedded = _i_sturdy.WireRef>(value: Retract): Event<_embedded> {return {"_variant": "Retract", "value": value};}; + export function Message<_embedded = _i_sturdy.WireRef>(value: Message<_embedded>): Event<_embedded> {return {"_variant": "Message", "value": value};}; + export function Sync<_embedded = _i_sturdy.WireRef>(value: Sync<_embedded>): Event<_embedded> {return {"_variant": "Sync", "value": value};}; +} + +export function Oid(value: number): Oid {return value;} + +export function Turn<_embedded = _i_sturdy.WireRef>(value: Array>): Turn<_embedded> {return value;} + +export function TurnEvent<_embedded = _i_sturdy.WireRef>({oid, event}: {oid: Oid, event: Event<_embedded>}): TurnEvent<_embedded> {return {"oid": oid, "event": event};} + +export function Assert<_embedded = _i_sturdy.WireRef>({assertion, handle}: {assertion: Assertion<_embedded>, handle: Handle}): Assert<_embedded> {return {"assertion": assertion, "handle": handle};} + +export function Retract(handle: Handle): Retract {return {"handle": handle};} + +export function Message<_embedded = _i_sturdy.WireRef>(body: Assertion<_embedded>): Message<_embedded> {return {"body": body};} + +export function Sync<_embedded = _i_sturdy.WireRef>(peer: _embedded): Sync<_embedded> {return {"peer": peer};} + +export function asPacket<_embedded = _i_sturdy.WireRef>(v: _.Value<_embedded>): Packet<_embedded> { + let result = toPacket(v); + if (result === void 0) throw new TypeError(`Invalid Packet: ${_.stringify(v)}`); + return result; +} + +export function toPacket<_embedded = _i_sturdy.WireRef>(v: _.Value<_embedded>): undefined | Packet<_embedded> { + let _tmp0: (Turn<_embedded>) | undefined; + let result: undefined | Packet<_embedded>; + _tmp0 = toTurn(v); + if (_tmp0 !== void 0) {result = {"_variant": "Turn", "value": _tmp0};}; + if (result === void 0) { + let _tmp1: (Error<_embedded>) | undefined; + _tmp1 = toError(v); + if (_tmp1 !== void 0) {result = {"_variant": "Error", "value": _tmp1};}; + }; + return result; +} + +export function fromPacket<_embedded = _i_sturdy.WireRef>(_v: Packet<_embedded>): _.Value<_embedded> { + switch (_v._variant) { + case "Turn": {return fromTurn<_embedded>(_v.value);}; + case "Error": {return fromError<_embedded>(_v.value);}; + }; +} + +export function asError<_embedded = _i_sturdy.WireRef>(v: _.Value<_embedded>): Error<_embedded> { + let result = toError(v); + if (result === void 0) throw new TypeError(`Invalid Error: ${_.stringify(v)}`); + return result; +} + +export function toError<_embedded = _i_sturdy.WireRef>(v: _.Value<_embedded>): undefined | Error<_embedded> { + let result: undefined | Error<_embedded>; + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { + let _tmp0: (null) | undefined; + _tmp0 = _.is(v.label, $error) ? null : void 0; + if (_tmp0 !== void 0) { + let _tmp1: (string) | undefined; + _tmp1 = typeof v[0] === 'string' ? v[0] : void 0; + if (_tmp1 !== void 0) { + let _tmp2: (_.Value<_embedded>) | undefined; + _tmp2 = v[1]; + if (_tmp2 !== void 0) {result = {"message": _tmp1, "detail": _tmp2};}; + }; + }; + }; + return result; +} + +export function fromError<_embedded = _i_sturdy.WireRef>(_v: Error<_embedded>): _.Value<_embedded> {return _.Record($error, [_v["message"], _v["detail"]]);} + +export function asAssertion<_embedded = _i_sturdy.WireRef>(v: _.Value<_embedded>): Assertion<_embedded> { + let result = toAssertion(v); + if (result === void 0) throw new TypeError(`Invalid Assertion: ${_.stringify(v)}`); + return result; +} + +export function toAssertion<_embedded = _i_sturdy.WireRef>(v: _.Value<_embedded>): undefined | Assertion<_embedded> { + let _tmp0: (_.Value<_embedded>) | undefined; + let result: undefined | Assertion<_embedded>; + _tmp0 = v; + if (_tmp0 !== void 0) {result = _tmp0;}; + return result; +} + +export function fromAssertion<_embedded = _i_sturdy.WireRef>(_v: Assertion<_embedded>): _.Value<_embedded> {return _v;} + +export function asHandle<_embedded = _i_sturdy.WireRef>(v: _.Value<_embedded>): Handle { + let result = toHandle(v); + if (result === void 0) throw new TypeError(`Invalid Handle: ${_.stringify(v)}`); + return result; +} + +export function toHandle<_embedded = _i_sturdy.WireRef>(v: _.Value<_embedded>): undefined | Handle { + let _tmp0: (number) | undefined; + let result: undefined | Handle; + _tmp0 = typeof v === 'number' ? v : void 0; + if (_tmp0 !== void 0) {result = _tmp0;}; + return result; +} + +export function fromHandle<_embedded = _i_sturdy.WireRef>(_v: Handle): _.Value<_embedded> {return _v;} + +export function asEvent<_embedded = _i_sturdy.WireRef>(v: _.Value<_embedded>): Event<_embedded> { + let result = toEvent(v); + if (result === void 0) throw new TypeError(`Invalid Event: ${_.stringify(v)}`); + return result; +} + +export function toEvent<_embedded = _i_sturdy.WireRef>(v: _.Value<_embedded>): undefined | Event<_embedded> { + let _tmp0: (Assert<_embedded>) | undefined; + let result: undefined | Event<_embedded>; + _tmp0 = toAssert(v); + if (_tmp0 !== void 0) {result = {"_variant": "Assert", "value": _tmp0};}; + if (result === void 0) { + let _tmp1: (Retract) | undefined; + _tmp1 = toRetract(v); + if (_tmp1 !== void 0) {result = {"_variant": "Retract", "value": _tmp1};}; + if (result === void 0) { + let _tmp2: (Message<_embedded>) | undefined; + _tmp2 = toMessage(v); + if (_tmp2 !== void 0) {result = {"_variant": "Message", "value": _tmp2};}; + if (result === void 0) { + let _tmp3: (Sync<_embedded>) | undefined; + _tmp3 = toSync(v); + if (_tmp3 !== void 0) {result = {"_variant": "Sync", "value": _tmp3};}; + }; + }; + }; + return result; +} + +export function fromEvent<_embedded = _i_sturdy.WireRef>(_v: Event<_embedded>): _.Value<_embedded> { + switch (_v._variant) { + case "Assert": {return fromAssert<_embedded>(_v.value);}; + case "Retract": {return fromRetract<_embedded>(_v.value);}; + case "Message": {return fromMessage<_embedded>(_v.value);}; + case "Sync": {return fromSync<_embedded>(_v.value);}; + }; +} + +export function asOid<_embedded = _i_sturdy.WireRef>(v: _.Value<_embedded>): Oid { + let result = toOid(v); + if (result === void 0) throw new TypeError(`Invalid Oid: ${_.stringify(v)}`); + return result; +} + +export function toOid<_embedded = _i_sturdy.WireRef>(v: _.Value<_embedded>): undefined | Oid { + let _tmp0: (number) | undefined; + let result: undefined | Oid; + _tmp0 = typeof v === 'number' ? v : void 0; + if (_tmp0 !== void 0) {result = _tmp0;}; + return result; +} + +export function fromOid<_embedded = _i_sturdy.WireRef>(_v: Oid): _.Value<_embedded> {return _v;} + +export function asTurn<_embedded = _i_sturdy.WireRef>(v: _.Value<_embedded>): Turn<_embedded> { + let result = toTurn(v); + if (result === void 0) throw new TypeError(`Invalid Turn: ${_.stringify(v)}`); + return result; +} + +export function toTurn<_embedded = _i_sturdy.WireRef>(v: _.Value<_embedded>): undefined | Turn<_embedded> { + let _tmp0: (Array>) | undefined; + let result: undefined | Turn<_embedded>; + _tmp0 = void 0; + if (_.Array.isArray(v)) { + _tmp0 = []; + for (const _tmp1 of v) { + let _tmp2: (TurnEvent<_embedded>) | undefined; + _tmp2 = toTurnEvent(_tmp1); + if (_tmp2 !== void 0) {_tmp0.push(_tmp2); continue;}; + _tmp0 = void 0; + break; + }; + }; + if (_tmp0 !== void 0) {result = _tmp0;}; + return result; +} + +export function fromTurn<_embedded = _i_sturdy.WireRef>(_v: Turn<_embedded>): _.Value<_embedded> {return _v.map(v => fromTurnEvent<_embedded>(v));} + +export function asTurnEvent<_embedded = _i_sturdy.WireRef>(v: _.Value<_embedded>): TurnEvent<_embedded> { + let result = toTurnEvent(v); + if (result === void 0) throw new TypeError(`Invalid TurnEvent: ${_.stringify(v)}`); + return result; +} + +export function toTurnEvent<_embedded = _i_sturdy.WireRef>(v: _.Value<_embedded>): undefined | TurnEvent<_embedded> { + let result: undefined | TurnEvent<_embedded>; + if (_.Array.isArray(v) && v.length === 2) { + let _tmp0: (Oid) | undefined; + _tmp0 = toOid(v[0]); + if (_tmp0 !== void 0) { + let _tmp1: (Event<_embedded>) | undefined; + _tmp1 = toEvent(v[1]); + if (_tmp1 !== void 0) {result = {"oid": _tmp0, "event": _tmp1};}; + }; + }; + return result; +} + +export function fromTurnEvent<_embedded = _i_sturdy.WireRef>(_v: TurnEvent<_embedded>): _.Value<_embedded> {return [fromOid<_embedded>(_v["oid"]), fromEvent<_embedded>(_v["event"])];} + +export function asAssert<_embedded = _i_sturdy.WireRef>(v: _.Value<_embedded>): Assert<_embedded> { + let result = toAssert(v); + if (result === void 0) throw new TypeError(`Invalid Assert: ${_.stringify(v)}`); + return result; +} + +export function toAssert<_embedded = _i_sturdy.WireRef>(v: _.Value<_embedded>): undefined | Assert<_embedded> { + let result: undefined | Assert<_embedded>; + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { + let _tmp0: (null) | undefined; + _tmp0 = _.is(v.label, $assert) ? null : void 0; + if (_tmp0 !== void 0) { + let _tmp1: (Assertion<_embedded>) | undefined; + _tmp1 = toAssertion(v[0]); + if (_tmp1 !== void 0) { + let _tmp2: (Handle) | undefined; + _tmp2 = toHandle(v[1]); + if (_tmp2 !== void 0) {result = {"assertion": _tmp1, "handle": _tmp2};}; + }; + }; + }; + return result; +} + +export function fromAssert<_embedded = _i_sturdy.WireRef>(_v: Assert<_embedded>): _.Value<_embedded> { + return _.Record( + $assert, + [fromAssertion<_embedded>(_v["assertion"]), fromHandle<_embedded>(_v["handle"])] + ); +} + +export function asRetract<_embedded = _i_sturdy.WireRef>(v: _.Value<_embedded>): Retract { + let result = toRetract(v); + if (result === void 0) throw new TypeError(`Invalid Retract: ${_.stringify(v)}`); + return result; +} + +export function toRetract<_embedded = _i_sturdy.WireRef>(v: _.Value<_embedded>): undefined | Retract { + let result: undefined | Retract; + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { + let _tmp0: (null) | undefined; + _tmp0 = _.is(v.label, $retract) ? null : void 0; + if (_tmp0 !== void 0) { + let _tmp1: (Handle) | undefined; + _tmp1 = toHandle(v[0]); + if (_tmp1 !== void 0) {result = {"handle": _tmp1};}; + }; + }; + return result; +} + +export function fromRetract<_embedded = _i_sturdy.WireRef>(_v: Retract): _.Value<_embedded> {return _.Record($retract, [fromHandle<_embedded>(_v["handle"])]);} + +export function asMessage<_embedded = _i_sturdy.WireRef>(v: _.Value<_embedded>): Message<_embedded> { + let result = toMessage(v); + if (result === void 0) throw new TypeError(`Invalid Message: ${_.stringify(v)}`); + return result; +} + +export function toMessage<_embedded = _i_sturdy.WireRef>(v: _.Value<_embedded>): undefined | Message<_embedded> { + let result: undefined | Message<_embedded>; + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { + let _tmp0: (null) | undefined; + _tmp0 = _.is(v.label, $message) ? null : void 0; + if (_tmp0 !== void 0) { + let _tmp1: (Assertion<_embedded>) | undefined; + _tmp1 = toAssertion(v[0]); + if (_tmp1 !== void 0) {result = {"body": _tmp1};}; + }; + }; + return result; +} + +export function fromMessage<_embedded = _i_sturdy.WireRef>(_v: Message<_embedded>): _.Value<_embedded> {return _.Record($message, [fromAssertion<_embedded>(_v["body"])]);} + +export function asSync<_embedded = _i_sturdy.WireRef>(v: _.Value<_embedded>): Sync<_embedded> { + let result = toSync(v); + if (result === void 0) throw new TypeError(`Invalid Sync: ${_.stringify(v)}`); + return result; +} + +export function toSync<_embedded = _i_sturdy.WireRef>(v: _.Value<_embedded>): undefined | Sync<_embedded> { + let result: undefined | Sync<_embedded>; + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { + let _tmp0: (null) | undefined; + _tmp0 = _.is(v.label, $sync) ? null : void 0; + if (_tmp0 !== void 0) { + let _tmp1: (_embedded) | undefined; + _tmp1 = _.isEmbedded<_embedded>(v[0]) ? v[0].embeddedValue : void 0; + if (_tmp1 !== void 0) {result = {"peer": _tmp1};}; + }; + }; + return result; +} + +export function fromSync<_embedded = _i_sturdy.WireRef>(_v: Sync<_embedded>): _.Value<_embedded> {return _.Record($sync, [_.embed(_v["peer"])]);} + diff --git a/src/gen/gatekeeper.ts b/src/gen/gatekeeper.ts index 7f1883d..a3a8fe3 100644 --- a/src/gen/gatekeeper.ts +++ b/src/gen/gatekeeper.ts @@ -1,36 +1,36 @@ import * as _ from "@preserves/core"; -import * as _i_Actor from "../runtime/actor"; +import * as _i_EntityRef from "../runtime/actor"; import * as _i_sturdy from "./sturdy"; export const $bind = Symbol.for("bind"); export const $resolve = Symbol.for("resolve"); -export type _embedded = _i_Actor.Ref; +export type _embedded = _i_EntityRef.Ref; -export type _val = _.Value<_embedded>; +export type Resolve<_embedded = _i_EntityRef.Ref> = {"sturdyref": _i_sturdy.SturdyRef<_embedded>, "observer": _embedded}; -export type Resolve = {"sturdyref": _i_sturdy.SturdyRef, "observer": _embedded}; - -export type Bind = {"oid": _val, "key": _.Bytes, "target": _embedded}; +export type Bind<_embedded = _i_EntityRef.Ref> = {"oid": _.Value<_embedded>, "key": _.Bytes, "target": _embedded}; -export function Resolve({sturdyref, observer}: {sturdyref: _i_sturdy.SturdyRef, observer: _embedded}): Resolve {return {"sturdyref": sturdyref, "observer": observer};} +export function Resolve<_embedded = _i_EntityRef.Ref>( + {sturdyref, observer}: {sturdyref: _i_sturdy.SturdyRef<_embedded>, observer: _embedded} +): Resolve<_embedded> {return {"sturdyref": sturdyref, "observer": observer};} -export function Bind({oid, key, target}: {oid: _val, key: _.Bytes, target: _embedded}): Bind {return {"oid": oid, "key": key, "target": target};} +export function Bind<_embedded = _i_EntityRef.Ref>({oid, key, target}: {oid: _.Value<_embedded>, key: _.Bytes, target: _embedded}): Bind<_embedded> {return {"oid": oid, "key": key, "target": target};} -export function asResolve(v: _val): Resolve { +export function asResolve<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): Resolve<_embedded> { let result = toResolve(v); if (result === void 0) throw new TypeError(`Invalid Resolve: ${_.stringify(v)}`); return result; } -export function toResolve(v: _val): undefined | Resolve { - let result: undefined | Resolve; - if (_.Record.isRecord<_val, _.Tuple<_val>, _embedded>(v)) { +export function toResolve<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | Resolve<_embedded> { + let result: undefined | Resolve<_embedded>; + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { let _tmp0: (null) | undefined; _tmp0 = _.is(v.label, $resolve) ? null : void 0; if (_tmp0 !== void 0) { - let _tmp1: (_i_sturdy.SturdyRef) | undefined; + let _tmp1: (_i_sturdy.SturdyRef<_embedded>) | undefined; _tmp1 = _i_sturdy.toSturdyRef(v[0]); if (_tmp1 !== void 0) { let _tmp2: (_embedded) | undefined; @@ -42,23 +42,26 @@ export function toResolve(v: _val): undefined | Resolve { return result; } -export function fromResolve(_v: Resolve): _val { - return _.Record($resolve, [_i_sturdy.fromSturdyRef(_v["sturdyref"]), _.embed(_v["observer"])]); +export function fromResolve<_embedded = _i_EntityRef.Ref>(_v: Resolve<_embedded>): _.Value<_embedded> { + return _.Record( + $resolve, + [_i_sturdy.fromSturdyRef<_embedded>(_v["sturdyref"]), _.embed(_v["observer"])] + ); } -export function asBind(v: _val): Bind { +export function asBind<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): Bind<_embedded> { let result = toBind(v); if (result === void 0) throw new TypeError(`Invalid Bind: ${_.stringify(v)}`); return result; } -export function toBind(v: _val): undefined | Bind { - let result: undefined | Bind; - if (_.Record.isRecord<_val, _.Tuple<_val>, _embedded>(v)) { +export function toBind<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | Bind<_embedded> { + let result: undefined | Bind<_embedded>; + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { let _tmp0: (null) | undefined; _tmp0 = _.is(v.label, $bind) ? null : void 0; if (_tmp0 !== void 0) { - let _tmp1: (_val) | undefined; + let _tmp1: (_.Value<_embedded>) | undefined; _tmp1 = v[0]; if (_tmp1 !== void 0) { let _tmp2: (_.Bytes) | undefined; @@ -74,5 +77,5 @@ export function toBind(v: _val): undefined | Bind { return result; } -export function fromBind(_v: Bind): _val {return _.Record($bind, [_v["oid"], _v["key"], _.embed(_v["target"])]);} +export function fromBind<_embedded = _i_EntityRef.Ref>(_v: Bind<_embedded>): _.Value<_embedded> {return _.Record($bind, [_v["oid"], _v["key"], _.embed(_v["target"])]);} diff --git a/src/gen/genericProtocol.ts b/src/gen/genericProtocol.ts new file mode 100644 index 0000000..17de7bd --- /dev/null +++ b/src/gen/genericProtocol.ts @@ -0,0 +1,356 @@ +import * as _ from "@preserves/core"; + +export const $assert = Symbol.for("assert"); +export const $error = Symbol.for("error"); +export const $message = Symbol.for("message"); +export const $retract = Symbol.for("retract"); +export const $sync = Symbol.for("sync"); + +export type Packet<_embedded = _.GenericEmbedded> = ( + {"_variant": "Turn", "value": Turn<_embedded>} | + {"_variant": "Error", "value": Error<_embedded>} +); + +export type Error<_embedded = _.GenericEmbedded> = {"message": string, "detail": _.Value<_embedded>}; + +export type Assertion<_embedded = _.GenericEmbedded> = _.Value<_embedded>; + +export type Handle = number; + +export type Event<_embedded = _.GenericEmbedded> = ( + {"_variant": "Assert", "value": Assert<_embedded>} | + {"_variant": "Retract", "value": Retract} | + {"_variant": "Message", "value": Message<_embedded>} | + {"_variant": "Sync", "value": Sync<_embedded>} +); + +export type Oid = number; + +export type Turn<_embedded = _.GenericEmbedded> = Array>; + +export type TurnEvent<_embedded = _.GenericEmbedded> = {"oid": Oid, "event": Event<_embedded>}; + +export type Assert<_embedded = _.GenericEmbedded> = {"assertion": Assertion<_embedded>, "handle": Handle}; + +export type Retract = {"handle": Handle}; + +export type Message<_embedded = _.GenericEmbedded> = {"body": Assertion<_embedded>}; + +export type Sync<_embedded = _.GenericEmbedded> = {"peer": _embedded}; + + +export namespace Packet { + export function Turn<_embedded = _.GenericEmbedded>(value: Turn<_embedded>): Packet<_embedded> {return {"_variant": "Turn", "value": value};}; + export function Error<_embedded = _.GenericEmbedded>(value: Error<_embedded>): Packet<_embedded> {return {"_variant": "Error", "value": value};}; +} + +export function Error<_embedded = _.GenericEmbedded>({message, detail}: {message: string, detail: _.Value<_embedded>}): Error<_embedded> {return {"message": message, "detail": detail};} + +export function Assertion<_embedded = _.GenericEmbedded>(value: _.Value<_embedded>): Assertion<_embedded> {return value;} + +export function Handle(value: number): Handle {return value;} + +export namespace Event { + export function Assert<_embedded = _.GenericEmbedded>(value: Assert<_embedded>): Event<_embedded> {return {"_variant": "Assert", "value": value};}; + export function Retract<_embedded = _.GenericEmbedded>(value: Retract): Event<_embedded> {return {"_variant": "Retract", "value": value};}; + export function Message<_embedded = _.GenericEmbedded>(value: Message<_embedded>): Event<_embedded> {return {"_variant": "Message", "value": value};}; + export function Sync<_embedded = _.GenericEmbedded>(value: Sync<_embedded>): Event<_embedded> {return {"_variant": "Sync", "value": value};}; +} + +export function Oid(value: number): Oid {return value;} + +export function Turn<_embedded = _.GenericEmbedded>(value: Array>): Turn<_embedded> {return value;} + +export function TurnEvent<_embedded = _.GenericEmbedded>({oid, event}: {oid: Oid, event: Event<_embedded>}): TurnEvent<_embedded> {return {"oid": oid, "event": event};} + +export function Assert<_embedded = _.GenericEmbedded>({assertion, handle}: {assertion: Assertion<_embedded>, handle: Handle}): Assert<_embedded> {return {"assertion": assertion, "handle": handle};} + +export function Retract(handle: Handle): Retract {return {"handle": handle};} + +export function Message<_embedded = _.GenericEmbedded>(body: Assertion<_embedded>): Message<_embedded> {return {"body": body};} + +export function Sync<_embedded = _.GenericEmbedded>(peer: _embedded): Sync<_embedded> {return {"peer": peer};} + +export function asPacket<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): Packet<_embedded> { + let result = toPacket(v); + if (result === void 0) throw new TypeError(`Invalid Packet: ${_.stringify(v)}`); + return result; +} + +export function toPacket<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | Packet<_embedded> { + let _tmp0: (Turn<_embedded>) | undefined; + let result: undefined | Packet<_embedded>; + _tmp0 = toTurn(v); + if (_tmp0 !== void 0) {result = {"_variant": "Turn", "value": _tmp0};}; + if (result === void 0) { + let _tmp1: (Error<_embedded>) | undefined; + _tmp1 = toError(v); + if (_tmp1 !== void 0) {result = {"_variant": "Error", "value": _tmp1};}; + }; + return result; +} + +export function fromPacket<_embedded = _.GenericEmbedded>(_v: Packet<_embedded>): _.Value<_embedded> { + switch (_v._variant) { + case "Turn": {return fromTurn<_embedded>(_v.value);}; + case "Error": {return fromError<_embedded>(_v.value);}; + }; +} + +export function asError<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): Error<_embedded> { + let result = toError(v); + if (result === void 0) throw new TypeError(`Invalid Error: ${_.stringify(v)}`); + return result; +} + +export function toError<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | Error<_embedded> { + let result: undefined | Error<_embedded>; + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { + let _tmp0: (null) | undefined; + _tmp0 = _.is(v.label, $error) ? null : void 0; + if (_tmp0 !== void 0) { + let _tmp1: (string) | undefined; + _tmp1 = typeof v[0] === 'string' ? v[0] : void 0; + if (_tmp1 !== void 0) { + let _tmp2: (_.Value<_embedded>) | undefined; + _tmp2 = v[1]; + if (_tmp2 !== void 0) {result = {"message": _tmp1, "detail": _tmp2};}; + }; + }; + }; + return result; +} + +export function fromError<_embedded = _.GenericEmbedded>(_v: Error<_embedded>): _.Value<_embedded> {return _.Record($error, [_v["message"], _v["detail"]]);} + +export function asAssertion<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): Assertion<_embedded> { + let result = toAssertion(v); + if (result === void 0) throw new TypeError(`Invalid Assertion: ${_.stringify(v)}`); + return result; +} + +export function toAssertion<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | Assertion<_embedded> { + let _tmp0: (_.Value<_embedded>) | undefined; + let result: undefined | Assertion<_embedded>; + _tmp0 = v; + if (_tmp0 !== void 0) {result = _tmp0;}; + return result; +} + +export function fromAssertion<_embedded = _.GenericEmbedded>(_v: Assertion<_embedded>): _.Value<_embedded> {return _v;} + +export function asHandle<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): Handle { + let result = toHandle(v); + if (result === void 0) throw new TypeError(`Invalid Handle: ${_.stringify(v)}`); + return result; +} + +export function toHandle<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | Handle { + let _tmp0: (number) | undefined; + let result: undefined | Handle; + _tmp0 = typeof v === 'number' ? v : void 0; + if (_tmp0 !== void 0) {result = _tmp0;}; + return result; +} + +export function fromHandle<_embedded = _.GenericEmbedded>(_v: Handle): _.Value<_embedded> {return _v;} + +export function asEvent<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): Event<_embedded> { + let result = toEvent(v); + if (result === void 0) throw new TypeError(`Invalid Event: ${_.stringify(v)}`); + return result; +} + +export function toEvent<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | Event<_embedded> { + let _tmp0: (Assert<_embedded>) | undefined; + let result: undefined | Event<_embedded>; + _tmp0 = toAssert(v); + if (_tmp0 !== void 0) {result = {"_variant": "Assert", "value": _tmp0};}; + if (result === void 0) { + let _tmp1: (Retract) | undefined; + _tmp1 = toRetract(v); + if (_tmp1 !== void 0) {result = {"_variant": "Retract", "value": _tmp1};}; + if (result === void 0) { + let _tmp2: (Message<_embedded>) | undefined; + _tmp2 = toMessage(v); + if (_tmp2 !== void 0) {result = {"_variant": "Message", "value": _tmp2};}; + if (result === void 0) { + let _tmp3: (Sync<_embedded>) | undefined; + _tmp3 = toSync(v); + if (_tmp3 !== void 0) {result = {"_variant": "Sync", "value": _tmp3};}; + }; + }; + }; + return result; +} + +export function fromEvent<_embedded = _.GenericEmbedded>(_v: Event<_embedded>): _.Value<_embedded> { + switch (_v._variant) { + case "Assert": {return fromAssert<_embedded>(_v.value);}; + case "Retract": {return fromRetract<_embedded>(_v.value);}; + case "Message": {return fromMessage<_embedded>(_v.value);}; + case "Sync": {return fromSync<_embedded>(_v.value);}; + }; +} + +export function asOid<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): Oid { + let result = toOid(v); + if (result === void 0) throw new TypeError(`Invalid Oid: ${_.stringify(v)}`); + return result; +} + +export function toOid<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | Oid { + let _tmp0: (number) | undefined; + let result: undefined | Oid; + _tmp0 = typeof v === 'number' ? v : void 0; + if (_tmp0 !== void 0) {result = _tmp0;}; + return result; +} + +export function fromOid<_embedded = _.GenericEmbedded>(_v: Oid): _.Value<_embedded> {return _v;} + +export function asTurn<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): Turn<_embedded> { + let result = toTurn(v); + if (result === void 0) throw new TypeError(`Invalid Turn: ${_.stringify(v)}`); + return result; +} + +export function toTurn<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | Turn<_embedded> { + let _tmp0: (Array>) | undefined; + let result: undefined | Turn<_embedded>; + _tmp0 = void 0; + if (_.Array.isArray(v)) { + _tmp0 = []; + for (const _tmp1 of v) { + let _tmp2: (TurnEvent<_embedded>) | undefined; + _tmp2 = toTurnEvent(_tmp1); + if (_tmp2 !== void 0) {_tmp0.push(_tmp2); continue;}; + _tmp0 = void 0; + break; + }; + }; + if (_tmp0 !== void 0) {result = _tmp0;}; + return result; +} + +export function fromTurn<_embedded = _.GenericEmbedded>(_v: Turn<_embedded>): _.Value<_embedded> {return _v.map(v => fromTurnEvent<_embedded>(v));} + +export function asTurnEvent<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): TurnEvent<_embedded> { + let result = toTurnEvent(v); + if (result === void 0) throw new TypeError(`Invalid TurnEvent: ${_.stringify(v)}`); + return result; +} + +export function toTurnEvent<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | TurnEvent<_embedded> { + let result: undefined | TurnEvent<_embedded>; + if (_.Array.isArray(v) && v.length === 2) { + let _tmp0: (Oid) | undefined; + _tmp0 = toOid(v[0]); + if (_tmp0 !== void 0) { + let _tmp1: (Event<_embedded>) | undefined; + _tmp1 = toEvent(v[1]); + if (_tmp1 !== void 0) {result = {"oid": _tmp0, "event": _tmp1};}; + }; + }; + return result; +} + +export function fromTurnEvent<_embedded = _.GenericEmbedded>(_v: TurnEvent<_embedded>): _.Value<_embedded> {return [fromOid<_embedded>(_v["oid"]), fromEvent<_embedded>(_v["event"])];} + +export function asAssert<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): Assert<_embedded> { + let result = toAssert(v); + if (result === void 0) throw new TypeError(`Invalid Assert: ${_.stringify(v)}`); + return result; +} + +export function toAssert<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | Assert<_embedded> { + let result: undefined | Assert<_embedded>; + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { + let _tmp0: (null) | undefined; + _tmp0 = _.is(v.label, $assert) ? null : void 0; + if (_tmp0 !== void 0) { + let _tmp1: (Assertion<_embedded>) | undefined; + _tmp1 = toAssertion(v[0]); + if (_tmp1 !== void 0) { + let _tmp2: (Handle) | undefined; + _tmp2 = toHandle(v[1]); + if (_tmp2 !== void 0) {result = {"assertion": _tmp1, "handle": _tmp2};}; + }; + }; + }; + return result; +} + +export function fromAssert<_embedded = _.GenericEmbedded>(_v: Assert<_embedded>): _.Value<_embedded> { + return _.Record( + $assert, + [fromAssertion<_embedded>(_v["assertion"]), fromHandle<_embedded>(_v["handle"])] + ); +} + +export function asRetract<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): Retract { + let result = toRetract(v); + if (result === void 0) throw new TypeError(`Invalid Retract: ${_.stringify(v)}`); + return result; +} + +export function toRetract<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | Retract { + let result: undefined | Retract; + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { + let _tmp0: (null) | undefined; + _tmp0 = _.is(v.label, $retract) ? null : void 0; + if (_tmp0 !== void 0) { + let _tmp1: (Handle) | undefined; + _tmp1 = toHandle(v[0]); + if (_tmp1 !== void 0) {result = {"handle": _tmp1};}; + }; + }; + return result; +} + +export function fromRetract<_embedded = _.GenericEmbedded>(_v: Retract): _.Value<_embedded> {return _.Record($retract, [fromHandle<_embedded>(_v["handle"])]);} + +export function asMessage<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): Message<_embedded> { + let result = toMessage(v); + if (result === void 0) throw new TypeError(`Invalid Message: ${_.stringify(v)}`); + return result; +} + +export function toMessage<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | Message<_embedded> { + let result: undefined | Message<_embedded>; + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { + let _tmp0: (null) | undefined; + _tmp0 = _.is(v.label, $message) ? null : void 0; + if (_tmp0 !== void 0) { + let _tmp1: (Assertion<_embedded>) | undefined; + _tmp1 = toAssertion(v[0]); + if (_tmp1 !== void 0) {result = {"body": _tmp1};}; + }; + }; + return result; +} + +export function fromMessage<_embedded = _.GenericEmbedded>(_v: Message<_embedded>): _.Value<_embedded> {return _.Record($message, [fromAssertion<_embedded>(_v["body"])]);} + +export function asSync<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): Sync<_embedded> { + let result = toSync(v); + if (result === void 0) throw new TypeError(`Invalid Sync: ${_.stringify(v)}`); + return result; +} + +export function toSync<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | Sync<_embedded> { + let result: undefined | Sync<_embedded>; + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { + let _tmp0: (null) | undefined; + _tmp0 = _.is(v.label, $sync) ? null : void 0; + if (_tmp0 !== void 0) { + let _tmp1: (_embedded) | undefined; + _tmp1 = _.isEmbedded<_embedded>(v[0]) ? v[0].embeddedValue : void 0; + if (_tmp1 !== void 0) {result = {"peer": _tmp1};}; + }; + }; + return result; +} + +export function fromSync<_embedded = _.GenericEmbedded>(_v: Sync<_embedded>): _.Value<_embedded> {return _.Record($sync, [_.embed(_v["peer"])]);} + diff --git a/src/gen/internalProtocol.ts b/src/gen/internalProtocol.ts new file mode 100644 index 0000000..e162370 --- /dev/null +++ b/src/gen/internalProtocol.ts @@ -0,0 +1,359 @@ +import * as _ from "@preserves/core"; +import * as _i_EntityRef from "../runtime/actor"; + +export const $assert = Symbol.for("assert"); +export const $error = Symbol.for("error"); +export const $message = Symbol.for("message"); +export const $retract = Symbol.for("retract"); +export const $sync = Symbol.for("sync"); + +export type _embedded = _i_EntityRef.Ref; + +export type Packet<_embedded = _i_EntityRef.Ref> = ( + {"_variant": "Turn", "value": Turn<_embedded>} | + {"_variant": "Error", "value": Error<_embedded>} +); + +export type Error<_embedded = _i_EntityRef.Ref> = {"message": string, "detail": _.Value<_embedded>}; + +export type Assertion<_embedded = _i_EntityRef.Ref> = _.Value<_embedded>; + +export type Handle = number; + +export type Event<_embedded = _i_EntityRef.Ref> = ( + {"_variant": "Assert", "value": Assert<_embedded>} | + {"_variant": "Retract", "value": Retract} | + {"_variant": "Message", "value": Message<_embedded>} | + {"_variant": "Sync", "value": Sync<_embedded>} +); + +export type Oid = number; + +export type Turn<_embedded = _i_EntityRef.Ref> = Array>; + +export type TurnEvent<_embedded = _i_EntityRef.Ref> = {"oid": Oid, "event": Event<_embedded>}; + +export type Assert<_embedded = _i_EntityRef.Ref> = {"assertion": Assertion<_embedded>, "handle": Handle}; + +export type Retract = {"handle": Handle}; + +export type Message<_embedded = _i_EntityRef.Ref> = {"body": Assertion<_embedded>}; + +export type Sync<_embedded = _i_EntityRef.Ref> = {"peer": _embedded}; + + +export namespace Packet { + export function Turn<_embedded = _i_EntityRef.Ref>(value: Turn<_embedded>): Packet<_embedded> {return {"_variant": "Turn", "value": value};}; + export function Error<_embedded = _i_EntityRef.Ref>(value: Error<_embedded>): Packet<_embedded> {return {"_variant": "Error", "value": value};}; +} + +export function Error<_embedded = _i_EntityRef.Ref>({message, detail}: {message: string, detail: _.Value<_embedded>}): Error<_embedded> {return {"message": message, "detail": detail};} + +export function Assertion<_embedded = _i_EntityRef.Ref>(value: _.Value<_embedded>): Assertion<_embedded> {return value;} + +export function Handle(value: number): Handle {return value;} + +export namespace Event { + export function Assert<_embedded = _i_EntityRef.Ref>(value: Assert<_embedded>): Event<_embedded> {return {"_variant": "Assert", "value": value};}; + export function Retract<_embedded = _i_EntityRef.Ref>(value: Retract): Event<_embedded> {return {"_variant": "Retract", "value": value};}; + export function Message<_embedded = _i_EntityRef.Ref>(value: Message<_embedded>): Event<_embedded> {return {"_variant": "Message", "value": value};}; + export function Sync<_embedded = _i_EntityRef.Ref>(value: Sync<_embedded>): Event<_embedded> {return {"_variant": "Sync", "value": value};}; +} + +export function Oid(value: number): Oid {return value;} + +export function Turn<_embedded = _i_EntityRef.Ref>(value: Array>): Turn<_embedded> {return value;} + +export function TurnEvent<_embedded = _i_EntityRef.Ref>({oid, event}: {oid: Oid, event: Event<_embedded>}): TurnEvent<_embedded> {return {"oid": oid, "event": event};} + +export function Assert<_embedded = _i_EntityRef.Ref>({assertion, handle}: {assertion: Assertion<_embedded>, handle: Handle}): Assert<_embedded> {return {"assertion": assertion, "handle": handle};} + +export function Retract(handle: Handle): Retract {return {"handle": handle};} + +export function Message<_embedded = _i_EntityRef.Ref>(body: Assertion<_embedded>): Message<_embedded> {return {"body": body};} + +export function Sync<_embedded = _i_EntityRef.Ref>(peer: _embedded): Sync<_embedded> {return {"peer": peer};} + +export function asPacket<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): Packet<_embedded> { + let result = toPacket(v); + if (result === void 0) throw new TypeError(`Invalid Packet: ${_.stringify(v)}`); + return result; +} + +export function toPacket<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | Packet<_embedded> { + let _tmp0: (Turn<_embedded>) | undefined; + let result: undefined | Packet<_embedded>; + _tmp0 = toTurn(v); + if (_tmp0 !== void 0) {result = {"_variant": "Turn", "value": _tmp0};}; + if (result === void 0) { + let _tmp1: (Error<_embedded>) | undefined; + _tmp1 = toError(v); + if (_tmp1 !== void 0) {result = {"_variant": "Error", "value": _tmp1};}; + }; + return result; +} + +export function fromPacket<_embedded = _i_EntityRef.Ref>(_v: Packet<_embedded>): _.Value<_embedded> { + switch (_v._variant) { + case "Turn": {return fromTurn<_embedded>(_v.value);}; + case "Error": {return fromError<_embedded>(_v.value);}; + }; +} + +export function asError<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): Error<_embedded> { + let result = toError(v); + if (result === void 0) throw new TypeError(`Invalid Error: ${_.stringify(v)}`); + return result; +} + +export function toError<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | Error<_embedded> { + let result: undefined | Error<_embedded>; + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { + let _tmp0: (null) | undefined; + _tmp0 = _.is(v.label, $error) ? null : void 0; + if (_tmp0 !== void 0) { + let _tmp1: (string) | undefined; + _tmp1 = typeof v[0] === 'string' ? v[0] : void 0; + if (_tmp1 !== void 0) { + let _tmp2: (_.Value<_embedded>) | undefined; + _tmp2 = v[1]; + if (_tmp2 !== void 0) {result = {"message": _tmp1, "detail": _tmp2};}; + }; + }; + }; + return result; +} + +export function fromError<_embedded = _i_EntityRef.Ref>(_v: Error<_embedded>): _.Value<_embedded> {return _.Record($error, [_v["message"], _v["detail"]]);} + +export function asAssertion<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): Assertion<_embedded> { + let result = toAssertion(v); + if (result === void 0) throw new TypeError(`Invalid Assertion: ${_.stringify(v)}`); + return result; +} + +export function toAssertion<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | Assertion<_embedded> { + let _tmp0: (_.Value<_embedded>) | undefined; + let result: undefined | Assertion<_embedded>; + _tmp0 = v; + if (_tmp0 !== void 0) {result = _tmp0;}; + return result; +} + +export function fromAssertion<_embedded = _i_EntityRef.Ref>(_v: Assertion<_embedded>): _.Value<_embedded> {return _v;} + +export function asHandle<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): Handle { + let result = toHandle(v); + if (result === void 0) throw new TypeError(`Invalid Handle: ${_.stringify(v)}`); + return result; +} + +export function toHandle<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | Handle { + let _tmp0: (number) | undefined; + let result: undefined | Handle; + _tmp0 = typeof v === 'number' ? v : void 0; + if (_tmp0 !== void 0) {result = _tmp0;}; + return result; +} + +export function fromHandle<_embedded = _i_EntityRef.Ref>(_v: Handle): _.Value<_embedded> {return _v;} + +export function asEvent<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): Event<_embedded> { + let result = toEvent(v); + if (result === void 0) throw new TypeError(`Invalid Event: ${_.stringify(v)}`); + return result; +} + +export function toEvent<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | Event<_embedded> { + let _tmp0: (Assert<_embedded>) | undefined; + let result: undefined | Event<_embedded>; + _tmp0 = toAssert(v); + if (_tmp0 !== void 0) {result = {"_variant": "Assert", "value": _tmp0};}; + if (result === void 0) { + let _tmp1: (Retract) | undefined; + _tmp1 = toRetract(v); + if (_tmp1 !== void 0) {result = {"_variant": "Retract", "value": _tmp1};}; + if (result === void 0) { + let _tmp2: (Message<_embedded>) | undefined; + _tmp2 = toMessage(v); + if (_tmp2 !== void 0) {result = {"_variant": "Message", "value": _tmp2};}; + if (result === void 0) { + let _tmp3: (Sync<_embedded>) | undefined; + _tmp3 = toSync(v); + if (_tmp3 !== void 0) {result = {"_variant": "Sync", "value": _tmp3};}; + }; + }; + }; + return result; +} + +export function fromEvent<_embedded = _i_EntityRef.Ref>(_v: Event<_embedded>): _.Value<_embedded> { + switch (_v._variant) { + case "Assert": {return fromAssert<_embedded>(_v.value);}; + case "Retract": {return fromRetract<_embedded>(_v.value);}; + case "Message": {return fromMessage<_embedded>(_v.value);}; + case "Sync": {return fromSync<_embedded>(_v.value);}; + }; +} + +export function asOid<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): Oid { + let result = toOid(v); + if (result === void 0) throw new TypeError(`Invalid Oid: ${_.stringify(v)}`); + return result; +} + +export function toOid<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | Oid { + let _tmp0: (number) | undefined; + let result: undefined | Oid; + _tmp0 = typeof v === 'number' ? v : void 0; + if (_tmp0 !== void 0) {result = _tmp0;}; + return result; +} + +export function fromOid<_embedded = _i_EntityRef.Ref>(_v: Oid): _.Value<_embedded> {return _v;} + +export function asTurn<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): Turn<_embedded> { + let result = toTurn(v); + if (result === void 0) throw new TypeError(`Invalid Turn: ${_.stringify(v)}`); + return result; +} + +export function toTurn<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | Turn<_embedded> { + let _tmp0: (Array>) | undefined; + let result: undefined | Turn<_embedded>; + _tmp0 = void 0; + if (_.Array.isArray(v)) { + _tmp0 = []; + for (const _tmp1 of v) { + let _tmp2: (TurnEvent<_embedded>) | undefined; + _tmp2 = toTurnEvent(_tmp1); + if (_tmp2 !== void 0) {_tmp0.push(_tmp2); continue;}; + _tmp0 = void 0; + break; + }; + }; + if (_tmp0 !== void 0) {result = _tmp0;}; + return result; +} + +export function fromTurn<_embedded = _i_EntityRef.Ref>(_v: Turn<_embedded>): _.Value<_embedded> {return _v.map(v => fromTurnEvent<_embedded>(v));} + +export function asTurnEvent<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): TurnEvent<_embedded> { + let result = toTurnEvent(v); + if (result === void 0) throw new TypeError(`Invalid TurnEvent: ${_.stringify(v)}`); + return result; +} + +export function toTurnEvent<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | TurnEvent<_embedded> { + let result: undefined | TurnEvent<_embedded>; + if (_.Array.isArray(v) && v.length === 2) { + let _tmp0: (Oid) | undefined; + _tmp0 = toOid(v[0]); + if (_tmp0 !== void 0) { + let _tmp1: (Event<_embedded>) | undefined; + _tmp1 = toEvent(v[1]); + if (_tmp1 !== void 0) {result = {"oid": _tmp0, "event": _tmp1};}; + }; + }; + return result; +} + +export function fromTurnEvent<_embedded = _i_EntityRef.Ref>(_v: TurnEvent<_embedded>): _.Value<_embedded> {return [fromOid<_embedded>(_v["oid"]), fromEvent<_embedded>(_v["event"])];} + +export function asAssert<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): Assert<_embedded> { + let result = toAssert(v); + if (result === void 0) throw new TypeError(`Invalid Assert: ${_.stringify(v)}`); + return result; +} + +export function toAssert<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | Assert<_embedded> { + let result: undefined | Assert<_embedded>; + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { + let _tmp0: (null) | undefined; + _tmp0 = _.is(v.label, $assert) ? null : void 0; + if (_tmp0 !== void 0) { + let _tmp1: (Assertion<_embedded>) | undefined; + _tmp1 = toAssertion(v[0]); + if (_tmp1 !== void 0) { + let _tmp2: (Handle) | undefined; + _tmp2 = toHandle(v[1]); + if (_tmp2 !== void 0) {result = {"assertion": _tmp1, "handle": _tmp2};}; + }; + }; + }; + return result; +} + +export function fromAssert<_embedded = _i_EntityRef.Ref>(_v: Assert<_embedded>): _.Value<_embedded> { + return _.Record( + $assert, + [fromAssertion<_embedded>(_v["assertion"]), fromHandle<_embedded>(_v["handle"])] + ); +} + +export function asRetract<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): Retract { + let result = toRetract(v); + if (result === void 0) throw new TypeError(`Invalid Retract: ${_.stringify(v)}`); + return result; +} + +export function toRetract<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | Retract { + let result: undefined | Retract; + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { + let _tmp0: (null) | undefined; + _tmp0 = _.is(v.label, $retract) ? null : void 0; + if (_tmp0 !== void 0) { + let _tmp1: (Handle) | undefined; + _tmp1 = toHandle(v[0]); + if (_tmp1 !== void 0) {result = {"handle": _tmp1};}; + }; + }; + return result; +} + +export function fromRetract<_embedded = _i_EntityRef.Ref>(_v: Retract): _.Value<_embedded> {return _.Record($retract, [fromHandle<_embedded>(_v["handle"])]);} + +export function asMessage<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): Message<_embedded> { + let result = toMessage(v); + if (result === void 0) throw new TypeError(`Invalid Message: ${_.stringify(v)}`); + return result; +} + +export function toMessage<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | Message<_embedded> { + let result: undefined | Message<_embedded>; + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { + let _tmp0: (null) | undefined; + _tmp0 = _.is(v.label, $message) ? null : void 0; + if (_tmp0 !== void 0) { + let _tmp1: (Assertion<_embedded>) | undefined; + _tmp1 = toAssertion(v[0]); + if (_tmp1 !== void 0) {result = {"body": _tmp1};}; + }; + }; + return result; +} + +export function fromMessage<_embedded = _i_EntityRef.Ref>(_v: Message<_embedded>): _.Value<_embedded> {return _.Record($message, [fromAssertion<_embedded>(_v["body"])]);} + +export function asSync<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): Sync<_embedded> { + let result = toSync(v); + if (result === void 0) throw new TypeError(`Invalid Sync: ${_.stringify(v)}`); + return result; +} + +export function toSync<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | Sync<_embedded> { + let result: undefined | Sync<_embedded>; + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { + let _tmp0: (null) | undefined; + _tmp0 = _.is(v.label, $sync) ? null : void 0; + if (_tmp0 !== void 0) { + let _tmp1: (_embedded) | undefined; + _tmp1 = _.isEmbedded<_embedded>(v[0]) ? v[0].embeddedValue : void 0; + if (_tmp1 !== void 0) {result = {"peer": _tmp1};}; + }; + }; + return result; +} + +export function fromSync<_embedded = _i_EntityRef.Ref>(_v: Sync<_embedded>): _.Value<_embedded> {return _.Record($sync, [_.embed(_v["peer"])]);} + diff --git a/src/gen/protocol.ts b/src/gen/protocol.ts deleted file mode 100644 index b38acbc..0000000 --- a/src/gen/protocol.ts +++ /dev/null @@ -1,291 +0,0 @@ -import * as _ from "@preserves/core"; -import * as _i_sturdy from "./sturdy"; - -export const $assert = Symbol.for("assert"); -export const $message = Symbol.for("message"); -export const $retract = Symbol.for("retract"); -export const $sync = Symbol.for("sync"); - -export type _embedded = _i_sturdy.WireRef; - -export type _val = _.Value<_embedded>; - -export type Assertion = _val; - -export type Handle = number; - -export type Event = ( - {"_variant": "Assert", "value": Assert} | - {"_variant": "Retract", "value": Retract} | - {"_variant": "Message", "value": Message} | - {"_variant": "Sync", "value": Sync} -); - -export type Oid = number; - -export type Turn = Array; - -export type TurnEvent = {"oid": Oid, "event": Event}; - -export type Assert = {"assertion": Assertion, "handle": Handle}; - -export type Retract = {"handle": Handle}; - -export type Message = {"body": Assertion}; - -export type Sync = {"peer": _embedded}; - - -export function Assertion(value: _val): Assertion {return value;} - -export function Handle(value: number): Handle {return value;} - -export namespace Event { - export function Assert(value: Assert): Event {return {"_variant": "Assert", "value": value};}; - export function Retract(value: Retract): Event {return {"_variant": "Retract", "value": value};}; - export function Message(value: Message): Event {return {"_variant": "Message", "value": value};}; - export function Sync(value: Sync): Event {return {"_variant": "Sync", "value": value};}; -} - -export function Oid(value: number): Oid {return value;} - -export function Turn(value: Array): Turn {return value;} - -export function TurnEvent({oid, event}: {oid: Oid, event: Event}): TurnEvent {return {"oid": oid, "event": event};} - -export function Assert({assertion, handle}: {assertion: Assertion, handle: Handle}): Assert {return {"assertion": assertion, "handle": handle};} - -export function Retract(handle: Handle): Retract {return {"handle": handle};} - -export function Message(body: Assertion): Message {return {"body": body};} - -export function Sync(peer: _embedded): Sync {return {"peer": peer};} - -export function asAssertion(v: _val): Assertion { - let result = toAssertion(v); - if (result === void 0) throw new TypeError(`Invalid Assertion: ${_.stringify(v)}`); - return result; -} - -export function toAssertion(v: _val): undefined | Assertion { - let _tmp0: (_val) | undefined; - let result: undefined | Assertion; - _tmp0 = v; - if (_tmp0 !== void 0) {result = _tmp0;}; - return result; -} - -export function fromAssertion(_v: Assertion): _val {return _v;} - -export function asHandle(v: _val): Handle { - let result = toHandle(v); - if (result === void 0) throw new TypeError(`Invalid Handle: ${_.stringify(v)}`); - return result; -} - -export function toHandle(v: _val): undefined | Handle { - let _tmp0: (number) | undefined; - let result: undefined | Handle; - _tmp0 = typeof v === 'number' ? v : void 0; - if (_tmp0 !== void 0) {result = _tmp0;}; - return result; -} - -export function fromHandle(_v: Handle): _val {return _v;} - -export function asEvent(v: _val): Event { - let result = toEvent(v); - if (result === void 0) throw new TypeError(`Invalid Event: ${_.stringify(v)}`); - return result; -} - -export function toEvent(v: _val): undefined | Event { - let _tmp0: (Assert) | undefined; - let result: undefined | Event; - _tmp0 = toAssert(v); - if (_tmp0 !== void 0) {result = {"_variant": "Assert", "value": _tmp0};}; - if (result === void 0) { - let _tmp1: (Retract) | undefined; - _tmp1 = toRetract(v); - if (_tmp1 !== void 0) {result = {"_variant": "Retract", "value": _tmp1};}; - if (result === void 0) { - let _tmp2: (Message) | undefined; - _tmp2 = toMessage(v); - if (_tmp2 !== void 0) {result = {"_variant": "Message", "value": _tmp2};}; - if (result === void 0) { - let _tmp3: (Sync) | undefined; - _tmp3 = toSync(v); - if (_tmp3 !== void 0) {result = {"_variant": "Sync", "value": _tmp3};}; - }; - }; - }; - return result; -} - -export function fromEvent(_v: Event): _val { - switch (_v._variant) { - case "Assert": {return fromAssert(_v.value);}; - case "Retract": {return fromRetract(_v.value);}; - case "Message": {return fromMessage(_v.value);}; - case "Sync": {return fromSync(_v.value);}; - }; -} - -export function asOid(v: _val): Oid { - let result = toOid(v); - if (result === void 0) throw new TypeError(`Invalid Oid: ${_.stringify(v)}`); - return result; -} - -export function toOid(v: _val): undefined | Oid { - let _tmp0: (number) | undefined; - let result: undefined | Oid; - _tmp0 = typeof v === 'number' ? v : void 0; - if (_tmp0 !== void 0) {result = _tmp0;}; - return result; -} - -export function fromOid(_v: Oid): _val {return _v;} - -export function asTurn(v: _val): Turn { - let result = toTurn(v); - if (result === void 0) throw new TypeError(`Invalid Turn: ${_.stringify(v)}`); - return result; -} - -export function toTurn(v: _val): undefined | Turn { - let _tmp0: (Array) | undefined; - let result: undefined | Turn; - _tmp0 = void 0; - if (_.Array.isArray(v)) { - _tmp0 = []; - for (const _tmp1 of v) { - let _tmp2: (TurnEvent) | undefined; - _tmp2 = toTurnEvent(_tmp1); - if (_tmp2 !== void 0) {_tmp0.push(_tmp2); continue;}; - _tmp0 = void 0; - break; - }; - }; - if (_tmp0 !== void 0) {result = _tmp0;}; - return result; -} - -export function fromTurn(_v: Turn): _val {return _v.map(v => fromTurnEvent(v));} - -export function asTurnEvent(v: _val): TurnEvent { - let result = toTurnEvent(v); - if (result === void 0) throw new TypeError(`Invalid TurnEvent: ${_.stringify(v)}`); - return result; -} - -export function toTurnEvent(v: _val): undefined | TurnEvent { - let result: undefined | TurnEvent; - if (_.Array.isArray(v) && v.length === 2) { - let _tmp0: (Oid) | undefined; - _tmp0 = toOid(v[0]); - if (_tmp0 !== void 0) { - let _tmp1: (Event) | undefined; - _tmp1 = toEvent(v[1]); - if (_tmp1 !== void 0) {result = {"oid": _tmp0, "event": _tmp1};}; - }; - }; - return result; -} - -export function fromTurnEvent(_v: TurnEvent): _val {return [fromOid(_v["oid"]), fromEvent(_v["event"])];} - -export function asAssert(v: _val): Assert { - let result = toAssert(v); - if (result === void 0) throw new TypeError(`Invalid Assert: ${_.stringify(v)}`); - return result; -} - -export function toAssert(v: _val): undefined | Assert { - let result: undefined | Assert; - if (_.Record.isRecord<_val, _.Tuple<_val>, _embedded>(v)) { - let _tmp0: (null) | undefined; - _tmp0 = _.is(v.label, $assert) ? null : void 0; - if (_tmp0 !== void 0) { - let _tmp1: (Assertion) | undefined; - _tmp1 = toAssertion(v[0]); - if (_tmp1 !== void 0) { - let _tmp2: (Handle) | undefined; - _tmp2 = toHandle(v[1]); - if (_tmp2 !== void 0) {result = {"assertion": _tmp1, "handle": _tmp2};}; - }; - }; - }; - return result; -} - -export function fromAssert(_v: Assert): _val { - return _.Record($assert, [fromAssertion(_v["assertion"]), fromHandle(_v["handle"])]); -} - -export function asRetract(v: _val): Retract { - let result = toRetract(v); - if (result === void 0) throw new TypeError(`Invalid Retract: ${_.stringify(v)}`); - return result; -} - -export function toRetract(v: _val): undefined | Retract { - let result: undefined | Retract; - if (_.Record.isRecord<_val, _.Tuple<_val>, _embedded>(v)) { - let _tmp0: (null) | undefined; - _tmp0 = _.is(v.label, $retract) ? null : void 0; - if (_tmp0 !== void 0) { - let _tmp1: (Handle) | undefined; - _tmp1 = toHandle(v[0]); - if (_tmp1 !== void 0) {result = {"handle": _tmp1};}; - }; - }; - return result; -} - -export function fromRetract(_v: Retract): _val {return _.Record($retract, [fromHandle(_v["handle"])]);} - -export function asMessage(v: _val): Message { - let result = toMessage(v); - if (result === void 0) throw new TypeError(`Invalid Message: ${_.stringify(v)}`); - return result; -} - -export function toMessage(v: _val): undefined | Message { - let result: undefined | Message; - if (_.Record.isRecord<_val, _.Tuple<_val>, _embedded>(v)) { - let _tmp0: (null) | undefined; - _tmp0 = _.is(v.label, $message) ? null : void 0; - if (_tmp0 !== void 0) { - let _tmp1: (Assertion) | undefined; - _tmp1 = toAssertion(v[0]); - if (_tmp1 !== void 0) {result = {"body": _tmp1};}; - }; - }; - return result; -} - -export function fromMessage(_v: Message): _val {return _.Record($message, [fromAssertion(_v["body"])]);} - -export function asSync(v: _val): Sync { - let result = toSync(v); - if (result === void 0) throw new TypeError(`Invalid Sync: ${_.stringify(v)}`); - return result; -} - -export function toSync(v: _val): undefined | Sync { - let result: undefined | Sync; - if (_.Record.isRecord<_val, _.Tuple<_val>, _embedded>(v)) { - let _tmp0: (null) | undefined; - _tmp0 = _.is(v.label, $sync) ? null : void 0; - if (_tmp0 !== void 0) { - let _tmp1: (_embedded) | undefined; - _tmp1 = _.isEmbedded<_embedded>(v[0]) ? v[0].embeddedValue : void 0; - if (_tmp1 !== void 0) {result = {"peer": _tmp1};}; - }; - }; - return result; -} - -export function fromSync(_v: Sync): _val {return _.Record($sync, [_.embed(_v["peer"])]);} - diff --git a/src/gen/racketEvent.ts b/src/gen/racketEvent.ts new file mode 100644 index 0000000..080dbaf --- /dev/null +++ b/src/gen/racketEvent.ts @@ -0,0 +1,35 @@ +import * as _ from "@preserves/core"; + +export const __lit0 = Symbol.for("racket-event"); + +export type RacketEvent<_embedded = _.GenericEmbedded> = {"source": _embedded, "event": _embedded}; + + +export function RacketEvent<_embedded = _.GenericEmbedded>({source, event}: {source: _embedded, event: _embedded}): RacketEvent<_embedded> {return {"source": source, "event": event};} + +export function asRacketEvent<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): RacketEvent<_embedded> { + let result = toRacketEvent(v); + if (result === void 0) throw new TypeError(`Invalid RacketEvent: ${_.stringify(v)}`); + return result; +} + +export function toRacketEvent<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | RacketEvent<_embedded> { + let result: undefined | RacketEvent<_embedded>; + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { + let _tmp0: (null) | undefined; + _tmp0 = _.is(v.label, __lit0) ? null : void 0; + if (_tmp0 !== void 0) { + let _tmp1: (_embedded) | undefined; + _tmp1 = _.isEmbedded<_embedded>(v[0]) ? v[0].embeddedValue : void 0; + if (_tmp1 !== void 0) { + let _tmp2: (_embedded) | undefined; + _tmp2 = _.isEmbedded<_embedded>(v[1]) ? v[1].embeddedValue : void 0; + if (_tmp2 !== void 0) {result = {"source": _tmp1, "event": _tmp2};}; + }; + }; + }; + return result; +} + +export function fromRacketEvent<_embedded = _.GenericEmbedded>(_v: RacketEvent<_embedded>): _.Value<_embedded> {return _.Record(__lit0, [_.embed(_v["source"]), _.embed(_v["event"])]);} + diff --git a/src/gen/secure-chat-protocol.ts b/src/gen/secureChatProtocol.ts similarity index 58% rename from src/gen/secure-chat-protocol.ts rename to src/gen/secureChatProtocol.ts index f28555b..632969d 100644 --- a/src/gen/secure-chat-protocol.ts +++ b/src/gen/secureChatProtocol.ts @@ -1,5 +1,5 @@ import * as _ from "@preserves/core"; -import * as _i_Actor from "../runtime/actor"; +import * as _i_EntityRef from "../runtime/actor"; export const $Observe = Symbol.for("Observe"); export const $claimNick = Symbol.for("claimNick"); @@ -9,22 +9,20 @@ export const $says = Symbol.for("says"); export const $user = Symbol.for("user"); export const __lit5 = true; -export type _embedded = _i_Actor.Ref; - -export type _val = _.Value<_embedded>; +export type _embedded = _i_EntityRef.Ref; export type UserId = number; -export type Join = {"uid": UserId, "handle": _embedded}; +export type Join<_embedded = _i_EntityRef.Ref> = {"uid": UserId, "handle": _embedded}; -export type Session = ( +export type Session<_embedded = _i_EntityRef.Ref> = ( {"_variant": "observeUsers", "observer": _embedded} | {"_variant": "observeSpeech", "observer": _embedded} | - {"_variant": "NickClaim", "value": NickClaim} | + {"_variant": "NickClaim", "value": NickClaim<_embedded>} | {"_variant": "Says", "value": Says} ); -export type NickClaim = {"uid": UserId, "name": string, "k": _embedded}; +export type NickClaim<_embedded = _i_EntityRef.Ref> = {"uid": UserId, "name": string, "k": _embedded}; export type NickClaimResponse = ({"_variant": "true"} | {"_variant": "NickConflict", "value": NickConflict}); @@ -37,16 +35,16 @@ export type NickConflict = null; export function UserId(value: number): UserId {return value;} -export function Join({uid, handle}: {uid: UserId, handle: _embedded}): Join {return {"uid": uid, "handle": handle};} +export function Join<_embedded = _i_EntityRef.Ref>({uid, handle}: {uid: UserId, handle: _embedded}): Join<_embedded> {return {"uid": uid, "handle": handle};} export namespace Session { - export function observeUsers(observer: _embedded): Session {return {"_variant": "observeUsers", "observer": observer};}; - export function observeSpeech(observer: _embedded): Session {return {"_variant": "observeSpeech", "observer": observer};}; - export function NickClaim(value: NickClaim): Session {return {"_variant": "NickClaim", "value": value};}; - export function Says(value: Says): Session {return {"_variant": "Says", "value": value};}; + export function observeUsers<_embedded = _i_EntityRef.Ref>(observer: _embedded): Session<_embedded> {return {"_variant": "observeUsers", "observer": observer};}; + export function observeSpeech<_embedded = _i_EntityRef.Ref>(observer: _embedded): Session<_embedded> {return {"_variant": "observeSpeech", "observer": observer};}; + export function NickClaim<_embedded = _i_EntityRef.Ref>(value: NickClaim<_embedded>): Session<_embedded> {return {"_variant": "NickClaim", "value": value};}; + export function Says<_embedded = _i_EntityRef.Ref>(value: Says): Session<_embedded> {return {"_variant": "Says", "value": value};}; } -export function NickClaim({uid, name, k}: {uid: UserId, name: string, k: _embedded}): NickClaim {return {"uid": uid, "name": name, "k": k};} +export function NickClaim<_embedded = _i_EntityRef.Ref>({uid, name, k}: {uid: UserId, name: string, k: _embedded}): NickClaim<_embedded> {return {"uid": uid, "name": name, "k": k};} export namespace NickClaimResponse { export function $true(): NickClaimResponse {return {"_variant": "true"};}; @@ -59,13 +57,13 @@ export function Says({who, what}: {who: UserId, what: string}): Says {return {"w export function NickConflict(): NickConflict {return null;} -export function asUserId(v: _val): UserId { +export function asUserId<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): UserId { let result = toUserId(v); if (result === void 0) throw new TypeError(`Invalid UserId: ${_.stringify(v)}`); return result; } -export function toUserId(v: _val): undefined | UserId { +export function toUserId<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | UserId { let _tmp0: (number) | undefined; let result: undefined | UserId; _tmp0 = typeof v === 'number' ? v : void 0; @@ -73,17 +71,17 @@ export function toUserId(v: _val): undefined | UserId { return result; } -export function fromUserId(_v: UserId): _val {return _v;} +export function fromUserId<_embedded = _i_EntityRef.Ref>(_v: UserId): _.Value<_embedded> {return _v;} -export function asJoin(v: _val): Join { +export function asJoin<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): Join<_embedded> { let result = toJoin(v); if (result === void 0) throw new TypeError(`Invalid Join: ${_.stringify(v)}`); return result; } -export function toJoin(v: _val): undefined | Join { - let result: undefined | Join; - if (_.Record.isRecord<_val, _.Tuple<_val>, _embedded>(v)) { +export function toJoin<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | Join<_embedded> { + let result: undefined | Join<_embedded>; + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { let _tmp0: (null) | undefined; _tmp0 = _.is(v.label, $joinedUser) ? null : void 0; if (_tmp0 !== void 0) { @@ -99,17 +97,19 @@ export function toJoin(v: _val): undefined | Join { return result; } -export function fromJoin(_v: Join): _val {return _.Record($joinedUser, [fromUserId(_v["uid"]), _.embed(_v["handle"])]);} +export function fromJoin<_embedded = _i_EntityRef.Ref>(_v: Join<_embedded>): _.Value<_embedded> { + return _.Record($joinedUser, [fromUserId<_embedded>(_v["uid"]), _.embed(_v["handle"])]); +} -export function asSession(v: _val): Session { +export function asSession<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): Session<_embedded> { let result = toSession(v); if (result === void 0) throw new TypeError(`Invalid Session: ${_.stringify(v)}`); return result; } -export function toSession(v: _val): undefined | Session { - let result: undefined | Session; - if (_.Record.isRecord<_val, _.Tuple<_val>, _embedded>(v)) { +export function toSession<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | Session<_embedded> { + let result: undefined | Session<_embedded>; + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { let _tmp0: (null) | undefined; _tmp0 = _.is(v.label, $Observe) ? null : void 0; if (_tmp0 !== void 0) { @@ -123,7 +123,7 @@ export function toSession(v: _val): undefined | Session { }; }; if (result === void 0) { - if (_.Record.isRecord<_val, _.Tuple<_val>, _embedded>(v)) { + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { let _tmp3: (null) | undefined; _tmp3 = _.is(v.label, $Observe) ? null : void 0; if (_tmp3 !== void 0) { @@ -137,7 +137,7 @@ export function toSession(v: _val): undefined | Session { }; }; if (result === void 0) { - let _tmp6: (NickClaim) | undefined; + let _tmp6: (NickClaim<_embedded>) | undefined; _tmp6 = toNickClaim(v); if (_tmp6 !== void 0) {result = {"_variant": "NickClaim", "value": _tmp6};}; if (result === void 0) { @@ -150,24 +150,24 @@ export function toSession(v: _val): undefined | Session { return result; } -export function fromSession(_v: Session): _val { +export function fromSession<_embedded = _i_EntityRef.Ref>(_v: Session<_embedded>): _.Value<_embedded> { switch (_v._variant) { case "observeUsers": {return _.Record($Observe, [$user, _.embed(_v["observer"])]);}; case "observeSpeech": {return _.Record($Observe, [$says, _.embed(_v["observer"])]);}; - case "NickClaim": {return fromNickClaim(_v.value);}; - case "Says": {return fromSays(_v.value);}; + case "NickClaim": {return fromNickClaim<_embedded>(_v.value);}; + case "Says": {return fromSays<_embedded>(_v.value);}; }; } -export function asNickClaim(v: _val): NickClaim { +export function asNickClaim<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): NickClaim<_embedded> { let result = toNickClaim(v); if (result === void 0) throw new TypeError(`Invalid NickClaim: ${_.stringify(v)}`); return result; } -export function toNickClaim(v: _val): undefined | NickClaim { - let result: undefined | NickClaim; - if (_.Record.isRecord<_val, _.Tuple<_val>, _embedded>(v)) { +export function toNickClaim<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | NickClaim<_embedded> { + let result: undefined | NickClaim<_embedded>; + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { let _tmp0: (null) | undefined; _tmp0 = _.is(v.label, $claimNick) ? null : void 0; if (_tmp0 !== void 0) { @@ -187,17 +187,17 @@ export function toNickClaim(v: _val): undefined | NickClaim { return result; } -export function fromNickClaim(_v: NickClaim): _val { - return _.Record($claimNick, [fromUserId(_v["uid"]), _v["name"], _.embed(_v["k"])]); +export function fromNickClaim<_embedded = _i_EntityRef.Ref>(_v: NickClaim<_embedded>): _.Value<_embedded> { + return _.Record($claimNick, [fromUserId<_embedded>(_v["uid"]), _v["name"], _.embed(_v["k"])]); } -export function asNickClaimResponse(v: _val): NickClaimResponse { +export function asNickClaimResponse<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): NickClaimResponse { let result = toNickClaimResponse(v); if (result === void 0) throw new TypeError(`Invalid NickClaimResponse: ${_.stringify(v)}`); return result; } -export function toNickClaimResponse(v: _val): undefined | NickClaimResponse { +export function toNickClaimResponse<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | NickClaimResponse { let _tmp0: (null) | undefined; let result: undefined | NickClaimResponse; _tmp0 = _.is(v, __lit5) ? null : void 0; @@ -210,22 +210,22 @@ export function toNickClaimResponse(v: _val): undefined | NickClaimResponse { return result; } -export function fromNickClaimResponse(_v: NickClaimResponse): _val { +export function fromNickClaimResponse<_embedded = _i_EntityRef.Ref>(_v: NickClaimResponse): _.Value<_embedded> { switch (_v._variant) { case "true": {return __lit5;}; - case "NickConflict": {return fromNickConflict(_v.value);}; + case "NickConflict": {return fromNickConflict<_embedded>(_v.value);}; }; } -export function asUserInfo(v: _val): UserInfo { +export function asUserInfo<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): UserInfo { let result = toUserInfo(v); if (result === void 0) throw new TypeError(`Invalid UserInfo: ${_.stringify(v)}`); return result; } -export function toUserInfo(v: _val): undefined | UserInfo { +export function toUserInfo<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | UserInfo { let result: undefined | UserInfo; - if (_.Record.isRecord<_val, _.Tuple<_val>, _embedded>(v)) { + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { let _tmp0: (null) | undefined; _tmp0 = _.is(v.label, $user) ? null : void 0; if (_tmp0 !== void 0) { @@ -241,17 +241,17 @@ export function toUserInfo(v: _val): undefined | UserInfo { return result; } -export function fromUserInfo(_v: UserInfo): _val {return _.Record($user, [fromUserId(_v["uid"]), _v["name"]]);} +export function fromUserInfo<_embedded = _i_EntityRef.Ref>(_v: UserInfo): _.Value<_embedded> {return _.Record($user, [fromUserId<_embedded>(_v["uid"]), _v["name"]]);} -export function asSays(v: _val): Says { +export function asSays<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): Says { let result = toSays(v); if (result === void 0) throw new TypeError(`Invalid Says: ${_.stringify(v)}`); return result; } -export function toSays(v: _val): undefined | Says { +export function toSays<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | Says { let result: undefined | Says; - if (_.Record.isRecord<_val, _.Tuple<_val>, _embedded>(v)) { + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { let _tmp0: (null) | undefined; _tmp0 = _.is(v.label, $says) ? null : void 0; if (_tmp0 !== void 0) { @@ -267,17 +267,17 @@ export function toSays(v: _val): undefined | Says { return result; } -export function fromSays(_v: Says): _val {return _.Record($says, [fromUserId(_v["who"]), _v["what"]]);} +export function fromSays<_embedded = _i_EntityRef.Ref>(_v: Says): _.Value<_embedded> {return _.Record($says, [fromUserId<_embedded>(_v["who"]), _v["what"]]);} -export function asNickConflict(v: _val): NickConflict { +export function asNickConflict<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): NickConflict { let result = toNickConflict(v); if (result === void 0) throw new TypeError(`Invalid NickConflict: ${_.stringify(v)}`); return result; } -export function toNickConflict(v: _val): undefined | NickConflict { +export function toNickConflict<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | NickConflict { let result: undefined | NickConflict; - if (_.Record.isRecord<_val, _.Tuple<_val>, _embedded>(v)) { + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { let _tmp0: (null) | undefined; _tmp0 = _.is(v.label, $nickConflict) ? null : void 0; if (_tmp0 !== void 0) {result = null;}; @@ -285,5 +285,5 @@ export function toNickConflict(v: _val): undefined | NickConflict { return result; } -export function fromNickConflict(_v: NickConflict): _val {return _.Record($nickConflict, []);} +export function fromNickConflict<_embedded = _i_EntityRef.Ref>(_v: NickConflict): _.Value<_embedded> {return _.Record($nickConflict, []);} diff --git a/src/gen/service.ts b/src/gen/service.ts new file mode 100644 index 0000000..fe38a64 --- /dev/null +++ b/src/gen/service.ts @@ -0,0 +1,61 @@ +import * as _ from "@preserves/core"; +import * as _i_EntityRef from "../runtime/actor"; + +export const __lit0 = Symbol.for("require-service"); +export const __lit1 = Symbol.for("service-running"); + +export type _embedded = _i_EntityRef.Ref; + +export type RequireService<_embedded = _i_EntityRef.Ref> = {"serviceName": _.Value<_embedded>}; + +export type ServiceRunning<_embedded = _i_EntityRef.Ref> = {"serviceName": _.Value<_embedded>}; + + +export function RequireService<_embedded = _i_EntityRef.Ref>(serviceName: _.Value<_embedded>): RequireService<_embedded> {return {"serviceName": serviceName};} + +export function ServiceRunning<_embedded = _i_EntityRef.Ref>(serviceName: _.Value<_embedded>): ServiceRunning<_embedded> {return {"serviceName": serviceName};} + +export function asRequireService<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): RequireService<_embedded> { + let result = toRequireService(v); + if (result === void 0) throw new TypeError(`Invalid RequireService: ${_.stringify(v)}`); + return result; +} + +export function toRequireService<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | RequireService<_embedded> { + let result: undefined | RequireService<_embedded>; + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { + let _tmp0: (null) | undefined; + _tmp0 = _.is(v.label, __lit0) ? null : void 0; + if (_tmp0 !== void 0) { + let _tmp1: (_.Value<_embedded>) | undefined; + _tmp1 = v[0]; + if (_tmp1 !== void 0) {result = {"serviceName": _tmp1};}; + }; + }; + return result; +} + +export function fromRequireService<_embedded = _i_EntityRef.Ref>(_v: RequireService<_embedded>): _.Value<_embedded> {return _.Record(__lit0, [_v["serviceName"]]);} + +export function asServiceRunning<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): ServiceRunning<_embedded> { + let result = toServiceRunning(v); + if (result === void 0) throw new TypeError(`Invalid ServiceRunning: ${_.stringify(v)}`); + return result; +} + +export function toServiceRunning<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | ServiceRunning<_embedded> { + let result: undefined | ServiceRunning<_embedded>; + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { + let _tmp0: (null) | undefined; + _tmp0 = _.is(v.label, __lit1) ? null : void 0; + if (_tmp0 !== void 0) { + let _tmp1: (_.Value<_embedded>) | undefined; + _tmp1 = v[0]; + if (_tmp1 !== void 0) {result = {"serviceName": _tmp1};}; + }; + }; + return result; +} + +export function fromServiceRunning<_embedded = _i_EntityRef.Ref>(_v: ServiceRunning<_embedded>): _.Value<_embedded> {return _.Record(__lit1, [_v["serviceName"]]);} + diff --git a/src/gen/simple-chat-protocol.ts b/src/gen/simpleChatProtocol.ts similarity index 63% rename from src/gen/simple-chat-protocol.ts rename to src/gen/simpleChatProtocol.ts index 323a8ee..8e3b342 100644 --- a/src/gen/simple-chat-protocol.ts +++ b/src/gen/simpleChatProtocol.ts @@ -1,12 +1,10 @@ import * as _ from "@preserves/core"; -import * as _i_Actor from "../runtime/actor"; +import * as _i_EntityRef from "../runtime/actor"; export const $Present = Symbol.for("Present"); export const $Says = Symbol.for("Says"); -export type _embedded = _i_Actor.Ref; - -export type _val = _.Value<_embedded>; +export type _embedded = _i_EntityRef.Ref; export type Present = {"username": string}; @@ -17,15 +15,15 @@ export function Present(username: string): Present {return {"username": username export function Says({who, what}: {who: string, what: string}): Says {return {"who": who, "what": what};} -export function asPresent(v: _val): Present { +export function asPresent<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): Present { let result = toPresent(v); if (result === void 0) throw new TypeError(`Invalid Present: ${_.stringify(v)}`); return result; } -export function toPresent(v: _val): undefined | Present { +export function toPresent<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | Present { let result: undefined | Present; - if (_.Record.isRecord<_val, _.Tuple<_val>, _embedded>(v)) { + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { let _tmp0: (null) | undefined; _tmp0 = _.is(v.label, $Present) ? null : void 0; if (_tmp0 !== void 0) { @@ -37,17 +35,17 @@ export function toPresent(v: _val): undefined | Present { return result; } -export function fromPresent(_v: Present): _val {return _.Record($Present, [_v["username"]]);} +export function fromPresent<_embedded = _i_EntityRef.Ref>(_v: Present): _.Value<_embedded> {return _.Record($Present, [_v["username"]]);} -export function asSays(v: _val): Says { +export function asSays<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): Says { let result = toSays(v); if (result === void 0) throw new TypeError(`Invalid Says: ${_.stringify(v)}`); return result; } -export function toSays(v: _val): undefined | Says { +export function toSays<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | Says { let result: undefined | Says; - if (_.Record.isRecord<_val, _.Tuple<_val>, _embedded>(v)) { + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { let _tmp0: (null) | undefined; _tmp0 = _.is(v.label, $Says) ? null : void 0; if (_tmp0 !== void 0) { @@ -63,5 +61,5 @@ export function toSays(v: _val): undefined | Says { return result; } -export function fromSays(_v: Says): _val {return _.Record($Says, [_v["who"], _v["what"]]);} +export function fromSays<_embedded = _i_EntityRef.Ref>(_v: Says): _.Value<_embedded> {return _.Record($Says, [_v["who"], _v["what"]]);} diff --git a/src/gen/stream.ts b/src/gen/stream.ts new file mode 100644 index 0000000..c0fa60b --- /dev/null +++ b/src/gen/stream.ts @@ -0,0 +1,401 @@ +import * as _ from "@preserves/core"; +import * as _i_EntityRef from "../runtime/actor"; + +export const $bytes = Symbol.for("bytes"); +export const $credit = Symbol.for("credit"); +export const $crlf = Symbol.for("crlf"); +export const $data = Symbol.for("data"); +export const $eof = Symbol.for("eof"); +export const $error = Symbol.for("error"); +export const $lf = Symbol.for("lf"); +export const $object = Symbol.for("object"); +export const $packet = Symbol.for("packet"); +export const $sink = Symbol.for("sink"); +export const $source = Symbol.for("source"); +export const $unbounded = Symbol.for("unbounded"); +export const __lit0 = Symbol.for("stream-connection"); +export const __lit1 = Symbol.for("stream-listener-ready"); +export const __lit2 = Symbol.for("stream-listener-error"); + +export type _embedded = _i_EntityRef.Ref; + +export type StreamConnection<_embedded = _i_EntityRef.Ref> = {"source": _embedded, "sink": _embedded, "spec": _.Value<_embedded>}; + +export type StreamListenerReady<_embedded = _i_EntityRef.Ref> = {"spec": _.Value<_embedded>}; + +export type StreamListenerError<_embedded = _i_EntityRef.Ref> = {"spec": _.Value<_embedded>, "message": string}; + +export type StreamError = {"message": string}; + +export type Source<_embedded = _i_EntityRef.Ref> = ( + {"_variant": "sink", "controller": _embedded} | + {"_variant": "StreamError", "value": StreamError} | + {"_variant": "credit", "amount": CreditAmount, "mode": Mode<_embedded>} +); + +export type Sink<_embedded = _i_EntityRef.Ref> = ( + {"_variant": "source", "controller": _embedded} | + {"_variant": "StreamError", "value": StreamError} | + {"_variant": "data", "payload": _.Value<_embedded>, "mode": Mode<_embedded>} | + {"_variant": "eof"} +); + +export type CreditAmount = ({"_variant": "count", "value": number} | {"_variant": "unbounded"}); + +export type Mode<_embedded = _i_EntityRef.Ref> = ( + {"_variant": "bytes"} | + {"_variant": "lines", "value": LineMode} | + {"_variant": "packet", "size": number} | + {"_variant": "object", "description": _.Value<_embedded>} +); + +export type LineMode = ({"_variant": "lf"} | {"_variant": "crlf"}); + + +export function StreamConnection<_embedded = _i_EntityRef.Ref>( + {source, sink, spec}: {source: _embedded, sink: _embedded, spec: _.Value<_embedded>} +): StreamConnection<_embedded> {return {"source": source, "sink": sink, "spec": spec};} + +export function StreamListenerReady<_embedded = _i_EntityRef.Ref>(spec: _.Value<_embedded>): StreamListenerReady<_embedded> {return {"spec": spec};} + +export function StreamListenerError<_embedded = _i_EntityRef.Ref>({spec, message}: {spec: _.Value<_embedded>, message: string}): StreamListenerError<_embedded> {return {"spec": spec, "message": message};} + +export function StreamError(message: string): StreamError {return {"message": message};} + +export namespace Source { + export function sink<_embedded = _i_EntityRef.Ref>(controller: _embedded): Source<_embedded> {return {"_variant": "sink", "controller": controller};}; + export function StreamError<_embedded = _i_EntityRef.Ref>(value: StreamError): Source<_embedded> {return {"_variant": "StreamError", "value": value};}; + export function credit<_embedded = _i_EntityRef.Ref>({amount, mode}: {amount: CreditAmount, mode: Mode<_embedded>}): Source<_embedded> {return {"_variant": "credit", "amount": amount, "mode": mode};}; +} + +export namespace Sink { + export function source<_embedded = _i_EntityRef.Ref>(controller: _embedded): Sink<_embedded> {return {"_variant": "source", "controller": controller};}; + export function StreamError<_embedded = _i_EntityRef.Ref>(value: StreamError): Sink<_embedded> {return {"_variant": "StreamError", "value": value};}; + export function data<_embedded = _i_EntityRef.Ref>({payload, mode}: {payload: _.Value<_embedded>, mode: Mode<_embedded>}): Sink<_embedded> {return {"_variant": "data", "payload": payload, "mode": mode};}; + export function eof<_embedded = _i_EntityRef.Ref>(): Sink<_embedded> {return {"_variant": "eof"};}; +} + +export namespace CreditAmount { + export function count(value: number): CreditAmount {return {"_variant": "count", "value": value};}; + export function unbounded(): CreditAmount {return {"_variant": "unbounded"};}; +} + +export namespace Mode { + export function bytes<_embedded = _i_EntityRef.Ref>(): Mode<_embedded> {return {"_variant": "bytes"};}; + export function lines<_embedded = _i_EntityRef.Ref>(value: LineMode): Mode<_embedded> {return {"_variant": "lines", "value": value};}; + export function packet<_embedded = _i_EntityRef.Ref>(size: number): Mode<_embedded> {return {"_variant": "packet", "size": size};}; + export function object<_embedded = _i_EntityRef.Ref>(description: _.Value<_embedded>): Mode<_embedded> {return {"_variant": "object", "description": description};}; +} + +export namespace LineMode { + export function lf(): LineMode {return {"_variant": "lf"};}; + export function crlf(): LineMode {return {"_variant": "crlf"};}; +} + +export function asStreamConnection<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): StreamConnection<_embedded> { + let result = toStreamConnection(v); + if (result === void 0) throw new TypeError(`Invalid StreamConnection: ${_.stringify(v)}`); + return result; +} + +export function toStreamConnection<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | StreamConnection<_embedded> { + let result: undefined | StreamConnection<_embedded>; + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { + let _tmp0: (null) | undefined; + _tmp0 = _.is(v.label, __lit0) ? null : void 0; + if (_tmp0 !== void 0) { + let _tmp1: (_embedded) | undefined; + _tmp1 = _.isEmbedded<_embedded>(v[0]) ? v[0].embeddedValue : void 0; + if (_tmp1 !== void 0) { + let _tmp2: (_embedded) | undefined; + _tmp2 = _.isEmbedded<_embedded>(v[1]) ? v[1].embeddedValue : void 0; + if (_tmp2 !== void 0) { + let _tmp3: (_.Value<_embedded>) | undefined; + _tmp3 = v[2]; + if (_tmp3 !== void 0) {result = {"source": _tmp1, "sink": _tmp2, "spec": _tmp3};}; + }; + }; + }; + }; + return result; +} + +export function fromStreamConnection<_embedded = _i_EntityRef.Ref>(_v: StreamConnection<_embedded>): _.Value<_embedded> { + return _.Record(__lit0, [_.embed(_v["source"]), _.embed(_v["sink"]), _v["spec"]]); +} + +export function asStreamListenerReady<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): StreamListenerReady<_embedded> { + let result = toStreamListenerReady(v); + if (result === void 0) throw new TypeError(`Invalid StreamListenerReady: ${_.stringify(v)}`); + return result; +} + +export function toStreamListenerReady<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | StreamListenerReady<_embedded> { + let result: undefined | StreamListenerReady<_embedded>; + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { + let _tmp0: (null) | undefined; + _tmp0 = _.is(v.label, __lit1) ? null : void 0; + if (_tmp0 !== void 0) { + let _tmp1: (_.Value<_embedded>) | undefined; + _tmp1 = v[0]; + if (_tmp1 !== void 0) {result = {"spec": _tmp1};}; + }; + }; + return result; +} + +export function fromStreamListenerReady<_embedded = _i_EntityRef.Ref>(_v: StreamListenerReady<_embedded>): _.Value<_embedded> {return _.Record(__lit1, [_v["spec"]]);} + +export function asStreamListenerError<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): StreamListenerError<_embedded> { + let result = toStreamListenerError(v); + if (result === void 0) throw new TypeError(`Invalid StreamListenerError: ${_.stringify(v)}`); + return result; +} + +export function toStreamListenerError<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | StreamListenerError<_embedded> { + let result: undefined | StreamListenerError<_embedded>; + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { + let _tmp0: (null) | undefined; + _tmp0 = _.is(v.label, __lit2) ? null : void 0; + if (_tmp0 !== void 0) { + let _tmp1: (_.Value<_embedded>) | undefined; + _tmp1 = v[0]; + if (_tmp1 !== void 0) { + let _tmp2: (string) | undefined; + _tmp2 = typeof v[1] === 'string' ? v[1] : void 0; + if (_tmp2 !== void 0) {result = {"spec": _tmp1, "message": _tmp2};}; + }; + }; + }; + return result; +} + +export function fromStreamListenerError<_embedded = _i_EntityRef.Ref>(_v: StreamListenerError<_embedded>): _.Value<_embedded> {return _.Record(__lit2, [_v["spec"], _v["message"]]);} + +export function asStreamError<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): StreamError { + let result = toStreamError(v); + if (result === void 0) throw new TypeError(`Invalid StreamError: ${_.stringify(v)}`); + return result; +} + +export function toStreamError<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | StreamError { + let result: undefined | StreamError; + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { + let _tmp0: (null) | undefined; + _tmp0 = _.is(v.label, $error) ? null : void 0; + if (_tmp0 !== void 0) { + let _tmp1: (string) | undefined; + _tmp1 = typeof v[0] === 'string' ? v[0] : void 0; + if (_tmp1 !== void 0) {result = {"message": _tmp1};}; + }; + }; + return result; +} + +export function fromStreamError<_embedded = _i_EntityRef.Ref>(_v: StreamError): _.Value<_embedded> {return _.Record($error, [_v["message"]]);} + +export function asSource<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): Source<_embedded> { + let result = toSource(v); + if (result === void 0) throw new TypeError(`Invalid Source: ${_.stringify(v)}`); + return result; +} + +export function toSource<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | Source<_embedded> { + let result: undefined | Source<_embedded>; + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { + let _tmp0: (null) | undefined; + _tmp0 = _.is(v.label, $sink) ? null : void 0; + if (_tmp0 !== void 0) { + let _tmp1: (_embedded) | undefined; + _tmp1 = _.isEmbedded<_embedded>(v[0]) ? v[0].embeddedValue : void 0; + if (_tmp1 !== void 0) {result = {"_variant": "sink", "controller": _tmp1};}; + }; + }; + if (result === void 0) { + let _tmp2: (StreamError) | undefined; + _tmp2 = toStreamError(v); + if (_tmp2 !== void 0) {result = {"_variant": "StreamError", "value": _tmp2};}; + if (result === void 0) { + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { + let _tmp3: (null) | undefined; + _tmp3 = _.is(v.label, $credit) ? null : void 0; + if (_tmp3 !== void 0) { + let _tmp4: (CreditAmount) | undefined; + _tmp4 = toCreditAmount(v[0]); + if (_tmp4 !== void 0) { + let _tmp5: (Mode<_embedded>) | undefined; + _tmp5 = toMode(v[1]); + if (_tmp5 !== void 0) {result = {"_variant": "credit", "amount": _tmp4, "mode": _tmp5};}; + }; + }; + }; + }; + }; + return result; +} + +export function fromSource<_embedded = _i_EntityRef.Ref>(_v: Source<_embedded>): _.Value<_embedded> { + switch (_v._variant) { + case "sink": {return _.Record($sink, [_.embed(_v["controller"])]);}; + case "StreamError": {return fromStreamError<_embedded>(_v.value);}; + case "credit": { + return _.Record( + $credit, + [fromCreditAmount<_embedded>(_v["amount"]), fromMode<_embedded>(_v["mode"])] + ); + }; + }; +} + +export function asSink<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): Sink<_embedded> { + let result = toSink(v); + if (result === void 0) throw new TypeError(`Invalid Sink: ${_.stringify(v)}`); + return result; +} + +export function toSink<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | Sink<_embedded> { + let result: undefined | Sink<_embedded>; + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { + let _tmp0: (null) | undefined; + _tmp0 = _.is(v.label, $source) ? null : void 0; + if (_tmp0 !== void 0) { + let _tmp1: (_embedded) | undefined; + _tmp1 = _.isEmbedded<_embedded>(v[0]) ? v[0].embeddedValue : void 0; + if (_tmp1 !== void 0) {result = {"_variant": "source", "controller": _tmp1};}; + }; + }; + if (result === void 0) { + let _tmp2: (StreamError) | undefined; + _tmp2 = toStreamError(v); + if (_tmp2 !== void 0) {result = {"_variant": "StreamError", "value": _tmp2};}; + if (result === void 0) { + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { + let _tmp3: (null) | undefined; + _tmp3 = _.is(v.label, $data) ? null : void 0; + if (_tmp3 !== void 0) { + let _tmp4: (_.Value<_embedded>) | undefined; + _tmp4 = v[0]; + if (_tmp4 !== void 0) { + let _tmp5: (Mode<_embedded>) | undefined; + _tmp5 = toMode(v[1]); + if (_tmp5 !== void 0) {result = {"_variant": "data", "payload": _tmp4, "mode": _tmp5};}; + }; + }; + }; + if (result === void 0) { + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { + let _tmp6: (null) | undefined; + _tmp6 = _.is(v.label, $eof) ? null : void 0; + if (_tmp6 !== void 0) {result = {"_variant": "eof"};}; + }; + }; + }; + }; + return result; +} + +export function fromSink<_embedded = _i_EntityRef.Ref>(_v: Sink<_embedded>): _.Value<_embedded> { + switch (_v._variant) { + case "source": {return _.Record($source, [_.embed(_v["controller"])]);}; + case "StreamError": {return fromStreamError<_embedded>(_v.value);}; + case "data": {return _.Record($data, [_v["payload"], fromMode<_embedded>(_v["mode"])]);}; + case "eof": {return _.Record($eof, []);}; + }; +} + +export function asCreditAmount<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): CreditAmount { + let result = toCreditAmount(v); + if (result === void 0) throw new TypeError(`Invalid CreditAmount: ${_.stringify(v)}`); + return result; +} + +export function toCreditAmount<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | CreditAmount { + let _tmp0: (number) | undefined; + let result: undefined | CreditAmount; + _tmp0 = typeof v === 'number' ? v : void 0; + if (_tmp0 !== void 0) {result = {"_variant": "count", "value": _tmp0};}; + if (result === void 0) { + let _tmp1: (null) | undefined; + _tmp1 = _.is(v, $unbounded) ? null : void 0; + if (_tmp1 !== void 0) {result = {"_variant": "unbounded"};}; + }; + return result; +} + +export function fromCreditAmount<_embedded = _i_EntityRef.Ref>(_v: CreditAmount): _.Value<_embedded> { + switch (_v._variant) {case "count": {return _v.value;}; case "unbounded": {return $unbounded;};}; +} + +export function asMode<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): Mode<_embedded> { + let result = toMode(v); + if (result === void 0) throw new TypeError(`Invalid Mode: ${_.stringify(v)}`); + return result; +} + +export function toMode<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | Mode<_embedded> { + let _tmp0: (null) | undefined; + let result: undefined | Mode<_embedded>; + _tmp0 = _.is(v, $bytes) ? null : void 0; + if (_tmp0 !== void 0) {result = {"_variant": "bytes"};}; + if (result === void 0) { + let _tmp1: (LineMode) | undefined; + _tmp1 = toLineMode(v); + if (_tmp1 !== void 0) {result = {"_variant": "lines", "value": _tmp1};}; + if (result === void 0) { + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { + let _tmp2: (null) | undefined; + _tmp2 = _.is(v.label, $packet) ? null : void 0; + if (_tmp2 !== void 0) { + let _tmp3: (number) | undefined; + _tmp3 = typeof v[0] === 'number' ? v[0] : void 0; + if (_tmp3 !== void 0) {result = {"_variant": "packet", "size": _tmp3};}; + }; + }; + if (result === void 0) { + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { + let _tmp4: (null) | undefined; + _tmp4 = _.is(v.label, $object) ? null : void 0; + if (_tmp4 !== void 0) { + let _tmp5: (_.Value<_embedded>) | undefined; + _tmp5 = v[0]; + if (_tmp5 !== void 0) {result = {"_variant": "object", "description": _tmp5};}; + }; + }; + }; + }; + }; + return result; +} + +export function fromMode<_embedded = _i_EntityRef.Ref>(_v: Mode<_embedded>): _.Value<_embedded> { + switch (_v._variant) { + case "bytes": {return $bytes;}; + case "lines": {return fromLineMode<_embedded>(_v.value);}; + case "packet": {return _.Record($packet, [_v["size"]]);}; + case "object": {return _.Record($object, [_v["description"]]);}; + }; +} + +export function asLineMode<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): LineMode { + let result = toLineMode(v); + if (result === void 0) throw new TypeError(`Invalid LineMode: ${_.stringify(v)}`); + return result; +} + +export function toLineMode<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | LineMode { + let _tmp0: (null) | undefined; + let result: undefined | LineMode; + _tmp0 = _.is(v, $lf) ? null : void 0; + if (_tmp0 !== void 0) {result = {"_variant": "lf"};}; + if (result === void 0) { + let _tmp1: (null) | undefined; + _tmp1 = _.is(v, $crlf) ? null : void 0; + if (_tmp1 !== void 0) {result = {"_variant": "crlf"};}; + }; + return result; +} + +export function fromLineMode<_embedded = _i_EntityRef.Ref>(_v: LineMode): _.Value<_embedded> { + switch (_v._variant) {case "lf": {return $lf;}; case "crlf": {return $crlf;};}; +} + diff --git a/src/gen/sturdy.ts b/src/gen/sturdy.ts index 065b14a..64d08c2 100644 --- a/src/gen/sturdy.ts +++ b/src/gen/sturdy.ts @@ -1,5 +1,5 @@ import * as _ from "@preserves/core"; -import * as _i_Actor from "../runtime/actor"; +import * as _i_EntityRef from "../runtime/actor"; export const $0 = 0; export const $1 = 1; @@ -25,53 +25,55 @@ export const $rec = Symbol.for("rec"); export const $ref = Symbol.for("ref"); export const $rewrite = Symbol.for("rewrite"); -export type _embedded = _i_Actor.Ref; +export type _embedded = _i_EntityRef.Ref; -export type _val = _.Value<_embedded>; +export type SturdyRef<_embedded = _i_EntityRef.Ref> = { + "oid": _.Value<_embedded>, + "caveatChain": Array>, + "sig": _.Bytes +}; -export type SturdyRef = {"oid": _val, "caveatChain": Array, "sig": _.Bytes}; +export type Attenuation<_embedded = _i_EntityRef.Ref> = Array>; -export type Attenuation = Array; - -export type Caveat = ( - {"_variant": "Rewrite", "value": Rewrite} | - {"_variant": "Alts", "value": Alts} +export type Caveat<_embedded = _i_EntityRef.Ref> = ( + {"_variant": "Rewrite", "value": Rewrite<_embedded>} | + {"_variant": "Alts", "value": Alts<_embedded>} ); -export type Rewrite = {"pattern": Pattern, "template": Template}; +export type Rewrite<_embedded = _i_EntityRef.Ref> = {"pattern": Pattern<_embedded>, "template": Template<_embedded>}; -export type Alts = {"alternatives": Array}; +export type Alts<_embedded = _i_EntityRef.Ref> = {"alternatives": Array>}; export type Oid = number; -export type WireRef = ( +export type WireRef<_embedded = _i_EntityRef.Ref> = ( {"_variant": "mine", "oid": Oid} | - {"_variant": "yours", "oid": Oid, "attenuation": Array} + {"_variant": "yours", "oid": Oid, "attenuation": Array>} ); -export type ConstructorSpec = ( - {"_variant": "CRec", "value": CRec} | +export type ConstructorSpec<_embedded = _i_EntityRef.Ref> = ( + {"_variant": "CRec", "value": CRec<_embedded>} | {"_variant": "CArr", "value": CArr} | {"_variant": "CDict", "value": CDict} ); -export type CRec = {"label": _val, "arity": number}; +export type CRec<_embedded = _i_EntityRef.Ref> = {"label": _.Value<_embedded>, "arity": number}; export type CArr = {"arity": number}; export type CDict = null; -export type Lit = {"value": _val}; +export type Lit<_embedded = _i_EntityRef.Ref> = {"value": _.Value<_embedded>}; -export type Pattern = ( +export type Pattern<_embedded = _i_EntityRef.Ref> = ( {"_variant": "PDiscard", "value": PDiscard} | {"_variant": "PAtom", "value": PAtom} | {"_variant": "PEmbedded", "value": PEmbedded} | - {"_variant": "PBind", "value": PBind} | - {"_variant": "PAnd", "value": PAnd} | - {"_variant": "PNot", "value": PNot} | - {"_variant": "Lit", "value": Lit} | - {"_variant": "PCompound", "value": PCompound} + {"_variant": "PBind", "value": PBind<_embedded>} | + {"_variant": "PAnd", "value": PAnd<_embedded>} | + {"_variant": "PNot", "value": PNot<_embedded>} | + {"_variant": "Lit", "value": Lit<_embedded>} | + {"_variant": "PCompound", "value": PCompound<_embedded>} ); export type PDiscard = null; @@ -88,77 +90,83 @@ export type PAtom = ( export type PEmbedded = null; -export type PBind = {"pattern": Pattern}; +export type PBind<_embedded = _i_EntityRef.Ref> = {"pattern": Pattern<_embedded>}; -export type PAnd = {"patterns": Array}; +export type PAnd<_embedded = _i_EntityRef.Ref> = {"patterns": Array>}; -export type PNot = {"pattern": Pattern}; +export type PNot<_embedded = _i_EntityRef.Ref> = {"pattern": Pattern<_embedded>}; -export type PCompound = {"ctor": ConstructorSpec, "members": PCompoundMembers}; +export type PCompound<_embedded = _i_EntityRef.Ref> = {"ctor": ConstructorSpec<_embedded>, "members": PCompoundMembers<_embedded>}; -export type PCompoundMembers = _.KeyedDictionary<_val, Pattern, _embedded>; +export type PCompoundMembers<_embedded = _i_EntityRef.Ref> = _.KeyedDictionary<_.Value<_embedded>, Pattern<_embedded>, _embedded>; -export type Template = ( - {"_variant": "TAttenuate", "value": TAttenuate} | +export type Template<_embedded = _i_EntityRef.Ref> = ( + {"_variant": "TAttenuate", "value": TAttenuate<_embedded>} | {"_variant": "TRef", "value": TRef} | - {"_variant": "Lit", "value": Lit} | - {"_variant": "TCompound", "value": TCompound} + {"_variant": "Lit", "value": Lit<_embedded>} | + {"_variant": "TCompound", "value": TCompound<_embedded>} ); -export type TAttenuate = {"template": Template, "attenuation": Attenuation}; +export type TAttenuate<_embedded = _i_EntityRef.Ref> = {"template": Template<_embedded>, "attenuation": Attenuation<_embedded>}; export type TRef = {"binding": number}; -export type TCompound = {"ctor": ConstructorSpec, "members": TCompoundMembers}; +export type TCompound<_embedded = _i_EntityRef.Ref> = {"ctor": ConstructorSpec<_embedded>, "members": TCompoundMembers<_embedded>}; -export type TCompoundMembers = _.KeyedDictionary<_val, Template, _embedded>; +export type TCompoundMembers<_embedded = _i_EntityRef.Ref> = _.KeyedDictionary<_.Value<_embedded>, Template<_embedded>, _embedded>; -export function SturdyRef( - {oid, caveatChain, sig}: {oid: _val, caveatChain: Array, sig: _.Bytes} -): SturdyRef {return {"oid": oid, "caveatChain": caveatChain, "sig": sig};} +export function SturdyRef<_embedded = _i_EntityRef.Ref>( + {oid, caveatChain, sig}: { + oid: _.Value<_embedded>, + caveatChain: Array>, + sig: _.Bytes + } +): SturdyRef<_embedded> {return {"oid": oid, "caveatChain": caveatChain, "sig": sig};} -export function Attenuation(value: Array): Attenuation {return value;} +export function Attenuation<_embedded = _i_EntityRef.Ref>(value: Array>): Attenuation<_embedded> {return value;} export namespace Caveat { - export function Rewrite(value: Rewrite): Caveat {return {"_variant": "Rewrite", "value": value};}; - export function Alts(value: Alts): Caveat {return {"_variant": "Alts", "value": value};}; + export function Rewrite<_embedded = _i_EntityRef.Ref>(value: Rewrite<_embedded>): Caveat<_embedded> {return {"_variant": "Rewrite", "value": value};}; + export function Alts<_embedded = _i_EntityRef.Ref>(value: Alts<_embedded>): Caveat<_embedded> {return {"_variant": "Alts", "value": value};}; } -export function Rewrite({pattern, template}: {pattern: Pattern, template: Template}): Rewrite {return {"pattern": pattern, "template": template};} +export function Rewrite<_embedded = _i_EntityRef.Ref>( + {pattern, template}: {pattern: Pattern<_embedded>, template: Template<_embedded>} +): Rewrite<_embedded> {return {"pattern": pattern, "template": template};} -export function Alts(alternatives: Array): Alts {return {"alternatives": alternatives};} +export function Alts<_embedded = _i_EntityRef.Ref>(alternatives: Array>): Alts<_embedded> {return {"alternatives": alternatives};} export function Oid(value: number): Oid {return value;} export namespace WireRef { - export function mine(oid: Oid): WireRef {return {"_variant": "mine", "oid": oid};}; - export function yours({oid, attenuation}: {oid: Oid, attenuation: Array}): WireRef {return {"_variant": "yours", "oid": oid, "attenuation": attenuation};}; + export function mine<_embedded = _i_EntityRef.Ref>(oid: Oid): WireRef<_embedded> {return {"_variant": "mine", "oid": oid};}; + export function yours<_embedded = _i_EntityRef.Ref>({oid, attenuation}: {oid: Oid, attenuation: Array>}): WireRef<_embedded> {return {"_variant": "yours", "oid": oid, "attenuation": attenuation};}; } export namespace ConstructorSpec { - export function CRec(value: CRec): ConstructorSpec {return {"_variant": "CRec", "value": value};}; - export function CArr(value: CArr): ConstructorSpec {return {"_variant": "CArr", "value": value};}; - export function CDict(value: CDict): ConstructorSpec {return {"_variant": "CDict", "value": value};}; + export function CRec<_embedded = _i_EntityRef.Ref>(value: CRec<_embedded>): ConstructorSpec<_embedded> {return {"_variant": "CRec", "value": value};}; + export function CArr<_embedded = _i_EntityRef.Ref>(value: CArr): ConstructorSpec<_embedded> {return {"_variant": "CArr", "value": value};}; + export function CDict<_embedded = _i_EntityRef.Ref>(value: CDict): ConstructorSpec<_embedded> {return {"_variant": "CDict", "value": value};}; } -export function CRec({label, arity}: {label: _val, arity: number}): CRec {return {"label": label, "arity": arity};} +export function CRec<_embedded = _i_EntityRef.Ref>({label, arity}: {label: _.Value<_embedded>, arity: number}): CRec<_embedded> {return {"label": label, "arity": arity};} export function CArr(arity: number): CArr {return {"arity": arity};} export function CDict(): CDict {return null;} -export function Lit(value: _val): Lit {return {"value": value};} +export function Lit<_embedded = _i_EntityRef.Ref>(value: _.Value<_embedded>): Lit<_embedded> {return {"value": value};} export namespace Pattern { - export function PDiscard(value: PDiscard): Pattern {return {"_variant": "PDiscard", "value": value};}; - export function PAtom(value: PAtom): Pattern {return {"_variant": "PAtom", "value": value};}; - export function PEmbedded(value: PEmbedded): Pattern {return {"_variant": "PEmbedded", "value": value};}; - export function PBind(value: PBind): Pattern {return {"_variant": "PBind", "value": value};}; - export function PAnd(value: PAnd): Pattern {return {"_variant": "PAnd", "value": value};}; - export function PNot(value: PNot): Pattern {return {"_variant": "PNot", "value": value};}; - export function Lit(value: Lit): Pattern {return {"_variant": "Lit", "value": value};}; - export function PCompound(value: PCompound): Pattern {return {"_variant": "PCompound", "value": value};}; + export function PDiscard<_embedded = _i_EntityRef.Ref>(value: PDiscard): Pattern<_embedded> {return {"_variant": "PDiscard", "value": value};}; + export function PAtom<_embedded = _i_EntityRef.Ref>(value: PAtom): Pattern<_embedded> {return {"_variant": "PAtom", "value": value};}; + export function PEmbedded<_embedded = _i_EntityRef.Ref>(value: PEmbedded): Pattern<_embedded> {return {"_variant": "PEmbedded", "value": value};}; + export function PBind<_embedded = _i_EntityRef.Ref>(value: PBind<_embedded>): Pattern<_embedded> {return {"_variant": "PBind", "value": value};}; + export function PAnd<_embedded = _i_EntityRef.Ref>(value: PAnd<_embedded>): Pattern<_embedded> {return {"_variant": "PAnd", "value": value};}; + export function PNot<_embedded = _i_EntityRef.Ref>(value: PNot<_embedded>): Pattern<_embedded> {return {"_variant": "PNot", "value": value};}; + export function Lit<_embedded = _i_EntityRef.Ref>(value: Lit<_embedded>): Pattern<_embedded> {return {"_variant": "Lit", "value": value};}; + export function PCompound<_embedded = _i_EntityRef.Ref>(value: PCompound<_embedded>): Pattern<_embedded> {return {"_variant": "PCompound", "value": value};}; } export function PDiscard(): PDiscard {return null;} @@ -175,52 +183,58 @@ export namespace PAtom { export function PEmbedded(): PEmbedded {return null;} -export function PBind(pattern: Pattern): PBind {return {"pattern": pattern};} +export function PBind<_embedded = _i_EntityRef.Ref>(pattern: Pattern<_embedded>): PBind<_embedded> {return {"pattern": pattern};} -export function PAnd(patterns: Array): PAnd {return {"patterns": patterns};} +export function PAnd<_embedded = _i_EntityRef.Ref>(patterns: Array>): PAnd<_embedded> {return {"patterns": patterns};} -export function PNot(pattern: Pattern): PNot {return {"pattern": pattern};} +export function PNot<_embedded = _i_EntityRef.Ref>(pattern: Pattern<_embedded>): PNot<_embedded> {return {"pattern": pattern};} -export function PCompound({ctor, members}: {ctor: ConstructorSpec, members: PCompoundMembers}): PCompound {return {"ctor": ctor, "members": members};} +export function PCompound<_embedded = _i_EntityRef.Ref>( + {ctor, members}: {ctor: ConstructorSpec<_embedded>, members: PCompoundMembers<_embedded>} +): PCompound<_embedded> {return {"ctor": ctor, "members": members};} -export function PCompoundMembers(value: _.KeyedDictionary<_val, Pattern, _embedded>): PCompoundMembers {return value;} +export function PCompoundMembers<_embedded = _i_EntityRef.Ref>(value: _.KeyedDictionary<_.Value<_embedded>, Pattern<_embedded>, _embedded>): PCompoundMembers<_embedded> {return value;} export namespace Template { - export function TAttenuate(value: TAttenuate): Template {return {"_variant": "TAttenuate", "value": value};}; - export function TRef(value: TRef): Template {return {"_variant": "TRef", "value": value};}; - export function Lit(value: Lit): Template {return {"_variant": "Lit", "value": value};}; - export function TCompound(value: TCompound): Template {return {"_variant": "TCompound", "value": value};}; + export function TAttenuate<_embedded = _i_EntityRef.Ref>(value: TAttenuate<_embedded>): Template<_embedded> {return {"_variant": "TAttenuate", "value": value};}; + export function TRef<_embedded = _i_EntityRef.Ref>(value: TRef): Template<_embedded> {return {"_variant": "TRef", "value": value};}; + export function Lit<_embedded = _i_EntityRef.Ref>(value: Lit<_embedded>): Template<_embedded> {return {"_variant": "Lit", "value": value};}; + export function TCompound<_embedded = _i_EntityRef.Ref>(value: TCompound<_embedded>): Template<_embedded> {return {"_variant": "TCompound", "value": value};}; } -export function TAttenuate({template, attenuation}: {template: Template, attenuation: Attenuation}): TAttenuate {return {"template": template, "attenuation": attenuation};} +export function TAttenuate<_embedded = _i_EntityRef.Ref>( + {template, attenuation}: {template: Template<_embedded>, attenuation: Attenuation<_embedded>} +): TAttenuate<_embedded> {return {"template": template, "attenuation": attenuation};} export function TRef(binding: number): TRef {return {"binding": binding};} -export function TCompound({ctor, members}: {ctor: ConstructorSpec, members: TCompoundMembers}): TCompound {return {"ctor": ctor, "members": members};} +export function TCompound<_embedded = _i_EntityRef.Ref>( + {ctor, members}: {ctor: ConstructorSpec<_embedded>, members: TCompoundMembers<_embedded>} +): TCompound<_embedded> {return {"ctor": ctor, "members": members};} -export function TCompoundMembers(value: _.KeyedDictionary<_val, Template, _embedded>): TCompoundMembers {return value;} +export function TCompoundMembers<_embedded = _i_EntityRef.Ref>(value: _.KeyedDictionary<_.Value<_embedded>, Template<_embedded>, _embedded>): TCompoundMembers<_embedded> {return value;} -export function asSturdyRef(v: _val): SturdyRef { +export function asSturdyRef<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): SturdyRef<_embedded> { let result = toSturdyRef(v); if (result === void 0) throw new TypeError(`Invalid SturdyRef: ${_.stringify(v)}`); return result; } -export function toSturdyRef(v: _val): undefined | SturdyRef { - let result: undefined | SturdyRef; - if (_.Record.isRecord<_val, _.Tuple<_val>, _embedded>(v)) { +export function toSturdyRef<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | SturdyRef<_embedded> { + let result: undefined | SturdyRef<_embedded>; + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { let _tmp0: (null) | undefined; _tmp0 = _.is(v.label, $ref) ? null : void 0; if (_tmp0 !== void 0) { - let _tmp1: (_val) | undefined; + let _tmp1: (_.Value<_embedded>) | undefined; _tmp1 = v[0]; if (_tmp1 !== void 0) { - let _tmp2: (Array) | undefined; + let _tmp2: (Array>) | undefined; _tmp2 = void 0; if (_.Array.isArray(v[1])) { _tmp2 = []; for (const _tmp3 of v[1]) { - let _tmp4: (Attenuation) | undefined; + let _tmp4: (Attenuation<_embedded>) | undefined; _tmp4 = toAttenuation(_tmp3); if (_tmp4 !== void 0) {_tmp2.push(_tmp4); continue;}; _tmp2 = void 0; @@ -238,24 +252,31 @@ export function toSturdyRef(v: _val): undefined | SturdyRef { return result; } -export function fromSturdyRef(_v: SturdyRef): _val { - return _.Record($ref, [_v["oid"], _v["caveatChain"].map(v => fromAttenuation(v)), _v["sig"]]); +export function fromSturdyRef<_embedded = _i_EntityRef.Ref>(_v: SturdyRef<_embedded>): _.Value<_embedded> { + return _.Record( + $ref, + [ + _v["oid"], + _v["caveatChain"].map(v => fromAttenuation<_embedded>(v)), + _v["sig"] + ] + ); } -export function asAttenuation(v: _val): Attenuation { +export function asAttenuation<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): Attenuation<_embedded> { let result = toAttenuation(v); if (result === void 0) throw new TypeError(`Invalid Attenuation: ${_.stringify(v)}`); return result; } -export function toAttenuation(v: _val): undefined | Attenuation { - let _tmp0: (Array) | undefined; - let result: undefined | Attenuation; +export function toAttenuation<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | Attenuation<_embedded> { + let _tmp0: (Array>) | undefined; + let result: undefined | Attenuation<_embedded>; _tmp0 = void 0; if (_.Array.isArray(v)) { _tmp0 = []; for (const _tmp1 of v) { - let _tmp2: (Caveat) | undefined; + let _tmp2: (Caveat<_embedded>) | undefined; _tmp2 = toCaveat(_tmp1); if (_tmp2 !== void 0) {_tmp0.push(_tmp2); continue;}; _tmp0 = void 0; @@ -266,50 +287,50 @@ export function toAttenuation(v: _val): undefined | Attenuation { return result; } -export function fromAttenuation(_v: Attenuation): _val {return _v.map(v => fromCaveat(v));} +export function fromAttenuation<_embedded = _i_EntityRef.Ref>(_v: Attenuation<_embedded>): _.Value<_embedded> {return _v.map(v => fromCaveat<_embedded>(v));} -export function asCaveat(v: _val): Caveat { +export function asCaveat<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): Caveat<_embedded> { let result = toCaveat(v); if (result === void 0) throw new TypeError(`Invalid Caveat: ${_.stringify(v)}`); return result; } -export function toCaveat(v: _val): undefined | Caveat { - let _tmp0: (Rewrite) | undefined; - let result: undefined | Caveat; +export function toCaveat<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | Caveat<_embedded> { + let _tmp0: (Rewrite<_embedded>) | undefined; + let result: undefined | Caveat<_embedded>; _tmp0 = toRewrite(v); if (_tmp0 !== void 0) {result = {"_variant": "Rewrite", "value": _tmp0};}; if (result === void 0) { - let _tmp1: (Alts) | undefined; + let _tmp1: (Alts<_embedded>) | undefined; _tmp1 = toAlts(v); if (_tmp1 !== void 0) {result = {"_variant": "Alts", "value": _tmp1};}; }; return result; } -export function fromCaveat(_v: Caveat): _val { +export function fromCaveat<_embedded = _i_EntityRef.Ref>(_v: Caveat<_embedded>): _.Value<_embedded> { switch (_v._variant) { - case "Rewrite": {return fromRewrite(_v.value);}; - case "Alts": {return fromAlts(_v.value);}; + case "Rewrite": {return fromRewrite<_embedded>(_v.value);}; + case "Alts": {return fromAlts<_embedded>(_v.value);}; }; } -export function asRewrite(v: _val): Rewrite { +export function asRewrite<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): Rewrite<_embedded> { let result = toRewrite(v); if (result === void 0) throw new TypeError(`Invalid Rewrite: ${_.stringify(v)}`); return result; } -export function toRewrite(v: _val): undefined | Rewrite { - let result: undefined | Rewrite; - if (_.Record.isRecord<_val, _.Tuple<_val>, _embedded>(v)) { +export function toRewrite<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | Rewrite<_embedded> { + let result: undefined | Rewrite<_embedded>; + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { let _tmp0: (null) | undefined; _tmp0 = _.is(v.label, $rewrite) ? null : void 0; if (_tmp0 !== void 0) { - let _tmp1: (Pattern) | undefined; + let _tmp1: (Pattern<_embedded>) | undefined; _tmp1 = toPattern(v[0]); if (_tmp1 !== void 0) { - let _tmp2: (Template) | undefined; + let _tmp2: (Template<_embedded>) | undefined; _tmp2 = toTemplate(v[1]); if (_tmp2 !== void 0) {result = {"pattern": _tmp1, "template": _tmp2};}; }; @@ -318,28 +339,31 @@ export function toRewrite(v: _val): undefined | Rewrite { return result; } -export function fromRewrite(_v: Rewrite): _val { - return _.Record($rewrite, [fromPattern(_v["pattern"]), fromTemplate(_v["template"])]); +export function fromRewrite<_embedded = _i_EntityRef.Ref>(_v: Rewrite<_embedded>): _.Value<_embedded> { + return _.Record( + $rewrite, + [fromPattern<_embedded>(_v["pattern"]), fromTemplate<_embedded>(_v["template"])] + ); } -export function asAlts(v: _val): Alts { +export function asAlts<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): Alts<_embedded> { let result = toAlts(v); if (result === void 0) throw new TypeError(`Invalid Alts: ${_.stringify(v)}`); return result; } -export function toAlts(v: _val): undefined | Alts { - let result: undefined | Alts; - if (_.Record.isRecord<_val, _.Tuple<_val>, _embedded>(v)) { +export function toAlts<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | Alts<_embedded> { + let result: undefined | Alts<_embedded>; + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { let _tmp0: (null) | undefined; _tmp0 = _.is(v.label, $or) ? null : void 0; if (_tmp0 !== void 0) { - let _tmp1: (Array) | undefined; + let _tmp1: (Array>) | undefined; _tmp1 = void 0; if (_.Array.isArray(v[0])) { _tmp1 = []; for (const _tmp2 of v[0]) { - let _tmp3: (Rewrite) | undefined; + let _tmp3: (Rewrite<_embedded>) | undefined; _tmp3 = toRewrite(_tmp2); if (_tmp3 !== void 0) {_tmp1.push(_tmp3); continue;}; _tmp1 = void 0; @@ -352,15 +376,17 @@ export function toAlts(v: _val): undefined | Alts { return result; } -export function fromAlts(_v: Alts): _val {return _.Record($or, [_v["alternatives"].map(v => fromRewrite(v))]);} +export function fromAlts<_embedded = _i_EntityRef.Ref>(_v: Alts<_embedded>): _.Value<_embedded> { + return _.Record($or, [_v["alternatives"].map(v => fromRewrite<_embedded>(v))]); +} -export function asOid(v: _val): Oid { +export function asOid<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): Oid { let result = toOid(v); if (result === void 0) throw new TypeError(`Invalid Oid: ${_.stringify(v)}`); return result; } -export function toOid(v: _val): undefined | Oid { +export function toOid<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | Oid { let _tmp0: (number) | undefined; let result: undefined | Oid; _tmp0 = typeof v === 'number' ? v : void 0; @@ -368,16 +394,16 @@ export function toOid(v: _val): undefined | Oid { return result; } -export function fromOid(_v: Oid): _val {return _v;} +export function fromOid<_embedded = _i_EntityRef.Ref>(_v: Oid): _.Value<_embedded> {return _v;} -export function asWireRef(v: _val): WireRef { +export function asWireRef<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): WireRef<_embedded> { let result = toWireRef(v); if (result === void 0) throw new TypeError(`Invalid WireRef: ${_.stringify(v)}`); return result; } -export function toWireRef(v: _val): undefined | WireRef { - let result: undefined | WireRef; +export function toWireRef<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | WireRef<_embedded> { + let result: undefined | WireRef<_embedded>; if (_.Array.isArray(v) && v.length === 2) { let _tmp0: (null) | undefined; _tmp0 = _.is(v[0], $0) ? null : void 0; @@ -395,12 +421,12 @@ export function toWireRef(v: _val): undefined | WireRef { let _tmp3: (Oid) | undefined; _tmp3 = toOid(v[1]); if (_tmp3 !== void 0) { - let _tmp4: (Array<_val>) | undefined; - let _tmp5: (Array) | undefined; + let _tmp4: (Array<_.Value<_embedded>>) | undefined; + let _tmp5: (Array>) | undefined; _tmp4 = v.slice(2); _tmp5 = []; for (const _tmp6 of _tmp4) { - let _tmp7: (Caveat) | undefined; + let _tmp7: (Caveat<_embedded>) | undefined; _tmp7 = toCaveat(_tmp6); if (_tmp7 !== void 0) {_tmp5.push(_tmp7); continue;}; _tmp5 = void 0; @@ -414,24 +440,28 @@ export function toWireRef(v: _val): undefined | WireRef { return result; } -export function fromWireRef(_v: WireRef): _val { +export function fromWireRef<_embedded = _i_EntityRef.Ref>(_v: WireRef<_embedded>): _.Value<_embedded> { switch (_v._variant) { - case "mine": {return [$0, fromOid(_v["oid"])];}; + case "mine": {return [$0, fromOid<_embedded>(_v["oid"])];}; case "yours": { - return [$1, fromOid(_v["oid"]), ... _v["attenuation"].map(v => fromCaveat(v))]; + return [ + $1, + fromOid<_embedded>(_v["oid"]), + ... _v["attenuation"].map(v => fromCaveat<_embedded>(v)) + ]; }; }; } -export function asConstructorSpec(v: _val): ConstructorSpec { +export function asConstructorSpec<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): ConstructorSpec<_embedded> { let result = toConstructorSpec(v); if (result === void 0) throw new TypeError(`Invalid ConstructorSpec: ${_.stringify(v)}`); return result; } -export function toConstructorSpec(v: _val): undefined | ConstructorSpec { - let _tmp0: (CRec) | undefined; - let result: undefined | ConstructorSpec; +export function toConstructorSpec<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | ConstructorSpec<_embedded> { + let _tmp0: (CRec<_embedded>) | undefined; + let result: undefined | ConstructorSpec<_embedded>; _tmp0 = toCRec(v); if (_tmp0 !== void 0) {result = {"_variant": "CRec", "value": _tmp0};}; if (result === void 0) { @@ -447,27 +477,27 @@ export function toConstructorSpec(v: _val): undefined | ConstructorSpec { return result; } -export function fromConstructorSpec(_v: ConstructorSpec): _val { +export function fromConstructorSpec<_embedded = _i_EntityRef.Ref>(_v: ConstructorSpec<_embedded>): _.Value<_embedded> { switch (_v._variant) { - case "CRec": {return fromCRec(_v.value);}; - case "CArr": {return fromCArr(_v.value);}; - case "CDict": {return fromCDict(_v.value);}; + case "CRec": {return fromCRec<_embedded>(_v.value);}; + case "CArr": {return fromCArr<_embedded>(_v.value);}; + case "CDict": {return fromCDict<_embedded>(_v.value);}; }; } -export function asCRec(v: _val): CRec { +export function asCRec<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): CRec<_embedded> { let result = toCRec(v); if (result === void 0) throw new TypeError(`Invalid CRec: ${_.stringify(v)}`); return result; } -export function toCRec(v: _val): undefined | CRec { - let result: undefined | CRec; - if (_.Record.isRecord<_val, _.Tuple<_val>, _embedded>(v)) { +export function toCRec<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | CRec<_embedded> { + let result: undefined | CRec<_embedded>; + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { let _tmp0: (null) | undefined; _tmp0 = _.is(v.label, $rec) ? null : void 0; if (_tmp0 !== void 0) { - let _tmp1: (_val) | undefined; + let _tmp1: (_.Value<_embedded>) | undefined; _tmp1 = v[0]; if (_tmp1 !== void 0) { let _tmp2: (number) | undefined; @@ -479,17 +509,17 @@ export function toCRec(v: _val): undefined | CRec { return result; } -export function fromCRec(_v: CRec): _val {return _.Record($rec, [_v["label"], _v["arity"]]);} +export function fromCRec<_embedded = _i_EntityRef.Ref>(_v: CRec<_embedded>): _.Value<_embedded> {return _.Record($rec, [_v["label"], _v["arity"]]);} -export function asCArr(v: _val): CArr { +export function asCArr<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): CArr { let result = toCArr(v); if (result === void 0) throw new TypeError(`Invalid CArr: ${_.stringify(v)}`); return result; } -export function toCArr(v: _val): undefined | CArr { +export function toCArr<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | CArr { let result: undefined | CArr; - if (_.Record.isRecord<_val, _.Tuple<_val>, _embedded>(v)) { + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { let _tmp0: (null) | undefined; _tmp0 = _.is(v.label, $arr) ? null : void 0; if (_tmp0 !== void 0) { @@ -501,17 +531,17 @@ export function toCArr(v: _val): undefined | CArr { return result; } -export function fromCArr(_v: CArr): _val {return _.Record($arr, [_v["arity"]]);} +export function fromCArr<_embedded = _i_EntityRef.Ref>(_v: CArr): _.Value<_embedded> {return _.Record($arr, [_v["arity"]]);} -export function asCDict(v: _val): CDict { +export function asCDict<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): CDict { let result = toCDict(v); if (result === void 0) throw new TypeError(`Invalid CDict: ${_.stringify(v)}`); return result; } -export function toCDict(v: _val): undefined | CDict { +export function toCDict<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | CDict { let result: undefined | CDict; - if (_.Record.isRecord<_val, _.Tuple<_val>, _embedded>(v)) { + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { let _tmp0: (null) | undefined; _tmp0 = _.is(v.label, $dict) ? null : void 0; if (_tmp0 !== void 0) {result = null;}; @@ -519,21 +549,21 @@ export function toCDict(v: _val): undefined | CDict { return result; } -export function fromCDict(_v: CDict): _val {return _.Record($dict, []);} +export function fromCDict<_embedded = _i_EntityRef.Ref>(_v: CDict): _.Value<_embedded> {return _.Record($dict, []);} -export function asLit(v: _val): Lit { +export function asLit<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): Lit<_embedded> { let result = toLit(v); if (result === void 0) throw new TypeError(`Invalid Lit: ${_.stringify(v)}`); return result; } -export function toLit(v: _val): undefined | Lit { - let result: undefined | Lit; - if (_.Record.isRecord<_val, _.Tuple<_val>, _embedded>(v)) { +export function toLit<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | Lit<_embedded> { + let result: undefined | Lit<_embedded>; + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { let _tmp0: (null) | undefined; _tmp0 = _.is(v.label, $lit) ? null : void 0; if (_tmp0 !== void 0) { - let _tmp1: (_val) | undefined; + let _tmp1: (_.Value<_embedded>) | undefined; _tmp1 = v[0]; if (_tmp1 !== void 0) {result = {"value": _tmp1};}; }; @@ -541,17 +571,17 @@ export function toLit(v: _val): undefined | Lit { return result; } -export function fromLit(_v: Lit): _val {return _.Record($lit, [_v["value"]]);} +export function fromLit<_embedded = _i_EntityRef.Ref>(_v: Lit<_embedded>): _.Value<_embedded> {return _.Record($lit, [_v["value"]]);} -export function asPattern(v: _val): Pattern { +export function asPattern<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): Pattern<_embedded> { let result = toPattern(v); if (result === void 0) throw new TypeError(`Invalid Pattern: ${_.stringify(v)}`); return result; } -export function toPattern(v: _val): undefined | Pattern { +export function toPattern<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | Pattern<_embedded> { let _tmp0: (PDiscard) | undefined; - let result: undefined | Pattern; + let result: undefined | Pattern<_embedded>; _tmp0 = toPDiscard(v); if (_tmp0 !== void 0) {result = {"_variant": "PDiscard", "value": _tmp0};}; if (result === void 0) { @@ -563,23 +593,23 @@ export function toPattern(v: _val): undefined | Pattern { _tmp2 = toPEmbedded(v); if (_tmp2 !== void 0) {result = {"_variant": "PEmbedded", "value": _tmp2};}; if (result === void 0) { - let _tmp3: (PBind) | undefined; + let _tmp3: (PBind<_embedded>) | undefined; _tmp3 = toPBind(v); if (_tmp3 !== void 0) {result = {"_variant": "PBind", "value": _tmp3};}; if (result === void 0) { - let _tmp4: (PAnd) | undefined; + let _tmp4: (PAnd<_embedded>) | undefined; _tmp4 = toPAnd(v); if (_tmp4 !== void 0) {result = {"_variant": "PAnd", "value": _tmp4};}; if (result === void 0) { - let _tmp5: (PNot) | undefined; + let _tmp5: (PNot<_embedded>) | undefined; _tmp5 = toPNot(v); if (_tmp5 !== void 0) {result = {"_variant": "PNot", "value": _tmp5};}; if (result === void 0) { - let _tmp6: (Lit) | undefined; + let _tmp6: (Lit<_embedded>) | undefined; _tmp6 = toLit(v); if (_tmp6 !== void 0) {result = {"_variant": "Lit", "value": _tmp6};}; if (result === void 0) { - let _tmp7: (PCompound) | undefined; + let _tmp7: (PCompound<_embedded>) | undefined; _tmp7 = toPCompound(v); if (_tmp7 !== void 0) {result = {"_variant": "PCompound", "value": _tmp7};}; }; @@ -592,28 +622,28 @@ export function toPattern(v: _val): undefined | Pattern { return result; } -export function fromPattern(_v: Pattern): _val { +export function fromPattern<_embedded = _i_EntityRef.Ref>(_v: Pattern<_embedded>): _.Value<_embedded> { switch (_v._variant) { - case "PDiscard": {return fromPDiscard(_v.value);}; - case "PAtom": {return fromPAtom(_v.value);}; - case "PEmbedded": {return fromPEmbedded(_v.value);}; - case "PBind": {return fromPBind(_v.value);}; - case "PAnd": {return fromPAnd(_v.value);}; - case "PNot": {return fromPNot(_v.value);}; - case "Lit": {return fromLit(_v.value);}; - case "PCompound": {return fromPCompound(_v.value);}; + case "PDiscard": {return fromPDiscard<_embedded>(_v.value);}; + case "PAtom": {return fromPAtom<_embedded>(_v.value);}; + case "PEmbedded": {return fromPEmbedded<_embedded>(_v.value);}; + case "PBind": {return fromPBind<_embedded>(_v.value);}; + case "PAnd": {return fromPAnd<_embedded>(_v.value);}; + case "PNot": {return fromPNot<_embedded>(_v.value);}; + case "Lit": {return fromLit<_embedded>(_v.value);}; + case "PCompound": {return fromPCompound<_embedded>(_v.value);}; }; } -export function asPDiscard(v: _val): PDiscard { +export function asPDiscard<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): PDiscard { let result = toPDiscard(v); if (result === void 0) throw new TypeError(`Invalid PDiscard: ${_.stringify(v)}`); return result; } -export function toPDiscard(v: _val): undefined | PDiscard { +export function toPDiscard<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | PDiscard { let result: undefined | PDiscard; - if (_.Record.isRecord<_val, _.Tuple<_val>, _embedded>(v)) { + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { let _tmp0: (null) | undefined; _tmp0 = _.is(v.label, $_) ? null : void 0; if (_tmp0 !== void 0) {result = null;}; @@ -621,15 +651,15 @@ export function toPDiscard(v: _val): undefined | PDiscard { return result; } -export function fromPDiscard(_v: PDiscard): _val {return _.Record($_, []);} +export function fromPDiscard<_embedded = _i_EntityRef.Ref>(_v: PDiscard): _.Value<_embedded> {return _.Record($_, []);} -export function asPAtom(v: _val): PAtom { +export function asPAtom<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): PAtom { let result = toPAtom(v); if (result === void 0) throw new TypeError(`Invalid PAtom: ${_.stringify(v)}`); return result; } -export function toPAtom(v: _val): undefined | PAtom { +export function toPAtom<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | PAtom { let _tmp0: (null) | undefined; let result: undefined | PAtom; _tmp0 = _.is(v, $Boolean) ? null : void 0; @@ -667,7 +697,7 @@ export function toPAtom(v: _val): undefined | PAtom { return result; } -export function fromPAtom(_v: PAtom): _val { +export function fromPAtom<_embedded = _i_EntityRef.Ref>(_v: PAtom): _.Value<_embedded> { switch (_v._variant) { case "Boolean": {return $Boolean;}; case "Float": {return $Float;}; @@ -679,13 +709,13 @@ export function fromPAtom(_v: PAtom): _val { }; } -export function asPEmbedded(v: _val): PEmbedded { +export function asPEmbedded<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): PEmbedded { let result = toPEmbedded(v); if (result === void 0) throw new TypeError(`Invalid PEmbedded: ${_.stringify(v)}`); return result; } -export function toPEmbedded(v: _val): undefined | PEmbedded { +export function toPEmbedded<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | PEmbedded { let _tmp0: (null) | undefined; let result: undefined | PEmbedded; _tmp0 = _.is(v, $Embedded) ? null : void 0; @@ -693,21 +723,21 @@ export function toPEmbedded(v: _val): undefined | PEmbedded { return result; } -export function fromPEmbedded(_v: PEmbedded): _val {return $Embedded;} +export function fromPEmbedded<_embedded = _i_EntityRef.Ref>(_v: PEmbedded): _.Value<_embedded> {return $Embedded;} -export function asPBind(v: _val): PBind { +export function asPBind<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): PBind<_embedded> { let result = toPBind(v); if (result === void 0) throw new TypeError(`Invalid PBind: ${_.stringify(v)}`); return result; } -export function toPBind(v: _val): undefined | PBind { - let result: undefined | PBind; - if (_.Record.isRecord<_val, _.Tuple<_val>, _embedded>(v)) { +export function toPBind<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | PBind<_embedded> { + let result: undefined | PBind<_embedded>; + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { let _tmp0: (null) | undefined; _tmp0 = _.is(v.label, $bind) ? null : void 0; if (_tmp0 !== void 0) { - let _tmp1: (Pattern) | undefined; + let _tmp1: (Pattern<_embedded>) | undefined; _tmp1 = toPattern(v[0]); if (_tmp1 !== void 0) {result = {"pattern": _tmp1};}; }; @@ -715,26 +745,26 @@ export function toPBind(v: _val): undefined | PBind { return result; } -export function fromPBind(_v: PBind): _val {return _.Record($bind, [fromPattern(_v["pattern"])]);} +export function fromPBind<_embedded = _i_EntityRef.Ref>(_v: PBind<_embedded>): _.Value<_embedded> {return _.Record($bind, [fromPattern<_embedded>(_v["pattern"])]);} -export function asPAnd(v: _val): PAnd { +export function asPAnd<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): PAnd<_embedded> { let result = toPAnd(v); if (result === void 0) throw new TypeError(`Invalid PAnd: ${_.stringify(v)}`); return result; } -export function toPAnd(v: _val): undefined | PAnd { - let result: undefined | PAnd; - if (_.Record.isRecord<_val, _.Tuple<_val>, _embedded>(v)) { +export function toPAnd<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | PAnd<_embedded> { + let result: undefined | PAnd<_embedded>; + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { let _tmp0: (null) | undefined; _tmp0 = _.is(v.label, $and) ? null : void 0; if (_tmp0 !== void 0) { - let _tmp1: (Array) | undefined; + let _tmp1: (Array>) | undefined; _tmp1 = void 0; if (_.Array.isArray(v[0])) { _tmp1 = []; for (const _tmp2 of v[0]) { - let _tmp3: (Pattern) | undefined; + let _tmp3: (Pattern<_embedded>) | undefined; _tmp3 = toPattern(_tmp2); if (_tmp3 !== void 0) {_tmp1.push(_tmp3); continue;}; _tmp1 = void 0; @@ -747,21 +777,21 @@ export function toPAnd(v: _val): undefined | PAnd { return result; } -export function fromPAnd(_v: PAnd): _val {return _.Record($and, [_v["patterns"].map(v => fromPattern(v))]);} +export function fromPAnd<_embedded = _i_EntityRef.Ref>(_v: PAnd<_embedded>): _.Value<_embedded> {return _.Record($and, [_v["patterns"].map(v => fromPattern<_embedded>(v))]);} -export function asPNot(v: _val): PNot { +export function asPNot<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): PNot<_embedded> { let result = toPNot(v); if (result === void 0) throw new TypeError(`Invalid PNot: ${_.stringify(v)}`); return result; } -export function toPNot(v: _val): undefined | PNot { - let result: undefined | PNot; - if (_.Record.isRecord<_val, _.Tuple<_val>, _embedded>(v)) { +export function toPNot<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | PNot<_embedded> { + let result: undefined | PNot<_embedded>; + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { let _tmp0: (null) | undefined; _tmp0 = _.is(v.label, $not) ? null : void 0; if (_tmp0 !== void 0) { - let _tmp1: (Pattern) | undefined; + let _tmp1: (Pattern<_embedded>) | undefined; _tmp1 = toPattern(v[0]); if (_tmp1 !== void 0) {result = {"pattern": _tmp1};}; }; @@ -769,24 +799,24 @@ export function toPNot(v: _val): undefined | PNot { return result; } -export function fromPNot(_v: PNot): _val {return _.Record($not, [fromPattern(_v["pattern"])]);} +export function fromPNot<_embedded = _i_EntityRef.Ref>(_v: PNot<_embedded>): _.Value<_embedded> {return _.Record($not, [fromPattern<_embedded>(_v["pattern"])]);} -export function asPCompound(v: _val): PCompound { +export function asPCompound<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): PCompound<_embedded> { let result = toPCompound(v); if (result === void 0) throw new TypeError(`Invalid PCompound: ${_.stringify(v)}`); return result; } -export function toPCompound(v: _val): undefined | PCompound { - let result: undefined | PCompound; - if (_.Record.isRecord<_val, _.Tuple<_val>, _embedded>(v)) { +export function toPCompound<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | PCompound<_embedded> { + let result: undefined | PCompound<_embedded>; + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { let _tmp0: (null) | undefined; _tmp0 = _.is(v.label, $compound) ? null : void 0; if (_tmp0 !== void 0) { - let _tmp1: (ConstructorSpec) | undefined; + let _tmp1: (ConstructorSpec<_embedded>) | undefined; _tmp1 = toConstructorSpec(v[0]); if (_tmp1 !== void 0) { - let _tmp2: (PCompoundMembers) | undefined; + let _tmp2: (PCompoundMembers<_embedded>) | undefined; _tmp2 = toPCompoundMembers(v[1]); if (_tmp2 !== void 0) {result = {"ctor": _tmp1, "members": _tmp2};}; }; @@ -795,30 +825,33 @@ export function toPCompound(v: _val): undefined | PCompound { return result; } -export function fromPCompound(_v: PCompound): _val { +export function fromPCompound<_embedded = _i_EntityRef.Ref>(_v: PCompound<_embedded>): _.Value<_embedded> { return _.Record( $compound, - [fromConstructorSpec(_v["ctor"]), fromPCompoundMembers(_v["members"])] + [ + fromConstructorSpec<_embedded>(_v["ctor"]), + fromPCompoundMembers<_embedded>(_v["members"]) + ] ); } -export function asPCompoundMembers(v: _val): PCompoundMembers { +export function asPCompoundMembers<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): PCompoundMembers<_embedded> { let result = toPCompoundMembers(v); if (result === void 0) throw new TypeError(`Invalid PCompoundMembers: ${_.stringify(v)}`); return result; } -export function toPCompoundMembers(v: _val): undefined | PCompoundMembers { - let _tmp0: (_.KeyedDictionary<_val, Pattern, _embedded>) | undefined; - let result: undefined | PCompoundMembers; +export function toPCompoundMembers<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | PCompoundMembers<_embedded> { + let _tmp0: (_.KeyedDictionary<_.Value<_embedded>, Pattern<_embedded>, _embedded>) | undefined; + let result: undefined | PCompoundMembers<_embedded>; _tmp0 = void 0; if (_.Dictionary.isDictionary<_embedded>(v)) { _tmp0 = new _.KeyedDictionary(); for (const [_tmp2, _tmp1] of v) { - let _tmp3: (_val) | undefined; + let _tmp3: (_.Value<_embedded>) | undefined; _tmp3 = _tmp2; if (_tmp3 !== void 0) { - let _tmp4: (Pattern) | undefined; + let _tmp4: (Pattern<_embedded>) | undefined; _tmp4 = toPattern(_tmp1); if (_tmp4 !== void 0) {_tmp0.set(_tmp3, _tmp4); continue;}; }; @@ -830,19 +863,19 @@ export function toPCompoundMembers(v: _val): undefined | PCompoundMembers { return result; } -export function fromPCompoundMembers(_v: PCompoundMembers): _val { - return new _.Dictionary<_embedded>(_.Array.from(_v.entries()).map(([k, v]) => [k, fromPattern(v)])); +export function fromPCompoundMembers<_embedded = _i_EntityRef.Ref>(_v: PCompoundMembers<_embedded>): _.Value<_embedded> { + return new _.Dictionary<_embedded>(_.Array.from(_v.entries()).map(([k, v]) => [k, fromPattern<_embedded>(v)])); } -export function asTemplate(v: _val): Template { +export function asTemplate<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): Template<_embedded> { let result = toTemplate(v); if (result === void 0) throw new TypeError(`Invalid Template: ${_.stringify(v)}`); return result; } -export function toTemplate(v: _val): undefined | Template { - let _tmp0: (TAttenuate) | undefined; - let result: undefined | Template; +export function toTemplate<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | Template<_embedded> { + let _tmp0: (TAttenuate<_embedded>) | undefined; + let result: undefined | Template<_embedded>; _tmp0 = toTAttenuate(v); if (_tmp0 !== void 0) {result = {"_variant": "TAttenuate", "value": _tmp0};}; if (result === void 0) { @@ -850,11 +883,11 @@ export function toTemplate(v: _val): undefined | Template { _tmp1 = toTRef(v); if (_tmp1 !== void 0) {result = {"_variant": "TRef", "value": _tmp1};}; if (result === void 0) { - let _tmp2: (Lit) | undefined; + let _tmp2: (Lit<_embedded>) | undefined; _tmp2 = toLit(v); if (_tmp2 !== void 0) {result = {"_variant": "Lit", "value": _tmp2};}; if (result === void 0) { - let _tmp3: (TCompound) | undefined; + let _tmp3: (TCompound<_embedded>) | undefined; _tmp3 = toTCompound(v); if (_tmp3 !== void 0) {result = {"_variant": "TCompound", "value": _tmp3};}; }; @@ -863,31 +896,31 @@ export function toTemplate(v: _val): undefined | Template { return result; } -export function fromTemplate(_v: Template): _val { +export function fromTemplate<_embedded = _i_EntityRef.Ref>(_v: Template<_embedded>): _.Value<_embedded> { switch (_v._variant) { - case "TAttenuate": {return fromTAttenuate(_v.value);}; - case "TRef": {return fromTRef(_v.value);}; - case "Lit": {return fromLit(_v.value);}; - case "TCompound": {return fromTCompound(_v.value);}; + case "TAttenuate": {return fromTAttenuate<_embedded>(_v.value);}; + case "TRef": {return fromTRef<_embedded>(_v.value);}; + case "Lit": {return fromLit<_embedded>(_v.value);}; + case "TCompound": {return fromTCompound<_embedded>(_v.value);}; }; } -export function asTAttenuate(v: _val): TAttenuate { +export function asTAttenuate<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): TAttenuate<_embedded> { let result = toTAttenuate(v); if (result === void 0) throw new TypeError(`Invalid TAttenuate: ${_.stringify(v)}`); return result; } -export function toTAttenuate(v: _val): undefined | TAttenuate { - let result: undefined | TAttenuate; - if (_.Record.isRecord<_val, _.Tuple<_val>, _embedded>(v)) { +export function toTAttenuate<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | TAttenuate<_embedded> { + let result: undefined | TAttenuate<_embedded>; + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { let _tmp0: (null) | undefined; _tmp0 = _.is(v.label, $attenuate) ? null : void 0; if (_tmp0 !== void 0) { - let _tmp1: (Template) | undefined; + let _tmp1: (Template<_embedded>) | undefined; _tmp1 = toTemplate(v[0]); if (_tmp1 !== void 0) { - let _tmp2: (Attenuation) | undefined; + let _tmp2: (Attenuation<_embedded>) | undefined; _tmp2 = toAttenuation(v[1]); if (_tmp2 !== void 0) {result = {"template": _tmp1, "attenuation": _tmp2};}; }; @@ -896,19 +929,25 @@ export function toTAttenuate(v: _val): undefined | TAttenuate { return result; } -export function fromTAttenuate(_v: TAttenuate): _val { - return _.Record($attenuate, [fromTemplate(_v["template"]), fromAttenuation(_v["attenuation"])]); +export function fromTAttenuate<_embedded = _i_EntityRef.Ref>(_v: TAttenuate<_embedded>): _.Value<_embedded> { + return _.Record( + $attenuate, + [ + fromTemplate<_embedded>(_v["template"]), + fromAttenuation<_embedded>(_v["attenuation"]) + ] + ); } -export function asTRef(v: _val): TRef { +export function asTRef<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): TRef { let result = toTRef(v); if (result === void 0) throw new TypeError(`Invalid TRef: ${_.stringify(v)}`); return result; } -export function toTRef(v: _val): undefined | TRef { +export function toTRef<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | TRef { let result: undefined | TRef; - if (_.Record.isRecord<_val, _.Tuple<_val>, _embedded>(v)) { + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { let _tmp0: (null) | undefined; _tmp0 = _.is(v.label, $ref) ? null : void 0; if (_tmp0 !== void 0) { @@ -920,24 +959,24 @@ export function toTRef(v: _val): undefined | TRef { return result; } -export function fromTRef(_v: TRef): _val {return _.Record($ref, [_v["binding"]]);} +export function fromTRef<_embedded = _i_EntityRef.Ref>(_v: TRef): _.Value<_embedded> {return _.Record($ref, [_v["binding"]]);} -export function asTCompound(v: _val): TCompound { +export function asTCompound<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): TCompound<_embedded> { let result = toTCompound(v); if (result === void 0) throw new TypeError(`Invalid TCompound: ${_.stringify(v)}`); return result; } -export function toTCompound(v: _val): undefined | TCompound { - let result: undefined | TCompound; - if (_.Record.isRecord<_val, _.Tuple<_val>, _embedded>(v)) { +export function toTCompound<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | TCompound<_embedded> { + let result: undefined | TCompound<_embedded>; + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { let _tmp0: (null) | undefined; _tmp0 = _.is(v.label, $compound) ? null : void 0; if (_tmp0 !== void 0) { - let _tmp1: (ConstructorSpec) | undefined; + let _tmp1: (ConstructorSpec<_embedded>) | undefined; _tmp1 = toConstructorSpec(v[0]); if (_tmp1 !== void 0) { - let _tmp2: (TCompoundMembers) | undefined; + let _tmp2: (TCompoundMembers<_embedded>) | undefined; _tmp2 = toTCompoundMembers(v[1]); if (_tmp2 !== void 0) {result = {"ctor": _tmp1, "members": _tmp2};}; }; @@ -946,30 +985,33 @@ export function toTCompound(v: _val): undefined | TCompound { return result; } -export function fromTCompound(_v: TCompound): _val { +export function fromTCompound<_embedded = _i_EntityRef.Ref>(_v: TCompound<_embedded>): _.Value<_embedded> { return _.Record( $compound, - [fromConstructorSpec(_v["ctor"]), fromTCompoundMembers(_v["members"])] + [ + fromConstructorSpec<_embedded>(_v["ctor"]), + fromTCompoundMembers<_embedded>(_v["members"]) + ] ); } -export function asTCompoundMembers(v: _val): TCompoundMembers { +export function asTCompoundMembers<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): TCompoundMembers<_embedded> { let result = toTCompoundMembers(v); if (result === void 0) throw new TypeError(`Invalid TCompoundMembers: ${_.stringify(v)}`); return result; } -export function toTCompoundMembers(v: _val): undefined | TCompoundMembers { - let _tmp0: (_.KeyedDictionary<_val, Template, _embedded>) | undefined; - let result: undefined | TCompoundMembers; +export function toTCompoundMembers<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | TCompoundMembers<_embedded> { + let _tmp0: (_.KeyedDictionary<_.Value<_embedded>, Template<_embedded>, _embedded>) | undefined; + let result: undefined | TCompoundMembers<_embedded>; _tmp0 = void 0; if (_.Dictionary.isDictionary<_embedded>(v)) { _tmp0 = new _.KeyedDictionary(); for (const [_tmp2, _tmp1] of v) { - let _tmp3: (_val) | undefined; + let _tmp3: (_.Value<_embedded>) | undefined; _tmp3 = _tmp2; if (_tmp3 !== void 0) { - let _tmp4: (Template) | undefined; + let _tmp4: (Template<_embedded>) | undefined; _tmp4 = toTemplate(_tmp1); if (_tmp4 !== void 0) {_tmp0.set(_tmp3, _tmp4); continue;}; }; @@ -981,7 +1023,7 @@ export function toTCompoundMembers(v: _val): undefined | TCompoundMembers { return result; } -export function fromTCompoundMembers(_v: TCompoundMembers): _val { - return new _.Dictionary<_embedded>(_.Array.from(_v.entries()).map(([k, v]) => [k, fromTemplate(v)])); +export function fromTCompoundMembers<_embedded = _i_EntityRef.Ref>(_v: TCompoundMembers<_embedded>): _.Value<_embedded> { + return new _.Dictionary<_embedded>(_.Array.from(_v.entries()).map(([k, v]) => [k, fromTemplate<_embedded>(v)])); } diff --git a/src/gen/tcp.ts b/src/gen/tcp.ts new file mode 100644 index 0000000..2fb08f0 --- /dev/null +++ b/src/gen/tcp.ts @@ -0,0 +1,115 @@ +import * as _ from "@preserves/core"; +import * as _i_EntityRef from "../runtime/actor"; + +export const __lit0 = Symbol.for("tcp-remote"); +export const __lit1 = Symbol.for("tcp-local"); +export const __lit2 = Symbol.for("tcp-peer"); + +export type _embedded = _i_EntityRef.Ref; + +export type TcpRemote = {"host": string, "port": number}; + +export type TcpLocal = {"host": string, "port": number}; + +export type TcpPeerInfo<_embedded = _i_EntityRef.Ref> = {"handle": _embedded, "local": TcpLocal, "remote": TcpRemote}; + + +export function TcpRemote({host, port}: {host: string, port: number}): TcpRemote {return {"host": host, "port": port};} + +export function TcpLocal({host, port}: {host: string, port: number}): TcpLocal {return {"host": host, "port": port};} + +export function TcpPeerInfo<_embedded = _i_EntityRef.Ref>( + {handle, local, remote}: {handle: _embedded, local: TcpLocal, remote: TcpRemote} +): TcpPeerInfo<_embedded> {return {"handle": handle, "local": local, "remote": remote};} + +export function asTcpRemote<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): TcpRemote { + let result = toTcpRemote(v); + if (result === void 0) throw new TypeError(`Invalid TcpRemote: ${_.stringify(v)}`); + return result; +} + +export function toTcpRemote<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | TcpRemote { + let result: undefined | TcpRemote; + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { + let _tmp0: (null) | undefined; + _tmp0 = _.is(v.label, __lit0) ? null : void 0; + if (_tmp0 !== void 0) { + let _tmp1: (string) | undefined; + _tmp1 = typeof v[0] === 'string' ? v[0] : void 0; + if (_tmp1 !== void 0) { + let _tmp2: (number) | undefined; + _tmp2 = typeof v[1] === 'number' ? v[1] : void 0; + if (_tmp2 !== void 0) {result = {"host": _tmp1, "port": _tmp2};}; + }; + }; + }; + return result; +} + +export function fromTcpRemote<_embedded = _i_EntityRef.Ref>(_v: TcpRemote): _.Value<_embedded> {return _.Record(__lit0, [_v["host"], _v["port"]]);} + +export function asTcpLocal<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): TcpLocal { + let result = toTcpLocal(v); + if (result === void 0) throw new TypeError(`Invalid TcpLocal: ${_.stringify(v)}`); + return result; +} + +export function toTcpLocal<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | TcpLocal { + let result: undefined | TcpLocal; + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { + let _tmp0: (null) | undefined; + _tmp0 = _.is(v.label, __lit1) ? null : void 0; + if (_tmp0 !== void 0) { + let _tmp1: (string) | undefined; + _tmp1 = typeof v[0] === 'string' ? v[0] : void 0; + if (_tmp1 !== void 0) { + let _tmp2: (number) | undefined; + _tmp2 = typeof v[1] === 'number' ? v[1] : void 0; + if (_tmp2 !== void 0) {result = {"host": _tmp1, "port": _tmp2};}; + }; + }; + }; + return result; +} + +export function fromTcpLocal<_embedded = _i_EntityRef.Ref>(_v: TcpLocal): _.Value<_embedded> {return _.Record(__lit1, [_v["host"], _v["port"]]);} + +export function asTcpPeerInfo<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): TcpPeerInfo<_embedded> { + let result = toTcpPeerInfo(v); + if (result === void 0) throw new TypeError(`Invalid TcpPeerInfo: ${_.stringify(v)}`); + return result; +} + +export function toTcpPeerInfo<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | TcpPeerInfo<_embedded> { + let result: undefined | TcpPeerInfo<_embedded>; + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { + let _tmp0: (null) | undefined; + _tmp0 = _.is(v.label, __lit2) ? null : void 0; + if (_tmp0 !== void 0) { + let _tmp1: (_embedded) | undefined; + _tmp1 = _.isEmbedded<_embedded>(v[0]) ? v[0].embeddedValue : void 0; + if (_tmp1 !== void 0) { + let _tmp2: (TcpLocal) | undefined; + _tmp2 = toTcpLocal(v[1]); + if (_tmp2 !== void 0) { + let _tmp3: (TcpRemote) | undefined; + _tmp3 = toTcpRemote(v[2]); + if (_tmp3 !== void 0) {result = {"handle": _tmp1, "local": _tmp2, "remote": _tmp3};}; + }; + }; + }; + }; + return result; +} + +export function fromTcpPeerInfo<_embedded = _i_EntityRef.Ref>(_v: TcpPeerInfo<_embedded>): _.Value<_embedded> { + return _.Record( + __lit2, + [ + _.embed(_v["handle"]), + fromTcpLocal<_embedded>(_v["local"]), + fromTcpRemote<_embedded>(_v["remote"]) + ] + ); +} + diff --git a/src/gen/timer.ts b/src/gen/timer.ts new file mode 100644 index 0000000..45ba0b8 --- /dev/null +++ b/src/gen/timer.ts @@ -0,0 +1,147 @@ +import * as _ from "@preserves/core"; + +export const $absolute = Symbol.for("absolute"); +export const $clear = Symbol.for("clear"); +export const $relative = Symbol.for("relative"); +export const __lit0 = Symbol.for("set-timer"); +export const __lit1 = Symbol.for("timer-expired"); +export const __lit5 = Symbol.for("later-than"); + +export type SetTimer<_embedded = _.GenericEmbedded> = {"label": _.Value<_embedded>, "msecs": number, "kind": TimerKind}; + +export type TimerExpired<_embedded = _.GenericEmbedded> = {"label": _.Value<_embedded>, "msecs": number}; + +export type TimerKind = ({"_variant": "relative"} | {"_variant": "absolute"} | {"_variant": "clear"}); + +export type LaterThan = {"msecs": number}; + + +export function SetTimer<_embedded = _.GenericEmbedded>( + {label, msecs, kind}: {label: _.Value<_embedded>, msecs: number, kind: TimerKind} +): SetTimer<_embedded> {return {"label": label, "msecs": msecs, "kind": kind};} + +export function TimerExpired<_embedded = _.GenericEmbedded>({label, msecs}: {label: _.Value<_embedded>, msecs: number}): TimerExpired<_embedded> {return {"label": label, "msecs": msecs};} + +export namespace TimerKind { + export function relative(): TimerKind {return {"_variant": "relative"};}; + export function absolute(): TimerKind {return {"_variant": "absolute"};}; + export function clear(): TimerKind {return {"_variant": "clear"};}; +} + +export function LaterThan(msecs: number): LaterThan {return {"msecs": msecs};} + +export function asSetTimer<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): SetTimer<_embedded> { + let result = toSetTimer(v); + if (result === void 0) throw new TypeError(`Invalid SetTimer: ${_.stringify(v)}`); + return result; +} + +export function toSetTimer<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | SetTimer<_embedded> { + let result: undefined | SetTimer<_embedded>; + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { + let _tmp0: (null) | undefined; + _tmp0 = _.is(v.label, __lit0) ? null : void 0; + if (_tmp0 !== void 0) { + let _tmp1: (_.Value<_embedded>) | undefined; + _tmp1 = v[0]; + if (_tmp1 !== void 0) { + let _tmp2: (number) | undefined; + _tmp2 = _.Float.isDouble(v[1]) ? v[1].value : void 0; + if (_tmp2 !== void 0) { + let _tmp3: (TimerKind) | undefined; + _tmp3 = toTimerKind(v[2]); + if (_tmp3 !== void 0) {result = {"label": _tmp1, "msecs": _tmp2, "kind": _tmp3};}; + }; + }; + }; + }; + return result; +} + +export function fromSetTimer<_embedded = _.GenericEmbedded>(_v: SetTimer<_embedded>): _.Value<_embedded> { + return _.Record( + __lit0, + [_v["label"], _.Double(_v["msecs"]), fromTimerKind<_embedded>(_v["kind"])] + ); +} + +export function asTimerExpired<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): TimerExpired<_embedded> { + let result = toTimerExpired(v); + if (result === void 0) throw new TypeError(`Invalid TimerExpired: ${_.stringify(v)}`); + return result; +} + +export function toTimerExpired<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | TimerExpired<_embedded> { + let result: undefined | TimerExpired<_embedded>; + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { + let _tmp0: (null) | undefined; + _tmp0 = _.is(v.label, __lit1) ? null : void 0; + if (_tmp0 !== void 0) { + let _tmp1: (_.Value<_embedded>) | undefined; + _tmp1 = v[0]; + if (_tmp1 !== void 0) { + let _tmp2: (number) | undefined; + _tmp2 = _.Float.isDouble(v[1]) ? v[1].value : void 0; + if (_tmp2 !== void 0) {result = {"label": _tmp1, "msecs": _tmp2};}; + }; + }; + }; + return result; +} + +export function fromTimerExpired<_embedded = _.GenericEmbedded>(_v: TimerExpired<_embedded>): _.Value<_embedded> {return _.Record(__lit1, [_v["label"], _.Double(_v["msecs"])]);} + +export function asTimerKind<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): TimerKind { + let result = toTimerKind(v); + if (result === void 0) throw new TypeError(`Invalid TimerKind: ${_.stringify(v)}`); + return result; +} + +export function toTimerKind<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | TimerKind { + let _tmp0: (null) | undefined; + let result: undefined | TimerKind; + _tmp0 = _.is(v, $relative) ? null : void 0; + if (_tmp0 !== void 0) {result = {"_variant": "relative"};}; + if (result === void 0) { + let _tmp1: (null) | undefined; + _tmp1 = _.is(v, $absolute) ? null : void 0; + if (_tmp1 !== void 0) {result = {"_variant": "absolute"};}; + if (result === void 0) { + let _tmp2: (null) | undefined; + _tmp2 = _.is(v, $clear) ? null : void 0; + if (_tmp2 !== void 0) {result = {"_variant": "clear"};}; + }; + }; + return result; +} + +export function fromTimerKind<_embedded = _.GenericEmbedded>(_v: TimerKind): _.Value<_embedded> { + switch (_v._variant) { + case "relative": {return $relative;}; + case "absolute": {return $absolute;}; + case "clear": {return $clear;}; + }; +} + +export function asLaterThan<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): LaterThan { + let result = toLaterThan(v); + if (result === void 0) throw new TypeError(`Invalid LaterThan: ${_.stringify(v)}`); + return result; +} + +export function toLaterThan<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | LaterThan { + let result: undefined | LaterThan; + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { + let _tmp0: (null) | undefined; + _tmp0 = _.is(v.label, __lit5) ? null : void 0; + if (_tmp0 !== void 0) { + let _tmp1: (number) | undefined; + _tmp1 = _.Float.isDouble(v[0]) ? v[0].value : void 0; + if (_tmp1 !== void 0) {result = {"msecs": _tmp1};}; + }; + }; + return result; +} + +export function fromLaterThan<_embedded = _.GenericEmbedded>(_v: LaterThan): _.Value<_embedded> {return _.Record(__lit5, [_.Double(_v["msecs"])]);} + diff --git a/src/gen/worker.ts b/src/gen/worker.ts index e4cfd28..521e51b 100644 --- a/src/gen/worker.ts +++ b/src/gen/worker.ts @@ -1,33 +1,31 @@ import * as _ from "@preserves/core"; -import * as _i_Actor from "../runtime/actor"; +import * as _i_EntityRef from "../runtime/actor"; export const $Instance = Symbol.for("Instance"); -export type _embedded = _i_Actor.Ref; +export type _embedded = _i_EntityRef.Ref; -export type _val = _.Value<_embedded>; - -export type Instance = {"name": string, "argument": _val}; +export type Instance<_embedded = _i_EntityRef.Ref> = {"name": string, "argument": _.Value<_embedded>}; -export function Instance({name, argument}: {name: string, argument: _val}): Instance {return {"name": name, "argument": argument};} +export function Instance<_embedded = _i_EntityRef.Ref>({name, argument}: {name: string, argument: _.Value<_embedded>}): Instance<_embedded> {return {"name": name, "argument": argument};} -export function asInstance(v: _val): Instance { +export function asInstance<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): Instance<_embedded> { let result = toInstance(v); if (result === void 0) throw new TypeError(`Invalid Instance: ${_.stringify(v)}`); return result; } -export function toInstance(v: _val): undefined | Instance { - let result: undefined | Instance; - if (_.Record.isRecord<_val, _.Tuple<_val>, _embedded>(v)) { +export function toInstance<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | Instance<_embedded> { + let result: undefined | Instance<_embedded>; + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { let _tmp0: (null) | undefined; _tmp0 = _.is(v.label, $Instance) ? null : void 0; if (_tmp0 !== void 0) { let _tmp1: (string) | undefined; _tmp1 = typeof v[0] === 'string' ? v[0] : void 0; if (_tmp1 !== void 0) { - let _tmp2: (_val) | undefined; + let _tmp2: (_.Value<_embedded>) | undefined; _tmp2 = v[1]; if (_tmp2 !== void 0) {result = {"name": _tmp1, "argument": _tmp2};}; }; @@ -36,5 +34,5 @@ export function toInstance(v: _val): undefined | Instance { return result; } -export function fromInstance(_v: Instance): _val {return _.Record($Instance, [_v["name"], _v["argument"]]);} +export function fromInstance<_embedded = _i_EntityRef.Ref>(_v: Instance<_embedded>): _.Value<_embedded> {return _.Record($Instance, [_v["name"], _v["argument"]]);} diff --git a/src/runtime/actor.ts b/src/runtime/actor.ts index f6b7fe0..4ad9756 100644 --- a/src/runtime/actor.ts +++ b/src/runtime/actor.ts @@ -2,6 +2,8 @@ import { IdentitySet, Value } from '@preserves/core'; import { Attenuation, runRewrites } from './rewrite.js'; import { queueTask } from './task.js'; +export type AnyValue = Value; + //--------------------------------------------------------------------------- if ('stackTraceLimit' in Error) { diff --git a/src/runtime/dataspace.ts b/src/runtime/dataspace.ts index c3fe240..93408f0 100644 --- a/src/runtime/dataspace.ts +++ b/src/runtime/dataspace.ts @@ -1,9 +1,11 @@ -import { Assertion, Entity, Handle, LocalAction, Ref, Turn } from 'runtime/actor'; -import { Dictionary, IdentityMap, is, Record, Tuple } from '@preserves/core'; -import { Bag, ChangeDescription } from './bag'; +import { KeyedDictionary, preserves } from '@preserves/core'; +import { AnyValue, Assertion, Entity, Handle, LocalAction, Ref, Turn } from 'runtime/actor'; -import { fromObserve, toObserve, Observe } from '../gen/dataspace'; -export * from '../gen/dataspace'; +import { fromObserve, Observe } from '../gen/dataspace'; +import { DBind, DDiscard, DLit, Pattern, DCompound, CArr, CDict, CRec } from '../gen/dataspacePatterns'; + +export { asObserve, fromObserve, toObserve, Observe, $Observe } from '../gen/dataspace'; +export * from '../gen/dataspacePatterns'; // Q. Why keep "Observe"? Why not do the clever trick of asserting the // observer, and having the dataspace read the implicit pattern it's @@ -36,54 +38,19 @@ export * from '../gen/dataspace'; // spurious variation. export class Dataspace implements Partial { - readonly handleMap: IdentityMap> = new IdentityMap(); - readonly assertions = new Bag(); - readonly subscriptions = new Dictionary>>(); - assert(turn: Turn, rec: Assertion, handle: Handle): void { - // console.log(preserves`ds ${turn.activeFacet.id} assert ${rec} ${handle}`); - if (!Record.isRecord, Ref>(rec)) return; - this.handleMap.set(handle, rec); - if (this.assertions.change(rec, +1) !== ChangeDescription.ABSENT_TO_PRESENT) return; - { - const o = toObserve(rec); - if (o !== void 0) { - const seen = new Dictionary(); - if (!this.subscriptions.has(o.label)) this.subscriptions.set(o.label, new Map()); - this.subscriptions.get(o.label)!.set(o.observer, seen); - this.assertions.forEach((_count, prev) => - is((prev as Record).label, o.label) - && seen.set(prev, turn.assert(o.observer, prev))); - } - } - this.subscriptions.get(rec.label)?.forEach((seen, peer) => - seen.has(rec) || seen.set(rec, turn.assert(peer, rec))); + console.log(preserves`ds ${turn.activeFacet.id} assert ${rec} ${handle}`); + throw new Error("Full dataspaces not implemented"); } retract(turn: Turn, upstreamHandle: Handle): void { - const rec = this.handleMap.get(upstreamHandle); - // console.log(preserves`ds ${turn.activeFacet.id} retract ${rec} ${upstreamHandle}`); - if (rec === void 0) return; - this.handleMap.delete(upstreamHandle); - if (this.assertions.change(rec, -1) !== ChangeDescription.PRESENT_TO_ABSENT) return; - this.subscriptions.get(rec.label)?.forEach((seen, _peer) => { - turn.retract(seen.get(rec)); - seen.delete(rec); - }); - { - const o = toObserve(rec); - if (o !== void 0) { - let peerMap = this.subscriptions.get(o.label)!; - peerMap.delete(o.observer); - if (peerMap.size === 0) this.subscriptions.delete(o.label); - } - } + console.log(preserves`ds ${turn.activeFacet.id} retract ${upstreamHandle}`); + throw new Error("Full dataspaces not implemented"); } message(turn: Turn, rec: Assertion): void { - // console.log(preserves`ds ${turn.activeFacet.id} message ${rec}`); - if (!Record.isRecord, Ref>(rec)) return; - this.subscriptions.get(rec.label)?.forEach((_seen, peer) => turn.message(peer, rec)); + console.log(preserves`ds ${turn.activeFacet.id} message ${rec}`); + throw new Error("Full dataspaces not implemented"); } } @@ -124,6 +91,46 @@ export function during(f: (t: Turn, a: Assertion) => Promise }; } -export function observe(t: Turn, ds: Ref, label: symbol, e: Partial): Handle { - return t.assert(ds, fromObserve(Observe({ label, observer: t.ref(e) }))); +export function observe(t: Turn, ds: Ref, pattern: Pattern, e: Partial): Handle { + return t.assert(ds, fromObserve(Observe({ pattern, observer: t.ref(e) }))); +} + +export namespace P { + export function discard(): Pattern { + return Pattern.DDiscard(DDiscard()); + } + export function bind(name: string, pattern: Pattern = discard()): Pattern { + return Pattern.DBind(DBind({name: Symbol.for(name), pattern})); + } + export function lit(value: AnyValue): Pattern { + return Pattern.DLit(DLit(value)); + } + export function rec(label: AnyValue, ...fields: Pattern[]): Pattern { + const members = new KeyedDictionary(); + fields.forEach((f, i) => { + if (f._variant !== 'DDiscard') members.set(i, f); + }); + return Pattern.DCompound(DCompound.rec({ + ctor: CRec({ label, arity: fields.length }), + members, + })); + } + export function arr(...entries: Pattern[]): Pattern { + const members = new KeyedDictionary(); + entries.forEach((f, i) => { + if (f._variant !== 'DDiscard') members.set(i, f); + }); + return Pattern.DCompound(DCompound.arr({ + ctor: CArr(entries.length), + members, + })); + } + export function dict(...entries: [AnyValue, Pattern][]): Pattern { + const members = new KeyedDictionary(); + entries.forEach(([k, p]) => members.set(k, p)); + return Pattern.DCompound(DCompound.dict({ + ctor: CDict(), + members, + })); + } } diff --git a/src/runtime/rewrite.ts b/src/runtime/rewrite.ts index 288f40a..8eeadc4 100644 --- a/src/runtime/rewrite.ts +++ b/src/runtime/rewrite.ts @@ -1,5 +1,6 @@ import type { Assertion, Handle, Ref, Turn } from "./actor.js"; import { Bytes, Dictionary, DoubleFloat, embed, IdentityMap, is, isEmbedded, Record, SingleFloat, Tuple } from "@preserves/core"; +import { SturdyValue } from "../transport/sturdy.js"; import { Alts, @@ -22,7 +23,6 @@ import { Rewrite, TRef, Template, - _val, _embedded, } from '../gen/sturdy.js'; export * from '../gen/sturdy.js'; @@ -237,7 +237,7 @@ export function forwarder(t: Turn, ref: Ref): { proxy: Ref, revoker: Ref } { return { proxy, revoker }; } -export function pRec(label: _val, ... members: Array): Pattern { +export function pRec(label: SturdyValue, ... members: Array): Pattern { return Pattern.PCompound(PCompound({ ctor: ConstructorSpec.CRec(CRec({ label: label, arity: members.length })), members: PCompoundMembers(new Dictionary<_embedded, Pattern>( @@ -251,13 +251,13 @@ export function pArr(... members: Array): Pattern { members.map((p, i) => [i, p] as const).filter(e => e[1]._variant !== 'PDiscard')))})); } -export function pDict(... entries: [_val, Pattern][]): Pattern { +export function pDict(... entries: [SturdyValue, Pattern][]): Pattern { return Pattern.PCompound(PCompound({ ctor: ConstructorSpec.CDict(CDict()), members: PCompoundMembers(new Dictionary<_embedded, Pattern>(entries))})); } -export function pLit(value: _val): Pattern { +export function pLit(value: SturdyValue): Pattern { return Pattern.Lit(Lit(value)); } diff --git a/src/transport/protocol.ts b/src/transport/protocol.ts index 59a9497..23150e9 100644 --- a/src/transport/protocol.ts +++ b/src/transport/protocol.ts @@ -1,5 +1,5 @@ import * as S from '../gen/sturdy.js'; -import * as IO from '../gen/protocol.js'; +import * as IO from '../gen/externalProtocol.js'; import { Ref } from '../runtime/actor.js'; import { Decoder, DecoderState, Encoder, EncoderState, GenericEmbedded, neverEmbeddedType, EmbeddedType, Value } from '@preserves/core'; @@ -15,7 +15,7 @@ export const wireRefEmbeddedType: EmbeddedType = { }, fromValue(v: Value): S.WireRef { - return S.asWireRef(v as S._val); + return S.asWireRef(v as Value); }, toValue(v: S.WireRef): Value { diff --git a/src/transport/relay.ts b/src/transport/relay.ts index 4805929..80d29a8 100644 --- a/src/transport/relay.ts +++ b/src/transport/relay.ts @@ -1,6 +1,6 @@ import { Actor, Assertion, Entity, Facet, Handle, Ref, Turn } from '../runtime/actor.js'; import { BytesLike, Decoder, Dictionary, embed, encode, IdentityMap, mapEmbeddeds, underlying, Value } from '@preserves/core'; -import * as IO from '../gen/protocol.js'; +import * as IO from '../gen/externalProtocol.js'; import { wireRefEmbeddedType, WireSymbol } from './protocol.js'; import { queueTask } from '../runtime/task.js'; import { attenuate } from '../runtime/rewrite.js'; diff --git a/src/transport/sturdy.ts b/src/transport/sturdy.ts index 9f9a9ae..db566be 100644 --- a/src/transport/sturdy.ts +++ b/src/transport/sturdy.ts @@ -7,11 +7,11 @@ // California: Internet Society, 2014. import { mac } from './cryptography.js'; -import { Bytes, decode, encode, is, neverEmbeddedType } from '@preserves/core'; +import { Bytes, decode, encode, is, neverEmbeddedType, Value } from '@preserves/core'; import * as S from '../gen/sturdy.js'; export * from '../gen/sturdy.js'; -export type SturdyValue = S._val; +export type SturdyValue = Value; export const KEY_LENGTH = 16; // 128 bits