{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE TemplateHaskell #-}
{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE TupleSections #-}
module Language.Change.Quote (ch, chs) where
import Data.Data (Data)
import Data.Void (Void)
import Data.List.NonEmpty (NonEmpty(..), toList, cons)
import Data.Char (isAlphaNum, isAsciiUpper, isSpace)
import Data.Bifunctor (first)
import Control.Monad (void)
import qualified Data.Map as Map
import qualified Data.Set as Set
import Data.Set (Set)
import qualified Text.Megaparsec as M
import Text.Megaparsec ((<|>))
import qualified Text.Megaparsec.Char as MC
import qualified Text.Megaparsec.Char.Lexer as Lexer
import qualified Control.Monad.Combinators.NonEmpty as NE
import Control.Monad.Reader (ReaderT(..), local)
import qualified Language.Haskell.TH as TH
import Language.Haskell.TH.Quote(QuasiQuoter(..), dataToExpQ)
import Language.Haskell.TH.Lib (appE, conE, varE)
import Data.Generics.Aliases (extQ)
import Language.Change (Change(..), Env(..), PSet(..), Pattern(..), applyChanges)
data CharS
= Lit Char
| AntiQ String
| CList [Char]
deriving (Typeable CharS
CharS -> DataType
CharS -> Constr
(forall b. Data b => b -> b) -> CharS -> CharS
forall a.
Typeable a
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> CharS -> u
forall u. (forall d. Data d => d -> u) -> CharS -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CharS -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CharS -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CharS -> m CharS
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CharS -> m CharS
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CharS
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CharS -> c CharS
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CharS)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CharS)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CharS -> m CharS
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CharS -> m CharS
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CharS -> m CharS
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CharS -> m CharS
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CharS -> m CharS
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CharS -> m CharS
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CharS -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CharS -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> CharS -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> CharS -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CharS -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CharS -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CharS -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CharS -> r
gmapT :: (forall b. Data b => b -> b) -> CharS -> CharS
$cgmapT :: (forall b. Data b => b -> b) -> CharS -> CharS
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CharS)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CharS)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CharS)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CharS)
dataTypeOf :: CharS -> DataType
$cdataTypeOf :: CharS -> DataType
toConstr :: CharS -> Constr
$ctoConstr :: CharS -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CharS
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CharS
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CharS -> c CharS
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CharS -> c CharS
Data)
newtype SetS = SetS (NonEmpty CharS)
deriving (Typeable SetS
SetS -> DataType
SetS -> Constr
(forall b. Data b => b -> b) -> SetS -> SetS
forall a.
Typeable a
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> SetS -> u
forall u. (forall d. Data d => d -> u) -> SetS -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SetS -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SetS -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SetS -> m SetS
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SetS -> m SetS
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SetS
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SetS -> c SetS
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SetS)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SetS)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SetS -> m SetS
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SetS -> m SetS
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SetS -> m SetS
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SetS -> m SetS
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SetS -> m SetS
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SetS -> m SetS
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SetS -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SetS -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> SetS -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SetS -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SetS -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SetS -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SetS -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SetS -> r
gmapT :: (forall b. Data b => b -> b) -> SetS -> SetS
$cgmapT :: (forall b. Data b => b -> b) -> SetS -> SetS
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SetS)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SetS)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SetS)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SetS)
dataTypeOf :: SetS -> DataType
$cdataTypeOf :: SetS -> DataType
toConstr :: SetS -> Constr
$ctoConstr :: SetS -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SetS
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SetS
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SetS -> c SetS
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SetS -> c SetS
Data)
data PSetS = PSetS SetS Bool
deriving (Typeable PSetS
PSetS -> DataType
PSetS -> Constr
(forall b. Data b => b -> b) -> PSetS -> PSetS
forall a.
Typeable a
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> PSetS -> u
forall u. (forall d. Data d => d -> u) -> PSetS -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PSetS -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PSetS -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PSetS -> m PSetS
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PSetS -> m PSetS
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PSetS
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PSetS -> c PSetS
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PSetS)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PSetS)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PSetS -> m PSetS
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PSetS -> m PSetS
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PSetS -> m PSetS
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PSetS -> m PSetS
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PSetS -> m PSetS
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PSetS -> m PSetS
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> PSetS -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> PSetS -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> PSetS -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> PSetS -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PSetS -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PSetS -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PSetS -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PSetS -> r
gmapT :: (forall b. Data b => b -> b) -> PSetS -> PSetS
$cgmapT :: (forall b. Data b => b -> b) -> PSetS -> PSetS
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PSetS)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PSetS)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PSetS)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PSetS)
dataTypeOf :: PSetS -> DataType
$cdataTypeOf :: PSetS -> DataType
toConstr :: PSetS -> Constr
$ctoConstr :: PSetS -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PSetS
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PSetS
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PSetS -> c PSetS
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PSetS -> c PSetS
Data)
data PatternS
= OneS PSetS
| OptionalS PSetS
| ManyS PSetS
deriving (Typeable PatternS
PatternS -> DataType
PatternS -> Constr
(forall b. Data b => b -> b) -> PatternS -> PatternS
forall a.
Typeable a
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> PatternS -> u
forall u. (forall d. Data d => d -> u) -> PatternS -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PatternS -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PatternS -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PatternS -> m PatternS
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PatternS -> m PatternS
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PatternS
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PatternS -> c PatternS
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PatternS)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PatternS)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PatternS -> m PatternS
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PatternS -> m PatternS
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PatternS -> m PatternS
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PatternS -> m PatternS
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PatternS -> m PatternS
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PatternS -> m PatternS
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> PatternS -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> PatternS -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> PatternS -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> PatternS -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PatternS -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PatternS -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PatternS -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PatternS -> r
gmapT :: (forall b. Data b => b -> b) -> PatternS -> PatternS
$cgmapT :: (forall b. Data b => b -> b) -> PatternS -> PatternS
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PatternS)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PatternS)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PatternS)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PatternS)
dataTypeOf :: PatternS -> DataType
$cdataTypeOf :: PatternS -> DataType
toConstr :: PatternS -> Constr
$ctoConstr :: PatternS -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PatternS
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PatternS
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PatternS -> c PatternS
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PatternS -> c PatternS
Data)
data EnvS = EnvS [PatternS] [PatternS]
deriving (Typeable EnvS
EnvS -> DataType
EnvS -> Constr
(forall b. Data b => b -> b) -> EnvS -> EnvS
forall a.
Typeable a
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> EnvS -> u
forall u. (forall d. Data d => d -> u) -> EnvS -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> EnvS -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> EnvS -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> EnvS -> m EnvS
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> EnvS -> m EnvS
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c EnvS
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EnvS -> c EnvS
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c EnvS)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c EnvS)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> EnvS -> m EnvS
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> EnvS -> m EnvS
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> EnvS -> m EnvS
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> EnvS -> m EnvS
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> EnvS -> m EnvS
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> EnvS -> m EnvS
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> EnvS -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> EnvS -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> EnvS -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> EnvS -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> EnvS -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> EnvS -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> EnvS -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> EnvS -> r
gmapT :: (forall b. Data b => b -> b) -> EnvS -> EnvS
$cgmapT :: (forall b. Data b => b -> b) -> EnvS -> EnvS
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c EnvS)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c EnvS)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c EnvS)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c EnvS)
dataTypeOf :: EnvS -> DataType
$cdataTypeOf :: EnvS -> DataType
toConstr :: EnvS -> Constr
$ctoConstr :: EnvS -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c EnvS
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c EnvS
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EnvS -> c EnvS
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EnvS -> c EnvS
Data)
type Pairing a b = NonEmpty (a, b)
type SoundList = NonEmpty CharS
type EnvList = NonEmpty EnvS
newtype Rep = Rep { Rep -> [Char]
convertRep :: String }
deriving (Typeable Rep
Rep -> DataType
Rep -> Constr
(forall b. Data b => b -> b) -> Rep -> Rep
forall a.
Typeable a
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Rep -> u
forall u. (forall d. Data d => d -> u) -> Rep -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Rep -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Rep -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Rep -> m Rep
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Rep -> m Rep
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Rep
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Rep -> c Rep
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Rep)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Rep)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Rep -> m Rep
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Rep -> m Rep
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Rep -> m Rep
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Rep -> m Rep
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Rep -> m Rep
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Rep -> m Rep
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Rep -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Rep -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Rep -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Rep -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Rep -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Rep -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Rep -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Rep -> r
gmapT :: (forall b. Data b => b -> b) -> Rep -> Rep
$cgmapT :: (forall b. Data b => b -> b) -> Rep -> Rep
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Rep)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Rep)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Rep)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Rep)
dataTypeOf :: Rep -> DataType
$cdataTypeOf :: Rep -> DataType
toConstr :: Rep -> Constr
$ctoConstr :: Rep -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Rep
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Rep
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Rep -> c Rep
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Rep -> c Rep
Data)
data StatementS
= Simple SoundList Rep EnvList
| SoundSplit SoundList (Pairing Rep EnvList)
| EnvSplit (Pairing SoundList Rep) EnvList
deriving (Typeable StatementS
StatementS -> DataType
StatementS -> Constr
(forall b. Data b => b -> b) -> StatementS -> StatementS
forall a.
Typeable a
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> StatementS -> u
forall u. (forall d. Data d => d -> u) -> StatementS -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> StatementS -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> StatementS -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> StatementS -> m StatementS
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> StatementS -> m StatementS
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c StatementS
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> StatementS -> c StatementS
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c StatementS)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c StatementS)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> StatementS -> m StatementS
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> StatementS -> m StatementS
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> StatementS -> m StatementS
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> StatementS -> m StatementS
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> StatementS -> m StatementS
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> StatementS -> m StatementS
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> StatementS -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> StatementS -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> StatementS -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> StatementS -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> StatementS -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> StatementS -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> StatementS -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> StatementS -> r
gmapT :: (forall b. Data b => b -> b) -> StatementS -> StatementS
$cgmapT :: (forall b. Data b => b -> b) -> StatementS -> StatementS
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c StatementS)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c StatementS)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c StatementS)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c StatementS)
dataTypeOf :: StatementS -> DataType
$cdataTypeOf :: StatementS -> DataType
toConstr :: StatementS -> Constr
$ctoConstr :: StatementS -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c StatementS
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c StatementS
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> StatementS -> c StatementS
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> StatementS -> c StatementS
Data)
newtype ChangeS = ChangeS (NonEmpty StatementS)
deriving (Typeable ChangeS
ChangeS -> DataType
ChangeS -> Constr
(forall b. Data b => b -> b) -> ChangeS -> ChangeS
forall a.
Typeable a
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> ChangeS -> u
forall u. (forall d. Data d => d -> u) -> ChangeS -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ChangeS -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ChangeS -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ChangeS -> m ChangeS
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ChangeS -> m ChangeS
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ChangeS
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ChangeS -> c ChangeS
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ChangeS)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ChangeS)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ChangeS -> m ChangeS
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ChangeS -> m ChangeS
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ChangeS -> m ChangeS
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ChangeS -> m ChangeS
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ChangeS -> m ChangeS
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ChangeS -> m ChangeS
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ChangeS -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ChangeS -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> ChangeS -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ChangeS -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ChangeS -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ChangeS -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ChangeS -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ChangeS -> r
gmapT :: (forall b. Data b => b -> b) -> ChangeS -> ChangeS
$cgmapT :: (forall b. Data b => b -> b) -> ChangeS -> ChangeS
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ChangeS)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ChangeS)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ChangeS)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ChangeS)
dataTypeOf :: ChangeS -> DataType
$cdataTypeOf :: ChangeS -> DataType
toConstr :: ChangeS -> Constr
$ctoConstr :: ChangeS -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ChangeS
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ChangeS
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ChangeS -> c ChangeS
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ChangeS -> c ChangeS
Data)
type Parser = ReaderT Bool (M.Parsec Void String)
allowNewlines :: Parser a -> Parser a
allowNewlines :: forall a. Parser a -> Parser a
allowNewlines = forall r (m :: * -> *) a. MonadReader r m => (r -> r) -> m a -> m a
local (forall a b. a -> b -> a
const Bool
True)
isSound, isIdentifier :: Char -> Bool
isSound :: Char -> Bool
isSound Char
c = Bool -> Bool
not (Char -> Bool
isSpace Char
c Bool -> Bool -> Bool
|| Char -> Bool
isAsciiUpper Char
c Bool -> Bool -> Bool
|| Char
c forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Char]
",>/;{}[]%_!?*")
isIdentifier :: Char -> Bool
isIdentifier Char
c = Char -> Bool
isAlphaNum Char
c Bool -> Bool -> Bool
|| Char
c forall a. Eq a => a -> a -> Bool
== Char
'_' Bool -> Bool -> Bool
|| Char
c forall a. Eq a => a -> a -> Bool
== Char
'\''
spaces :: Parser ()
spaces :: Parser ()
spaces = forall r (m :: * -> *) a. (r -> m a) -> ReaderT r m a
ReaderT forall a b. (a -> b) -> a -> b
$ \Bool
allowNs ->
forall e s (m :: * -> *).
MonadParsec e s m =>
m () -> m () -> m () -> m ()
Lexer.space (if Bool
allowNs then forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
MC.space1 else forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
MC.hspace1) Parsec Void [Char] ()
lineComment forall (f :: * -> *) a. Alternative f => f a
M.empty
where lineComment :: Parsec Void [Char] ()
lineComment = forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Tokens s -> m ()
Lexer.skipLineComment [Char]
"//"
symbol :: Char -> Parser ()
symbol :: Char -> Parser ()
symbol Char
c = forall e s (m :: * -> *).
MonadParsec e s m =>
Token s -> m (Token s)
M.single Char
c forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser ()
spaces
charS :: Parser CharS
charS :: Parser CharS
charS = forall (f :: * -> *) (m :: * -> *) a.
(Foldable f, Alternative m) =>
f (m a) -> m a
M.choice [ Parser CharS
lit, Parser CharS
oneChar, Parser CharS
multipleChar ]
where
lit :: Parser CharS
lit = Char -> CharS
Lit forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall e s (m :: * -> *).
MonadParsec e s m =>
(Token s -> Bool) -> m (Token s)
M.satisfy Char -> Bool
isSound forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Parser ()
spaces
oneChar :: Parser CharS
oneChar = [Char] -> CharS
AntiQ forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a. Applicative f => a -> f a
pure forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall e s (m :: * -> *).
MonadParsec e s m =>
(Token s -> Bool) -> m (Token s)
M.satisfy Char -> Bool
isAsciiUpper forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Parser ()
spaces
multipleChar :: Parser CharS
multipleChar = [Char] -> CharS
AntiQ
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Char -> Parser ()
symbol Char
'['
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall e s (m :: * -> *).
MonadParsec e s m =>
Maybe [Char] -> (Token s -> Bool) -> m (Tokens s)
M.takeWhile1P (forall a. a -> Maybe a
Just [Char]
"Haskell identifier") Char -> Bool
isIdentifier
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Parser ()
spaces
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Char -> Parser ()
symbol Char
']'
setS :: Parser SetS
setS :: Parser SetS
setS = forall (f :: * -> *) (m :: * -> *) a.
(Foldable f, Alternative m) =>
f (m a) -> m a
M.choice
[ NonEmpty CharS -> SetS
SetS forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a. Applicative f => a -> f a
pure forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser CharS
charS
, NonEmpty CharS -> SetS
SetS forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Char -> Parser ()
symbol Char
'{' forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (m :: * -> *) a. MonadPlus m => m a -> m (NonEmpty a)
NE.some Parser CharS
charS forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Char -> Parser ()
symbol Char
'}'
]
pSetS :: Parser PSetS
pSetS :: Parser PSetS
pSetS = SetS -> Bool -> PSetS
PSetS
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser SetS
setS
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) (m :: * -> *) a.
(Foldable f, Alternative m) =>
f (m a) -> m a
M.choice [ Bool
False forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Char -> Parser ()
symbol Char
'!', forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True ]
patternS :: Parser PatternS
patternS :: Parser PatternS
patternS = do
PSetS
pset <- Parser PSetS
pSetS
forall (f :: * -> *) (m :: * -> *) a.
(Foldable f, Alternative m) =>
f (m a) -> m a
M.choice
[ PSetS -> PatternS
OptionalS PSetS
pset forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Char -> Parser ()
symbol Char
'?'
, PSetS -> PatternS
ManyS PSetS
pset forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Char -> Parser ()
symbol Char
'*'
, forall (m :: * -> *) a. Monad m => a -> m a
return (PSetS -> PatternS
OneS PSetS
pset)
]
envS :: Parser EnvS
envS :: Parser EnvS
envS = [PatternS] -> [PatternS] -> EnvS
EnvS
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall a. [a] -> [a]
reverse forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
M.many Parser PatternS
patternS)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Char -> Parser ()
symbol Char
'_'
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
M.many Parser PatternS
patternS
pairing :: Parser a -> Parser () -> Parser b -> Parser (Pairing a b)
pairing :: forall a b.
Parser a -> Parser () -> Parser b -> Parser (Pairing a b)
pairing Parser a
pa Parser ()
psep Parser b
pb = do
forall a. Parser a -> Parser a
allowNewlines (Char -> Parser ()
symbol Char
'{')
Pairing a b
ps <- forall a. Parser a -> Parser a
allowNewlines (forall (m :: * -> *) a sep.
MonadPlus m =>
m a -> m sep -> m (NonEmpty a)
NE.sepBy1 ReaderT Bool (ParsecT Void [Char] Identity) (a, b)
pair (Char -> Parser ()
symbol Char
';'))
Char -> Parser ()
symbol Char
'}'
forall (m :: * -> *) a. Monad m => a -> m a
return Pairing a b
ps
where
pair :: ReaderT Bool (ParsecT Void [Char] Identity) (a, b)
pair = (,) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a
pa forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Parser ()
psep forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser b
pb
soundList :: Parser SoundList
soundList :: Parser (NonEmpty CharS)
soundList = forall (m :: * -> *) a sep.
MonadPlus m =>
m a -> m sep -> m (NonEmpty a)
NE.sepBy1 Parser CharS
charS (Char -> Parser ()
symbol Char
',')
envList :: Parser EnvList
envList :: Parser EnvList
envList = forall (m :: * -> *) a sep.
MonadPlus m =>
m a -> m sep -> m (NonEmpty a)
NE.sepBy1 Parser EnvS
envS (Char -> Parser ()
symbol Char
',')
rep :: Parser Rep
rep :: Parser Rep
rep = forall (f :: * -> *) (m :: * -> *) a.
(Foldable f, Alternative m) =>
f (m a) -> m a
M.choice
[ [Char] -> Rep
Rep forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall e s (m :: * -> *).
MonadParsec e s m =>
Maybe [Char] -> (Token s -> Bool) -> m (Tokens s)
M.takeWhile1P (forall a. a -> Maybe a
Just [Char]
"phoneme") Char -> Bool
isSound forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Parser ()
spaces
, [Char] -> Rep
Rep [Char]
"" forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Char -> Parser ()
symbol Char
'%'
]
statementS :: Parser StatementS
statementS :: Parser StatementS
statementS = Parser StatementS
envSplit forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser StatementS
other
where
envSplit :: Parser StatementS
envSplit = Pairing (NonEmpty CharS) Rep -> EnvList -> StatementS
EnvSplit
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a b.
Parser a -> Parser () -> Parser b -> Parser (Pairing a b)
pairing Parser (NonEmpty CharS)
soundList (Char -> Parser ()
symbol Char
'>') Parser Rep
rep
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Char -> Parser ()
symbol Char
'/'
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser EnvList
envList
other :: Parser StatementS
other = do
NonEmpty CharS
sounds <- Parser (NonEmpty CharS)
soundList
Char -> Parser ()
symbol Char
'>'
forall (f :: * -> *) (m :: * -> *) a.
(Foldable f, Alternative m) =>
f (m a) -> m a
M.choice
[ NonEmpty CharS -> Pairing Rep EnvList -> StatementS
SoundSplit NonEmpty CharS
sounds forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a b.
Parser a -> Parser () -> Parser b -> Parser (Pairing a b)
pairing Parser Rep
rep (Char -> Parser ()
symbol Char
'/') Parser EnvList
envList
, NonEmpty CharS -> Rep -> EnvList -> StatementS
Simple NonEmpty CharS
sounds forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Rep
rep forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Char -> Parser ()
symbol Char
'/' forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser EnvList
envList
]
someNewlines :: Parser ()
someNewlines :: Parser ()
someNewlines = forall (f :: * -> *) a. Functor f => f a -> f ()
void (forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
M.some (Char -> Parser ()
symbol Char
'\n' forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Char -> Parser ()
symbol Char
'\r'))
changeS :: Parser ChangeS
changeS :: Parser ChangeS
changeS = NonEmpty StatementS -> ChangeS
ChangeS forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) a sep.
MonadPlus m =>
m a -> m sep -> m (NonEmpty a)
NE.sepEndBy1 Parser StatementS
statementS Parser ()
someNewlines
bulletedChanges :: Parser (NonEmpty ChangeS)
bulletedChanges :: Parser (NonEmpty ChangeS)
bulletedChanges = do
Char -> Parser ()
symbol Char
'*'
StatementS
stmt <- Parser StatementS
statementS
Bool
newline <- forall (m :: * -> *) a. Alternative m => a -> m a -> m a
M.option Bool
False (Bool
True forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Parser ()
someNewlines)
if Bool
newline
then forall (f :: * -> *) (m :: * -> *) a.
(Foldable f, Alternative m) =>
f (m a) -> m a
M.choice
[ (NonEmpty StatementS -> ChangeS
ChangeS (StatementS
stmt forall a. a -> [a] -> NonEmpty a
:| []) forall a. a -> NonEmpty a -> NonEmpty a
`cons`) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (NonEmpty ChangeS)
bulletedChanges
, (\(NonEmpty StatementS
stmts, [ChangeS]
cs) -> NonEmpty StatementS -> ChangeS
ChangeS (StatementS
stmt forall a. a -> NonEmpty a -> NonEmpty a
`cons` NonEmpty StatementS
stmts) forall a. a -> [a] -> NonEmpty a
:| [ChangeS]
cs) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (NonEmpty StatementS, [ChangeS])
nonBulleted
, forall (m :: * -> *) a. Monad m => a -> m a
return (NonEmpty StatementS -> ChangeS
ChangeS (StatementS
stmt forall a. a -> [a] -> NonEmpty a
:| []) forall a. a -> [a] -> NonEmpty a
:| [])
]
else forall (m :: * -> *) a. Monad m => a -> m a
return (NonEmpty StatementS -> ChangeS
ChangeS (StatementS
stmt forall a. a -> [a] -> NonEmpty a
:| []) forall a. a -> [a] -> NonEmpty a
:| [])
where
nonBulleted :: Parser (NonEmpty StatementS, [ChangeS])
nonBulleted :: Parser (NonEmpty StatementS, [ChangeS])
nonBulleted = do
StatementS
stmt <- Parser StatementS
statementS
Bool
newline <- forall (m :: * -> *) a. Alternative m => a -> m a -> m a
M.option Bool
False (Bool
True forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Parser ()
someNewlines)
if Bool
newline
then forall (f :: * -> *) (m :: * -> *) a.
(Foldable f, Alternative m) =>
f (m a) -> m a
M.choice
[ (\NonEmpty ChangeS
cs -> (StatementS
stmt forall a. a -> [a] -> NonEmpty a
:| [], forall a. NonEmpty a -> [a]
toList NonEmpty ChangeS
cs)) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (NonEmpty ChangeS)
bulletedChanges
, forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first (StatementS
stmt forall a. a -> NonEmpty a -> NonEmpty a
`cons`) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (NonEmpty StatementS, [ChangeS])
nonBulleted
, forall (m :: * -> *) a. Monad m => a -> m a
return (StatementS
stmt forall a. a -> [a] -> NonEmpty a
:| [], [])
]
else forall (m :: * -> *) a. Monad m => a -> m a
return (StatementS
stmt forall a. a -> [a] -> NonEmpty a
:| [], [])
total :: Parser a -> Parser a
total :: forall a. Parser a -> Parser a
total Parser a
p = forall a. Parser a -> Parser a
allowNewlines Parser ()
spaces forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (Parser a
p forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall e s (m :: * -> *). MonadParsec e s m => m ()
M.eof)
ch :: QuasiQuoter
ch :: QuasiQuoter
ch = QuasiQuoter
{ quoteExp :: [Char] -> Q Exp
quoteExp = forall a. Data a => Parser a -> Q Exp -> [Char] -> Q Exp
makeQuoter (forall a. Parser a -> Parser a
total Parser ChangeS
changeS) (forall (m :: * -> *). Quote m => Name -> m Exp
varE 'convertChangeS)
, quotePat :: [Char] -> Q Pat
quotePat = forall a. HasCallStack => a
undefined
, quoteType :: [Char] -> Q Type
quoteType = forall a. HasCallStack => a
undefined
, quoteDec :: [Char] -> Q [Dec]
quoteDec = forall a. HasCallStack => a
undefined
}
chs :: QuasiQuoter
chs :: QuasiQuoter
chs = QuasiQuoter
{ quoteExp :: [Char] -> Q Exp
quoteExp = forall a. Data a => Parser a -> Q Exp -> [Char] -> Q Exp
makeQuoter (forall a. NonEmpty a -> [a]
toList forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. Parser a -> Parser a
total Parser (NonEmpty ChangeS)
bulletedChanges) (forall (m :: * -> *). Quote m => m Exp -> m Exp -> m Exp
appE (forall (m :: * -> *). Quote m => Name -> m Exp
varE 'map) (forall (m :: * -> *). Quote m => Name -> m Exp
varE 'convertChangeS))
, quotePat :: [Char] -> Q Pat
quotePat = forall a. HasCallStack => a
undefined
, quoteType :: [Char] -> Q Type
quoteType = forall a. HasCallStack => a
undefined
, quoteDec :: [Char] -> Q [Dec]
quoteDec = forall a. HasCallStack => a
undefined
}
initialState :: s -> M.SourcePos -> M.State s Void
initialState :: forall s. s -> SourcePos -> State s Void
initialState s
input SourcePos
position =
M.State
{ stateInput :: s
M.stateInput = s
input
, stateOffset :: Int
M.stateOffset = Int
0
, statePosState :: PosState s
M.statePosState =
M.PosState
{ pstateInput :: s
M.pstateInput = s
input
, pstateOffset :: Int
M.pstateOffset = Int
0
, pstateSourcePos :: SourcePos
M.pstateSourcePos = SourcePos
position
, pstateTabWidth :: Pos
M.pstateTabWidth = Pos
M.defaultTabWidth
, pstateLinePrefix :: [Char]
M.pstateLinePrefix = [Char]
""
}
, stateParseErrors :: [ParseError s Void]
M.stateParseErrors = []
}
makeQuoter :: (Data a) => Parser a -> TH.ExpQ -> String -> TH.ExpQ
makeQuoter :: forall a. Data a => Parser a -> Q Exp -> [Char] -> Q Exp
makeQuoter Parser a
parse Q Exp
convert [Char]
input = do
Loc
loc <- Q Loc
TH.location
let file :: [Char]
file = Loc -> [Char]
TH.loc_filename Loc
loc
(Int
line, Int
col) = Loc -> (Int, Int)
TH.loc_start Loc
loc
state :: State [Char] Void
state = forall s. s -> SourcePos -> State s Void
initialState [Char]
input ([Char] -> Pos -> Pos -> SourcePos
M.SourcePos [Char]
file (Int -> Pos
M.mkPos Int
line) (Int -> Pos
M.mkPos Int
col))
case forall a b. (a, b) -> b
snd (forall e s a.
Parsec e s a
-> State s e -> (State s e, Either (ParseErrorBundle s e) a)
M.runParser' (forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
runReaderT Parser a
parse Bool
False) State [Char] Void
state) of
Left ParseErrorBundle [Char] Void
errors -> forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail (forall s e.
(VisualStream s, TraversableStream s, ShowErrorComponent e) =>
ParseErrorBundle s e -> [Char]
M.errorBundlePretty ParseErrorBundle [Char] Void
errors)
Right a
change ->
let change' :: Q Exp
change' = forall (m :: * -> *) a.
(Quote m, Data a) =>
(forall b. Data b => b -> Maybe (m Exp)) -> a -> m Exp
dataToExpQ (forall a b. a -> b -> a
const forall a. Maybe a
Nothing forall a b r.
(Typeable a, Typeable b) =>
(a -> r) -> (b -> r) -> a -> r
`extQ` CharS -> Maybe (Q Exp)
antiquote) a
change
in forall (m :: * -> *). Quote m => m Exp -> m Exp -> m Exp
appE Q Exp
convert Q Exp
change'
antiquote :: CharS -> Maybe TH.ExpQ
antiquote :: CharS -> Maybe (Q Exp)
antiquote = \case
Lit Char
_ -> forall a. Maybe a
Nothing
AntiQ [Char]
s -> forall a. a -> Maybe a
Just (forall (m :: * -> *). Quote m => m Exp -> m Exp -> m Exp
appE (forall (m :: * -> *). Quote m => Name -> m Exp
conE 'CList) (forall (m :: * -> *). Quote m => Name -> m Exp
varE ([Char] -> Name
TH.mkName ([Char]
"set" forall a. [a] -> [a] -> [a]
++ [Char]
s))))
CList [Char]
_ -> forall a. Maybe a
Nothing
badAntiQ :: a
badAntiQ :: forall a. a
badAntiQ = forall a. HasCallStack => [Char] -> a
error [Char]
"Language.Change.Quote: Unexpected AntiQ at runtime.\nThis error should never happen."
convertCharList :: CharS -> [Char]
convertCharList :: CharS -> [Char]
convertCharList = \case
Lit Char
c -> [Char
c]
AntiQ [Char]
_ -> forall a. a
badAntiQ
CList [Char]
cs -> [Char]
cs
convertCharSet :: CharS -> Set Char
convertCharSet :: CharS -> Set Char
convertCharSet = \case
Lit Char
c -> forall a. a -> Set a
Set.singleton Char
c
AntiQ [Char]
_ -> forall a. a
badAntiQ
CList [Char]
cs -> forall a. Ord a => [a] -> Set a
Set.fromList [Char]
cs
convertSetS :: SetS -> Set Char
convertSetS :: SetS -> Set Char
convertSetS (SetS NonEmpty CharS
cs) = forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap CharS -> Set Char
convertCharSet NonEmpty CharS
cs
convertPSetS :: PSetS -> PSet Char
convertPSetS :: PSetS -> PSet Char
convertPSetS (PSetS SetS
set Bool
b) = forall a. Set a -> Bool -> PSet a
PSet (SetS -> Set Char
convertSetS SetS
set) Bool
b
convertPatternS :: PatternS -> Pattern Char
convertPatternS :: PatternS -> Pattern Char
convertPatternS = \case
OneS PSetS
set -> forall a. PSet a -> Pattern a
One (PSetS -> PSet Char
convertPSetS PSetS
set)
OptionalS PSetS
set -> forall a. PSet a -> Pattern a
Optional (PSetS -> PSet Char
convertPSetS PSetS
set)
ManyS PSetS
set -> forall a. PSet a -> Pattern a
Many (PSetS -> PSet Char
convertPSetS PSetS
set)
convertEnvS :: EnvS -> Env Char
convertEnvS :: EnvS -> Env Char
convertEnvS (EnvS [PatternS]
e1 [PatternS]
e2) = forall a. [Pattern a] -> [Pattern a] -> Env a
Env (forall a b. (a -> b) -> [a] -> [b]
map PatternS -> Pattern Char
convertPatternS [PatternS]
e1) (forall a b. (a -> b) -> [a] -> [b]
map PatternS -> Pattern Char
convertPatternS [PatternS]
e2)
convertEnvPair :: (Rep, EnvList) -> [(String, Env Char)]
convertEnvPair :: (Rep, EnvList) -> [([Char], Env Char)]
convertEnvPair (Rep
rp, EnvList
envs) =
let rp' :: [Char]
rp' = Rep -> [Char]
convertRep Rep
rp
in forall a b. (a -> b) -> [a] -> [b]
map (\EnvS
env -> ([Char]
rp', EnvS -> Env Char
convertEnvS EnvS
env)) (forall a. NonEmpty a -> [a]
toList EnvList
envs)
convertStatementS :: StatementS -> [(Char, [(String, Env Char)])]
convertStatementS :: StatementS -> [(Char, [([Char], Env Char)])]
convertStatementS = \case
Simple NonEmpty CharS
sounds Rep
rp EnvList
envs ->
let pairs :: [([Char], Env Char)]
pairs = (Rep, EnvList) -> [([Char], Env Char)]
convertEnvPair (Rep
rp, EnvList
envs)
in forall a b. (a -> b) -> [a] -> [b]
map (, [([Char], Env Char)]
pairs) (forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap CharS -> [Char]
convertCharList NonEmpty CharS
sounds)
SoundSplit NonEmpty CharS
sounds Pairing Rep EnvList
envPairs ->
let pairs :: [([Char], Env Char)]
pairs = forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (Rep, EnvList) -> [([Char], Env Char)]
convertEnvPair Pairing Rep EnvList
envPairs
in forall a b. (a -> b) -> [a] -> [b]
map (, [([Char], Env Char)]
pairs) (forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap CharS -> [Char]
convertCharList NonEmpty CharS
sounds)
EnvSplit Pairing (NonEmpty CharS) Rep
soundPairs EnvList
envs ->
let envs' :: [Env Char]
envs' = forall a b. (a -> b) -> [a] -> [b]
map EnvS -> Env Char
convertEnvS (forall a. NonEmpty a -> [a]
toList EnvList
envs)
in forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (\(NonEmpty CharS
sounds, Rep
rp) ->
let rp' :: [Char]
rp' = Rep -> [Char]
convertRep Rep
rp
pairs :: [([Char], Env Char)]
pairs = forall a b. (a -> b) -> [a] -> [b]
map ([Char]
rp', ) [Env Char]
envs'
in forall a b. (a -> b) -> [a] -> [b]
map (, [([Char], Env Char)]
pairs) (forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap CharS -> [Char]
convertCharList NonEmpty CharS
sounds))
Pairing (NonEmpty CharS) Rep
soundPairs
convertChangeS :: ChangeS -> Change Char
convertChangeS :: ChangeS -> Change Char
convertChangeS (ChangeS NonEmpty StatementS
stmts) = forall a. Map a [([a], Env a)] -> Change a
Change (forall k a. Ord k => (a -> a -> a) -> [(k, a)] -> Map k a
Map.fromListWith (forall a b c. (a -> b -> c) -> b -> a -> c
flip forall a. [a] -> [a] -> [a]
(++)) (forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap StatementS -> [(Char, [([Char], Env Char)])]
convertStatementS NonEmpty StatementS
stmts))