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))
      }
    }

    
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 }

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 банально удобнее.

    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);
  }
}