Fully implements remove_{one,all,at}.

5 files changed, 326 insertions, 94 deletions

diff --git a/data/tests/extra_functionals.fate b/data/tests/extra_functionals.fate
index bc629cb..cdbebb3 100644
--- a/data/tests/extra_functionals.fate
+++ b/data/tests/extra_functionals.fate
@@ -55,4 +55,18 @@
 (set int_list_b (shuffle int_list_a))
 (shuffle! int_list_c)
 
+(set int_list_c (var int_list_a))
+(remove_one! 6 int_list_a)
+
+(= (var int_list_a) (remove_one 6 int_list_c))
+
+(set int_list_b (var int_list_a))
+(remove_all! 3 int_list_a)
+
+(= (var int_list_a) (remove_all 3 int_list_b))
+
+(set int_list_c (var int_list_a))
+(remove_at! 4 int_list_a)
+(= (var int_list_a) (remove_at 4 int_list_c))
+
 (end)
diff --git a/src/core/src/tonkadur/wyrd/v1/compiler/fate/v1/ComputationCompiler.java b/src/core/src/tonkadur/wyrd/v1/compiler/fate/v1/ComputationCompiler.java
index ccfc525..186fdd0 100644
--- a/src/core/src/tonkadur/wyrd/v1/compiler/fate/v1/ComputationCompiler.java
+++ b/src/core/src/tonkadur/wyrd/v1/compiler/fate/v1/ComputationCompiler.java
@@ -25,10 +25,12 @@ import tonkadur.wyrd.v1.compiler.util.IfElse;
 import tonkadur.wyrd.v1.compiler.util.If;
 import tonkadur.wyrd.v1.compiler.util.Shuffle;
 import tonkadur.wyrd.v1.compiler.util.RemoveAt;
+import tonkadur.wyrd.v1.compiler.util.RemoveAllOf;
+import tonkadur.wyrd.v1.compiler.util.RemoveOneOf;
 import tonkadur.wyrd.v1.compiler.util.CreateCons;
 import tonkadur.wyrd.v1.compiler.util.IterativeSearch;
 import tonkadur.wyrd.v1.compiler.util.CountOccurrences;
-
+import tonkadur.wyrd.v1.compiler.util.LambdaEvaluation;
 
 import tonkadur.wyrd.v1.lang.computation.*;
 
@@ -1744,21 +1746,18 @@ implements tonkadur.fate.v1.lang.meta.ComputationVisitor
       final ComputationCompiler target_line_cc;
       final List<Computation> parameters;
       final Register result;
-      final String return_to_label;
 
       parameters = new ArrayList<Computation>();
       target_line_cc = new ComputationCompiler(compiler);
 
-      return_to_label =
-         compiler.assembler().generate_label("<lambda_eval#return_to>");
-
       n.get_lambda_function_reference().get_visited_by(target_line_cc);
 
       assimilate(target_line_cc);
 
       result = reserve(TypeCompiler.compile(compiler, n.get_type()));
 
-      parameters.add(result.get_address());
+      result_as_address = result.get_address();
+      result_as_computation = result.get_value();
 
       for
       (
@@ -1776,29 +1775,17 @@ implements tonkadur.fate.v1.lang.meta.ComputationVisitor
          parameters.add(cc.get_computation());
       }
 
-      init_instructions.addAll
-      (
-         compiler.registers().store_parameters(parameters)
-      );
-
       init_instructions.add
       (
-         compiler.assembler().mark_after
+         LambdaEvaluation.generate
          (
-            compiler.assembler().merge
-            (
-               compiler.registers().get_visit_context_instructions
-               (
-                  target_line_cc.get_computation(),
-                  compiler.assembler().get_label_constant(return_to_label)
-               )
-            ),
-            return_to_label
+            compiler.registers(),
+            compiler.assembler(),
+            target_line_cc.get_computation(),
+            result_as_address,
+            parameters
          )
       );
-
-      result_as_address = result.get_address();
-      result_as_computation = result.get_value();
    }
 
    @Override
