...

17 files changed, 2425 insertions, 16 deletions

diff --git a/src/core/src/tonkadur/fate/v1/lang/computation/IndexedFilterComputation.java b/src/core/src/tonkadur/fate/v1/lang/computation/IndexedFilterComputation.java
new file mode 100644
index 0000000..573a78f
--- /dev/null
+++ b/src/core/src/tonkadur/fate/v1/lang/computation/IndexedFilterComputation.java
@@ -0,0 +1,137 @@
+package tonkadur.fate.v1.lang.computation;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.ArrayList;
+
+import tonkadur.parser.Origin;
+import tonkadur.parser.ParsingError;
+
+import tonkadur.fate.v1.lang.type.Type;
+import tonkadur.fate.v1.lang.type.CollectionType;
+
+import tonkadur.fate.v1.lang.meta.ComputationVisitor;
+import tonkadur.fate.v1.lang.meta.Computation;
+import tonkadur.fate.v1.lang.meta.Computation;
+import tonkadur.fate.v1.lang.meta.RecurrentChecks;
+
+public class IndexedFilterComputation extends Computation
+{
+   /***************************************************************************/
+   /**** MEMBERS **************************************************************/
+   /***************************************************************************/
+   protected final List<Computation> extra_params;
+   protected final Computation lambda_function;
+   protected final Computation collection;
+
+   /***************************************************************************/
+   /**** PROTECTED ************************************************************/
+   /***************************************************************************/
+   /**** Constructors *********************************************************/
+   protected IndexedFilterComputation
+   (
+      final Origin origin,
+      final Computation lambda_function,
+      final Computation collection,
+      final List<Computation> extra_params
+   )
+   {
+      super(origin, collection.get_type());
+
+      this.lambda_function = lambda_function;
+      this.collection = collection;
+      this.extra_params = extra_params;
+   }
+
+   /***************************************************************************/
+   /**** PUBLIC ***************************************************************/
+   /***************************************************************************/
+   /**** Constructors *********************************************************/
+   public static IndexedFilterComputation build
+   (
+      final Origin origin,
+      final Computation lambda_function,
+      final Computation collection,
+      final List<Computation> extra_params
+   )
+   throws ParsingError
+   {
+      final List<Type> target_signature;
+
+      target_signature = new ArrayList<Type>();
+
+      RecurrentChecks.assert_is_a_collection(collection);
+
+      target_signature.add(Type.INT);
+      target_signature.add
+      (
+         ((CollectionType) collection.get_type()).get_content_type()
+      );
+
+      for (final Computation c: extra_params)
+      {
+         target_signature.add(c.get_type());
+      }
+
+      RecurrentChecks.assert_lambda_matches_types
+      (
+         lambda_function,
+         Type.BOOL,
+         target_signature
+      );
+
+      return
+         new IndexedFilterComputation
+         (
+            origin,
+            lambda_function,
+            collection,
+            extra_params
+         );
+   }
+
+   /**** Accessors ************************************************************/
+   @Override
+   public void get_visited_by (final ComputationVisitor cv)
+   throws Throwable
+   {
+      cv.visit_indexed_filter(this);
+   }
+
+   public Computation get_lambda_function ()
+   {
+      return lambda_function;
+   }
+
+   public Computation get_collection ()
+   {
+      return collection;
+   }
+
+   public List<Computation> get_extra_parameters ()
+   {
+      return extra_params;
+   }
+
+   /**** Misc. ****************************************************************/
+   @Override
+   public String toString ()
+   {
+      final StringBuilder sb = new StringBuilder();
+
+      sb.append("(IndexedFilter ");
+      sb.append(lambda_function.toString());
+      sb.append(" ");
+      sb.append(collection.toString());
+
+      for (final Computation c: extra_params)
+      {
+         sb.append(" ");
+         sb.append(c.toString());
+      }
+
+      sb.append(")");
+
+      return sb.toString();
+   }
+}
diff --git a/src/core/src/tonkadur/fate/v1/lang/computation/IndexedMergeComputation.java b/src/core/src/tonkadur/fate/v1/lang/computation/IndexedMergeComputation.java
new file mode 100644
index 0000000..3a81b53
--- /dev/null
+++ b/src/core/src/tonkadur/fate/v1/lang/computation/IndexedMergeComputation.java
@@ -0,0 +1,178 @@
+package tonkadur.fate.v1.lang.computation;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import tonkadur.parser.Origin;
+import tonkadur.parser.ParsingError;
+
+import tonkadur.fate.v1.lang.type.Type;
+import tonkadur.fate.v1.lang.type.LambdaType;
+import tonkadur.fate.v1.lang.type.CollectionType;
+
+import tonkadur.fate.v1.lang.meta.ComputationVisitor;
+import tonkadur.fate.v1.lang.meta.Computation;
+import tonkadur.fate.v1.lang.meta.Computation;
+import tonkadur.fate.v1.lang.meta.RecurrentChecks;
+
+public class IndexedMergeComputation extends Computation
+{
+   /***************************************************************************/
+   /**** MEMBERS **************************************************************/
+   /***************************************************************************/
+   protected final List<Computation> extra_params;
+   protected final Computation lambda_function;
+   protected final Computation collection_in_a;
+   protected final Computation collection_in_b;
+   protected final boolean to_set;
+
+   /***************************************************************************/
+   /**** PROTECTED ************************************************************/
+   /***************************************************************************/
+   /**** Constructors *********************************************************/
+   protected IndexedMergeComputation
+   (
+      final Origin origin,
+      final Computation lambda_function,
+      final Computation collection_in_a,
+      final Computation collection_in_b,
+      final boolean to_set,
+      final List<Computation> extra_params,
+      final Type output_type
+   )
+   {
+      super(origin, output_type);
+
+      this.lambda_function = lambda_function;
+      this.collection_in_a = collection_in_a;
+      this.collection_in_b = collection_in_b;
+      this.to_set = to_set;
+      this.extra_params = extra_params;
+   }
+
+   /***************************************************************************/
+   /**** PUBLIC ***************************************************************/
+   /***************************************************************************/
+   /**** Constructors *********************************************************/
+   public static IndexedMergeComputation build
+   (
+      final Origin origin,
+      final Computation lambda_function,
+      final Computation collection_in_a,
+      final Computation collection_in_b,
+      final boolean to_set,
+      final List<Computation> extra_params
+   )
+   throws Throwable
+   {
+      final List<Type> types_in;
+
+      types_in = new ArrayList<Type>();
+
+      RecurrentChecks.assert_is_a_collection(collection_in_a);
+      RecurrentChecks.assert_is_a_collection(collection_in_b);
+
+      types_in.add(Type.INT);
+
+      types_in.add
+      (
+         ((CollectionType) collection_in_a.get_type()).get_content_type()
+      );
+
+      types_in.add
+      (
+         ((CollectionType) collection_in_b.get_type()).get_content_type()
+      );
+
+      for (final Computation c: extra_params)
+      {
+         types_in.add(c.get_type());
+      }
+
+      RecurrentChecks.assert_lambda_matches_types(lambda_function, types_in);
+
+      return
+         new IndexedMergeComputation
+         (
+            origin,
+            lambda_function,
+            collection_in_a,
+            collection_in_b,
+            to_set,
+            extra_params,
+            CollectionType.build
+            (
+               origin,
+               ((LambdaType) lambda_function.get_type()).get_return_type(),
+               to_set,
+               "auto generated"
+            )
+         );
+   }
+
+   /**** Accessors ************************************************************/
+   @Override
+   public void get_visited_by (final ComputationVisitor cv)
+   throws Throwable
+   {
+      cv.visit_indexed_merge(this);
+   }
+
+   public Computation get_lambda_function ()
+   {
+      return lambda_function;
+   }
+
+   public Computation get_collection_in_a ()
+   {
+      return collection_in_a;
+   }
+
+   public Computation get_collection_in_b ()
+   {
+      return collection_in_b;
+   }
+
+   public List<Computation> get_extra_parameters ()
+   {
+      return extra_params;
+   }
+
+   public boolean to_set ()
+   {
+      return to_set;
+   }
+
+   /**** Misc. ****************************************************************/
+   @Override
+   public String toString ()
+   {
+      final StringBuilder sb = new StringBuilder();
+
+      if (to_set)
+      {
+         sb.append("(IndexedMergeToSet ");
+      }
+      else
+      {
+         sb.append("(IndexedMergeToList ");
+      }
+
+      sb.append(lambda_function.toString());
+      sb.append(" ");
+      sb.append(collection_in_a.toString());
+      sb.append(" ");
+
+      sb.append(collection_in_b.toString());
+
+      for (final Computation c: extra_params)
+      {
+         sb.append(" ");
+         sb.append(c.toString());
+      }
+
+      sb.append(")");
+
+      return sb.toString();
+   }
+}
diff --git a/src/core/src/tonkadur/fate/v1/lang/computation/IndexedPartitionComputation.java b/src/core/src/tonkadur/fate/v1/lang/computation/IndexedPartitionComputation.java
new file mode 100644
index 0000000..d192f36
--- /dev/null
+++ b/src/core/src/tonkadur/fate/v1/lang/computation/IndexedPartitionComputation.java
@@ -0,0 +1,151 @@
+package tonkadur.fate.v1.lang.computation;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.ArrayList;
+
+import tonkadur.parser.Origin;
+import tonkadur.parser.ParsingError;
+
+import tonkadur.fate.v1.lang.type.CollectionType;
+import tonkadur.fate.v1.lang.type.ConsType;
+import tonkadur.fate.v1.lang.type.Type;
+
+import tonkadur.fate.v1.lang.meta.ComputationVisitor;
+import tonkadur.fate.v1.lang.meta.Computation;
+import tonkadur.fate.v1.lang.meta.Computation;
+import tonkadur.fate.v1.lang.meta.RecurrentChecks;
+
+public class IndexedPartitionComputation extends Computation
+{
+   /***************************************************************************/
+   /**** MEMBERS **************************************************************/
+   /***************************************************************************/
+   protected final List<Computation> extra_params;
+   protected final Computation lambda_function;
+   protected final Computation collection;
+
+   /***************************************************************************/
+   /**** PROTECTED ************************************************************/
+   /***************************************************************************/
+   /**** Constructors *********************************************************/
+   protected IndexedPartitionComputation
+   (
+      final Origin origin,
+      final Computation lambda_function,
+      final Computation collection,
+      final List<Computation> extra_params,
+      final Type output_type
+   )
+   {
+      super(origin, output_type);
+
+      this.lambda_function = lambda_function;
+      this.collection = collection;
+      this.extra_params = extra_params;
+   }
+
+   /***************************************************************************/
+   /**** PUBLIC ***************************************************************/
+   /***************************************************************************/
+   /**** Constructors *********************************************************/
+   public static IndexedPartitionComputation build
+   (
+      final Origin origin,
+      final Computation lambda_function,
+      final Computation collection,
+      final List<Computation> extra_params
+   )
+   throws Throwable
+   {
+      final Type type;
+      final List<Type> target_signature;
+
+      target_signature = new ArrayList<Type>();
+
+      RecurrentChecks.assert_is_a_collection(collection);
+
+      target_signature.add(Type.INT);
+
+      target_signature.add
+      (
+         ((CollectionType) collection.get_type()).get_content_type()
+      );
+
+      for (final Computation c: extra_params)
+      {
+         target_signature.add(c.get_type());
+      }
+
+      RecurrentChecks.assert_lambda_matches_types
+      (
+         lambda_function,
+         Type.BOOL,
+         target_signature
+      );
+
+      type =
+         new ConsType
+         (
+            origin,
+            collection.get_type(),
+            collection.get_type(),
+            "auto generated"
+         );
+
+      return
+         new IndexedPartitionComputation
+         (
+            origin,
+            lambda_function,
+            collection,
+            extra_params,
+            type
+         );
+   }
+
+   /**** Accessors ************************************************************/
+   @Override
+   public void get_visited_by (final ComputationVisitor cv)
+   throws Throwable
+   {
+      cv.visit_indexed_partition(this);
+   }
+
+   public Computation get_lambda_function ()
+   {
+      return lambda_function;
+   }
+
+   public Computation get_collection ()
+   {
+      return collection;
+   }
+
+   public List<Computation> get_extra_parameters ()
+   {
+      return extra_params;
+   }
+
+   /**** Misc. ****************************************************************/
+   @Override
+   public String toString ()
+   {
+      final StringBuilder sb = new StringBuilder();
+
+      sb.append("(IndexedPartition ");
+      sb.append(lambda_function.toString());
+      sb.append(" ");
+      sb.append(collection.toString());
+
+      for (final Computation c: extra_params)
+      {
+         sb.append(" ");
+         sb.append(c.toString());
+      }
+
+      sb.append(")");
+
+      return sb.toString();
+   }
+}
diff --git a/src/core/src/tonkadur/fate/v1/lang/instruction/IndexedFilter.java b/src/core/src/tonkadur/fate/v1/lang/instruction/IndexedFilter.java
new file mode 100644
index 0000000..e05b162
--- /dev/null
+++ b/src/core/src/tonkadur/fate/v1/lang/instruction/IndexedFilter.java
@@ -0,0 +1,131 @@
+package tonkadur.fate.v1.lang.instruction;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.ArrayList;
+
+import tonkadur.parser.Origin;
+import tonkadur.parser.ParsingError;
+
+import tonkadur.fate.v1.lang.type.Type;
+import tonkadur.fate.v1.lang.type.LambdaType;
+import tonkadur.fate.v1.lang.type.CollectionType;
+
+import tonkadur.fate.v1.lang.meta.Computation;
+import tonkadur.fate.v1.lang.meta.Instruction;
+import tonkadur.fate.v1.lang.meta.InstructionVisitor;
+import tonkadur.fate.v1.lang.meta.Reference;
+import tonkadur.fate.v1.lang.meta.RecurrentChecks;
+
+public class IndexedFilter extends Instruction
+{
+   /***************************************************************************/
+   /**** MEMBERS **************************************************************/
+   /***************************************************************************/
+   protected final List<Computation> extra_params;
+   protected final Computation lambda_function;
+   protected final Reference collection;
+
+   /***************************************************************************/
+   /**** PROTECTED ************************************************************/
+   /***************************************************************************/
+   /**** Constructors *********************************************************/
+   protected IndexedFilter
+   (
+      final Origin origin,
+      final Computation lambda_function,
+      final Reference collection,
+      final List<Computation> extra_params
+   )
+   {
+      super(origin);
+
+      this.lambda_function = lambda_function;
+      this.collection = collection;
+      this.extra_params = extra_params;
+   }
+
+   /***************************************************************************/
+   /**** PUBLIC ***************************************************************/
+   /***************************************************************************/
+   /**** Constructors *********************************************************/
+   public static IndexedFilter build
+   (
+      final Origin origin,
+      final Computation lambda_function,
+      final Reference collection,
+      final List<Computation> extra_params
+   )
+   throws ParsingError
+   {
+      final List<Type> target_signature;
+
+      target_signature = new ArrayList<Type>();
+
+      RecurrentChecks.assert_is_a_collection(collection);
+
+      target_signature.add(Type.INT);
+      target_signature.add
+      (
+         ((CollectionType) collection.get_type()).get_content_type()
+      );
+
+      for (final Computation c: extra_params)
+      {
+         target_signature.add(c.get_type());
+      }
+      RecurrentChecks.assert_lambda_matches_types
+      (
+         lambda_function,
+         Type.BOOL,
+         target_signature
+      );
+
+      return new IndexedFilter(origin, lambda_function, collection, extra_params);
+   }
+
+   /**** Accessors ************************************************************/
+   @Override
+   public void get_visited_by (final InstructionVisitor iv)
+   throws Throwable
+   {
+      iv.visit_indexed_filter(this);
+   }
+
+   public Computation get_lambda_function ()
+   {
+      return lambda_function;
+   }
+
+   public Reference get_collection ()
+   {
+      return collection;
+   }
+
+   public List<Computation> get_extra_parameters ()
+   {
+      return extra_params;
+   }
+
+   /**** Misc. ****************************************************************/
+   @Override
+   public String toString ()
+   {
+      final StringBuilder sb = new StringBuilder();
+
+      sb.append("(IndexedFilter ");
+      sb.append(lambda_function.toString());
+      sb.append(" ");
+      sb.append(collection.toString());
+
+      for (final Computation c: extra_params)
+      {
+         sb.append(" ");
+         sb.append(c.toString());
+      }
+
+      sb.append(")");
+
+      return sb.toString();
+   }
+}
diff --git a/src/core/src/tonkadur/fate/v1/lang/instruction/IndexedMerge.java b/src/core/src/tonkadur/fate/v1/lang/instruction/IndexedMerge.java
new file mode 100644
index 0000000..5fd86ec
--- /dev/null
+++ b/src/core/src/tonkadur/fate/v1/lang/instruction/IndexedMerge.java
@@ -0,0 +1,156 @@
+package tonkadur.fate.v1.lang.instruction;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import tonkadur.parser.Origin;
+import tonkadur.parser.ParsingError;
+
+import tonkadur.fate.v1.lang.type.Type;
+import tonkadur.fate.v1.lang.type.CollectionType;
+
+import tonkadur.fate.v1.lang.meta.Computation;
+import tonkadur.fate.v1.lang.meta.Instruction;
+import tonkadur.fate.v1.lang.meta.InstructionVisitor;
+import tonkadur.fate.v1.lang.meta.Reference;
+import tonkadur.fate.v1.lang.meta.RecurrentChecks;
+
+public class IndexedMerge extends Instruction
+{
+   /***************************************************************************/
+   /**** MEMBERS **************************************************************/
+   /***************************************************************************/
+   protected final List<Computation> extra_params;
+   protected final Computation lambda_function;
+   protected final Reference collection;
+   protected final Computation collection_in_b;
+
+   /***************************************************************************/
+   /**** PROTECTED ************************************************************/
+   /***************************************************************************/
+   /**** Constructors *********************************************************/
+   protected IndexedMerge
+   (
+      final Origin origin,
+      final Computation lambda_function,
+      final Reference collection,
+      final Computation collection_in_b,
+      final List<Computation> extra_params
+   )
+   {
+      super(origin);
+
+      this.lambda_function = lambda_function;
+      this.collection = collection;
+      this.collection_in_b = collection_in_b;
+      this.extra_params = extra_params;
+   }
+
+   /***************************************************************************/
+   /**** PUBLIC ***************************************************************/
+   /***************************************************************************/
+   /**** Constructors *********************************************************/
+   public static IndexedMerge build
+   (
+      final Origin origin,
+      final Computation lambda_function,
+      final Reference collection,
+      final Computation collection_in_b,
+      final List<Computation> extra_params
+   )
+   throws Throwable
+   {
+      final List<Type> types_in;
+
+      types_in = new ArrayList<Type>();
+
+      RecurrentChecks.assert_is_a_collection(collection);
+      RecurrentChecks.assert_is_a_collection(collection_in_b);
+
+      types_in.add(Type.INT);
+      types_in.add
+      (
+         ((CollectionType) collection.get_type()).get_content_type()
+      );
+
+      types_in.add
+      (
+         ((CollectionType) collection_in_b.get_type()).get_content_type()
+      );
+
+      for (final Computation c: extra_params)
+      {
+         types_in.add(c.get_type());
+      }
+
+      RecurrentChecks.assert_lambda_matches_types
+      (
+         lambda_function,
+         ((CollectionType) collection.get_type()).get_content_type(),
+         types_in
+      );
+
+      return
+         new IndexedMerge
+         (
+            origin,
+            lambda_function,
+            collection,
+            collection_in_b,
+            extra_params
+         );
+   }
+
+   /**** Accessors ************************************************************/
+   @Override
+   public void get_visited_by (final InstructionVisitor iv)
+   throws Throwable
+   {
+      iv.visit_indexed_merge(this);
+   }
+
+   public Computation get_lambda_function ()
+   {
+      return lambda_function;
+   }
+
+   public Computation get_collection_in_b ()
+   {
+      return collection_in_b;
+   }
+
+   public Reference get_collection ()
+   {
+      return collection;
+   }
+
+   public List<Computation> get_extra_parameters ()
+   {
+      return extra_params;
+   }
+
+   /**** Misc. ****************************************************************/
+   @Override
+   public String toString ()
+   {
+      final StringBuilder sb = new StringBuilder();
+
+      sb.append("(IndexedMerge ");
+      sb.append(lambda_function.toString());
+      sb.append(" ");
+      sb.append(collection.toString());
+
+      sb.append(" ");
+      sb.append(collection_in_b.toString());
+
+      for (final Computation c: extra_params)
+      {
+         sb.append(" ");
+         sb.append(c.toString());
+      }
+
+      sb.append(")");
+
+      return sb.toString();
+   }
+}
diff --git a/src/core/src/tonkadur/fate/v1/lang/instruction/IndexedPartition.java b/src/core/src/tonkadur/fate/v1/lang/instruction/IndexedPartition.java
new file mode 100644
index 0000000..cec125a
--- /dev/null
+++ b/src/core/src/tonkadur/fate/v1/lang/instruction/IndexedPartition.java
@@ -0,0 +1,156 @@
+package tonkadur.fate.v1.lang.instruction;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.ArrayList;
+
+import tonkadur.parser.Origin;
+import tonkadur.parser.ParsingError;
+
+import tonkadur.fate.v1.lang.type.Type;
+import tonkadur.fate.v1.lang.type.CollectionType;
+
+import tonkadur.fate.v1.lang.meta.Computation;
+import tonkadur.fate.v1.lang.meta.Instruction;
+import tonkadur.fate.v1.lang.meta.InstructionVisitor;
+import tonkadur.fate.v1.lang.meta.Reference;
+import tonkadur.fate.v1.lang.meta.RecurrentChecks;
+
+public class IndexedPartition extends Instruction
+{
+   /***************************************************************************/
+   /**** MEMBERS **************************************************************/
+   /***************************************************************************/
+   protected final List<Computation> extra_params;
+   protected final Computation lambda_function;
+   protected final Reference collection_in;
+   protected final Reference collection_out;
+
+   /***************************************************************************/
+   /**** PROTECTED ************************************************************/
+   /***************************************************************************/
+   /**** Constructors *********************************************************/
+   protected IndexedPartition
+   (
+      final Origin origin,
+      final Computation lambda_function,
+      final Reference collection_in,
+      final Reference collection_out,
+      final List<Computation> extra_params
+   )
+   {
+      super(origin);
+
+      this.lambda_function = lambda_function;
+      this.collection_in = collection_in;
+      this.collection_out = collection_out;
+      this.extra_params = extra_params;
+   }
+
+   /***************************************************************************/
+   /**** PUBLIC ***************************************************************/
+   /***************************************************************************/
+   /**** Constructors *********************************************************/
+   public static IndexedPartition build
+   (
+      final Origin origin,
+      final Computation lambda_function,
+      final Reference collection_in,
+      final Reference collection_out,
+      final List<Computation> extra_params
+   )
+   throws ParsingError
+   {
+      final List<Type> target_signature;
+
+      target_signature = new ArrayList<Type>();
+
+      RecurrentChecks.assert_is_a_collection(collection_in);
+      RecurrentChecks.assert_is_a_collection(collection_out);
+      RecurrentChecks.assert_can_be_used_as
+      (
+         collection_in,
+         collection_out.get_type()
+      );
+
+      target_signature.add(Type.INT);
+      target_signature.add
+      (
+         ((CollectionType) collection_in.get_type()).get_content_type()
+      );
+
+      for (final Computation c: extra_params)
+      {
+         target_signature.add(c.get_type());
+      }
+
+      RecurrentChecks.assert_lambda_matches_types
+      (
+         lambda_function,
+         Type.BOOL,
+         target_signature
+      );
+
+      return
+         new IndexedPartition
+         (
+            origin,
+            lambda_function,
+            collection_in,
+            collection_out,
+            extra_params
+         );
+   }
+
+   /**** Accessors ************************************************************/
+   @Override
+   public void get_visited_by (final InstructionVisitor iv)
+   throws Throwable
+   {
+      iv.visit_indexed_partition(this);
+   }
+
+   public Computation get_lambda_function ()
+   {
+      return lambda_function;
+   }
+
+   public Reference get_collection_in ()
+   {
+      return collection_in;
+   }
+
+   public Reference get_collection_out ()
+   {
+      return collection_out;
+   }
+
+   public List<Computation> get_extra_parameters ()
+   {
+      return extra_params;
+   }
+
+   /**** Misc. ****************************************************************/
+   @Override
+   public String toString ()
+   {
+      final StringBuilder sb = new StringBuilder();
+
+      sb.append("(IndexedPartition ");
+      sb.append(lambda_function.toString());
+      sb.append(" ");
+      sb.append(collection_in.toString());
+      sb.append(" ");
+      sb.append(collection_out.toString());
+
+      for (final Computation c: extra_params)
+      {
+         sb.append(" ");
+         sb.append(c.toString());
+      }
+
+      sb.append(")");
+
+      return sb.toString();
+   }
+}
diff --git a/src/core/src/tonkadur/fate/v1/lang/meta/ComputationVisitor.java b/src/core/src/tonkadur/fate/v1/lang/meta/ComputationVisitor.java
index 4beca98..cd164c9 100644
--- a/src/core/src/tonkadur/fate/v1/lang/meta/ComputationVisitor.java
+++ b/src/core/src/tonkadur/fate/v1/lang/meta/ComputationVisitor.java
@@ -133,15 +133,24 @@ public interface ComputationVisitor
    public void visit_merge (final MergeComputation n)
    throws Throwable;
 
