{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveFunctor #-}
{-# LANGUAGE DeriveTraversable #-}
{-# LANGUAGE DeriveFoldable #-}
{-# LANGUAGE ScopedTypeVariables #-}
module Language.ECMAScript3.Syntax (JavaScript(..)
,unJavaScript
,Statement(..)
,isIterationStmt
,CaseClause(..)
,CatchClause(..)
,ForInit(..)
,ForInInit(..)
,VarDecl(..)
,Expression(..)
,InfixOp(..)
,AssignOp(..)
,Id(..)
,unId
,PrefixOp(..)
,Prop(..)
,UnaryAssignOp(..)
,LValue (..)
,SourcePos
,isValid
,isValidIdentifier
,isValidIdentifierName
,isReservedWord
,isValidIdStart
,isValidIdPart
,EnclosingStatement(..)
,pushLabel
,pushEnclosing
,HasLabelSet (..)
,isIter
,isIterSwitch
) where
import Text.Parsec.Pos(initialPos,SourcePos)
import Data.Data (Data)
import Data.Typeable (Typeable)
import Data.Foldable (Foldable)
import Data.Traversable (Traversable)
import Data.Default.Class
import Data.Generics.Uniplate.Data
import Data.Char
import Control.Monad.State
import Control.Arrow
data JavaScript a
= Script a [Statement a]
deriving (Int -> JavaScript a -> ShowS
forall a. Show a => Int -> JavaScript a -> ShowS
forall a. Show a => [JavaScript a] -> ShowS
forall a. Show a => JavaScript a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [JavaScript a] -> ShowS
$cshowList :: forall a. Show a => [JavaScript a] -> ShowS
show :: JavaScript a -> String
$cshow :: forall a. Show a => JavaScript a -> String
showsPrec :: Int -> JavaScript a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> JavaScript a -> ShowS
Show,JavaScript a -> Constr
JavaScript a -> DataType
forall {a}. Data a => Typeable (JavaScript a)
forall a. Data a => JavaScript a -> Constr
forall a. Data a => JavaScript a -> DataType
forall a.
Data a =>
(forall b. Data b => b -> b) -> JavaScript a -> JavaScript a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> JavaScript a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> JavaScript a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> JavaScript a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> JavaScript a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> JavaScript a -> m (JavaScript a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> JavaScript a -> m (JavaScript a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (JavaScript a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> JavaScript a -> c (JavaScript a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (JavaScript a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (JavaScript a))
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 (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (JavaScript a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> JavaScript a -> c (JavaScript a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (JavaScript a))
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> JavaScript a -> m (JavaScript a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> JavaScript a -> m (JavaScript a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> JavaScript a -> m (JavaScript a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> JavaScript a -> m (JavaScript a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> JavaScript a -> m (JavaScript a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> JavaScript a -> m (JavaScript a)
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> JavaScript a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> JavaScript a -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> JavaScript a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> JavaScript a -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> JavaScript a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> JavaScript a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> JavaScript a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> JavaScript a -> r
gmapT :: (forall b. Data b => b -> b) -> JavaScript a -> JavaScript a
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> JavaScript a -> JavaScript a
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (JavaScript a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (JavaScript a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (JavaScript a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (JavaScript a))
dataTypeOf :: JavaScript a -> DataType
$cdataTypeOf :: forall a. Data a => JavaScript a -> DataType
toConstr :: JavaScript a -> Constr
$ctoConstr :: forall a. Data a => JavaScript a -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (JavaScript a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (JavaScript a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> JavaScript a -> c (JavaScript a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> JavaScript a -> c (JavaScript a)
Data,Typeable,JavaScript a -> JavaScript a -> Bool
forall a. Eq a => JavaScript a -> JavaScript a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: JavaScript a -> JavaScript a -> Bool
$c/= :: forall a. Eq a => JavaScript a -> JavaScript a -> Bool
== :: JavaScript a -> JavaScript a -> Bool
$c== :: forall a. Eq a => JavaScript a -> JavaScript a -> Bool
Eq,JavaScript a -> JavaScript a -> Bool
JavaScript a -> JavaScript a -> Ordering
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
forall {a}. Ord a => Eq (JavaScript a)
forall a. Ord a => JavaScript a -> JavaScript a -> Bool
forall a. Ord a => JavaScript a -> JavaScript a -> Ordering
forall a. Ord a => JavaScript a -> JavaScript a -> JavaScript a
min :: JavaScript a -> JavaScript a -> JavaScript a
$cmin :: forall a. Ord a => JavaScript a -> JavaScript a -> JavaScript a
max :: JavaScript a -> JavaScript a -> JavaScript a
$cmax :: forall a. Ord a => JavaScript a -> JavaScript a -> JavaScript a
>= :: JavaScript a -> JavaScript a -> Bool
$c>= :: forall a. Ord a => JavaScript a -> JavaScript a -> Bool
> :: JavaScript a -> JavaScript a -> Bool
$c> :: forall a. Ord a => JavaScript a -> JavaScript a -> Bool
<= :: JavaScript a -> JavaScript a -> Bool
$c<= :: forall a. Ord a => JavaScript a -> JavaScript a -> Bool
< :: JavaScript a -> JavaScript a -> Bool
$c< :: forall a. Ord a => JavaScript a -> JavaScript a -> Bool
compare :: JavaScript a -> JavaScript a -> Ordering
$ccompare :: forall a. Ord a => JavaScript a -> JavaScript a -> Ordering
Ord,forall a b. a -> JavaScript b -> JavaScript a
forall a b. (a -> b) -> JavaScript a -> JavaScript b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> JavaScript b -> JavaScript a
$c<$ :: forall a b. a -> JavaScript b -> JavaScript a
fmap :: forall a b. (a -> b) -> JavaScript a -> JavaScript b
$cfmap :: forall a b. (a -> b) -> JavaScript a -> JavaScript b
Functor,forall a. Eq a => a -> JavaScript a -> Bool
forall a. Num a => JavaScript a -> a
forall a. Ord a => JavaScript a -> a
forall m. Monoid m => JavaScript m -> m
forall a. JavaScript a -> Bool
forall a. JavaScript a -> Int
forall a. JavaScript a -> [a]
forall a. (a -> a -> a) -> JavaScript a -> a
forall m a. Monoid m => (a -> m) -> JavaScript a -> m
forall b a. (b -> a -> b) -> b -> JavaScript a -> b
forall a b. (a -> b -> b) -> b -> JavaScript a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => JavaScript a -> a
$cproduct :: forall a. Num a => JavaScript a -> a
sum :: forall a. Num a => JavaScript a -> a
$csum :: forall a. Num a => JavaScript a -> a
minimum :: forall a. Ord a => JavaScript a -> a
$cminimum :: forall a. Ord a => JavaScript a -> a
maximum :: forall a. Ord a => JavaScript a -> a
$cmaximum :: forall a. Ord a => JavaScript a -> a
elem :: forall a. Eq a => a -> JavaScript a -> Bool
$celem :: forall a. Eq a => a -> JavaScript a -> Bool
length :: forall a. JavaScript a -> Int
$clength :: forall a. JavaScript a -> Int
null :: forall a. JavaScript a -> Bool
$cnull :: forall a. JavaScript a -> Bool
toList :: forall a. JavaScript a -> [a]
$ctoList :: forall a. JavaScript a -> [a]
foldl1 :: forall a. (a -> a -> a) -> JavaScript a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> JavaScript a -> a
foldr1 :: forall a. (a -> a -> a) -> JavaScript a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> JavaScript a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> JavaScript a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> JavaScript a -> b
foldl :: forall b a. (b -> a -> b) -> b -> JavaScript a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> JavaScript a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> JavaScript a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> JavaScript a -> b
foldr :: forall a b. (a -> b -> b) -> b -> JavaScript a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> JavaScript a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> JavaScript a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> JavaScript a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> JavaScript a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> JavaScript a -> m
fold :: forall m. Monoid m => JavaScript m -> m
$cfold :: forall m. Monoid m => JavaScript m -> m
Foldable,Functor JavaScript
Foldable JavaScript
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
JavaScript (m a) -> m (JavaScript a)
forall (f :: * -> *) a.
Applicative f =>
JavaScript (f a) -> f (JavaScript a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> JavaScript a -> m (JavaScript b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> JavaScript a -> f (JavaScript b)
sequence :: forall (m :: * -> *) a.
Monad m =>
JavaScript (m a) -> m (JavaScript a)
$csequence :: forall (m :: * -> *) a.
Monad m =>
JavaScript (m a) -> m (JavaScript a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> JavaScript a -> m (JavaScript b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> JavaScript a -> m (JavaScript b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
JavaScript (f a) -> f (JavaScript a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
JavaScript (f a) -> f (JavaScript a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> JavaScript a -> f (JavaScript b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> JavaScript a -> f (JavaScript b)
Traversable)
instance Default a => Default (JavaScript a) where
def :: JavaScript a
def = forall a. a -> [Statement a] -> JavaScript a
Script forall a. Default a => a
def []
unJavaScript :: JavaScript a -> [Statement a]
unJavaScript :: forall a. JavaScript a -> [Statement a]
unJavaScript (Script a
_ [Statement a]
stmts) = [Statement a]
stmts
instance Default SourcePos where
def :: SourcePos
def = String -> SourcePos
initialPos String
""
data Id a = Id a String
deriving (Int -> Id a -> ShowS
forall a. Show a => Int -> Id a -> ShowS
forall a. Show a => [Id a] -> ShowS
forall a. Show a => Id a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Id a] -> ShowS
$cshowList :: forall a. Show a => [Id a] -> ShowS
show :: Id a -> String
$cshow :: forall a. Show a => Id a -> String
showsPrec :: Int -> Id a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Id a -> ShowS
Show,Id a -> Id a -> Bool
forall a. Eq a => Id a -> Id a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Id a -> Id a -> Bool
$c/= :: forall a. Eq a => Id a -> Id a -> Bool
== :: Id a -> Id a -> Bool
$c== :: forall a. Eq a => Id a -> Id a -> Bool
Eq,Id a -> Id a -> Bool
Id a -> Id a -> Ordering
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
forall {a}. Ord a => Eq (Id a)
forall a. Ord a => Id a -> Id a -> Bool
forall a. Ord a => Id a -> Id a -> Ordering
forall a. Ord a => Id a -> Id a -> Id a
min :: Id a -> Id a -> Id a
$cmin :: forall a. Ord a => Id a -> Id a -> Id a
max :: Id a -> Id a -> Id a
$cmax :: forall a. Ord a => Id a -> Id a -> Id a
>= :: Id a -> Id a -> Bool
$c>= :: forall a. Ord a => Id a -> Id a -> Bool
> :: Id a -> Id a -> Bool
$c> :: forall a. Ord a => Id a -> Id a -> Bool
<= :: Id a -> Id a -> Bool
$c<= :: forall a. Ord a => Id a -> Id a -> Bool
< :: Id a -> Id a -> Bool
$c< :: forall a. Ord a => Id a -> Id a -> Bool
compare :: Id a -> Id a -> Ordering
$ccompare :: forall a. Ord a => Id a -> Id a -> Ordering
Ord,Id a -> Constr
Id a -> DataType
forall {a}. Data a => Typeable (Id a)
forall a. Data a => Id a -> Constr
forall a. Data a => Id a -> DataType
forall a. Data a => (forall b. Data b => b -> b) -> Id a -> Id a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Id a -> u
forall a u. Data a => (forall d. Data d => d -> u) -> Id a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Id a -> r
forall a r r'.
Data a =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Id a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Id a -> m (Id a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Id a -> m (Id a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Id a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Id a -> c (Id a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Id a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Id a))
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 (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Id a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Id a -> c (Id a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Id a))
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Id a -> m (Id a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Id a -> m (Id a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Id a -> m (Id a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Id a -> m (Id a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Id a -> m (Id a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Id a -> m (Id a)
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Id a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Id a -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Id a -> [u]
$cgmapQ :: forall a u. Data a => (forall d. Data d => d -> u) -> Id a -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Id a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Id a -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Id a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Id a -> r
gmapT :: (forall b. Data b => b -> b) -> Id a -> Id a
$cgmapT :: forall a. Data a => (forall b. Data b => b -> b) -> Id a -> Id a
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Id a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Id a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Id a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Id a))
dataTypeOf :: Id a -> DataType
$cdataTypeOf :: forall a. Data a => Id a -> DataType
toConstr :: Id a -> Constr
$ctoConstr :: forall a. Data a => Id a -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Id a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Id a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Id a -> c (Id a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Id a -> c (Id a)
Data,Typeable,forall a b. a -> Id b -> Id a
forall a b. (a -> b) -> Id a -> Id b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> Id b -> Id a
$c<$ :: forall a b. a -> Id b -> Id a
fmap :: forall a b. (a -> b) -> Id a -> Id b
$cfmap :: forall a b. (a -> b) -> Id a -> Id b
Functor,forall a. Eq a => a -> Id a -> Bool
forall a. Num a => Id a -> a
forall a. Ord a => Id a -> a
forall m. Monoid m => Id m -> m
forall a. Id a -> Bool
forall a. Id a -> Int
forall a. Id a -> [a]
forall a. (a -> a -> a) -> Id a -> a
forall m a. Monoid m => (a -> m) -> Id a -> m
forall b a. (b -> a -> b) -> b -> Id a -> b
forall a b. (a -> b -> b) -> b -> Id a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => Id a -> a
$cproduct :: forall a. Num a => Id a -> a
sum :: forall a. Num a => Id a -> a
$csum :: forall a. Num a => Id a -> a
minimum :: forall a. Ord a => Id a -> a
$cminimum :: forall a. Ord a => Id a -> a
maximum :: forall a. Ord a => Id a -> a
$cmaximum :: forall a. Ord a => Id a -> a
elem :: forall a. Eq a => a -> Id a -> Bool
$celem :: forall a. Eq a => a -> Id a -> Bool
length :: forall a. Id a -> Int
$clength :: forall a. Id a -> Int
null :: forall a. Id a -> Bool
$cnull :: forall a. Id a -> Bool
toList :: forall a. Id a -> [a]
$ctoList :: forall a. Id a -> [a]
foldl1 :: forall a. (a -> a -> a) -> Id a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Id a -> a
foldr1 :: forall a. (a -> a -> a) -> Id a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Id a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> Id a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Id a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Id a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Id a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Id a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Id a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Id a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> Id a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> Id a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Id a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Id a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Id a -> m
fold :: forall m. Monoid m => Id m -> m
$cfold :: forall m. Monoid m => Id m -> m
Foldable,Functor Id
Foldable Id
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => Id (m a) -> m (Id a)
forall (f :: * -> *) a. Applicative f => Id (f a) -> f (Id a)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> Id a -> m (Id b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Id a -> f (Id b)
sequence :: forall (m :: * -> *) a. Monad m => Id (m a) -> m (Id a)
$csequence :: forall (m :: * -> *) a. Monad m => Id (m a) -> m (Id a)
mapM :: forall (m :: * -> *) a b. Monad m => (a -> m b) -> Id a -> m (Id b)
$cmapM :: forall (m :: * -> *) a b. Monad m => (a -> m b) -> Id a -> m (Id b)
sequenceA :: forall (f :: * -> *) a. Applicative f => Id (f a) -> f (Id a)
$csequenceA :: forall (f :: * -> *) a. Applicative f => Id (f a) -> f (Id a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Id a -> f (Id b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Id a -> f (Id b)
Traversable)
unId :: Id a -> String
unId :: forall a. Id a -> String
unId (Id a
_ String
s) = String
s
data InfixOp = OpLT
| OpLEq
| OpGT
| OpGEq
| OpIn
| OpInstanceof
| OpEq
| OpNEq
| OpStrictEq
| OpStrictNEq
| OpLAnd
| OpLOr
| OpMul
| OpDiv
| OpMod
| OpSub
| OpLShift
| OpSpRShift
| OpZfRShift
| OpBAnd
| OpBXor
| OpBOr
| OpAdd
deriving (Int -> InfixOp -> ShowS
[InfixOp] -> ShowS
InfixOp -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [InfixOp] -> ShowS
$cshowList :: [InfixOp] -> ShowS
show :: InfixOp -> String
$cshow :: InfixOp -> String
showsPrec :: Int -> InfixOp -> ShowS
$cshowsPrec :: Int -> InfixOp -> ShowS
Show,Typeable InfixOp
InfixOp -> Constr
InfixOp -> DataType
(forall b. Data b => b -> b) -> InfixOp -> InfixOp
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) -> InfixOp -> u
forall u. (forall d. Data d => d -> u) -> InfixOp -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> InfixOp -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> InfixOp -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> InfixOp -> m InfixOp
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> InfixOp -> m InfixOp
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c InfixOp
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> InfixOp -> c InfixOp
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c InfixOp)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c InfixOp)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> InfixOp -> m InfixOp
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> InfixOp -> m InfixOp
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> InfixOp -> m InfixOp
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> InfixOp -> m InfixOp
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> InfixOp -> m InfixOp
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> InfixOp -> m InfixOp
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> InfixOp -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> InfixOp -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> InfixOp -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> InfixOp -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> InfixOp -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> InfixOp -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> InfixOp -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> InfixOp -> r
gmapT :: (forall b. Data b => b -> b) -> InfixOp -> InfixOp
$cgmapT :: (forall b. Data b => b -> b) -> InfixOp -> InfixOp
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c InfixOp)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c InfixOp)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c InfixOp)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c InfixOp)
dataTypeOf :: InfixOp -> DataType
$cdataTypeOf :: InfixOp -> DataType
toConstr :: InfixOp -> Constr
$ctoConstr :: InfixOp -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c InfixOp
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c InfixOp
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> InfixOp -> c InfixOp
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> InfixOp -> c InfixOp
Data,Typeable,InfixOp -> InfixOp -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: InfixOp -> InfixOp -> Bool
$c/= :: InfixOp -> InfixOp -> Bool
== :: InfixOp -> InfixOp -> Bool
$c== :: InfixOp -> InfixOp -> Bool
Eq,Eq InfixOp
InfixOp -> InfixOp -> Bool
InfixOp -> InfixOp -> Ordering
InfixOp -> InfixOp -> InfixOp
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
min :: InfixOp -> InfixOp -> InfixOp
$cmin :: InfixOp -> InfixOp -> InfixOp
max :: InfixOp -> InfixOp -> InfixOp
$cmax :: InfixOp -> InfixOp -> InfixOp
>= :: InfixOp -> InfixOp -> Bool
$c>= :: InfixOp -> InfixOp -> Bool
> :: InfixOp -> InfixOp -> Bool
$c> :: InfixOp -> InfixOp -> Bool
<= :: InfixOp -> InfixOp -> Bool
$c<= :: InfixOp -> InfixOp -> Bool
< :: InfixOp -> InfixOp -> Bool
$c< :: InfixOp -> InfixOp -> Bool
compare :: InfixOp -> InfixOp -> Ordering
$ccompare :: InfixOp -> InfixOp -> Ordering
Ord,Int -> InfixOp
InfixOp -> Int
InfixOp -> [InfixOp]
InfixOp -> InfixOp
InfixOp -> InfixOp -> [InfixOp]
InfixOp -> InfixOp -> InfixOp -> [InfixOp]
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: InfixOp -> InfixOp -> InfixOp -> [InfixOp]
$cenumFromThenTo :: InfixOp -> InfixOp -> InfixOp -> [InfixOp]
enumFromTo :: InfixOp -> InfixOp -> [InfixOp]
$cenumFromTo :: InfixOp -> InfixOp -> [InfixOp]
enumFromThen :: InfixOp -> InfixOp -> [InfixOp]
$cenumFromThen :: InfixOp -> InfixOp -> [InfixOp]
enumFrom :: InfixOp -> [InfixOp]
$cenumFrom :: InfixOp -> [InfixOp]
fromEnum :: InfixOp -> Int
$cfromEnum :: InfixOp -> Int
toEnum :: Int -> InfixOp
$ctoEnum :: Int -> InfixOp
pred :: InfixOp -> InfixOp
$cpred :: InfixOp -> InfixOp
succ :: InfixOp -> InfixOp
$csucc :: InfixOp -> InfixOp
Enum)
data AssignOp = OpAssign
| OpAssignAdd
| OpAssignSub
| OpAssignMul
| OpAssignDiv
| OpAssignMod
| OpAssignLShift
| OpAssignSpRShift
| OpAssignZfRShift
| OpAssignBAnd
| OpAssignBXor
| OpAssignBOr
deriving (Int -> AssignOp -> ShowS
[AssignOp] -> ShowS
AssignOp -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AssignOp] -> ShowS
$cshowList :: [AssignOp] -> ShowS
show :: AssignOp -> String
$cshow :: AssignOp -> String
showsPrec :: Int -> AssignOp -> ShowS
$cshowsPrec :: Int -> AssignOp -> ShowS
Show,Typeable 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)
gmapMo :: 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
gmapMp :: forall (m :: * -> *).
MonadPlus 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
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> AssignOp -> m AssignOp
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> AssignOp -> m AssignOp
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> AssignOp -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> AssignOp -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> AssignOp -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> AssignOp -> [u]
gmapQr :: 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
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AssignOp -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AssignOp -> r
gmapT :: (forall b. Data b => b -> b) -> AssignOp -> AssignOp
$cgmapT :: (forall b. Data b => b -> b) -> AssignOp -> AssignOp
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AssignOp)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AssignOp)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AssignOp)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AssignOp)
dataTypeOf :: AssignOp -> DataType
$cdataTypeOf :: AssignOp -> DataType
toConstr :: AssignOp -> Constr
$ctoConstr :: AssignOp -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AssignOp
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AssignOp
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AssignOp -> c AssignOp
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AssignOp -> c AssignOp
Data,Typeable,AssignOp -> AssignOp -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AssignOp -> AssignOp -> Bool
$c/= :: AssignOp -> AssignOp -> Bool
== :: AssignOp -> AssignOp -> Bool
$c== :: AssignOp -> AssignOp -> Bool
Eq,Eq 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
min :: AssignOp -> AssignOp -> AssignOp
$cmin :: AssignOp -> AssignOp -> AssignOp
max :: AssignOp -> AssignOp -> AssignOp
$cmax :: AssignOp -> AssignOp -> AssignOp
>= :: AssignOp -> AssignOp -> Bool
$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
compare :: AssignOp -> AssignOp -> Ordering
$ccompare :: AssignOp -> AssignOp -> Ordering
Ord)
data UnaryAssignOp = PrefixInc
| PrefixDec
| PostfixInc
| PostfixDec
deriving (Int -> UnaryAssignOp -> ShowS
[UnaryAssignOp] -> ShowS
UnaryAssignOp -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [UnaryAssignOp] -> ShowS
$cshowList :: [UnaryAssignOp] -> ShowS
show :: UnaryAssignOp -> String
$cshow :: UnaryAssignOp -> String
showsPrec :: Int -> UnaryAssignOp -> ShowS
$cshowsPrec :: Int -> UnaryAssignOp -> ShowS
Show, Typeable UnaryAssignOp
UnaryAssignOp -> Constr
UnaryAssignOp -> DataType
(forall b. Data b => b -> b) -> UnaryAssignOp -> UnaryAssignOp
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) -> UnaryAssignOp -> u
forall u. (forall d. Data d => d -> u) -> UnaryAssignOp -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> UnaryAssignOp -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> UnaryAssignOp -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> UnaryAssignOp -> m UnaryAssignOp
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> UnaryAssignOp -> m UnaryAssignOp
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c UnaryAssignOp
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UnaryAssignOp -> c UnaryAssignOp
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c UnaryAssignOp)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c UnaryAssignOp)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> UnaryAssignOp -> m UnaryAssignOp
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> UnaryAssignOp -> m UnaryAssignOp
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> UnaryAssignOp -> m UnaryAssignOp
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> UnaryAssignOp -> m UnaryAssignOp
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> UnaryAssignOp -> m UnaryAssignOp
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> UnaryAssignOp -> m UnaryAssignOp
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> UnaryAssignOp -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> UnaryAssignOp -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> UnaryAssignOp -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> UnaryAssignOp -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> UnaryAssignOp -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> UnaryAssignOp -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> UnaryAssignOp -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> UnaryAssignOp -> r
gmapT :: (forall b. Data b => b -> b) -> UnaryAssignOp -> UnaryAssignOp
$cgmapT :: (forall b. Data b => b -> b) -> UnaryAssignOp -> UnaryAssignOp
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c UnaryAssignOp)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c UnaryAssignOp)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c UnaryAssignOp)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c UnaryAssignOp)
dataTypeOf :: UnaryAssignOp -> DataType
$cdataTypeOf :: UnaryAssignOp -> DataType
toConstr :: UnaryAssignOp -> Constr
$ctoConstr :: UnaryAssignOp -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c UnaryAssignOp
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c UnaryAssignOp
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UnaryAssignOp -> c UnaryAssignOp
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UnaryAssignOp -> c UnaryAssignOp
Data, Typeable, UnaryAssignOp -> UnaryAssignOp -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UnaryAssignOp -> UnaryAssignOp -> Bool
$c/= :: UnaryAssignOp -> UnaryAssignOp -> Bool
== :: UnaryAssignOp -> UnaryAssignOp -> Bool
$c== :: UnaryAssignOp -> UnaryAssignOp -> Bool
Eq, Eq UnaryAssignOp
UnaryAssignOp -> UnaryAssignOp -> Bool
UnaryAssignOp -> UnaryAssignOp -> Ordering
UnaryAssignOp -> UnaryAssignOp -> UnaryAssignOp
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
min :: UnaryAssignOp -> UnaryAssignOp -> UnaryAssignOp
$cmin :: UnaryAssignOp -> UnaryAssignOp -> UnaryAssignOp
max :: UnaryAssignOp -> UnaryAssignOp -> UnaryAssignOp
$cmax :: UnaryAssignOp -> UnaryAssignOp -> UnaryAssignOp
>= :: UnaryAssignOp -> UnaryAssignOp -> Bool
$c>= :: UnaryAssignOp -> UnaryAssignOp -> Bool
> :: UnaryAssignOp -> UnaryAssignOp -> Bool
$c> :: UnaryAssignOp -> UnaryAssignOp -> Bool
<= :: UnaryAssignOp -> UnaryAssignOp -> Bool
$c<= :: UnaryAssignOp -> UnaryAssignOp -> Bool
< :: UnaryAssignOp -> UnaryAssignOp -> Bool
$c< :: UnaryAssignOp -> UnaryAssignOp -> Bool
compare :: UnaryAssignOp -> UnaryAssignOp -> Ordering
$ccompare :: UnaryAssignOp -> UnaryAssignOp -> Ordering
Ord)
data PrefixOp = PrefixLNot
| PrefixBNot
| PrefixPlus
| PrefixMinus
| PrefixTypeof
| PrefixVoid
| PrefixDelete
deriving (Int -> PrefixOp -> ShowS
[PrefixOp] -> ShowS
PrefixOp -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PrefixOp] -> ShowS
$cshowList :: [PrefixOp] -> ShowS
show :: PrefixOp -> String
$cshow :: PrefixOp -> String
showsPrec :: Int -> PrefixOp -> ShowS
$cshowsPrec :: Int -> PrefixOp -> ShowS
Show,Typeable PrefixOp
PrefixOp -> Constr
PrefixOp -> DataType
(forall b. Data b => b -> b) -> PrefixOp -> PrefixOp
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) -> PrefixOp -> u
forall u. (forall d. Data d => d -> u) -> PrefixOp -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PrefixOp -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PrefixOp -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PrefixOp -> m PrefixOp
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PrefixOp -> m PrefixOp
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PrefixOp
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PrefixOp -> c PrefixOp
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PrefixOp)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PrefixOp)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PrefixOp -> m PrefixOp
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PrefixOp -> m PrefixOp
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PrefixOp -> m PrefixOp
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PrefixOp -> m PrefixOp
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PrefixOp -> m PrefixOp
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PrefixOp -> m PrefixOp
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> PrefixOp -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> PrefixOp -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> PrefixOp -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> PrefixOp -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PrefixOp -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PrefixOp -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PrefixOp -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PrefixOp -> r
gmapT :: (forall b. Data b => b -> b) -> PrefixOp -> PrefixOp
$cgmapT :: (forall b. Data b => b -> b) -> PrefixOp -> PrefixOp
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PrefixOp)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PrefixOp)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PrefixOp)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PrefixOp)
dataTypeOf :: PrefixOp -> DataType
$cdataTypeOf :: PrefixOp -> DataType
toConstr :: PrefixOp -> Constr
$ctoConstr :: PrefixOp -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PrefixOp
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PrefixOp
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PrefixOp -> c PrefixOp
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PrefixOp -> c PrefixOp
Data,Typeable,PrefixOp -> PrefixOp -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PrefixOp -> PrefixOp -> Bool
$c/= :: PrefixOp -> PrefixOp -> Bool
== :: PrefixOp -> PrefixOp -> Bool
$c== :: PrefixOp -> PrefixOp -> Bool
Eq,Eq PrefixOp
PrefixOp -> PrefixOp -> Bool
PrefixOp -> PrefixOp -> Ordering
PrefixOp -> PrefixOp -> PrefixOp
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
min :: PrefixOp -> PrefixOp -> PrefixOp
$cmin :: PrefixOp -> PrefixOp -> PrefixOp
max :: PrefixOp -> PrefixOp -> PrefixOp
$cmax :: PrefixOp -> PrefixOp -> PrefixOp
>= :: PrefixOp -> PrefixOp -> Bool
$c>= :: PrefixOp -> PrefixOp -> Bool
> :: PrefixOp -> PrefixOp -> Bool
$c> :: PrefixOp -> PrefixOp -> Bool
<= :: PrefixOp -> PrefixOp -> Bool
$c<= :: PrefixOp -> PrefixOp -> Bool
< :: PrefixOp -> PrefixOp -> Bool
$c< :: PrefixOp -> PrefixOp -> Bool
compare :: PrefixOp -> PrefixOp -> Ordering
$ccompare :: PrefixOp -> PrefixOp -> Ordering
Ord)
data Prop a = PropId a (Id a)
| PropString a String
| PropNum a Integer
deriving (Int -> Prop a -> ShowS
forall a. Show a => Int -> Prop a -> ShowS
forall a. Show a => [Prop a] -> ShowS
forall a. Show a => Prop a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Prop a] -> ShowS
$cshowList :: forall a. Show a => [Prop a] -> ShowS
show :: Prop a -> String
$cshow :: forall a. Show a => Prop a -> String
showsPrec :: Int -> Prop a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Prop a -> ShowS
Show,Prop a -> Constr
Prop a -> DataType
forall {a}. Data a => Typeable (Prop a)
forall a. Data a => Prop a -> Constr
forall a. Data a => Prop a -> DataType
forall a.
Data a =>
(forall b. Data b => b -> b) -> Prop a -> Prop a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Prop a -> u
forall a u. Data a => (forall d. Data d => d -> u) -> Prop a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Prop a -> r
forall a r r'.
Data a =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Prop a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Prop a -> m (Prop a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Prop a -> m (Prop a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Prop a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Prop a -> c (Prop a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Prop a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Prop a))
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 (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Prop a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Prop a -> c (Prop a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Prop a))
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Prop a -> m (Prop a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Prop a -> m (Prop a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Prop a -> m (Prop a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Prop a -> m (Prop a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Prop a -> m (Prop a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Prop a -> m (Prop a)
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Prop a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Prop a -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Prop a -> [u]
$cgmapQ :: forall a u. Data a => (forall d. Data d => d -> u) -> Prop a -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Prop a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Prop a -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Prop a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Prop a -> r
gmapT :: (forall b. Data b => b -> b) -> Prop a -> Prop a
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> Prop a -> Prop a
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Prop a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Prop a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Prop a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Prop a))
dataTypeOf :: Prop a -> DataType
$cdataTypeOf :: forall a. Data a => Prop a -> DataType
toConstr :: Prop a -> Constr
$ctoConstr :: forall a. Data a => Prop a -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Prop a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Prop a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Prop a -> c (Prop a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Prop a -> c (Prop a)
Data,Typeable,Prop a -> Prop a -> Bool
forall a. Eq a => Prop a -> Prop a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Prop a -> Prop a -> Bool
$c/= :: forall a. Eq a => Prop a -> Prop a -> Bool
== :: Prop a -> Prop a -> Bool
$c== :: forall a. Eq a => Prop a -> Prop a -> Bool
Eq,Prop a -> Prop a -> Bool
Prop a -> Prop a -> Ordering
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
forall {a}. Ord a => Eq (Prop a)
forall a. Ord a => Prop a -> Prop a -> Bool
forall a. Ord a => Prop a -> Prop a -> Ordering
forall a. Ord a => Prop a -> Prop a -> Prop a
min :: Prop a -> Prop a -> Prop a
$cmin :: forall a. Ord a => Prop a -> Prop a -> Prop a
max :: Prop a -> Prop a -> Prop a
$cmax :: forall a. Ord a => Prop a -> Prop a -> Prop a
>= :: Prop a -> Prop a -> Bool
$c>= :: forall a. Ord a => Prop a -> Prop a -> Bool
> :: Prop a -> Prop a -> Bool
$c> :: forall a. Ord a => Prop a -> Prop a -> Bool
<= :: Prop a -> Prop a -> Bool
$c<= :: forall a. Ord a => Prop a -> Prop a -> Bool
< :: Prop a -> Prop a -> Bool
$c< :: forall a. Ord a => Prop a -> Prop a -> Bool
compare :: Prop a -> Prop a -> Ordering
$ccompare :: forall a. Ord a => Prop a -> Prop a -> Ordering
Ord,forall a b. a -> Prop b -> Prop a
forall a b. (a -> b) -> Prop a -> Prop b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> Prop b -> Prop a
$c<$ :: forall a b. a -> Prop b -> Prop a
fmap :: forall a b. (a -> b) -> Prop a -> Prop b
$cfmap :: forall a b. (a -> b) -> Prop a -> Prop b
Functor,forall a. Eq a => a -> Prop a -> Bool
forall a. Num a => Prop a -> a
forall a. Ord a => Prop a -> a
forall m. Monoid m => Prop m -> m
forall a. Prop a -> Bool
forall a. Prop a -> Int
forall a. Prop a -> [a]
forall a. (a -> a -> a) -> Prop a -> a
forall m a. Monoid m => (a -> m) -> Prop a -> m
forall b a. (b -> a -> b) -> b -> Prop a -> b
forall a b. (a -> b -> b) -> b -> Prop a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => Prop a -> a
$cproduct :: forall a. Num a => Prop a -> a
sum :: forall a. Num a => Prop a -> a
$csum :: forall a. Num a => Prop a -> a
minimum :: forall a. Ord a => Prop a -> a
$cminimum :: forall a. Ord a => Prop a -> a
maximum :: forall a. Ord a => Prop a -> a
$cmaximum :: forall a. Ord a => Prop a -> a
elem :: forall a. Eq a => a -> Prop a -> Bool
$celem :: forall a. Eq a => a -> Prop a -> Bool
length :: forall a. Prop a -> Int
$clength :: forall a. Prop a -> Int
null :: forall a. Prop a -> Bool
$cnull :: forall a. Prop a -> Bool
toList :: forall a. Prop a -> [a]
$ctoList :: forall a. Prop a -> [a]
foldl1 :: forall a. (a -> a -> a) -> Prop a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Prop a -> a
foldr1 :: forall a. (a -> a -> a) -> Prop a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Prop a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> Prop a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Prop a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Prop a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Prop a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Prop a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Prop a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Prop a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> Prop a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> Prop a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Prop a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Prop a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Prop a -> m
fold :: forall m. Monoid m => Prop m -> m
$cfold :: forall m. Monoid m => Prop m -> m
Foldable,Functor Prop
Foldable Prop
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => Prop (m a) -> m (Prop a)
forall (f :: * -> *) a. Applicative f => Prop (f a) -> f (Prop a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Prop a -> m (Prop b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Prop a -> f (Prop b)
sequence :: forall (m :: * -> *) a. Monad m => Prop (m a) -> m (Prop a)
$csequence :: forall (m :: * -> *) a. Monad m => Prop (m a) -> m (Prop a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Prop a -> m (Prop b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Prop a -> m (Prop b)
sequenceA :: forall (f :: * -> *) a. Applicative f => Prop (f a) -> f (Prop a)
$csequenceA :: forall (f :: * -> *) a. Applicative f => Prop (f a) -> f (Prop a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Prop a -> f (Prop b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Prop a -> f (Prop b)
Traversable)
data LValue a
= LVar a String
| LDot a (Expression a) String
| LBracket a (Expression a) (Expression a)
deriving (Int -> LValue a -> ShowS
forall a. Show a => Int -> LValue a -> ShowS
forall a. Show a => [LValue a] -> ShowS
forall a. Show a => LValue a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [LValue a] -> ShowS
$cshowList :: forall a. Show a => [LValue a] -> ShowS
show :: LValue a -> String
$cshow :: forall a. Show a => LValue a -> String
showsPrec :: Int -> LValue a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> LValue a -> ShowS
Show, LValue a -> LValue a -> Bool
forall a. Eq a => LValue a -> LValue a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: LValue a -> LValue a -> Bool
$c/= :: forall a. Eq a => LValue a -> LValue a -> Bool
== :: LValue a -> LValue a -> Bool
$c== :: forall a. Eq a => LValue a -> LValue a -> Bool
Eq, LValue a -> LValue a -> Bool
LValue a -> LValue a -> Ordering
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
forall {a}. Ord a => Eq (LValue a)
forall a. Ord a => LValue a -> LValue a -> Bool
forall a. Ord a => LValue a -> LValue a -> Ordering
forall a. Ord a => LValue a -> LValue a -> LValue a
min :: LValue a -> LValue a -> LValue a
$cmin :: forall a. Ord a => LValue a -> LValue a -> LValue a
max :: LValue a -> LValue a -> LValue a
$cmax :: forall a. Ord a => LValue a -> LValue a -> LValue a
>= :: LValue a -> LValue a -> Bool
$c>= :: forall a. Ord a => LValue a -> LValue a -> Bool
> :: LValue a -> LValue a -> Bool
$c> :: forall a. Ord a => LValue a -> LValue a -> Bool
<= :: LValue a -> LValue a -> Bool
$c<= :: forall a. Ord a => LValue a -> LValue a -> Bool
< :: LValue a -> LValue a -> Bool
$c< :: forall a. Ord a => LValue a -> LValue a -> Bool
compare :: LValue a -> LValue a -> Ordering
$ccompare :: forall a. Ord a => LValue a -> LValue a -> Ordering
Ord, LValue a -> Constr
LValue a -> DataType
forall {a}. Data a => Typeable (LValue a)
forall a. Data a => LValue a -> Constr
forall a. Data a => LValue a -> DataType
forall a.
Data a =>
(forall b. Data b => b -> b) -> LValue a -> LValue a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> LValue a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> LValue a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> LValue a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> LValue a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> LValue a -> m (LValue a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> LValue a -> m (LValue a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (LValue a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> LValue a -> c (LValue a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (LValue a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (LValue a))
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 (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (LValue a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> LValue a -> c (LValue a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (LValue a))
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> LValue a -> m (LValue a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> LValue a -> m (LValue a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> LValue a -> m (LValue a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> LValue a -> m (LValue a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> LValue a -> m (LValue a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> LValue a -> m (LValue a)
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> LValue a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> LValue a -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> LValue a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> LValue a -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> LValue a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> LValue a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> LValue a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> LValue a -> r
gmapT :: (forall b. Data b => b -> b) -> LValue a -> LValue a
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> LValue a -> LValue a
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (LValue a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (LValue a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (LValue a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (LValue a))
dataTypeOf :: LValue a -> DataType
$cdataTypeOf :: forall a. Data a => LValue a -> DataType
toConstr :: LValue a -> Constr
$ctoConstr :: forall a. Data a => LValue a -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (LValue a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (LValue a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> LValue a -> c (LValue a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> LValue a -> c (LValue a)
Data, Typeable, forall a b. a -> LValue b -> LValue a
forall a b. (a -> b) -> LValue a -> LValue b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> LValue b -> LValue a
$c<$ :: forall a b. a -> LValue b -> LValue a
fmap :: forall a b. (a -> b) -> LValue a -> LValue b
$cfmap :: forall a b. (a -> b) -> LValue a -> LValue b
Functor,forall a. Eq a => a -> LValue a -> Bool
forall a. Num a => LValue a -> a
forall a. Ord a => LValue a -> a
forall m. Monoid m => LValue m -> m
forall a. LValue a -> Bool
forall a. LValue a -> Int
forall a. LValue a -> [a]
forall a. (a -> a -> a) -> LValue a -> a
forall m a. Monoid m => (a -> m) -> LValue a -> m
forall b a. (b -> a -> b) -> b -> LValue a -> b
forall a b. (a -> b -> b) -> b -> LValue a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => LValue a -> a
$cproduct :: forall a. Num a => LValue a -> a
sum :: forall a. Num a => LValue a -> a
$csum :: forall a. Num a => LValue a -> a
minimum :: forall a. Ord a => LValue a -> a
$cminimum :: forall a. Ord a => LValue a -> a
maximum :: forall a. Ord a => LValue a -> a
$cmaximum :: forall a. Ord a => LValue a -> a
elem :: forall a. Eq a => a -> LValue a -> Bool
$celem :: forall a. Eq a => a -> LValue a -> Bool
length :: forall a. LValue a -> Int
$clength :: forall a. LValue a -> Int
null :: forall a. LValue a -> Bool
$cnull :: forall a. LValue a -> Bool
toList :: forall a. LValue a -> [a]
$ctoList :: forall a. LValue a -> [a]
foldl1 :: forall a. (a -> a -> a) -> LValue a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> LValue a -> a
foldr1 :: forall a. (a -> a -> a) -> LValue a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> LValue a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> LValue a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> LValue a -> b
foldl :: forall b a. (b -> a -> b) -> b -> LValue a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> LValue a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> LValue a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> LValue a -> b
foldr :: forall a b. (a -> b -> b) -> b -> LValue a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> LValue a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> LValue a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> LValue a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> LValue a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> LValue a -> m
fold :: forall m. Monoid m => LValue m -> m
$cfold :: forall m. Monoid m => LValue m -> m
Foldable,Functor LValue
Foldable LValue
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => LValue (m a) -> m (LValue a)
forall (f :: * -> *) a.
Applicative f =>
LValue (f a) -> f (LValue a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> LValue a -> m (LValue b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> LValue a -> f (LValue b)
sequence :: forall (m :: * -> *) a. Monad m => LValue (m a) -> m (LValue a)
$csequence :: forall (m :: * -> *) a. Monad m => LValue (m a) -> m (LValue a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> LValue a -> m (LValue b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> LValue a -> m (LValue b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
LValue (f a) -> f (LValue a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
LValue (f a) -> f (LValue a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> LValue a -> f (LValue b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> LValue a -> f (LValue b)
Traversable)
data Expression a
= StringLit a String
| RegexpLit a String Bool Bool
| NumLit a Double
| IntLit a Int
| BoolLit a Bool
| NullLit a
| ArrayLit a [Expression a]
| ObjectLit a [(Prop a, Expression a)]
| ThisRef a
| VarRef a (Id a)
| DotRef a (Expression a) (Id a)
| BracketRef a (Expression a) (Expression a)
| NewExpr a (Expression a) [Expression a]
| PrefixExpr a PrefixOp (Expression a)
| UnaryAssignExpr a UnaryAssignOp (LValue a)
| InfixExpr a InfixOp (Expression a) (Expression a)
| CondExpr a (Expression a) (Expression a) (Expression a)
| AssignExpr a AssignOp (LValue a) (Expression a)
| ListExpr a [Expression a]
| CallExpr a (Expression a) [Expression a]
| FuncExpr a (Maybe (Id a)) [Id a] [Statement a]
deriving (Int -> Expression a -> ShowS
forall a. Show a => Int -> Expression a -> ShowS
forall a. Show a => [Expression a] -> ShowS
forall a. Show a => Expression a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Expression a] -> ShowS
$cshowList :: forall a. Show a => [Expression a] -> ShowS
show :: Expression a -> String
$cshow :: forall a. Show a => Expression a -> String
showsPrec :: Int -> Expression a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Expression a -> ShowS
Show,Expression a -> Constr
Expression a -> DataType
forall {a}. Data a => Typeable (Expression a)
forall a. Data a => Expression a -> Constr
forall a. Data a => Expression a -> DataType
forall a.
Data a =>
(forall b. Data b => b -> b) -> Expression a -> Expression a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Expression a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> Expression a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Expression a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Expression a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Expression a -> m (Expression a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Expression a -> m (Expression a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Expression a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Expression a -> c (Expression a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Expression a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Expression a))
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 (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Expression a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Expression a -> c (Expression a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Expression a))
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Expression a -> m (Expression a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Expression a -> m (Expression a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Expression a -> m (Expression a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Expression a -> m (Expression a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Expression a -> m (Expression a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Expression a -> m (Expression a)
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Expression a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Expression a -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Expression a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> Expression a -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Expression a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Expression a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Expression a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Expression a -> r
gmapT :: (forall b. Data b => b -> b) -> Expression a -> Expression a
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> Expression a -> Expression a
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Expression a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Expression a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Expression a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Expression a))
dataTypeOf :: Expression a -> DataType
$cdataTypeOf :: forall a. Data a => Expression a -> DataType
toConstr :: Expression a -> Constr
$ctoConstr :: forall a. Data a => Expression a -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Expression a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Expression a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Expression a -> c (Expression a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Expression a -> c (Expression a)
Data,Typeable,Expression a -> Expression a -> Bool
forall a. Eq a => Expression a -> Expression a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Expression a -> Expression a -> Bool
$c/= :: forall a. Eq a => Expression a -> Expression a -> Bool
== :: Expression a -> Expression a -> Bool
$c== :: forall a. Eq a => Expression a -> Expression a -> Bool
Eq,Expression a -> Expression a -> Ordering
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
forall {a}. Ord a => Eq (Expression a)
forall a. Ord a => Expression a -> Expression a -> Bool
forall a. Ord a => Expression a -> Expression a -> Ordering
forall a. Ord a => Expression a -> Expression a -> Expression a
min :: Expression a -> Expression a -> Expression a
$cmin :: forall a. Ord a => Expression a -> Expression a -> Expression a
max :: Expression a -> Expression a -> Expression a
$cmax :: forall a. Ord a => Expression a -> Expression a -> Expression a
>= :: Expression a -> Expression a -> Bool
$c>= :: forall a. Ord a => Expression a -> Expression a -> Bool
> :: Expression a -> Expression a -> Bool
$c> :: forall a. Ord a => Expression a -> Expression a -> Bool
<= :: Expression a -> Expression a -> Bool
$c<= :: forall a. Ord a => Expression a -> Expression a -> Bool
< :: Expression a -> Expression a -> Bool
$c< :: forall a. Ord a => Expression a -> Expression a -> Bool
compare :: Expression a -> Expression a -> Ordering
$ccompare :: forall a. Ord a => Expression a -> Expression a -> Ordering
Ord,forall a b. a -> Expression b -> Expression a
forall a b. (a -> b) -> Expression a -> Expression b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> Expression b -> Expression a
$c<$ :: forall a b. a -> Expression b -> Expression a
fmap :: forall a b. (a -> b) -> Expression a -> Expression b
$cfmap :: forall a b. (a -> b) -> Expression a -> Expression b
Functor,forall a. Eq a => a -> Expression a -> Bool
forall a. Num a => Expression a -> a
forall a. Ord a => Expression a -> a
forall m. Monoid m => Expression m -> m
forall a. Expression a -> Bool
forall a. Expression a -> Int
forall a. Expression a -> [a]
forall a. (a -> a -> a) -> Expression a -> a
forall m a. Monoid m => (a -> m) -> Expression a -> m
forall b a. (b -> a -> b) -> b -> Expression a -> b
forall a b. (a -> b -> b) -> b -> Expression a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => Expression a -> a
$cproduct :: forall a. Num a => Expression a -> a
sum :: forall a. Num a => Expression a -> a
$csum :: forall a. Num a => Expression a -> a
minimum :: forall a. Ord a => Expression a -> a
$cminimum :: forall a. Ord a => Expression a -> a
maximum :: forall a. Ord a => Expression a -> a
$cmaximum :: forall a. Ord a => Expression a -> a
elem :: forall a. Eq a => a -> Expression a -> Bool
$celem :: forall a. Eq a => a -> Expression a -> Bool
length :: forall a. Expression a -> Int
$clength :: forall a. Expression a -> Int
null :: forall a. Expression a -> Bool
$cnull :: forall a. Expression a -> Bool
toList :: forall a. Expression a -> [a]
$ctoList :: forall a. Expression a -> [a]
foldl1 :: forall a. (a -> a -> a) -> Expression a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Expression a -> a
foldr1 :: forall a. (a -> a -> a) -> Expression a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Expression a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> Expression a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Expression a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Expression a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Expression a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Expression a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Expression a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Expression a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> Expression a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> Expression a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Expression a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Expression a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Expression a -> m
fold :: forall m. Monoid m => Expression m -> m
$cfold :: forall m. Monoid m => Expression m -> m
Foldable,Functor Expression
Foldable Expression
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
Expression (m a) -> m (Expression a)
forall (f :: * -> *) a.
Applicative f =>
Expression (f a) -> f (Expression a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Expression a -> m (Expression b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Expression a -> f (Expression b)
sequence :: forall (m :: * -> *) a.
Monad m =>
Expression (m a) -> m (Expression a)
$csequence :: forall (m :: * -> *) a.
Monad m =>
Expression (m a) -> m (Expression a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Expression a -> m (Expression b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Expression a -> m (Expression b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Expression (f a) -> f (Expression a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Expression (f a) -> f (Expression a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Expression a -> f (Expression b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Expression a -> f (Expression b)
Traversable)
data CaseClause a = CaseClause a (Expression a) [Statement a]
| CaseDefault a [Statement a]
deriving (Int -> CaseClause a -> ShowS
forall a. Show a => Int -> CaseClause a -> ShowS
forall a. Show a => [CaseClause a] -> ShowS
forall a. Show a => CaseClause a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CaseClause a] -> ShowS
$cshowList :: forall a. Show a => [CaseClause a] -> ShowS
show :: CaseClause a -> String
$cshow :: forall a. Show a => CaseClause a -> String
showsPrec :: Int -> CaseClause a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> CaseClause a -> ShowS
Show,CaseClause a -> Constr
CaseClause a -> DataType
forall {a}. Data a => Typeable (CaseClause a)
forall a. Data a => CaseClause a -> Constr
forall a. Data a => CaseClause a -> DataType
forall a.
Data a =>
(forall b. Data b => b -> b) -> CaseClause a -> CaseClause a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> CaseClause a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> CaseClause a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CaseClause a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CaseClause a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> CaseClause a -> m (CaseClause a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> CaseClause a -> m (CaseClause a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (CaseClause a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CaseClause a -> c (CaseClause a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (CaseClause a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (CaseClause a))
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 (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (CaseClause a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CaseClause a -> c (CaseClause a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (CaseClause a))
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CaseClause a -> m (CaseClause a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> CaseClause a -> m (CaseClause a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CaseClause a -> m (CaseClause a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> CaseClause a -> m (CaseClause a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CaseClause a -> m (CaseClause a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> CaseClause a -> m (CaseClause a)
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CaseClause a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> CaseClause a -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> CaseClause a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> CaseClause a -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CaseClause a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CaseClause a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CaseClause a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CaseClause a -> r
gmapT :: (forall b. Data b => b -> b) -> CaseClause a -> CaseClause a
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> CaseClause a -> CaseClause a
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (CaseClause a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (CaseClause a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (CaseClause a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (CaseClause a))
dataTypeOf :: CaseClause a -> DataType
$cdataTypeOf :: forall a. Data a => CaseClause a -> DataType
toConstr :: CaseClause a -> Constr
$ctoConstr :: forall a. Data a => CaseClause a -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (CaseClause a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (CaseClause a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CaseClause a -> c (CaseClause a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CaseClause a -> c (CaseClause a)
Data,Typeable,CaseClause a -> CaseClause a -> Bool
forall a. Eq a => CaseClause a -> CaseClause a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CaseClause a -> CaseClause a -> Bool
$c/= :: forall a. Eq a => CaseClause a -> CaseClause a -> Bool
== :: CaseClause a -> CaseClause a -> Bool
$c== :: forall a. Eq a => CaseClause a -> CaseClause a -> Bool
Eq,CaseClause a -> CaseClause a -> Bool
CaseClause a -> CaseClause a -> Ordering
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
forall {a}. Ord a => Eq (CaseClause a)
forall a. Ord a => CaseClause a -> CaseClause a -> Bool
forall a. Ord a => CaseClause a -> CaseClause a -> Ordering
forall a. Ord a => CaseClause a -> CaseClause a -> CaseClause a
min :: CaseClause a -> CaseClause a -> CaseClause a
$cmin :: forall a. Ord a => CaseClause a -> CaseClause a -> CaseClause a
max :: CaseClause a -> CaseClause a -> CaseClause a
$cmax :: forall a. Ord a => CaseClause a -> CaseClause a -> CaseClause a
>= :: CaseClause a -> CaseClause a -> Bool
$c>= :: forall a. Ord a => CaseClause a -> CaseClause a -> Bool
> :: CaseClause a -> CaseClause a -> Bool
$c> :: forall a. Ord a => CaseClause a -> CaseClause a -> Bool
<= :: CaseClause a -> CaseClause a -> Bool
$c<= :: forall a. Ord a => CaseClause a -> CaseClause a -> Bool
< :: CaseClause a -> CaseClause a -> Bool
$c< :: forall a. Ord a => CaseClause a -> CaseClause a -> Bool
compare :: CaseClause a -> CaseClause a -> Ordering
$ccompare :: forall a. Ord a => CaseClause a -> CaseClause a -> Ordering
Ord,forall a b. a -> CaseClause b -> CaseClause a
forall a b. (a -> b) -> CaseClause a -> CaseClause b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> CaseClause b -> CaseClause a
$c<$ :: forall a b. a -> CaseClause b -> CaseClause a
fmap :: forall a b. (a -> b) -> CaseClause a -> CaseClause b
$cfmap :: forall a b. (a -> b) -> CaseClause a -> CaseClause b
Functor,forall a. Eq a => a -> CaseClause a -> Bool
forall a. Num a => CaseClause a -> a
forall a. Ord a => CaseClause a -> a
forall m. Monoid m => CaseClause m -> m
forall a. CaseClause a -> Bool
forall a. CaseClause a -> Int
forall a. CaseClause a -> [a]
forall a. (a -> a -> a) -> CaseClause a -> a
forall m a. Monoid m => (a -> m) -> CaseClause a -> m
forall b a. (b -> a -> b) -> b -> CaseClause a -> b
forall a b. (a -> b -> b) -> b -> CaseClause a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => CaseClause a -> a
$cproduct :: forall a. Num a => CaseClause a -> a
sum :: forall a. Num a => CaseClause a -> a
$csum :: forall a. Num a => CaseClause a -> a
minimum :: forall a. Ord a => CaseClause a -> a
$cminimum :: forall a. Ord a => CaseClause a -> a
maximum :: forall a. Ord a => CaseClause a -> a
$cmaximum :: forall a. Ord a => CaseClause a -> a
elem :: forall a. Eq a => a -> CaseClause a -> Bool
$celem :: forall a. Eq a => a -> CaseClause a -> Bool
length :: forall a. CaseClause a -> Int
$clength :: forall a. CaseClause a -> Int
null :: forall a. CaseClause a -> Bool
$cnull :: forall a. CaseClause a -> Bool
toList :: forall a. CaseClause a -> [a]
$ctoList :: forall a. CaseClause a -> [a]
foldl1 :: forall a. (a -> a -> a) -> CaseClause a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> CaseClause a -> a
foldr1 :: forall a. (a -> a -> a) -> CaseClause a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> CaseClause a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> CaseClause a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> CaseClause a -> b
foldl :: forall b a. (b -> a -> b) -> b -> CaseClause a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> CaseClause a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> CaseClause a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> CaseClause a -> b
foldr :: forall a b. (a -> b -> b) -> b -> CaseClause a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> CaseClause a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> CaseClause a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> CaseClause a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> CaseClause a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> CaseClause a -> m
fold :: forall m. Monoid m => CaseClause m -> m
$cfold :: forall m. Monoid m => CaseClause m -> m
Foldable,Functor CaseClause
Foldable CaseClause
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
CaseClause (m a) -> m (CaseClause a)
forall (f :: * -> *) a.
Applicative f =>
CaseClause (f a) -> f (CaseClause a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> CaseClause a -> m (CaseClause b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> CaseClause a -> f (CaseClause b)
sequence :: forall (m :: * -> *) a.
Monad m =>
CaseClause (m a) -> m (CaseClause a)
$csequence :: forall (m :: * -> *) a.
Monad m =>
CaseClause (m a) -> m (CaseClause a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> CaseClause a -> m (CaseClause b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> CaseClause a -> m (CaseClause b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
CaseClause (f a) -> f (CaseClause a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
CaseClause (f a) -> f (CaseClause a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> CaseClause a -> f (CaseClause b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> CaseClause a -> f (CaseClause b)
Traversable)
data CatchClause a = CatchClause a (Id a) (Statement a)
deriving (Int -> CatchClause a -> ShowS
forall a. Show a => Int -> CatchClause a -> ShowS
forall a. Show a => [CatchClause a] -> ShowS
forall a. Show a => CatchClause a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CatchClause a] -> ShowS
$cshowList :: forall a. Show a => [CatchClause a] -> ShowS
show :: CatchClause a -> String
$cshow :: forall a. Show a => CatchClause a -> String
showsPrec :: Int -> CatchClause a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> CatchClause a -> ShowS
Show,CatchClause a -> Constr
CatchClause a -> DataType
forall {a}. Data a => Typeable (CatchClause a)
forall a. Data a => CatchClause a -> Constr
forall a. Data a => CatchClause a -> DataType
forall a.
Data a =>
(forall b. Data b => b -> b) -> CatchClause a -> CatchClause a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> CatchClause a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> CatchClause a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CatchClause a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CatchClause a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> CatchClause a -> m (CatchClause a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> CatchClause a -> m (CatchClause a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (CatchClause a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CatchClause a -> c (CatchClause a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (CatchClause a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (CatchClause a))
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 (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (CatchClause a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CatchClause a -> c (CatchClause a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (CatchClause a))
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CatchClause a -> m (CatchClause a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> CatchClause a -> m (CatchClause a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CatchClause a -> m (CatchClause a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> CatchClause a -> m (CatchClause a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> CatchClause a -> m (CatchClause a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> CatchClause a -> m (CatchClause a)
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CatchClause a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> CatchClause a -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> CatchClause a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> CatchClause a -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CatchClause a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CatchClause a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CatchClause a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CatchClause a -> r
gmapT :: (forall b. Data b => b -> b) -> CatchClause a -> CatchClause a
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> CatchClause a -> CatchClause a
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (CatchClause a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (CatchClause a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (CatchClause a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (CatchClause a))
dataTypeOf :: CatchClause a -> DataType
$cdataTypeOf :: forall a. Data a => CatchClause a -> DataType
toConstr :: CatchClause a -> Constr
$ctoConstr :: forall a. Data a => CatchClause a -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (CatchClause a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (CatchClause a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CatchClause a -> c (CatchClause a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CatchClause a -> c (CatchClause a)
Data,Typeable,CatchClause a -> CatchClause a -> Bool
forall a. Eq a => CatchClause a -> CatchClause a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CatchClause a -> CatchClause a -> Bool
$c/= :: forall a. Eq a => CatchClause a -> CatchClause a -> Bool
== :: CatchClause a -> CatchClause a -> Bool
$c== :: forall a. Eq a => CatchClause a -> CatchClause a -> Bool
Eq,CatchClause a -> CatchClause a -> Bool
CatchClause a -> CatchClause a -> Ordering
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
forall {a}. Ord a => Eq (CatchClause a)
forall a. Ord a => CatchClause a -> CatchClause a -> Bool
forall a. Ord a => CatchClause a -> CatchClause a -> Ordering
forall a. Ord a => CatchClause a -> CatchClause a -> CatchClause a
min :: CatchClause a -> CatchClause a -> CatchClause a
$cmin :: forall a. Ord a => CatchClause a -> CatchClause a -> CatchClause a
max :: CatchClause a -> CatchClause a -> CatchClause a
$cmax :: forall a. Ord a => CatchClause a -> CatchClause a -> CatchClause a
>= :: CatchClause a -> CatchClause a -> Bool
$c>= :: forall a. Ord a => CatchClause a -> CatchClause a -> Bool
> :: CatchClause a -> CatchClause a -> Bool
$c> :: forall a. Ord a => CatchClause a -> CatchClause a -> Bool
<= :: CatchClause a -> CatchClause a -> Bool
$c<= :: forall a. Ord a => CatchClause a -> CatchClause a -> Bool
< :: CatchClause a -> CatchClause a -> Bool
$c< :: forall a. Ord a => CatchClause a -> CatchClause a -> Bool
compare :: CatchClause a -> CatchClause a -> Ordering
$ccompare :: forall a. Ord a => CatchClause a -> CatchClause a -> Ordering
Ord,forall a b. a -> CatchClause b -> CatchClause a
forall a b. (a -> b) -> CatchClause a -> CatchClause b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> CatchClause b -> CatchClause a
$c<$ :: forall a b. a -> CatchClause b -> CatchClause a
fmap :: forall a b. (a -> b) -> CatchClause a -> CatchClause b
$cfmap :: forall a b. (a -> b) -> CatchClause a -> CatchClause b
Functor,forall a. Eq a => a -> CatchClause a -> Bool
forall a. Num a => CatchClause a -> a
forall a. Ord a => CatchClause a -> a
forall m. Monoid m => CatchClause m -> m
forall a. CatchClause a -> Bool
forall a. CatchClause a -> Int
forall a. CatchClause a -> [a]
forall a. (a -> a -> a) -> CatchClause a -> a
forall m a. Monoid m => (a -> m) -> CatchClause a -> m
forall b a. (b -> a -> b) -> b -> CatchClause a -> b
forall a b. (a -> b -> b) -> b -> CatchClause a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => CatchClause a -> a
$cproduct :: forall a. Num a => CatchClause a -> a
sum :: forall a. Num a => CatchClause a -> a
$csum :: forall a. Num a => CatchClause a -> a
minimum :: forall a. Ord a => CatchClause a -> a
$cminimum :: forall a. Ord a => CatchClause a -> a
maximum :: forall a. Ord a => CatchClause a -> a
$cmaximum :: forall a. Ord a => CatchClause a -> a
elem :: forall a. Eq a => a -> CatchClause a -> Bool
$celem :: forall a. Eq a => a -> CatchClause a -> Bool
length :: forall a. CatchClause a -> Int
$clength :: forall a. CatchClause a -> Int
null :: forall a. CatchClause a -> Bool
$cnull :: forall a. CatchClause a -> Bool
toList :: forall a. CatchClause a -> [a]
$ctoList :: forall a. CatchClause a -> [a]
foldl1 :: forall a. (a -> a -> a) -> CatchClause a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> CatchClause a -> a
foldr1 :: forall a. (a -> a -> a) -> CatchClause a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> CatchClause a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> CatchClause a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> CatchClause a -> b
foldl :: forall b a. (b -> a -> b) -> b -> CatchClause a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> CatchClause a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> CatchClause a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> CatchClause a -> b
foldr :: forall a b. (a -> b -> b) -> b -> CatchClause a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> CatchClause a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> CatchClause a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> CatchClause a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> CatchClause a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> CatchClause a -> m
fold :: forall m. Monoid m => CatchClause m -> m
$cfold :: forall m. Monoid m => CatchClause m -> m
Foldable,Functor CatchClause
Foldable CatchClause
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
CatchClause (m a) -> m (CatchClause a)
forall (f :: * -> *) a.
Applicative f =>
CatchClause (f a) -> f (CatchClause a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> CatchClause a -> m (CatchClause b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> CatchClause a -> f (CatchClause b)
sequence :: forall (m :: * -> *) a.
Monad m =>
CatchClause (m a) -> m (CatchClause a)
$csequence :: forall (m :: * -> *) a.
Monad m =>
CatchClause (m a) -> m (CatchClause a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> CatchClause a -> m (CatchClause b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> CatchClause a -> m (CatchClause b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
CatchClause (f a) -> f (CatchClause a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
CatchClause (f a) -> f (CatchClause a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> CatchClause a -> f (CatchClause b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> CatchClause a -> f (CatchClause b)
Traversable)
data VarDecl a = VarDecl a (Id a) (Maybe (Expression a))
deriving (Int -> VarDecl a -> ShowS
forall a. Show a => Int -> VarDecl a -> ShowS
forall a. Show a => [VarDecl a] -> ShowS
forall a. Show a => VarDecl a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [VarDecl a] -> ShowS
$cshowList :: forall a. Show a => [VarDecl a] -> ShowS
show :: VarDecl a -> String
$cshow :: forall a. Show a => VarDecl a -> String
showsPrec :: Int -> VarDecl a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> VarDecl a -> ShowS
Show,VarDecl a -> Constr
VarDecl a -> DataType
forall {a}. Data a => Typeable (VarDecl a)
forall a. Data a => VarDecl a -> Constr
forall a. Data a => VarDecl a -> DataType
forall a.
Data a =>
(forall b. Data b => b -> b) -> VarDecl a -> VarDecl a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> VarDecl a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> VarDecl a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> VarDecl a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> VarDecl a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> VarDecl a -> m (VarDecl a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> VarDecl a -> m (VarDecl a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (VarDecl a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> VarDecl a -> c (VarDecl a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (VarDecl a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (VarDecl a))
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 (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (VarDecl a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> VarDecl a -> c (VarDecl a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (VarDecl a))
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> VarDecl a -> m (VarDecl a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> VarDecl a -> m (VarDecl a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> VarDecl a -> m (VarDecl a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> VarDecl a -> m (VarDecl a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> VarDecl a -> m (VarDecl a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> VarDecl a -> m (VarDecl a)
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> VarDecl a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> VarDecl a -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> VarDecl a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> VarDecl a -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> VarDecl a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> VarDecl a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> VarDecl a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> VarDecl a -> r
gmapT :: (forall b. Data b => b -> b) -> VarDecl a -> VarDecl a
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> VarDecl a -> VarDecl a
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (VarDecl a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (VarDecl a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (VarDecl a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (VarDecl a))
dataTypeOf :: VarDecl a -> DataType
$cdataTypeOf :: forall a. Data a => VarDecl a -> DataType
toConstr :: VarDecl a -> Constr
$ctoConstr :: forall a. Data a => VarDecl a -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (VarDecl a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (VarDecl a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> VarDecl a -> c (VarDecl a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> VarDecl a -> c (VarDecl a)
Data,Typeable,VarDecl a -> VarDecl a -> Bool
forall a. Eq a => VarDecl a -> VarDecl a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VarDecl a -> VarDecl a -> Bool
$c/= :: forall a. Eq a => VarDecl a -> VarDecl a -> Bool
== :: VarDecl a -> VarDecl a -> Bool
$c== :: forall a. Eq a => VarDecl a -> VarDecl a -> Bool
Eq,VarDecl a -> VarDecl a -> Bool
VarDecl a -> VarDecl a -> Ordering
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
forall {a}. Ord a => Eq (VarDecl a)
forall a. Ord a => VarDecl a -> VarDecl a -> Bool
forall a. Ord a => VarDecl a -> VarDecl a -> Ordering
forall a. Ord a => VarDecl a -> VarDecl a -> VarDecl a
min :: VarDecl a -> VarDecl a -> VarDecl a
$cmin :: forall a. Ord a => VarDecl a -> VarDecl a -> VarDecl a
max :: VarDecl a -> VarDecl a -> VarDecl a
$cmax :: forall a. Ord a => VarDecl a -> VarDecl a -> VarDecl a
>= :: VarDecl a -> VarDecl a -> Bool
$c>= :: forall a. Ord a => VarDecl a -> VarDecl a -> Bool
> :: VarDecl a -> VarDecl a -> Bool
$c> :: forall a. Ord a => VarDecl a -> VarDecl a -> Bool
<= :: VarDecl a -> VarDecl a -> Bool
$c<= :: forall a. Ord a => VarDecl a -> VarDecl a -> Bool
< :: VarDecl a -> VarDecl a -> Bool
$c< :: forall a. Ord a => VarDecl a -> VarDecl a -> Bool
compare :: VarDecl a -> VarDecl a -> Ordering
$ccompare :: forall a. Ord a => VarDecl a -> VarDecl a -> Ordering
Ord,forall a b. a -> VarDecl b -> VarDecl a
forall a b. (a -> b) -> VarDecl a -> VarDecl b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> VarDecl b -> VarDecl a
$c<$ :: forall a b. a -> VarDecl b -> VarDecl a
fmap :: forall a b. (a -> b) -> VarDecl a -> VarDecl b
$cfmap :: forall a b. (a -> b) -> VarDecl a -> VarDecl b
Functor,forall a. Eq a => a -> VarDecl a -> Bool
forall a. Num a => VarDecl a -> a
forall a. Ord a => VarDecl a -> a
forall m. Monoid m => VarDecl m -> m
forall a. VarDecl a -> Bool
forall a. VarDecl a -> Int
forall a. VarDecl a -> [a]
forall a. (a -> a -> a) -> VarDecl a -> a
forall m a. Monoid m => (a -> m) -> VarDecl a -> m
forall b a. (b -> a -> b) -> b -> VarDecl a -> b
forall a b. (a -> b -> b) -> b -> VarDecl a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => VarDecl a -> a
$cproduct :: forall a. Num a => VarDecl a -> a
sum :: forall a. Num a => VarDecl a -> a
$csum :: forall a. Num a => VarDecl a -> a
minimum :: forall a. Ord a => VarDecl a -> a
$cminimum :: forall a. Ord a => VarDecl a -> a
maximum :: forall a. Ord a => VarDecl a -> a
$cmaximum :: forall a. Ord a => VarDecl a -> a
elem :: forall a. Eq a => a -> VarDecl a -> Bool
$celem :: forall a. Eq a => a -> VarDecl a -> Bool
length :: forall a. VarDecl a -> Int
$clength :: forall a. VarDecl a -> Int
null :: forall a. VarDecl a -> Bool
$cnull :: forall a. VarDecl a -> Bool
toList :: forall a. VarDecl a -> [a]
$ctoList :: forall a. VarDecl a -> [a]
foldl1 :: forall a. (a -> a -> a) -> VarDecl a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> VarDecl a -> a
foldr1 :: forall a. (a -> a -> a) -> VarDecl a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> VarDecl a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> VarDecl a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> VarDecl a -> b
foldl :: forall b a. (b -> a -> b) -> b -> VarDecl a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> VarDecl a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> VarDecl a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> VarDecl a -> b
foldr :: forall a b. (a -> b -> b) -> b -> VarDecl a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> VarDecl a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> VarDecl a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> VarDecl a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> VarDecl a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> VarDecl a -> m
fold :: forall m. Monoid m => VarDecl m -> m
$cfold :: forall m. Monoid m => VarDecl m -> m
Foldable,Functor VarDecl
Foldable VarDecl
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => VarDecl (m a) -> m (VarDecl a)
forall (f :: * -> *) a.
Applicative f =>
VarDecl (f a) -> f (VarDecl a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> VarDecl a -> m (VarDecl b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> VarDecl a -> f (VarDecl b)
sequence :: forall (m :: * -> *) a. Monad m => VarDecl (m a) -> m (VarDecl a)
$csequence :: forall (m :: * -> *) a. Monad m => VarDecl (m a) -> m (VarDecl a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> VarDecl a -> m (VarDecl b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> VarDecl a -> m (VarDecl b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
VarDecl (f a) -> f (VarDecl a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
VarDecl (f a) -> f (VarDecl a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> VarDecl a -> f (VarDecl b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> VarDecl a -> f (VarDecl b)
Traversable)
data ForInit a = NoInit
| VarInit [VarDecl a]
| ExprInit (Expression a)
deriving (Int -> ForInit a -> ShowS
forall a. Show a => Int -> ForInit a -> ShowS
forall a. Show a => [ForInit a] -> ShowS
forall a. Show a => ForInit a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ForInit a] -> ShowS
$cshowList :: forall a. Show a => [ForInit a] -> ShowS
show :: ForInit a -> String
$cshow :: forall a. Show a => ForInit a -> String
showsPrec :: Int -> ForInit a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> ForInit a -> ShowS
Show,ForInit a -> Constr
ForInit a -> DataType
forall {a}. Data a => Typeable (ForInit a)
forall a. Data a => ForInit a -> Constr
forall a. Data a => ForInit a -> DataType
forall a.
Data a =>
(forall b. Data b => b -> b) -> ForInit a -> ForInit a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> ForInit a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> ForInit a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ForInit a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ForInit a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> ForInit a -> m (ForInit a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> ForInit a -> m (ForInit a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ForInit a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ForInit a -> c (ForInit a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (ForInit a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ForInit a))
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 (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ForInit a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ForInit a -> c (ForInit a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (ForInit a))
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ForInit a -> m (ForInit a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> ForInit a -> m (ForInit a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ForInit a -> m (ForInit a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> ForInit a -> m (ForInit a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ForInit a -> m (ForInit a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> ForInit a -> m (ForInit a)
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ForInit a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> ForInit a -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> ForInit a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> ForInit a -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ForInit a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ForInit a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ForInit a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ForInit a -> r
gmapT :: (forall b. Data b => b -> b) -> ForInit a -> ForInit a
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> ForInit a -> ForInit a
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ForInit a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ForInit a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (ForInit a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (ForInit a))
dataTypeOf :: ForInit a -> DataType
$cdataTypeOf :: forall a. Data a => ForInit a -> DataType
toConstr :: ForInit a -> Constr
$ctoConstr :: forall a. Data a => ForInit a -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ForInit a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ForInit a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ForInit a -> c (ForInit a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ForInit a -> c (ForInit a)
Data,Typeable,ForInit a -> ForInit a -> Bool
forall a. Eq a => ForInit a -> ForInit a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ForInit a -> ForInit a -> Bool
$c/= :: forall a. Eq a => ForInit a -> ForInit a -> Bool
== :: ForInit a -> ForInit a -> Bool
$c== :: forall a. Eq a => ForInit a -> ForInit a -> Bool
Eq,ForInit a -> ForInit a -> Bool
ForInit a -> ForInit a -> Ordering
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
forall {a}. Ord a => Eq (ForInit a)
forall a. Ord a => ForInit a -> ForInit a -> Bool
forall a. Ord a => ForInit a -> ForInit a -> Ordering
forall a. Ord a => ForInit a -> ForInit a -> ForInit a
min :: ForInit a -> ForInit a -> ForInit a
$cmin :: forall a. Ord a => ForInit a -> ForInit a -> ForInit a
max :: ForInit a -> ForInit a -> ForInit a
$cmax :: forall a. Ord a => ForInit a -> ForInit a -> ForInit a
>= :: ForInit a -> ForInit a -> Bool
$c>= :: forall a. Ord a => ForInit a -> ForInit a -> Bool
> :: ForInit a -> ForInit a -> Bool
$c> :: forall a. Ord a => ForInit a -> ForInit a -> Bool
<= :: ForInit a -> ForInit a -> Bool
$c<= :: forall a. Ord a => ForInit a -> ForInit a -> Bool
< :: ForInit a -> ForInit a -> Bool
$c< :: forall a. Ord a => ForInit a -> ForInit a -> Bool
compare :: ForInit a -> ForInit a -> Ordering
$ccompare :: forall a. Ord a => ForInit a -> ForInit a -> Ordering
Ord,forall a b. a -> ForInit b -> ForInit a
forall a b. (a -> b) -> ForInit a -> ForInit b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> ForInit b -> ForInit a
$c<$ :: forall a b. a -> ForInit b -> ForInit a
fmap :: forall a b. (a -> b) -> ForInit a -> ForInit b
$cfmap :: forall a b. (a -> b) -> ForInit a -> ForInit b
Functor,forall a. Eq a => a -> ForInit a -> Bool
forall a. Num a => ForInit a -> a
forall a. Ord a => ForInit a -> a
forall m. Monoid m => ForInit m -> m
forall a. ForInit a -> Bool
forall a. ForInit a -> Int
forall a. ForInit a -> [a]
forall a. (a -> a -> a) -> ForInit a -> a
forall m a. Monoid m => (a -> m) -> ForInit a -> m
forall b a. (b -> a -> b) -> b -> ForInit a -> b
forall a b. (a -> b -> b) -> b -> ForInit a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => ForInit a -> a
$cproduct :: forall a. Num a => ForInit a -> a
sum :: forall a. Num a => ForInit a -> a
$csum :: forall a. Num a => ForInit a -> a
minimum :: forall a. Ord a => ForInit a -> a
$cminimum :: forall a. Ord a => ForInit a -> a
maximum :: forall a. Ord a => ForInit a -> a
$cmaximum :: forall a. Ord a => ForInit a -> a
elem :: forall a. Eq a => a -> ForInit a -> Bool
$celem :: forall a. Eq a => a -> ForInit a -> Bool
length :: forall a. ForInit a -> Int
$clength :: forall a. ForInit a -> Int
null :: forall a. ForInit a -> Bool
$cnull :: forall a. ForInit a -> Bool
toList :: forall a. ForInit a -> [a]
$ctoList :: forall a. ForInit a -> [a]
foldl1 :: forall a. (a -> a -> a) -> ForInit a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> ForInit a -> a
foldr1 :: forall a. (a -> a -> a) -> ForInit a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> ForInit a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> ForInit a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> ForInit a -> b
foldl :: forall b a. (b -> a -> b) -> b -> ForInit a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> ForInit a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> ForInit a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> ForInit a -> b
foldr :: forall a b. (a -> b -> b) -> b -> ForInit a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> ForInit a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> ForInit a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> ForInit a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> ForInit a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> ForInit a -> m
fold :: forall m. Monoid m => ForInit m -> m
$cfold :: forall m. Monoid m => ForInit m -> m
Foldable,Functor ForInit
Foldable ForInit
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => ForInit (m a) -> m (ForInit a)
forall (f :: * -> *) a.
Applicative f =>
ForInit (f a) -> f (ForInit a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ForInit a -> m (ForInit b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ForInit a -> f (ForInit b)
sequence :: forall (m :: * -> *) a. Monad m => ForInit (m a) -> m (ForInit a)
$csequence :: forall (m :: * -> *) a. Monad m => ForInit (m a) -> m (ForInit a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ForInit a -> m (ForInit b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ForInit a -> m (ForInit b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
ForInit (f a) -> f (ForInit a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
ForInit (f a) -> f (ForInit a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ForInit a -> f (ForInit b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ForInit a -> f (ForInit b)
Traversable)
data ForInInit a = ForInVar (Id a)
| ForInLVal (LValue a)
deriving (Int -> ForInInit a -> ShowS
forall a. Show a => Int -> ForInInit a -> ShowS
forall a. Show a => [ForInInit a] -> ShowS
forall a. Show a => ForInInit a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ForInInit a] -> ShowS
$cshowList :: forall a. Show a => [ForInInit a] -> ShowS
show :: ForInInit a -> String
$cshow :: forall a. Show a => ForInInit a -> String
showsPrec :: Int -> ForInInit a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> ForInInit a -> ShowS
Show,ForInInit a -> Constr
ForInInit a -> DataType
forall {a}. Data a => Typeable (ForInInit a)
forall a. Data a => ForInInit a -> Constr
forall a. Data a => ForInInit a -> DataType
forall a.
Data a =>
(forall b. Data b => b -> b) -> ForInInit a -> ForInInit a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> ForInInit a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> ForInInit a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ForInInit a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ForInInit a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> ForInInit a -> m (ForInInit a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> ForInInit a -> m (ForInInit a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ForInInit a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ForInInit a -> c (ForInInit a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (ForInInit a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ForInInit a))
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 (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ForInInit a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ForInInit a -> c (ForInInit a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (ForInInit a))
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ForInInit a -> m (ForInInit a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> ForInInit a -> m (ForInInit a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ForInInit a -> m (ForInInit a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> ForInInit a -> m (ForInInit a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ForInInit a -> m (ForInInit a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> ForInInit a -> m (ForInInit a)
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ForInInit a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> ForInInit a -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> ForInInit a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> ForInInit a -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ForInInit a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ForInInit a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ForInInit a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ForInInit a -> r
gmapT :: (forall b. Data b => b -> b) -> ForInInit a -> ForInInit a
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> ForInInit a -> ForInInit a
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ForInInit a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ForInInit a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (ForInInit a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (ForInInit a))
dataTypeOf :: ForInInit a -> DataType
$cdataTypeOf :: forall a. Data a => ForInInit a -> DataType
toConstr :: ForInInit a -> Constr
$ctoConstr :: forall a. Data a => ForInInit a -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ForInInit a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ForInInit a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ForInInit a -> c (ForInInit a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ForInInit a -> c (ForInInit a)
Data,Typeable,ForInInit a -> ForInInit a -> Bool
forall a. Eq a => ForInInit a -> ForInInit a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ForInInit a -> ForInInit a -> Bool
$c/= :: forall a. Eq a => ForInInit a -> ForInInit a -> Bool
== :: ForInInit a -> ForInInit a -> Bool
$c== :: forall a. Eq a => ForInInit a -> ForInInit a -> Bool
Eq,ForInInit a -> ForInInit a -> Bool
ForInInit a -> ForInInit a -> Ordering
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
forall {a}. Ord a => Eq (ForInInit a)
forall a. Ord a => ForInInit a -> ForInInit a -> Bool
forall a. Ord a => ForInInit a -> ForInInit a -> Ordering
forall a. Ord a => ForInInit a -> ForInInit a -> ForInInit a
min :: ForInInit a -> ForInInit a -> ForInInit a
$cmin :: forall a. Ord a => ForInInit a -> ForInInit a -> ForInInit a
max :: ForInInit a -> ForInInit a -> ForInInit a
$cmax :: forall a. Ord a => ForInInit a -> ForInInit a -> ForInInit a
>= :: ForInInit a -> ForInInit a -> Bool
$c>= :: forall a. Ord a => ForInInit a -> ForInInit a -> Bool
> :: ForInInit a -> ForInInit a -> Bool
$c> :: forall a. Ord a => ForInInit a -> ForInInit a -> Bool
<= :: ForInInit a -> ForInInit a -> Bool
$c<= :: forall a. Ord a => ForInInit a -> ForInInit a -> Bool
< :: ForInInit a -> ForInInit a -> Bool
$c< :: forall a. Ord a => ForInInit a -> ForInInit a -> Bool
compare :: ForInInit a -> ForInInit a -> Ordering
$ccompare :: forall a. Ord a => ForInInit a -> ForInInit a -> Ordering
Ord,forall a b. a -> ForInInit b -> ForInInit a
forall a b. (a -> b) -> ForInInit a -> ForInInit b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> ForInInit b -> ForInInit a
$c<$ :: forall a b. a -> ForInInit b -> ForInInit a
fmap :: forall a b. (a -> b) -> ForInInit a -> ForInInit b
$cfmap :: forall a b. (a -> b) -> ForInInit a -> ForInInit b
Functor,forall a. Eq a => a -> ForInInit a -> Bool
forall a. Num a => ForInInit a -> a
forall a. Ord a => ForInInit a -> a
forall m. Monoid m => ForInInit m -> m
forall a. ForInInit a -> Bool
forall a. ForInInit a -> Int
forall a. ForInInit a -> [a]
forall a. (a -> a -> a) -> ForInInit a -> a
forall m a. Monoid m => (a -> m) -> ForInInit a -> m
forall b a. (b -> a -> b) -> b -> ForInInit a -> b
forall a b. (a -> b -> b) -> b -> ForInInit a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => ForInInit a -> a
$cproduct :: forall a. Num a => ForInInit a -> a
sum :: forall a. Num a => ForInInit a -> a
$csum :: forall a. Num a => ForInInit a -> a
minimum :: forall a. Ord a => ForInInit a -> a
$cminimum :: forall a. Ord a => ForInInit a -> a
maximum :: forall a. Ord a => ForInInit a -> a
$cmaximum :: forall a. Ord a => ForInInit a -> a
elem :: forall a. Eq a => a -> ForInInit a -> Bool
$celem :: forall a. Eq a => a -> ForInInit a -> Bool
length :: forall a. ForInInit a -> Int
$clength :: forall a. ForInInit a -> Int
null :: forall a. ForInInit a -> Bool
$cnull :: forall a. ForInInit a -> Bool
toList :: forall a. ForInInit a -> [a]
$ctoList :: forall a. ForInInit a -> [a]
foldl1 :: forall a. (a -> a -> a) -> ForInInit a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> ForInInit a -> a
foldr1 :: forall a. (a -> a -> a) -> ForInInit a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> ForInInit a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> ForInInit a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> ForInInit a -> b
foldl :: forall b a. (b -> a -> b) -> b -> ForInInit a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> ForInInit a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> ForInInit a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> ForInInit a -> b
foldr :: forall a b. (a -> b -> b) -> b -> ForInInit a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> ForInInit a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> ForInInit a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> ForInInit a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> ForInInit a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> ForInInit a -> m
fold :: forall m. Monoid m => ForInInit m -> m
$cfold :: forall m. Monoid m => ForInInit m -> m
Foldable,Functor ForInInit
Foldable ForInInit
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
ForInInit (m a) -> m (ForInInit a)
forall (f :: * -> *) a.
Applicative f =>
ForInInit (f a) -> f (ForInInit a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ForInInit a -> m (ForInInit b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ForInInit a -> f (ForInInit b)
sequence :: forall (m :: * -> *) a.
Monad m =>
ForInInit (m a) -> m (ForInInit a)
$csequence :: forall (m :: * -> *) a.
Monad m =>
ForInInit (m a) -> m (ForInInit a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ForInInit a -> m (ForInInit b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ForInInit a -> m (ForInInit b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
ForInInit (f a) -> f (ForInInit a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
ForInInit (f a) -> f (ForInInit a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ForInInit a -> f (ForInInit b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ForInInit a -> f (ForInInit b)
Traversable)
data Statement a
= BlockStmt a [Statement a]
| EmptyStmt a
| ExprStmt a (Expression a)
| IfStmt a (Expression a) (Statement a) (Statement a)
| IfSingleStmt a (Expression a) (Statement a)
| SwitchStmt a (Expression a) [CaseClause a]
| WhileStmt a (Expression a) (Statement a)
| DoWhileStmt a (Statement a) (Expression a)
| BreakStmt a (Maybe (Id a))
| ContinueStmt a (Maybe (Id a))
| LabelledStmt a (Id a) (Statement a)
| ForInStmt a (ForInInit a) (Expression a) (Statement a)
| ForStmt a (ForInit a)
(Maybe (Expression a))
(Maybe (Expression a))
(Statement a)
| TryStmt a (Statement a) (Maybe (CatchClause a))
(Maybe (Statement a))
| ThrowStmt a (Expression a)
| ReturnStmt a (Maybe (Expression a))
| WithStmt a (Expression a) (Statement a)
| VarDeclStmt a [VarDecl a]
| FunctionStmt a (Id a) [Id a] [Statement a]
deriving (Int -> Statement a -> ShowS
forall a. Show a => Int -> Statement a -> ShowS
forall a. Show a => [Statement a] -> ShowS
forall a. Show a => Statement a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Statement a] -> ShowS
$cshowList :: forall a. Show a => [Statement a] -> ShowS
show :: Statement a -> String
$cshow :: forall a. Show a => Statement a -> String
showsPrec :: Int -> Statement a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Statement a -> ShowS
Show,Statement a -> Constr
Statement a -> DataType
forall {a}. Data a => Typeable (Statement a)
forall a. Data a => Statement a -> Constr
forall a. Data a => Statement a -> DataType
forall a.
Data a =>
(forall b. Data b => b -> b) -> Statement a -> Statement a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Statement a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> Statement a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Statement a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Statement a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Statement a -> m (Statement a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Statement a -> m (Statement a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Statement a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Statement a -> c (Statement a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Statement a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Statement a))
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 (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Statement a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Statement a -> c (Statement a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Statement a))
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Statement a -> m (Statement a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Statement a -> m (Statement a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Statement a -> m (Statement a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Statement a -> m (Statement a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Statement a -> m (Statement a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Statement a -> m (Statement a)
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Statement a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Statement a -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Statement a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> Statement a -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Statement a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Statement a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Statement a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Statement a -> r
gmapT :: (forall b. Data b => b -> b) -> Statement a -> Statement a
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> Statement a -> Statement a
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Statement a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Statement a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Statement a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Statement a))
dataTypeOf :: Statement a -> DataType
$cdataTypeOf :: forall a. Data a => Statement a -> DataType
toConstr :: Statement a -> Constr
$ctoConstr :: forall a. Data a => Statement a -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Statement a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Statement a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Statement a -> c (Statement a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Statement a -> c (Statement a)
Data,Typeable,Statement a -> Statement a -> Bool
forall a. Eq a => Statement a -> Statement a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Statement a -> Statement a -> Bool
$c/= :: forall a. Eq a => Statement a -> Statement a -> Bool
== :: Statement a -> Statement a -> Bool
$c== :: forall a. Eq a => Statement a -> Statement a -> Bool
Eq,Statement a -> Statement a -> Ordering
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
forall {a}. Ord a => Eq (Statement a)
forall a. Ord a => Statement a -> Statement a -> Bool
forall a. Ord a => Statement a -> Statement a -> Ordering
forall a. Ord a => Statement a -> Statement a -> Statement a
min :: Statement a -> Statement a -> Statement a
$cmin :: forall a. Ord a => Statement a -> Statement a -> Statement a
max :: Statement a -> Statement a -> Statement a
$cmax :: forall a. Ord a => Statement a -> Statement a -> Statement a
>= :: Statement a -> Statement a -> Bool
$c>= :: forall a. Ord a => Statement a -> Statement a -> Bool
> :: Statement a -> Statement a -> Bool
$c> :: forall a. Ord a => Statement a -> Statement a -> Bool
<= :: Statement a -> Statement a -> Bool
$c<= :: forall a. Ord a => Statement a -> Statement a -> Bool
< :: Statement a -> Statement a -> Bool
$c< :: forall a. Ord a => Statement a -> Statement a -> Bool
compare :: Statement a -> Statement a -> Ordering
$ccompare :: forall a. Ord a => Statement a -> Statement a -> Ordering
Ord,forall a b. a -> Statement b -> Statement a
forall a b. (a -> b) -> Statement a -> Statement b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> Statement b -> Statement a
$c<$ :: forall a b. a -> Statement b -> Statement a
fmap :: forall a b. (a -> b) -> Statement a -> Statement b
$cfmap :: forall a b. (a -> b) -> Statement a -> Statement b
Functor,forall a. Eq a => a -> Statement a -> Bool
forall a. Num a => Statement a -> a
forall a. Ord a => Statement a -> a
forall m. Monoid m => Statement m -> m
forall a. Statement a -> Bool
forall a. Statement a -> Int
forall a. Statement a -> [a]
forall a. (a -> a -> a) -> Statement a -> a
forall m a. Monoid m => (a -> m) -> Statement a -> m
forall b a. (b -> a -> b) -> b -> Statement a -> b
forall a b. (a -> b -> b) -> b -> Statement a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => Statement a -> a
$cproduct :: forall a. Num a => Statement a -> a
sum :: forall a. Num a => Statement a -> a
$csum :: forall a. Num a => Statement a -> a
minimum :: forall a. Ord a => Statement a -> a
$cminimum :: forall a. Ord a => Statement a -> a
maximum :: forall a. Ord a => Statement a -> a
$cmaximum :: forall a. Ord a => Statement a -> a
elem :: forall a. Eq a => a -> Statement a -> Bool
$celem :: forall a. Eq a => a -> Statement a -> Bool
length :: forall a. Statement a -> Int
$clength :: forall a. Statement a -> Int
null :: forall a. Statement a -> Bool
$cnull :: forall a. Statement a -> Bool
toList :: forall a. Statement a -> [a]
$ctoList :: forall a. Statement a -> [a]
foldl1 :: forall a. (a -> a -> a) -> Statement a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Statement a -> a
foldr1 :: forall a. (a -> a -> a) -> Statement a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Statement a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> Statement a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Statement a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Statement a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Statement a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Statement a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Statement a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Statement a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> Statement a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> Statement a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Statement a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Statement a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Statement a -> m
fold :: forall m. Monoid m => Statement m -> m
$cfold :: forall m. Monoid m => Statement m -> m
Foldable,Functor Statement
Foldable Statement
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
Statement (m a) -> m (Statement a)
forall (f :: * -> *) a.
Applicative f =>
Statement (f a) -> f (Statement a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Statement a -> m (Statement b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Statement a -> f (Statement b)
sequence :: forall (m :: * -> *) a.
Monad m =>
Statement (m a) -> m (Statement a)
$csequence :: forall (m :: * -> *) a.
Monad m =>
Statement (m a) -> m (Statement a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Statement a -> m (Statement b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Statement a -> m (Statement b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Statement (f a) -> f (Statement a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Statement (f a) -> f (Statement a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Statement a -> f (Statement b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Statement a -> f (Statement b)
Traversable)
isIterationStmt :: Statement a -> Bool
isIterationStmt :: forall a. Statement a -> Bool
isIterationStmt Statement a
s = case Statement a
s of
WhileStmt {} -> Bool
True
DoWhileStmt {} -> Bool
True
ForStmt {} -> Bool
True
ForInStmt {} -> Bool
True
Statement a
_ -> Bool
False
isValid :: forall a. (Data a, Typeable a) => JavaScript a -> Bool
isValid :: forall a. (Data a, Typeable a) => JavaScript a -> Bool
isValid JavaScript a
js = (Data a, Typeable a) => JavaScript a -> Bool
checkIdentifiers JavaScript a
js Bool -> Bool -> Bool
&& forall {a}. Data a => JavaScript a -> Bool
checkBreakContinueLabels JavaScript a
js
where checkIdentifiers :: (Data a, Typeable a) => JavaScript a -> Bool
checkIdentifiers :: (Data a, Typeable a) => JavaScript a -> Bool
checkIdentifiers JavaScript a
js =
forall (t :: * -> *). Foldable t => t Bool -> Bool
and forall a b. (a -> b) -> a -> b
$ forall a b. (a -> b) -> [a] -> [b]
map String -> Bool
isValidIdentifierName forall a b. (a -> b) -> a -> b
$
[String
n | (Id a
_ String
n) :: Id a <- forall from to. Biplate from to => from -> [to]
universeBi JavaScript a
js] forall a. [a] -> [a] -> [a]
++
[String
n | (LVar a
_ String
n) :: LValue a <- forall from to. Biplate from to => from -> [to]
universeBi JavaScript a
js] forall a. [a] -> [a] -> [a]
++
[String
n | (LDot a
_ Expression a
_ String
n) :: LValue a <- forall from to. Biplate from to => from -> [to]
universeBi JavaScript a
js]
checkBreakContinueLabels :: JavaScript a -> Bool
checkBreakContinueLabels js :: JavaScript a
js@(Script a
_ [Statement a]
body) = forall (t :: * -> *). Foldable t => t Bool -> Bool
and forall a b. (a -> b) -> a -> b
$ forall a b. (a -> b) -> [a] -> [b]
map forall a. Statement a -> Bool
checkStmt forall a b. (a -> b) -> a -> b
$
[Statement a]
body forall a. [a] -> [a] -> [a]
++ forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([[Statement a]
body | FuncExpr a
_ Maybe (Id a)
_ [Id a]
_ [Statement a]
body <- forall from to. Biplate from to => from -> [to]
universeBi JavaScript a
js] forall a. [a] -> [a] -> [a]
++
[[Statement a]
body | FunctionStmt a
_ Id a
_ [Id a]
_ [Statement a]
body <- forall from to. Biplate from to => from -> [to]
universeBi JavaScript a
js])
checkStmt :: Statement a -> Bool
checkStmt :: forall a. Statement a -> Bool
checkStmt Statement a
s = forall s a. State s a -> s -> a
evalState (forall a.
Statement a -> State ([String], [EnclosingStatement]) Bool
checkStmtM Statement a
s) ([], [])
checkStmtM :: Statement a -> State ([Label], [EnclosingStatement]) Bool
checkStmtM :: forall a.
Statement a -> State ([String], [EnclosingStatement]) Bool
checkStmtM Statement a
stmt = case Statement a
stmt of
ContinueStmt a
a Maybe (Id a)
mlab -> do
[EnclosingStatement]
encls <- forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets forall a b. (a, b) -> b
snd
let enIts :: [EnclosingStatement]
enIts = forall a. (a -> Bool) -> [a] -> [a]
filter EnclosingStatement -> Bool
isIter [EnclosingStatement]
encls
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ case Maybe (Id a)
mlab of
Maybe (Id a)
Nothing -> Bool -> Bool
not forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) a. Foldable t => t a -> Bool
null [EnclosingStatement]
enIts
Just Id a
lab -> forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any (forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
elem (forall a. Id a -> String
unId Id a
lab) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. HasLabelSet a => a -> [String]
getLabelSet) [EnclosingStatement]
enIts
BreakStmt a
a Maybe (Id a)
mlab -> do
[EnclosingStatement]
encls <- forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets forall a b. (a, b) -> b
snd
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ case Maybe (Id a)
mlab of
Maybe (Id a)
Nothing -> forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any EnclosingStatement -> Bool
isIterSwitch [EnclosingStatement]
encls
Just Id a
lab -> forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any (forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
elem (forall a. Id a -> String
unId Id a
lab) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. HasLabelSet a => a -> [String]
getLabelSet) [EnclosingStatement]
encls
LabelledStmt a
_ Id a
lab Statement a
s -> do
[String]
labs <- forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets forall a b. (a, b) -> a
fst
if (forall a. Id a -> String
unId Id a
lab) forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [String]
labs then forall (m :: * -> *) a. Monad m => a -> m a
return Bool
False
else forall (m :: * -> *) b a.
Monad m =>
Id b
-> StateT ([String], [EnclosingStatement]) m a
-> StateT ([String], [EnclosingStatement]) m a
pushLabel Id a
lab forall a b. (a -> b) -> a -> b
$ forall a.
Statement a -> State ([String], [EnclosingStatement]) Bool
checkStmtM Statement a
s
WhileStmt a
_ Expression a
_ Statement a
s -> forall a.
Statement a -> State ([String], [EnclosingStatement]) Bool
iterCommon Statement a
s
DoWhileStmt a
_ Statement a
s Expression a
_ -> forall a.
Statement a -> State ([String], [EnclosingStatement]) Bool
iterCommon Statement a
s
ForStmt a
_ ForInit a
_ Maybe (Expression a)
_ Maybe (Expression a)
_ Statement a
s -> forall a.
Statement a -> State ([String], [EnclosingStatement]) Bool
iterCommon Statement a
s
ForInStmt a
_ ForInInit a
_ Expression a
_ Statement a
s -> forall a.
Statement a -> State ([String], [EnclosingStatement]) Bool
iterCommon Statement a
s
SwitchStmt a
_ Expression a
_ [CaseClause a]
cs -> forall (m :: * -> *) a.
Monad m =>
([String] -> EnclosingStatement)
-> StateT ([String], [EnclosingStatement]) m a
-> StateT ([String], [EnclosingStatement]) m a
pushEnclosing [String] -> EnclosingStatement
EnclosingSwitch forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM forall (t :: * -> *). Foldable t => t Bool -> Bool
and forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM forall {a}.
CaseClause a -> State ([String], [EnclosingStatement]) Bool
checkCaseM [CaseClause a]
cs
BlockStmt a
_ [Statement a]
ss -> forall (m :: * -> *) a.
Monad m =>
([String] -> EnclosingStatement)
-> StateT ([String], [EnclosingStatement]) m a
-> StateT ([String], [EnclosingStatement]) m a
pushEnclosing [String] -> EnclosingStatement
EnclosingOther forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM forall (t :: * -> *). Foldable t => t Bool -> Bool
and forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM forall a.
Statement a -> State ([String], [EnclosingStatement]) Bool
checkStmtM [Statement a]
ss
IfStmt a
_ Expression a
_ Statement a
t Statement a
e -> forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 Bool -> Bool -> Bool
(&&) (forall a.
Statement a -> State ([String], [EnclosingStatement]) Bool
checkStmtM Statement a
t) (forall a.
Statement a -> State ([String], [EnclosingStatement]) Bool
checkStmtM Statement a
e)
IfSingleStmt a
_ Expression a
_ Statement a
t -> forall a.
Statement a -> State ([String], [EnclosingStatement]) Bool
checkStmtM Statement a
t
TryStmt a
_ Statement a
body Maybe (CatchClause a)
mcatch Maybe (Statement a)
mfinally -> forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 Bool -> Bool -> Bool
(&&) (forall a.
Statement a -> State ([String], [EnclosingStatement]) Bool
checkStmtM Statement a
body) forall a b. (a -> b) -> a -> b
$
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 Bool -> Bool -> Bool
(&&) (forall b a. b -> (a -> b) -> Maybe a -> b
maybe (forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True) forall {a}.
CatchClause a -> State ([String], [EnclosingStatement]) Bool
checkCatchM Maybe (CatchClause a)
mcatch)
(forall b a. b -> (a -> b) -> Maybe a -> b
maybe (forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True) forall a.
Statement a -> State ([String], [EnclosingStatement]) Bool
checkStmtM Maybe (Statement a)
mfinally)
WithStmt a
_ Expression a
_ Statement a
body -> forall a.
Statement a -> State ([String], [EnclosingStatement]) Bool
checkStmtM Statement a
body
Statement a
_ -> forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True
iterCommon :: Statement a -> State ([String], [EnclosingStatement]) Bool
iterCommon Statement a
s = forall (m :: * -> *) a.
Monad m =>
([String] -> EnclosingStatement)
-> StateT ([String], [EnclosingStatement]) m a
-> StateT ([String], [EnclosingStatement]) m a
pushEnclosing [String] -> EnclosingStatement
EnclosingIter forall a b. (a -> b) -> a -> b
$ forall a.
Statement a -> State ([String], [EnclosingStatement]) Bool
checkStmtM Statement a
s
pushEnclosing :: Monad m => ([Label] -> EnclosingStatement)
-> StateT ([Label], [EnclosingStatement]) m a
-> StateT ([Label], [EnclosingStatement]) m a
pushEnclosing :: forall (m :: * -> *) a.
Monad m =>
([String] -> EnclosingStatement)
-> StateT ([String], [EnclosingStatement]) m a
-> StateT ([String], [EnclosingStatement]) m a
pushEnclosing [String] -> EnclosingStatement
ctor = forall (m :: * -> *) s a.
Monad m =>
(s -> s) -> StateT s m a -> StateT s m a
bracketState (\([String]
labs, [EnclosingStatement]
encls) -> ([], [String] -> EnclosingStatement
ctor [String]
labsforall a. a -> [a] -> [a]
:[EnclosingStatement]
encls))
pushLabel :: Monad m => Id b -> StateT ([Label], [EnclosingStatement]) m a
-> StateT ([Label], [EnclosingStatement]) m a
pushLabel :: forall (m :: * -> *) b a.
Monad m =>
Id b
-> StateT ([String], [EnclosingStatement]) m a
-> StateT ([String], [EnclosingStatement]) m a
pushLabel Id b
l = forall (m :: * -> *) s a.
Monad m =>
(s -> s) -> StateT s m a -> StateT s m a
bracketState (forall (a :: * -> * -> *) b c d.
Arrow a =>
a b c -> a (b, d) (c, d)
first (forall a. Id a -> String
unId Id b
lforall a. a -> [a] -> [a]
:))
checkCaseM :: CaseClause a -> State ([String], [EnclosingStatement]) Bool
checkCaseM CaseClause a
c = let ss :: [Statement a]
ss = case CaseClause a
c of
CaseClause a
_ Expression a
_ [Statement a]
body -> [Statement a]
body
CaseDefault a
_ [Statement a]
body -> [Statement a]
body
in forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM forall (t :: * -> *). Foldable t => t Bool -> Bool
and forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM forall a.
Statement a -> State ([String], [EnclosingStatement]) Bool
checkStmtM [Statement a]
ss
checkCatchM :: CatchClause a -> State ([String], [EnclosingStatement]) Bool
checkCatchM (CatchClause a
_ Id a
_ Statement a
body) = forall a.
Statement a -> State ([String], [EnclosingStatement]) Bool
checkStmtM Statement a
body
bracketState :: Monad m => (s -> s) -> StateT s m a -> StateT s m a
bracketState :: forall (m :: * -> *) s a.
Monad m =>
(s -> s) -> StateT s m a -> StateT s m a
bracketState s -> s
f StateT s m a
m = do s
original <- forall s (m :: * -> *). MonadState s m => m s
get
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify s -> s
f
a
rv <- StateT s m a
m
forall s (m :: * -> *). MonadState s m => s -> m ()
put s
original
forall (m :: * -> *) a. Monad m => a -> m a
return a
rv
isValidIdentifier :: Id a -> Bool
isValidIdentifier :: forall a. Id a -> Bool
isValidIdentifier (Id a
_ String
name) = String -> Bool
isValidIdentifierName String
name
isValidIdentifierName :: String -> Bool
isValidIdentifierName :: String -> Bool
isValidIdentifierName String
name = case String
name of
String
"" -> Bool
False
(Char
c:String
cs) -> Char -> Bool
isValidIdStart Char
c Bool -> Bool -> Bool
&& forall (t :: * -> *). Foldable t => t Bool -> Bool
and (forall a b. (a -> b) -> [a] -> [b]
map Char -> Bool
isValidIdPart String
cs) Bool -> Bool -> Bool
&& (Bool -> Bool
not forall a b. (a -> b) -> a -> b
$ String -> Bool
isReservedWord String
name)
isReservedWord :: String -> Bool
isReservedWord :: String -> Bool
isReservedWord = (forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [String]
reservedWords)
where reservedWords :: [String]
reservedWords = [String]
keyword forall a. [a] -> [a] -> [a]
++ [String]
futureReservedWord forall a. [a] -> [a] -> [a]
++ [String]
nullKw forall a. [a] -> [a] -> [a]
++ [String]
boolLit
keyword :: [String]
keyword = [String
"break", String
"case", String
"catch", String
"continue", String
"default", String
"delete"
,String
"do", String
"else", String
"finally", String
"for", String
"function", String
"if", String
"in"
,String
"instanceof", String
"new", String
"return", String
"switch", String
"this", String
"throw"
,String
"try", String
"typeof", String
"var", String
"void", String
"while", String
"with"]
futureReservedWord :: [String]
futureReservedWord = [String
"abstract", String
"boolean", String
"byte", String
"char", String
"class"
,String
"const", String
"debugger", String
"enum", String
"export", String
"extends"
,String
"final", String
"float", String
"goto", String
"implements", String
"int"
,String
"interface", String
"long", String
"native", String
"package", String
"private"
,String
"protected", String
"short", String
"static", String
"super"
,String
"synchronized", String
"throws", String
"transient", String
"volatile"]
nullKw :: [String]
nullKw = [String
"null"]
boolLit :: [String]
boolLit = [String
"true", String
"false"]
isValidIdStart :: Char -> Bool
isValidIdStart :: Char -> Bool
isValidIdStart Char
c = Char -> Bool
unicodeLetter Char
c Bool -> Bool -> Bool
|| Char
c forall a. Eq a => a -> a -> Bool
== Char
'$' Bool -> Bool -> Bool
|| Char
c forall a. Eq a => a -> a -> Bool
== Char
'_'
where unicodeLetter :: Char -> Bool
unicodeLetter Char
c = case Char -> GeneralCategory
generalCategory Char
c of
GeneralCategory
UppercaseLetter -> Bool
True
GeneralCategory
LowercaseLetter -> Bool
True
GeneralCategory
TitlecaseLetter -> Bool
True
GeneralCategory
ModifierLetter -> Bool
True
GeneralCategory
OtherLetter -> Bool
True
GeneralCategory
LetterNumber -> Bool
True
GeneralCategory
_ -> Bool
False
isValidIdPart :: Char -> Bool
isValidIdPart :: Char -> Bool
isValidIdPart Char
c = Char -> Bool
isValidIdStart Char
c Bool -> Bool -> Bool
|| Char -> Bool
isValidIdPartUnicode Char
c
where isValidIdPartUnicode :: Char -> Bool
isValidIdPartUnicode Char
c = case Char -> GeneralCategory
generalCategory Char
c of
GeneralCategory
NonSpacingMark -> Bool
True
GeneralCategory
SpacingCombiningMark -> Bool
True
GeneralCategory
DecimalNumber -> Bool
True
GeneralCategory
ConnectorPunctuation -> Bool
True
GeneralCategory
_ -> Bool
False
data EnclosingStatement = EnclosingIter [Label]
| EnclosingSwitch [Label]
| EnclosingOther [Label]
instance Show EnclosingStatement where
show :: EnclosingStatement -> String
show (EnclosingIter [String]
ls) = String
"iteration" forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show [String]
ls
show (EnclosingSwitch [String]
ls) = String
"switch" forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show [String]
ls
show (EnclosingOther [String]
ls) = String
"statement" forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show [String]
ls
isIter :: EnclosingStatement -> Bool
isIter :: EnclosingStatement -> Bool
isIter (EnclosingIter [String]
_) = Bool
True
isIter EnclosingStatement
_ = Bool
False
isIterSwitch :: EnclosingStatement -> Bool
isIterSwitch :: EnclosingStatement -> Bool
isIterSwitch (EnclosingIter [String]
_) = Bool
True
isIterSwitch (EnclosingSwitch [String]
_) = Bool
True
isIterSwitch EnclosingStatement
_ = Bool
False
class HasLabelSet a where
getLabelSet :: a -> [Label]
setLabelSet :: [Label] -> a -> a
modifyLabelSet :: HasLabelSet a => ([Label] -> [Label]) -> a -> a
modifyLabelSet :: forall a. HasLabelSet a => ([String] -> [String]) -> a -> a
modifyLabelSet [String] -> [String]
f a
a = forall a. HasLabelSet a => [String] -> a -> a
setLabelSet ([String] -> [String]
f forall a b. (a -> b) -> a -> b
$ forall a. HasLabelSet a => a -> [String]
getLabelSet a
a) a
a
instance HasLabelSet EnclosingStatement where
getLabelSet :: EnclosingStatement -> [String]
getLabelSet EnclosingStatement
e = case EnclosingStatement
e of
EnclosingIter [String]
ls -> [String]
ls
EnclosingSwitch [String]
ls -> [String]
ls
EnclosingOther [String]
ls -> [String]
ls
setLabelSet :: [String] -> EnclosingStatement -> EnclosingStatement
setLabelSet [String]
ls EnclosingStatement
e = case EnclosingStatement
e of
EnclosingIter [String]
_ -> [String] -> EnclosingStatement
EnclosingIter [String]
ls
EnclosingSwitch [String]
_ -> [String] -> EnclosingStatement
EnclosingSwitch [String]
ls
EnclosingOther [String]
_ -> [String] -> EnclosingStatement
EnclosingOther [String]
ls
type Label = String