anchor.diff:  
   exists(F, Seq) ->
       find_internal(seq(Seq), F) =/= undefined.
  +
  +exists2(F, Seq1, Seq2) ->
  +    find2_internal(F, seq(Seq1), seq(Seq2)) =/= undefined.
  +
  +exactlyOne(Seq0) ->
  +    case next(seq(Seq0)) of
  +        finished ->
  +            throw_arg_exn();
  +        {Item, Seq} ->
  +            case next(Seq) of
  +                finished ->
  +                    Item;
  +                _ ->
  +                    throw_arg_exn()
  +            end
  +    end.
   
   filter(Pred, Seq) ->
       {seq, {filter, Pred, seq(Seq)}}.
  
positive.code:     end.
  
  init(Num, Gen) ->
      {seq, {iter, 0, Num, Gen}}.
  
  isEmpty(Seq) ->
      next(seq(Seq)) =:= finished.
  
negative.code:                                     end),
      unit.
  
  iteri(Action, Seq) ->
      _ = aggregate(Seq, 0, fun (S, I) ->
                                    Action(S, I),
                                    S+1
                            end),
      unit.
  
  iter2(Action, Seq1, Seq2) ->
      _ = toList(map2(Action, Seq1, Seq2)),
      unit.
  
  countBy(F, Seq0) ->
        L = lists:usort(toList(map(F, seq(Seq0)))),
        length(L).
  
  delay(F) ->
      {seq, {delay, F}}.
  
  % cast is effectively a noop
  cast(Seq) -> seq(Seq).
  
  choose(Chooser, Seq) ->
      filter(fun(I) ->
  