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
 }
@@ -52,6 +52,7 @@ pub type MachineState {
   // ReturnAwaitValue(Context, ValueHash)
   Done(TermHash)
   IteratingEnv(Context, Env, Int)
+  // IteratingFields(Context, List<ValueHash>, Env, TermHash)
   ErrorState(ByteArray)
 }
 
@@ -134,3 +135,157 @@ 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 = Env {
+        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"
+}