+   public void visit_indexed_merge (final IndexedMergeComputation n)
+   throws Throwable;
+
    public void visit_filter (final FilterComputation n)
    throws Throwable;
 
+   public void visit_indexed_filter (final IndexedFilterComputation n)
+   throws Throwable;
+
    public void visit_sublist (final SubListComputation n)
    throws Throwable;
 
    public void visit_partition (final PartitionComputation n)
    throws Throwable;
 
+   public void visit_indexed_partition (final IndexedPartitionComputation n)
+   throws Throwable;
+
    public void visit_push_element (final PushElementComputation n)
    throws Throwable;
 
diff --git a/src/core/src/tonkadur/fate/v1/lang/meta/InstructionVisitor.java b/src/core/src/tonkadur/fate/v1/lang/meta/InstructionVisitor.java
index b356f7d..a3038ac 100644
--- a/src/core/src/tonkadur/fate/v1/lang/meta/InstructionVisitor.java
+++ b/src/core/src/tonkadur/fate/v1/lang/meta/InstructionVisitor.java
@@ -56,15 +56,24 @@ public interface InstructionVisitor
    public void visit_merge (final Merge n)
    throws Throwable;
 
+   public void visit_indexed_merge (final IndexedMerge n)
+   throws Throwable;
+
    public void visit_filter (final Filter n)
    throws Throwable;
 
