Creating an answer of http://nabetani.sakura.ne.jp/hena/ord3ynode/ in Haskell

create.pl

use strict;
use warnings;

my %dfa = (
    BA => {
        r => 'AC',
        l => 'AD',
        b => 'AB',
    },
    AB => {
        r => 'BE',
        l => 'BC',
        b => 'BA',
    },
    AC => {
        r => 'CB',
        l => 'CF',
        b => 'CA',
    },
    CA => {
        r => 'AD',
        l => 'AB',
        b => 'AC',
    },
    BC => {
        r => 'CF',
        l => 'CA',
        b => 'CB',
    },
    CB => {
        r => 'BA',
        l => 'BE',
        b => 'BC',
    },
    BE => {
        r => 'ED',
        l => 'EF',
        b => 'EB',
    },
    EB => {
        r => 'BC',
        l => 'BA',
        b => 'BE',
    },
    CF => {
        r => 'FE',
        l => 'FD',
        b => 'FC',
    },
    FC => {
        r => 'CA',
        l => 'CB',
        b => 'CF',
    },
    AD => {
        r => 'DF',
        l => 'DE',
        b => 'DA',
    },
    DA => {
        r => 'AB',
        l => 'AC',
        b => 'AD',
    },
    DF => {
        r => 'FC',
        l => 'FE',
        b => 'FD',
    },
    FD => {
        r => 'DE',
        l => 'DA',
        b => 'DF',
    },
    DE => {
        r => 'EF',
        l => 'EB',
        b => 'ED',
    },
    ED => {
        r => 'DA',
        l => 'DF',
        b => 'DE',
    },
    EF => {
        r => 'FD',
        l => 'FC',
        b => 'FE',
    },
    FE => {
        r => 'EB',
        l => 'ED',
        b => 'EF',
    },
);

for my $st (keys %dfa) {
    my ($s, $t) = split //, $st, 2;
    for my $d (keys %{$dfa{$st}}) {
        my $n = (split //, $dfa{$st}{$d})[1];
        my $dire = {r => 'Right', l => 'Left ', b => 'Back '}->{$d};
        print "nextNode $s $t $dire = $n\n";
    }
}

ynode.hs

data Node = A | B | C | D | E | F deriving Show
data Direction = Right | Left | Back deriving Show

nextNode :: Node -> Node -> Direction -> Node
nextNode A C Main.Left  = F
nextNode A C Main.Right = B
nextNode A C Main.Back  = A
nextNode E B Main.Left  = A
nextNode E B Main.Right = C
nextNode E B Main.Back  = E
nextNode F C Main.Left  = B
nextNode F C Main.Right = A
nextNode F C Main.Back  = F
nextNode B C Main.Left  = A
nextNode B C Main.Right = F
nextNode B C Main.Back  = B
nextNode B E Main.Left  = F
nextNode B E Main.Right = D
nextNode B E Main.Back  = B
nextNode C B Main.Left  = E
nextNode C B Main.Right = A
nextNode C B Main.Back  = C
nextNode E D Main.Left  = F
nextNode E D Main.Right = A
nextNode E D Main.Back  = E
nextNode E F Main.Left  = C
nextNode E F Main.Right = D
nextNode E F Main.Back  = E
nextNode F E Main.Left  = D
nextNode F E Main.Right = B
nextNode F E Main.Back  = F
nextNode C A Main.Left  = B
nextNode C A Main.Right = D
nextNode C A Main.Back  = C
nextNode A D Main.Left  = E
nextNode A D Main.Right = F
nextNode A D Main.Back  = A
nextNode D F Main.Left  = E
nextNode D F Main.Right = C
nextNode D F Main.Back  = D
nextNode D E Main.Left  = B
nextNode D E Main.Right = F
nextNode D E Main.Back  = D
nextNode C F Main.Left  = D
nextNode C F Main.Right = E
nextNode C F Main.Back  = C
nextNode F D Main.Left  = A
nextNode F D Main.Right = E
nextNode F D Main.Back  = F
nextNode B A Main.Left  = D
nextNode B A Main.Right = C
nextNode B A Main.Back  = B
nextNode A B Main.Left  = C
nextNode A B Main.Right = E
nextNode A B Main.Back  = A
nextNode D A Main.Left  = C
nextNode D A Main.Right = B
nextNode D A Main.Back  = D

solve :: Node -> Node -> [Direction] -> [Node]
solve _ t [] = [t]
solve s t (d:ds) = let n = nextNode s t d
                   in t : solve t n ds

{-
*Main> solve B A [Main.Left, Main.Left, Main.Right, Main.Right, Main.Right]
[A,D,E,F,D,E]
-}