Stuff...

1 files changed, 26 insertions, 1 deletions

diff --git a/edit-lens/src/Control/DFST.lhs b/edit-lens/src/Control/DFST.lhs
index 6e16c74..271a13e 100644
--- a/edit-lens/src/Control/DFST.lhs
+++ b/edit-lens/src/Control/DFST.lhs
@@ -10,9 +10,10 @@ module Control.DFST
   ( DFST(..)
   , runDFST, runDFST'
   , toFST
+  , dotDFST
   ) where
 
-import Data.Map.Lazy (Map, (!?))
+import Data.Map.Lazy (Map, (!?), (!))
 import qualified Data.Map.Lazy as Map
 
 import Data.Set (Set)
@@ -21,6 +22,8 @@ import qualified Data.Set as Set
 import Data.Sequence (Seq(..))
 import qualified Data.Sequence as Seq
 
+import Data.Bool (bool)
+
 import Data.Monoid
 
 import Numeric.Natural
@@ -30,6 +33,8 @@ import Control.Monad.State
 
 import Control.FST (FST(FST))
 import qualified Control.FST as FST
+
+import Text.Dot
 \end{code}
 \end{comment}
 
@@ -39,6 +44,10 @@ import qualified Control.FST as FST
   Zusätzlich ändern wir die Darstellung indem wir $\epsilon$-Transitionen kontrahieren.
   Wir erweitern hierfür die Ausgabe pro Transition von einem einzelnen Zeichen zu einem Wort beliebiger Länge und fügen, bei jeder Kontraktion einer $\epsilon$-Transition $A \rightarrow B$, die Ausgabe der Transition vorne an die Ausgabe aller Transitionen $B \rightarrow \ast$ von $B$ an.
 \end{defn}
+
+\begin{rem}
+  Die FSTs aus den bisherigen Beispielen \ref{eg:linebreak}, \ref{eg:w100}, \ref{eg:l80timesw100} sind deterministisch.
+\end{rem}
   
 \begin{code}
 data DFST state input output = DFST
@@ -105,5 +114,21 @@ runDFST' _             st  Empty     acc = (acc, Just st)
 runDFST' dfst@DFST{..} st (c :<| cs) acc = case stTransition !? (st, c) of
   Just (st', mc') -> runDFST' dfst st' cs $ acc <> mc'
   Nothing -> (acc, Nothing)
+  
+dotDFST :: forall state input output. (Ord state, Ord input, Ord output, Show state, Show input, Show output) => DFST state input output -> Dot ()
+dotDFST DFST{..} = do
+  let
+    stTransition' = Map.toList stTransition
+    states = Set.singleton stInitial <> stAccept <> foldMap (Set.singleton . fst . fst) stTransition' <> foldMap (Set.singleton . fst . snd) stTransition'
+  stateIds <- sequence . (flip Map.fromSet) states $ \st -> node
+    [ ("label", show st)
+    , ("peripheries", bool "1" "2" $ st `Set.member` stAccept)
+    ]
+  init <- node [ ("label", ""), ("shape", "none") ]
+  init .->. (stateIds ! stInitial)
+  forM_ stTransition' $ \((f, inS), (t, outS)) -> do
+    edge (stateIds ! f) (stateIds ! t)
+      [ ("label", show (inS, outS))
+      ]
 \end{code}
 \end{comment}