Added return to tweaked machine - WIP

Author: Riley-Kilgore

lib/uplc/tweaked_machine.ak

@@ -22,7 +22,7 @@ pub type Context {
   FrameAwaitFunTerm(Env, TermHash, ContextHash)
   FrameAwaitFunValue(Value, ContextHash)
   FrameForce(ContextHash)
-  FrameConstr(Env, Int, List<TermHash>, List<Value>, ContextHash)
+  FrameConstr(Env, Int, List<TermHash>, List<ValueHash>, ContextHash)
   FrameCases(Env, List<TermHash>, ContextHash)
   NoFrame
 }
@@ -184,3 +184,152 @@ pub fn compute(
     _ -> fail
   }
 }
+
+pub fn return(
+  ctx: Context,
+  value_hash: ValueHash,
+  value: Value,
+  inner_context: Option<Context>,
+) -> MachineState {
+  expect value_hash == ( value |> builtin.serialise_data |> hashing_algo )
+
+  when ctx is {
+    FrameAwaitArg(function, ctx_hash) ->
+      apply_eval(ctx_hash, function, value_hash, inner_context)
+    FrameAwaitFunTerm(arg_env, arg_hash, ctx_hash) -> {
+      let frame = FrameAwaitArg(value, ctx_hash)
+      Compute(frame, arg_env, arg_hash)
+    }
+    FrameAwaitFunValue(arg, ctx_hash) -> {
+      let arg_hash = arg |> builtin.serialise_data |> hashing_algo
+      apply_eval(ctx_hash, value, arg_hash, inner_context)
+    }
+    FrameForce(ctx_hash) ->
+      force_eval(ctx_hash, value_hash, value, inner_context)
+    NoFrame ->
+      Done(discharge_value(value) |> builtin.serialise_data |> hashing_algo)
+    FrameConstr(env, tag, fields, eval_fields, ctx_hash) -> {
+      // FrameConstr(Env, Int, List<TermHash>, List<Value>, ContextHash)
+      let done = [value_hash, ..eval_fields]
+
+      when fields is {
+        [] -> {
+          expect Some(inner_context) = inner_context
+          let constr_value = VConstr { tag, fields: done }
+          let constr_hash =
+            constr_value |> builtin.serialise_data |> hashing_algo
+          Return(inner_context, constr_hash)
+        }
+        [next_hash, ..rest] ->
+          Compute(FrameConstr(env, tag, rest, done, ctx_hash), env, next_hash)
+      }
+    }
+    FrameCases(env, cs, ctx_hash) ->
+      when value is {
+        VConstr { tag, fields } -> {
+          let branch_hash = cs |> list_at(tag)
+          // Use the new iterative approach instead of recursive transfer_fields
+          expect Some(ctx) = inner_context
+          expect ctx_hash == ( ctx |> builtin.serialise_data |> hashing_algo )
+          // Can we use a Return instead of IteratingFields?
+          if builtin.null_list(fields) {
+            // No fields to transfer
+            Compute(ctx, env, branch_hash)
+          } else {
+            todo
+          }
+        }
+        _ -> ErrorState("Not a constr")
+      }
+  }
+}
+
+fn force_eval(
+  ctx_hash: ContextHash,
+  value_hash: ValueHash,
+  value: Value,
+  ctx: Option<Context>,
+) -> MachineState {
+  expect Some(ctx) = ctx
+  expect ctx_hash == ( ctx |> builtin.serialise_data |> hashing_algo )
+  expect value_hash == ( ctx |> builtin.serialise_data |> hashing_algo )
+  when value is {
+    VDelay(body_hash, env) -> Compute(ctx, env, body_hash)
+    VBuiltin { fun, force_count, args_count, args } ->
+      if force_count > 0 {
+        let new_value =
+          VBuiltin { fun, force_count: force_count - 1, args_count, args }
+        let new_hash = new_value |> builtin.serialise_data |> hashing_algo
+        Return(ctx, new_hash)
+      } else {
+        ErrorState("builtin term argument expected")
+      }
+    _ -> ErrorState("nonpolymorphic instantiation")
+  }
+}
+
+fn apply_eval(
+  ctx_hash: ContextHash,
+  function: Value,
+  argument: ValueHash,
+  ctx: Option<Context>,
+) -> MachineState {
+  expect Some(ctx) = ctx
+  expect ctx_hash == ( ctx |> builtin.serialise_data |> hashing_algo )
+  when function is {
+    VLambda { body: body_hash, env } -> {
+      let new_env =
+        Node {
+          value: argument,
+          next: env |> builtin.serialise_data |> hashing_algo,
+        }
+      Compute(ctx, new_env, body_hash)
+    }
+    VBuiltin { fun, force_count, args_count, args } ->
+      if force_count == 0 {
+        let result = eval_builtin(fun, args_count, args, argument)
+        Return(ctx, result)
+      } else {
+        ErrorState("Unexpected Builtin Term Argument")
+      }
+    _ -> ErrorState("Not a function")
+  }
+}
+
+fn eval_builtin(
+  fun: Int,
+  args_count: Int,
+  args: List<ValueHash>,
+  next_arg: ValueHash,
+) -> ValueHash {
+  if args_count == 0 {
+    fail @"Impossible"
+  } else if args_count == 1 {
+    // TODO: Implement call_builtin for the tweaked machine
+    // This is a placeholder - actual implementation would need to handle builtins
+    fail @"call_builtin not implemented"
+  } else {
+    VBuiltin {
+      fun,
+      force_count: 0,
+      args_count: args_count - 1,
+      args: [next_arg, ..args],
+    }
+      |> builtin.serialise_data
+      |> hashing_algo
+  }
+}
+
+fn list_at(list: List<a>, index: Int) -> a {
+  if index == 0 {
+    list |> builtin.head_list
+  } else {
+    list |> builtin.tail_list |> list_at(index - 1)
+  }
+}
+
+fn discharge_value(value: Value) -> Term {
+  // This is a placeholder - actual implementation would need to convert Value to Term
+  // Similar to the implementation in machine.ak but adapted for the tweaked machine
+  fail @"discharge_value not implemented"
+}