Update all new Tasks

Task/Amb/C-sharp/amb-1.cs

@@ -0,0 +1,152 @@
+using System;
+using System.Collections.Generic;
+
+public class Amb : IDisposable
+{
+    List<IValueSet> streams = new List<IValueSet>();
+    List<IAssertOrAction> assertsOrActions = new List<IAssertOrAction>();
+    volatile bool stopped = false;
+
+    public IAmbValue<T> DefineValues<T>(params T[] values)
+    {
+        return DefineValueSet(values);
+    }
+
+    public IAmbValue<T> DefineValueSet<T>(IEnumerable<T> values)
+    {
+        ValueSet<T> stream = new ValueSet<T>();
+        stream.Enumerable = values;
+        streams.Add(stream);
+        return stream;
+    }
+
+    public Amb Assert(Func<bool> function)
+    {
+        assertsOrActions.Add(new AmbAssert()
+        {
+            Level = streams.Count,
+            IsValidFunction = function
+        });
+        return this;
+    }
+
+    public Amb Perform(Action action)
+    {
+        assertsOrActions.Add(new AmbAction()
+        {
+            Level = streams.Count,
+            Action = action
+        });
+        return this;
+    }
+
+    public void Stop()
+    {
+        stopped = true;
+    }
+
+    public void Dispose()
+    {
+        RunLevel(0, 0);
+        if (!stopped)
+        {
+            throw new AmbException();
+        }
+    }
+
+    void RunLevel(int level, int actionIndex)
+    {
+        while (actionIndex < assertsOrActions.Count && assertsOrActions[actionIndex].Level <= level)
+        {
+            if (!assertsOrActions[actionIndex].Invoke() || stopped)
+                return;
+            actionIndex++;
+        }
+        if (level < streams.Count)
+        {
+            using (IValueSetIterator iterator = streams[level].CreateIterator())
+            {
+                while (iterator.MoveNext())
+                {
+                    RunLevel(level + 1, actionIndex);
+                }
+            }
+        }
+    }
+
+    interface IValueSet
+    {
+        IValueSetIterator CreateIterator();
+    }
+
+    interface IValueSetIterator : IDisposable
+    {
+        bool MoveNext();
+    }
+
+    interface IAssertOrAction
+    {
+        int Level { get; }
+        bool Invoke();
+    }
+
+    class AmbAssert : IAssertOrAction
+    {
+        internal int Level;
+        internal Func<bool> IsValidFunction;
+
+        int IAssertOrAction.Level { get { return Level; } }
+
+        bool IAssertOrAction.Invoke()
+        {
+            return IsValidFunction();
+        }
+    }
+
+    class AmbAction : IAssertOrAction
+    {
+        internal int Level;
+        internal Action Action;
+
+        int IAssertOrAction.Level { get { return Level; } }
+
+        bool IAssertOrAction.Invoke()
+        {
+            Action(); return true;
+        }
+    }
+
+    class ValueSet<T> : IValueSet, IAmbValue<T>, IValueSetIterator
+    {
+        internal IEnumerable<T> Enumerable;
+        private IEnumerator<T> enumerator;
+
+        public T Value { get { return enumerator.Current; } }
+
+        public IValueSetIterator CreateIterator()
+        {
+            enumerator = Enumerable.GetEnumerator();
+            return this;
+        }
+
+        public bool MoveNext()
+        {
+            return enumerator.MoveNext();
+        }
+
+        public void Dispose()
+        {
+            enumerator.Dispose();
+        }
+    }
+}
+
+public interface IAmbValue<T>
+{
+    T Value { get; }
+}
+
+public class AmbException : Exception
+{
+    public AmbException() : base("AMB is angry") { }
+}

Task/Amb/C-sharp/amb-2.cs

@@ -0,0 +1,30 @@
+    // original problem
+    using (Amb amb = new Amb())
+    {
+        var set1 = amb.DefineValues("the", "that", "a");
+        var set2 = amb.DefineValues("frog", "elephant", "thing");
+        var set3 = amb.DefineValues("walked", "treaded", "grows");
+        var set4 = amb.DefineValues("slowly", "quickly");
+
+        amb.Assert(() => IsJoinable(set1.Value, set2.Value));
+        amb.Assert(() => IsJoinable(set2.Value, set3.Value));
+        amb.Assert(() => IsJoinable(set3.Value, set4.Value));
+
+        amb.Perform(() =>
+            {
+                System.Console.WriteLine("{0} {1} {2} {3}", set1.Value, set2.Value, set3.Value, set4.Value);
+                amb.Stop();
+            });
+    }
+    // problem from http://www.randomhacks.net/articles/2005/10/11/amb-operator
+    using (Amb amb = new Amb())
+    {
+        IAmbValue<int> x = amb.DefineValues(1, 2, 3);
+        IAmbValue<int> y = amb.DefineValues(4, 5, 6);
+        amb.Assert(() => x.Value * y.Value == 8);
+        amb.Perform(() =>
+            {
+                System.Console.WriteLine("{0} {1}", x.Value, y.Value);
+                amb.Stop();
+            });
+    }