+   public void visit_indexed_filter (final IndexedFilter n)
+   throws Throwable;
+
    public void visit_sublist (final SubList n)
    throws Throwable;
 
    public void visit_partition (final Partition n)
    throws Throwable;
 
+   public void visit_indexed_partition (final IndexedPartition n)
+   throws Throwable;
+
    public void visit_sort (final Sort n)
    throws Throwable;
 
diff --git a/src/core/src/tonkadur/fate/v1/parser/FateLexer.g4 b/src/core/src/tonkadur/fate/v1/parser/FateLexer.g4
index b8d0bc7..c5f073d 100644
--- a/src/core/src/tonkadur/fate/v1/parser/FateLexer.g4
+++ b/src/core/src/tonkadur/fate/v1/parser/FateLexer.g4
@@ -57,7 +57,9 @@ IGNORE_ERROR_KW: L_PAREN 'ignore'US('error'|'warning') SEP+;
 FATE_VERSION_KW: L_PAREN 'fate'US'version' SEP+;
 FIELD_KW: L_PAREN 'field' SEP+;
 FILTER_KW: L_PAREN 'filter' SEP+;
+INDEXED_FILTER_KW: L_PAREN 'indexed'US'filter' SEP+;
 IMP_FILTER_KW: L_PAREN 'filter!' SEP+;
+IMP_INDEXED_FILTER_KW: L_PAREN 'indexed'US'filter!' SEP+;
 FOR_EACH_KW: L_PAREN ('for'US'each') SEP+;
 FOR_KW: L_PAREN 'for' SEP+;
 FOLDR_KW: L_PAREN 'foldr' SEP+;
@@ -88,7 +90,10 @@ CLAMP_KW: L_PAREN ('clamp') SEP+;
 MODULO_KW: L_PAREN ('modulo'|'%'|'mod') SEP+;
 MERGE_TO_LIST_KW : L_PAREN 'merge'US'to'US'list' SEP+;
 MERGE_TO_SET_KW : L_PAREN 'merge'US'to'US'set' SEP+;