@@ -2020,7 +2007,46 @@ implements tonkadur.fate.v1.lang.meta.ComputationVisitor
    )
    throws Throwable
    {
-      /* TODO */
+      final ComputationCompiler address_compiler, target_compiler;
+      final Address collection_address;
+      final Register result;
+
+      result = reserve(TypeCompiler.compile(compiler, n.get_type()));
+      result_as_address = result.get_address();
+      result_as_computation = result.get_value();
+
+      address_compiler = new ComputationCompiler(compiler);
+      target_compiler = new ComputationCompiler(compiler);
+
+      n.get_collection().get_visited_by(address_compiler);
+
+      if (address_compiler.has_init())
+      {
+         init_instructions.add(address_compiler.get_init());
+      }
+
+      init_instructions.add
+      (
+         new SetValue(result_as_address, address_compiler.get_computation())
+      );
+
+      address_compiler.release_registers(init_instructions);
+
+      n.get_element().get_visited_by(target_compiler);
+
+      assimilate(target_compiler);
+
+      init_instructions.add
+      (
+         RemoveAllOf.generate
+         (
+            compiler.registers(),
+            compiler.assembler(),
+            target_compiler.get_computation(),
+            new Size(result_as_address),
+            result_as_address
+         )
+      );
    }
 
    @Override
@@ -2030,7 +2056,48 @@ implements tonkadur.fate.v1.lang.meta.ComputationVisitor
    )
    throws Throwable
    {
-      /* TODO */
+      final ComputationCompiler address_compiler, target_compiler;
+      final Address collection_address;
+      final Register result, target_index;
+
+      result = reserve(TypeCompiler.compile(compiler, n.get_type()));
+      result_as_address = result.get_address();
+      result_as_computation = result.get_value();
+
+      address_compiler = new ComputationCompiler(compiler);
+      target_compiler = new ComputationCompiler(compiler);
+
+      n.get_collection().get_visited_by(address_compiler);
+
+      if (address_compiler.has_init())
+      {
+         init_instructions.add(address_compiler.get_init());
+      }
+
+      init_instructions.add
+      (
+         new SetValue(result_as_address, address_compiler.get_computation())
+      );
+
+      address_compiler.release_registers(init_instructions);
+
+      n.get_index().get_visited_by(target_compiler);
+
+      target_compiler.generate_address();
+
+      assimilate(target_compiler);
+
+      init_instructions.add
+      (
+         RemoveAt.generate
+         (
+            compiler.registers(),
+            compiler.assembler(),
+            target_compiler.get_address(),
+            new Size(result_as_address),
+            result_as_address
+         )
+      );
    }
 
    @Override
@@ -2040,7 +2107,50 @@ implements tonkadur.fate.v1.lang.meta.ComputationVisitor
    )
    throws Throwable
    {
-      /* TODO */
+      final ComputationCompiler elem_cc, collection_cc;
+      final Register result;
+
+      elem_cc = new ComputationCompiler(compiler);
+      collection_cc = new ComputationCompiler(compiler);
+
+      result = reserve(TypeCompiler.compile(compiler, n.get_type()));
+      result_as_address = result.get_address();
+      result_as_computation = result.get_value();
+
+      n.get_collection().get_visited_by(collection_cc);
+
+      if (collection_cc.has_init())
+      {
+         init_instructions.add(collection_cc.get_init());
+      }
+
+      init_instructions.add
+      (
+         new SetValue(result_as_address, collection_cc.get_computation())
+      );
+
+      collection_cc.release_registers(init_instructions);
+
+      n.get_element().get_visited_by(elem_cc);
+
+      elem_cc.generate_address();
+
+      assimilate(elem_cc);
+
+      init_instructions.add
+      (
+         RemoveOneOf.generate
+         (
+            compiler.registers(),
+            compiler.assembler(),
+            elem_cc.get_computation(),
+            result_as_address,
+            (
+               (tonkadur.fate.v1.lang.type.CollectionType)
+               n.get_collection().get_type()
+            ).is_set()
+         )
+      );
    }
 
    @Override
