def stream (n)
    {
      comp enumerable
      {
        yield n;
        yieldcomp (stream (n + 1));
      }
    }

    
    def filesUnderFolder (rootFolder : string) : IEnumerable [string]
    {
      comp enumerable
      {
        foreach (file in System.IO.Directory.GetFiles (rootFolder))
          yield file;
        foreach (dir in System.IO.Directory.GetDirectories (rootFolder))
          yieldcomp (filesUnderFolder (dir))
      }
    }

1. 
   Начинай сообщение для коммита со строки:
   

   [Snippets] Computation Expressions

   Чтобы было проще понимать что да коммит.
   
   
2. 
   Не экономь на файлах.
   Лучше много маленьких чем мало больших.
   Ибо так гораздо удобнее искать что где лежит.
   
   
3. 
   EmptyEnumerable[T]/EmptyEnumerator[T] не имеют состояния. Следовательно их можно раз и на всегда закешировать в статической переменной.
   
   
4. 
   Зачем так сложно?
   

     public module EnumerableHelper
     {
   ...    
       public Delay[T] (cont : void -> IEnumerable[T]) : IEnumerable[T]
       {
         foreach (t in cont ())  yield t
       }

   
   
   Почему не:
   

       public Delay[T] (cont : void -> IEnumerable[T]) : IEnumerable[T]
       {
         cont ();
       }

   
   
   
5. 
   Тут ты тоже перемудрил. Так лучше:
   

     public variant LazyStream[T]
     {
       | Nil;
       | Cons { value : T; cont : void -> LazyStream[T] }
       
       public ToEnumerable () : IEnumerable[T]
       {
         def loop(_)
         {
           | Nil => ()
           | Cons (value, cont) =>
             yield value;
             loop(cont());
         }
         loop(this);
       }
     }

   
   
   
6. 
   Вместо:
   

         def temp = Macros.NewSymbol ();
         def loop = Macros.NewSymbol ();

   
   лучше писать
   

         def temp = Macros.NewSymbol ("temp");
         def loop = Macros.NewSymbol ("loop");

   
   Так макрос после рускрутки получится более читаемый.
   
   
7. 
   Тут происходит нечто страшное:
   

         def coll =
           <[
               EnumerableHelper.Delay (() =>
                 {
                   $init;
                   $postInit;
                   
                   def $(loop : name) ()
                   {
                     match ($cond)
                     {
                       | false => LazyStream.Nil ();
                       | true =>  LazyStream.Cons ($var, () => { $change; $(loop : name) () })
                     }
                   }
                   
                   $(loop : name) ().ToEnumerable ()
                 })
           ]>;

   
   def $(loop : name) () лишнее.
   Достаточно def loop ()
   Ибо макросы по умолчанию гигееничны.
   
   Но главное тут плодится куча мусора на ровном месте.
   Вот так гораздо лучше:
   

     public module ForHelper
     {
       public Enumerate[T](cond : void -> bool, value : void -> T, change : void -> void) : IEnumerable[T]
       {
         while (cond())
         {
           yield value();
           change();
         }
       }
     }

   
   

         def coll =
           <[
               EnumerableHelper.Delay (() =>
                 {
                   $init;
                   $postInit;
                   
                   ForHelper.Enumerate(() => $cond, () => $var, () => $change)
                 })
           ]>;

   
   
   
8. 
   Тут ИМХО лучше так:
   

     internal class ListBuilder : ComputationBuilder
   ...
       public override Yield (expr : PExpr) : PExpr
       {
         <[ $(acc : name).Add($expr) ]>
       }
   ...
       public override Run (expr : PExpr) : PExpr
       {
         <[
           { 
             mutable $(acc : name) = List();
             $expr;
             $(acc : name).NToList ()
           }
         ]>
       }

   
   
9. 
   Зачем нужно два void'а?
   

     public sealed class ComputationVoid
     {
       public static Value : ComputationVoid = ComputationVoid ()
     }
   
     public variant FakeVoid
     {
       | FakeVoid
     }

   
   
   
10. 
    Можно писать так:
    

    _testDo(10).Iter(WriteLine);

    
    местный вывод типов может даже в таких ситуациях разбираться...
    
    
11. 
    А еще я вернул ComputationExpressions.sln который ты зачемто удалил.
    Ибо многим работать в IDE банально удобнее.

VD>Какие люди в нашей деревне!

type Cont[R,A] = Fun[Fun[A,R],R]

class Cont[R,A] {
    cont: Fun[Fun[A,R],R];
    Cont(cont: Fun[Fun[A,R],R]) { this.cont = cont; }
}

class Cont[R,A] {
    Map[B](fun: Fun[A,B]): Cont[R,B] { ... }
}

class Cont[R,A] {
    Map[B](fun: Fun[A,B]): Cont[R,B] {
        return new Cont(k => this.cont(x => k(fun(x))));
    }
}

Join(m: Cont[Cont[A]]): Cont[A]

cont.Bind(f) == Join(cont.Map(f))

class Cont[R,A] {
    static Join[R,A](c: Cont[R,Cont[R,A]]): Cont[R,A] {
        return new Cont(x => c.cont(k => k.cont(x)));
    }
}

Продолжения
Обработка исключений
ГУИ
Логгинг
Коммуникации между процессами
Парсеры
Интерпретаторы
Энергичное исполнение кода
Интерфейс к коду на других языках (FFI)

Бэктрекинг
Логика
STM
Multiresult
optional result
случайные значения
недетерминированность

да и самому можно толпу придумать — например, упорядочивание результатов, или для моделирования устройств — вычисления с тактами, ну и т.д.

VD>В прочем, с философской точки зрения попытка хорошая. Просто мы совершенно разные люди. Тебе видимо чужд не научный метод определения пола кошаков (бросил... побежала — кошка, побежал — кот) .

D>В общем, считайте, что async из F# уже почти есть в Немерле

    def poolContext = ThreadPoolExecutionContext(10);
    def guiContext = WindowsFormsExecutionContext(form);
    
    def worker()
    {
        comp async
        {
            callcomp Async.SwitchTo(poolContext);
            //делаем что-то тяжолое в контексте пула.
            callcomp Async.SwitchTo(guiContext);
            //а тут спокойно ковыряемся в gui.
            returncomp worker();
        }
    }
    poolContext.Start(worker());

<[
try
{
}
catch 
{
  ..$(GenerateExcetpionHandlers())
}
]>

    
D>    def filesUnderFolder (rootFolder : string) : IEnumerable [string]
D>    {
D>      comp enumerable
D>      {
D>        foreach (file in System.IO.Directory.GetFiles (rootFolder))
D>          yield file;
D>        foreach (dir in System.IO.Directory.GetDirectories (rootFolder))
D>          yieldcomp (filesUnderFolder (dir))
D>      }
D>    }
D>

   let rec getAllFiles pattern folder  = 
      seq { for x in Directory.GetDirectories folder do yield! getAllFiles pattern x 
            for x in Directory.GetFiles(folder, pattern) do yield x }

    def filesUnderFolder(pattern, rootFolder)
    {
      comp enumerable
      {
        foreach (file in Directory.GetFiles(rootFolder, pattern))
          yield file;
        foreach (dir in Directory.GetDirectories(rootFolder))
          yieldcomp filesUnderFolder(pattern, dir);
      }
    }

    let rec getAllFiles pattern folder  = 
        seq
        {
            for x in Directory.GetDirectories folder do
                yield! getAllFiles pattern x 
            for x in Directory.GetFiles(folder, pattern) do
                yield x 
        }

  public macro @compEnumerable (expr)
  syntax ("comp", "enumerable", expr)
  {
    ComputationExpander.Expand (EnumerableBuilder.Instance, expr)
  }
  
  public macro @compEnumerableSeq (expr)
  syntax ("seq", expr)
  {
    ComputationExpander.Expand (EnumerableBuilder.Instance, expr)
  }

    
D>    def filesUnderFolder (rootFolder : string) : IEnumerable [string]
D>    {
D>      comp enumerable
D>      {
D>        foreach (file in System.IO.Directory.GetFiles (rootFolder))
D>          yield file;
D>        foreach (dir in System.IO.Directory.GetDirectories (rootFolder))
D>          yieldcomp (filesUnderFolder (dir))
D>      }
D>    }
D>

    compdef filesUnderFolder (rootFolder : string) : IEnumerable [string]
    {
      foreach (file in System.IO.Directory.GetFiles (rootFolder))
        yield file;

      foreach (dir in System.IO.Directory.GetDirectories (rootFolder))
        yieldcomp (filesUnderFolder (dir))
    }

[url=http://nemerle.googlecode.com/svn/nemerle/trunk/snippets/raytracer/ray-cs.cs]ray-cs.cs[/url]        4 249
[url=http://nemerle.googlecode.com/svn/nemerle/trunk/snippets/raytracer/ray2.ml]ray2.ml[/url]          2 793
[url=http://nemerle.googlecode.com/svn/nemerle/trunk/snippets/raytracer/ray3.ml]ray3.ml[/url]          3 030
[url=http://nemerle.googlecode.com/svn/nemerle/trunk/snippets/raytracer/ray.n]ray.n[/url]            2 962
[url=http://nemerle.googlecode.com/svn/nemerle/trunk/snippets/raytracer/ray2.n]ray2.n[/url]           3 024
[url=http://nemerle.googlecode.com/svn/nemerle/trunk/snippets/raytracer/ray3.n]ray3.n[/url]           3 470
[url=http://nemerle.googlecode.com/svn/nemerle/trunk/snippets/raytracer/ray-compressed.n]ray-compressed.n[/url] 2 725
[url=http://nemerle.googlecode.com/svn/nemerle/trunk/snippets/raytracer/ray-hand-opt.n]ray-hand-opt.n[/url]   3 574

WH>    def filesUnderFolder(pattern, rootFolder)
WH>    {
WH>      comp enumerable
WH>      {
WH>        foreach (file in Directory.GetFiles(rootFolder, pattern))
WH>          yield file;
WH>        foreach (dir in Directory.GetDirectories(rootFolder))
WH>          yieldcomp filesUnderFolder(pattern, dir);
WH>      }
WH>    }
WH>

using System.IO.Directory;

def filesUnderFolder(pattern, rootFolder)
{
  comp enumerable
  {
    foreach (file in GetFiles(rootFolder, pattern))
      yield file;
    foreach (dir in GetDirectories(rootFolder))
      yieldcomp filesUnderFolder(pattern, dir);
  }
}

type Cont a = (a -> Result) -> Result

return a = \c -> c a

bind m k = \c -> m (\a -> k a c)

  public macro DefCompEnum (name, args, expr)
  {
    def args = (args :> PExpr.Tuple).args.Map(PParameter);
    def name = (name :> PExpr.Ref).name;
    def res = ComputationExpander.Expand (EnumerableBuilder.Instance, expr);
    <[
      def $(name : name)(..$args)
      {
        $res;
      }
    ]>
  }

    DefCompEnum(filesUnderFolder, (rootFolder : string, pattern),
    {
      foreach (file in Directory.GetFiles(rootFolder, pattern))
        yield file;
      foreach (dir in Directory.GetDirectories(rootFolder))
        yieldcomp filesUnderFolder(dir, pattern);
    });
    filesUnderFolder("H:\\Video", "*").Iter(WriteLine);

  public macro DefCompEnum (name, args, expr)
  syntax ("compdef", fancName, args, expr)
  {
    def args = (args :> PExpr.Tuple).args.Map(PParameter);
    def name = (name :> PExpr.Ref).name;
    def res = ComputationExpander.Expand (EnumerableBuilder.Instance, expr);
    <[
      def $(name : name)(..$args)
      {
        $res;
      }
    ]>
  }

  public macro @compList (expr)
  syntax ("comp", "list", expr)
  {
    ComputationExpander.Expand (ListBuilder (), expr)
  }
  
  public macro @compArray (expr)
  syntax ("comp", "array", expr)
  {
    ComputationExpander.Expand (ArrayBuilder (), expr)
  }
  
  public macro @compEnumerable (expr)
  syntax ("comp", "enumerable", expr)
  {
    ComputationExpander.Expand (EnumerableBuilder.Instance, expr)
  }

  public macro @comp (builder, expr)
  syntax ("comp", builder, expr)
  {
    def builder = match (builder)
    {
      | PExpr.Ref(name) when name.Id == "list"       => Extensions.ListBuilder()
      | PExpr.Ref(name) when name.Id == "array"      => Extensions.ArrayBuilder()
      | PExpr.Ref(name) when name.Id == "enumerable" => Extensions.EnumerableBuilder.Instance
      | _                                            => DefaultBuilder(builder)
    }
    ComputationExpander.Expand (builder, expr)
  }

VD>>

WH>А ты попробуй

  public macro DefCompEnum (prefix, body)
  syntax ("compdef", prefix, body)
  {
    match (prefix)
    {
      | <[ $name(..$args) ]> => <[ def $name = (..$args) => $body  ]>
      | _ => Message.FatalError(prefix.Location, "Expected fanc def: func_name(optional_parameters)")
    }
  }

compdef test(a, b)
{
  a + b
}
    
WriteLine(test(2, 3));

variant CompExpr
{
    | Sequence { seq : list[CompExpr] }
    | Return { expr : PExpr }
    | ReturnComp { expr : CompExpr }
...
}

def where (coll, pred)
{
  comp builder
  {
    defcomp x = coll;
    if pred (x) 
      return x
    else
      returncomp zero
  }
}

match (c : TryCase)
{
  | Catch (exn, exn_ty, handler) => ...
  | Filter (exn, exn_ty, filter, handler) => ...
  | Ellipsis (handler) => ...
}

D>match (c : TryCase)
D>{
D>  | Catch (exn, exn_ty, handler) => ...
D>  | Filter (exn, exn_ty, filter, handler) => ...
D>  | Ellipsis (handler) => ...
D>}
D>

try {
} catch {
   | e is ArgumentNullException => 
}

try {
} catch {
   | e is ArgumentNullException when e.Message.Contains("x") => 
}

try {
} catch {
   | _ => 
}

try
{
  ...
}
catch
{
  | e is SomeException when e.SomeProperty == 123
}

def fmap (coll, f)
{
  comp builder
  {
    defcomp x = coll;
    return (f (x))
  }
}

def get_html_async (url : string)
{
  comp async 
  {
    def request = WebRequest.Create(url);
    defcomp response = request.AsyncGetResponse();
    def stream = response.GetResponseStream();
    def reader = StreamReader(stream);
    defcomp text = reader.AsyncReadToEnd();  
    return text  
  }  
}

D>def fmap (coll, f)
D>{
D>  comp builder
D>  {
D>    defcomp x = coll;
D>    return (f (x))
D>  }
D>}
D>

public static IEnumerable<TResult> Select<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, TResult> selector)

public MapLazy[From, To](this source : SCG.IEnumerable[From], convert : From -> To) : SCG.IEnumerable[To]

VD><[
VD>try
VD>{
VD>}
VD>catch 
VD>{
VD>  ..$(GenerateExcetpionHandlers())
VD>}
VD>]>
VD>

  comp builder
  {
    using (defcomp x = resource_in_monad)
    {
      ...
    }
  }

public struct unit { }

(a + b) + c = a + (b + c)

x.SelectMany(y => f(y).SelectMany(g)

x.SelectMany(f).SelectMany(g)