let rec iter arr i act =
    act arr.(i);
    if i < Array.length arr - 1 then
        let next = iter arr (i + 1)
        in `Some next
    else
        `None;;
                
let rec iterOther mact other act = 
    let v = other (fun x -> act (mact x)) in
    match v with
    | `Some v -> `Some (iterOther mact v)
    | `None   -> `None;;
        
let (~~) arr = iter arr 0;; (* just a construction helper *)

(* That's the function you've asked :) *)
let rec map' f it = iterOther f it;;
        
let res = map' string_of_int ~~[| 1;2;3 |];;

(* we've already constructed a new iterator, just checking what's inside *)
let rec each' f it = 
    match it f with
    | `Some v -> each' f v
    | `None   -> ()
    in each' (Printf.printf "%s\n") res;;

- Папа, это что?
— Море, море, море!
— Папа, а что это было?

let rec iter arr i act =
    act arr.(i);
    if i < Array.length arr - 1 then
        let next = iter arr (i + 1)
        in `Some next
    else
        `None;;
        
let (~~) arr = iter arr 0;; (* just a construction helper *)

let lst = [ ~~[| 1;2;3 |]; ~~[| 4;5;6 |]; ~~[| 7;8;9 |]; ];; 

let rec filter f lst = 
    let rec filter' = function
        | x::xs -> (match x f with
                   | `Some v -> v :: filter' xs
                   | `None   -> filter' xs)
        | []    -> []
    in
    match filter' lst with
    | []  -> ()
    | nl  -> filter f nl;;
        
filter (Printf.printf "%d\n") lst;;

let rec iter arr i act =
    act arr.(i);
    if i < Array.length arr - 1 then
        let next = iter arr (i + 1)
        in `Some next
    else
        `None;;
        
let rec iter2 lst act =
    match lst with
    | x::xs -> act x; `Some (iter2 xs)
    | []    -> `None;;
        
let (~~) arr = iter arr 0;; (* just a construction helper *)

let lst = [ ~~[| 1;2;3 |]; ~~[| 4;5;6 |]; ~~[| 7;8;9 |]; ];; 

let lst2 = [ iter2 [ 1;2;3 ]; iter2 [ 4;5;6 ]; iter2 [ 7;8;9 ]; ];; 

let rec filter f lst = 
    let rec filter' = function
        | x::xs -> (match x f with
                   | `Some v -> v :: filter' xs
                   | `None   -> filter' xs)
        | []    -> []
    in
    match filter' lst with
    | []  -> ()
    | nl  -> filter f nl;;
        
let _ = filter (Printf.printf "%d\n") lst;;

let _ = filter (Printf.printf "%d\n") lst2;;

ВВ>Получается, что это функциональная обвертка над императивной штукой

[? List: (a, a * a) | a <- 1--10 ?]

[? String: a | a <-   'a'  -- 'z'  ?]

DM>Простите за мой французский, но я напишу на Окамле

DM>(* функция, создающая один итератор *)
DM>let file_iter n = Enum.init 10 (fun i -> Printf.sprintf "file%d line%d" n i)

DM>(* список таких итераторов *)
DM>let files = List.init 10 (fun n -> file_iter n)

DM>(* вывод строк по одной *)
DM>let rec show_lines lst =
DM>  let continue = List.fold_left (fun not_end it -> (* проходимся по списку итераторов *)
DM>    match Enum.get it with (* берем из каждого по одной строке *)
DM>    | None -> not_end 
DM>    | Some line -> print_endline line; true) false lst  in (* выводим ее, и определяем, нужно ли продолжать *)
DM>  if continue then show_lines lst else ();; (* пока все не кончились, повторяем *)

DM>show_lines files (* запускаем *)
DM>

let lst = [ [ 1;2;3 ]; [ 4;5;6 ]; [ 7;8;9 ]; ];;                  

let rec iter = function
    | x::xs -> ( Printf.printf "%d\n" x; `Some (xs) )
    | []    -> `None;;
            
let rec filter f lst = 
    let rec filter' = function
        | x::xs -> (match f x with
                   | `Some(v) -> v :: filter' xs
                   | `None    -> filter' xs)
        | []    -> []
    in
    match filter' lst with
    | []  -> ()
    | nl  -> filter f nl;;
        
filter iter lst;;

IEnumerable<Int32> Range(int start, int end)
{
    var e = end + 1;

    for (var i = start; i < e; i++)
        yield return i;
}


foreach (var i in Range(0, 100)) {
    //Do something
}

void Range(int start, int end, Action<Int32> fun)
{
    var e = end + 1;

    for (var i = start; i < e; i++)
        fun(i);
}

Func<T,Int32,Boolean> Create(Action<T> fun, int take)
{
    var t = take + 1;
    return (e, i) => {
            if (i < t) {            
                fun(e);
                return true;
            }
            else
                return false;
        };
}

bool hadString = false;
using(StreamWriter sw = OpenWriteStream())
foreach(var s in source.ReadStrings())
{
  if (hadString)
    sw.Write(", ");
  else 
    hadString = true;
  sw.Write(s);
}

using(StreamWriter sw = OpenWriteStream())
{
  var sProcessor = new sProcessor(sw);
  source.ReadStrings(sProcessor.Process)
}
...

private class sProcessor
{
  private bool _hadString = false;
  private StreamWriter _sw;
  public sProcessor(StreamWriter sw)
  {
    _sw = sw;
  }
  public void Process(string s)
  {
    if (_hadString)
      _sw.Write(", ");
    else 
      _hadString = true;
    _sw.Write(s);
  }
}

ВВ>>Вообще вопрос можно задать так — почему итераторы не нужны в Хаскеле?

L>Потому что он весь из себя ленивый — ты свободно можешь создать бесконечный список и вернуть его из фнкции.

let where f x::xs = if f x then x :: (lazy where f xs) else where f xs
        | f []    = [];

for (;;) yield 1;

let fold f z x::xs = fold f (f z x) xs
       | f z []    = z

Ты так и не определил, что же такое правильный инструмент. ДАвай я это сделаю за тебя. Из твоего ответа видно, что ты считаешь правильным инструментом тот, который напрямую предназначен для решения этой задачи.
Так ты считаешь?

Так вот реальный мир против. Правильный инструмент это тот который решает поставленную задачу с наименьшими затратами (и сил и времени и всего остального).

comp f next x y | r == 0    = next x y
                | otherwise = r
                where r = f x y

(* функция, создающая один итератор *)
let file_iter n = Enum.init 10 (fun i -> Printf.sprintf "file%d line%d" n i)

(* список таких итераторов *)
let files = List.init 10 (fun n -> file_iter n)

(* вывод строк по одной *)
let rec show_lines lst =
  let continue = List.fold_left (fun not_end it -> (* проходимся по списку итераторов *)
    match Enum.get it with (* берем из каждого по одной строке *)
    | None -> not_end 
    | Some line -> print_endline line; true) false lst  in (* выводим ее, и определяем, нужно ли продолжать *)
  if continue then show_lines lst else ();; (* пока все не кончились, повторяем *)

show_lines files (* запускаем *)

DM>Простите за мой французский, но я напишу на Окамле

fold :: (a -> b -> b) -> b -> IntMap a -> b
fold f z coll  (f an ...(f a2 (f a1 z)))
prod = fold (*) 1 coll
       (an * ...(a2 * (a1 * 1)))
prodbut n = snd (fold iteratee (n,1) coll)
  where iteratee a (n,s) =
      if n <= 0 then (n,a*s) else (n-1,s)

open ExtLib;;

let lst = [ [ 1;2;3 ]; [ 4;5;6 ]; [ 7;8;9 ]; ];;                  

let rec iter action = function
  | x::xs -> action x; Some xs 
  | []    -> None;;
            
let rec filter f lst = 
  match List.filter_map f lst with
  | []  -> ()
  | nl  -> filter f nl;;
        
filter (iter (Printf.printf "%d ")) lst;;

class ForEach f where
  toEnumerator :: f a -> [a]

foreach :: (ForEach f, Monad m) => f a -> (a -> m ()) -> m ()
foreach = mapM_ . toEnumerator

foreach collection (\item ->
    doSomethingWith item
)

toList :: Foldable t => t a -> [a]
toList = foldr (:) []

Prelude Data.Foldable> for_ [0..5] print
0
1
2
3
4
5

for_ :: (Foldable t, Applicative f) => t a -> (a -> f b) -> f ()

When the compiler detects your iterator, it will automatically generate the Current, MoveNext and Dispose methods of the IEnumerator or IEnumerator<T> interface.

Return Value The Type instance that represents the exact runtime type of the current instance.

IEnumerable<int> Range(int start, int end)
{
  for(var i = start; i <= end; ++i)
    yield return i;
}