diff --git a/src/core/src/tonkadur/wyrd/v1/compiler/fate/v1/InstructionCompiler.java b/src/core/src/tonkadur/wyrd/v1/compiler/fate/v1/InstructionCompiler.java
index 1f47d8f..ba268f1 100644
--- a/src/core/src/tonkadur/wyrd/v1/compiler/fate/v1/InstructionCompiler.java
+++ b/src/core/src/tonkadur/wyrd/v1/compiler/fate/v1/InstructionCompiler.java
@@ -52,6 +52,7 @@ import tonkadur.wyrd.v1.compiler.util.Shuffle;
 import tonkadur.wyrd.v1.compiler.util.Clear;
 import tonkadur.wyrd.v1.compiler.util.IterativeSearch;
 import tonkadur.wyrd.v1.compiler.util.RemoveAllOf;
+import tonkadur.wyrd.v1.compiler.util.RemoveOneOf;
 import tonkadur.wyrd.v1.compiler.util.ReverseList;
 import tonkadur.wyrd.v1.compiler.util.RemoveAt;
 
@@ -2054,16 +2055,10 @@ implements tonkadur.fate.v1.lang.meta.InstructionVisitor
        * )
        */
       final ComputationCompiler elem_cc, collection_cc;
-      final Register collection_size, found, index;
-      final Address elem, collection;
 
       elem_cc = new ComputationCompiler(compiler);
       collection_cc = new ComputationCompiler(compiler);
 
-      collection_size = compiler.registers().reserve(Type.INT, result);
-      found = compiler.registers().reserve(Type.BOOL, result);
-      index = compiler.registers().reserve(Type.INT, result);
-
       n.get_element().get_visited_by(elem_cc);
       n.get_collection().get_visited_by(collection_cc);
 
@@ -2079,76 +2074,21 @@ implements tonkadur.fate.v1.lang.meta.InstructionVisitor
          result.add(collection_cc.get_init());
       }
 
-      elem = elem_cc.get_address();
-      collection = collection_cc.get_address();
-
-      result.add
-      (
-         new SetValue(collection_size.get_address(), new Size(collection))
-      );
-
-
-      if
-      (
-         (
-            (tonkadur.fate.v1.lang.type.CollectionType)
-            n.get_collection().get_type()
-         ).is_set()
-      )
-      {
-         result.add
-         (
-            BinarySearch.generate
-            (
-               compiler.registers(),
-               compiler.assembler(),
-               new ValueOf(elem),
-               collection_size.get_value(),
-               collection,
-               found.get_address(),
-               index.get_address()
-            )
-         );
-      }
-      else
-      {
-         result.add
-         (
-            IterativeSearch.generate
-            (
-               compiler.registers(),
-               compiler.assembler(),
-               new ValueOf(elem),
-               collection_size.get_value(),
-               collection,
-               found.get_address(),
-               index.get_address()
-            )
-         );
-      }
-
       result.add
       (
-         If.generate
+         RemoveOneOf.generate
          (
             compiler.registers(),
             compiler.assembler(),
-            new ValueOf(found.get_address()),
-            RemoveAt.generate
+            elem_cc.get_computation(),
+            collection_cc.get_address(),
             (
-               compiler.registers(),
-               compiler.assembler(),
-               index.get_address(),
-               collection_size.get_value(),
-               collection
-            )
+               (tonkadur.fate.v1.lang.type.CollectionType)
+               n.get_collection().get_type()
+            ).is_set()
          )
       );
 
-      compiler.registers().release(index, result);
-      compiler.registers().release(found, result);
-      compiler.registers().release(collection_size, result);
-
       elem_cc.release_registers(result);
       collection_cc.release_registers(result);
    }
