{-|
Module     : Language.Change.Quote
Copyright  : (c) Owen Bechtel, 2023
License    : MIT
Maintainer : ombspring@gmail.com
Stability  : experimental
-}

{-# 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 -- antiquoted identifier
  | CList [Char] -- does not exist in syntax; used for compilation of antiquotes
  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) -- True = allow newlines

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)

{-|
Compile a sound change specification into a value of type 'Change' 'Char'.

Example:

@
setV = "aeiou"

change1 = [ch|
  m, n, ŋ > { m \/ _{mpb}; n \/ _{ntd}; ŋ \/ _{ŋkg} }
  { p > b; t > d; k > g } \/ V_V
  |]
@

The sound change in this example consists of two statements separated by a newline. The first statement says 
\"m, n, and ŋ become \/m\/ when followed by m, p, or b, \/n\/ when followed by n, t, or d, and \/ŋ\/ when followed by ŋ, k, or g.\"
The second statement says that voiceless stops (p, t, and k) become voiced when between two vowels. The uppercase @V@ here is
shorthand for \"any element of @setV@.\" 

All uppercase letters are interpreted in this way, which means they are not allowed as phonemes. 
Whitespace characters, as well as the following symbols ( @,>\/;{}[]%_!?*@ ) are also not allowed as phonemes. 
All other unicode characters are allowed. (For example, you can use @#@ as a \"phoneme\" representing the start or end of a word.)
 
Here's another example:

@
change2 = [ch|
  V > % \/ s_{ptk}             \/\/ vowel loss after \/s\/ before stops
  { o > ø; u > y } \/ _V!*{ji} \/\/ umlaut before \/j\/ and \/i\/ (with optional consonants in between) 
  y > i \/ _                   \/\/ unconditional shift
 |]
@

This example illustrates several features:

* You can create line comments with @\/\/@. 

* The left side of @>@ need not be a single phoneme; it can also be a set of phonemes (in this case @V@).

* The symbol @%@ represents the empty string.

* Certain suffixes can be added to phonemes and phoneme-sets to create more complex patterns:

    * @X!@ matches anything /not/ in the set @X@.

    * @X*@ matches zero or more elements of @X@.

    * @X?@ matches zero or one elements of @X@.

    * There are also the combinations @X!*@ and @X!?@.

* To create an unconditional sound change, use the empty environment @_@.

* The statements in a sound change are applied in a single traversal.
This means that the same phoneme cannot be affected by more than one statement.
For example, the change above would convert \"yni\" into \"ini,\" and \"uni\" into \"yni.\"
(If you want to sequence multiple changes, use 'chs'.)

* If multiple statements are applicable to the same phoneme, the first one is applied.
For example, the change above would convert \"soki\" into \"ski\", not \"søki.\"

Other noteworthy things:

* As mentioned above, capital letters refer to sets of characters: @V@ refers to @setV@, @N@ refers to @setN@, and so on.
To refer to sets with longer names, you can use square brackets; 
for example, if you define @setNasal :: [Char]@, you can refer to it with @[Nasal]@.

* It is possible to have multiple conditions in a single statement. For example, @e > i / _a, a_@ means \"\/e\/ becomes \/i\/ when before \/a\/ /or/ after \/a\/.\" 

* The parser is whitespace-sensitive. Horizontal space characters can go almost anywhere, 
but newlines are only allowed between statements (where they are required)
and inside of @{}@ blocks.
-}

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 
  }

{-|
Compile a sequence of sound changes into a value of type @['Change' 'Char']@.
Each change is preceded by a bullet @*@. For example:

@
changes = [chs|
  * p > f \/ _{tk}
    t > θ \/ _{pk}
    k > x \/ _{pt} \/\/ these three statements are applied in a single traversal
  * x > ç \/ i_    \/\/ this statement is applied after the ones before it
  * i > j \/ _V
  |]
@

For example, @'applyChanges' changes "ikt"@ would return @"içt"@.
-}

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))