+INDEXED_MERGE_TO_LIST_KW : L_PAREN 'indexed'US'merge'US'to'US'list' SEP+;
+INDEXED_MERGE_TO_SET_KW : L_PAREN 'indexed'US'merge'US'to'US'set' SEP+;
 IMP_MERGE_KW : L_PAREN 'merge!' SEP+;
+IMP_INDEXED_MERGE_KW : L_PAREN 'indexed'US'merge!' SEP+;
 NEWLINE_KW: L_PAREN 'newline)';
 NEW_KW: L_PAREN ('new'|'reserve'|'create') SEP+;
 NOT_KW: L_PAREN ('not'|'~'|'!') SEP+;
@@ -97,6 +102,8 @@ OR_KW: L_PAREN ('or'|'\\/') SEP+;
 RICH_TEXT_KW: L_PAREN (('rich'US)?'text') SEP+;
 PARTITION_KW: L_PAREN 'partition' SEP+;
 IMP_PARTITION_KW: L_PAREN 'partition!' SEP+;
+INDEXED_PARTITION_KW: L_PAREN 'indexed'US'partition' SEP+;
+IMP_INDEXED_PARTITION_KW: L_PAREN 'indexed'US'partition!' SEP+;
 POP_LEFT_KW: L_PAREN 'pop'US'left' SEP+;
 IMP_POP_LEFT_KW: L_PAREN 'pop'US'left!' SEP+;
 POP_RIGHT_KW: L_PAREN 'pop'US'right' SEP+;
diff --git a/src/core/src/tonkadur/fate/v1/parser/FateParser.g4 b/src/core/src/tonkadur/fate/v1/parser/FateParser.g4
index 1289a9e..d4798a0 100644
--- a/src/core/src/tonkadur/fate/v1/parser/FateParser.g4
+++ b/src/core/src/tonkadur/fate/v1/parser/FateParser.g4
@@ -924,6 +924,49 @@ returns [Instruction result]
          );
    }
 
+   | IMP_INDEXED_MERGE_KW
+         fun=non_text_value WS+
+         value_reference WS+
+         inv1=non_text_value WS*
+      R_PAREN
+   {
+      $result =
+         IndexedMerge.build
+         (
+            CONTEXT.get_origin_at
+            (
+               ($IMP_INDEXED_MERGE_KW.getLine()),
+               ($IMP_INDEXED_MERGE_KW.getCharPositionInLine())
+            ),
+            ($fun.result),
+            ($value_reference.result),
+            ($inv1.result),
+            new ArrayList()
+         );
+   }
+
+   | IMP_INDEXED_MERGE_KW
+         fun=non_text_value WS+
+         value_reference WS+
+         inv1=non_text_value WS+
+         value_list WS*
+      R_PAREN
+   {
+      $result =
+         IndexedMerge.build
+         (
+            CONTEXT.get_origin_at
+            (
+               ($IMP_INDEXED_MERGE_KW.getLine()),
+               ($IMP_INDEXED_MERGE_KW.getCharPositionInLine())
+            ),
+            ($fun.result),
+            ($value_reference.result),
+            ($inv1.result),
+            ($value_list.result)
+         );
+   }
+
    | IMP_MERGE_KW
       fun=non_text_value WS+
       def0=value WS+
@@ -1027,6 +1070,42 @@ returns [Instruction result]
          );
    }
 
+   | IMP_INDEXED_FILTER_KW non_text_value WS+ value_reference WS* R_PAREN
+   {
+      $result =
+         IndexedFilter.build
+         (
+            CONTEXT.get_origin_at
+            (
+               ($IMP_INDEXED_FILTER_KW.getLine()),
+               ($IMP_INDEXED_FILTER_KW.getCharPositionInLine())
+            ),
+            ($non_text_value.result),
+            ($value_reference.result),
+            new ArrayList()
+         );
+   }
+
+   | IMP_INDEXED_FILTER_KW
+         non_text_value WS+
+         value_reference WS+
+         value_list WS*
+      R_PAREN
+   {
+      $result =
+         IndexedFilter.build
+         (
+            CONTEXT.get_origin_at
+            (
+               ($IMP_INDEXED_FILTER_KW.getLine()),
+               ($IMP_INDEXED_FILTER_KW.getCharPositionInLine())
+            ),
+            ($non_text_value.result),
+            ($value_reference.result),
+            ($value_list.result)
+         );
+   }
+
    | IMP_PARTITION_KW
       non_text_value WS+
       iftrue=value_reference WS+