diff --git a/src/core/src/tonkadur/wyrd/v1/compiler/util/LambdaEvaluation.java b/src/core/src/tonkadur/wyrd/v1/compiler/util/LambdaEvaluation.java
new file mode 100644
index 0000000..976c60e
--- /dev/null
+++ b/src/core/src/tonkadur/wyrd/v1/compiler/util/LambdaEvaluation.java
@@ -0,0 +1,58 @@
+package tonkadur.wyrd.v1.compiler.util;
+
+import java.util.List;
+import java.util.ArrayList;
+
+import tonkadur.wyrd.v1.lang.meta.Instruction;
+import tonkadur.wyrd.v1.lang.meta.Computation;
+import tonkadur.wyrd.v1.lang.computation.Address;
+
+import tonkadur.wyrd.v1.lang.instruction.SetValue;
+
+import tonkadur.wyrd.v1.compiler.util.registers.RegisterManager;
+
+public class LambdaEvaluation
+{
+   /* Utility Class */
+   private LambdaEvaluation () {}
+
+   /* Uses Durstenfeld's shuffling algorithm */
+   public static Instruction generate
+   (
+      final RegisterManager registers,
+      final InstructionManager assembler,
+      final Computation lambda_function,
+      final Address result_storage,
+      final List<Computation> parameters
+   )
+   {
+      final List<Instruction> result;
+      final String return_to_label;
+
+      result = new ArrayList<Instruction>();
+
+      return_to_label = assembler.generate_label("<lambda_eval#return_to>");
+
+      parameters.add(0, result_storage);
+
+      result.addAll(registers.store_parameters(parameters));
+
+      result.add
+      (
+         assembler.mark_after
+         (
+            assembler.merge
+            (
+               registers.get_visit_context_instructions
+               (
+                  lambda_function,
+                  assembler.get_label_constant(return_to_label)
+               )
+            ),
+            return_to_label
+         )
+      );
+
+      return assembler.merge(result);
+   }
+}
diff --git a/src/core/src/tonkadur/wyrd/v1/compiler/util/RemoveOneOf.java b/src/core/src/tonkadur/wyrd/v1/compiler/util/RemoveOneOf.java
new file mode 100644
index 0000000..50f7d82
--- /dev/null
+++ b/src/core/src/tonkadur/wyrd/v1/compiler/util/RemoveOneOf.java
@@ -0,0 +1,110 @@
+package tonkadur.wyrd.v1.compiler.util;
+
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Collections;
+
+import tonkadur.wyrd.v1.lang.Register;
+
+import tonkadur.wyrd.v1.lang.type.Type;
+
+import tonkadur.wyrd.v1.lang.meta.Computation;
+import tonkadur.wyrd.v1.lang.meta.Instruction;
+
+import tonkadur.wyrd.v1.lang.computation.Cast;
+import tonkadur.wyrd.v1.lang.computation.Constant;
+import tonkadur.wyrd.v1.lang.computation.Operation;
+import tonkadur.wyrd.v1.lang.computation.Address;
+import tonkadur.wyrd.v1.lang.computation.RelativeAddress;
+import tonkadur.wyrd.v1.lang.computation.ValueOf;
+import tonkadur.wyrd.v1.lang.computation.Size;
+
+import tonkadur.wyrd.v1.lang.instruction.SetValue;
+
+import tonkadur.wyrd.v1.compiler.util.registers.RegisterManager;
+
+public class RemoveOneOf
+{
+   /* Utility Class */
+   private RemoveOneOf () {}
+   public static Instruction generate
+   (
+      final RegisterManager registers,
+      final InstructionManager assembler,
+      final Computation element,
+      final Address collection,
+      final boolean is_set
+   )
+   {
+      final Register collection_size, found, index;
+      final List<Instruction> result;
+
+      result = new ArrayList<Instruction>();
+
+      index = registers.reserve(Type.INT, result);
+      collection_size = registers.reserve(Type.INT, result);
+      found = registers.reserve(Type.BOOL, result);
+
+      result.add
+      (
+         new SetValue(collection_size.get_address(), new Size(collection))
+      );
+
+      if (is_set)
+      {
+         result.add
+         (
+            BinarySearch.generate
+            (
+               registers,
+               assembler,
+               element,
+               collection_size.get_value(),
+               collection,
+               found.get_address(),
+               index.get_address()
+            )
+         );
+      }
+      else
+      {
+         result.add
+         (
+            IterativeSearch.generate
+            (
+               registers,
+               assembler,
+               element,
+               collection_size.get_value(),
+               collection,
+               found.get_address(),
+               index.get_address()
+            )
+         );
+      }
+
+      result.add
+      (
+         If.generate
+         (
+            registers,
+            assembler,
+            found.get_value(),
+            RemoveAt.generate
+            (
+               registers,
+               assembler,
+               index.get_address(),
+               collection_size.get_value(),
+               collection
+            )
+         )
+      );
+
+      registers.release(index, result);
+      registers.release(collection_size, result);
+      registers.release(found, result);
+
+      return assembler.merge(result);
+   }
+}