reduced examples to show Anders

Author: dimitropoulos

Diff for: packages/conformance-tests/from-wat/memory-grow.wat

@@ -4,7 +4,7 @@
   (func $entry (export "entry") (result i32 i32 i32)
     memory.size  ;; pushes 42 to the stack
     i32.const 27 ;; we will grow by 27 pages
-    memory.grow  ;; grows and pushes 69 to the stack
+    memory.grow  ;; grows and pushes 42 to the stack (the previous value)
     memory.size  ;; pushes 69 to the stack
   )
 )

Diff for: packages/playground/evaluate/start.ts

@@ -1,3 +1,3 @@
-import type { funcs } from "../doom/doom";
-import type { entry } from "../doom/doom";
-export type NextResult = entry<[], true, 0>;
+import type { funcs } from "../../conformance-tests/from-c/conway";
+import type { entry } from "../../conformance-tests/from-c/conway";
+export type NextResult = entry<[0], true, 0>;

Diff for: packages/playground/toy-examples/0-simplest-possible.ts

@@ -0,0 +1,93 @@
+/** tells the machine to add a string to the current */
+type AddInstruction = {
+  kind: 'add';
+  value: string;
+}
+
+type HandleAddInstruction<
+  instruction extends AddInstruction,
+  state extends ProgramState
+> = {
+  instructions: state['instructions'];
+  result: `${state['result']}${instruction['value']}`;
+}
+
+/** tells the machine to uppercase the whole string */
+type UppercaseInstruction = {
+  kind: 'uppercase';
+}
+
+type HandleUppercaseInstruction<
+  instruction extends UppercaseInstruction, // unused, but the instruction itself is always passed first to an instruction handler for consistency
+  state extends ProgramState
+> = {
+  instructions: state['instructions'];
+  result: Uppercase<state['result']>;
+}
+
+type Instruction = AddInstruction | UppercaseInstruction;
+
+type selectInstruction<
+  initialState extends ProgramState,
+  remainingInstructions extends Instruction[],
+  instruction extends Instruction,
+  state extends ProgramState = {
+    instructions: remainingInstructions;
+    result: initialState['result'];
+  }
+> =
+  instruction extends AddInstruction
+  ? HandleAddInstruction<instruction, state>
+
+  : instruction extends UppercaseInstruction
+  ? HandleUppercaseInstruction<instruction, state>
+
+  : never
+
+
+type ProgramState = {
+  instructions: Instruction[];
+  result: string;
+}
+
+type executeInstruction<
+  state extends ProgramState
+> =
+  state['instructions'] extends [
+    infer instruction extends Instruction,
+    ...infer remainingInstructions extends Instruction[]
+  ]
+
+  ? executeInstruction<
+      selectInstruction<
+        state,
+        remainingInstructions,
+        instruction
+      >
+    >
+
+  : state['result'];
+
+type Bootstrap = {
+  instructions: [
+    {
+      kind: 'add',
+      value: 'hello'
+    },
+    {
+      kind: 'add',
+      value: ' world'
+    },
+    {
+      kind: 'uppercase'
+    },
+    {
+      kind: 'add',
+      value: '!'
+    },
+  ];
+  result: '';
+}
+
+type Execution = executeInstruction<Bootstrap>;
+//   ^?

Diff for: packages/playground/toy-examples/1-with-stopping.ts

@@ -0,0 +1,124 @@
+/** tells the machine to add a string to the current */
+export type AddInstruction = {
+  kind: 'add';
+  value: string;
+}
+
+export type HandleAddInstruction<
+  instruction extends AddInstruction,
+  state extends ProgramState
+> = {
+  count: state['count'];
+  instructions: state['instructions'];
+  result: `${state['result']}${instruction['value']}`;
+}
+
+/** tells the machine to uppercase the whole string */
+export type UppercaseInstruction = {
+  kind: 'uppercase';
+}
+
+export type HandleUppercaseInstruction<
+  instruction extends UppercaseInstruction, // unused, but the instruction itself is always passed first to an instruction handler for consistency
+  state extends ProgramState
+> = {
+  count: state['count'];
+  instructions: state['instructions'];
+  result: Uppercase<state['result']>;
+}
+
+export type Instruction = AddInstruction | UppercaseInstruction;
+
+export type selectInstruction<
+  initialState extends ProgramState,
+  remainingInstructions extends Instruction[],
+  instruction extends Instruction,
+  state extends ProgramState = {
+    count: [...initialState['count'], 1];
+    instructions: remainingInstructions;
+    result: initialState['result'];
+  }
+> =
+  instruction extends AddInstruction
+  ? HandleAddInstruction<instruction, state>
+
+  : instruction extends UppercaseInstruction
+  ? HandleUppercaseInstruction<instruction, state>
+
+  : never
+
+
+export type ProgramState = {
+  count: 1[];
+  instructions: Instruction[];
+  result: string;
+}
+
+export type executeInstruction<
+  state extends ProgramState,
+  stopAt extends number = 1000,
+> =
+  state['instructions'] extends [
+    infer instruction extends Instruction,
+    ...infer remainingInstructions extends Instruction[]
+  ]
+
+  ? stopAt extends state['count']['length']
+    ? state
+    : executeInstruction<
+        selectInstruction<
+          state,
+          remainingInstructions,
+          instruction
+        >,
+        stopAt
+      >
+
+  : state['result'];
+
+
+export type Bootstrap = {
+  count: [];
+  instructions: [
+    {
+      kind: 'add',
+      value: 'hello'
+    },
+    {
+      kind: 'add',
+      value: ' world'
+    },
+    {
+      kind: 'uppercase'
+    },
+    {
+      kind: 'add',
+      value: '!'
+    },
+  ];
+  result: '';
+}
+
+// with no explicit `stopAt`, the program will run until it's done
+export type Execution = executeInstruction<Bootstrap>;
+//          ^?
+
+export type Execution0 = executeInstruction<Bootstrap, 0>;
+export type Execution0Result = Execution0['result'];
+//          ^?
+
+export type Execution1 = executeInstruction<Bootstrap, 1>;
+export type Execution1Result = Execution1['result']
+//          ^?
+
+export type Execution2 = executeInstruction<Bootstrap, 2>;
+export type Execution2Result = Execution2['result']
+//          ^?
+
+export type Execution3 = executeInstruction<Bootstrap, 3>;
+export type Execution3Result = Execution3['result']
+//          ^?
+
+export type Execution4 = executeInstruction<Bootstrap, 4>;
+export type Execution4Result = Execution4
+//          ^?