2f:Tbf0,{ let { Machine } = await import('https://esm.run/@effect/experimental'); let { Schema } = await import("https://esm.run/@effect/schema"); let { Cause, Chunk, Data, Effect, List, Request, Schedule } = await import("https://esm.run/effect"); let assert = { strictEqual: (a, b) => { console.log(`${a} =?= ${b}`) } }; // Manually erased types for observable // class Increment extends Schema.TaggedRequest()("Increment",...) {} class Increment extends Schema.TaggedRequest()("Increment", Schema.never, Schema.number, {}) {} class Decrement extends Schema.TaggedRequest()("Decrement", Schema.never, Schema.number, {}) {} class IncrementBy extends Schema.TaggedRequest()("IncrementBy", Schema.never, Schema.number, { number: Schema.number }) {} class FailBackground extends Schema.TaggedRequest()("FailBackground", Schema.never, Schema.void, {}) {} // const counter = Machine.makeWith()(...) const counter = Machine.makeWith()( (input, previous) => Machine.procedures.make(previous ?? input, { identifier: `Counter(${input})` }).pipe( // Machine.procedures.add()("Increment",...) Machine.procedures.add()("Increment", ({ state }) => Effect.sync(() => { const count = state + 1 return [count, count] })), // Machine.procedures.add()("Decrement",...) Machine.procedures.add()("Decrement", ({ state }) => Effect.sync(() => { const count = state - 1 return [count, count] })), // Machine.procedures.add()("IncrementBy",...) Machine.procedures.add()("IncrementBy", ({ request, state }) => Effect.sync(() => { const count = state + request.number return [count, count] })), // Machine.procedures.add()(...) Machine.procedures.add()( "FailBackground", ({ forkWith, state }) => forkWith(Effect.fail("error"), state) ) ) ) const program = Effect.gen(function*(_) { yield* _(Effect.sleep(500)) // wait for DevTools const booted = yield* _(Machine.boot(counter, 0)) yield* _(Effect.sleep(10)) assert.strictEqual(yield* _(booted.state), 0) assert.strictEqual(yield* _(booted.send(new Increment())), 1) assert.strictEqual(yield* _(booted.send(new Increment())), 2) assert.strictEqual(yield* _(booted.send(new IncrementBy({ number: 2 }))), 4) assert.strictEqual(yield* _(booted.send(new Decrement())), 3) // assert.strictEqual(yield* _(booted.send(new FailBackground())), undefined) // const cause = yield* _(booted.join, Effect.sandbox, Effect.flip) // const failure = Cause.failures(cause).pipe(Chunk.unsafeHead) // assert.strictEqual(failure.cause, Cause.die("error")) return yield* _(booted.state) }).pipe( Effect.scoped, ); const result = Effect.runPromise(program) return result; // returns 3 as the latest state machine state in the observable cell }30:T45c,## crem > Crème de la Crem: Composable Representable Executable Machines https://arxiv.org/pdf/2307.09090.pdf Without the topology and the whole composition machinery: - using Action as Machine procedures with the `fields` as the Input type and State as a tuple of `[output, state]`. Not sure this example is benefitting from `Procedure` extending `TaggedRequest`? - implemented a quick and dirty monomorphised version of feedback `Feedback :: StateMachine a [b] → StateMachine b [a] → StateMachine a [b]` for now with mutable internal state. - might be best with a simpler Mealy type which extends Stream? (though SerialisableMachine seems useful) that would also mean defining semantics for composition of backpressure? Seems like it should be possible to also do the Kmett move (hiding `s` making Mealy composable) from: ```haskell data Mealy 𝑠 𝑎 𝑏 = Mealy { initialState :: 𝑠 , action :: 𝑠 → 𝑎 → (𝑏, 𝑠) } ``` to ```haskell newtype Mealy 𝑎 𝑏 = Mealy { runMealy :: 𝑎 → (𝑏, Mealy 𝑎 𝑏) } ``` ![image.png](${await FileAttachment("image.png").url()})31:T2fba,{ let { Machine } = await import('https://esm.run/@effect/experimental'); let { Schema: S } = await import("https://esm.run/@effect/schema"); let { Console, Cause, Chunk, Data, Effect, List, Request, Schedule, Match, ReadonlyArray } = await import("https://esm.run/effect"); const assert = { strictEqual: (a, b) => { console.log(`${a} =?= ${b}`); }, }; // In crem this defined at the type level together with a topology of allowed states // Here we use it as internal state for the state machine. // data CartVertex // = WaitingForPayment // | InitiatingPayment // | PaymentComplete const CartState = S.literal( "WaitingForPayment", "InitiatingPayment", "PaymentComplete", ); // type CartState = S.Schema.Type; const CartEvent = S.literal("CartPaymentInitiated", "CartPaymentCompleted"); // type CartEvent = S.Schema.Type; const CartEvents = S.array(CartEvent); // type CartEvents = S.Schema.Type; // data CartCommand // = PayCart // | MarkCartAsPaid // Commands // class PayCart extends S.TaggedRequest()( // "PayCart", // S.never, // CartEvents, // {}, // ) {} // class MarkCartAsPaid extends S.TaggedRequest()( // "MarkCartAsPaid", // S.never, // CartEvents, // {}, // ) {} // const CartCommand = S.union(PayCart, MarkCartAsPaid); const CartCommand = S.literal("PayCart", "MarkCartAsPaid"); // type CartCommand = S.Schema.Type; const CartCommands = S.array(CartCommand); // type CartCommands = S.Schema.Type; // Aggregate : StateMachine Command [Event] const AggregateState = S.tuple(CartEvents, CartState); // type AggregateState = S.Schema.Type; // class AggregateAction extends S.TaggedRequest()( class AggregateAction extends S.TaggedRequest()( "AggregateAction", S.never, AggregateState, { command: CartCommand }, ) {} // const pair = (a: T): [T, T] => [a, a] as [T, T]; const pair = (a) => [a, a]; // const cartAggregate = Machine.makeWith()( const cartAggregate = Machine.makeWith()( (input, previous) => Effect.gen(function* (_) { const state = previous ?? input; const fakeOutput = [ ["CartPaymentInitiated"], "WaitingForPayment", ]; // ] as const; return Machine.procedures .make(state, { identifier: `Cart(${state})`, }) .pipe( // Machine.procedures.add()( Machine.procedures.add()( "AggregateAction", ({ request: { command }, state: [_, state] }) => Effect.sync(() => // Match.type().pipe( Match.type().pipe( Match.when("WaitingForPayment", () => // Match.type().pipe( Match.type().pipe( Match.when("PayCart", () => // pair([ pair([ ["CartPaymentInitiated"], "InitiatingPayment", ]), ), Match.when("MarkCartAsPaid", () => // pair([[], "WaitingForPayment"]), pair([[], "WaitingForPayment"]), ), Match.exhaustive, )(command), ), Match.when("InitiatingPayment", () => // Match.type().pipe( Match.type().pipe( Match.when("PayCart", () => // pair([[], "InitiatingPayment"]), pair([[], "InitiatingPayment"]), ), Match.when("MarkCartAsPaid", () => // pair([ pair([ ["CartPaymentCompleted"], "PaymentComplete", ]), ), Match.exhaustive, )(command), ), Match.when("PaymentComplete", () => // pair([[], "PaymentComplete"]), pair([[], "PaymentComplete"]), ), Match.exhaustive, )(state), ), ), ); }), ); // Policy : StateMachine Event [Command] // class PolicyAction extends S.TaggedRequest()( class PolicyAction extends S.TaggedRequest()( "PolicyAction", S.never, CartCommands, { event: CartEvent }, ) {} // policies are stateless but we use state as the output here. // const paymentGateway = Machine.makeWith()(() => const paymentGateway = Machine.makeWith()(() => // Machine.procedures.make([] as CartCommands).pipe( Machine.procedures.make([]).pipe( // Machine.procedures.add()( Machine.procedures.add()( "PolicyAction", ({ forkOne, request: { event } }) => Effect.sync(() => // Match.type().pipe( Match.type().pipe( Match.when("CartPaymentInitiated", () => // pair(["MarkCartAsPaid"]), pair(["MarkCartAsPaid"]), ), // Match.when("CartPaymentCompleted", () => pair([])), Match.when("CartPaymentCompleted", () => pair([])), Match.exhaustive, )(event), ).pipe( Effect.tap((x) => Console.log("gateway: ", x)), // Effect.delay(2000), ), ), ), ); // Feedback // :: StateMachine a [b] // → StateMachine b [a] // → StateMachine a [b] // Feedback cart paymentGateway // Feedback // :: (StateMachine Command [Events]) // -> (StateMachine Event [Command]) // -> StateMachine Command [Events] // class FeedbackAction extends S.TaggedRequest()( class FeedbackAction extends S.TaggedRequest()( "FeedbackAction", S.never, AggregateState, { command: CartCommand }, ) {} // const feedback = ( // aggregate: Machine.Machine< // AggregateState, // AggregateAction, // never, // AggregateState, // never, // never // >, // policy: Machine.Machine< // CartCommands, // PolicyAction, // never, // void, // never, // never // >, // ): Machine.Machine< // AggregateState, // AggregateAction, // never, // AggregateState, // never, // never // > => const feedback = (aggregate, policy) => // Machine.makeWith()((input, previous) => Machine.makeWith()((input, previous) => Effect.gen(function* (_) { const state = previous ?? input; const _aggregate = yield* _(Machine.boot(aggregate, state)); const _policy = yield* _(Machine.boot(policy)); const fakeOutput = [ ["CartPaymentInitiated"], "WaitingForPayment", ]; // ] as const; return Machine.procedures .make(state, { identifier: `Cart(${state})`, }) .pipe( // Machine.procedures.add()( Machine.procedures.add()( "AggregateAction", ({ request: { command }, state: [_, state] }) => Effect.gen(function* (_) { const [events] = yield* _( _aggregate.send(new AggregateAction({ command })), ); const commands = yield* _( Effect.forEach(events, (event) => _policy.send(new PolicyAction({ event })), ), Effect.map((nested) => ReadonlyArray.flatten(nested)), ); let _commands = commands; // let _events: CartEvents = []; // let _lastState: CartState = state; let _events = []; let _lastState = state; while (ReadonlyArray.isNonEmptyArray(_commands)) { console.log("commands", _commands); _events = ReadonlyArray.appendAll( _events, yield* _( Effect.forEach(commands, (command) => _aggregate.send(new AggregateAction({ command })).pipe( Effect.map(([events, state]) => { _lastState = state; return events; }), ), ), Effect.map((nested) => ReadonlyArray.flatten(nested)), ), ); console.log("events", _events); _commands = yield* _( Effect.forEach(_events, (event) => _policy.send(new PolicyAction({ event })), ), Effect.map((nested) => ReadonlyArray.flatten(nested)), ); } // return pair([_events, _lastState]); return pair([_events, _lastState]); }), ), ); }), ); const program = Effect.gen(function* (_) { const booted = yield* _( Machine.boot(cartAggregate, [[], "WaitingForPayment"]), ); yield* _(Effect.sleep(10)); assert.strictEqual(yield* _(booted.state), "WaitingForPayment"); assert.strictEqual( yield* _(booted.send(new AggregateAction({ command: "PayCart" }))), "CartPaymentInitiated", ); assert.strictEqual(yield* _(booted.state), "InitiatingPayment"); assert.strictEqual( yield* _(booted.send(new AggregateAction({ command: "MarkCartAsPaid" }))), "CartPaymentCompleted", ); console.log("----------"); const bootedFeedback = yield* _( Machine.boot(feedback(cartAggregate, paymentGateway), [ [], "WaitingForPayment", ]), ); yield* _(Effect.sleep(10)); assert.strictEqual(yield* _(bootedFeedback.state), "WaitingForPayment"); assert.strictEqual( yield* _(bootedFeedback.send(new AggregateAction({ command: "PayCart" }))), "CartPaymentInitiated", ); // assert.strictEqual(yield* _(booted.send(new FailBackground())), undefined) // const cause = yield* _(booted.join, Effect.sandbox, Effect.flip) // const failure = Cause.failures(cause).pipe(Chunk.unsafeHead) // assert.strictEqual(failure.cause, Cause.die("error")) return yield* _(booted.state); }).pipe(Effect.scoped); const result = await Effect.runPromise(program); console.log("result: ", result); // ,WaitingForPayment =?= WaitingForPayment // CartPaymentInitiated,InitiatingPayment =?= CartPaymentInitiated // CartPaymentInitiated,InitiatingPayment =?= InitiatingPayment // CartPaymentCompleted,PaymentComplete =?= CartPaymentCompleted // ---------- // ,WaitingForPayment =?= WaitingForPayment // gateway: [ // [ "MarkCartAsPaid" ], [ "MarkCartAsPaid" ] // ] // commands [ "MarkCartAsPaid" ] // events [ "CartPaymentCompleted" ] // gateway: [ // [], [] // ] // CartPaymentCompleted,PaymentComplete =?= CartPaymentInitiated // result: [ // [ "CartPaymentCompleted" ], "PaymentComplete" // ] return result; // returns 3 as the latest state machine state in the observable cell }32:[{"id":"fcadbce6aa80082424ed62607dae39faae8816f37ff534a4d49ee07ea9c88f3a73a6768c7834510b58b36e3a7673d0a6112c38c5fb2eb86738751a54eb7713b6","href":"https://static.observableusercontent.com/files/fcadbce6aa80082424ed62607dae39faae8816f37ff534a4d49ee07ea9c88f3a73a6768c7834510b58b36e3a7673d0a6112c38c5fb2eb86738751a54eb7713b6","name":"image.png","type":"image/png","lastModified":1712733602474.011,"size":53742},{"id":"7c86ff6438327568b0feded62f5a0e51fb83174c3026ce9ce0555bd14b9ec962e34504d32c7135dff5664ad68d005636efb86d209c544bcda739cc1c98f0e69b","href":"https://static.observableusercontent.com/files/7c86ff6438327568b0feded62f5a0e51fb83174c3026ce9ce0555bd14b9ec962e34504d32c7135dff5664ad68d005636efb86d209c544bcda739cc1c98f0e69b","name":"image@1.png","type":"image/png","lastModified":1712733628346.87,"size":61831}] 2d:{"title":"@effect/experimental machines / DDD (Crème de la Crem)","cells":[{"id":0,"value":"# @effect/experimental machines / DDD (Crème de la Crem)\n\nKicking the tires of https://github.com/Effect-TS/effect/blob/main/packages/experimental/CHANGELOG.md#patch-changes-29\n\nThe Machine module can be used to create effectful state machines. It would be nice to add typesafe transitions:\n- like in https://github.com/eram/typescript-fsm\n- or with an indexed monad https://github.com/derrickbeining/fp-ts-indexed-monad\n- there's also a closed PR with xstate integration https://github.com/Effect-TS/effect/pull/2247 ","pinned":false,"hidden":false,"mode":"md"},{"id":21,"value":"$2f","pinned":true,"hidden":false,"mode":"ojs"},{"id":94,"value":"$30","pinned":false,"hidden":false,"mode":"md"},{"id":99,"value":"### Cart\n\nhttps://github.com/marcosh/crem/tree/main/examples/Crem/Example/Cart\n![image@1.png](${await FileAttachment(\"image@1.png\").url()})\n\nOutputs:\n```\n,WaitingForPayment =?= WaitingForPayment\nCartPaymentInitiated,InitiatingPayment =?= CartPaymentInitiated\nCartPaymentInitiated,InitiatingPayment =?= InitiatingPayment\nCartPaymentCompleted,PaymentComplete =?= CartPaymentCompleted\n----------\n,WaitingForPayment =?= WaitingForPayment\ngateway: [\n [ \"MarkCartAsPaid\" ], [ \"MarkCartAsPaid\" ]\n]\ncommands [ \"MarkCartAsPaid\" ]\nevents [ \"CartPaymentCompleted\" ]\ngateway: [\n [], []\n]\nCartPaymentCompleted,PaymentComplete =?= CartPaymentInitiated\nresult: [\n [ \"CartPaymentCompleted\" ], \"PaymentComplete\"\n]\n```","pinned":false,"hidden":false,"mode":"md"},{"id":96,"value":"$31","pinned":true,"hidden":false,"mode":"ojs"}],"files":"$W32","stdlib":"1","titling":"auto"}