if (current_abstraction_level > 4)
  enable_optimization = 0;

_>А почему зря? Человек с опытом программирования на Delphi изучил исходники STL, расширил свой кругозор, у него возникли понятные вопросы почему STL сделан так а не иначе, и нельзя ли сделать лучше.

ее можно реализовать при помощи чистого ООП не потеряв ничего в фичах и гибкости

let get_iter l =
  let lref = ref l in
    let next () = 
        match !lref with 
          | [] -> None
          | a::b -> (lref := b; Some a)
  in next
  
let rec print it = 
  match it () with
    | Some x -> (Printf.printf "%d\n" x; print it)
    | None -> ()
    ;;

print (get_iter [1; 2; 3; 4])

I>Начинали на схеме, потом была Ада, потом С++ А если я кое что похожее начинал на асме, не зная ничего про ФП, стало быть функции цельнотянутые из императивного ассемблера ?

In the late 70’s I became aware of John Backus’s work on FP1. While his idea of programming with functional forms struck me as essential, I realized that his attempt to permanently fix the number of functional forms was fundamentally wrong. The number of functional forms – or as I call them now – generic algorithms is always growing as we discover new algorithms. In 1980 together with Dave Musser and Deepak Kapur I started working on a language Tecton to describe algorithms defined on algebraic theories. The language was functional since I did not realize at the time that memory and pointers were a fundamental part of programming. I also spent time studying Aristotle and his successors and that lead me to a better understanding of fundamental operations on objects like equality and copying and the relation between whole and part.

class SampleMachine
  include StateMachine
  state_machine :states => [:a_state, :b_state, :c_state, :d_state], :events => [:w_event, :x_event, :y_event, :z_event]
  state_transition :state=>:a_state, :event=>:x_event, :next=>:c_state
  state_transition :state=>:a_state, :event=>:y_event, :next=>:a_state
  state_transition :state=>:a_state, :event=>:z_event, :next=>:b_state
                                                            
  state_transition :state=>:b_state, :event=>:w_event, :next=>:b_state
  state_transition :state=>:b_state, :event=>:y_event, :next=>:c_state
  state_transition :state=>:b_state, :event=>:z_event, :next=>:a_state
                                                            
  state_transition :state=>:c_state, :event=>:x_event, :next=>:b_state
end

sm = SampleMachine.new
assert_equal(:a_state, sm.current_state)
sm.send_event(:x_event)
assert_equal(:c_state, sm.current_state)

KV>В nemerle не придется

generator stateA
loop
while condition
do something
yield stateB

generator stateB
loop
while condition
do something
yield stateA

subroutine dispatcher
var d := new dictionary〈generator → iterator〉
d[stateA] := start stateA
d[stateB] := start stateB
var current := stateA
loop
current := next d[current]

generator stateA
    loop
        while condition
            do something
        yield stateB

generator stateB
    loop
        while condition
            do something
        yield stateA

subroutine dispatcher
    var d := new dictionary〈generator → iterator〉
    d[stateA] := start stateA
    d[stateB] := start stateB
    var current := stateA
    loop
        current := next d[current]

#pragma indent
using Nemerle.Fsm;

[FsmDef(
    SampleMachine
    {
        default stateA;

        state stateA
            | eventX => stateC;
            | eventY => stateA;
            | eventZ => stateB;
            
        state stateB
            | eventW => stateB;
            | eventY => stateC;
            | eventZ => stateA;
            
        state stateC
            | eventX => stateB;
    }
)]

def sm = SampleMachine;
Assert.Equal(sm.States.stateA, sm.CurrentState);
sm.Event(sm.Events.eventX);
Assert.Equal(sm.States.stateC, sm.CurrentState);

[FsmDef(
    SampleMachine
    {
        default stateA;
    
        event eventW
            | stateB => stateB;
            
        event eventX
            | stateA => stateC;
            | stateC => stateB;
        
        event eventY
            | stateA => stateA;
            | stateB => stateC;
            
        event eventZ
            | stateA => stateB;
            | stateB => stateA;
    }
)]
// Далее, код идентичен

public class SampleMachine: StateMachine<State, Event>
{
    public SampleMachine()
    {
        StateTransition(State.A, Event.X, State.C);
        StateTransition(State.A, Event.Y, State.A);
        StateTransition(State.A, Event.Z, State.B);

        StateTransition(State.B, Event.W, State.B);
        StateTransition(State.B, Event.Y, State.C);
        StateTransition(State.B, Event.Z, State.A);

        StateTransition(State.C, Event.X, State.B);
    }
}

G>public class SampleMachine: StateMachine<State, Event>
G>{
G>    public SampleMachine()
G>    {
G>        StateTransition(State.A, Event.X, State.C);
G>        StateTransition(State.A, Event.Y, State.A);
G>        StateTransition(State.A, Event.Z, State.B);

G>        StateTransition(State.B, Event.W, State.B);
G>        StateTransition(State.B, Event.Y, State.C);
G>        StateTransition(State.B, Event.Z, State.A);

G>        StateTransition(State.C, Event.X, State.B);
G>    }
G>}
G>

IEnumerable<Vertex> Verteces(Vertex root)
{
   var hash = new HashSet<Vertex>();
   ListVisitor<Vertex> visitList = null; 
   Visitor<Vertex> visit = (v) => { hash.Add(v); visitList(v.Childs); };
   visitList = (l) => { foreach(var v in l ?? new Vertex[0] ) visit(v); }

   visit(root);

   return hash;
}

G>>public class SampleMachine: StateMachine<State, Event>
G>>{
G>>    public SampleMachine()
G>>    {
G>>        StateTransition(State.A, Event.X, State.C);
G>>        StateTransition(State.A, Event.Y, State.A);
G>>        StateTransition(State.A, Event.Z, State.B);

G>>        StateTransition(State.B, Event.W, State.B);
G>>        StateTransition(State.B, Event.Y, State.C);
G>>        StateTransition(State.B, Event.Z, State.A);

G>>        StateTransition(State.C, Event.X, State.B);
G>>    }
G>>}
G>>

I>Т.е. пока что ты сел в лужу

public enum State {A,B,C,D}
public enum Event {W,X,Y,Z}

I>IEnumerable<Vertex> Verteces(Vertex root)
I>{
I>   var hash = new HashSet<Vertex>();
I>   ListVisitor<Vertex> visitList = null; 
I>   Visitor<Vertex> visit = (v) => { hash.Add(v); visitList(v.Childs); };
I>   visitList = (l) => { foreach(var v in l ?? new Vertex[0] ) visit(v); }

I>   visit(root);

I>   return hash;
I>}
I>

public static IEnumerable<T> Traverse<T>(this IEnumerable<T> source, Func<T, IEnumerable<T>> childrenSelector)
{
    return source.SelectMany(e => Traverse(e, childrenSelector));
}

public static IEnumerable<T> Traverse<T>(T item, Func<T, IEnumerable<T>> childrenSelector)
{
    yield return item;
    foreach (var subItem in childrenSelector(item).Traverse(childrenSelector))
    {
        yield return subItem;
    }
}

TreeNumerable.Traverse(root, v => v.Childs ?? new Vertex[0]).Distinct()