@@ -1034,7 +1113,7 @@ returns [Instruction result]
       R_PAREN
    {
       $result =
-        Partition.build
+         Partition.build
          (
             CONTEXT.get_origin_at
             (
@@ -1056,7 +1135,7 @@ returns [Instruction result]
       R_PAREN
    {
       $result =
-        Partition.build
+         Partition.build
          (
             CONTEXT.get_origin_at
             (
@@ -1070,6 +1149,49 @@ returns [Instruction result]
          );
    }
 
+   | IMP_INDEXED_PARTITION_KW
+      non_text_value WS+
+      iftrue=value_reference WS+
+      iffalse=value_reference WS*
+      R_PAREN
+   {
+      $result =
+         IndexedPartition.build
+         (
+            CONTEXT.get_origin_at
+            (
+               ($IMP_INDEXED_PARTITION_KW.getLine()),
+               ($IMP_INDEXED_PARTITION_KW.getCharPositionInLine())
+            ),
+            ($non_text_value.result),
+            ($iftrue.result),
+            ($iffalse.result),
+            new ArrayList()
+         );
+   }
+
+   | IMP_INDEXED_PARTITION_KW
+      non_text_value WS+
+      iftrue=value_reference WS+
+      iffalse=value_reference WS+
+      value_list WS*
+      R_PAREN
+   {
+      $result =
+         IndexedPartition.build
+         (
+            CONTEXT.get_origin_at
+            (
+               ($IMP_INDEXED_PARTITION_KW.getLine()),
+               ($IMP_INDEXED_PARTITION_KW.getCharPositionInLine())
+            ),
+            ($non_text_value.result),
+            ($iftrue.result),
+            ($iffalse.result),
+            ($value_list.result)
+         );
+   }
+
    | IMP_SORT_KW non_text_value WS+ value_reference WS* R_PAREN
    {
       $result =
@@ -1089,7 +1211,7 @@ returns [Instruction result]
    | IMP_SORT_KW non_text_value WS+ value_reference WS+ value_list WS* R_PAREN
    {
       $result =
-        Sort.build
+         Sort.build
          (
             CONTEXT.get_origin_at
             (
@@ -1106,7 +1228,7 @@ returns [Instruction result]
    | IMP_SHUFFLE_KW value_reference WS* R_PAREN
    {
       $result =
-        Shuffle.build
+         Shuffle.build
          (
             CONTEXT.get_origin_at
             (
@@ -3977,6 +4099,51 @@ returns [Computation result]
          );
    }
 
+   | INDEXED_MERGE_TO_LIST_KW
+         fun=non_text_value WS+
+         inv0=non_text_value WS+
+         inv1=non_text_value WS*
+      R_PAREN
+   {
+      $result =
+         IndexedMergeComputation.build
+         (
+            CONTEXT.get_origin_at
+            (
+               ($INDEXED_MERGE_TO_LIST_KW.getLine()),
+               ($INDEXED_MERGE_TO_LIST_KW.getCharPositionInLine())
+            ),
+            ($fun.result),
+            ($inv0.result),
+            ($inv1.result),
+            false,
+            new ArrayList()
+         );
+   }
+
+   | INDEXED_MERGE_TO_LIST_KW
+         fun=non_text_value WS+
+         inv0=non_text_value WS+
+         inv1=non_text_value WS+
+         value_list WS*
+      R_PAREN
+   {
+      $result =
+         IndexedMergeComputation.build
+         (
+            CONTEXT.get_origin_at
+            (
+               ($INDEXED_MERGE_TO_LIST_KW.getLine()),
+               ($INDEXED_MERGE_TO_LIST_KW.getCharPositionInLine())
+            ),
+            ($fun.result),
+            ($inv0.result),
+            ($inv1.result),
+            false,
+            ($value_list.result)
+         );
+   }
+
    | MERGE_TO_LIST_KW
          fun=non_text_value WS+
          inv0=non_text_value WS+
@@ -4079,6 +4246,51 @@ returns [Computation result]
          );
    }
 
+   | INDEXED_MERGE_TO_SET_KW
+         fun=non_text_value WS+
+         inv0=non_text_value WS+
+         inv1=non_text_value WS*
+      R_PAREN
+   {
+      $result =
+         IndexedMergeComputation.build
+         (
+            CONTEXT.get_origin_at
+            (
+               ($INDEXED_MERGE_TO_SET_KW.getLine()),
+               ($INDEXED_MERGE_TO_SET_KW.getCharPositionInLine())
+            ),
+            ($fun.result),
+            ($inv0.result),
+            ($inv1.result),
+            true,
+            new ArrayList()
+         );
+   }
+
+   | INDEXED_MERGE_TO_SET_KW
+         fun=non_text_value WS+
+         inv0=non_text_value WS+
+         inv1=non_text_value WS+
+         value_list WS*
+      R_PAREN
+   {
+      $result =
+         IndexedMergeComputation.build
+         (
+            CONTEXT.get_origin_at
+            (
+               ($INDEXED_MERGE_TO_SET_KW.getLine()),
+               ($INDEXED_MERGE_TO_SET_KW.getCharPositionInLine())
+            ),
+            ($fun.result),
+            ($inv0.result),
+            ($inv1.result),
+            true,
+            ($value_list.result)
+         );
+   }
+
    | MERGE_TO_SET_KW
          fun=non_text_value WS+
          inv0=non_text_value WS+
@@ -4273,10 +4485,46 @@ returns [Computation result]
          );
    }
 
+   | INDEXED_PARTITION_KW fun=non_text_value WS+ coll=non_text_value WS* R_PAREN
+   {
+      $result =
+         IndexedPartitionComputation.build
+         (
+            CONTEXT.get_origin_at
+            (
+               ($INDEXED_PARTITION_KW.getLine()),
+               ($INDEXED_PARTITION_KW.getCharPositionInLine())
+            ),
+            ($fun.result),
+            ($coll.result),
+            new ArrayList()
+         );
+   }
+
+   | INDEXED_PARTITION_KW
+         fun=non_text_value WS+
+         coll=non_text_value WS+
+         value_list WS*
+      R_PAREN
+   {
+      $result =
+         IndexedPartitionComputation.build
+         (
+            CONTEXT.get_origin_at
+            (
+               ($INDEXED_PARTITION_KW.getLine()),
+               ($INDEXED_PARTITION_KW.getCharPositionInLine())
+            ),
+            ($fun.result),
+            ($coll.result),
+            ($value_list.result)
+         );
+   }
+
    | SORT_KW fun=non_text_value WS+ coll=non_text_value WS* R_PAREN
    {
       $result =
-        SortComputation.build
+         SortComputation.build
          (
             CONTEXT.get_origin_at
             (
@@ -4296,7 +4544,7 @@ returns [Computation result]
       R_PAREN
    {
       $result =
-        SortComputation.build
+         SortComputation.build
          (
             CONTEXT.get_origin_at
             (
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 767724a..64f7220 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
@@ -29,6 +29,7 @@ import tonkadur.wyrd.v1.compiler.util.IfElse;
 import tonkadur.wyrd.v1.compiler.util.If;
 import tonkadur.wyrd.v1.compiler.util.Fold;
 import tonkadur.wyrd.v1.compiler.util.FilterLambda;
+import tonkadur.wyrd.v1.compiler.util.IndexedFilterLambda;
 import tonkadur.wyrd.v1.compiler.util.Shuffle;
 import tonkadur.wyrd.v1.compiler.util.RemoveAt;
 import tonkadur.wyrd.v1.compiler.util.RemoveElementsOf;
@@ -36,8 +37,11 @@ import tonkadur.wyrd.v1.compiler.util.InsertAt;
 import tonkadur.wyrd.v1.compiler.util.RemoveAllOf;
 import tonkadur.wyrd.v1.compiler.util.IndexedMapLambda;
 import tonkadur.wyrd.v1.compiler.util.PartitionLambda;
+import tonkadur.wyrd.v1.compiler.util.IndexedPartitionLambda;
 import tonkadur.wyrd.v1.compiler.util.MapLambda;
+import tonkadur.wyrd.v1.compiler.util.PopElement;
 import tonkadur.wyrd.v1.compiler.util.MergeLambda;
+import tonkadur.wyrd.v1.compiler.util.IndexedMergeLambda;
 import tonkadur.wyrd.v1.compiler.util.RemoveOneOf;
 import tonkadur.wyrd.v1.compiler.util.ReverseList;
 import tonkadur.wyrd.v1.compiler.util.CreateCons;
@@ -1929,7 +1933,6 @@ implements tonkadur.fate.v1.lang.meta.ComputationVisitor
    )
    throws Throwable
    {
-      final Address car_addr, cdr_addr;
       final ComputationCompiler car_compiler, cdr_compiler;
       final Register result;
 
@@ -2722,6 +2725,7 @@ implements tonkadur.fate.v1.lang.meta.ComputationVisitor
    )
    throws Throwable
    {
+      /* TODO: handle the default values if there are any. */
       final List<Computation> params;
       final ComputationCompiler lambda_cc;
       final ComputationCompiler in_collection_a_cc, in_collection_b_cc;
@@ -2789,6 +2793,79 @@ implements tonkadur.fate.v1.lang.meta.ComputationVisitor
    }
 
    @Override
+   public void visit_indexed_merge
+   (
+      final tonkadur.fate.v1.lang.computation.IndexedMergeComputation n
+   )
+   throws Throwable
+   {
+      final List<Computation> params;
+      final ComputationCompiler lambda_cc;
+      final ComputationCompiler in_collection_a_cc, in_collection_b_cc;
+      final Register result;
+
+      result = reserve(TypeCompiler.compile(compiler, n.get_type()));
+
+      result_as_address = result.get_address();
+      result_as_computation = result.get_value();
+
+      params = new ArrayList<Computation>();
+
+      for
+      (
+         final tonkadur.fate.v1.lang.meta.Computation p:
+            n.get_extra_parameters()
+      )
+      {
+         final ComputationCompiler param_cc;
+
+         param_cc = new ComputationCompiler(compiler);
+
+         p.get_visited_by(param_cc);
+
+         /* Let's not re-compute the parameters on every iteration. */
+         param_cc.generate_address();
+
+         assimilate(param_cc);
+
+         params.add(param_cc.get_computation());
+      }
+
+      lambda_cc = new ComputationCompiler(compiler);
+
+      n.get_lambda_function().get_visited_by(lambda_cc);
+
+      assimilate(lambda_cc);
+
+      in_collection_a_cc = new ComputationCompiler(compiler);
+
+      n.get_collection_in_a().get_visited_by(in_collection_a_cc);
+
+      assimilate(in_collection_a_cc);
+
+      in_collection_b_cc = new ComputationCompiler(compiler);
+
+      n.get_collection_in_b().get_visited_by(in_collection_b_cc);
+
+      assimilate(in_collection_b_cc);
+
+      init_instructions.add
+      (
+         IndexedMergeLambda.generate
+         (
+            compiler.registers(),
+            compiler.assembler(),
+            lambda_cc.get_computation(),
+            in_collection_a_cc.get_address(),
+            in_collection_b_cc.get_address(),
+            result_as_address,
+            n.to_set(),
+            params
+         )
+      );
+   }
+
+   @Override
    public void visit_sublist
    (
       final tonkadur.fate.v1.lang.computation.SubListComputation n
@@ -2900,6 +2977,107 @@ implements tonkadur.fate.v1.lang.meta.ComputationVisitor
    }
 
    @Override
+   public void visit_indexed_partition
+   (
+      final tonkadur.fate.v1.lang.computation.IndexedPartitionComputation n
+   )
+   throws Throwable
+   {
+      final List<Computation> params;
+      final ComputationCompiler lambda_cc, in_collection_cc;
+      final Address car_addr, cdr_addr;
+      final Register result;
+
+      result = reserve(DictType.WILD);
+
+      result_as_address = result.get_address();
+      result_as_computation = result.get_value();
+
+      params = new ArrayList<Computation>();
+
+      for
+      (
+         final tonkadur.fate.v1.lang.meta.Computation p:
+            n.get_extra_parameters()
+      )
+      {
+         final ComputationCompiler param_cc;
+
+         param_cc = new ComputationCompiler(compiler);
+
+         p.get_visited_by(param_cc);
+
+         /* Let's not re-compute the parameters on every iteration. */
+         param_cc.generate_address();
+
+         assimilate(param_cc);
+
+         params.add(param_cc.get_computation());
+      }
+
+      lambda_cc = new ComputationCompiler(compiler);
+
+      n.get_lambda_function().get_visited_by(lambda_cc);
+
+      assimilate(lambda_cc);
+
+      in_collection_cc = new ComputationCompiler(compiler);
+
+      n.get_collection().get_visited_by(in_collection_cc);
+
+      if (in_collection_cc.has_init())
+      {
+         init_instructions.add(in_collection_cc.get_init());
+      }
+
+      car_addr =
+         new RelativeAddress
+         (
+            result_as_address,
+            new Constant(Type.STRING, "0"),
+            in_collection_cc.get_computation().get_type()
+         );
+
+      init_instructions.add
+      (
+         new SetValue
+         (
+            car_addr,
+            in_collection_cc.get_computation()
+         )
+      );
+
+      cdr_addr =
+         new RelativeAddress
+         (
+            result_as_address,
+            new Constant(Type.STRING, "1"),
+            in_collection_cc.get_computation().get_type()
+         );
+
+      in_collection_cc.release_registers(init_instructions);
+
+      init_instructions.add(new Initialize(cdr_addr));
+
+      init_instructions.add
+      (
+         IndexedPartitionLambda.generate
+         (
+            compiler.registers(),
+            compiler.assembler(),
+            lambda_cc.get_computation(),
+            car_addr,
+            cdr_addr,
+            (
+               (tonkadur.fate.v1.lang.type.CollectionType)
+               n.get_collection().get_type()
+            ).is_set(),
+            params
+         )
+      );
+   }
+
+   @Override
    public void visit_sort
    (
       final tonkadur.fate.v1.lang.computation.SortComputation n
@@ -2983,6 +3161,79 @@ implements tonkadur.fate.v1.lang.meta.ComputationVisitor
    }
 
    @Override
+   public void visit_indexed_filter
+   (
+      final tonkadur.fate.v1.lang.computation.IndexedFilterComputation n
+   )
+   throws Throwable
+   {
+      final List<Computation> params;
+      final ComputationCompiler lambda_cc, in_collection_cc;
+      final Register result;
+
+      result = reserve(TypeCompiler.compile(compiler, n.get_type()));
+
+      result_as_address = result.get_address();
+      result_as_computation = result.get_value();
+
+      params = new ArrayList<Computation>();
+
+      for
+      (
+         final tonkadur.fate.v1.lang.meta.Computation p:
+            n.get_extra_parameters()
+      )
+      {
+         final ComputationCompiler param_cc;
+
+         param_cc = new ComputationCompiler(compiler);
+
+         p.get_visited_by(param_cc);
+
+         /* Let's not re-compute the parameters on every iteration. */
+         param_cc.generate_address();
+
+         assimilate(param_cc);
+
+         params.add(param_cc.get_computation());
+      }
+
+      lambda_cc = new ComputationCompiler(compiler);
+
+      n.get_lambda_function().get_visited_by(lambda_cc);
+
+      assimilate(lambda_cc);
+
+      in_collection_cc = new ComputationCompiler(compiler);
+
+      n.get_collection().get_visited_by(in_collection_cc);
+
+      if (in_collection_cc.has_init())
+      {
+         init_instructions.add(in_collection_cc.get_init());
+      }
+
+      init_instructions.add
+      (
+         new SetValue(result_as_address, in_collection_cc.get_computation())
+      );
+
+      in_collection_cc.release_registers(init_instructions);
+
+      init_instructions.add
+      (
+         IndexedFilterLambda.generate
+         (
+            compiler.registers(),
+            compiler.assembler(),
+            lambda_cc.get_computation(),
+            result_as_address,
+            params
+         )
+      );
+   }
+
+   @Override
    public void visit_indexed_map
    (
       final tonkadur.fate.v1.lang.computation.IndexedMapComputation n
@@ -3130,7 +3381,75 @@ implements tonkadur.fate.v1.lang.meta.ComputationVisitor
    )
    throws Throwable
    {
-      /* TODO */
+      final ComputationCompiler address_compiler;
+      final Register result;
+      final Address car_addr, cdr_addr;
+
+      result = reserve(DictType.WILD);
+      result_as_computation = result.get_value();
+      result_as_address = result.get_address();
+
+      address_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())
+      );
+
+      car_addr =
+         new RelativeAddress
+         (
+            result_as_address,
+            new Constant(Type.STRING, "0"),
+            address_compiler.get_computation().get_type()
+         );
+
+      init_instructions.add
+      (
+         new SetValue
+         (
+            car_addr,
+            address_compiler.get_computation()
+         )
+      );
+
+      address_compiler.release_registers(init_instructions);
+
+      cdr_addr =
+         new RelativeAddress
+         (
+            result_as_address,
+            new Constant(Type.STRING, "1"),
+            TypeCompiler.compile
+            (
+               compiler,
+               (
+                  (tonkadur.fate.v1.lang.type.CollectionType)
+                     n.get_collection().get_type()
+               ).get_content_type()
+            )
+         );
+
+      init_instructions.add(new Initialize(cdr_addr));
+
+      init_instructions.add
+      (
+         PopElement.generate
+         (
+            compiler.registers(),
+            compiler.assembler(),
+            car_addr,
+            cdr_addr,
+            n.is_from_left()
+         )
+      );
    }
 
    @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 9cd5d43..0f23a34 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
@@ -50,12 +50,16 @@ import tonkadur.wyrd.v1.compiler.util.IfElse;
 import tonkadur.wyrd.v1.compiler.util.InstructionManager;
 import tonkadur.wyrd.v1.compiler.util.NOP;
 import tonkadur.wyrd.v1.compiler.util.While;
+import tonkadur.wyrd.v1.compiler.util.IndexedFilterLambda;
 import tonkadur.wyrd.v1.compiler.util.FilterLambda;
 import tonkadur.wyrd.v1.compiler.util.Shuffle;
 import tonkadur.wyrd.v1.compiler.util.Clear;
 import tonkadur.wyrd.v1.compiler.util.MapLambda;
+import tonkadur.wyrd.v1.compiler.util.PopElement;
 import tonkadur.wyrd.v1.compiler.util.MergeLambda;
+import tonkadur.wyrd.v1.compiler.util.IndexedMergeLambda;
 import tonkadur.wyrd.v1.compiler.util.PartitionLambda;
+import tonkadur.wyrd.v1.compiler.util.IndexedPartitionLambda;
 import tonkadur.wyrd.v1.compiler.util.IndexedMapLambda;
 import tonkadur.wyrd.v1.compiler.util.IterativeSearch;
 import tonkadur.wyrd.v1.compiler.util.RemoveAllOf;
@@ -215,7 +219,6 @@ implements tonkadur.fate.v1.lang.meta.InstructionVisitor
          result.add(index_compiler.get_init());
       }
 
-
       element_compiler = new ComputationCompiler(compiler);
 
       n.get_element().get_visited_by(element_compiler);
@@ -641,6 +644,7 @@ implements tonkadur.fate.v1.lang.meta.InstructionVisitor
    )
    throws Throwable
    {
+      /* TODO: handle default values. */
       /* This is one dangerous operation to do in-place, so we don't. */
       final Register holder;
       final ComputationCompiler lambda_cc;
@@ -744,6 +748,115 @@ implements tonkadur.fate.v1.lang.meta.InstructionVisitor
    }
 
    @Override
+   public void visit_indexed_merge
+   (
+      final tonkadur.fate.v1.lang.instruction.IndexedMerge n
+   )
+   throws Throwable
+   {
+      /* This is one dangerous operation to do in-place, so we don't. */
+      final Register holder;
+      final ComputationCompiler lambda_cc;
+      final List<Computation> params;
+      final List<ComputationCompiler> param_cc_list;
+      final ComputationCompiler collection_cc, in_collection_b_cc;
+
+      params = new ArrayList<Computation>();
+      param_cc_list = new ArrayList<ComputationCompiler>();
+
+      lambda_cc = new ComputationCompiler(compiler);
+
+      n.get_lambda_function().get_visited_by(lambda_cc);
+
+      if (lambda_cc.has_init())
+      {
+         result.add(lambda_cc.get_init());
+      }
+
+      collection_cc = new ComputationCompiler(compiler);
+
+      n.get_collection().get_visited_by(collection_cc);
+
+      if (collection_cc.has_init())
+      {
+         result.add(collection_cc.get_init());
+      }
+
+      holder =
+         compiler.registers().reserve
+         (
+            collection_cc.get_computation().get_type(),
+            result
+         );
+
+      result.add
+      (
+         new SetValue(holder.get_address(), collection_cc.get_computation())
+      );
+
+      in_collection_b_cc = new ComputationCompiler(compiler);
+
+      n.get_collection_in_b().get_visited_by(in_collection_b_cc);
+
+      if (in_collection_b_cc.has_init())
+      {
+         result.add(in_collection_b_cc.get_init());
+      }
+
+      for
+      (
+         final tonkadur.fate.v1.lang.meta.Computation p:
+            n.get_extra_parameters()
+      )
+      {
+         final ComputationCompiler param_cc;
+
+         param_cc = new ComputationCompiler(compiler);
+
+         p.get_visited_by(param_cc);
+
+         /* Let's not re-compute the parameters on every iteration. */
+         param_cc.generate_address();
+
+         if (param_cc.has_init())
+         {
+            result.add(param_cc.get_init());
+         }
+
+         param_cc_list.add(param_cc);
+
+         params.add(param_cc.get_computation());
+      }
+
+      result.add
+      (
+         IndexedMergeLambda.generate
+         (
+            compiler.registers(),
+            compiler.assembler(),
+            lambda_cc.get_computation(),
+            holder.get_address(),
+            in_collection_b_cc.get_address(),
+            collection_cc.get_address(),
+            (
+               (tonkadur.fate.v1.lang.type.CollectionType)
+               n.get_collection().get_type()
+            ).is_set(),
+            params
+         )
+      );
+
+      collection_cc.release_registers(result);
+      in_collection_b_cc.release_registers(result);
+      compiler.registers().release(holder, result);
+
+      for (final ComputationCompiler cc: param_cc_list)
+      {
+         cc.release_registers(result);
+      }
+   }
+
+   @Override
    public void visit_partition
    (
       final tonkadur.fate.v1.lang.instruction.Partition n
@@ -837,6 +950,99 @@ implements tonkadur.fate.v1.lang.meta.InstructionVisitor
    }
 
    @Override
+   public void visit_indexed_partition
+   (
+      final tonkadur.fate.v1.lang.instruction.IndexedPartition n
+   )
+   throws Throwable
+   {
+      final List<Computation> params;
+      final List<ComputationCompiler> param_cc_list;
+      final ComputationCompiler lambda_cc, collection_in_cc, collection_out_cc;
+
+      params = new ArrayList<Computation>();
+      param_cc_list = new ArrayList<ComputationCompiler>();
+
+      for
+      (
+         final tonkadur.fate.v1.lang.meta.Computation p:
+            n.get_extra_parameters()
+      )
+      {
+         final ComputationCompiler param_cc;
+
+         param_cc = new ComputationCompiler(compiler);
+
+         p.get_visited_by(param_cc);
+
+         /* Let's not re-compute the parameters on every iteration. */
+         param_cc.generate_address();
+
+         if (param_cc.has_init())
+         {
+            result.add(param_cc.get_init());
+         }
+
+         param_cc_list.add(param_cc);
+
+         params.add(param_cc.get_computation());
+      }
+
+      lambda_cc = new ComputationCompiler(compiler);
+
+      n.get_lambda_function().get_visited_by(lambda_cc);
+
+      if (lambda_cc.has_init())
+      {
+         result.add(lambda_cc.get_init());
+      }
+
+      collection_in_cc = new ComputationCompiler(compiler);
+
+      n.get_collection_in().get_visited_by(collection_in_cc);
+
+      if (collection_in_cc.has_init())
+      {
+         result.add(collection_in_cc.get_init());
+      }
+
+      collection_out_cc = new ComputationCompiler(compiler);
+
+      n.get_collection_out().get_visited_by(collection_out_cc);
+
+      if (collection_out_cc.has_init())
+      {
+         result.add(collection_out_cc.get_init());
+      }
+
+      result.add
+      (
+         IndexedPartitionLambda.generate
+         (
+            compiler.registers(),
+            compiler.assembler(),
+            lambda_cc.get_computation(),
+            collection_in_cc.get_address(),
+            collection_out_cc.get_address(),
+            (
+               (tonkadur.fate.v1.lang.type.CollectionType)
+               n.get_collection_out().get_type()
+            ).is_set(),
+            params
+         )
+      );
+
+      lambda_cc.release_registers(result);
+      collection_in_cc.release_registers(result);
+      collection_out_cc.release_registers(result);
+
+      for (final ComputationCompiler cc: param_cc_list)
+      {
+         cc.release_registers(result);
+      }
+   }
+
+   @Override
    public void visit_sublist
    (
       final tonkadur.fate.v1.lang.instruction.SubList n
@@ -866,8 +1072,6 @@ implements tonkadur.fate.v1.lang.meta.InstructionVisitor
          result.add(address_compiler.get_init());
       }
 
-      address_compiler.release_registers(result);
-
       n.get_element().get_visited_by(element_compiler);
 
       if (element_compiler.has_init())
@@ -1005,6 +1209,84 @@ implements tonkadur.fate.v1.lang.meta.InstructionVisitor
    }
 
    @Override
+   public void visit_indexed_filter
+   (
+      final tonkadur.fate.v1.lang.instruction.IndexedFilter n
+   )
+   throws Throwable
+   {
+      final List<Computation> params;
+      final List<ComputationCompiler> param_cc_list;
+      final ComputationCompiler lambda_cc, collection_cc;
+
+      params = new ArrayList<Computation>();
+      param_cc_list = new ArrayList<ComputationCompiler>();
+
+      for
+      (
+         final tonkadur.fate.v1.lang.meta.Computation p:
+            n.get_extra_parameters()
+      )
+      {
+         final ComputationCompiler param_cc;
+
+         param_cc = new ComputationCompiler(compiler);
+
+         p.get_visited_by(param_cc);
+
+         /* Let's not re-compute the parameters on every iteration. */
+         param_cc.generate_address();
+
+         if (param_cc.has_init())
+         {
+            result.add(param_cc.get_init());
+         }
+
+         param_cc_list.add(param_cc);
+
+         params.add(param_cc.get_computation());
+      }
+
+      lambda_cc = new ComputationCompiler(compiler);
+
+      n.get_lambda_function().get_visited_by(lambda_cc);
+
+      if (lambda_cc.has_init())
+      {
+         result.add(lambda_cc.get_init());
+      }
+
+      collection_cc = new ComputationCompiler(compiler);
+
+      n.get_collection().get_visited_by(collection_cc);
+
+      if (collection_cc.has_init())
+      {
+         result.add(collection_cc.get_init());
+      }
+
+      result.add
+      (
+         IndexedFilterLambda.generate
+         (
+            compiler.registers(),
+            compiler.assembler(),
+            lambda_cc.get_computation(),
+            collection_cc.get_address(),
+            params
+         )
+      );
+
+      lambda_cc.release_registers(result);
+      collection_cc.release_registers(result);
+
+      for (final ComputationCompiler cc: param_cc_list)
+      {
+         cc.release_registers(result);
+      }
+   }
+
+   @Override
    public void visit_indexed_map
    (
       final tonkadur.fate.v1.lang.instruction.IndexedMap n
@@ -1670,7 +1952,6 @@ implements tonkadur.fate.v1.lang.meta.InstructionVisitor
       collection_cc.release_registers(result);
    }
 
-
    @Override
    public void visit_cond_instruction
    (
@@ -1772,7 +2053,6 @@ implements tonkadur.fate.v1.lang.meta.InstructionVisitor
       result.add(compiler.assembler().merge(previous_else_branch));
    }
 
-
    @Override
    public void visit_event_call
    (
diff --git a/src/core/src/tonkadur/wyrd/v1/compiler/util/IndexedFilterLambda.java b/src/core/src/tonkadur/wyrd/v1/compiler/util/IndexedFilterLambda.java
new file mode 100644
index 0000000..29f08d4
--- /dev/null
+++ b/src/core/src/tonkadur/wyrd/v1/compiler/util/IndexedFilterLambda.java
@@ -0,0 +1,164 @@
+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.type.MapType;
+
+import tonkadur.wyrd.v1.lang.meta.Instruction;
+import tonkadur.wyrd.v1.lang.meta.Computation;
+
+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 IndexedFilterLambda
+{
+   /* Utility Class */
+   private IndexedFilterLambda () {}
+
+   /* Uses Durstenfeld's shuffling algorithm */
+   public static Instruction generate
+   (
+      final RegisterManager registers,
+      final InstructionManager assembler,
+      final Computation lambda,
+      final Address collection,
+      final List<Computation> extra_params
+   )
+   {
+      final List<Instruction> result, while_body, remove_instructions;
+      final Register iterator, index_storage, collection_size, storage;
+
+      result = new ArrayList<Instruction>();
+      while_body = new ArrayList<Instruction>();
+      remove_instructions = new ArrayList<Instruction>();
+
+      iterator = registers.reserve(Type.INT, result);
+      index_storage = registers.reserve(Type.INT, result);
+      collection_size = registers.reserve(Type.INT, result);
+      storage = registers.reserve(Type.BOOL, result);
+
+      result.add(new SetValue(iterator.get_address(), Constant.ZERO));
+      result.add
+      (
+         new SetValue(collection_size.get_address(), new Size(collection))
+      );
+
+      extra_params.add
+      (
+         0,
+         new ValueOf
+         (
+            new RelativeAddress
+            (
+               collection,
+               new Cast(iterator.get_value(), Type.STRING),
+               ((MapType) collection.get_target_type()).get_member_type()
+            )
+         )
+      );
+
+      extra_params.add(0, iterator.get_value());
+
+      remove_instructions.add
+      (
+         new SetValue(index_storage.get_address(), iterator.get_value())
+      );
+
+      remove_instructions.add
+      (
+         RemoveAt.generate
+         (
+            registers,
+            assembler,
+            index_storage.get_address(),
+            collection_size.get_value(),
+            collection
+         )
+      );
+
+      remove_instructions.add
+      (
+         new SetValue
+         (
+            collection_size.get_address(),
+            Operation.minus(collection_size.get_value(), Constant.ONE)
+         )
+      );
+
+      while_body.add
+      (
+         LambdaEvaluation.generate
+         (
+            registers,
+            assembler,
+            lambda,
+            /* Can't put it in the target collection directly, since that may
+             * be a set.
+             */
+            storage.get_address(),
+            extra_params
+         )
+      );
+
+      while_body.add
+      (
+         IfElse.generate
+         (
+            registers,
+            assembler,
+            Operation.not(storage.get_value()),
+            assembler.merge(remove_instructions),
+            new SetValue
+            (
+               iterator.get_address(),
+               Operation.plus(iterator.get_value(), Constant.ONE)
+            )
+         )
+      );
+
+      while_body.add
+      (
+         new SetValue
+         (
+            iterator.get_address(),
+            Operation.plus(iterator.get_value(), Constant.ONE)
+         )
+      );
+
+      result.add
+      (
+         While.generate
+         (
+            registers,
+            assembler,
+            Operation.less_than
+            (
+               iterator.get_value(),
+               collection_size.get_value()
+            ),
+            assembler.merge(while_body)
+         )
+      );
+
+      registers.release(iterator, result);
+      registers.release(index_storage, result);
+      registers.release(collection_size, result);
+      registers.release(storage, result);
+
+      return assembler.merge(result);
+   }
+}
diff --git a/src/core/src/tonkadur/wyrd/v1/compiler/util/IndexedMergeLambda.java b/src/core/src/tonkadur/wyrd/v1/compiler/util/IndexedMergeLambda.java
new file mode 100644
index 0000000..3a501e2
--- /dev/null
+++ b/src/core/src/tonkadur/wyrd/v1/compiler/util/IndexedMergeLambda.java
@@ -0,0 +1,190 @@
+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.type.MapType;
+
+import tonkadur.wyrd.v1.lang.meta.Instruction;
+import tonkadur.wyrd.v1.lang.meta.Computation;
+
+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.computation.IfElseComputation;
+
+import tonkadur.wyrd.v1.lang.instruction.SetValue;
+
+import tonkadur.wyrd.v1.compiler.util.registers.RegisterManager;
+
+public class IndexedMergeLambda
+{
+   /* Utility Class */
+   private IndexedMergeLambda () {}
+
+   /* Uses Durstenfeld's shuffling algorithm */
+   public static Instruction generate
+   (
+      final RegisterManager registers,
+      final InstructionManager assembler,
+      final Computation lambda,
+      final Address collection_in_a,
+      final Address collection_in_b,
+      final Address collection_out,
+      final boolean to_set,
+      final List<Computation> extra_params
+   )
+   {
+      final List<Instruction> result, while_body;
+      final Register iterator, collection_in_size, storage;
+      final Register collection_in_b_size;
+
+      result = new ArrayList<Instruction>();
+      while_body = new ArrayList<Instruction>();
+
+      iterator = registers.reserve(Type.INT, result);
+      collection_in_size = registers.reserve(Type.INT, result);
+      collection_in_b_size = registers.reserve(Type.INT, result);
+      storage =
+         registers.reserve
+         (
+            ((MapType) collection_out.get_target_type()).get_member_type(),
+            result
+         );
+
+      result.add(new SetValue(iterator.get_address(), Constant.ZERO));
+
+      result.add
+      (
+         new SetValue
+         (
+            collection_in_size.get_address(),
+            new Size(collection_in_a)
+         )
+      );
+
+      result.add
+      (
+         new SetValue
+         (
+            collection_in_b_size.get_address(),
+            new Size(collection_in_b)
+         )
+      );
+
+      result.add
+      (
+         new SetValue
+         (
+            collection_in_size.get_address(),
+            new IfElseComputation
+            (
+               Operation.less_than
+               (
+                  collection_in_b_size.get_value(),
+                  collection_in_size.get_value()
+               ),
+               collection_in_b_size.get_value(),
+               collection_in_size.get_value()
+            )
+         )
+      );
+
+
+      extra_params.add
+      (
+         0,
+         new ValueOf
+         (
+            new RelativeAddress
+            (
+               collection_in_b,
+               new Cast(iterator.get_value(), Type.STRING),
+               ((MapType) collection_in_b.get_target_type()).get_member_type()
+            )
+         )
+      );
+
+      extra_params.add
+      (
+         0,
+         new ValueOf
+         (
+            new RelativeAddress
+            (
+               collection_in_a,
+               new Cast(iterator.get_value(), Type.STRING),
+               ((MapType) collection_in_a.get_target_type()).get_member_type()
+            )
+         )
+      );
+
+      extra_params.add(0, iterator.get_value());
+
+      while_body.add
+      (
+         LambdaEvaluation.generate
+         (
+            registers,
+            assembler,
+            lambda,
+            /* Can't put it in the target collection directly, since that may
+             * be a set.
+             */
+            storage.get_address(),
+            extra_params
+         )
+      );
+
+      while_body.add
+      (
+         AddElement.generate
+         (
+            registers,
+            assembler,
+            storage.get_value(),
+            collection_out,
+            to_set
+         )
+      );
+
+      while_body.add
+      (
+         new SetValue
+         (
+            iterator.get_address(),
+            Operation.plus(iterator.get_value(), Constant.ONE)
+         )
+      );
+
+      result.add
+      (
+         While.generate
+         (
+            registers,
+            assembler,
+            Operation.less_than
+            (
+               iterator.get_value(),
+               collection_in_size.get_value()
+            ),
+            assembler.merge(while_body)
+         )
+      );
+
+      registers.release(iterator, result);
+      registers.release(collection_in_size, result);
+      registers.release(collection_in_b_size, result);
+      registers.release(storage, result);
+
+      return assembler.merge(result);
+   }
+}
diff --git a/src/core/src/tonkadur/wyrd/v1/compiler/util/IndexedPartitionLambda.java b/src/core/src/tonkadur/wyrd/v1/compiler/util/IndexedPartitionLambda.java
new file mode 100644
index 0000000..8bd2c74
--- /dev/null
+++ b/src/core/src/tonkadur/wyrd/v1/compiler/util/IndexedPartitionLambda.java
@@ -0,0 +1,177 @@
+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.type.MapType;
+
+import tonkadur.wyrd.v1.lang.meta.Instruction;
+import tonkadur.wyrd.v1.lang.meta.Computation;
+
+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 IndexedPartitionLambda
+{
+   /* Utility Class */
+   private IndexedPartitionLambda () {}
+
+   /* Uses Durstenfeld's shuffling algorithm */
+   public static Instruction generate
+   (
+      final RegisterManager registers,
+      final InstructionManager assembler,
+      final Computation lambda,
+      final Address collection_in,
+      final Address collection_out,
+      final boolean to_set,
+      final List<Computation> extra_params
+   )
+   {
+      final List<Instruction> result, while_body, remove_instructions;
+      final Register iterator, index_storage, collection_size, storage;
+      final Computation iterator_target;
+
+      result = new ArrayList<Instruction>();
+      while_body = new ArrayList<Instruction>();
+      remove_instructions = new ArrayList<Instruction>();
+
+      iterator = registers.reserve(Type.INT, result);
+      index_storage = registers.reserve(Type.INT, result);
+      collection_size = registers.reserve(Type.INT, result);
+      storage = registers.reserve(Type.BOOL, result);
+
+      iterator_target =
+         new ValueOf
+         (
+            new RelativeAddress
+            (
+               collection_in,
+               new Cast(iterator.get_value(), Type.STRING),
+               ((MapType) collection_in.get_target_type()).get_member_type()
+            )
+         );
+
+      result.add(new SetValue(iterator.get_address(), Constant.ZERO));
+      result.add
+      (
+         new SetValue(collection_size.get_address(), new Size(collection_in))
+      );
+
+      extra_params.add(0, iterator_target);
+      extra_params.add(0, iterator.get_value());
+
+      remove_instructions.add
+      (
+         AddElement.generate
+         (
+            registers,
+            assembler,
+            iterator_target,
+            collection_out,
+            to_set
+         )
+      );
+
+      remove_instructions.add
+      (
+         new SetValue(index_storage.get_address(), iterator.get_value())
+      );
+
+      remove_instructions.add
+      (
+         RemoveAt.generate
+         (
+            registers,
+            assembler,
+            index_storage.get_address(),
+            collection_size.get_value(),
+            collection_in
+         )
+      );
+
+      remove_instructions.add
+      (
+         new SetValue
+         (
+            collection_size.get_address(),
+            Operation.minus(collection_size.get_value(), Constant.ONE)
+         )
+      );
+
+      while_body.add
+      (
+         LambdaEvaluation.generate
+         (
+            registers,
+            assembler,
+            lambda,
+            /* Can't put it in the target collection directly, since that may
+             * be a set.
+             */
+            storage.get_address(),
+            extra_params
+         )
+      );
+
+      while_body.add
+      (
+         IfElse.generate
+         (
+            registers,
+            assembler,
+            Operation.not(storage.get_value()),
+            assembler.merge(remove_instructions),
+            new SetValue
+            (
+               iterator.get_address(),
+               Operation.plus(iterator.get_value(), Constant.ONE)
+            )
+         )
+      );
+
+      while_body.add
+      (
+         new SetValue
+         (
+            iterator.get_address(),
+            Operation.plus(iterator.get_value(), Constant.ONE)
+         )
+      );
+
+      result.add
+      (
+         While.generate
+         (
+            registers,
+            assembler,
+            Operation.less_than
+            (
+               iterator.get_value(),
+               collection_size.get_value()
+            ),
+            assembler.merge(while_body)
+         )
+      );
+
+      registers.release(iterator, result);
+      registers.release(index_storage, result);
+      registers.release(collection_size, result);
+      registers.release(storage, result);
+
+      return assembler.merge(result);
+   }
+}
diff --git a/src/core/src/tonkadur/wyrd/v1/compiler/util/PopElement.java b/src/core/src/tonkadur/wyrd/v1/compiler/util/PopElement.java
new file mode 100644
index 0000000..9e30aee
--- /dev/null
+++ b/src/core/src/tonkadur/wyrd/v1/compiler/util/PopElement.java
@@ -0,0 +1,97 @@
+package tonkadur.wyrd.v1.compiler.util;
+
+import java.util.List;
+import java.util.ArrayList;
+
+import tonkadur.wyrd.v1.lang.Register;
+
+import tonkadur.wyrd.v1.lang.type.Type;
+import tonkadur.wyrd.v1.lang.type.PointerType;
+
+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.lang.instruction.Initialize;
+
+import tonkadur.wyrd.v1.compiler.util.registers.RegisterManager;
+
+public class PopElement
+{
+   /* Utility Class */
+   private PopElement () {}
+   public static Instruction generate
+   (
+      final RegisterManager registers,
+      final InstructionManager assembler,
+      final Address collection,
+      final Computation element_holder,
+      final boolean is_from_left
+   )
+   {
+      final Register index, collection_size;
+      final List<Instruction> result;
+      final Computation target_index;
+
+      result = new ArrayList<Instruction>();
+
+      index = registers.reserve(Type.INT, result);
+      collection_size = registers.reserve(Type.INT, result);
+
+      result.add
+      (
+         new SetValue(collection_size.get_address(), new Size(collection))
+      );
+
+
+      if (is_from_left)
+      {
+         target_index = Constant.ZERO;
+      }
+      else
+      {
+         target_index = collection_size.get_value();
+      }
+
+      result.add(new SetValue(index.get_address(), target_index));
+
+      result.add
+      (
+         new SetValue
+         (
+            element_holder,
+            new RelativeAddress
+            (
+               collection,
+               target_index,
+               ((PointerType) element_holder.get_type()).get_target_type()
+            )
+         )
+      );
+
+      result.add
+      (
+         RemoveAt.generate
+         (
+            registers,
+            assembler,
+            index.get_address(),
+            collection_size.get_value(),
+            collection
+         )
+      );
+
+      registers.release(collection_size, result);
+      registers.release(index, result);
+
+      return assembler.merge(result);
+   }
+}
diff --git a/src/core/src/tonkadur/wyrd/v1/lang/instruction/SetValue.java b/src/core/src/tonkadur/wyrd/v1/lang/instruction/SetValue.java
index 4b66fbe..ad0573a 100644
--- a/src/core/src/tonkadur/wyrd/v1/lang/instruction/SetValue.java
+++ b/src/core/src/tonkadur/wyrd/v1/lang/instruction/SetValue.java
@@ -11,21 +11,21 @@ public class SetValue extends Instruction
    /***************************************************************************/
    /**** MEMBERS **************************************************************/
    /***************************************************************************/
-   protected final Address address;
+   protected final Computation address;
    protected final Computation value;
 
    /***************************************************************************/
    /**** PUBLIC ***************************************************************/
    /***************************************************************************/
    /**** Constructors *********************************************************/
-   public SetValue (final Address address, final Computation value)
+   public SetValue (final Computation address, final Computation value)
    {
       this.address = address;
       this.value = value;
    }
 
    /**** Accessors ************************************************************/
-   public Address get_address ()
+   public Computation get_address ()
    {
       return address;
    }