anchor.diff:  -module('Microsoft.FSharp.Collections.SeqModule').
   -export([
            append/2,
  -         %average/1,
  -         %averageBy/2,
  +         average/1,
  +         averageBy/2,
            %cache/1,
            %cast/1,
  -         %choose/2,
  +         choose/2,
            collect/2,
            %compareWith/3
  -         %concat/2
  -         %contains/2
  -         %countBy/2
  +         concat/1,
  +         contains/2,
  +         % countBy/2
            delay/1,
            %distinct/1,
            %distinctBy/2,
            empty/0,
            %exactlyOne/1,
  -         %exists/2,
  +         exists/2,
            %exists2/3,
            filter/2,
  -         %find/2,
  -         %findIndex/2,
  -         %fold/3,
  +         find/2,
  +         findIndex/2,
  +         fold/3,
            %forall/2
            %forall2/3
            %groupBy/2,
  -         %head/1,
  +         head/1,
            %init/2,
            %initInfinite/1,
  -         %isEmpty/1,
  -         %iter/2,
  +         isEmpty/1,
  +         iter/2,
            %iter2/3,
            %iteri2,
            %last/1,
  
positive.code:     [1,2,3] = toList(delay(fun () -> ofList([1,2,3]) end)),
      ok.
  
  lists_are_seqs_test() ->
      [1,2,3] = toList([1,2,3]),
      [1,2,3] = toList(delay(fun () -> [1,2,3] end)),
  
negative.code:         {Item, Enum} ->
              {Item, {append, second, Seq1Enum, Enum}}
      end;
  
  next({concat, undefined, Sources0}) ->
      case next(Sources0) of
          {Enum, Sources} ->
              next({concat, seq(Enum), Sources});
          finished ->
              finished
      end;
  next({concat, Enum0, Sources0}) ->
      case next(Enum0) of
          finished ->
              case next(Sources0) of
                  {Enum, Sources} ->
                      next({concat, seq(Enum), Sources});
                  finished ->
                      finished
              end;
          {Item, Enum} ->
              {Item, {concat, Enum, Sources0}}
      end;
  
  next({iter, N, N, _Gen}) ->
      finished;
  next({iter, Count, Num, Gen}) ->
      {Gen(Count), {iter, Count+1, Num, Gen}};
  
  next({delay, F}) ->
      next(seq(F()));
  next({collect, F, {seq, Enum}}) ->
  