{-# LANGUAGE DeriveDataTypeable, FlexibleInstances, GeneralizedNewtypeDeriving, OverloadedStrings, RecordWildCards, DeriveGeneric #-}
-- | Shell script types.
module Language.Bash.Syntax
    (
      -- * Commands
      Command(..)
    , ShellCommand(..)
    , WordList(..)
    , CaseClause(..)
    , CaseTerm(..)
      -- * Redirections
    , Redir(..)
    , IODesc(..)
    , RedirOp(..)
    , HeredocOp(..)
      -- * Lists
    , List(..)
    , Statement(..)
    , ListTerm(..)
    , AndOr(..)
    , Pipeline(..)
      -- * Assignments
    , 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

-- | The BashDoc monoid is used for building Statements, AndOr or Pipelines.
-- Consider the following situation: We have the following command
--
-- > cat <<EOF
-- > some here doc
-- > EOF
--
-- and we want to pipe its output to another arbitrary command @cmd@.
-- We want this pipeline to look like this:
--
-- > cat <<EOF |
-- > some here doc
-- > EOF
-- > cmd
--
-- Note the @|@ at the end of the first line: If we were simply pretty printing the @cat@ command we had no idea where to insert the pipe symbol.
-- And that's the purpose of BashDoc: We store possible suffixes to such lines, commands and the here documents attached to them separately and do the concatenation in the Semigroup instance of BashDoc.
data BashDoc ann = BashDoc
    (Doc ann) -- ^ The head: This is stuff we want to put before the line break and here documents
    (Doc ann) -- ^ The tail: Everthing which follows the here documents
    (Doc ann) -- ^ Collected here documents

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

-- | A utility class for pretty printing without heredocs
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 by 4 columns.
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

-- | Render a conditional command with a block.
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

-- | Render a conditional command with a block whose condition is a list of statements.
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

-- | Does the last statement in a list have a here doc attached?
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

-- | A Bash command with redirections.
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

-- | A Bash command.
data ShellCommand
      -- | A simple command consisting of assignments followed by words.
    = SimpleCommand [Assign] [Word]
      -- | The shell builtins @declare@, @eval@, @export@, @local@, @readonly@,
      -- and @typeset@ can accept both assignments and words as arguments.
    | AssignBuiltin Word [Either Assign Word]
      -- | A function name and definition.
    | FunctionDef String List
      -- | A named coprocess.
    | Coproc String Command
      -- | A @(...)@ list, denoting a subshell.
    | Subshell List
      -- | A @{...}@ list.
    | Group List
      -- | An arithmetic expression.
    | Arith String
      -- | A Bash @[[...]]@ conditional expression.
    | Cond (CondExpr Word)
      -- | A @for /name/ in /words/@ command. If @in /words/@ is absent,
      -- the word list defaults to @\"$\@\"@.
    | For String WordList List
      -- | An arithmetic @for ((...))@ command.
    | ArithFor String List
      -- | A @select /name/ in /words/@ command. If @in /words/@ is absent,
      -- the word list defaults to @\"$\@\"@.
    | Select String WordList List
      -- | A @case@ command.
    | Case Word [CaseClause]
      -- | An @if@ command, with a predicate, consequent, and alternative.
      -- @elif@ clauses are parsed as nested @if@ statements.
    | If List List (Maybe List)
      -- | An @until@ command.
    | Until List List
      -- | A @while@ command.
    | 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"

-- | A word list or @\"$\@\"@.
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

-- | A single case clause.
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)

-- | A case clause terminator.
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

-- | A redirection.
data Redir
      -- | A redirection.
    = Redir
        { -- | An optional file descriptor.
          Redir -> Maybe IODesc
redirDesc   :: Maybe IODesc
          -- | The redirection operator.
        , Redir -> RedirOp
redirOp     :: RedirOp
          -- | The redirection target.
        , Redir -> [Span]
redirTarget :: Word
        }
      -- | A here document.
    | Heredoc
        { -- | The here document operator.
          Redir -> HeredocOp
heredocOp          :: HeredocOp
          -- | The here document delimiter.
        , Redir -> String
heredocDelim       :: String
          -- | 'True' if the delimiter was quoted.
        , Redir -> Bool
heredocDelimQuoted :: Bool
          -- | The document itself, if the delimiter was quoted, no expansions
          -- are parsed. If the delimiter was not quoted, parameter, arithmetic
          -- and command substitutions take place.
        , 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

-- | A redirection file descriptor.
data IODesc
      -- | A file descriptor number.
    = IONumber Int
      -- | A variable @{/varname/}@ to allocate a file descriptor for.
    | 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
"}"

-- | A redirection operator.
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

-- | A here document operator.
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

-- | A compound list of statements.
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

-- | A single statement in a list.
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

-- | A statement terminator.
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
"&"

-- | A right-associative list of pipelines.
data AndOr
      -- | The last pipeline of a list.
    = Last Pipeline
      -- | A @&&@ construct.
    | And Pipeline AndOr
      -- | A @||@ construct.
    | 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

-- | A (possibly timed or inverted) pipeline, linked with @|@ or @|&@.
data Pipeline = Pipeline
    { -- | 'True' if the pipeline is timed with @time@.
      Pipeline -> Bool
timed      :: Bool
      -- | 'True' if the pipeline is timed with the @-p@ flag.
    , Pipeline -> Bool
timedPosix :: Bool
      -- | 'True' if the pipeline is inverted with @!@.
    , Pipeline -> Bool
inverted   :: Bool
      -- | A list of commands, separated by @|@, or @|&@.
      -- @command1 |& command2@ is treated as a shorthand for
      -- @command1 2>&1 | command2@.
    , 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))

-- | An assignment.
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

-- | An assignment operator.
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

-- | The right side of an assignment.
data RValue
      -- | A simple word.
    = RValue Word
      -- | An array assignment, as @(subscript, word)@ pairs.
    | 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