> {-# OPTIONS_HADDOCK show-extensions #-}
> {-|
> Module : LTK.Porters
> Copyright : (c) 2018-2020,2022-2023 Dakotah Lambert
> License   : MIT
> 
> This module provides methods to convert automata to and from
> various formats.
> -}

> module LTK.Porters
>        ( -- *Conversions
>          -- |In the following definitions,
>          -- @(Type t)@ is shorthand for @(String -> t)@.
>          from
>        , fromE
>        , to
>        -- *Formats
>        -- |We use types to create a bit of magic
>        -- in order to read and write automata in
>        -- various formats.
>        , Type
>        , Dot(Dot)
>        , EggBox(EggBox)
>        , SyntacticOrder(SyntacticOrder)
>        , Jeff(Jeff)
>        , Pleb(Pleb)
>        , ATT(ATT)
>        , ATTO(ATTO)
>        , Corpus(Corpus)
>        -- *Miscellaneous
>        , formatSet
>        , transliterate
>        , transliterateString
>        , untransliterate
>        , untransliterateString
>        , Importable(..)
>        , Exportable(..)
>        ) where

> import LTK.FSA          (FSA, renameStates, renameSymbolsBy
>                         , syntacticMonoid
>                         )
> import LTK.Porters.ATT  ( exportATT
>                         , invertATT
>                         , readATT
>                         )
> import LTK.Porters.Corpus (readCorpus)
> import LTK.Porters.Dot  (exportDot, formatSet)
> import LTK.Porters.EggBox (exportEggBox)
> import LTK.Porters.SyntacticOrder (exportSyntacticOrder)
> import LTK.Porters.Jeff ( exportJeff
>                         , readJeff
>                         , transliterate
>                         , transliterateString
>                         , untransliterate
>                         , untransliterateString
>                         )
> import LTK.Porters.Pleb (readPleb)

> -- |A type that can be written from an 'FSA'.
> class Exportable t
>     where fromFSA  ::  (Ord n, Ord e, Show n, Show e) =>
>                        (t -> t) -> FSA n e -> String

> -- |A type that can be read and turned into an 'FSA'.
> class Importable t
>     where toFSA :: (t -> t) -> String -> Either String (FSA Integer String)

> -- |Create an 'FSA' from a @String@ treated as the given 'Type'.
> from :: (Importable i) => Type i -> String -> FSA Integer String
> from :: forall i. Importable i => Type i -> String -> FSA Integer String
from Type i
ty = forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either forall a. HasCallStack => String -> a
error forall a. a -> a
id forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall i.
Importable i =>
Type i -> String -> Either String (FSA Integer String)
fromE Type i
ty

> -- |Try to create an 'FSA' from a @String@ treated as the given 'Type'.
> fromE :: (Importable i) =>
>          Type i -> String -> Either String (FSA Integer String)
> fromE :: forall i.
Importable i =>
Type i -> String -> Either String (FSA Integer String)
fromE = forall i.
Importable i =>
Type i -> String -> Either String (FSA Integer String)
toFSA

> -- |Create a @String@ from an 'FSA', formatted appropriately for
> -- the given 'Type'.
> to :: (Ord n, Ord e, Show n, Show e, Exportable x) =>
>       Type x -> FSA n e -> String
> to :: forall n e x.
(Ord n, Ord e, Show n, Show e, Exportable x) =>
Type x -> FSA n e -> String
to = forall t n e.
(Exportable t, Ord n, Ord e, Show n, Show e) =>
(t -> t) -> FSA n e -> String
fromFSA

> -- |An importable or exportable format.
> type Type t = t -> t

=== Instances for Jeff's format

> -- |Jeff's format.
> newtype Jeff = Jeff Jeff

> instance Exportable Jeff
>     where fromFSA :: forall n e.
(Ord n, Ord e, Show n, Show e) =>
(Jeff -> Jeff) -> FSA n e -> String
fromFSA Jeff -> Jeff
_ = forall e n. (Ord e, Ord n, Show e) => FSA n e -> String
exportJeff

> instance Importable Jeff
>     where toFSA :: (Jeff -> Jeff) -> String -> Either String (FSA Integer String)
toFSA Jeff -> Jeff
_ = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall e n n1.
(Ord e, Ord n, Ord n1, Enum n1) =>
FSA n e -> FSA n1 e
renameStates forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Either String (FSA Int String)
readJeff

=== instances for Dot format

> -- |The GraphViz Dot format.
> newtype Dot = Dot Dot

> instance Exportable Dot
>     where fromFSA :: forall n e.
(Ord n, Ord e, Show n, Show e) =>
(Dot -> Dot) -> FSA n e -> String
fromFSA Dot -> Dot
_ = forall e n. (Ord e, Ord n, Show e, Show n) => FSA n e -> String
exportDot

=== instances for EggBox (in Dot format)

> -- |The egg-box in GraphViz Dot format.
> newtype EggBox = EggBox EggBox -- ^@since 1.1

> instance Exportable EggBox
>     where fromFSA :: forall n e.
(Ord n, Ord e, Show n, Show e) =>
(EggBox -> EggBox) -> FSA n e -> String
fromFSA EggBox -> EggBox
_ = forall n e. (Ord n, Ord e, Show e) => SynMon n e -> String
exportEggBox forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall e n.
(Ord e, Ord n) =>
FSA n e -> FSA ([Maybe n], [Symbol e]) e
syntacticMonoid

=== instances for SyntacticOrder (in Dot format)

> -- |A Hasse diagram of the syntactic order.
> --
> -- @since 1.1
> newtype SyntacticOrder = SyntacticOrder SyntacticOrder
> instance Exportable SyntacticOrder
>     where fromFSA :: forall n e.
(Ord n, Ord e, Show n, Show e) =>
(SyntacticOrder -> SyntacticOrder) -> FSA n e -> String
fromFSA SyntacticOrder -> SyntacticOrder
_ = forall n e. (Ord n, Ord e, Show e) => SynMon n e -> String
exportSyntacticOrder forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall e n.
(Ord e, Ord n) =>
FSA n e -> FSA ([Maybe n], [Symbol e]) e
syntacticMonoid

=== instances for Pleb format

> -- |The format defined by the (P)iecewise / (L)ocal (E)xpression (B)uilder.
> newtype Pleb = Pleb Pleb

> instance Importable Pleb
>     where toFSA :: (Pleb -> Pleb) -> String -> Either String (FSA Integer String)
toFSA Pleb -> Pleb
_ = String -> Either String (FSA Integer String)
readPleb

=== instances for ATT format

> -- |The AT&T finite-state transducer format, input projection
> --
> -- @since 0.3
> newtype ATT = ATT ATT

> instance Importable ATT
>     where toFSA :: (ATT -> ATT) -> String -> Either String (FSA Integer String)
toFSA ATT -> ATT
_ = forall a b. b -> Either a b
Right forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> FSA Integer String
readATT

> instance Exportable ATT
>     where fromFSA :: forall n e.
(Ord n, Ord e, Show n, Show e) =>
(ATT -> ATT) -> FSA n e -> String
fromFSA ATT -> ATT
_ = forall n e. (Ord n, Ord e, Show e) => FSA n e -> String
exportATT

> -- |The AT&T finite-state transducer format, output projection
> --
> -- @since 0.3
> newtype ATTO = ATTO ATTO

> instance Importable ATTO
>     where toFSA :: (ATTO -> ATTO) -> String -> Either String (FSA Integer String)
toFSA ATTO -> ATTO
_ = forall a b. b -> Either a b
Right forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> FSA Integer String
readATT forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> String
invertATT

> instance Exportable ATTO
>     where fromFSA :: forall n e.
(Ord n, Ord e, Show n, Show e) =>
(ATTO -> ATTO) -> FSA n e -> String
fromFSA ATTO -> ATTO
_ = String -> String
invertATT forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall n e. (Ord n, Ord e, Show e) => FSA n e -> String
exportATT

> -- |A corpus of strings
> --
> -- @since 0.3
> newtype Corpus = Corpus Corpus

> instance Importable Corpus
>     where toFSA :: (Corpus -> Corpus) -> String -> Either String (FSA Integer String)
toFSA Corpus -> Corpus
_ = forall a b. b -> Either a b
Right forall b c a. (b -> c) -> (a -> b) -> a -> c
.
>                     forall e n n1.
(Ord e, Ord n, Ord n1, Enum n1) =>
FSA n e -> FSA n1 e
renameStates forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall e e1 n.
(Ord e, Ord e1, Ord n) =>
(e -> e1) -> FSA n e -> FSA n e1
renameSymbolsBy (forall a. a -> [a] -> [a]
:[]) forall b c a. (b -> c) -> (a -> b) -> a -> c
.
>                     forall a. Ord a => [[a]] -> FSA [a] a
readCorpus forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> [String]
lines