Code doesn't work - why?

[Robin via Digitalmars-d-learn]

Hello,

I came back to D after a longer break and just wanted to set up a 
small project to further get in contact with this language.

However, it seems that the codes which simply shall simulate a 
deterministic finit automaton do not work correctly.

CODE ---

struct DeterministicState {
public:
	this(string name, bool isFinal, DeterministicState[char] 
transits...) {
                this.name = name;
                this.finalState = isFinal;
                this.addTransits(transits);
        }

        this(string name, bool isFinal) {
                this.name = name;
                this.finalState = isFinal;
        }

        this(bool isFinal, DeterministicState[char] transits...) {
                this("", isFinal, transits);
        }

        this(DeterministicState[char] transits...) {
                this("", false, transits);
        }

        void addTransits(DeterministicState[char] newTransits) {
                foreach (immutable key; newTransits.keys) {
                        transits[key] = newTransits[key];
                }
        }

        string getName() const {
                return name;
        }

        bool isFinalState() const {
                return finalState;
        }

        bool hasNext(char input) const {
                return (input in transits) ? true : false;
        }

        DeterministicState getNext(char input) {
                return transits[input];
        }

        string toString() const {
                return name;
        }

private:
        string name;
        DeterministicState[char] transits;
        bool finalState;
}

struct DeterministicFiniteAutomaton {
public:
        DeterministicState[] input(char[] input) {
                DeterministicState[] trace = [ start ];
                auto currentState = trace[0];
                foreach (immutable c; input) {
                        if (currentState.hasNext(c) == false) {
				writeln(currentState.toString() ~ " has next for " ~ 
to!string(c));
                                break;
                        } else {
				writeln(currentState.toString() ~ " has NO next for " ~ 
to!string(c));
                        }
                        currentState = currentState.getNext(c);
                        trace ~= currentState;
                }
                return trace;
        }

        this(DeterministicState start) {
                this.start = start;
        }

private:
        DeterministicState start;
}

void main()
{
        auto s0 = DeterministicState("s0", false);
        auto s1 = DeterministicState("s1", false);
        auto s2 = DeterministicState("s2", true);
        s0.addTransits(['0' : s1, '1' : s2]);
        s1.addTransits(['0' : s0, '1' : s2]);
        s2.addTransits(['0' : s2, '1' : s2]);
        auto dfa = DeterministicFiniteAutomaton(s0);
        auto trace = dfa.input("0001".dup);
        foreach (t; trace) {
                writeln(t.toString());
        }
        writeln("Trace Length = " ~ to!string(trace.length));
}

---

The output is the following:

s0 has NO next for 0
s1 has next for 0
s0
s1
Trace Length = 2

Which states that the trace for input "0001" has just a length of 
2 instead of 4. And I do not really understand why s1 has no next 
item while it was defined in main.

I hope someone can clear things up for me. I really don't get why 
this isn't working as intended.

Regards,
Rob