{-# LANGUAGE DeriveDataTypeable, FlexibleInstances, GeneralizedNewtypeDeriving, OverloadedStrings, RecordWildCards, DeriveGeneric #-}
module Language.Bash.Syntax
(
Command(..)
, ShellCommand(..)
, WordList(..)
, CaseClause(..)
, CaseTerm(..)
, Redir(..)
, IODesc(..)
, RedirOp(..)
, HeredocOp(..)
, List(..)
, Statement(..)
, ListTerm(..)
, AndOr(..)
, Pipeline(..)
, Assign(..)
, AssignOp(..)
, RValue(..)
) where
import Prelude hiding (Word)
import Data.Data (Data)
import Data.List (intersperse)
import Data.Typeable (Typeable)
import GHC.Generics (Generic)
import Prettyprinter (Doc, Pretty(..), (<+>), hardline, hcat, hsep, indent, nest, nesting, punctuate, vcat)
import Prettyprinter.Internal.Type (Doc(Empty))
import Language.Bash.Cond (CondExpr)
import Language.Bash.Operator
import Language.Bash.Pretty
import Language.Bash.Word
data BashDoc ann = BashDoc
(Doc ann)
(Doc ann)
(Doc ann)
instance Semigroup (BashDoc ann) where
BashDoc Doc ann
Empty Doc ann
Empty Doc ann
Empty <> :: BashDoc ann -> BashDoc ann -> BashDoc ann
<> BashDoc ann
y = BashDoc ann
y
BashDoc ann
x <> BashDoc Doc ann
Empty Doc ann
Empty Doc ann
Empty = BashDoc ann
x
BashDoc Doc ann
h1 Doc ann
t1 Doc ann
Empty <> BashDoc Doc ann
h2 Doc ann
t2 Doc ann
hds2 = Doc ann -> Doc ann -> Doc ann -> BashDoc ann
forall ann. Doc ann -> Doc ann -> Doc ann -> BashDoc ann
BashDoc Doc ann
h1 (Doc ann
t1 Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Doc ann
h2 Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<++> Doc ann
t2) Doc ann
hds2
BashDoc Doc ann
h1 Doc ann
t1 Doc ann
hds1 <> BashDoc Doc ann
h2 Doc ann
t2 Doc ann
hds2 = Doc ann -> Doc ann -> Doc ann -> BashDoc ann
forall ann. Doc ann -> Doc ann -> Doc ann -> BashDoc ann
BashDoc Doc ann
h1 (Doc ann
t1 Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Doc ann -> Doc ann
forall {ann}. Doc ann -> Doc ann
noIndent (Doc ann
h2 Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
$++$ Doc ann
hds1) Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
$++$ Doc ann
t2) Doc ann
hds2
where
noIndent :: Doc ann -> Doc ann
noIndent Doc ann
doc = (Int -> Doc ann) -> Doc ann
forall ann. (Int -> Doc ann) -> Doc ann
nesting ((Int -> Doc ann) -> Doc ann) -> (Int -> Doc ann) -> Doc ann
forall a b. (a -> b) -> a -> b
$ \Int
i -> Int -> Doc ann -> Doc ann
forall ann. Int -> Doc ann -> Doc ann
nest (- Int
i) Doc ann
doc
instance Monoid (BashDoc ann) where
mempty :: BashDoc ann
mempty = Doc ann -> Doc ann -> Doc ann -> BashDoc ann
forall ann. Doc ann -> Doc ann -> Doc ann -> BashDoc ann
BashDoc Doc ann
forall a. Monoid a => a
mempty Doc ann
forall a. Monoid a => a
mempty Doc ann
forall a. Monoid a => a
mempty
mappend :: BashDoc ann -> BashDoc ann -> BashDoc ann
mappend = BashDoc ann -> BashDoc ann -> BashDoc ann
forall a. Semigroup a => a -> a -> a
(<>)
docOp :: Doc ann -> BashDoc ann
docOp :: forall ann. Doc ann -> BashDoc ann
docOp Doc ann
xs = Doc ann -> Doc ann -> Doc ann -> BashDoc ann
forall ann. Doc ann -> Doc ann -> Doc ann -> BashDoc ann
BashDoc Doc ann
xs Doc ann
forall a. Monoid a => a
mempty Doc ann
forall a. Monoid a => a
mempty
prettyBashDoc :: BashDoc ann -> Doc ann
prettyBashDoc :: forall ann. BashDoc ann -> Doc ann
prettyBashDoc (BashDoc Doc ann
h Doc ann
t Doc ann
hds) = Doc ann
h Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<++> Doc ann
t Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
$++$ Doc ann
hds
class ToBashDoc a where
toBashDoc :: a -> BashDoc ann
prettyHeredocs :: [Redir] -> Doc ann
prettyHeredocs :: forall ann. [Redir] -> Doc ann
prettyHeredocs [] = Doc ann
forall a. Monoid a => a
mempty
prettyHeredocs [Redir]
rs = [Doc ann] -> Doc ann
forall a. Monoid a => [a] -> a
mconcat ([Doc ann] -> Doc ann) -> [Doc ann] -> Doc ann
forall a b. (a -> b) -> a -> b
$ Doc ann -> [Doc ann] -> [Doc ann]
forall a. a -> [a] -> [a]
intersperse Doc ann
forall ann. Doc ann
hardline ([Doc ann] -> [Doc ann]) -> [Doc ann] -> [Doc ann]
forall a b. (a -> b) -> a -> b
$ (Redir -> Doc ann) -> [Redir] -> [Doc ann]
forall a b. (a -> b) -> [a] -> [b]
map Redir -> Doc ann
forall {ann}. Redir -> Doc ann
prettyHeredoc [Redir]
rs
where
prettyHeredoc :: Redir -> Doc ann
prettyHeredoc Heredoc{Bool
String
[Span]
HeredocOp
heredocOp :: HeredocOp
heredocDelim :: String
heredocDelimQuoted :: Bool
hereDocument :: [Span]
heredocOp :: Redir -> HeredocOp
heredocDelim :: Redir -> String
heredocDelimQuoted :: Redir -> Bool
hereDocument :: Redir -> [Span]
..} = [Span] -> Doc ann
forall ann. [Span] -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty ([Span] -> [Span]
ensureTrailingNewline [Span]
hereDocument) Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
heredocDelim
prettyHeredoc Redir
_ = Doc ann
forall a. Monoid a => a
mempty
ensureTrailingNewline :: [Span] -> [Span]
ensureTrailingNewline [] = []
ensureTrailingNewline [Span]
xs
| [Span] -> Span
forall a. HasCallStack => [a] -> a
last [Span]
xs Span -> Span -> Bool
forall a. Eq a => a -> a -> Bool
== Char -> Span
Char Char
'\n' = [Span]
xs
| Bool
otherwise = [Span]
xs [Span] -> [Span] -> [Span]
forall a. [a] -> [a] -> [a]
++ [Char -> Span
Char Char
'\n']
indent' :: Doc ann -> Doc ann
indent' :: forall {ann}. Doc ann -> Doc ann
indent' = Int -> Doc ann -> Doc ann
forall ann. Int -> Doc ann -> Doc ann
indent Int
4
prettyBlock :: Doc ann -> Doc ann -> Doc ann -> Doc ann -> Doc ann -> Doc ann
prettyBlock :: forall ann.
Doc ann -> Doc ann -> Doc ann -> Doc ann -> Doc ann -> Doc ann
prettyBlock Doc ann
pre Doc ann
cond Doc ann
bs Doc ann
block Doc ann
be = Doc ann
pre Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Doc ann
cond Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Doc ann
bs Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
$+$ Doc ann
block Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
$+$ Doc ann
be
prettyBlockList :: Doc ann -> List -> Doc ann -> Doc ann -> Doc ann -> Doc ann
prettyBlockList :: forall ann.
Doc ann -> List -> Doc ann -> Doc ann -> Doc ann -> Doc ann
prettyBlockList Doc ann
pre List
l Doc ann
bs Doc ann
block Doc ann
be
| List -> Bool
hasHeredoc List
l = Doc ann
pre Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> List -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. List -> Doc ann
pretty List
l Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
$+$ Doc ann
bs Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
$+$ Doc ann
block Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
$+$ Doc ann
be
| Bool
otherwise = Doc ann -> Doc ann -> Doc ann -> Doc ann -> Doc ann -> Doc ann
forall ann.
Doc ann -> Doc ann -> Doc ann -> Doc ann -> Doc ann -> Doc ann
prettyBlock Doc ann
pre (List -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. List -> Doc ann
pretty List
l) Doc ann
bs Doc ann
block Doc ann
be
hasHeredoc :: List -> Bool
hasHeredoc :: List -> Bool
hasHeredoc (List []) = Bool
False
hasHeredoc (List [Statement]
xs) = let
Statement AndOr
l ListTerm
_ = [Statement] -> Statement
forall a. HasCallStack => [a] -> a
last [Statement]
xs
BashDoc Doc ann
_ Doc ann
_ Doc ann
hds = AndOr -> BashDoc ann
forall ann. AndOr -> BashDoc ann
forall a ann. ToBashDoc a => a -> BashDoc ann
toBashDoc AndOr
l
in case Doc Any
forall ann. Doc ann
hds of
Doc Any
Empty -> Bool
False
Doc Any
_ -> Bool
True
data Command = Command ShellCommand [Redir]
deriving (Typeable Command
Typeable Command
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Command -> c Command)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Command)
-> (Command -> Constr)
-> (Command -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Command))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Command))
-> ((forall b. Data b => b -> b) -> Command -> Command)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Command -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Command -> r)
-> (forall u. (forall d. Data d => d -> u) -> Command -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Command -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Command -> m Command)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Command -> m Command)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Command -> m Command)
-> Data Command
Command -> Constr
Command -> DataType
(forall b. Data b => b -> b) -> Command -> Command
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) -> Command -> u
forall u. (forall d. Data d => d -> u) -> Command -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Command -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Command -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Command -> m Command
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Command -> m Command
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Command
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Command -> c Command
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Command)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Command)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Command -> c Command
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Command -> c Command
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Command
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Command
$ctoConstr :: Command -> Constr
toConstr :: Command -> Constr
$cdataTypeOf :: Command -> DataType
dataTypeOf :: Command -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Command)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Command)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Command)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Command)
$cgmapT :: (forall b. Data b => b -> b) -> Command -> Command
gmapT :: (forall b. Data b => b -> b) -> Command -> Command
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Command -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Command -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Command -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Command -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Command -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Command -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Command -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Command -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Command -> m Command
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Command -> m Command
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Command -> m Command
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Command -> m Command
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Command -> m Command
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Command -> m Command
Data, Command -> Command -> Bool
(Command -> Command -> Bool)
-> (Command -> Command -> Bool) -> Eq Command
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Command -> Command -> Bool
== :: Command -> Command -> Bool
$c/= :: Command -> Command -> Bool
/= :: Command -> Command -> Bool
Eq, ReadPrec [Command]
ReadPrec Command
Int -> ReadS Command
ReadS [Command]
(Int -> ReadS Command)
-> ReadS [Command]
-> ReadPrec Command
-> ReadPrec [Command]
-> Read Command
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Command
readsPrec :: Int -> ReadS Command
$creadList :: ReadS [Command]
readList :: ReadS [Command]
$creadPrec :: ReadPrec Command
readPrec :: ReadPrec Command
$creadListPrec :: ReadPrec [Command]
readListPrec :: ReadPrec [Command]
Read, Int -> Command -> ShowS
[Command] -> ShowS
Command -> String
(Int -> Command -> ShowS)
-> (Command -> String) -> ([Command] -> ShowS) -> Show Command
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Command -> ShowS
showsPrec :: Int -> Command -> ShowS
$cshow :: Command -> String
show :: Command -> String
$cshowList :: [Command] -> ShowS
showList :: [Command] -> ShowS
Show, Typeable, (forall x. Command -> Rep Command x)
-> (forall x. Rep Command x -> Command) -> Generic Command
forall x. Rep Command x -> Command
forall x. Command -> Rep Command x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Command -> Rep Command x
from :: forall x. Command -> Rep Command x
$cto :: forall x. Rep Command x -> Command
to :: forall x. Rep Command x -> Command
Generic)
instance Pretty Command where
pretty :: forall ann. Command -> Doc ann
pretty = BashDoc ann -> Doc ann
forall ann. BashDoc ann -> Doc ann
prettyBashDoc (BashDoc ann -> Doc ann)
-> (Command -> BashDoc ann) -> Command -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Command -> BashDoc ann
forall ann. Command -> BashDoc ann
forall a ann. ToBashDoc a => a -> BashDoc ann
toBashDoc
instance ToBashDoc Command where
toBashDoc :: forall ann. Command -> BashDoc ann
toBashDoc (Command ShellCommand
c [Redir]
rs) = Doc ann -> Doc ann -> Doc ann -> BashDoc ann
forall ann. Doc ann -> Doc ann -> Doc ann -> BashDoc ann
BashDoc Doc ann
forall a. Monoid a => a
mempty (ShellCommand -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. ShellCommand -> Doc ann
pretty ShellCommand
c Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<++> [Redir] -> Doc ann
forall ann. [Redir] -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty [Redir]
rs) ([Redir] -> Doc ann
forall ann. [Redir] -> Doc ann
prettyHeredocs ([Redir] -> Doc ann) -> [Redir] -> Doc ann
forall a b. (a -> b) -> a -> b
$ (Redir -> Bool) -> [Redir] -> [Redir]
forall a. (a -> Bool) -> [a] -> [a]
filter Redir -> Bool
isHeredoc [Redir]
rs)
where
isHeredoc :: Redir -> Bool
isHeredoc Heredoc{} = Bool
True
isHeredoc Redir
_ = Bool
False
data ShellCommand
= SimpleCommand [Assign] [Word]
| AssignBuiltin Word [Either Assign Word]
| FunctionDef String List
| Coproc String Command
| Subshell List
| Group List
| Arith String
| Cond (CondExpr Word)
| For String WordList List
| ArithFor String List
| Select String WordList List
| Case Word [CaseClause]
| If List List (Maybe List)
| Until List List
| While List List
deriving (Typeable ShellCommand
Typeable ShellCommand
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ShellCommand -> c ShellCommand)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ShellCommand)
-> (ShellCommand -> Constr)
-> (ShellCommand -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ShellCommand))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ShellCommand))
-> ((forall b. Data b => b -> b) -> ShellCommand -> ShellCommand)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ShellCommand -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ShellCommand -> r)
-> (forall u. (forall d. Data d => d -> u) -> ShellCommand -> [u])
-> (forall u.
Int -> (forall d. Data d => d -> u) -> ShellCommand -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ShellCommand -> m ShellCommand)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ShellCommand -> m ShellCommand)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ShellCommand -> m ShellCommand)
-> Data ShellCommand
ShellCommand -> Constr
ShellCommand -> DataType
(forall b. Data b => b -> b) -> ShellCommand -> ShellCommand
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) -> ShellCommand -> u
forall u. (forall d. Data d => d -> u) -> ShellCommand -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ShellCommand -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ShellCommand -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ShellCommand -> m ShellCommand
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ShellCommand -> m ShellCommand
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ShellCommand
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ShellCommand -> c ShellCommand
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ShellCommand)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ShellCommand)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ShellCommand -> c ShellCommand
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ShellCommand -> c ShellCommand
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ShellCommand
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ShellCommand
$ctoConstr :: ShellCommand -> Constr
toConstr :: ShellCommand -> Constr
$cdataTypeOf :: ShellCommand -> DataType
dataTypeOf :: ShellCommand -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ShellCommand)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ShellCommand)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ShellCommand)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ShellCommand)
$cgmapT :: (forall b. Data b => b -> b) -> ShellCommand -> ShellCommand
gmapT :: (forall b. Data b => b -> b) -> ShellCommand -> ShellCommand
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ShellCommand -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ShellCommand -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ShellCommand -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ShellCommand -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ShellCommand -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ShellCommand -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ShellCommand -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ShellCommand -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ShellCommand -> m ShellCommand
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ShellCommand -> m ShellCommand
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ShellCommand -> m ShellCommand
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ShellCommand -> m ShellCommand
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ShellCommand -> m ShellCommand
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ShellCommand -> m ShellCommand
Data, ShellCommand -> ShellCommand -> Bool
(ShellCommand -> ShellCommand -> Bool)
-> (ShellCommand -> ShellCommand -> Bool) -> Eq ShellCommand
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ShellCommand -> ShellCommand -> Bool
== :: ShellCommand -> ShellCommand -> Bool
$c/= :: ShellCommand -> ShellCommand -> Bool
/= :: ShellCommand -> ShellCommand -> Bool
Eq, ReadPrec [ShellCommand]
ReadPrec ShellCommand
Int -> ReadS ShellCommand
ReadS [ShellCommand]
(Int -> ReadS ShellCommand)
-> ReadS [ShellCommand]
-> ReadPrec ShellCommand
-> ReadPrec [ShellCommand]
-> Read ShellCommand
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ShellCommand
readsPrec :: Int -> ReadS ShellCommand
$creadList :: ReadS [ShellCommand]
readList :: ReadS [ShellCommand]
$creadPrec :: ReadPrec ShellCommand
readPrec :: ReadPrec ShellCommand
$creadListPrec :: ReadPrec [ShellCommand]
readListPrec :: ReadPrec [ShellCommand]
Read, Int -> ShellCommand -> ShowS
[ShellCommand] -> ShowS
ShellCommand -> String
(Int -> ShellCommand -> ShowS)
-> (ShellCommand -> String)
-> ([ShellCommand] -> ShowS)
-> Show ShellCommand
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ShellCommand -> ShowS
showsPrec :: Int -> ShellCommand -> ShowS
$cshow :: ShellCommand -> String
show :: ShellCommand -> String
$cshowList :: [ShellCommand] -> ShowS
showList :: [ShellCommand] -> ShowS
Show, Typeable, (forall x. ShellCommand -> Rep ShellCommand x)
-> (forall x. Rep ShellCommand x -> ShellCommand)
-> Generic ShellCommand
forall x. Rep ShellCommand x -> ShellCommand
forall x. ShellCommand -> Rep ShellCommand x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ShellCommand -> Rep ShellCommand x
from :: forall x. ShellCommand -> Rep ShellCommand x
$cto :: forall x. Rep ShellCommand x -> ShellCommand
to :: forall x. Rep ShellCommand x -> ShellCommand
Generic)
instance Pretty ShellCommand where
pretty :: forall ann. ShellCommand -> Doc ann
pretty (SimpleCommand [Assign]
as [[Span]]
ws) = [Assign] -> Doc ann
forall ann. [Assign] -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty [Assign]
as Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<++> [[Span]] -> Doc ann
forall ann. [[Span]] -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty [[Span]]
ws
pretty (AssignBuiltin [Span]
w [Either Assign [Span]]
args) = [Span] -> Doc ann
forall ann. [Span] -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty [Span]
w Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<++> [Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
hsep ((Either Assign [Span] -> Doc ann)
-> [Either Assign [Span]] -> [Doc ann]
forall a b. (a -> b) -> [a] -> [b]
map ((Assign -> Doc ann)
-> ([Span] -> Doc ann) -> Either Assign [Span] -> Doc ann
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either Assign -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Assign -> Doc ann
pretty [Span] -> Doc ann
forall ann. [Span] -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty) [Either Assign [Span]]
args)
pretty (FunctionDef String
name List
l) =
String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
name Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Doc ann
"()" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
$+$ ShellCommand -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. ShellCommand -> Doc ann
pretty (List -> ShellCommand
Group List
l)
pretty (Coproc String
name Command
c) =
Doc ann
"coproc" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
name Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Command -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Command -> Doc ann
pretty Command
c
pretty (Subshell List
l) =
Doc ann
"(" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> List -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. List -> Doc ann
pretty List
l Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Doc ann
")"
pretty (Group List
l) =
Doc ann
"{" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
$+$ Doc ann -> Doc ann
forall {ann}. Doc ann -> Doc ann
indent' (List -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. List -> Doc ann
pretty List
l) Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
$+$ Doc ann
"}"
pretty (Arith String
s) =
Doc ann
"((" Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
s Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Doc ann
"))"
pretty (Cond CondExpr [Span]
e) =
Doc ann
"[[" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> CondExpr [Span] -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. CondExpr [Span] -> Doc ann
pretty CondExpr [Span]
e Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Doc ann
"]]"
pretty (For String
w WordList
ws List
l) =
Doc ann -> Doc ann -> Doc ann -> Doc ann -> Doc ann -> Doc ann
forall ann.
Doc ann -> Doc ann -> Doc ann -> Doc ann -> Doc ann -> Doc ann
prettyBlock Doc ann
"for" (String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
w Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> WordList -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. WordList -> Doc ann
pretty WordList
ws Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Doc ann
";") Doc ann
"do" (Doc ann -> Doc ann
forall {ann}. Doc ann -> Doc ann
indent' (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ List -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. List -> Doc ann
pretty List
l) Doc ann
"done"
pretty (ArithFor String
s List
l) =
Doc ann -> Doc ann -> Doc ann -> Doc ann -> Doc ann -> Doc ann
forall ann.
Doc ann -> Doc ann -> Doc ann -> Doc ann -> Doc ann -> Doc ann
prettyBlock Doc ann
"for" (Doc ann
"((" Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
s Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Doc ann
"))") Doc ann
"do" (Doc ann -> Doc ann
forall {ann}. Doc ann -> Doc ann
indent' (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ List -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. List -> Doc ann
pretty List
l) Doc ann
"done"
pretty (Select String
w WordList
ws List
l) =
Doc ann -> Doc ann -> Doc ann -> Doc ann -> Doc ann -> Doc ann
forall ann.
Doc ann -> Doc ann -> Doc ann -> Doc ann -> Doc ann -> Doc ann
prettyBlock Doc ann
"select" (String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
w Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<++> WordList -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. WordList -> Doc ann
pretty WordList
ws Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Doc ann
";") Doc ann
"do" (Doc ann -> Doc ann
forall {ann}. Doc ann -> Doc ann
indent' (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ List -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. List -> Doc ann
pretty List
l) Doc ann
"done"
pretty (Case [Span]
w [CaseClause]
cs) =
Doc ann -> Doc ann -> Doc ann -> Doc ann -> Doc ann -> Doc ann
forall ann.
Doc ann -> Doc ann -> Doc ann -> Doc ann -> Doc ann -> Doc ann
prettyBlock Doc ann
"case" ([Span] -> Doc ann
forall ann. [Span] -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty [Span]
w) Doc ann
"in" ([Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
vcat ([Doc ann] -> Doc ann) -> [Doc ann] -> Doc ann
forall a b. (a -> b) -> a -> b
$ (CaseClause -> Doc ann) -> [CaseClause] -> [Doc ann]
forall a b. (a -> b) -> [a] -> [b]
map (Doc ann -> Doc ann
forall {ann}. Doc ann -> Doc ann
indent' (Doc ann -> Doc ann)
-> (CaseClause -> Doc ann) -> CaseClause -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CaseClause -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. CaseClause -> Doc ann
pretty) [CaseClause]
cs) Doc ann
"esac"
pretty (If List
p List
t Maybe List
f) =
Doc ann -> List -> Doc ann -> Doc ann -> Doc ann -> Doc ann
forall ann.
Doc ann -> List -> Doc ann -> Doc ann -> Doc ann -> Doc ann
prettyBlockList Doc ann
"if" List
p Doc ann
"then"
(Doc ann -> Doc ann
forall {ann}. Doc ann -> Doc ann
indent' (List -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. List -> Doc ann
pretty List
t) Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
$++$ (Doc ann -> (List -> Doc ann) -> Maybe List -> Doc ann
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Doc ann
forall a. Monoid a => a
mempty (\List
l -> Doc ann
"else" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
$+$ Doc ann -> Doc ann
forall {ann}. Doc ann -> Doc ann
indent' (List -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. List -> Doc ann
pretty List
l)) Maybe List
f)
)
Doc ann
"fi"
pretty (Until List
p List
l) =
Doc ann -> List -> Doc ann -> Doc ann -> Doc ann -> Doc ann
forall ann.
Doc ann -> List -> Doc ann -> Doc ann -> Doc ann -> Doc ann
prettyBlockList Doc ann
"until" List
p Doc ann
"do" (Doc ann -> Doc ann
forall {ann}. Doc ann -> Doc ann
indent' (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ List -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. List -> Doc ann
pretty List
l) Doc ann
"done"
pretty (While List
p List
l) =
Doc ann -> List -> Doc ann -> Doc ann -> Doc ann -> Doc ann
forall ann.
Doc ann -> List -> Doc ann -> Doc ann -> Doc ann -> Doc ann
prettyBlockList Doc ann
"while" List
p Doc ann
"do" (Doc ann -> Doc ann
forall {ann}. Doc ann -> Doc ann
indent' (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ List -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. List -> Doc ann
pretty List
l) Doc ann
"done"
data WordList
= Args
| WordList [Word]
deriving (Typeable WordList
Typeable WordList
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> WordList -> c WordList)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c WordList)
-> (WordList -> Constr)
-> (WordList -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c WordList))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c WordList))
-> ((forall b. Data b => b -> b) -> WordList -> WordList)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> WordList -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> WordList -> r)
-> (forall u. (forall d. Data d => d -> u) -> WordList -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> WordList -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> WordList -> m WordList)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> WordList -> m WordList)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> WordList -> m WordList)
-> Data WordList
WordList -> Constr
WordList -> DataType
(forall b. Data b => b -> b) -> WordList -> WordList
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) -> WordList -> u
forall u. (forall d. Data d => d -> u) -> WordList -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> WordList -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> WordList -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> WordList -> m WordList
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> WordList -> m WordList
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c WordList
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> WordList -> c WordList
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c WordList)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c WordList)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> WordList -> c WordList
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> WordList -> c WordList
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c WordList
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c WordList
$ctoConstr :: WordList -> Constr
toConstr :: WordList -> Constr
$cdataTypeOf :: WordList -> DataType
dataTypeOf :: WordList -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c WordList)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c WordList)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c WordList)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c WordList)
$cgmapT :: (forall b. Data b => b -> b) -> WordList -> WordList
gmapT :: (forall b. Data b => b -> b) -> WordList -> WordList
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> WordList -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> WordList -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> WordList -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> WordList -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> WordList -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> WordList -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> WordList -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> WordList -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> WordList -> m WordList
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> WordList -> m WordList
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> WordList -> m WordList
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> WordList -> m WordList
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> WordList -> m WordList
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> WordList -> m WordList
Data, WordList -> WordList -> Bool
(WordList -> WordList -> Bool)
-> (WordList -> WordList -> Bool) -> Eq WordList
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: WordList -> WordList -> Bool
== :: WordList -> WordList -> Bool
$c/= :: WordList -> WordList -> Bool
/= :: WordList -> WordList -> Bool
Eq, ReadPrec [WordList]
ReadPrec WordList
Int -> ReadS WordList
ReadS [WordList]
(Int -> ReadS WordList)
-> ReadS [WordList]
-> ReadPrec WordList
-> ReadPrec [WordList]
-> Read WordList
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS WordList
readsPrec :: Int -> ReadS WordList
$creadList :: ReadS [WordList]
readList :: ReadS [WordList]
$creadPrec :: ReadPrec WordList
readPrec :: ReadPrec WordList
$creadListPrec :: ReadPrec [WordList]
readListPrec :: ReadPrec [WordList]
Read, Int -> WordList -> ShowS
[WordList] -> ShowS
WordList -> String
(Int -> WordList -> ShowS)
-> (WordList -> String) -> ([WordList] -> ShowS) -> Show WordList
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> WordList -> ShowS
showsPrec :: Int -> WordList -> ShowS
$cshow :: WordList -> String
show :: WordList -> String
$cshowList :: [WordList] -> ShowS
showList :: [WordList] -> ShowS
Show, Typeable, (forall x. WordList -> Rep WordList x)
-> (forall x. Rep WordList x -> WordList) -> Generic WordList
forall x. Rep WordList x -> WordList
forall x. WordList -> Rep WordList x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. WordList -> Rep WordList x
from :: forall x. WordList -> Rep WordList x
$cto :: forall x. Rep WordList x -> WordList
to :: forall x. Rep WordList x -> WordList
Generic)
instance Pretty WordList where
pretty :: forall ann. WordList -> Doc ann
pretty WordList
Args = Doc ann
forall a. Monoid a => a
mempty
pretty (WordList [[Span]]
ws) = Doc ann
"in" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> [[Span]] -> Doc ann
forall ann. [[Span]] -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty [[Span]]
ws
data CaseClause = CaseClause [Word] List CaseTerm
deriving (Typeable CaseClause
Typeable CaseClause
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CaseClause -> c CaseClause)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CaseClause)
-> (CaseClause -> Constr)
-> (CaseClause -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CaseClause))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CaseClause))
-> ((forall b. Data b => b -> b) -> CaseClause -> CaseClause)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CaseClause -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CaseClause -> r)
-> (forall u. (forall d. Data d => d -> u) -> CaseClause -> [u])
-> (forall u.
Int -> (forall d. Data d => d -> u) -> CaseClause -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CaseClause -> m CaseClause)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CaseClause -> m CaseClause)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CaseClause -> m CaseClause)
-> Data CaseClause
CaseClause -> Constr
CaseClause -> DataType
(forall b. Data b => b -> b) -> CaseClause -> CaseClause
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) -> CaseClause -> u
forall u. (forall d. Data d => d -> u) -> CaseClause -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CaseClause -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CaseClause -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CaseClause -> m CaseClause
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CaseClause -> m CaseClause
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CaseClause
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CaseClause -> c CaseClause
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CaseClause)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CaseClause)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CaseClause -> c CaseClause
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CaseClause -> c CaseClause
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CaseClause
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CaseClause
$ctoConstr :: CaseClause -> Constr
toConstr :: CaseClause -> Constr
$cdataTypeOf :: CaseClause -> DataType
dataTypeOf :: CaseClause -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CaseClause)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CaseClause)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CaseClause)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CaseClause)
$cgmapT :: (forall b. Data b => b -> b) -> CaseClause -> CaseClause
gmapT :: (forall b. Data b => b -> b) -> CaseClause -> CaseClause
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CaseClause -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CaseClause -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CaseClause -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CaseClause -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> CaseClause -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> CaseClause -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CaseClause -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CaseClause -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CaseClause -> m CaseClause
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CaseClause -> m CaseClause
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CaseClause -> m CaseClause
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CaseClause -> m CaseClause
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CaseClause -> m CaseClause
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CaseClause -> m CaseClause
Data, CaseClause -> CaseClause -> Bool
(CaseClause -> CaseClause -> Bool)
-> (CaseClause -> CaseClause -> Bool) -> Eq CaseClause
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CaseClause -> CaseClause -> Bool
== :: CaseClause -> CaseClause -> Bool
$c/= :: CaseClause -> CaseClause -> Bool
/= :: CaseClause -> CaseClause -> Bool
Eq, ReadPrec [CaseClause]
ReadPrec CaseClause
Int -> ReadS CaseClause
ReadS [CaseClause]
(Int -> ReadS CaseClause)
-> ReadS [CaseClause]
-> ReadPrec CaseClause
-> ReadPrec [CaseClause]
-> Read CaseClause
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS CaseClause
readsPrec :: Int -> ReadS CaseClause
$creadList :: ReadS [CaseClause]
readList :: ReadS [CaseClause]
$creadPrec :: ReadPrec CaseClause
readPrec :: ReadPrec CaseClause
$creadListPrec :: ReadPrec [CaseClause]
readListPrec :: ReadPrec [CaseClause]
Read, Int -> CaseClause -> ShowS
[CaseClause] -> ShowS
CaseClause -> String
(Int -> CaseClause -> ShowS)
-> (CaseClause -> String)
-> ([CaseClause] -> ShowS)
-> Show CaseClause
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CaseClause -> ShowS
showsPrec :: Int -> CaseClause -> ShowS
$cshow :: CaseClause -> String
show :: CaseClause -> String
$cshowList :: [CaseClause] -> ShowS
showList :: [CaseClause] -> ShowS
Show, Typeable, (forall x. CaseClause -> Rep CaseClause x)
-> (forall x. Rep CaseClause x -> CaseClause) -> Generic CaseClause
forall x. Rep CaseClause x -> CaseClause
forall x. CaseClause -> Rep CaseClause x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. CaseClause -> Rep CaseClause x
from :: forall x. CaseClause -> Rep CaseClause x
$cto :: forall x. Rep CaseClause x -> CaseClause
to :: forall x. Rep CaseClause x -> CaseClause
Generic)
instance Pretty CaseClause where
pretty :: forall ann. CaseClause -> Doc ann
pretty (CaseClause [[Span]]
ps List
l CaseTerm
term) =
[Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
hcat (Doc ann -> [Doc ann] -> [Doc ann]
forall ann. Doc ann -> [Doc ann] -> [Doc ann]
punctuate Doc ann
" | " (([Span] -> Doc ann) -> [[Span]] -> [Doc ann]
forall a b. (a -> b) -> [a] -> [b]
map [Span] -> Doc ann
forall ann. [Span] -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty [[Span]]
ps)) Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Doc ann
")" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
$+$
Doc ann -> Doc ann
forall {ann}. Doc ann -> Doc ann
indent' (List -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. List -> Doc ann
pretty List
l) Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
$+$
(Doc ann -> Doc ann
forall {ann}. Doc ann -> Doc ann
indent' (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ CaseTerm -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. CaseTerm -> Doc ann
pretty CaseTerm
term)
data CaseTerm
= Break
| FallThrough
| Continue
deriving (Typeable CaseTerm
Typeable CaseTerm
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CaseTerm -> c CaseTerm)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CaseTerm)
-> (CaseTerm -> Constr)
-> (CaseTerm -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CaseTerm))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CaseTerm))
-> ((forall b. Data b => b -> b) -> CaseTerm -> CaseTerm)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CaseTerm -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CaseTerm -> r)
-> (forall u. (forall d. Data d => d -> u) -> CaseTerm -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> CaseTerm -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CaseTerm -> m CaseTerm)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CaseTerm -> m CaseTerm)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CaseTerm -> m CaseTerm)
-> Data CaseTerm
CaseTerm -> Constr
CaseTerm -> DataType
(forall b. Data b => b -> b) -> CaseTerm -> CaseTerm
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) -> CaseTerm -> u
forall u. (forall d. Data d => d -> u) -> CaseTerm -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CaseTerm -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CaseTerm -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CaseTerm -> m CaseTerm
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CaseTerm -> m CaseTerm
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CaseTerm
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CaseTerm -> c CaseTerm
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CaseTerm)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CaseTerm)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CaseTerm -> c CaseTerm
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CaseTerm -> c CaseTerm
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CaseTerm
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CaseTerm
$ctoConstr :: CaseTerm -> Constr
toConstr :: CaseTerm -> Constr
$cdataTypeOf :: CaseTerm -> DataType
dataTypeOf :: CaseTerm -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CaseTerm)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CaseTerm)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CaseTerm)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CaseTerm)
$cgmapT :: (forall b. Data b => b -> b) -> CaseTerm -> CaseTerm
gmapT :: (forall b. Data b => b -> b) -> CaseTerm -> CaseTerm
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CaseTerm -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CaseTerm -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CaseTerm -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CaseTerm -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> CaseTerm -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> CaseTerm -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CaseTerm -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CaseTerm -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CaseTerm -> m CaseTerm
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CaseTerm -> m CaseTerm
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CaseTerm -> m CaseTerm
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CaseTerm -> m CaseTerm
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CaseTerm -> m CaseTerm
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CaseTerm -> m CaseTerm
Data, CaseTerm -> CaseTerm -> Bool
(CaseTerm -> CaseTerm -> Bool)
-> (CaseTerm -> CaseTerm -> Bool) -> Eq CaseTerm
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CaseTerm -> CaseTerm -> Bool
== :: CaseTerm -> CaseTerm -> Bool
$c/= :: CaseTerm -> CaseTerm -> Bool
/= :: CaseTerm -> CaseTerm -> Bool
Eq, Eq CaseTerm
Eq CaseTerm
-> (CaseTerm -> CaseTerm -> Ordering)
-> (CaseTerm -> CaseTerm -> Bool)
-> (CaseTerm -> CaseTerm -> Bool)
-> (CaseTerm -> CaseTerm -> Bool)
-> (CaseTerm -> CaseTerm -> Bool)
-> (CaseTerm -> CaseTerm -> CaseTerm)
-> (CaseTerm -> CaseTerm -> CaseTerm)
-> Ord CaseTerm
CaseTerm -> CaseTerm -> Bool
CaseTerm -> CaseTerm -> Ordering
CaseTerm -> CaseTerm -> CaseTerm
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: CaseTerm -> CaseTerm -> Ordering
compare :: CaseTerm -> CaseTerm -> Ordering
$c< :: CaseTerm -> CaseTerm -> Bool
< :: CaseTerm -> CaseTerm -> Bool
$c<= :: CaseTerm -> CaseTerm -> Bool
<= :: CaseTerm -> CaseTerm -> Bool
$c> :: CaseTerm -> CaseTerm -> Bool
> :: CaseTerm -> CaseTerm -> Bool
$c>= :: CaseTerm -> CaseTerm -> Bool
>= :: CaseTerm -> CaseTerm -> Bool
$cmax :: CaseTerm -> CaseTerm -> CaseTerm
max :: CaseTerm -> CaseTerm -> CaseTerm
$cmin :: CaseTerm -> CaseTerm -> CaseTerm
min :: CaseTerm -> CaseTerm -> CaseTerm
Ord, ReadPrec [CaseTerm]
ReadPrec CaseTerm
Int -> ReadS CaseTerm
ReadS [CaseTerm]
(Int -> ReadS CaseTerm)
-> ReadS [CaseTerm]
-> ReadPrec CaseTerm
-> ReadPrec [CaseTerm]
-> Read CaseTerm
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS CaseTerm
readsPrec :: Int -> ReadS CaseTerm
$creadList :: ReadS [CaseTerm]
readList :: ReadS [CaseTerm]
$creadPrec :: ReadPrec CaseTerm
readPrec :: ReadPrec CaseTerm
$creadListPrec :: ReadPrec [CaseTerm]
readListPrec :: ReadPrec [CaseTerm]
Read, Int -> CaseTerm -> ShowS
[CaseTerm] -> ShowS
CaseTerm -> String
(Int -> CaseTerm -> ShowS)
-> (CaseTerm -> String) -> ([CaseTerm] -> ShowS) -> Show CaseTerm
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CaseTerm -> ShowS
showsPrec :: Int -> CaseTerm -> ShowS
$cshow :: CaseTerm -> String
show :: CaseTerm -> String
$cshowList :: [CaseTerm] -> ShowS
showList :: [CaseTerm] -> ShowS
Show, Typeable, CaseTerm
CaseTerm -> CaseTerm -> Bounded CaseTerm
forall a. a -> a -> Bounded a
$cminBound :: CaseTerm
minBound :: CaseTerm
$cmaxBound :: CaseTerm
maxBound :: CaseTerm
Bounded, Int -> CaseTerm
CaseTerm -> Int
CaseTerm -> [CaseTerm]
CaseTerm -> CaseTerm
CaseTerm -> CaseTerm -> [CaseTerm]
CaseTerm -> CaseTerm -> CaseTerm -> [CaseTerm]
(CaseTerm -> CaseTerm)
-> (CaseTerm -> CaseTerm)
-> (Int -> CaseTerm)
-> (CaseTerm -> Int)
-> (CaseTerm -> [CaseTerm])
-> (CaseTerm -> CaseTerm -> [CaseTerm])
-> (CaseTerm -> CaseTerm -> [CaseTerm])
-> (CaseTerm -> CaseTerm -> CaseTerm -> [CaseTerm])
-> Enum CaseTerm
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: CaseTerm -> CaseTerm
succ :: CaseTerm -> CaseTerm
$cpred :: CaseTerm -> CaseTerm
pred :: CaseTerm -> CaseTerm
$ctoEnum :: Int -> CaseTerm
toEnum :: Int -> CaseTerm
$cfromEnum :: CaseTerm -> Int
fromEnum :: CaseTerm -> Int
$cenumFrom :: CaseTerm -> [CaseTerm]
enumFrom :: CaseTerm -> [CaseTerm]
$cenumFromThen :: CaseTerm -> CaseTerm -> [CaseTerm]
enumFromThen :: CaseTerm -> CaseTerm -> [CaseTerm]
$cenumFromTo :: CaseTerm -> CaseTerm -> [CaseTerm]
enumFromTo :: CaseTerm -> CaseTerm -> [CaseTerm]
$cenumFromThenTo :: CaseTerm -> CaseTerm -> CaseTerm -> [CaseTerm]
enumFromThenTo :: CaseTerm -> CaseTerm -> CaseTerm -> [CaseTerm]
Enum, (forall x. CaseTerm -> Rep CaseTerm x)
-> (forall x. Rep CaseTerm x -> CaseTerm) -> Generic CaseTerm
forall x. Rep CaseTerm x -> CaseTerm
forall x. CaseTerm -> Rep CaseTerm x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. CaseTerm -> Rep CaseTerm x
from :: forall x. CaseTerm -> Rep CaseTerm x
$cto :: forall x. Rep CaseTerm x -> CaseTerm
to :: forall x. Rep CaseTerm x -> CaseTerm
Generic)
instance Operator CaseTerm where
operatorTable :: [(CaseTerm, String)]
operatorTable = [CaseTerm] -> [String] -> [(CaseTerm, String)]
forall a b. [a] -> [b] -> [(a, b)]
zip [CaseTerm
forall a. Bounded a => a
minBound .. CaseTerm
forall a. Bounded a => a
maxBound] [String
";;", String
";&", String
";;&"]
instance Pretty CaseTerm where
pretty :: forall ann. CaseTerm -> Doc ann
pretty = CaseTerm -> Doc ann
forall a ann. Operator a => a -> Doc ann
prettyOperator
data Redir
= Redir
{
Redir -> Maybe IODesc
redirDesc :: Maybe IODesc
, Redir -> RedirOp
redirOp :: RedirOp
, Redir -> [Span]
redirTarget :: Word
}
| Heredoc
{
Redir -> HeredocOp
heredocOp :: HeredocOp
, Redir -> String
heredocDelim :: String
, Redir -> Bool
heredocDelimQuoted :: Bool
, Redir -> [Span]
hereDocument :: Word
}
deriving (Typeable Redir
Typeable Redir
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Redir -> c Redir)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Redir)
-> (Redir -> Constr)
-> (Redir -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Redir))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Redir))
-> ((forall b. Data b => b -> b) -> Redir -> Redir)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Redir -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Redir -> r)
-> (forall u. (forall d. Data d => d -> u) -> Redir -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Redir -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Redir -> m Redir)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Redir -> m Redir)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Redir -> m Redir)
-> Data Redir
Redir -> Constr
Redir -> DataType
(forall b. Data b => b -> b) -> Redir -> Redir
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) -> Redir -> u
forall u. (forall d. Data d => d -> u) -> Redir -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Redir -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Redir -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Redir -> m Redir
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Redir -> m Redir
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Redir
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Redir -> c Redir
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Redir)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Redir)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Redir -> c Redir
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Redir -> c Redir
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Redir
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Redir
$ctoConstr :: Redir -> Constr
toConstr :: Redir -> Constr
$cdataTypeOf :: Redir -> DataType
dataTypeOf :: Redir -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Redir)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Redir)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Redir)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Redir)
$cgmapT :: (forall b. Data b => b -> b) -> Redir -> Redir
gmapT :: (forall b. Data b => b -> b) -> Redir -> Redir
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Redir -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Redir -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Redir -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Redir -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Redir -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Redir -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Redir -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Redir -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Redir -> m Redir
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Redir -> m Redir
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Redir -> m Redir
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Redir -> m Redir
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Redir -> m Redir
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Redir -> m Redir
Data, Redir -> Redir -> Bool
(Redir -> Redir -> Bool) -> (Redir -> Redir -> Bool) -> Eq Redir
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Redir -> Redir -> Bool
== :: Redir -> Redir -> Bool
$c/= :: Redir -> Redir -> Bool
/= :: Redir -> Redir -> Bool
Eq, ReadPrec [Redir]
ReadPrec Redir
Int -> ReadS Redir
ReadS [Redir]
(Int -> ReadS Redir)
-> ReadS [Redir]
-> ReadPrec Redir
-> ReadPrec [Redir]
-> Read Redir
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Redir
readsPrec :: Int -> ReadS Redir
$creadList :: ReadS [Redir]
readList :: ReadS [Redir]
$creadPrec :: ReadPrec Redir
readPrec :: ReadPrec Redir
$creadListPrec :: ReadPrec [Redir]
readListPrec :: ReadPrec [Redir]
Read, Int -> Redir -> ShowS
[Redir] -> ShowS
Redir -> String
(Int -> Redir -> ShowS)
-> (Redir -> String) -> ([Redir] -> ShowS) -> Show Redir
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Redir -> ShowS
showsPrec :: Int -> Redir -> ShowS
$cshow :: Redir -> String
show :: Redir -> String
$cshowList :: [Redir] -> ShowS
showList :: [Redir] -> ShowS
Show, Typeable, (forall x. Redir -> Rep Redir x)
-> (forall x. Rep Redir x -> Redir) -> Generic Redir
forall x. Rep Redir x -> Redir
forall x. Redir -> Rep Redir x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Redir -> Rep Redir x
from :: forall x. Redir -> Rep Redir x
$cto :: forall x. Rep Redir x -> Redir
to :: forall x. Rep Redir x -> Redir
Generic)
instance Pretty Redir where
pretty :: forall {ann}. Redir -> Doc ann
pretty Redir{[Span]
Maybe IODesc
RedirOp
redirDesc :: Redir -> Maybe IODesc
redirOp :: Redir -> RedirOp
redirTarget :: Redir -> [Span]
redirDesc :: Maybe IODesc
redirOp :: RedirOp
redirTarget :: [Span]
..} =
Maybe IODesc -> Doc ann
forall ann. Maybe IODesc -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Maybe IODesc
redirDesc Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> RedirOp -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. RedirOp -> Doc ann
pretty RedirOp
redirOp Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> [Span] -> Doc ann
forall ann. [Span] -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty [Span]
redirTarget
pretty Heredoc{Bool
String
[Span]
HeredocOp
heredocOp :: Redir -> HeredocOp
heredocDelim :: Redir -> String
heredocDelimQuoted :: Redir -> Bool
hereDocument :: Redir -> [Span]
heredocOp :: HeredocOp
heredocDelim :: String
heredocDelimQuoted :: Bool
hereDocument :: [Span]
..} =
HeredocOp -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. HeredocOp -> Doc ann
pretty HeredocOp
heredocOp Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<>
String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty (if Bool
heredocDelimQuoted
then String
"'" String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
heredocDelim String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
"'"
else String
heredocDelim)
prettyList :: forall ann. [Redir] -> Doc ann
prettyList = [Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
hsep ([Doc ann] -> Doc ann)
-> ([Redir] -> [Doc ann]) -> [Redir] -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Redir -> Doc ann) -> [Redir] -> [Doc ann]
forall a b. (a -> b) -> [a] -> [b]
map Redir -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall {ann}. Redir -> Doc ann
pretty
data IODesc
= IONumber Int
| IOVar String
deriving (Typeable IODesc
Typeable IODesc
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IODesc -> c IODesc)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c IODesc)
-> (IODesc -> Constr)
-> (IODesc -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c IODesc))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IODesc))
-> ((forall b. Data b => b -> b) -> IODesc -> IODesc)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> IODesc -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> IODesc -> r)
-> (forall u. (forall d. Data d => d -> u) -> IODesc -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> IODesc -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> IODesc -> m IODesc)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> IODesc -> m IODesc)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> IODesc -> m IODesc)
-> Data IODesc
IODesc -> Constr
IODesc -> DataType
(forall b. Data b => b -> b) -> IODesc -> IODesc
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) -> IODesc -> u
forall u. (forall d. Data d => d -> u) -> IODesc -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IODesc -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IODesc -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> IODesc -> m IODesc
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> IODesc -> m IODesc
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c IODesc
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IODesc -> c IODesc
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c IODesc)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IODesc)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IODesc -> c IODesc
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IODesc -> c IODesc
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c IODesc
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c IODesc
$ctoConstr :: IODesc -> Constr
toConstr :: IODesc -> Constr
$cdataTypeOf :: IODesc -> DataType
dataTypeOf :: IODesc -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c IODesc)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c IODesc)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IODesc)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IODesc)
$cgmapT :: (forall b. Data b => b -> b) -> IODesc -> IODesc
gmapT :: (forall b. Data b => b -> b) -> IODesc -> IODesc
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IODesc -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IODesc -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IODesc -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IODesc -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> IODesc -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> IODesc -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> IODesc -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> IODesc -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> IODesc -> m IODesc
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> IODesc -> m IODesc
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> IODesc -> m IODesc
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> IODesc -> m IODesc
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> IODesc -> m IODesc
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> IODesc -> m IODesc
Data, IODesc -> IODesc -> Bool
(IODesc -> IODesc -> Bool)
-> (IODesc -> IODesc -> Bool) -> Eq IODesc
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: IODesc -> IODesc -> Bool
== :: IODesc -> IODesc -> Bool
$c/= :: IODesc -> IODesc -> Bool
/= :: IODesc -> IODesc -> Bool
Eq, ReadPrec [IODesc]
ReadPrec IODesc
Int -> ReadS IODesc
ReadS [IODesc]
(Int -> ReadS IODesc)
-> ReadS [IODesc]
-> ReadPrec IODesc
-> ReadPrec [IODesc]
-> Read IODesc
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS IODesc
readsPrec :: Int -> ReadS IODesc
$creadList :: ReadS [IODesc]
readList :: ReadS [IODesc]
$creadPrec :: ReadPrec IODesc
readPrec :: ReadPrec IODesc
$creadListPrec :: ReadPrec [IODesc]
readListPrec :: ReadPrec [IODesc]
Read, Int -> IODesc -> ShowS
[IODesc] -> ShowS
IODesc -> String
(Int -> IODesc -> ShowS)
-> (IODesc -> String) -> ([IODesc] -> ShowS) -> Show IODesc
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> IODesc -> ShowS
showsPrec :: Int -> IODesc -> ShowS
$cshow :: IODesc -> String
show :: IODesc -> String
$cshowList :: [IODesc] -> ShowS
showList :: [IODesc] -> ShowS
Show, Typeable, (forall x. IODesc -> Rep IODesc x)
-> (forall x. Rep IODesc x -> IODesc) -> Generic IODesc
forall x. Rep IODesc x -> IODesc
forall x. IODesc -> Rep IODesc x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. IODesc -> Rep IODesc x
from :: forall x. IODesc -> Rep IODesc x
$cto :: forall x. Rep IODesc x -> IODesc
to :: forall x. Rep IODesc x -> IODesc
Generic)
instance Pretty IODesc where
pretty :: forall ann. IODesc -> Doc ann
pretty (IONumber Int
n) = Int -> Doc ann
forall ann. Int -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Int
n
pretty (IOVar String
n) = Doc ann
"{" Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
n Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Doc ann
"}"
data RedirOp
= In
| Out
| OutOr
| Append
| AndOut
| AndAppend
| HereString
| InAnd
| OutAnd
| InOut
deriving (Typeable RedirOp
Typeable RedirOp
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RedirOp -> c RedirOp)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RedirOp)
-> (RedirOp -> Constr)
-> (RedirOp -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RedirOp))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RedirOp))
-> ((forall b. Data b => b -> b) -> RedirOp -> RedirOp)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RedirOp -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RedirOp -> r)
-> (forall u. (forall d. Data d => d -> u) -> RedirOp -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> RedirOp -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RedirOp -> m RedirOp)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RedirOp -> m RedirOp)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RedirOp -> m RedirOp)
-> Data RedirOp
RedirOp -> Constr
RedirOp -> DataType
(forall b. Data b => b -> b) -> RedirOp -> RedirOp
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) -> RedirOp -> u
forall u. (forall d. Data d => d -> u) -> RedirOp -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RedirOp -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RedirOp -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RedirOp -> m RedirOp
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RedirOp -> m RedirOp
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RedirOp
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RedirOp -> c RedirOp
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RedirOp)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RedirOp)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RedirOp -> c RedirOp
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RedirOp -> c RedirOp
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RedirOp
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RedirOp
$ctoConstr :: RedirOp -> Constr
toConstr :: RedirOp -> Constr
$cdataTypeOf :: RedirOp -> DataType
dataTypeOf :: RedirOp -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RedirOp)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RedirOp)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RedirOp)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RedirOp)
$cgmapT :: (forall b. Data b => b -> b) -> RedirOp -> RedirOp
gmapT :: (forall b. Data b => b -> b) -> RedirOp -> RedirOp
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RedirOp -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RedirOp -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RedirOp -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RedirOp -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> RedirOp -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> RedirOp -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> RedirOp -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> RedirOp -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RedirOp -> m RedirOp
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RedirOp -> m RedirOp
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RedirOp -> m RedirOp
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RedirOp -> m RedirOp
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RedirOp -> m RedirOp
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RedirOp -> m RedirOp
Data, RedirOp -> RedirOp -> Bool
(RedirOp -> RedirOp -> Bool)
-> (RedirOp -> RedirOp -> Bool) -> Eq RedirOp
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RedirOp -> RedirOp -> Bool
== :: RedirOp -> RedirOp -> Bool
$c/= :: RedirOp -> RedirOp -> Bool
/= :: RedirOp -> RedirOp -> Bool
Eq, Eq RedirOp
Eq RedirOp
-> (RedirOp -> RedirOp -> Ordering)
-> (RedirOp -> RedirOp -> Bool)
-> (RedirOp -> RedirOp -> Bool)
-> (RedirOp -> RedirOp -> Bool)
-> (RedirOp -> RedirOp -> Bool)
-> (RedirOp -> RedirOp -> RedirOp)
-> (RedirOp -> RedirOp -> RedirOp)
-> Ord RedirOp
RedirOp -> RedirOp -> Bool
RedirOp -> RedirOp -> Ordering
RedirOp -> RedirOp -> RedirOp
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: RedirOp -> RedirOp -> Ordering
compare :: RedirOp -> RedirOp -> Ordering
$c< :: RedirOp -> RedirOp -> Bool
< :: RedirOp -> RedirOp -> Bool
$c<= :: RedirOp -> RedirOp -> Bool
<= :: RedirOp -> RedirOp -> Bool
$c> :: RedirOp -> RedirOp -> Bool
> :: RedirOp -> RedirOp -> Bool
$c>= :: RedirOp -> RedirOp -> Bool
>= :: RedirOp -> RedirOp -> Bool
$cmax :: RedirOp -> RedirOp -> RedirOp
max :: RedirOp -> RedirOp -> RedirOp
$cmin :: RedirOp -> RedirOp -> RedirOp
min :: RedirOp -> RedirOp -> RedirOp
Ord, ReadPrec [RedirOp]
ReadPrec RedirOp
Int -> ReadS RedirOp
ReadS [RedirOp]
(Int -> ReadS RedirOp)
-> ReadS [RedirOp]
-> ReadPrec RedirOp
-> ReadPrec [RedirOp]
-> Read RedirOp
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS RedirOp
readsPrec :: Int -> ReadS RedirOp
$creadList :: ReadS [RedirOp]
readList :: ReadS [RedirOp]
$creadPrec :: ReadPrec RedirOp
readPrec :: ReadPrec RedirOp
$creadListPrec :: ReadPrec [RedirOp]
readListPrec :: ReadPrec [RedirOp]
Read, Int -> RedirOp -> ShowS
[RedirOp] -> ShowS
RedirOp -> String
(Int -> RedirOp -> ShowS)
-> (RedirOp -> String) -> ([RedirOp] -> ShowS) -> Show RedirOp
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RedirOp -> ShowS
showsPrec :: Int -> RedirOp -> ShowS
$cshow :: RedirOp -> String
show :: RedirOp -> String
$cshowList :: [RedirOp] -> ShowS
showList :: [RedirOp] -> ShowS
Show, Typeable, Int -> RedirOp
RedirOp -> Int
RedirOp -> [RedirOp]
RedirOp -> RedirOp
RedirOp -> RedirOp -> [RedirOp]
RedirOp -> RedirOp -> RedirOp -> [RedirOp]
(RedirOp -> RedirOp)
-> (RedirOp -> RedirOp)
-> (Int -> RedirOp)
-> (RedirOp -> Int)
-> (RedirOp -> [RedirOp])
-> (RedirOp -> RedirOp -> [RedirOp])
-> (RedirOp -> RedirOp -> [RedirOp])
-> (RedirOp -> RedirOp -> RedirOp -> [RedirOp])
-> Enum RedirOp
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: RedirOp -> RedirOp
succ :: RedirOp -> RedirOp
$cpred :: RedirOp -> RedirOp
pred :: RedirOp -> RedirOp
$ctoEnum :: Int -> RedirOp
toEnum :: Int -> RedirOp
$cfromEnum :: RedirOp -> Int
fromEnum :: RedirOp -> Int
$cenumFrom :: RedirOp -> [RedirOp]
enumFrom :: RedirOp -> [RedirOp]
$cenumFromThen :: RedirOp -> RedirOp -> [RedirOp]
enumFromThen :: RedirOp -> RedirOp -> [RedirOp]
$cenumFromTo :: RedirOp -> RedirOp -> [RedirOp]
enumFromTo :: RedirOp -> RedirOp -> [RedirOp]
$cenumFromThenTo :: RedirOp -> RedirOp -> RedirOp -> [RedirOp]
enumFromThenTo :: RedirOp -> RedirOp -> RedirOp -> [RedirOp]
Enum, RedirOp
RedirOp -> RedirOp -> Bounded RedirOp
forall a. a -> a -> Bounded a
$cminBound :: RedirOp
minBound :: RedirOp
$cmaxBound :: RedirOp
maxBound :: RedirOp
Bounded, (forall x. RedirOp -> Rep RedirOp x)
-> (forall x. Rep RedirOp x -> RedirOp) -> Generic RedirOp
forall x. Rep RedirOp x -> RedirOp
forall x. RedirOp -> Rep RedirOp x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. RedirOp -> Rep RedirOp x
from :: forall x. RedirOp -> Rep RedirOp x
$cto :: forall x. Rep RedirOp x -> RedirOp
to :: forall x. Rep RedirOp x -> RedirOp
Generic)
instance Operator RedirOp where
operatorTable :: [(RedirOp, String)]
operatorTable = [RedirOp] -> [String] -> [(RedirOp, String)]
forall a b. [a] -> [b] -> [(a, b)]
zip [RedirOp
forall a. Bounded a => a
minBound .. RedirOp
forall a. Bounded a => a
maxBound]
[String
"<", String
">", String
">|", String
">>", String
"&>", String
"&>>", String
"<<<", String
"<&", String
">&", String
"<>"]
instance Pretty RedirOp where
pretty :: forall ann. RedirOp -> Doc ann
pretty = RedirOp -> Doc ann
forall a ann. Operator a => a -> Doc ann
prettyOperator
data HeredocOp
= Here
| HereStrip
deriving (Typeable HeredocOp
Typeable HeredocOp
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HeredocOp -> c HeredocOp)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HeredocOp)
-> (HeredocOp -> Constr)
-> (HeredocOp -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c HeredocOp))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HeredocOp))
-> ((forall b. Data b => b -> b) -> HeredocOp -> HeredocOp)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> HeredocOp -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> HeredocOp -> r)
-> (forall u. (forall d. Data d => d -> u) -> HeredocOp -> [u])
-> (forall u.
Int -> (forall d. Data d => d -> u) -> HeredocOp -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> HeredocOp -> m HeredocOp)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HeredocOp -> m HeredocOp)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HeredocOp -> m HeredocOp)
-> Data HeredocOp
HeredocOp -> Constr
HeredocOp -> DataType
(forall b. Data b => b -> b) -> HeredocOp -> HeredocOp
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) -> HeredocOp -> u
forall u. (forall d. Data d => d -> u) -> HeredocOp -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> HeredocOp -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> HeredocOp -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> HeredocOp -> m HeredocOp
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HeredocOp -> m HeredocOp
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HeredocOp
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HeredocOp -> c HeredocOp
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c HeredocOp)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HeredocOp)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HeredocOp -> c HeredocOp
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HeredocOp -> c HeredocOp
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HeredocOp
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HeredocOp
$ctoConstr :: HeredocOp -> Constr
toConstr :: HeredocOp -> Constr
$cdataTypeOf :: HeredocOp -> DataType
dataTypeOf :: HeredocOp -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c HeredocOp)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c HeredocOp)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HeredocOp)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HeredocOp)
$cgmapT :: (forall b. Data b => b -> b) -> HeredocOp -> HeredocOp
gmapT :: (forall b. Data b => b -> b) -> HeredocOp -> HeredocOp
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> HeredocOp -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> HeredocOp -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> HeredocOp -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> HeredocOp -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> HeredocOp -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> HeredocOp -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HeredocOp -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HeredocOp -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> HeredocOp -> m HeredocOp
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> HeredocOp -> m HeredocOp
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HeredocOp -> m HeredocOp
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HeredocOp -> m HeredocOp
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HeredocOp -> m HeredocOp
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HeredocOp -> m HeredocOp
Data, HeredocOp -> HeredocOp -> Bool
(HeredocOp -> HeredocOp -> Bool)
-> (HeredocOp -> HeredocOp -> Bool) -> Eq HeredocOp
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: HeredocOp -> HeredocOp -> Bool
== :: HeredocOp -> HeredocOp -> Bool
$c/= :: HeredocOp -> HeredocOp -> Bool
/= :: HeredocOp -> HeredocOp -> Bool
Eq, Eq HeredocOp
Eq HeredocOp
-> (HeredocOp -> HeredocOp -> Ordering)
-> (HeredocOp -> HeredocOp -> Bool)
-> (HeredocOp -> HeredocOp -> Bool)
-> (HeredocOp -> HeredocOp -> Bool)
-> (HeredocOp -> HeredocOp -> Bool)
-> (HeredocOp -> HeredocOp -> HeredocOp)
-> (HeredocOp -> HeredocOp -> HeredocOp)
-> Ord HeredocOp
HeredocOp -> HeredocOp -> Bool
HeredocOp -> HeredocOp -> Ordering
HeredocOp -> HeredocOp -> HeredocOp
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: HeredocOp -> HeredocOp -> Ordering
compare :: HeredocOp -> HeredocOp -> Ordering
$c< :: HeredocOp -> HeredocOp -> Bool
< :: HeredocOp -> HeredocOp -> Bool
$c<= :: HeredocOp -> HeredocOp -> Bool
<= :: HeredocOp -> HeredocOp -> Bool
$c> :: HeredocOp -> HeredocOp -> Bool
> :: HeredocOp -> HeredocOp -> Bool
$c>= :: HeredocOp -> HeredocOp -> Bool
>= :: HeredocOp -> HeredocOp -> Bool
$cmax :: HeredocOp -> HeredocOp -> HeredocOp
max :: HeredocOp -> HeredocOp -> HeredocOp
$cmin :: HeredocOp -> HeredocOp -> HeredocOp
min :: HeredocOp -> HeredocOp -> HeredocOp
Ord, ReadPrec [HeredocOp]
ReadPrec HeredocOp
Int -> ReadS HeredocOp
ReadS [HeredocOp]
(Int -> ReadS HeredocOp)
-> ReadS [HeredocOp]
-> ReadPrec HeredocOp
-> ReadPrec [HeredocOp]
-> Read HeredocOp
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS HeredocOp
readsPrec :: Int -> ReadS HeredocOp
$creadList :: ReadS [HeredocOp]
readList :: ReadS [HeredocOp]
$creadPrec :: ReadPrec HeredocOp
readPrec :: ReadPrec HeredocOp
$creadListPrec :: ReadPrec [HeredocOp]
readListPrec :: ReadPrec [HeredocOp]
Read, Int -> HeredocOp -> ShowS
[HeredocOp] -> ShowS
HeredocOp -> String
(Int -> HeredocOp -> ShowS)
-> (HeredocOp -> String)
-> ([HeredocOp] -> ShowS)
-> Show HeredocOp
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> HeredocOp -> ShowS
showsPrec :: Int -> HeredocOp -> ShowS
$cshow :: HeredocOp -> String
show :: HeredocOp -> String
$cshowList :: [HeredocOp] -> ShowS
showList :: [HeredocOp] -> ShowS
Show, Typeable, Int -> HeredocOp
HeredocOp -> Int
HeredocOp -> [HeredocOp]
HeredocOp -> HeredocOp
HeredocOp -> HeredocOp -> [HeredocOp]
HeredocOp -> HeredocOp -> HeredocOp -> [HeredocOp]
(HeredocOp -> HeredocOp)
-> (HeredocOp -> HeredocOp)
-> (Int -> HeredocOp)
-> (HeredocOp -> Int)
-> (HeredocOp -> [HeredocOp])
-> (HeredocOp -> HeredocOp -> [HeredocOp])
-> (HeredocOp -> HeredocOp -> [HeredocOp])
-> (HeredocOp -> HeredocOp -> HeredocOp -> [HeredocOp])
-> Enum HeredocOp
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: HeredocOp -> HeredocOp
succ :: HeredocOp -> HeredocOp
$cpred :: HeredocOp -> HeredocOp
pred :: HeredocOp -> HeredocOp
$ctoEnum :: Int -> HeredocOp
toEnum :: Int -> HeredocOp
$cfromEnum :: HeredocOp -> Int
fromEnum :: HeredocOp -> Int
$cenumFrom :: HeredocOp -> [HeredocOp]
enumFrom :: HeredocOp -> [HeredocOp]
$cenumFromThen :: HeredocOp -> HeredocOp -> [HeredocOp]
enumFromThen :: HeredocOp -> HeredocOp -> [HeredocOp]
$cenumFromTo :: HeredocOp -> HeredocOp -> [HeredocOp]
enumFromTo :: HeredocOp -> HeredocOp -> [HeredocOp]
$cenumFromThenTo :: HeredocOp -> HeredocOp -> HeredocOp -> [HeredocOp]
enumFromThenTo :: HeredocOp -> HeredocOp -> HeredocOp -> [HeredocOp]
Enum, HeredocOp
HeredocOp -> HeredocOp -> Bounded HeredocOp
forall a. a -> a -> Bounded a
$cminBound :: HeredocOp
minBound :: HeredocOp
$cmaxBound :: HeredocOp
maxBound :: HeredocOp
Bounded, (forall x. HeredocOp -> Rep HeredocOp x)
-> (forall x. Rep HeredocOp x -> HeredocOp) -> Generic HeredocOp
forall x. Rep HeredocOp x -> HeredocOp
forall x. HeredocOp -> Rep HeredocOp x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. HeredocOp -> Rep HeredocOp x
from :: forall x. HeredocOp -> Rep HeredocOp x
$cto :: forall x. Rep HeredocOp x -> HeredocOp
to :: forall x. Rep HeredocOp x -> HeredocOp
Generic)
instance Operator HeredocOp where
operatorTable :: [(HeredocOp, String)]
operatorTable = [HeredocOp] -> [String] -> [(HeredocOp, String)]
forall a b. [a] -> [b] -> [(a, b)]
zip [HeredocOp
Here, HeredocOp
HereStrip] [String
"<<", String
"<<-"]
instance Pretty HeredocOp where
pretty :: forall ann. HeredocOp -> Doc ann
pretty = HeredocOp -> Doc ann
forall a ann. Operator a => a -> Doc ann
prettyOperator
newtype List = List [Statement]
deriving (Typeable List
Typeable List
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> List -> c List)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c List)
-> (List -> Constr)
-> (List -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c List))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c List))
-> ((forall b. Data b => b -> b) -> List -> List)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> List -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> List -> r)
-> (forall u. (forall d. Data d => d -> u) -> List -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> List -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> List -> m List)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> List -> m List)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> List -> m List)
-> Data List
List -> Constr
List -> DataType
(forall b. Data b => b -> b) -> List -> List
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) -> List -> u
forall u. (forall d. Data d => d -> u) -> List -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> List -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> List -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> List -> m List
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> List -> m List
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c List
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> List -> c List
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c List)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c List)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> List -> c List
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> List -> c List
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c List
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c List
$ctoConstr :: List -> Constr
toConstr :: List -> Constr
$cdataTypeOf :: List -> DataType
dataTypeOf :: List -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c List)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c List)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c List)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c List)
$cgmapT :: (forall b. Data b => b -> b) -> List -> List
gmapT :: (forall b. Data b => b -> b) -> List -> List
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> List -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> List -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> List -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> List -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> List -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> List -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> List -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> List -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> List -> m List
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> List -> m List
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> List -> m List
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> List -> m List
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> List -> m List
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> List -> m List
Data, List -> List -> Bool
(List -> List -> Bool) -> (List -> List -> Bool) -> Eq List
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: List -> List -> Bool
== :: List -> List -> Bool
$c/= :: List -> List -> Bool
/= :: List -> List -> Bool
Eq, Semigroup List
List
Semigroup List
-> List
-> (List -> List -> List)
-> ([List] -> List)
-> Monoid List
[List] -> List
List -> List -> List
forall a.
Semigroup a -> a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
$cmempty :: List
mempty :: List
$cmappend :: List -> List -> List
mappend :: List -> List -> List
$cmconcat :: [List] -> List
mconcat :: [List] -> List
Monoid, ReadPrec [List]
ReadPrec List
Int -> ReadS List
ReadS [List]
(Int -> ReadS List)
-> ReadS [List] -> ReadPrec List -> ReadPrec [List] -> Read List
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS List
readsPrec :: Int -> ReadS List
$creadList :: ReadS [List]
readList :: ReadS [List]
$creadPrec :: ReadPrec List
readPrec :: ReadPrec List
$creadListPrec :: ReadPrec [List]
readListPrec :: ReadPrec [List]
Read, NonEmpty List -> List
List -> List -> List
(List -> List -> List)
-> (NonEmpty List -> List)
-> (forall b. Integral b => b -> List -> List)
-> Semigroup List
forall b. Integral b => b -> List -> List
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
$c<> :: List -> List -> List
<> :: List -> List -> List
$csconcat :: NonEmpty List -> List
sconcat :: NonEmpty List -> List
$cstimes :: forall b. Integral b => b -> List -> List
stimes :: forall b. Integral b => b -> List -> List
Semigroup, Int -> List -> ShowS
[List] -> ShowS
List -> String
(Int -> List -> ShowS)
-> (List -> String) -> ([List] -> ShowS) -> Show List
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> List -> ShowS
showsPrec :: Int -> List -> ShowS
$cshow :: List -> String
show :: List -> String
$cshowList :: [List] -> ShowS
showList :: [List] -> ShowS
Show, Typeable, (forall x. List -> Rep List x)
-> (forall x. Rep List x -> List) -> Generic List
forall x. Rep List x -> List
forall x. List -> Rep List x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. List -> Rep List x
from :: forall x. List -> Rep List x
$cto :: forall x. Rep List x -> List
to :: forall x. Rep List x -> List
Generic)
instance Pretty List where
pretty :: forall ann. List -> Doc ann
pretty (List [Statement]
as) = [Statement] -> Doc ann
forall ann. [Statement] -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty [Statement]
as
data Statement = Statement AndOr ListTerm
deriving (Typeable Statement
Typeable Statement
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Statement -> c Statement)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Statement)
-> (Statement -> Constr)
-> (Statement -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Statement))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Statement))
-> ((forall b. Data b => b -> b) -> Statement -> Statement)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Statement -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Statement -> r)
-> (forall u. (forall d. Data d => d -> u) -> Statement -> [u])
-> (forall u.
Int -> (forall d. Data d => d -> u) -> Statement -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Statement -> m Statement)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Statement -> m Statement)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Statement -> m Statement)
-> Data Statement
Statement -> Constr
Statement -> DataType
(forall b. Data b => b -> b) -> Statement -> Statement
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) -> Statement -> u
forall u. (forall d. Data d => d -> u) -> Statement -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Statement -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Statement -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Statement -> m Statement
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Statement -> m Statement
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Statement
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Statement -> c Statement
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Statement)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Statement)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Statement -> c Statement
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Statement -> c Statement
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Statement
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Statement
$ctoConstr :: Statement -> Constr
toConstr :: Statement -> Constr
$cdataTypeOf :: Statement -> DataType
dataTypeOf :: Statement -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Statement)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Statement)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Statement)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Statement)
$cgmapT :: (forall b. Data b => b -> b) -> Statement -> Statement
gmapT :: (forall b. Data b => b -> b) -> Statement -> Statement
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Statement -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Statement -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Statement -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Statement -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Statement -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Statement -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Statement -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Statement -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Statement -> m Statement
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Statement -> m Statement
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Statement -> m Statement
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Statement -> m Statement
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Statement -> m Statement
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Statement -> m Statement
Data, Statement -> Statement -> Bool
(Statement -> Statement -> Bool)
-> (Statement -> Statement -> Bool) -> Eq Statement
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Statement -> Statement -> Bool
== :: Statement -> Statement -> Bool
$c/= :: Statement -> Statement -> Bool
/= :: Statement -> Statement -> Bool
Eq, ReadPrec [Statement]
ReadPrec Statement
Int -> ReadS Statement
ReadS [Statement]
(Int -> ReadS Statement)
-> ReadS [Statement]
-> ReadPrec Statement
-> ReadPrec [Statement]
-> Read Statement
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Statement
readsPrec :: Int -> ReadS Statement
$creadList :: ReadS [Statement]
readList :: ReadS [Statement]
$creadPrec :: ReadPrec Statement
readPrec :: ReadPrec Statement
$creadListPrec :: ReadPrec [Statement]
readListPrec :: ReadPrec [Statement]
Read, Int -> Statement -> ShowS
[Statement] -> ShowS
Statement -> String
(Int -> Statement -> ShowS)
-> (Statement -> String)
-> ([Statement] -> ShowS)
-> Show Statement
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Statement -> ShowS
showsPrec :: Int -> Statement -> ShowS
$cshow :: Statement -> String
show :: Statement -> String
$cshowList :: [Statement] -> ShowS
showList :: [Statement] -> ShowS
Show, Typeable, (forall x. Statement -> Rep Statement x)
-> (forall x. Rep Statement x -> Statement) -> Generic Statement
forall x. Rep Statement x -> Statement
forall x. Statement -> Rep Statement x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Statement -> Rep Statement x
from :: forall x. Statement -> Rep Statement x
$cto :: forall x. Rep Statement x -> Statement
to :: forall x. Rep Statement x -> Statement
Generic)
instance Pretty Statement where
pretty :: forall ann. Statement -> Doc ann
pretty = BashDoc ann -> Doc ann
forall ann. BashDoc ann -> Doc ann
prettyBashDoc (BashDoc ann -> Doc ann)
-> (Statement -> BashDoc ann) -> Statement -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Statement -> BashDoc ann
forall ann. Statement -> BashDoc ann
forall a ann. ToBashDoc a => a -> BashDoc ann
toBashDoc
prettyList :: forall ann. [Statement] -> Doc ann
prettyList = (Statement -> Doc ann -> Doc ann)
-> Doc ann -> [Statement] -> Doc ann
forall a b. (a -> b -> b) -> b -> [a] -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr Statement -> Doc ann -> Doc ann
forall {ann}. Statement -> Doc ann -> Doc ann
f Doc ann
forall a. Monoid a => a
mempty
where
f :: Statement -> Doc ann -> Doc ann
f a :: Statement
a@(Statement AndOr
_ ListTerm
Sequential) Doc ann
b = Statement -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Statement -> Doc ann
pretty Statement
a Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
$++$ Doc ann
b
f a :: Statement
a@(Statement AndOr
_ ListTerm
Asynchronous) Doc ann
b = Statement -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Statement -> Doc ann
pretty Statement
a Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<++> Doc ann
b
instance ToBashDoc Statement where
toBashDoc :: forall ann. Statement -> BashDoc ann
toBashDoc (Statement AndOr
l ListTerm
lt) = AndOr -> BashDoc ann
forall ann. AndOr -> BashDoc ann
forall a ann. ToBashDoc a => a -> BashDoc ann
toBashDoc AndOr
l BashDoc ann -> BashDoc ann -> BashDoc ann
forall a. Semigroup a => a -> a -> a
<> ListTerm -> BashDoc ann
forall ann. ListTerm -> BashDoc ann
forall a ann. ToBashDoc a => a -> BashDoc ann
toBashDoc ListTerm
lt
data ListTerm
= Sequential
| Asynchronous
deriving (Typeable ListTerm
Typeable ListTerm
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ListTerm -> c ListTerm)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ListTerm)
-> (ListTerm -> Constr)
-> (ListTerm -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ListTerm))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ListTerm))
-> ((forall b. Data b => b -> b) -> ListTerm -> ListTerm)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ListTerm -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ListTerm -> r)
-> (forall u. (forall d. Data d => d -> u) -> ListTerm -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> ListTerm -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ListTerm -> m ListTerm)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ListTerm -> m ListTerm)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ListTerm -> m ListTerm)
-> Data ListTerm
ListTerm -> Constr
ListTerm -> DataType
(forall b. Data b => b -> b) -> ListTerm -> ListTerm
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) -> ListTerm -> u
forall u. (forall d. Data d => d -> u) -> ListTerm -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ListTerm -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ListTerm -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ListTerm -> m ListTerm
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ListTerm -> m ListTerm
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ListTerm
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ListTerm -> c ListTerm
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ListTerm)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ListTerm)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ListTerm -> c ListTerm
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ListTerm -> c ListTerm
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ListTerm
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ListTerm
$ctoConstr :: ListTerm -> Constr
toConstr :: ListTerm -> Constr
$cdataTypeOf :: ListTerm -> DataType
dataTypeOf :: ListTerm -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ListTerm)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ListTerm)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ListTerm)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ListTerm)
$cgmapT :: (forall b. Data b => b -> b) -> ListTerm -> ListTerm
gmapT :: (forall b. Data b => b -> b) -> ListTerm -> ListTerm
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ListTerm -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ListTerm -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ListTerm -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ListTerm -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ListTerm -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ListTerm -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ListTerm -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ListTerm -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ListTerm -> m ListTerm
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ListTerm -> m ListTerm
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ListTerm -> m ListTerm
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ListTerm -> m ListTerm
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ListTerm -> m ListTerm
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ListTerm -> m ListTerm
Data, ListTerm -> ListTerm -> Bool
(ListTerm -> ListTerm -> Bool)
-> (ListTerm -> ListTerm -> Bool) -> Eq ListTerm
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ListTerm -> ListTerm -> Bool
== :: ListTerm -> ListTerm -> Bool
$c/= :: ListTerm -> ListTerm -> Bool
/= :: ListTerm -> ListTerm -> Bool
Eq, Eq ListTerm
Eq ListTerm
-> (ListTerm -> ListTerm -> Ordering)
-> (ListTerm -> ListTerm -> Bool)
-> (ListTerm -> ListTerm -> Bool)
-> (ListTerm -> ListTerm -> Bool)
-> (ListTerm -> ListTerm -> Bool)
-> (ListTerm -> ListTerm -> ListTerm)
-> (ListTerm -> ListTerm -> ListTerm)
-> Ord ListTerm
ListTerm -> ListTerm -> Bool
ListTerm -> ListTerm -> Ordering
ListTerm -> ListTerm -> ListTerm
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ListTerm -> ListTerm -> Ordering
compare :: ListTerm -> ListTerm -> Ordering
$c< :: ListTerm -> ListTerm -> Bool
< :: ListTerm -> ListTerm -> Bool
$c<= :: ListTerm -> ListTerm -> Bool
<= :: ListTerm -> ListTerm -> Bool
$c> :: ListTerm -> ListTerm -> Bool
> :: ListTerm -> ListTerm -> Bool
$c>= :: ListTerm -> ListTerm -> Bool
>= :: ListTerm -> ListTerm -> Bool
$cmax :: ListTerm -> ListTerm -> ListTerm
max :: ListTerm -> ListTerm -> ListTerm
$cmin :: ListTerm -> ListTerm -> ListTerm
min :: ListTerm -> ListTerm -> ListTerm
Ord, ReadPrec [ListTerm]
ReadPrec ListTerm
Int -> ReadS ListTerm
ReadS [ListTerm]
(Int -> ReadS ListTerm)
-> ReadS [ListTerm]
-> ReadPrec ListTerm
-> ReadPrec [ListTerm]
-> Read ListTerm
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ListTerm
readsPrec :: Int -> ReadS ListTerm
$creadList :: ReadS [ListTerm]
readList :: ReadS [ListTerm]
$creadPrec :: ReadPrec ListTerm
readPrec :: ReadPrec ListTerm
$creadListPrec :: ReadPrec [ListTerm]
readListPrec :: ReadPrec [ListTerm]
Read, Int -> ListTerm -> ShowS
[ListTerm] -> ShowS
ListTerm -> String
(Int -> ListTerm -> ShowS)
-> (ListTerm -> String) -> ([ListTerm] -> ShowS) -> Show ListTerm
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ListTerm -> ShowS
showsPrec :: Int -> ListTerm -> ShowS
$cshow :: ListTerm -> String
show :: ListTerm -> String
$cshowList :: [ListTerm] -> ShowS
showList :: [ListTerm] -> ShowS
Show, Typeable, ListTerm
ListTerm -> ListTerm -> Bounded ListTerm
forall a. a -> a -> Bounded a
$cminBound :: ListTerm
minBound :: ListTerm
$cmaxBound :: ListTerm
maxBound :: ListTerm
Bounded, Int -> ListTerm
ListTerm -> Int
ListTerm -> [ListTerm]
ListTerm -> ListTerm
ListTerm -> ListTerm -> [ListTerm]
ListTerm -> ListTerm -> ListTerm -> [ListTerm]
(ListTerm -> ListTerm)
-> (ListTerm -> ListTerm)
-> (Int -> ListTerm)
-> (ListTerm -> Int)
-> (ListTerm -> [ListTerm])
-> (ListTerm -> ListTerm -> [ListTerm])
-> (ListTerm -> ListTerm -> [ListTerm])
-> (ListTerm -> ListTerm -> ListTerm -> [ListTerm])
-> Enum ListTerm
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: ListTerm -> ListTerm
succ :: ListTerm -> ListTerm
$cpred :: ListTerm -> ListTerm
pred :: ListTerm -> ListTerm
$ctoEnum :: Int -> ListTerm
toEnum :: Int -> ListTerm
$cfromEnum :: ListTerm -> Int
fromEnum :: ListTerm -> Int
$cenumFrom :: ListTerm -> [ListTerm]
enumFrom :: ListTerm -> [ListTerm]
$cenumFromThen :: ListTerm -> ListTerm -> [ListTerm]
enumFromThen :: ListTerm -> ListTerm -> [ListTerm]
$cenumFromTo :: ListTerm -> ListTerm -> [ListTerm]
enumFromTo :: ListTerm -> ListTerm -> [ListTerm]
$cenumFromThenTo :: ListTerm -> ListTerm -> ListTerm -> [ListTerm]
enumFromThenTo :: ListTerm -> ListTerm -> ListTerm -> [ListTerm]
Enum, (forall x. ListTerm -> Rep ListTerm x)
-> (forall x. Rep ListTerm x -> ListTerm) -> Generic ListTerm
forall x. Rep ListTerm x -> ListTerm
forall x. ListTerm -> Rep ListTerm x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ListTerm -> Rep ListTerm x
from :: forall x. ListTerm -> Rep ListTerm x
$cto :: forall x. Rep ListTerm x -> ListTerm
to :: forall x. Rep ListTerm x -> ListTerm
Generic)
instance Operator ListTerm where
operatorTable :: [(ListTerm, String)]
operatorTable =
[ (ListTerm
Sequential , String
";" )
, (ListTerm
Sequential , String
"\n")
, (ListTerm
Asynchronous, String
"&" )
]
instance Pretty ListTerm where
pretty :: forall ann. ListTerm -> Doc ann
pretty = ListTerm -> Doc ann
forall a ann. Operator a => a -> Doc ann
prettyOperator
instance ToBashDoc ListTerm where
toBashDoc :: forall ann. ListTerm -> BashDoc ann
toBashDoc ListTerm
Sequential = Doc ann -> BashDoc ann
forall ann. Doc ann -> BashDoc ann
docOp Doc ann
";"
toBashDoc ListTerm
Asynchronous = Doc ann -> BashDoc ann
forall ann. Doc ann -> BashDoc ann
docOp Doc ann
"&"
data AndOr
= Last Pipeline
| And Pipeline AndOr
| Or Pipeline AndOr
deriving (Typeable AndOr
Typeable AndOr
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AndOr -> c AndOr)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AndOr)
-> (AndOr -> Constr)
-> (AndOr -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AndOr))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AndOr))
-> ((forall b. Data b => b -> b) -> AndOr -> AndOr)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AndOr -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AndOr -> r)
-> (forall u. (forall d. Data d => d -> u) -> AndOr -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> AndOr -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> AndOr -> m AndOr)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AndOr -> m AndOr)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AndOr -> m AndOr)
-> Data AndOr
AndOr -> Constr
AndOr -> DataType
(forall b. Data b => b -> b) -> AndOr -> AndOr
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) -> AndOr -> u
forall u. (forall d. Data d => d -> u) -> AndOr -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AndOr -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AndOr -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> AndOr -> m AndOr
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AndOr -> m AndOr
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AndOr
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AndOr -> c AndOr
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AndOr)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AndOr)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AndOr -> c AndOr
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AndOr -> c AndOr
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AndOr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AndOr
$ctoConstr :: AndOr -> Constr
toConstr :: AndOr -> Constr
$cdataTypeOf :: AndOr -> DataType
dataTypeOf :: AndOr -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AndOr)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AndOr)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AndOr)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AndOr)
$cgmapT :: (forall b. Data b => b -> b) -> AndOr -> AndOr
gmapT :: (forall b. Data b => b -> b) -> AndOr -> AndOr
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AndOr -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AndOr -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AndOr -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AndOr -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> AndOr -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> AndOr -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> AndOr -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> AndOr -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> AndOr -> m AndOr
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> AndOr -> m AndOr
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AndOr -> m AndOr
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AndOr -> m AndOr
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AndOr -> m AndOr
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AndOr -> m AndOr
Data, AndOr -> AndOr -> Bool
(AndOr -> AndOr -> Bool) -> (AndOr -> AndOr -> Bool) -> Eq AndOr
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AndOr -> AndOr -> Bool
== :: AndOr -> AndOr -> Bool
$c/= :: AndOr -> AndOr -> Bool
/= :: AndOr -> AndOr -> Bool
Eq, ReadPrec [AndOr]
ReadPrec AndOr
Int -> ReadS AndOr
ReadS [AndOr]
(Int -> ReadS AndOr)
-> ReadS [AndOr]
-> ReadPrec AndOr
-> ReadPrec [AndOr]
-> Read AndOr
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS AndOr
readsPrec :: Int -> ReadS AndOr
$creadList :: ReadS [AndOr]
readList :: ReadS [AndOr]
$creadPrec :: ReadPrec AndOr
readPrec :: ReadPrec AndOr
$creadListPrec :: ReadPrec [AndOr]
readListPrec :: ReadPrec [AndOr]
Read, Int -> AndOr -> ShowS
[AndOr] -> ShowS
AndOr -> String
(Int -> AndOr -> ShowS)
-> (AndOr -> String) -> ([AndOr] -> ShowS) -> Show AndOr
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> AndOr -> ShowS
showsPrec :: Int -> AndOr -> ShowS
$cshow :: AndOr -> String
show :: AndOr -> String
$cshowList :: [AndOr] -> ShowS
showList :: [AndOr] -> ShowS
Show, Typeable, (forall x. AndOr -> Rep AndOr x)
-> (forall x. Rep AndOr x -> AndOr) -> Generic AndOr
forall x. Rep AndOr x -> AndOr
forall x. AndOr -> Rep AndOr x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. AndOr -> Rep AndOr x
from :: forall x. AndOr -> Rep AndOr x
$cto :: forall x. Rep AndOr x -> AndOr
to :: forall x. Rep AndOr x -> AndOr
Generic)
instance Pretty AndOr where
pretty :: forall ann. AndOr -> Doc ann
pretty = BashDoc ann -> Doc ann
forall ann. BashDoc ann -> Doc ann
prettyBashDoc (BashDoc ann -> Doc ann)
-> (AndOr -> BashDoc ann) -> AndOr -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. AndOr -> BashDoc ann
forall ann. AndOr -> BashDoc ann
forall a ann. ToBashDoc a => a -> BashDoc ann
toBashDoc
instance ToBashDoc AndOr where
toBashDoc :: forall ann. AndOr -> BashDoc ann
toBashDoc (Last Pipeline
p) = Pipeline -> BashDoc ann
forall ann. Pipeline -> BashDoc ann
forall a ann. ToBashDoc a => a -> BashDoc ann
toBashDoc Pipeline
p
toBashDoc (And Pipeline
p AndOr
a) = Pipeline -> BashDoc ann
forall ann. Pipeline -> BashDoc ann
forall a ann. ToBashDoc a => a -> BashDoc ann
toBashDoc Pipeline
p BashDoc ann -> BashDoc ann -> BashDoc ann
forall a. Semigroup a => a -> a -> a
<> Doc ann -> BashDoc ann
forall ann. Doc ann -> BashDoc ann
docOp Doc ann
" &&" BashDoc ann -> BashDoc ann -> BashDoc ann
forall a. Semigroup a => a -> a -> a
<> AndOr -> BashDoc ann
forall ann. AndOr -> BashDoc ann
forall a ann. ToBashDoc a => a -> BashDoc ann
toBashDoc AndOr
a
toBashDoc (Or Pipeline
p AndOr
a) = Pipeline -> BashDoc ann
forall ann. Pipeline -> BashDoc ann
forall a ann. ToBashDoc a => a -> BashDoc ann
toBashDoc Pipeline
p BashDoc ann -> BashDoc ann -> BashDoc ann
forall a. Semigroup a => a -> a -> a
<> Doc ann -> BashDoc ann
forall ann. Doc ann -> BashDoc ann
docOp Doc ann
" ||" BashDoc ann -> BashDoc ann -> BashDoc ann
forall a. Semigroup a => a -> a -> a
<> AndOr -> BashDoc ann
forall ann. AndOr -> BashDoc ann
forall a ann. ToBashDoc a => a -> BashDoc ann
toBashDoc AndOr
a
data Pipeline = Pipeline
{
Pipeline -> Bool
timed :: Bool
, Pipeline -> Bool
timedPosix :: Bool
, Pipeline -> Bool
inverted :: Bool
, Pipeline -> [Command]
commands :: [Command]
} deriving (Typeable Pipeline
Typeable Pipeline
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Pipeline -> c Pipeline)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Pipeline)
-> (Pipeline -> Constr)
-> (Pipeline -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Pipeline))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Pipeline))
-> ((forall b. Data b => b -> b) -> Pipeline -> Pipeline)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Pipeline -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Pipeline -> r)
-> (forall u. (forall d. Data d => d -> u) -> Pipeline -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Pipeline -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Pipeline -> m Pipeline)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Pipeline -> m Pipeline)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Pipeline -> m Pipeline)
-> Data Pipeline
Pipeline -> Constr
Pipeline -> DataType
(forall b. Data b => b -> b) -> Pipeline -> Pipeline
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) -> Pipeline -> u
forall u. (forall d. Data d => d -> u) -> Pipeline -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Pipeline -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Pipeline -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Pipeline -> m Pipeline
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Pipeline -> m Pipeline
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Pipeline
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Pipeline -> c Pipeline
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Pipeline)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Pipeline)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Pipeline -> c Pipeline
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Pipeline -> c Pipeline
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Pipeline
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Pipeline
$ctoConstr :: Pipeline -> Constr
toConstr :: Pipeline -> Constr
$cdataTypeOf :: Pipeline -> DataType
dataTypeOf :: Pipeline -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Pipeline)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Pipeline)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Pipeline)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Pipeline)
$cgmapT :: (forall b. Data b => b -> b) -> Pipeline -> Pipeline
gmapT :: (forall b. Data b => b -> b) -> Pipeline -> Pipeline
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Pipeline -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Pipeline -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Pipeline -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Pipeline -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Pipeline -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Pipeline -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Pipeline -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Pipeline -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Pipeline -> m Pipeline
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Pipeline -> m Pipeline
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Pipeline -> m Pipeline
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Pipeline -> m Pipeline
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Pipeline -> m Pipeline
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Pipeline -> m Pipeline
Data, Pipeline -> Pipeline -> Bool
(Pipeline -> Pipeline -> Bool)
-> (Pipeline -> Pipeline -> Bool) -> Eq Pipeline
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Pipeline -> Pipeline -> Bool
== :: Pipeline -> Pipeline -> Bool
$c/= :: Pipeline -> Pipeline -> Bool
/= :: Pipeline -> Pipeline -> Bool
Eq, ReadPrec [Pipeline]
ReadPrec Pipeline
Int -> ReadS Pipeline
ReadS [Pipeline]
(Int -> ReadS Pipeline)
-> ReadS [Pipeline]
-> ReadPrec Pipeline
-> ReadPrec [Pipeline]
-> Read Pipeline
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Pipeline
readsPrec :: Int -> ReadS Pipeline
$creadList :: ReadS [Pipeline]
readList :: ReadS [Pipeline]
$creadPrec :: ReadPrec Pipeline
readPrec :: ReadPrec Pipeline
$creadListPrec :: ReadPrec [Pipeline]
readListPrec :: ReadPrec [Pipeline]
Read, Int -> Pipeline -> ShowS
[Pipeline] -> ShowS
Pipeline -> String
(Int -> Pipeline -> ShowS)
-> (Pipeline -> String) -> ([Pipeline] -> ShowS) -> Show Pipeline
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Pipeline -> ShowS
showsPrec :: Int -> Pipeline -> ShowS
$cshow :: Pipeline -> String
show :: Pipeline -> String
$cshowList :: [Pipeline] -> ShowS
showList :: [Pipeline] -> ShowS
Show, Typeable, (forall x. Pipeline -> Rep Pipeline x)
-> (forall x. Rep Pipeline x -> Pipeline) -> Generic Pipeline
forall x. Rep Pipeline x -> Pipeline
forall x. Pipeline -> Rep Pipeline x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Pipeline -> Rep Pipeline x
from :: forall x. Pipeline -> Rep Pipeline x
$cto :: forall x. Rep Pipeline x -> Pipeline
to :: forall x. Rep Pipeline x -> Pipeline
Generic)
instance Pretty Pipeline where
pretty :: forall ann. Pipeline -> Doc ann
pretty = BashDoc ann -> Doc ann
forall ann. BashDoc ann -> Doc ann
prettyBashDoc (BashDoc ann -> Doc ann)
-> (Pipeline -> BashDoc ann) -> Pipeline -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Pipeline -> BashDoc ann
forall ann. Pipeline -> BashDoc ann
forall a ann. ToBashDoc a => a -> BashDoc ann
toBashDoc
instance ToBashDoc Pipeline where
toBashDoc :: forall ann. Pipeline -> BashDoc ann
toBashDoc Pipeline{Bool
[Command]
timed :: Pipeline -> Bool
timedPosix :: Pipeline -> Bool
inverted :: Pipeline -> Bool
commands :: Pipeline -> [Command]
timed :: Bool
timedPosix :: Bool
inverted :: Bool
commands :: [Command]
..} = let
timed' :: Doc ann
timed' = if Bool
timed then Doc ann
"time" else Doc ann
forall a. Monoid a => a
mempty
timedPosix' :: Doc ann
timedPosix' = if Bool
timedPosix then Doc ann
"-p" else Doc ann
forall a. Monoid a => a
mempty
inverted' :: Doc ann
inverted' = if Bool
inverted then Doc ann
"!" else Doc ann
forall a. Monoid a => a
mempty
space :: Doc ann
space = if Bool
timed Bool -> Bool -> Bool
|| Bool
timedPosix Bool -> Bool -> Bool
|| Bool
inverted then Doc ann
" " else Doc ann
forall a. Monoid a => a
mempty
prefix :: BashDoc ann
prefix = Doc ann -> Doc ann -> Doc ann -> BashDoc ann
forall ann. Doc ann -> Doc ann -> Doc ann -> BashDoc ann
BashDoc Doc ann
forall a. Monoid a => a
mempty (Doc ann
timed' Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<++> Doc ann
timedPosix' Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<++> Doc ann
inverted' Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Doc ann
space) Doc ann
forall a. Monoid a => a
mempty
in BashDoc ann
prefix BashDoc ann -> BashDoc ann -> BashDoc ann
forall a. Semigroup a => a -> a -> a
<> [BashDoc ann] -> BashDoc ann
forall a. Monoid a => [a] -> a
mconcat (BashDoc ann -> [BashDoc ann] -> [BashDoc ann]
forall a. a -> [a] -> [a]
intersperse (Doc ann -> BashDoc ann
forall ann. Doc ann -> BashDoc ann
docOp Doc ann
" |") ((Command -> BashDoc ann) -> [Command] -> [BashDoc ann]
forall a b. (a -> b) -> [a] -> [b]
map Command -> BashDoc ann
forall ann. Command -> BashDoc ann
forall a ann. ToBashDoc a => a -> BashDoc ann
toBashDoc [Command]
commands))
data Assign = Assign Parameter AssignOp RValue
deriving (Typeable Assign
Typeable Assign
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Assign -> c Assign)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Assign)
-> (Assign -> Constr)
-> (Assign -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Assign))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Assign))
-> ((forall b. Data b => b -> b) -> Assign -> Assign)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Assign -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Assign -> r)
-> (forall u. (forall d. Data d => d -> u) -> Assign -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Assign -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Assign -> m Assign)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Assign -> m Assign)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Assign -> m Assign)
-> Data Assign
Assign -> Constr
Assign -> DataType
(forall b. Data b => b -> b) -> Assign -> Assign
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) -> Assign -> u
forall u. (forall d. Data d => d -> u) -> Assign -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Assign -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Assign -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Assign -> m Assign
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Assign -> m Assign
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Assign
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Assign -> c Assign
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Assign)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Assign)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Assign -> c Assign
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Assign -> c Assign
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Assign
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Assign
$ctoConstr :: Assign -> Constr
toConstr :: Assign -> Constr
$cdataTypeOf :: Assign -> DataType
dataTypeOf :: Assign -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Assign)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Assign)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Assign)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Assign)
$cgmapT :: (forall b. Data b => b -> b) -> Assign -> Assign
gmapT :: (forall b. Data b => b -> b) -> Assign -> Assign
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Assign -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Assign -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Assign -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Assign -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Assign -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Assign -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Assign -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Assign -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Assign -> m Assign
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Assign -> m Assign
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Assign -> m Assign
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Assign -> m Assign
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Assign -> m Assign
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Assign -> m Assign
Data, Assign -> Assign -> Bool
(Assign -> Assign -> Bool)
-> (Assign -> Assign -> Bool) -> Eq Assign
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Assign -> Assign -> Bool
== :: Assign -> Assign -> Bool
$c/= :: Assign -> Assign -> Bool
/= :: Assign -> Assign -> Bool
Eq, ReadPrec [Assign]
ReadPrec Assign
Int -> ReadS Assign
ReadS [Assign]
(Int -> ReadS Assign)
-> ReadS [Assign]
-> ReadPrec Assign
-> ReadPrec [Assign]
-> Read Assign
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Assign
readsPrec :: Int -> ReadS Assign
$creadList :: ReadS [Assign]
readList :: ReadS [Assign]
$creadPrec :: ReadPrec Assign
readPrec :: ReadPrec Assign
$creadListPrec :: ReadPrec [Assign]
readListPrec :: ReadPrec [Assign]
Read, Int -> Assign -> ShowS
[Assign] -> ShowS
Assign -> String
(Int -> Assign -> ShowS)
-> (Assign -> String) -> ([Assign] -> ShowS) -> Show Assign
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Assign -> ShowS
showsPrec :: Int -> Assign -> ShowS
$cshow :: Assign -> String
show :: Assign -> String
$cshowList :: [Assign] -> ShowS
showList :: [Assign] -> ShowS
Show, Typeable, (forall x. Assign -> Rep Assign x)
-> (forall x. Rep Assign x -> Assign) -> Generic Assign
forall x. Rep Assign x -> Assign
forall x. Assign -> Rep Assign x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Assign -> Rep Assign x
from :: forall x. Assign -> Rep Assign x
$cto :: forall x. Rep Assign x -> Assign
to :: forall x. Rep Assign x -> Assign
Generic)
instance Pretty Assign where
pretty :: forall ann. Assign -> Doc ann
pretty (Assign Parameter
lhs AssignOp
op RValue
rhs) = Parameter -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Parameter -> Doc ann
pretty Parameter
lhs Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> AssignOp -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. AssignOp -> Doc ann
pretty AssignOp
op Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> RValue -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. RValue -> Doc ann
pretty RValue
rhs
prettyList :: forall ann. [Assign] -> Doc ann
prettyList = [Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
hsep ([Doc ann] -> Doc ann)
-> ([Assign] -> [Doc ann]) -> [Assign] -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Assign -> Doc ann) -> [Assign] -> [Doc ann]
forall a b. (a -> b) -> [a] -> [b]
map Assign -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Assign -> Doc ann
pretty
data AssignOp
= Equals
| PlusEquals
deriving (Typeable AssignOp
Typeable AssignOp
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AssignOp -> c AssignOp)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AssignOp)
-> (AssignOp -> Constr)
-> (AssignOp -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AssignOp))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AssignOp))
-> ((forall b. Data b => b -> b) -> AssignOp -> AssignOp)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AssignOp -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AssignOp -> r)
-> (forall u. (forall d. Data d => d -> u) -> AssignOp -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> AssignOp -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> AssignOp -> m AssignOp)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AssignOp -> m AssignOp)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AssignOp -> m AssignOp)
-> Data AssignOp
AssignOp -> Constr
AssignOp -> DataType
(forall b. Data b => b -> b) -> AssignOp -> AssignOp
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) -> AssignOp -> u
forall u. (forall d. Data d => d -> u) -> AssignOp -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AssignOp -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AssignOp -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> AssignOp -> m AssignOp
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AssignOp -> m AssignOp
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AssignOp
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AssignOp -> c AssignOp
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AssignOp)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AssignOp)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AssignOp -> c AssignOp
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AssignOp -> c AssignOp
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AssignOp
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AssignOp
$ctoConstr :: AssignOp -> Constr
toConstr :: AssignOp -> Constr
$cdataTypeOf :: AssignOp -> DataType
dataTypeOf :: AssignOp -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AssignOp)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AssignOp)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AssignOp)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AssignOp)
$cgmapT :: (forall b. Data b => b -> b) -> AssignOp -> AssignOp
gmapT :: (forall b. Data b => b -> b) -> AssignOp -> AssignOp
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AssignOp -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AssignOp -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AssignOp -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AssignOp -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> AssignOp -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> AssignOp -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> AssignOp -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> AssignOp -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> AssignOp -> m AssignOp
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> AssignOp -> m AssignOp
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AssignOp -> m AssignOp
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AssignOp -> m AssignOp
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AssignOp -> m AssignOp
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AssignOp -> m AssignOp
Data, AssignOp -> AssignOp -> Bool
(AssignOp -> AssignOp -> Bool)
-> (AssignOp -> AssignOp -> Bool) -> Eq AssignOp
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AssignOp -> AssignOp -> Bool
== :: AssignOp -> AssignOp -> Bool
$c/= :: AssignOp -> AssignOp -> Bool
/= :: AssignOp -> AssignOp -> Bool
Eq, Eq AssignOp
Eq AssignOp
-> (AssignOp -> AssignOp -> Ordering)
-> (AssignOp -> AssignOp -> Bool)
-> (AssignOp -> AssignOp -> Bool)
-> (AssignOp -> AssignOp -> Bool)
-> (AssignOp -> AssignOp -> Bool)
-> (AssignOp -> AssignOp -> AssignOp)
-> (AssignOp -> AssignOp -> AssignOp)
-> Ord AssignOp
AssignOp -> AssignOp -> Bool
AssignOp -> AssignOp -> Ordering
AssignOp -> AssignOp -> AssignOp
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: AssignOp -> AssignOp -> Ordering
compare :: AssignOp -> AssignOp -> Ordering
$c< :: AssignOp -> AssignOp -> Bool
< :: AssignOp -> AssignOp -> Bool
$c<= :: AssignOp -> AssignOp -> Bool
<= :: AssignOp -> AssignOp -> Bool
$c> :: AssignOp -> AssignOp -> Bool
> :: AssignOp -> AssignOp -> Bool
$c>= :: AssignOp -> AssignOp -> Bool
>= :: AssignOp -> AssignOp -> Bool
$cmax :: AssignOp -> AssignOp -> AssignOp
max :: AssignOp -> AssignOp -> AssignOp
$cmin :: AssignOp -> AssignOp -> AssignOp
min :: AssignOp -> AssignOp -> AssignOp
Ord, ReadPrec [AssignOp]
ReadPrec AssignOp
Int -> ReadS AssignOp
ReadS [AssignOp]
(Int -> ReadS AssignOp)
-> ReadS [AssignOp]
-> ReadPrec AssignOp
-> ReadPrec [AssignOp]
-> Read AssignOp
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS AssignOp
readsPrec :: Int -> ReadS AssignOp
$creadList :: ReadS [AssignOp]
readList :: ReadS [AssignOp]
$creadPrec :: ReadPrec AssignOp
readPrec :: ReadPrec AssignOp
$creadListPrec :: ReadPrec [AssignOp]
readListPrec :: ReadPrec [AssignOp]
Read, Int -> AssignOp -> ShowS
[AssignOp] -> ShowS
AssignOp -> String
(Int -> AssignOp -> ShowS)
-> (AssignOp -> String) -> ([AssignOp] -> ShowS) -> Show AssignOp
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> AssignOp -> ShowS
showsPrec :: Int -> AssignOp -> ShowS
$cshow :: AssignOp -> String
show :: AssignOp -> String
$cshowList :: [AssignOp] -> ShowS
showList :: [AssignOp] -> ShowS
Show, Typeable, AssignOp
AssignOp -> AssignOp -> Bounded AssignOp
forall a. a -> a -> Bounded a
$cminBound :: AssignOp
minBound :: AssignOp
$cmaxBound :: AssignOp
maxBound :: AssignOp
Bounded, Int -> AssignOp
AssignOp -> Int
AssignOp -> [AssignOp]
AssignOp -> AssignOp
AssignOp -> AssignOp -> [AssignOp]
AssignOp -> AssignOp -> AssignOp -> [AssignOp]
(AssignOp -> AssignOp)
-> (AssignOp -> AssignOp)
-> (Int -> AssignOp)
-> (AssignOp -> Int)
-> (AssignOp -> [AssignOp])
-> (AssignOp -> AssignOp -> [AssignOp])
-> (AssignOp -> AssignOp -> [AssignOp])
-> (AssignOp -> AssignOp -> AssignOp -> [AssignOp])
-> Enum AssignOp
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: AssignOp -> AssignOp
succ :: AssignOp -> AssignOp
$cpred :: AssignOp -> AssignOp
pred :: AssignOp -> AssignOp
$ctoEnum :: Int -> AssignOp
toEnum :: Int -> AssignOp
$cfromEnum :: AssignOp -> Int
fromEnum :: AssignOp -> Int
$cenumFrom :: AssignOp -> [AssignOp]
enumFrom :: AssignOp -> [AssignOp]
$cenumFromThen :: AssignOp -> AssignOp -> [AssignOp]
enumFromThen :: AssignOp -> AssignOp -> [AssignOp]
$cenumFromTo :: AssignOp -> AssignOp -> [AssignOp]
enumFromTo :: AssignOp -> AssignOp -> [AssignOp]
$cenumFromThenTo :: AssignOp -> AssignOp -> AssignOp -> [AssignOp]
enumFromThenTo :: AssignOp -> AssignOp -> AssignOp -> [AssignOp]
Enum, (forall x. AssignOp -> Rep AssignOp x)
-> (forall x. Rep AssignOp x -> AssignOp) -> Generic AssignOp
forall x. Rep AssignOp x -> AssignOp
forall x. AssignOp -> Rep AssignOp x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. AssignOp -> Rep AssignOp x
from :: forall x. AssignOp -> Rep AssignOp x
$cto :: forall x. Rep AssignOp x -> AssignOp
to :: forall x. Rep AssignOp x -> AssignOp
Generic)
instance Operator AssignOp where
operatorTable :: [(AssignOp, String)]
operatorTable = [AssignOp] -> [String] -> [(AssignOp, String)]
forall a b. [a] -> [b] -> [(a, b)]
zip [AssignOp
Equals, AssignOp
PlusEquals] [String
"=", String
"+="]
instance Pretty AssignOp where
pretty :: forall ann. AssignOp -> Doc ann
pretty = AssignOp -> Doc ann
forall a ann. Operator a => a -> Doc ann
prettyOperator
data RValue
= RValue Word
| RArray [(Maybe Word, Word)]
deriving (Typeable RValue
Typeable RValue
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RValue -> c RValue)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RValue)
-> (RValue -> Constr)
-> (RValue -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RValue))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RValue))
-> ((forall b. Data b => b -> b) -> RValue -> RValue)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RValue -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RValue -> r)
-> (forall u. (forall d. Data d => d -> u) -> RValue -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> RValue -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RValue -> m RValue)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RValue -> m RValue)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RValue -> m RValue)
-> Data RValue
RValue -> Constr
RValue -> DataType
(forall b. Data b => b -> b) -> RValue -> RValue
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) -> RValue -> u
forall u. (forall d. Data d => d -> u) -> RValue -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RValue -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RValue -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RValue -> m RValue
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RValue -> m RValue
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RValue
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RValue -> c RValue
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RValue)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RValue)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RValue -> c RValue
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RValue -> c RValue
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RValue
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RValue
$ctoConstr :: RValue -> Constr
toConstr :: RValue -> Constr
$cdataTypeOf :: RValue -> DataType
dataTypeOf :: RValue -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RValue)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RValue)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RValue)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RValue)
$cgmapT :: (forall b. Data b => b -> b) -> RValue -> RValue
gmapT :: (forall b. Data b => b -> b) -> RValue -> RValue
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RValue -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RValue -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RValue -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RValue -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> RValue -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> RValue -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> RValue -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> RValue -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RValue -> m RValue
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RValue -> m RValue
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RValue -> m RValue
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RValue -> m RValue
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RValue -> m RValue
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RValue -> m RValue
Data, RValue -> RValue -> Bool
(RValue -> RValue -> Bool)
-> (RValue -> RValue -> Bool) -> Eq RValue
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RValue -> RValue -> Bool
== :: RValue -> RValue -> Bool
$c/= :: RValue -> RValue -> Bool
/= :: RValue -> RValue -> Bool
Eq, ReadPrec [RValue]
ReadPrec RValue
Int -> ReadS RValue
ReadS [RValue]
(Int -> ReadS RValue)
-> ReadS [RValue]
-> ReadPrec RValue
-> ReadPrec [RValue]
-> Read RValue
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS RValue
readsPrec :: Int -> ReadS RValue
$creadList :: ReadS [RValue]
readList :: ReadS [RValue]
$creadPrec :: ReadPrec RValue
readPrec :: ReadPrec RValue
$creadListPrec :: ReadPrec [RValue]
readListPrec :: ReadPrec [RValue]
Read, Int -> RValue -> ShowS
[RValue] -> ShowS
RValue -> String
(Int -> RValue -> ShowS)
-> (RValue -> String) -> ([RValue] -> ShowS) -> Show RValue
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RValue -> ShowS
showsPrec :: Int -> RValue -> ShowS
$cshow :: RValue -> String
show :: RValue -> String
$cshowList :: [RValue] -> ShowS
showList :: [RValue] -> ShowS
Show, Typeable, (forall x. RValue -> Rep RValue x)
-> (forall x. Rep RValue x -> RValue) -> Generic RValue
forall x. Rep RValue x -> RValue
forall x. RValue -> Rep RValue x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. RValue -> Rep RValue x
from :: forall x. RValue -> Rep RValue x
$cto :: forall x. Rep RValue x -> RValue
to :: forall x. Rep RValue x -> RValue
Generic)
instance Pretty RValue where
pretty :: forall ann. RValue -> Doc ann
pretty (RValue [Span]
w) = [Span] -> Doc ann
forall ann. [Span] -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty [Span]
w
pretty (RArray [(Maybe [Span], [Span])]
rs) = Doc ann
"(" Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> [Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
hsep (((Maybe [Span], [Span]) -> Doc ann)
-> [(Maybe [Span], [Span])] -> [Doc ann]
forall a b. (a -> b) -> [a] -> [b]
map (Maybe [Span], [Span]) -> Doc ann
forall {a} {a} {ann}.
(Pretty a, Pretty a) =>
(Maybe a, a) -> Doc ann
f [(Maybe [Span], [Span])]
rs) Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Doc ann
")"
where
f :: (Maybe a, a) -> Doc ann
f (Maybe a
Nothing , a
w) = a -> Doc ann
forall ann. a -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty a
w
f (Just a
sub, a
w) = Doc ann
"[" Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> a -> Doc ann
forall ann. a -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty a
sub Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Doc ann
"]=" Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> a -> Doc ann
forall ann. a -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty a
w