Correct the function does not continue after reaching the final state the first time, which means the code does not work with _real_ DFA’s. I could have called my type/post something else but I don’t think it would have helped with the clarity for people like myself which have only the basics of CS from college (and what’s there is in fact shoddy at best).

The next step for me is going to be actually building the Psuedo DFA from a string match input, but I am interested in learning more and I will take your advice an look into implementing intersection and union. Again, thanks for taking the time to read and pass along some more information/advice.

Taking a closer look at your code; your second notion of “match” is wrong, as it stops processing the string once you find a final state.

This issue aside, if you are really interested in studying the tradeoffs between various representations, you should try implementing some of the standard automata constructions: for example, can you define intersection :: DFA -> DFA -> DFA and union :: DFA -> DFA -> DFA? How does the definitions for your representation(s) compare to the definitions for mine?

my solution falls horribly short in use for different alphabets, which I realized as I was building it but didn’t mention in the post. Many thanks for the comment.

data DFA st ab = DFA st (st -> ab -> st) (st -> Bool)

machine :: DFA Int Char
machine = DFA 1 delta (== 4)
   where
     delta 1 'a' = 2
     delta 1 'b' = 1
     delta 2 'a' = 3
     delta 2 'b' = 1
     delta 3 'a' = 3
     delta 3 'b' = 4
     delta _ _   = 5   -- a dead state

match :: DFA st ab -> [ab] -> Bool
match (DFA st delta isFinal) abs = isFinal (foldl delta st abs)

Although to be more useful, you really need to have an enumeration of the alphabet. (An enumeration of the states isn’t so important.)