-- |ECMAScript 3 syntax. /Spec/ refers to the ECMA-262 specification,
-- 3rd edition.
{-# 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) -- used by data JavaScript
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
import Control.Monad.State
import Control.Arrow

data JavaScript a
  -- |A script in \<script\> ... \</script\> tags.
  = Script a [Statement a] 
  deriving (Int -> JavaScript a -> ShowS
[JavaScript a] -> ShowS
JavaScript a -> String
(Int -> JavaScript a -> ShowS)
-> (JavaScript a -> String)
-> ([JavaScript a] -> ShowS)
-> Show (JavaScript a)
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
$cshowsPrec :: forall a. Show a => Int -> JavaScript a -> ShowS
showsPrec :: Int -> JavaScript a -> ShowS
$cshow :: forall a. Show a => JavaScript a -> String
show :: JavaScript a -> String
$cshowList :: forall a. Show a => [JavaScript a] -> ShowS
showList :: [JavaScript a] -> ShowS
Show,Typeable (JavaScript a)
Typeable (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 (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (JavaScript a))
-> (JavaScript a -> Constr)
-> (JavaScript a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (JavaScript a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (JavaScript a)))
-> ((forall b. Data b => b -> b) -> JavaScript a -> JavaScript a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> JavaScript a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> JavaScript a -> r)
-> (forall u. (forall d. Data d => d -> u) -> JavaScript a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> JavaScript a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> JavaScript a -> m (JavaScript a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> JavaScript a -> m (JavaScript a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> JavaScript a -> m (JavaScript a))
-> Data (JavaScript a)
JavaScript a -> Constr
JavaScript a -> DataType
(forall b. Data b => b -> b) -> JavaScript a -> JavaScript a
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 u. Int -> (forall d. Data d => d -> u) -> JavaScript a -> u
forall u. (forall d. Data d => d -> u) -> JavaScript a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> JavaScript a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> JavaScript a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> JavaScript a -> m (JavaScript a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> JavaScript a -> m (JavaScript 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))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (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)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> JavaScript a -> 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)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (JavaScript a)
$ctoConstr :: forall a. Data a => JavaScript a -> Constr
toConstr :: JavaScript a -> Constr
$cdataTypeOf :: forall a. Data a => JavaScript a -> DataType
dataTypeOf :: JavaScript a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (JavaScript a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> 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))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (JavaScript a))
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> JavaScript a -> JavaScript a
gmapT :: (forall b. Data b => b -> b) -> JavaScript a -> JavaScript a
$cgmapQl :: 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
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> JavaScript a -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> JavaScript a -> r
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> JavaScript a -> [u]
gmapQ :: forall u. (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
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> JavaScript a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad 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)
$cgmapMp :: 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)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> JavaScript a -> m (JavaScript a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> JavaScript a -> m (JavaScript a)
Data,Typeable,JavaScript a -> JavaScript a -> Bool
(JavaScript a -> JavaScript a -> Bool)
-> (JavaScript a -> JavaScript a -> Bool) -> Eq (JavaScript a)
forall a. Eq a => JavaScript a -> JavaScript a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$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
/= :: JavaScript a -> JavaScript a -> Bool
Eq,Eq (JavaScript a)
Eq (JavaScript a) =>
(JavaScript a -> JavaScript a -> Ordering)
-> (JavaScript a -> JavaScript a -> Bool)
-> (JavaScript a -> JavaScript a -> Bool)
-> (JavaScript a -> JavaScript a -> Bool)
-> (JavaScript a -> JavaScript a -> Bool)
-> (JavaScript a -> JavaScript a -> JavaScript a)
-> (JavaScript a -> JavaScript a -> JavaScript a)
-> Ord (JavaScript a)
JavaScript a -> JavaScript a -> Bool
JavaScript a -> JavaScript a -> Ordering
JavaScript a -> JavaScript a -> JavaScript a
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
$ccompare :: forall a. Ord a => JavaScript a -> JavaScript a -> Ordering
compare :: JavaScript a -> JavaScript a -> Ordering
$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
>= :: JavaScript a -> JavaScript a -> Bool
$cmax :: forall a. Ord a => JavaScript a -> JavaScript a -> JavaScript a
max :: JavaScript a -> JavaScript a -> JavaScript a
$cmin :: forall a. Ord a => JavaScript a -> JavaScript a -> JavaScript a
min :: JavaScript a -> JavaScript a -> JavaScript a
Ord,(forall a b. (a -> b) -> JavaScript a -> JavaScript b)
-> (forall a b. a -> JavaScript b -> JavaScript a)
-> Functor JavaScript
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
$cfmap :: forall a b. (a -> b) -> JavaScript a -> JavaScript b
fmap :: forall a b. (a -> b) -> JavaScript a -> JavaScript b
$c<$ :: forall a b. a -> JavaScript b -> JavaScript a
<$ :: forall a b. a -> JavaScript b -> JavaScript a
Functor,(forall m. Monoid m => JavaScript m -> m)
-> (forall m a. Monoid m => (a -> m) -> JavaScript a -> m)
-> (forall m a. Monoid m => (a -> m) -> JavaScript a -> m)
-> (forall a b. (a -> b -> b) -> b -> JavaScript a -> b)
-> (forall a b. (a -> b -> b) -> b -> JavaScript a -> b)
-> (forall b a. (b -> a -> b) -> b -> JavaScript a -> b)
-> (forall b a. (b -> a -> b) -> b -> JavaScript a -> b)
-> (forall a. (a -> a -> a) -> JavaScript a -> a)
-> (forall a. (a -> a -> a) -> JavaScript a -> a)
-> (forall a. JavaScript a -> [a])
-> (forall a. JavaScript a -> Bool)
-> (forall a. JavaScript a -> Int)
-> (forall a. Eq a => a -> JavaScript a -> Bool)
-> (forall a. Ord a => JavaScript a -> a)
-> (forall a. Ord a => JavaScript a -> a)
-> (forall a. Num a => JavaScript a -> a)
-> (forall a. Num a => JavaScript a -> a)
-> Foldable JavaScript
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
$cfold :: forall m. Monoid m => JavaScript m -> m
fold :: forall m. Monoid m => JavaScript m -> 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
foldMap' :: forall m a. Monoid m => (a -> m) -> JavaScript a -> m
$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
foldr' :: forall a b. (a -> b -> 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
foldl' :: forall b a. (b -> a -> b) -> b -> JavaScript a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> JavaScript a -> a
foldr1 :: forall a. (a -> a -> a) -> JavaScript a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> JavaScript a -> a
foldl1 :: forall a. (a -> a -> a) -> JavaScript a -> a
$ctoList :: forall a. JavaScript a -> [a]
toList :: forall a. JavaScript a -> [a]
$cnull :: forall a. JavaScript a -> Bool
null :: forall a. JavaScript a -> Bool
$clength :: forall a. JavaScript a -> Int
length :: forall a. JavaScript a -> Int
$celem :: forall a. Eq a => a -> JavaScript a -> Bool
elem :: forall a. Eq a => a -> JavaScript a -> Bool
$cmaximum :: forall a. Ord a => JavaScript a -> a
maximum :: forall a. Ord a => JavaScript a -> a
$cminimum :: forall a. Ord a => JavaScript a -> a
minimum :: forall a. Ord a => JavaScript a -> a
$csum :: forall a. Num a => JavaScript a -> a
sum :: forall a. Num a => JavaScript a -> a
$cproduct :: forall a. Num a => JavaScript a -> a
product :: forall a. Num a => JavaScript a -> a
Foldable,Functor JavaScript
Foldable JavaScript
(Functor JavaScript, Foldable JavaScript) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> JavaScript a -> f (JavaScript b))
-> (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 (m :: * -> *) a.
    Monad m =>
    JavaScript (m a) -> m (JavaScript a))
-> Traversable 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)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> JavaScript a -> f (JavaScript b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> JavaScript a -> f (JavaScript b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
JavaScript (f a) -> f (JavaScript a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
JavaScript (f a) -> f (JavaScript a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> JavaScript a -> m (JavaScript b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> JavaScript a -> m (JavaScript b)
$csequence :: forall (m :: * -> *) a.
Monad m =>
JavaScript (m a) -> m (JavaScript a)
sequence :: forall (m :: * -> *) a.
Monad m =>
JavaScript (m a) -> m (JavaScript a)
Traversable)

instance Default a => Default (JavaScript a) where
  def :: JavaScript a
def = a -> [Statement a] -> JavaScript a
forall a. a -> [Statement a] -> JavaScript a
Script a
forall a. Default a => a
def []

-- | extracts statements from a JavaScript type
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
[Id a] -> ShowS
Id a -> String
(Int -> Id a -> ShowS)
-> (Id a -> String) -> ([Id a] -> ShowS) -> Show (Id a)
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
$cshowsPrec :: forall a. Show a => Int -> Id a -> ShowS
showsPrec :: Int -> Id a -> ShowS
$cshow :: forall a. Show a => Id a -> String
show :: Id a -> String
$cshowList :: forall a. Show a => [Id a] -> ShowS
showList :: [Id a] -> ShowS
Show,Id a -> Id a -> Bool
(Id a -> Id a -> Bool) -> (Id a -> Id a -> Bool) -> Eq (Id a)
forall a. Eq a => Id a -> Id a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$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
/= :: Id a -> Id a -> Bool
Eq,Eq (Id a)
Eq (Id a) =>
(Id a -> Id a -> Ordering)
-> (Id a -> Id a -> Bool)
-> (Id a -> Id a -> Bool)
-> (Id a -> Id a -> Bool)
-> (Id a -> Id a -> Bool)
-> (Id a -> Id a -> Id a)
-> (Id a -> Id a -> Id a)
-> Ord (Id a)
Id a -> Id a -> Bool
Id a -> Id a -> Ordering
Id a -> Id a -> Id a
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
$ccompare :: forall a. Ord a => Id a -> Id a -> Ordering
compare :: Id a -> Id a -> Ordering
$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
>= :: Id a -> Id a -> Bool
$cmax :: forall a. Ord a => Id a -> Id a -> Id a
max :: Id a -> Id a -> Id a
$cmin :: forall a. Ord a => Id a -> Id a -> Id a
min :: Id a -> Id a -> Id a
Ord,Typeable (Id a)
Typeable (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 (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Id a))
-> (Id a -> Constr)
-> (Id a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Id a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Id a)))
-> ((forall b. Data b => b -> b) -> Id a -> Id a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Id a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Id a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Id a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Id a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Id a -> m (Id a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Id a -> m (Id a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Id a -> m (Id a))
-> Data (Id a)
Id a -> Constr
Id a -> DataType
(forall b. Data b => b -> b) -> Id a -> Id a
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 u. Int -> (forall d. Data d => d -> u) -> Id a -> u
forall u. (forall d. Data d => d -> u) -> Id a -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Id a -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Id a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Id a -> m (Id a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Id a -> m (Id 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))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (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)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Id a -> 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)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Id a)
$ctoConstr :: forall a. Data a => Id a -> Constr
toConstr :: Id a -> Constr
$cdataTypeOf :: forall a. Data a => Id a -> DataType
dataTypeOf :: Id a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Id a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> 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))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Id a))
$cgmapT :: forall a. Data a => (forall b. Data b => b -> b) -> Id a -> Id a
gmapT :: (forall b. Data b => b -> b) -> Id a -> Id a
$cgmapQl :: 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
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Id a -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Id a -> r
$cgmapQ :: forall a u. Data a => (forall d. Data d => d -> u) -> Id a -> [u]
gmapQ :: forall u. (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
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Id a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad 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)
$cgmapMp :: 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)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Id a -> m (Id a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Id a -> m (Id a)
Data,Typeable,(forall a b. (a -> b) -> Id a -> Id b)
-> (forall a b. a -> Id b -> Id a) -> Functor Id
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
$cfmap :: forall a b. (a -> b) -> Id a -> Id b
fmap :: forall a b. (a -> b) -> Id a -> Id b
$c<$ :: forall a b. a -> Id b -> Id a
<$ :: forall a b. a -> Id b -> Id a
Functor,(forall m. Monoid m => Id m -> m)
-> (forall m a. Monoid m => (a -> m) -> Id a -> m)
-> (forall m a. Monoid m => (a -> m) -> Id a -> m)
-> (forall a b. (a -> b -> b) -> b -> Id a -> b)
-> (forall a b. (a -> b -> b) -> b -> Id a -> b)
-> (forall b a. (b -> a -> b) -> b -> Id a -> b)
-> (forall b a. (b -> a -> b) -> b -> Id a -> b)
-> (forall a. (a -> a -> a) -> Id a -> a)
-> (forall a. (a -> a -> a) -> Id a -> a)
-> (forall a. Id a -> [a])
-> (forall a. Id a -> Bool)
-> (forall a. Id a -> Int)
-> (forall a. Eq a => a -> Id a -> Bool)
-> (forall a. Ord a => Id a -> a)
-> (forall a. Ord a => Id a -> a)
-> (forall a. Num a => Id a -> a)
-> (forall a. Num a => Id a -> a)
-> Foldable Id
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
$cfold :: forall m. Monoid m => Id m -> m
fold :: forall m. Monoid m => Id m -> 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
foldMap' :: forall m a. Monoid m => (a -> m) -> Id a -> m
$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
foldr' :: forall a b. (a -> b -> 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
foldl' :: forall b a. (b -> a -> b) -> b -> Id a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> Id a -> a
foldr1 :: forall a. (a -> a -> a) -> Id a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Id a -> a
foldl1 :: forall a. (a -> a -> a) -> Id a -> a
$ctoList :: forall a. Id a -> [a]
toList :: forall a. Id a -> [a]
$cnull :: forall a. Id a -> Bool
null :: forall a. Id a -> Bool
$clength :: forall a. Id a -> Int
length :: forall a. Id a -> Int
$celem :: forall a. Eq a => a -> Id a -> Bool
elem :: forall a. Eq a => a -> Id a -> Bool
$cmaximum :: forall a. Ord a => Id a -> a
maximum :: forall a. Ord a => Id a -> a
$cminimum :: forall a. Ord a => Id a -> a
minimum :: forall a. Ord a => Id a -> a
$csum :: forall a. Num a => Id a -> a
sum :: forall a. Num a => Id a -> a
$cproduct :: forall a. Num a => Id a -> a
product :: forall a. Num a => Id a -> a
Foldable,Functor Id
Foldable Id
(Functor Id, Foldable Id) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> Id a -> f (Id b))
-> (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 (m :: * -> *) a. Monad m => Id (m a) -> m (Id a))
-> Traversable 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)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Id a -> f (Id b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Id a -> f (Id b)
$csequenceA :: forall (f :: * -> *) a. Applicative f => Id (f a) -> f (Id a)
sequenceA :: forall (f :: * -> *) a. Applicative f => Id (f a) -> f (Id a)
$cmapM :: forall (m :: * -> *) a b. Monad m => (a -> m b) -> Id a -> m (Id b)
mapM :: forall (m :: * -> *) a b. Monad m => (a -> m b) -> Id a -> m (Id b)
$csequence :: forall (m :: * -> *) a. Monad m => Id (m a) -> m (Id a)
sequence :: forall (m :: * -> *) a. Monad m => Id (m a) -> m (Id a)
Traversable)

unId :: Id a -> String
unId :: forall a. Id a -> String
unId (Id a
_ String
s) = String
s

-- | Infix operators: see spec 11.5-11.11
data InfixOp = OpLT -- ^ @<@
             | OpLEq -- ^ @<=@
             | OpGT -- ^ @>@
             | OpGEq -- ^ @>=@
             | OpIn -- ^ @in@
             | OpInstanceof -- ^ @instanceof@
             | 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
(Int -> InfixOp -> ShowS)
-> (InfixOp -> String) -> ([InfixOp] -> ShowS) -> Show InfixOp
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> InfixOp -> ShowS
showsPrec :: Int -> InfixOp -> ShowS
$cshow :: InfixOp -> String
show :: InfixOp -> String
$cshowList :: [InfixOp] -> ShowS
showList :: [InfixOp] -> ShowS
Show,Typeable InfixOp
Typeable InfixOp =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> InfixOp -> c InfixOp)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c InfixOp)
-> (InfixOp -> Constr)
-> (InfixOp -> DataType)
-> (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))
-> ((forall b. Data b => b -> b) -> InfixOp -> InfixOp)
-> (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 u. (forall d. Data d => d -> u) -> InfixOp -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> InfixOp -> u)
-> (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 (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> InfixOp -> m InfixOp)
-> Data 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)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> InfixOp -> c InfixOp
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> InfixOp -> c InfixOp
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c InfixOp
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c InfixOp
$ctoConstr :: InfixOp -> Constr
toConstr :: InfixOp -> Constr
$cdataTypeOf :: InfixOp -> DataType
dataTypeOf :: InfixOp -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c InfixOp)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c InfixOp)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c InfixOp)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c InfixOp)
$cgmapT :: (forall b. Data b => b -> b) -> InfixOp -> InfixOp
gmapT :: (forall b. Data b => b -> b) -> InfixOp -> InfixOp
$cgmapQl :: 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
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> InfixOp -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> InfixOp -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> InfixOp -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> InfixOp -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> InfixOp -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> InfixOp -> u
$cgmapM :: forall (m :: * -> *).
Monad 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
$cgmapMp :: 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
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> InfixOp -> m InfixOp
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> InfixOp -> m InfixOp
Data,Typeable,InfixOp -> InfixOp -> Bool
(InfixOp -> InfixOp -> Bool)
-> (InfixOp -> InfixOp -> Bool) -> Eq InfixOp
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: InfixOp -> InfixOp -> Bool
== :: InfixOp -> InfixOp -> Bool
$c/= :: InfixOp -> InfixOp -> Bool
/= :: InfixOp -> InfixOp -> Bool
Eq,Eq InfixOp
Eq InfixOp =>
(InfixOp -> InfixOp -> Ordering)
-> (InfixOp -> InfixOp -> Bool)
-> (InfixOp -> InfixOp -> Bool)
-> (InfixOp -> InfixOp -> Bool)
-> (InfixOp -> InfixOp -> Bool)
-> (InfixOp -> InfixOp -> InfixOp)
-> (InfixOp -> InfixOp -> InfixOp)
-> Ord 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
$ccompare :: InfixOp -> InfixOp -> Ordering
compare :: InfixOp -> InfixOp -> Ordering
$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
>= :: InfixOp -> InfixOp -> Bool
$cmax :: InfixOp -> InfixOp -> InfixOp
max :: InfixOp -> InfixOp -> InfixOp
$cmin :: InfixOp -> InfixOp -> InfixOp
min :: InfixOp -> InfixOp -> InfixOp
Ord,Int -> InfixOp
InfixOp -> Int
InfixOp -> [InfixOp]
InfixOp -> InfixOp
InfixOp -> InfixOp -> [InfixOp]
InfixOp -> InfixOp -> InfixOp -> [InfixOp]
(InfixOp -> InfixOp)
-> (InfixOp -> InfixOp)
-> (Int -> InfixOp)
-> (InfixOp -> Int)
-> (InfixOp -> [InfixOp])
-> (InfixOp -> InfixOp -> [InfixOp])
-> (InfixOp -> InfixOp -> [InfixOp])
-> (InfixOp -> InfixOp -> InfixOp -> [InfixOp])
-> Enum 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
$csucc :: InfixOp -> InfixOp
succ :: InfixOp -> InfixOp
$cpred :: InfixOp -> InfixOp
pred :: InfixOp -> InfixOp
$ctoEnum :: Int -> InfixOp
toEnum :: Int -> InfixOp
$cfromEnum :: InfixOp -> Int
fromEnum :: InfixOp -> Int
$cenumFrom :: InfixOp -> [InfixOp]
enumFrom :: InfixOp -> [InfixOp]
$cenumFromThen :: InfixOp -> InfixOp -> [InfixOp]
enumFromThen :: InfixOp -> InfixOp -> [InfixOp]
$cenumFromTo :: InfixOp -> InfixOp -> [InfixOp]
enumFromTo :: InfixOp -> InfixOp -> [InfixOp]
$cenumFromThenTo :: InfixOp -> InfixOp -> InfixOp -> [InfixOp]
enumFromThenTo :: InfixOp -> InfixOp -> InfixOp -> [InfixOp]
Enum)

-- | Assignment operators: see spec 11.13
data AssignOp = OpAssign -- ^ simple assignment, @=@
              | OpAssignAdd -- ^ @+=@
              | OpAssignSub -- ^ @-=@
              | OpAssignMul -- ^ @*=@
              | OpAssignDiv -- ^ @/=@
              | OpAssignMod -- ^ @%=@
              | OpAssignLShift -- ^ @<<=@
              | OpAssignSpRShift -- ^ @>>=@
              | OpAssignZfRShift -- ^ @>>>=@
              | OpAssignBAnd -- ^ @&=@
              | OpAssignBXor -- ^ @^=@
              | OpAssignBOr -- ^ @|=@
  deriving (Int -> AssignOp -> ShowS
[AssignOp] -> ShowS
AssignOp -> String
(Int -> AssignOp -> ShowS)
-> (AssignOp -> String) -> ([AssignOp] -> ShowS) -> Show AssignOp
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> AssignOp -> ShowS
showsPrec :: Int -> AssignOp -> ShowS
$cshow :: AssignOp -> String
show :: AssignOp -> String
$cshowList :: [AssignOp] -> ShowS
showList :: [AssignOp] -> ShowS
Show,Typeable AssignOp
Typeable AssignOp =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> AssignOp -> c AssignOp)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c AssignOp)
-> (AssignOp -> Constr)
-> (AssignOp -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c AssignOp))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AssignOp))
-> ((forall b. Data b => b -> b) -> AssignOp -> AssignOp)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AssignOp -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AssignOp -> r)
-> (forall u. (forall d. Data d => d -> u) -> AssignOp -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> AssignOp -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> AssignOp -> m AssignOp)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AssignOp -> m AssignOp)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AssignOp -> m AssignOp)
-> Data AssignOp
AssignOp -> Constr
AssignOp -> DataType
(forall b. Data b => b -> b) -> AssignOp -> AssignOp
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> AssignOp -> u
forall u. (forall d. Data d => d -> u) -> AssignOp -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AssignOp -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AssignOp -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> AssignOp -> m AssignOp
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AssignOp -> m AssignOp
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AssignOp
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AssignOp -> c AssignOp
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AssignOp)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AssignOp)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AssignOp -> c AssignOp
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AssignOp -> c AssignOp
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AssignOp
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AssignOp
$ctoConstr :: AssignOp -> Constr
toConstr :: AssignOp -> Constr
$cdataTypeOf :: AssignOp -> DataType
dataTypeOf :: AssignOp -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AssignOp)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AssignOp)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AssignOp)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AssignOp)
$cgmapT :: (forall b. Data b => b -> b) -> AssignOp -> AssignOp
gmapT :: (forall b. Data b => b -> b) -> AssignOp -> AssignOp
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AssignOp -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AssignOp -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AssignOp -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AssignOp -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> AssignOp -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> AssignOp -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> AssignOp -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> AssignOp -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> AssignOp -> m AssignOp
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> AssignOp -> m AssignOp
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AssignOp -> m AssignOp
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AssignOp -> m AssignOp
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AssignOp -> m AssignOp
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AssignOp -> m AssignOp
Data,Typeable,AssignOp -> AssignOp -> Bool
(AssignOp -> AssignOp -> Bool)
-> (AssignOp -> AssignOp -> Bool) -> Eq AssignOp
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AssignOp -> AssignOp -> Bool
== :: AssignOp -> AssignOp -> Bool
$c/= :: AssignOp -> AssignOp -> Bool
/= :: AssignOp -> AssignOp -> Bool
Eq,Eq AssignOp
Eq AssignOp =>
(AssignOp -> AssignOp -> Ordering)
-> (AssignOp -> AssignOp -> Bool)
-> (AssignOp -> AssignOp -> Bool)
-> (AssignOp -> AssignOp -> Bool)
-> (AssignOp -> AssignOp -> Bool)
-> (AssignOp -> AssignOp -> AssignOp)
-> (AssignOp -> AssignOp -> AssignOp)
-> Ord AssignOp
AssignOp -> AssignOp -> Bool
AssignOp -> AssignOp -> Ordering
AssignOp -> AssignOp -> AssignOp
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: AssignOp -> AssignOp -> Ordering
compare :: AssignOp -> AssignOp -> Ordering
$c< :: AssignOp -> AssignOp -> Bool
< :: AssignOp -> AssignOp -> Bool
$c<= :: AssignOp -> AssignOp -> Bool
<= :: AssignOp -> AssignOp -> Bool
$c> :: AssignOp -> AssignOp -> Bool
> :: AssignOp -> AssignOp -> Bool
$c>= :: AssignOp -> AssignOp -> Bool
>= :: AssignOp -> AssignOp -> Bool
$cmax :: AssignOp -> AssignOp -> AssignOp
max :: AssignOp -> AssignOp -> AssignOp
$cmin :: AssignOp -> AssignOp -> AssignOp
min :: AssignOp -> AssignOp -> AssignOp
Ord)

-- | Unary assignment operators: see spec 11.3, 11.4.4, 11.4.5
data UnaryAssignOp = PrefixInc -- ^ @++x@
                   | PrefixDec -- ^ @--x@
                   | PostfixInc -- ^ @x++@
                   | PostfixDec -- ^ @x--@
  deriving (Int -> UnaryAssignOp -> ShowS
[UnaryAssignOp] -> ShowS
UnaryAssignOp -> String
(Int -> UnaryAssignOp -> ShowS)
-> (UnaryAssignOp -> String)
-> ([UnaryAssignOp] -> ShowS)
-> Show UnaryAssignOp
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> UnaryAssignOp -> ShowS
showsPrec :: Int -> UnaryAssignOp -> ShowS
$cshow :: UnaryAssignOp -> String
show :: UnaryAssignOp -> String
$cshowList :: [UnaryAssignOp] -> ShowS
showList :: [UnaryAssignOp] -> ShowS
Show, Typeable UnaryAssignOp
Typeable UnaryAssignOp =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> UnaryAssignOp -> c UnaryAssignOp)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c UnaryAssignOp)
-> (UnaryAssignOp -> Constr)
-> (UnaryAssignOp -> DataType)
-> (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))
-> ((forall b. Data b => b -> b) -> UnaryAssignOp -> UnaryAssignOp)
-> (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 u. (forall d. Data d => d -> u) -> UnaryAssignOp -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> UnaryAssignOp -> u)
-> (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 (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> UnaryAssignOp -> m UnaryAssignOp)
-> Data 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)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UnaryAssignOp -> c UnaryAssignOp
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UnaryAssignOp -> c UnaryAssignOp
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c UnaryAssignOp
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c UnaryAssignOp
$ctoConstr :: UnaryAssignOp -> Constr
toConstr :: UnaryAssignOp -> Constr
$cdataTypeOf :: UnaryAssignOp -> DataType
dataTypeOf :: UnaryAssignOp -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c UnaryAssignOp)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c UnaryAssignOp)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c UnaryAssignOp)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c UnaryAssignOp)
$cgmapT :: (forall b. Data b => b -> b) -> UnaryAssignOp -> UnaryAssignOp
gmapT :: (forall b. Data b => b -> b) -> UnaryAssignOp -> UnaryAssignOp
$cgmapQl :: 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
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> UnaryAssignOp -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> UnaryAssignOp -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> UnaryAssignOp -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> UnaryAssignOp -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> UnaryAssignOp -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> UnaryAssignOp -> u
$cgmapM :: forall (m :: * -> *).
Monad 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
$cgmapMp :: 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
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> UnaryAssignOp -> m UnaryAssignOp
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> UnaryAssignOp -> m UnaryAssignOp
Data, Typeable, UnaryAssignOp -> UnaryAssignOp -> Bool
(UnaryAssignOp -> UnaryAssignOp -> Bool)
-> (UnaryAssignOp -> UnaryAssignOp -> Bool) -> Eq UnaryAssignOp
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: UnaryAssignOp -> UnaryAssignOp -> Bool
== :: UnaryAssignOp -> UnaryAssignOp -> Bool
$c/= :: UnaryAssignOp -> UnaryAssignOp -> Bool
/= :: UnaryAssignOp -> UnaryAssignOp -> Bool
Eq, Eq UnaryAssignOp
Eq UnaryAssignOp =>
(UnaryAssignOp -> UnaryAssignOp -> Ordering)
-> (UnaryAssignOp -> UnaryAssignOp -> Bool)
-> (UnaryAssignOp -> UnaryAssignOp -> Bool)
-> (UnaryAssignOp -> UnaryAssignOp -> Bool)
-> (UnaryAssignOp -> UnaryAssignOp -> Bool)
-> (UnaryAssignOp -> UnaryAssignOp -> UnaryAssignOp)
-> (UnaryAssignOp -> UnaryAssignOp -> UnaryAssignOp)
-> Ord 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
$ccompare :: UnaryAssignOp -> UnaryAssignOp -> Ordering
compare :: UnaryAssignOp -> UnaryAssignOp -> Ordering
$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
>= :: UnaryAssignOp -> UnaryAssignOp -> Bool
$cmax :: UnaryAssignOp -> UnaryAssignOp -> UnaryAssignOp
max :: UnaryAssignOp -> UnaryAssignOp -> UnaryAssignOp
$cmin :: UnaryAssignOp -> UnaryAssignOp -> UnaryAssignOp
min :: UnaryAssignOp -> UnaryAssignOp -> UnaryAssignOp
Ord)

-- | Prefix operators: see spec 11.4 (excluding 11.4.4, 11.4.5)
data PrefixOp = PrefixLNot -- ^ @!@
              | PrefixBNot -- ^ @~@
              | PrefixPlus -- ^ @+@
              | PrefixMinus -- ^ @-@
              | PrefixTypeof -- ^ @typeof@
              | PrefixVoid -- ^ @void@
              | PrefixDelete -- ^ @delete@
  deriving (Int -> PrefixOp -> ShowS
[PrefixOp] -> ShowS
PrefixOp -> String
(Int -> PrefixOp -> ShowS)
-> (PrefixOp -> String) -> ([PrefixOp] -> ShowS) -> Show PrefixOp
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PrefixOp -> ShowS
showsPrec :: Int -> PrefixOp -> ShowS
$cshow :: PrefixOp -> String
show :: PrefixOp -> String
$cshowList :: [PrefixOp] -> ShowS
showList :: [PrefixOp] -> ShowS
Show,Typeable PrefixOp
Typeable PrefixOp =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> PrefixOp -> c PrefixOp)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c PrefixOp)
-> (PrefixOp -> Constr)
-> (PrefixOp -> DataType)
-> (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))
-> ((forall b. Data b => b -> b) -> PrefixOp -> PrefixOp)
-> (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 u. (forall d. Data d => d -> u) -> PrefixOp -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> PrefixOp -> u)
-> (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 (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PrefixOp -> m PrefixOp)
-> Data 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)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PrefixOp -> c PrefixOp
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PrefixOp -> c PrefixOp
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PrefixOp
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PrefixOp
$ctoConstr :: PrefixOp -> Constr
toConstr :: PrefixOp -> Constr
$cdataTypeOf :: PrefixOp -> DataType
dataTypeOf :: PrefixOp -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PrefixOp)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PrefixOp)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PrefixOp)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PrefixOp)
$cgmapT :: (forall b. Data b => b -> b) -> PrefixOp -> PrefixOp
gmapT :: (forall b. Data b => b -> b) -> PrefixOp -> PrefixOp
$cgmapQl :: 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
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PrefixOp -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PrefixOp -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> PrefixOp -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> PrefixOp -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> PrefixOp -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> PrefixOp -> u
$cgmapM :: forall (m :: * -> *).
Monad 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
$cgmapMp :: 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
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PrefixOp -> m PrefixOp
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PrefixOp -> m PrefixOp
Data,Typeable,PrefixOp -> PrefixOp -> Bool
(PrefixOp -> PrefixOp -> Bool)
-> (PrefixOp -> PrefixOp -> Bool) -> Eq PrefixOp
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PrefixOp -> PrefixOp -> Bool
== :: PrefixOp -> PrefixOp -> Bool
$c/= :: PrefixOp -> PrefixOp -> Bool
/= :: PrefixOp -> PrefixOp -> Bool
Eq,Eq PrefixOp
Eq PrefixOp =>
(PrefixOp -> PrefixOp -> Ordering)
-> (PrefixOp -> PrefixOp -> Bool)
-> (PrefixOp -> PrefixOp -> Bool)
-> (PrefixOp -> PrefixOp -> Bool)
-> (PrefixOp -> PrefixOp -> Bool)
-> (PrefixOp -> PrefixOp -> PrefixOp)
-> (PrefixOp -> PrefixOp -> PrefixOp)
-> Ord 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
$ccompare :: PrefixOp -> PrefixOp -> Ordering
compare :: PrefixOp -> PrefixOp -> Ordering
$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
>= :: PrefixOp -> PrefixOp -> Bool
$cmax :: PrefixOp -> PrefixOp -> PrefixOp
max :: PrefixOp -> PrefixOp -> PrefixOp
$cmin :: PrefixOp -> PrefixOp -> PrefixOp
min :: PrefixOp -> PrefixOp -> PrefixOp
Ord)

-- | Property names in an object initializer: see spec 11.1.5
data Prop a = PropId a (Id a) -- ^ property name is an identifier, @foo@
            | PropString a String -- ^ property name is a string, @\"foo\"@
            | PropNum a Integer -- ^ property name is an integer, @42@
  deriving (Int -> Prop a -> ShowS
[Prop a] -> ShowS
Prop a -> String
(Int -> Prop a -> ShowS)
-> (Prop a -> String) -> ([Prop a] -> ShowS) -> Show (Prop a)
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
$cshowsPrec :: forall a. Show a => Int -> Prop a -> ShowS
showsPrec :: Int -> Prop a -> ShowS
$cshow :: forall a. Show a => Prop a -> String
show :: Prop a -> String
$cshowList :: forall a. Show a => [Prop a] -> ShowS
showList :: [Prop a] -> ShowS
Show,Typeable (Prop a)
Typeable (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 (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Prop a))
-> (Prop a -> Constr)
-> (Prop a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Prop a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Prop a)))
-> ((forall b. Data b => b -> b) -> Prop a -> Prop a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Prop a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Prop a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Prop a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Prop a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Prop a -> m (Prop a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Prop a -> m (Prop a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Prop a -> m (Prop a))
-> Data (Prop a)
Prop a -> Constr
Prop a -> DataType
(forall b. Data b => b -> b) -> Prop a -> Prop a
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 u. Int -> (forall d. Data d => d -> u) -> Prop a -> u
forall u. (forall d. Data d => d -> u) -> Prop a -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Prop a -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Prop a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Prop a -> m (Prop a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Prop a -> m (Prop 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))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (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)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Prop a -> 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)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Prop a)
$ctoConstr :: forall a. Data a => Prop a -> Constr
toConstr :: Prop a -> Constr
$cdataTypeOf :: forall a. Data a => Prop a -> DataType
dataTypeOf :: Prop a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Prop a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> 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))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Prop a))
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> Prop a -> Prop a
gmapT :: (forall b. Data b => b -> b) -> Prop a -> Prop a
$cgmapQl :: 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
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Prop a -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Prop a -> r
$cgmapQ :: forall a u. Data a => (forall d. Data d => d -> u) -> Prop a -> [u]
gmapQ :: forall u. (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
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Prop a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad 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)
$cgmapMp :: 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)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Prop a -> m (Prop a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Prop a -> m (Prop a)
Data,Typeable,Prop a -> Prop a -> Bool
(Prop a -> Prop a -> Bool)
-> (Prop a -> Prop a -> Bool) -> Eq (Prop a)
forall a. Eq a => Prop a -> Prop a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$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
/= :: Prop a -> Prop a -> Bool
Eq,Eq (Prop a)
Eq (Prop a) =>
(Prop a -> Prop a -> Ordering)
-> (Prop a -> Prop a -> Bool)
-> (Prop a -> Prop a -> Bool)
-> (Prop a -> Prop a -> Bool)
-> (Prop a -> Prop a -> Bool)
-> (Prop a -> Prop a -> Prop a)
-> (Prop a -> Prop a -> Prop a)
-> Ord (Prop a)
Prop a -> Prop a -> Bool
Prop a -> Prop a -> Ordering
Prop a -> Prop a -> Prop a
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
$ccompare :: forall a. Ord a => Prop a -> Prop a -> Ordering
compare :: Prop a -> Prop a -> Ordering
$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
>= :: Prop a -> Prop a -> Bool
$cmax :: forall a. Ord a => Prop a -> Prop a -> Prop a
max :: Prop a -> Prop a -> Prop a
$cmin :: forall a. Ord a => Prop a -> Prop a -> Prop a
min :: Prop a -> Prop a -> Prop a
Ord,(forall a b. (a -> b) -> Prop a -> Prop b)
-> (forall a b. a -> Prop b -> Prop a) -> Functor Prop
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
$cfmap :: forall a b. (a -> b) -> Prop a -> Prop b
fmap :: forall a b. (a -> b) -> Prop a -> Prop b
$c<$ :: forall a b. a -> Prop b -> Prop a
<$ :: forall a b. a -> Prop b -> Prop a
Functor,(forall m. Monoid m => Prop m -> m)
-> (forall m a. Monoid m => (a -> m) -> Prop a -> m)
-> (forall m a. Monoid m => (a -> m) -> Prop a -> m)
-> (forall a b. (a -> b -> b) -> b -> Prop a -> b)
-> (forall a b. (a -> b -> b) -> b -> Prop a -> b)
-> (forall b a. (b -> a -> b) -> b -> Prop a -> b)
-> (forall b a. (b -> a -> b) -> b -> Prop a -> b)
-> (forall a. (a -> a -> a) -> Prop a -> a)
-> (forall a. (a -> a -> a) -> Prop a -> a)
-> (forall a. Prop a -> [a])
-> (forall a. Prop a -> Bool)
-> (forall a. Prop a -> Int)
-> (forall a. Eq a => a -> Prop a -> Bool)
-> (forall a. Ord a => Prop a -> a)
-> (forall a. Ord a => Prop a -> a)
-> (forall a. Num a => Prop a -> a)
-> (forall a. Num a => Prop a -> a)
-> Foldable Prop
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
$cfold :: forall m. Monoid m => Prop m -> m
fold :: forall m. Monoid m => Prop m -> 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
foldMap' :: forall m a. Monoid m => (a -> m) -> Prop a -> m
$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
foldr' :: forall a b. (a -> b -> 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
foldl' :: forall b a. (b -> a -> b) -> b -> Prop a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> Prop a -> a
foldr1 :: forall a. (a -> a -> a) -> Prop a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Prop a -> a
foldl1 :: forall a. (a -> a -> a) -> Prop a -> a
$ctoList :: forall a. Prop a -> [a]
toList :: forall a. Prop a -> [a]
$cnull :: forall a. Prop a -> Bool
null :: forall a. Prop a -> Bool
$clength :: forall a. Prop a -> Int
length :: forall a. Prop a -> Int
$celem :: forall a. Eq a => a -> Prop a -> Bool
elem :: forall a. Eq a => a -> Prop a -> Bool
$cmaximum :: forall a. Ord a => Prop a -> a
maximum :: forall a. Ord a => Prop a -> a
$cminimum :: forall a. Ord a => Prop a -> a
minimum :: forall a. Ord a => Prop a -> a
$csum :: forall a. Num a => Prop a -> a
sum :: forall a. Num a => Prop a -> a
$cproduct :: forall a. Num a => Prop a -> a
product :: forall a. Num a => Prop a -> a
Foldable,Functor Prop
Foldable Prop
(Functor Prop, Foldable Prop) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> Prop a -> f (Prop b))
-> (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 (m :: * -> *) a. Monad m => Prop (m a) -> m (Prop a))
-> Traversable 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)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Prop a -> f (Prop b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Prop a -> f (Prop b)
$csequenceA :: forall (f :: * -> *) a. Applicative f => Prop (f a) -> f (Prop a)
sequenceA :: forall (f :: * -> *) a. Applicative f => Prop (f a) -> f (Prop a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Prop a -> m (Prop b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Prop a -> m (Prop b)
$csequence :: forall (m :: * -> *) a. Monad m => Prop (m a) -> m (Prop a)
sequence :: forall (m :: * -> *) a. Monad m => Prop (m a) -> m (Prop a)
Traversable)
 
-- | Left-hand side expressions: see spec 11.2
data LValue a
  = LVar a String -- ^ variable reference, @foo@
  | LDot a (Expression a) String -- ^ @foo.bar@
  | LBracket a (Expression a) (Expression a) -- ^ @foo[bar]@
  deriving (Int -> LValue a -> ShowS
[LValue a] -> ShowS
LValue a -> String
(Int -> LValue a -> ShowS)
-> (LValue a -> String) -> ([LValue a] -> ShowS) -> Show (LValue a)
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
$cshowsPrec :: forall a. Show a => Int -> LValue a -> ShowS
showsPrec :: Int -> LValue a -> ShowS
$cshow :: forall a. Show a => LValue a -> String
show :: LValue a -> String
$cshowList :: forall a. Show a => [LValue a] -> ShowS
showList :: [LValue a] -> ShowS
Show, LValue a -> LValue a -> Bool
(LValue a -> LValue a -> Bool)
-> (LValue a -> LValue a -> Bool) -> Eq (LValue a)
forall a. Eq a => LValue a -> LValue a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$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
/= :: LValue a -> LValue a -> Bool
Eq, Eq (LValue a)
Eq (LValue a) =>
(LValue a -> LValue a -> Ordering)
-> (LValue a -> LValue a -> Bool)
-> (LValue a -> LValue a -> Bool)
-> (LValue a -> LValue a -> Bool)
-> (LValue a -> LValue a -> Bool)
-> (LValue a -> LValue a -> LValue a)
-> (LValue a -> LValue a -> LValue a)
-> Ord (LValue a)
LValue a -> LValue a -> Bool
LValue a -> LValue a -> Ordering
LValue a -> LValue a -> LValue a
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
$ccompare :: forall a. Ord a => LValue a -> LValue a -> Ordering
compare :: LValue a -> LValue a -> Ordering
$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
>= :: LValue a -> LValue a -> Bool
$cmax :: forall a. Ord a => LValue a -> LValue a -> LValue a
max :: LValue a -> LValue a -> LValue a
$cmin :: forall a. Ord a => LValue a -> LValue a -> LValue a
min :: LValue a -> LValue a -> LValue a
Ord, Typeable (LValue a)
Typeable (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 (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (LValue a))
-> (LValue a -> Constr)
-> (LValue a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (LValue a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (LValue a)))
-> ((forall b. Data b => b -> b) -> LValue a -> LValue a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> LValue a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> LValue a -> r)
-> (forall u. (forall d. Data d => d -> u) -> LValue a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> LValue a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> LValue a -> m (LValue a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> LValue a -> m (LValue a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> LValue a -> m (LValue a))
-> Data (LValue a)
LValue a -> Constr
LValue a -> DataType
(forall b. Data b => b -> b) -> LValue a -> LValue a
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 u. Int -> (forall d. Data d => d -> u) -> LValue a -> u
forall u. (forall d. Data d => d -> u) -> LValue a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> LValue a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> LValue a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> LValue a -> m (LValue a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> LValue a -> m (LValue 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))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (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)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> LValue a -> 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)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (LValue a)
$ctoConstr :: forall a. Data a => LValue a -> Constr
toConstr :: LValue a -> Constr
$cdataTypeOf :: forall a. Data a => LValue a -> DataType
dataTypeOf :: LValue a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (LValue a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> 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))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (LValue a))
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> LValue a -> LValue a
gmapT :: (forall b. Data b => b -> b) -> LValue a -> LValue a
$cgmapQl :: 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
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> LValue a -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> LValue a -> r
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> LValue a -> [u]
gmapQ :: forall u. (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
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> LValue a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad 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)
$cgmapMp :: 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)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> LValue a -> m (LValue a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> LValue a -> m (LValue a)
Data, Typeable, (forall a b. (a -> b) -> LValue a -> LValue b)
-> (forall a b. a -> LValue b -> LValue a) -> Functor LValue
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
$cfmap :: forall a b. (a -> b) -> LValue a -> LValue b
fmap :: forall a b. (a -> b) -> LValue a -> LValue b
$c<$ :: forall a b. a -> LValue b -> LValue a
<$ :: forall a b. a -> LValue b -> LValue a
Functor,(forall m. Monoid m => LValue m -> m)
-> (forall m a. Monoid m => (a -> m) -> LValue a -> m)
-> (forall m a. Monoid m => (a -> m) -> LValue a -> m)
-> (forall a b. (a -> b -> b) -> b -> LValue a -> b)
-> (forall a b. (a -> b -> b) -> b -> LValue a -> b)
-> (forall b a. (b -> a -> b) -> b -> LValue a -> b)
-> (forall b a. (b -> a -> b) -> b -> LValue a -> b)
-> (forall a. (a -> a -> a) -> LValue a -> a)
-> (forall a. (a -> a -> a) -> LValue a -> a)
-> (forall a. LValue a -> [a])
-> (forall a. LValue a -> Bool)
-> (forall a. LValue a -> Int)
-> (forall a. Eq a => a -> LValue a -> Bool)
-> (forall a. Ord a => LValue a -> a)
-> (forall a. Ord a => LValue a -> a)
-> (forall a. Num a => LValue a -> a)
-> (forall a. Num a => LValue a -> a)
-> Foldable LValue
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
$cfold :: forall m. Monoid m => LValue m -> m
fold :: forall m. Monoid m => LValue m -> 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
foldMap' :: forall m a. Monoid m => (a -> m) -> LValue a -> m
$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
foldr' :: forall a b. (a -> b -> 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
foldl' :: forall b a. (b -> a -> b) -> b -> LValue a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> LValue a -> a
foldr1 :: forall a. (a -> a -> a) -> LValue a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> LValue a -> a
foldl1 :: forall a. (a -> a -> a) -> LValue a -> a
$ctoList :: forall a. LValue a -> [a]
toList :: forall a. LValue a -> [a]
$cnull :: forall a. LValue a -> Bool
null :: forall a. LValue a -> Bool
$clength :: forall a. LValue a -> Int
length :: forall a. LValue a -> Int
$celem :: forall a. Eq a => a -> LValue a -> Bool
elem :: forall a. Eq a => a -> LValue a -> Bool
$cmaximum :: forall a. Ord a => LValue a -> a
maximum :: forall a. Ord a => LValue a -> a
$cminimum :: forall a. Ord a => LValue a -> a
minimum :: forall a. Ord a => LValue a -> a
$csum :: forall a. Num a => LValue a -> a
sum :: forall a. Num a => LValue a -> a
$cproduct :: forall a. Num a => LValue a -> a
product :: forall a. Num a => LValue a -> a
Foldable,Functor LValue
Foldable LValue
(Functor LValue, Foldable LValue) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> LValue a -> f (LValue b))
-> (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 (m :: * -> *) a.
    Monad m =>
    LValue (m a) -> m (LValue a))
-> Traversable 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)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> LValue a -> f (LValue b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> LValue a -> f (LValue b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
LValue (f a) -> f (LValue a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
LValue (f a) -> f (LValue a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> LValue a -> m (LValue b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> LValue a -> m (LValue b)
$csequence :: forall (m :: * -> *) a. Monad m => LValue (m a) -> m (LValue a)
sequence :: forall (m :: * -> *) a. Monad m => LValue (m a) -> m (LValue a)
Traversable) 

-- | Expressions, see spec 11
data Expression a
  = StringLit a String -- ^ @\"foo\"@, spec 11.1.3, 7.8
  | RegexpLit a String Bool Bool 
    -- ^ @RegexpLit a regexp global?  case_insensitive?@ -- regular
    -- expression, see spec 11.1.3, 7.8
  | NumLit a Double -- ^ @41.99999@, spec 11.1.3, 7.8
  | IntLit a Int -- ^ @42@, spec 11.1.3, 7.8
  | BoolLit a Bool -- ^ @true@, spec 11.1.3, 7.8
  | NullLit a -- ^ @null@, spec 11.1.3, 7.8
  | ArrayLit a [Expression a] -- ^ @[1,2,3]@, spec 11.1.4
  | ObjectLit a [(Prop a, Expression a)] -- ^ @{foo:\"bar\", baz: 42}@, spec 11.1.5
  | ThisRef a -- ^ @this@, spec 11.1.1
  | VarRef a (Id a) -- ^ @foo@, spec 11.1.2
  | DotRef a (Expression a) (Id a) -- ^ @foo.bar@, spec 11.2.1
  | BracketRef a (Expression a) {- container -} (Expression a) {- key -} 
    -- ^ @foo[bar@, spec 11.2.1
  | NewExpr a (Expression a) {- constructor -} [Expression a] 
    -- ^ @new foo(bar)@, spec 11.2.2
  | PrefixExpr a PrefixOp (Expression a) 
    -- ^ @\@e@, spec 11.4 (excluding 11.4.4, 111.4.5)
  | UnaryAssignExpr a UnaryAssignOp (LValue a) 
    -- ^ @++x@, @x--@ etc., spec 11.3, 11.4.4, 11.4.5
  | InfixExpr a InfixOp (Expression a) (Expression a) 
    -- ^ @e1\@e2@, spec 11.5, 11.6, 11.7, 11.8, 11.9, 11.10, 11.11
  | CondExpr a (Expression a) (Expression a) (Expression a)
    -- ^ @e1 ? e2 : e3@, spec 11.12
  | AssignExpr a AssignOp (LValue a) (Expression a)
    -- ^ @e1 \@=e2@, spec 11.13
  | ListExpr a [Expression a] -- ^ @e1, e2@, spec 11.14
  | CallExpr a (Expression a) [Expression a] -- ^ @f(x,y,z)@, spec 11.2.3
  --funcexprs are optionally named
  | FuncExpr a (Maybe (Id a)) [Id a] [Statement a]
    -- ^ @function f (x,y,z) {...}@, spec 11.2.5, 13
  deriving (Int -> Expression a -> ShowS
[Expression a] -> ShowS
Expression a -> String
(Int -> Expression a -> ShowS)
-> (Expression a -> String)
-> ([Expression a] -> ShowS)
-> Show (Expression a)
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
$cshowsPrec :: forall a. Show a => Int -> Expression a -> ShowS
showsPrec :: Int -> Expression a -> ShowS
$cshow :: forall a. Show a => Expression a -> String
show :: Expression a -> String
$cshowList :: forall a. Show a => [Expression a] -> ShowS
showList :: [Expression a] -> ShowS
Show,Typeable (Expression a)
Typeable (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 (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Expression a))
-> (Expression a -> Constr)
-> (Expression a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Expression a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Expression a)))
-> ((forall b. Data b => b -> b) -> Expression a -> Expression a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Expression a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Expression a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Expression a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Expression a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Expression a -> m (Expression a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Expression a -> m (Expression a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Expression a -> m (Expression a))
-> Data (Expression a)
Expression a -> Constr
Expression a -> DataType
(forall b. Data b => b -> b) -> Expression a -> Expression a
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 u. Int -> (forall d. Data d => d -> u) -> Expression a -> u
forall u. (forall d. Data d => d -> u) -> Expression a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Expression a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Expression a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Expression a -> m (Expression a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Expression a -> m (Expression 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))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (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)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Expression a -> 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)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Expression a)
$ctoConstr :: forall a. Data a => Expression a -> Constr
toConstr :: Expression a -> Constr
$cdataTypeOf :: forall a. Data a => Expression a -> DataType
dataTypeOf :: Expression a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Expression a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> 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))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Expression a))
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> Expression a -> Expression a
gmapT :: (forall b. Data b => b -> b) -> Expression a -> Expression a
$cgmapQl :: 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
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Expression a -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Expression a -> r
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> Expression a -> [u]
gmapQ :: forall u. (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
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Expression a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad 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)
$cgmapMp :: 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)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Expression a -> m (Expression a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Expression a -> m (Expression a)
Data,Typeable,Expression a -> Expression a -> Bool
(Expression a -> Expression a -> Bool)
-> (Expression a -> Expression a -> Bool) -> Eq (Expression a)
forall a. Eq a => Expression a -> Expression a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$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
/= :: Expression a -> Expression a -> Bool
Eq,Eq (Expression a)
Eq (Expression a) =>
(Expression a -> Expression a -> Ordering)
-> (Expression a -> Expression a -> Bool)
-> (Expression a -> Expression a -> Bool)
-> (Expression a -> Expression a -> Bool)
-> (Expression a -> Expression a -> Bool)
-> (Expression a -> Expression a -> Expression a)
-> (Expression a -> Expression a -> Expression a)
-> Ord (Expression a)
Expression a -> Expression a -> Bool
Expression a -> Expression a -> Ordering
Expression a -> Expression a -> Expression a
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
$ccompare :: forall a. Ord a => Expression a -> Expression a -> Ordering
compare :: Expression a -> Expression a -> Ordering
$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
>= :: Expression a -> Expression a -> Bool
$cmax :: forall a. Ord a => Expression a -> Expression a -> Expression a
max :: Expression a -> Expression a -> Expression a
$cmin :: forall a. Ord a => Expression a -> Expression a -> Expression a
min :: Expression a -> Expression a -> Expression a
Ord,(forall a b. (a -> b) -> Expression a -> Expression b)
-> (forall a b. a -> Expression b -> Expression a)
-> Functor Expression
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
$cfmap :: forall a b. (a -> b) -> Expression a -> Expression b
fmap :: forall a b. (a -> b) -> Expression a -> Expression b
$c<$ :: forall a b. a -> Expression b -> Expression a
<$ :: forall a b. a -> Expression b -> Expression a
Functor,(forall m. Monoid m => Expression m -> m)
-> (forall m a. Monoid m => (a -> m) -> Expression a -> m)
-> (forall m a. Monoid m => (a -> m) -> Expression a -> m)
-> (forall a b. (a -> b -> b) -> b -> Expression a -> b)
-> (forall a b. (a -> b -> b) -> b -> Expression a -> b)
-> (forall b a. (b -> a -> b) -> b -> Expression a -> b)
-> (forall b a. (b -> a -> b) -> b -> Expression a -> b)
-> (forall a. (a -> a -> a) -> Expression a -> a)
-> (forall a. (a -> a -> a) -> Expression a -> a)
-> (forall a. Expression a -> [a])
-> (forall a. Expression a -> Bool)
-> (forall a. Expression a -> Int)
-> (forall a. Eq a => a -> Expression a -> Bool)
-> (forall a. Ord a => Expression a -> a)
-> (forall a. Ord a => Expression a -> a)
-> (forall a. Num a => Expression a -> a)
-> (forall a. Num a => Expression a -> a)
-> Foldable Expression
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
$cfold :: forall m. Monoid m => Expression m -> m
fold :: forall m. Monoid m => Expression m -> 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
foldMap' :: forall m a. Monoid m => (a -> m) -> Expression a -> m
$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
foldr' :: forall a b. (a -> b -> 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
foldl' :: forall b a. (b -> a -> b) -> b -> Expression a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> Expression a -> a
foldr1 :: forall a. (a -> a -> a) -> Expression a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Expression a -> a
foldl1 :: forall a. (a -> a -> a) -> Expression a -> a
$ctoList :: forall a. Expression a -> [a]
toList :: forall a. Expression a -> [a]
$cnull :: forall a. Expression a -> Bool
null :: forall a. Expression a -> Bool
$clength :: forall a. Expression a -> Int
length :: forall a. Expression a -> Int
$celem :: forall a. Eq a => a -> Expression a -> Bool
elem :: forall a. Eq a => a -> Expression a -> Bool
$cmaximum :: forall a. Ord a => Expression a -> a
maximum :: forall a. Ord a => Expression a -> a
$cminimum :: forall a. Ord a => Expression a -> a
minimum :: forall a. Ord a => Expression a -> a
$csum :: forall a. Num a => Expression a -> a
sum :: forall a. Num a => Expression a -> a
$cproduct :: forall a. Num a => Expression a -> a
product :: forall a. Num a => Expression a -> a
Foldable,Functor Expression
Foldable Expression
(Functor Expression, Foldable Expression) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> Expression a -> f (Expression b))
-> (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 (m :: * -> *) a.
    Monad m =>
    Expression (m a) -> m (Expression a))
-> Traversable 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)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Expression a -> f (Expression b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Expression a -> f (Expression b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Expression (f a) -> f (Expression a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Expression (f a) -> f (Expression a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Expression a -> m (Expression b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Expression a -> m (Expression b)
$csequence :: forall (m :: * -> *) a.
Monad m =>
Expression (m a) -> m (Expression a)
sequence :: forall (m :: * -> *) a.
Monad m =>
Expression (m a) -> m (Expression a)
Traversable)

-- | Case clauses, spec 12.11
data CaseClause a = CaseClause a (Expression a) [Statement a]
                    -- ^ @case e: stmts;@
                  | CaseDefault a [Statement a]
                    -- ^ @default: stmts;@
  deriving (Int -> CaseClause a -> ShowS
[CaseClause a] -> ShowS
CaseClause a -> String
(Int -> CaseClause a -> ShowS)
-> (CaseClause a -> String)
-> ([CaseClause a] -> ShowS)
-> Show (CaseClause a)
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
$cshowsPrec :: forall a. Show a => Int -> CaseClause a -> ShowS
showsPrec :: Int -> CaseClause a -> ShowS
$cshow :: forall a. Show a => CaseClause a -> String
show :: CaseClause a -> String
$cshowList :: forall a. Show a => [CaseClause a] -> ShowS
showList :: [CaseClause a] -> ShowS
Show,Typeable (CaseClause a)
Typeable (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 (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (CaseClause a))
-> (CaseClause a -> Constr)
-> (CaseClause a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (CaseClause a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (CaseClause a)))
-> ((forall b. Data b => b -> b) -> CaseClause a -> CaseClause a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CaseClause a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CaseClause a -> r)
-> (forall u. (forall d. Data d => d -> u) -> CaseClause a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> CaseClause a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> CaseClause a -> m (CaseClause a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CaseClause a -> m (CaseClause a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CaseClause a -> m (CaseClause a))
-> Data (CaseClause a)
CaseClause a -> Constr
CaseClause a -> DataType
(forall b. Data b => b -> b) -> CaseClause a -> CaseClause a
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 u. Int -> (forall d. Data d => d -> u) -> CaseClause a -> u
forall u. (forall d. Data d => d -> u) -> CaseClause a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CaseClause a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CaseClause a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CaseClause a -> m (CaseClause a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CaseClause a -> m (CaseClause 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))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (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)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CaseClause a -> 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)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (CaseClause a)
$ctoConstr :: forall a. Data a => CaseClause a -> Constr
toConstr :: CaseClause a -> Constr
$cdataTypeOf :: forall a. Data a => CaseClause a -> DataType
dataTypeOf :: CaseClause a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (CaseClause a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> 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))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (CaseClause a))
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> CaseClause a -> CaseClause a
gmapT :: (forall b. Data b => b -> b) -> CaseClause a -> CaseClause a
$cgmapQl :: 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
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CaseClause a -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CaseClause a -> r
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> CaseClause a -> [u]
gmapQ :: forall u. (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
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CaseClause a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad 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)
$cgmapMp :: 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)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> CaseClause a -> m (CaseClause a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CaseClause a -> m (CaseClause a)
Data,Typeable,CaseClause a -> CaseClause a -> Bool
(CaseClause a -> CaseClause a -> Bool)
-> (CaseClause a -> CaseClause a -> Bool) -> Eq (CaseClause a)
forall a. Eq a => CaseClause a -> CaseClause a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$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
/= :: CaseClause a -> CaseClause a -> Bool
Eq,Eq (CaseClause a)
Eq (CaseClause a) =>
(CaseClause a -> CaseClause a -> Ordering)
-> (CaseClause a -> CaseClause a -> Bool)
-> (CaseClause a -> CaseClause a -> Bool)
-> (CaseClause a -> CaseClause a -> Bool)
-> (CaseClause a -> CaseClause a -> Bool)
-> (CaseClause a -> CaseClause a -> CaseClause a)
-> (CaseClause a -> CaseClause a -> CaseClause a)
-> Ord (CaseClause a)
CaseClause a -> CaseClause a -> Bool
CaseClause a -> CaseClause a -> Ordering
CaseClause a -> CaseClause a -> CaseClause a
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
$ccompare :: forall a. Ord a => CaseClause a -> CaseClause a -> Ordering
compare :: CaseClause a -> CaseClause a -> Ordering
$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
>= :: CaseClause a -> CaseClause a -> Bool
$cmax :: forall a. Ord a => CaseClause a -> CaseClause a -> CaseClause a
max :: CaseClause a -> CaseClause a -> CaseClause a
$cmin :: forall a. Ord a => CaseClause a -> CaseClause a -> CaseClause a
min :: CaseClause a -> CaseClause a -> CaseClause a
Ord,(forall a b. (a -> b) -> CaseClause a -> CaseClause b)
-> (forall a b. a -> CaseClause b -> CaseClause a)
-> Functor CaseClause
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
$cfmap :: forall a b. (a -> b) -> CaseClause a -> CaseClause b
fmap :: forall a b. (a -> b) -> CaseClause a -> CaseClause b
$c<$ :: forall a b. a -> CaseClause b -> CaseClause a
<$ :: forall a b. a -> CaseClause b -> CaseClause a
Functor,(forall m. Monoid m => CaseClause m -> m)
-> (forall m a. Monoid m => (a -> m) -> CaseClause a -> m)
-> (forall m a. Monoid m => (a -> m) -> CaseClause a -> m)
-> (forall a b. (a -> b -> b) -> b -> CaseClause a -> b)
-> (forall a b. (a -> b -> b) -> b -> CaseClause a -> b)
-> (forall b a. (b -> a -> b) -> b -> CaseClause a -> b)
-> (forall b a. (b -> a -> b) -> b -> CaseClause a -> b)
-> (forall a. (a -> a -> a) -> CaseClause a -> a)
-> (forall a. (a -> a -> a) -> CaseClause a -> a)
-> (forall a. CaseClause a -> [a])
-> (forall a. CaseClause a -> Bool)
-> (forall a. CaseClause a -> Int)
-> (forall a. Eq a => a -> CaseClause a -> Bool)
-> (forall a. Ord a => CaseClause a -> a)
-> (forall a. Ord a => CaseClause a -> a)
-> (forall a. Num a => CaseClause a -> a)
-> (forall a. Num a => CaseClause a -> a)
-> Foldable CaseClause
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
$cfold :: forall m. Monoid m => CaseClause m -> m
fold :: forall m. Monoid m => CaseClause m -> 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
foldMap' :: forall m a. Monoid m => (a -> m) -> CaseClause a -> m
$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
foldr' :: forall a b. (a -> b -> 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
foldl' :: forall b a. (b -> a -> b) -> b -> CaseClause a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> CaseClause a -> a
foldr1 :: forall a. (a -> a -> a) -> CaseClause a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> CaseClause a -> a
foldl1 :: forall a. (a -> a -> a) -> CaseClause a -> a
$ctoList :: forall a. CaseClause a -> [a]
toList :: forall a. CaseClause a -> [a]
$cnull :: forall a. CaseClause a -> Bool
null :: forall a. CaseClause a -> Bool
$clength :: forall a. CaseClause a -> Int
length :: forall a. CaseClause a -> Int
$celem :: forall a. Eq a => a -> CaseClause a -> Bool
elem :: forall a. Eq a => a -> CaseClause a -> Bool
$cmaximum :: forall a. Ord a => CaseClause a -> a
maximum :: forall a. Ord a => CaseClause a -> a
$cminimum :: forall a. Ord a => CaseClause a -> a
minimum :: forall a. Ord a => CaseClause a -> a
$csum :: forall a. Num a => CaseClause a -> a
sum :: forall a. Num a => CaseClause a -> a
$cproduct :: forall a. Num a => CaseClause a -> a
product :: forall a. Num a => CaseClause a -> a
Foldable,Functor CaseClause
Foldable CaseClause
(Functor CaseClause, Foldable CaseClause) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> CaseClause a -> f (CaseClause b))
-> (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 (m :: * -> *) a.
    Monad m =>
    CaseClause (m a) -> m (CaseClause a))
-> Traversable 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)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> CaseClause a -> f (CaseClause b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> CaseClause a -> f (CaseClause b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
CaseClause (f a) -> f (CaseClause a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
CaseClause (f a) -> f (CaseClause a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> CaseClause a -> m (CaseClause b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> CaseClause a -> m (CaseClause b)
$csequence :: forall (m :: * -> *) a.
Monad m =>
CaseClause (m a) -> m (CaseClause a)
sequence :: forall (m :: * -> *) a.
Monad m =>
CaseClause (m a) -> m (CaseClause a)
Traversable)

-- | Catch clause, spec 12.14
data CatchClause a = CatchClause a (Id a) (Statement a) 
                     -- ^ @catch (x) {...}@
  deriving (Int -> CatchClause a -> ShowS
[CatchClause a] -> ShowS
CatchClause a -> String
(Int -> CatchClause a -> ShowS)
-> (CatchClause a -> String)
-> ([CatchClause a] -> ShowS)
-> Show (CatchClause a)
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
$cshowsPrec :: forall a. Show a => Int -> CatchClause a -> ShowS
showsPrec :: Int -> CatchClause a -> ShowS
$cshow :: forall a. Show a => CatchClause a -> String
show :: CatchClause a -> String
$cshowList :: forall a. Show a => [CatchClause a] -> ShowS
showList :: [CatchClause a] -> ShowS
Show,Typeable (CatchClause a)
Typeable (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 (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (CatchClause a))
-> (CatchClause a -> Constr)
-> (CatchClause a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (CatchClause a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (CatchClause a)))
-> ((forall b. Data b => b -> b) -> CatchClause a -> CatchClause a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CatchClause a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CatchClause a -> r)
-> (forall u. (forall d. Data d => d -> u) -> CatchClause a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> CatchClause a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> CatchClause a -> m (CatchClause a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> CatchClause a -> m (CatchClause a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> CatchClause a -> m (CatchClause a))
-> Data (CatchClause a)
CatchClause a -> Constr
CatchClause a -> DataType
(forall b. Data b => b -> b) -> CatchClause a -> CatchClause a
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 u. Int -> (forall d. Data d => d -> u) -> CatchClause a -> u
forall u. (forall d. Data d => d -> u) -> CatchClause a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CatchClause a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CatchClause a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> CatchClause a -> m (CatchClause a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CatchClause a -> m (CatchClause 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))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (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)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CatchClause a -> 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)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (CatchClause a)
$ctoConstr :: forall a. Data a => CatchClause a -> Constr
toConstr :: CatchClause a -> Constr
$cdataTypeOf :: forall a. Data a => CatchClause a -> DataType
dataTypeOf :: CatchClause a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (CatchClause a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> 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))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (CatchClause a))
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> CatchClause a -> CatchClause a
gmapT :: (forall b. Data b => b -> b) -> CatchClause a -> CatchClause a
$cgmapQl :: 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
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CatchClause a -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CatchClause a -> r
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> CatchClause a -> [u]
gmapQ :: forall u. (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
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CatchClause a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad 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)
$cgmapMp :: 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)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> CatchClause a -> m (CatchClause a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CatchClause a -> m (CatchClause a)
Data,Typeable,CatchClause a -> CatchClause a -> Bool
(CatchClause a -> CatchClause a -> Bool)
-> (CatchClause a -> CatchClause a -> Bool) -> Eq (CatchClause a)
forall a. Eq a => CatchClause a -> CatchClause a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$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
/= :: CatchClause a -> CatchClause a -> Bool
Eq,Eq (CatchClause a)
Eq (CatchClause a) =>
(CatchClause a -> CatchClause a -> Ordering)
-> (CatchClause a -> CatchClause a -> Bool)
-> (CatchClause a -> CatchClause a -> Bool)
-> (CatchClause a -> CatchClause a -> Bool)
-> (CatchClause a -> CatchClause a -> Bool)
-> (CatchClause a -> CatchClause a -> CatchClause a)
-> (CatchClause a -> CatchClause a -> CatchClause a)
-> Ord (CatchClause a)
CatchClause a -> CatchClause a -> Bool
CatchClause a -> CatchClause a -> Ordering
CatchClause a -> CatchClause a -> CatchClause a
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
$ccompare :: forall a. Ord a => CatchClause a -> CatchClause a -> Ordering
compare :: CatchClause a -> CatchClause a -> Ordering
$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
>= :: CatchClause a -> CatchClause a -> Bool
$cmax :: forall a. Ord a => CatchClause a -> CatchClause a -> CatchClause a
max :: CatchClause a -> CatchClause a -> CatchClause a
$cmin :: forall a. Ord a => CatchClause a -> CatchClause a -> CatchClause a
min :: CatchClause a -> CatchClause a -> CatchClause a
Ord,(forall a b. (a -> b) -> CatchClause a -> CatchClause b)
-> (forall a b. a -> CatchClause b -> CatchClause a)
-> Functor CatchClause
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
$cfmap :: forall a b. (a -> b) -> CatchClause a -> CatchClause b
fmap :: forall a b. (a -> b) -> CatchClause a -> CatchClause b
$c<$ :: forall a b. a -> CatchClause b -> CatchClause a
<$ :: forall a b. a -> CatchClause b -> CatchClause a
Functor,(forall m. Monoid m => CatchClause m -> m)
-> (forall m a. Monoid m => (a -> m) -> CatchClause a -> m)
-> (forall m a. Monoid m => (a -> m) -> CatchClause a -> m)
-> (forall a b. (a -> b -> b) -> b -> CatchClause a -> b)
-> (forall a b. (a -> b -> b) -> b -> CatchClause a -> b)
-> (forall b a. (b -> a -> b) -> b -> CatchClause a -> b)
-> (forall b a. (b -> a -> b) -> b -> CatchClause a -> b)
-> (forall a. (a -> a -> a) -> CatchClause a -> a)
-> (forall a. (a -> a -> a) -> CatchClause a -> a)
-> (forall a. CatchClause a -> [a])
-> (forall a. CatchClause a -> Bool)
-> (forall a. CatchClause a -> Int)
-> (forall a. Eq a => a -> CatchClause a -> Bool)
-> (forall a. Ord a => CatchClause a -> a)
-> (forall a. Ord a => CatchClause a -> a)
-> (forall a. Num a => CatchClause a -> a)
-> (forall a. Num a => CatchClause a -> a)
-> Foldable CatchClause
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
$cfold :: forall m. Monoid m => CatchClause m -> m
fold :: forall m. Monoid m => CatchClause m -> 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
foldMap' :: forall m a. Monoid m => (a -> m) -> CatchClause a -> m
$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
foldr' :: forall a b. (a -> b -> 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
foldl' :: forall b a. (b -> a -> b) -> b -> CatchClause a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> CatchClause a -> a
foldr1 :: forall a. (a -> a -> a) -> CatchClause a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> CatchClause a -> a
foldl1 :: forall a. (a -> a -> a) -> CatchClause a -> a
$ctoList :: forall a. CatchClause a -> [a]
toList :: forall a. CatchClause a -> [a]
$cnull :: forall a. CatchClause a -> Bool
null :: forall a. CatchClause a -> Bool
$clength :: forall a. CatchClause a -> Int
length :: forall a. CatchClause a -> Int
$celem :: forall a. Eq a => a -> CatchClause a -> Bool
elem :: forall a. Eq a => a -> CatchClause a -> Bool
$cmaximum :: forall a. Ord a => CatchClause a -> a
maximum :: forall a. Ord a => CatchClause a -> a
$cminimum :: forall a. Ord a => CatchClause a -> a
minimum :: forall a. Ord a => CatchClause a -> a
$csum :: forall a. Num a => CatchClause a -> a
sum :: forall a. Num a => CatchClause a -> a
$cproduct :: forall a. Num a => CatchClause a -> a
product :: forall a. Num a => CatchClause a -> a
Foldable,Functor CatchClause
Foldable CatchClause
(Functor CatchClause, Foldable CatchClause) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> CatchClause a -> f (CatchClause b))
-> (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 (m :: * -> *) a.
    Monad m =>
    CatchClause (m a) -> m (CatchClause a))
-> Traversable 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)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> CatchClause a -> f (CatchClause b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> CatchClause a -> f (CatchClause b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
CatchClause (f a) -> f (CatchClause a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
CatchClause (f a) -> f (CatchClause a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> CatchClause a -> m (CatchClause b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> CatchClause a -> m (CatchClause b)
$csequence :: forall (m :: * -> *) a.
Monad m =>
CatchClause (m a) -> m (CatchClause a)
sequence :: forall (m :: * -> *) a.
Monad m =>
CatchClause (m a) -> m (CatchClause a)
Traversable)

-- | A variable declaration, spec 12.2
data VarDecl a = VarDecl a (Id a) (Maybe (Expression a)) 
                 -- ^ @var x = e;@
  deriving (Int -> VarDecl a -> ShowS
[VarDecl a] -> ShowS
VarDecl a -> String
(Int -> VarDecl a -> ShowS)
-> (VarDecl a -> String)
-> ([VarDecl a] -> ShowS)
-> Show (VarDecl a)
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
$cshowsPrec :: forall a. Show a => Int -> VarDecl a -> ShowS
showsPrec :: Int -> VarDecl a -> ShowS
$cshow :: forall a. Show a => VarDecl a -> String
show :: VarDecl a -> String
$cshowList :: forall a. Show a => [VarDecl a] -> ShowS
showList :: [VarDecl a] -> ShowS
Show,Typeable (VarDecl a)
Typeable (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 (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (VarDecl a))
-> (VarDecl a -> Constr)
-> (VarDecl a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (VarDecl a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (VarDecl a)))
-> ((forall b. Data b => b -> b) -> VarDecl a -> VarDecl a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> VarDecl a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> VarDecl a -> r)
-> (forall u. (forall d. Data d => d -> u) -> VarDecl a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> VarDecl a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> VarDecl a -> m (VarDecl a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> VarDecl a -> m (VarDecl a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> VarDecl a -> m (VarDecl a))
-> Data (VarDecl a)
VarDecl a -> Constr
VarDecl a -> DataType
(forall b. Data b => b -> b) -> VarDecl a -> VarDecl a
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 u. Int -> (forall d. Data d => d -> u) -> VarDecl a -> u
forall u. (forall d. Data d => d -> u) -> VarDecl a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> VarDecl a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> VarDecl a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> VarDecl a -> m (VarDecl a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> VarDecl a -> m (VarDecl 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))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (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)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> VarDecl a -> 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)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (VarDecl a)
$ctoConstr :: forall a. Data a => VarDecl a -> Constr
toConstr :: VarDecl a -> Constr
$cdataTypeOf :: forall a. Data a => VarDecl a -> DataType
dataTypeOf :: VarDecl a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (VarDecl a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> 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))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (VarDecl a))
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> VarDecl a -> VarDecl a
gmapT :: (forall b. Data b => b -> b) -> VarDecl a -> VarDecl a
$cgmapQl :: 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
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> VarDecl a -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> VarDecl a -> r
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> VarDecl a -> [u]
gmapQ :: forall u. (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
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> VarDecl a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad 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)
$cgmapMp :: 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)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> VarDecl a -> m (VarDecl a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> VarDecl a -> m (VarDecl a)
Data,Typeable,VarDecl a -> VarDecl a -> Bool
(VarDecl a -> VarDecl a -> Bool)
-> (VarDecl a -> VarDecl a -> Bool) -> Eq (VarDecl a)
forall a. Eq a => VarDecl a -> VarDecl a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$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
/= :: VarDecl a -> VarDecl a -> Bool
Eq,Eq (VarDecl a)
Eq (VarDecl a) =>
(VarDecl a -> VarDecl a -> Ordering)
-> (VarDecl a -> VarDecl a -> Bool)
-> (VarDecl a -> VarDecl a -> Bool)
-> (VarDecl a -> VarDecl a -> Bool)
-> (VarDecl a -> VarDecl a -> Bool)
-> (VarDecl a -> VarDecl a -> VarDecl a)
-> (VarDecl a -> VarDecl a -> VarDecl a)
-> Ord (VarDecl a)
VarDecl a -> VarDecl a -> Bool
VarDecl a -> VarDecl a -> Ordering
VarDecl a -> VarDecl a -> VarDecl a
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
$ccompare :: forall a. Ord a => VarDecl a -> VarDecl a -> Ordering
compare :: VarDecl a -> VarDecl a -> Ordering
$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
>= :: VarDecl a -> VarDecl a -> Bool
$cmax :: forall a. Ord a => VarDecl a -> VarDecl a -> VarDecl a
max :: VarDecl a -> VarDecl a -> VarDecl a
$cmin :: forall a. Ord a => VarDecl a -> VarDecl a -> VarDecl a
min :: VarDecl a -> VarDecl a -> VarDecl a
Ord,(forall a b. (a -> b) -> VarDecl a -> VarDecl b)
-> (forall a b. a -> VarDecl b -> VarDecl a) -> Functor VarDecl
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
$cfmap :: forall a b. (a -> b) -> VarDecl a -> VarDecl b
fmap :: forall a b. (a -> b) -> VarDecl a -> VarDecl b
$c<$ :: forall a b. a -> VarDecl b -> VarDecl a
<$ :: forall a b. a -> VarDecl b -> VarDecl a
Functor,(forall m. Monoid m => VarDecl m -> m)
-> (forall m a. Monoid m => (a -> m) -> VarDecl a -> m)
-> (forall m a. Monoid m => (a -> m) -> VarDecl a -> m)
-> (forall a b. (a -> b -> b) -> b -> VarDecl a -> b)
-> (forall a b. (a -> b -> b) -> b -> VarDecl a -> b)
-> (forall b a. (b -> a -> b) -> b -> VarDecl a -> b)
-> (forall b a. (b -> a -> b) -> b -> VarDecl a -> b)
-> (forall a. (a -> a -> a) -> VarDecl a -> a)
-> (forall a. (a -> a -> a) -> VarDecl a -> a)
-> (forall a. VarDecl a -> [a])
-> (forall a. VarDecl a -> Bool)
-> (forall a. VarDecl a -> Int)
-> (forall a. Eq a => a -> VarDecl a -> Bool)
-> (forall a. Ord a => VarDecl a -> a)
-> (forall a. Ord a => VarDecl a -> a)
-> (forall a. Num a => VarDecl a -> a)
-> (forall a. Num a => VarDecl a -> a)
-> Foldable VarDecl
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
$cfold :: forall m. Monoid m => VarDecl m -> m
fold :: forall m. Monoid m => VarDecl m -> 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
foldMap' :: forall m a. Monoid m => (a -> m) -> VarDecl a -> m
$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
foldr' :: forall a b. (a -> b -> 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
foldl' :: forall b a. (b -> a -> b) -> b -> VarDecl a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> VarDecl a -> a
foldr1 :: forall a. (a -> a -> a) -> VarDecl a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> VarDecl a -> a
foldl1 :: forall a. (a -> a -> a) -> VarDecl a -> a
$ctoList :: forall a. VarDecl a -> [a]
toList :: forall a. VarDecl a -> [a]
$cnull :: forall a. VarDecl a -> Bool
null :: forall a. VarDecl a -> Bool
$clength :: forall a. VarDecl a -> Int
length :: forall a. VarDecl a -> Int
$celem :: forall a. Eq a => a -> VarDecl a -> Bool
elem :: forall a. Eq a => a -> VarDecl a -> Bool
$cmaximum :: forall a. Ord a => VarDecl a -> a
maximum :: forall a. Ord a => VarDecl a -> a
$cminimum :: forall a. Ord a => VarDecl a -> a
minimum :: forall a. Ord a => VarDecl a -> a
$csum :: forall a. Num a => VarDecl a -> a
sum :: forall a. Num a => VarDecl a -> a
$cproduct :: forall a. Num a => VarDecl a -> a
product :: forall a. Num a => VarDecl a -> a
Foldable,Functor VarDecl
Foldable VarDecl
(Functor VarDecl, Foldable VarDecl) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> VarDecl a -> f (VarDecl b))
-> (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 (m :: * -> *) a.
    Monad m =>
    VarDecl (m a) -> m (VarDecl a))
-> Traversable 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)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> VarDecl a -> f (VarDecl b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> VarDecl a -> f (VarDecl b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
VarDecl (f a) -> f (VarDecl a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
VarDecl (f a) -> f (VarDecl a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> VarDecl a -> m (VarDecl b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> VarDecl a -> m (VarDecl b)
$csequence :: forall (m :: * -> *) a. Monad m => VarDecl (m a) -> m (VarDecl a)
sequence :: forall (m :: * -> *) a. Monad m => VarDecl (m a) -> m (VarDecl a)
Traversable)
  
-- | for initializer, spec 12.6
data ForInit a = NoInit -- ^ empty
               | VarInit [VarDecl a] -- ^ @var x, y=42@
               | ExprInit (Expression a) -- ^ @expr@
  deriving (Int -> ForInit a -> ShowS
[ForInit a] -> ShowS
ForInit a -> String
(Int -> ForInit a -> ShowS)
-> (ForInit a -> String)
-> ([ForInit a] -> ShowS)
-> Show (ForInit a)
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
$cshowsPrec :: forall a. Show a => Int -> ForInit a -> ShowS
showsPrec :: Int -> ForInit a -> ShowS
$cshow :: forall a. Show a => ForInit a -> String
show :: ForInit a -> String
$cshowList :: forall a. Show a => [ForInit a] -> ShowS
showList :: [ForInit a] -> ShowS
Show,Typeable (ForInit a)
Typeable (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 (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ForInit a))
-> (ForInit a -> Constr)
-> (ForInit a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (ForInit a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ForInit a)))
-> ((forall b. Data b => b -> b) -> ForInit a -> ForInit a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ForInit a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ForInit a -> r)
-> (forall u. (forall d. Data d => d -> u) -> ForInit a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ForInit a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ForInit a -> m (ForInit a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ForInit a -> m (ForInit a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ForInit a -> m (ForInit a))
-> Data (ForInit a)
ForInit a -> Constr
ForInit a -> DataType
(forall b. Data b => b -> b) -> ForInit a -> ForInit a
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 u. Int -> (forall d. Data d => d -> u) -> ForInit a -> u
forall u. (forall d. Data d => d -> u) -> ForInit a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ForInit a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ForInit a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ForInit a -> m (ForInit a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ForInit a -> m (ForInit 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))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (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)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ForInit a -> 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)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ForInit a)
$ctoConstr :: forall a. Data a => ForInit a -> Constr
toConstr :: ForInit a -> Constr
$cdataTypeOf :: forall a. Data a => ForInit a -> DataType
dataTypeOf :: ForInit a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (ForInit a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> 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))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ForInit a))
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> ForInit a -> ForInit a
gmapT :: (forall b. Data b => b -> b) -> ForInit a -> ForInit a
$cgmapQl :: 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
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ForInit a -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ForInit a -> r
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> ForInit a -> [u]
gmapQ :: forall u. (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
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ForInit a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad 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)
$cgmapMp :: 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)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> ForInit a -> m (ForInit a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ForInit a -> m (ForInit a)
Data,Typeable,ForInit a -> ForInit a -> Bool
(ForInit a -> ForInit a -> Bool)
-> (ForInit a -> ForInit a -> Bool) -> Eq (ForInit a)
forall a. Eq a => ForInit a -> ForInit a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$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
/= :: ForInit a -> ForInit a -> Bool
Eq,Eq (ForInit a)
Eq (ForInit a) =>
(ForInit a -> ForInit a -> Ordering)
-> (ForInit a -> ForInit a -> Bool)
-> (ForInit a -> ForInit a -> Bool)
-> (ForInit a -> ForInit a -> Bool)
-> (ForInit a -> ForInit a -> Bool)
-> (ForInit a -> ForInit a -> ForInit a)
-> (ForInit a -> ForInit a -> ForInit a)
-> Ord (ForInit a)
ForInit a -> ForInit a -> Bool
ForInit a -> ForInit a -> Ordering
ForInit a -> ForInit a -> ForInit a
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
$ccompare :: forall a. Ord a => ForInit a -> ForInit a -> Ordering
compare :: ForInit a -> ForInit a -> Ordering
$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
>= :: ForInit a -> ForInit a -> Bool
$cmax :: forall a. Ord a => ForInit a -> ForInit a -> ForInit a
max :: ForInit a -> ForInit a -> ForInit a
$cmin :: forall a. Ord a => ForInit a -> ForInit a -> ForInit a
min :: ForInit a -> ForInit a -> ForInit a
Ord,(forall a b. (a -> b) -> ForInit a -> ForInit b)
-> (forall a b. a -> ForInit b -> ForInit a) -> Functor ForInit
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
$cfmap :: forall a b. (a -> b) -> ForInit a -> ForInit b
fmap :: forall a b. (a -> b) -> ForInit a -> ForInit b
$c<$ :: forall a b. a -> ForInit b -> ForInit a
<$ :: forall a b. a -> ForInit b -> ForInit a
Functor,(forall m. Monoid m => ForInit m -> m)
-> (forall m a. Monoid m => (a -> m) -> ForInit a -> m)
-> (forall m a. Monoid m => (a -> m) -> ForInit a -> m)
-> (forall a b. (a -> b -> b) -> b -> ForInit a -> b)
-> (forall a b. (a -> b -> b) -> b -> ForInit a -> b)
-> (forall b a. (b -> a -> b) -> b -> ForInit a -> b)
-> (forall b a. (b -> a -> b) -> b -> ForInit a -> b)
-> (forall a. (a -> a -> a) -> ForInit a -> a)
-> (forall a. (a -> a -> a) -> ForInit a -> a)
-> (forall a. ForInit a -> [a])
-> (forall a. ForInit a -> Bool)
-> (forall a. ForInit a -> Int)
-> (forall a. Eq a => a -> ForInit a -> Bool)
-> (forall a. Ord a => ForInit a -> a)
-> (forall a. Ord a => ForInit a -> a)
-> (forall a. Num a => ForInit a -> a)
-> (forall a. Num a => ForInit a -> a)
-> Foldable ForInit
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
$cfold :: forall m. Monoid m => ForInit m -> m
fold :: forall m. Monoid m => ForInit m -> 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
foldMap' :: forall m a. Monoid m => (a -> m) -> ForInit a -> m
$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
foldr' :: forall a b. (a -> b -> 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
foldl' :: forall b a. (b -> a -> b) -> b -> ForInit a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> ForInit a -> a
foldr1 :: forall a. (a -> a -> a) -> ForInit a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> ForInit a -> a
foldl1 :: forall a. (a -> a -> a) -> ForInit a -> a
$ctoList :: forall a. ForInit a -> [a]
toList :: forall a. ForInit a -> [a]
$cnull :: forall a. ForInit a -> Bool
null :: forall a. ForInit a -> Bool
$clength :: forall a. ForInit a -> Int
length :: forall a. ForInit a -> Int
$celem :: forall a. Eq a => a -> ForInit a -> Bool
elem :: forall a. Eq a => a -> ForInit a -> Bool
$cmaximum :: forall a. Ord a => ForInit a -> a
maximum :: forall a. Ord a => ForInit a -> a
$cminimum :: forall a. Ord a => ForInit a -> a
minimum :: forall a. Ord a => ForInit a -> a
$csum :: forall a. Num a => ForInit a -> a
sum :: forall a. Num a => ForInit a -> a
$cproduct :: forall a. Num a => ForInit a -> a
product :: forall a. Num a => ForInit a -> a
Foldable,Functor ForInit
Foldable ForInit
(Functor ForInit, Foldable ForInit) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> ForInit a -> f (ForInit b))
-> (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 (m :: * -> *) a.
    Monad m =>
    ForInit (m a) -> m (ForInit a))
-> Traversable 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)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ForInit a -> f (ForInit b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ForInit a -> f (ForInit b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
ForInit (f a) -> f (ForInit a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
ForInit (f a) -> f (ForInit a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ForInit a -> m (ForInit b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ForInit a -> m (ForInit b)
$csequence :: forall (m :: * -> *) a. Monad m => ForInit (m a) -> m (ForInit a)
sequence :: forall (m :: * -> *) a. Monad m => ForInit (m a) -> m (ForInit a)
Traversable)

-- | for..in initializer, spec 12.6
data ForInInit a = ForInVar (Id a) -- ^ @var x@
                 | ForInLVal (LValue a) -- ^ @foo.baz@, @foo[bar]@, @z@
 deriving (Int -> ForInInit a -> ShowS
[ForInInit a] -> ShowS
ForInInit a -> String
(Int -> ForInInit a -> ShowS)
-> (ForInInit a -> String)
-> ([ForInInit a] -> ShowS)
-> Show (ForInInit a)
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
$cshowsPrec :: forall a. Show a => Int -> ForInInit a -> ShowS
showsPrec :: Int -> ForInInit a -> ShowS
$cshow :: forall a. Show a => ForInInit a -> String
show :: ForInInit a -> String
$cshowList :: forall a. Show a => [ForInInit a] -> ShowS
showList :: [ForInInit a] -> ShowS
Show,Typeable (ForInInit a)
Typeable (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 (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ForInInit a))
-> (ForInInit a -> Constr)
-> (ForInInit a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (ForInInit a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ForInInit a)))
-> ((forall b. Data b => b -> b) -> ForInInit a -> ForInInit a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ForInInit a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ForInInit a -> r)
-> (forall u. (forall d. Data d => d -> u) -> ForInInit a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ForInInit a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ForInInit a -> m (ForInInit a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ForInInit a -> m (ForInInit a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ForInInit a -> m (ForInInit a))
-> Data (ForInInit a)
ForInInit a -> Constr
ForInInit a -> DataType
(forall b. Data b => b -> b) -> ForInInit a -> ForInInit a
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 u. Int -> (forall d. Data d => d -> u) -> ForInInit a -> u
forall u. (forall d. Data d => d -> u) -> ForInInit a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ForInInit a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ForInInit a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ForInInit a -> m (ForInInit a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ForInInit a -> m (ForInInit 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))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (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)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ForInInit a -> 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)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ForInInit a)
$ctoConstr :: forall a. Data a => ForInInit a -> Constr
toConstr :: ForInInit a -> Constr
$cdataTypeOf :: forall a. Data a => ForInInit a -> DataType
dataTypeOf :: ForInInit a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (ForInInit a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> 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))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ForInInit a))
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> ForInInit a -> ForInInit a
gmapT :: (forall b. Data b => b -> b) -> ForInInit a -> ForInInit a
$cgmapQl :: 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
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ForInInit a -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ForInInit a -> r
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> ForInInit a -> [u]
gmapQ :: forall u. (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
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ForInInit a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad 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)
$cgmapMp :: 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)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> ForInInit a -> m (ForInInit a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ForInInit a -> m (ForInInit a)
Data,Typeable,ForInInit a -> ForInInit a -> Bool
(ForInInit a -> ForInInit a -> Bool)
-> (ForInInit a -> ForInInit a -> Bool) -> Eq (ForInInit a)
forall a. Eq a => ForInInit a -> ForInInit a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$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
/= :: ForInInit a -> ForInInit a -> Bool
Eq,Eq (ForInInit a)
Eq (ForInInit a) =>
(ForInInit a -> ForInInit a -> Ordering)
-> (ForInInit a -> ForInInit a -> Bool)
-> (ForInInit a -> ForInInit a -> Bool)
-> (ForInInit a -> ForInInit a -> Bool)
-> (ForInInit a -> ForInInit a -> Bool)
-> (ForInInit a -> ForInInit a -> ForInInit a)
-> (ForInInit a -> ForInInit a -> ForInInit a)
-> Ord (ForInInit a)
ForInInit a -> ForInInit a -> Bool
ForInInit a -> ForInInit a -> Ordering
ForInInit a -> ForInInit a -> ForInInit a
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
$ccompare :: forall a. Ord a => ForInInit a -> ForInInit a -> Ordering
compare :: ForInInit a -> ForInInit a -> Ordering
$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
>= :: ForInInit a -> ForInInit a -> Bool
$cmax :: forall a. Ord a => ForInInit a -> ForInInit a -> ForInInit a
max :: ForInInit a -> ForInInit a -> ForInInit a
$cmin :: forall a. Ord a => ForInInit a -> ForInInit a -> ForInInit a
min :: ForInInit a -> ForInInit a -> ForInInit a
Ord,(forall a b. (a -> b) -> ForInInit a -> ForInInit b)
-> (forall a b. a -> ForInInit b -> ForInInit a)
-> Functor ForInInit
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
$cfmap :: forall a b. (a -> b) -> ForInInit a -> ForInInit b
fmap :: forall a b. (a -> b) -> ForInInit a -> ForInInit b
$c<$ :: forall a b. a -> ForInInit b -> ForInInit a
<$ :: forall a b. a -> ForInInit b -> ForInInit a
Functor,(forall m. Monoid m => ForInInit m -> m)
-> (forall m a. Monoid m => (a -> m) -> ForInInit a -> m)
-> (forall m a. Monoid m => (a -> m) -> ForInInit a -> m)
-> (forall a b. (a -> b -> b) -> b -> ForInInit a -> b)
-> (forall a b. (a -> b -> b) -> b -> ForInInit a -> b)
-> (forall b a. (b -> a -> b) -> b -> ForInInit a -> b)
-> (forall b a. (b -> a -> b) -> b -> ForInInit a -> b)
-> (forall a. (a -> a -> a) -> ForInInit a -> a)
-> (forall a. (a -> a -> a) -> ForInInit a -> a)
-> (forall a. ForInInit a -> [a])
-> (forall a. ForInInit a -> Bool)
-> (forall a. ForInInit a -> Int)
-> (forall a. Eq a => a -> ForInInit a -> Bool)
-> (forall a. Ord a => ForInInit a -> a)
-> (forall a. Ord a => ForInInit a -> a)
-> (forall a. Num a => ForInInit a -> a)
-> (forall a. Num a => ForInInit a -> a)
-> Foldable ForInInit
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
$cfold :: forall m. Monoid m => ForInInit m -> m
fold :: forall m. Monoid m => ForInInit m -> 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
foldMap' :: forall m a. Monoid m => (a -> m) -> ForInInit a -> m
$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
foldr' :: forall a b. (a -> b -> 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
foldl' :: forall b a. (b -> a -> b) -> b -> ForInInit a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> ForInInit a -> a
foldr1 :: forall a. (a -> a -> a) -> ForInInit a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> ForInInit a -> a
foldl1 :: forall a. (a -> a -> a) -> ForInInit a -> a
$ctoList :: forall a. ForInInit a -> [a]
toList :: forall a. ForInInit a -> [a]
$cnull :: forall a. ForInInit a -> Bool
null :: forall a. ForInInit a -> Bool
$clength :: forall a. ForInInit a -> Int
length :: forall a. ForInInit a -> Int
$celem :: forall a. Eq a => a -> ForInInit a -> Bool
elem :: forall a. Eq a => a -> ForInInit a -> Bool
$cmaximum :: forall a. Ord a => ForInInit a -> a
maximum :: forall a. Ord a => ForInInit a -> a
$cminimum :: forall a. Ord a => ForInInit a -> a
minimum :: forall a. Ord a => ForInInit a -> a
$csum :: forall a. Num a => ForInInit a -> a
sum :: forall a. Num a => ForInInit a -> a
$cproduct :: forall a. Num a => ForInInit a -> a
product :: forall a. Num a => ForInInit a -> a
Foldable,Functor ForInInit
Foldable ForInInit
(Functor ForInInit, Foldable ForInInit) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> ForInInit a -> f (ForInInit b))
-> (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 (m :: * -> *) a.
    Monad m =>
    ForInInit (m a) -> m (ForInInit a))
-> Traversable 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)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ForInInit a -> f (ForInInit b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ForInInit a -> f (ForInInit b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
ForInInit (f a) -> f (ForInInit a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
ForInInit (f a) -> f (ForInInit a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ForInInit a -> m (ForInInit b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ForInInit a -> m (ForInInit b)
$csequence :: forall (m :: * -> *) a.
Monad m =>
ForInInit (m a) -> m (ForInInit a)
sequence :: forall (m :: * -> *) a.
Monad m =>
ForInInit (m a) -> m (ForInInit a)
Traversable)
  
-- | Statements, spec 12.
data Statement a 
  = BlockStmt a [Statement a] -- ^ @{stmts}@, spec 12.1
  | EmptyStmt a -- ^ @;@, spec 12.3
  | ExprStmt a (Expression a) -- ^ @expr;@, spec 12.4
  | IfStmt a (Expression a) (Statement a) (Statement a) 
    -- ^ @if (e) stmt@, spec 12.5
  | IfSingleStmt a (Expression a) (Statement a)
    -- ^ @if (e) stmt1 else stmt2@, spec 12.5
  | SwitchStmt a (Expression a) [CaseClause a]
    -- ^ @switch (e) clauses@, spec 12.11
  | WhileStmt a (Expression a) (Statement a)
    -- ^ @while (e) do stmt@, spec 12.6
  | DoWhileStmt a (Statement a) (Expression a)
    -- ^ @do stmt while (e);@, spec 12.6
  | BreakStmt a (Maybe (Id a)) -- ^ @break lab;@, spec 12.8
  | ContinueStmt a (Maybe (Id a)) -- ^ @continue lab;@, spec 12.7
  | LabelledStmt a (Id a) (Statement a) -- ^ @lab: stmt@, spec 12.12
  | ForInStmt a (ForInInit a) (Expression a) (Statement a) 
    -- ^ @for (x in o) stmt@, spec 12.6
  | ForStmt a (ForInit a)        
              (Maybe (Expression a)) -- test
              (Maybe (Expression a)) -- increment
              (Statement a)          -- body 
    -- ^ @ForStmt a init test increment body@, @for (init; test,
    -- increment) body@, spec 12.6
  | TryStmt a (Statement a) {-body-} (Maybe (CatchClause a))
      (Maybe (Statement a)) {-finally-}
    -- ^ @try stmt catch(x) stmt finally stmt@, spec 12.14
  | ThrowStmt a (Expression a)
    -- ^ @throw expr;@, spec 12.13
  | ReturnStmt a (Maybe (Expression a))
    -- ^ @return expr;@, spec 12.9
  | WithStmt a (Expression a) (Statement a)
    -- ^ @with (o) stmt@, spec 12.10
  | VarDeclStmt a [VarDecl a]
    -- ^ @var x, y=42;@, spec 12.2
  | FunctionStmt a (Id a) {-name-} [Id a] {-args-} [Statement a] {-body-}
    -- ^ @function f(x, y, z) {...}@, spec 13
  deriving (Int -> Statement a -> ShowS
[Statement a] -> ShowS
Statement a -> String
(Int -> Statement a -> ShowS)
-> (Statement a -> String)
-> ([Statement a] -> ShowS)
-> Show (Statement a)
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
$cshowsPrec :: forall a. Show a => Int -> Statement a -> ShowS
showsPrec :: Int -> Statement a -> ShowS
$cshow :: forall a. Show a => Statement a -> String
show :: Statement a -> String
$cshowList :: forall a. Show a => [Statement a] -> ShowS
showList :: [Statement a] -> ShowS
Show,Typeable (Statement a)
Typeable (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 (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Statement a))
-> (Statement a -> Constr)
-> (Statement a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Statement a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Statement a)))
-> ((forall b. Data b => b -> b) -> Statement a -> Statement a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Statement a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Statement a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Statement a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Statement a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Statement a -> m (Statement a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Statement a -> m (Statement a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Statement a -> m (Statement a))
-> Data (Statement a)
Statement a -> Constr
Statement a -> DataType
(forall b. Data b => b -> b) -> Statement a -> Statement a
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 u. Int -> (forall d. Data d => d -> u) -> Statement a -> u
forall u. (forall d. Data d => d -> u) -> Statement a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Statement a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Statement a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Statement a -> m (Statement a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Statement a -> m (Statement 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))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (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)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Statement a -> 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)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Statement a)
$ctoConstr :: forall a. Data a => Statement a -> Constr
toConstr :: Statement a -> Constr
$cdataTypeOf :: forall a. Data a => Statement a -> DataType
dataTypeOf :: Statement a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Statement a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> 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))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Statement a))
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> Statement a -> Statement a
gmapT :: (forall b. Data b => b -> b) -> Statement a -> Statement a
$cgmapQl :: 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
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Statement a -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Statement a -> r
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> Statement a -> [u]
gmapQ :: forall u. (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
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Statement a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad 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)
$cgmapMp :: 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)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Statement a -> m (Statement a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Statement a -> m (Statement a)
Data,Typeable,Statement a -> Statement a -> Bool
(Statement a -> Statement a -> Bool)
-> (Statement a -> Statement a -> Bool) -> Eq (Statement a)
forall a. Eq a => Statement a -> Statement a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$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
/= :: Statement a -> Statement a -> Bool
Eq,Eq (Statement a)
Eq (Statement a) =>
(Statement a -> Statement a -> Ordering)
-> (Statement a -> Statement a -> Bool)
-> (Statement a -> Statement a -> Bool)
-> (Statement a -> Statement a -> Bool)
-> (Statement a -> Statement a -> Bool)
-> (Statement a -> Statement a -> Statement a)
-> (Statement a -> Statement a -> Statement a)
-> Ord (Statement a)
Statement a -> Statement a -> Bool
Statement a -> Statement a -> Ordering
Statement a -> Statement a -> Statement a
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
$ccompare :: forall a. Ord a => Statement a -> Statement a -> Ordering
compare :: Statement a -> Statement a -> Ordering
$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
>= :: Statement a -> Statement a -> Bool
$cmax :: forall a. Ord a => Statement a -> Statement a -> Statement a
max :: Statement a -> Statement a -> Statement a
$cmin :: forall a. Ord a => Statement a -> Statement a -> Statement a
min :: Statement a -> Statement a -> Statement a
Ord,(forall a b. (a -> b) -> Statement a -> Statement b)
-> (forall a b. a -> Statement b -> Statement a)
-> Functor Statement
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
$cfmap :: forall a b. (a -> b) -> Statement a -> Statement b
fmap :: forall a b. (a -> b) -> Statement a -> Statement b
$c<$ :: forall a b. a -> Statement b -> Statement a
<$ :: forall a b. a -> Statement b -> Statement a
Functor,(forall m. Monoid m => Statement m -> m)
-> (forall m a. Monoid m => (a -> m) -> Statement a -> m)
-> (forall m a. Monoid m => (a -> m) -> Statement a -> m)
-> (forall a b. (a -> b -> b) -> b -> Statement a -> b)
-> (forall a b. (a -> b -> b) -> b -> Statement a -> b)
-> (forall b a. (b -> a -> b) -> b -> Statement a -> b)
-> (forall b a. (b -> a -> b) -> b -> Statement a -> b)
-> (forall a. (a -> a -> a) -> Statement a -> a)
-> (forall a. (a -> a -> a) -> Statement a -> a)
-> (forall a. Statement a -> [a])
-> (forall a. Statement a -> Bool)
-> (forall a. Statement a -> Int)
-> (forall a. Eq a => a -> Statement a -> Bool)
-> (forall a. Ord a => Statement a -> a)
-> (forall a. Ord a => Statement a -> a)
-> (forall a. Num a => Statement a -> a)
-> (forall a. Num a => Statement a -> a)
-> Foldable Statement
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
$cfold :: forall m. Monoid m => Statement m -> m
fold :: forall m. Monoid m => Statement m -> 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
foldMap' :: forall m a. Monoid m => (a -> m) -> Statement a -> m
$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
foldr' :: forall a b. (a -> b -> 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
foldl' :: forall b a. (b -> a -> b) -> b -> Statement a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> Statement a -> a
foldr1 :: forall a. (a -> a -> a) -> Statement a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Statement a -> a
foldl1 :: forall a. (a -> a -> a) -> Statement a -> a
$ctoList :: forall a. Statement a -> [a]
toList :: forall a. Statement a -> [a]
$cnull :: forall a. Statement a -> Bool
null :: forall a. Statement a -> Bool
$clength :: forall a. Statement a -> Int
length :: forall a. Statement a -> Int
$celem :: forall a. Eq a => a -> Statement a -> Bool
elem :: forall a. Eq a => a -> Statement a -> Bool
$cmaximum :: forall a. Ord a => Statement a -> a
maximum :: forall a. Ord a => Statement a -> a
$cminimum :: forall a. Ord a => Statement a -> a
minimum :: forall a. Ord a => Statement a -> a
$csum :: forall a. Num a => Statement a -> a
sum :: forall a. Num a => Statement a -> a
$cproduct :: forall a. Num a => Statement a -> a
product :: forall a. Num a => Statement a -> a
Foldable,Functor Statement
Foldable Statement
(Functor Statement, Foldable Statement) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> Statement a -> f (Statement b))
-> (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 (m :: * -> *) a.
    Monad m =>
    Statement (m a) -> m (Statement a))
-> Traversable 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)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Statement a -> f (Statement b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Statement a -> f (Statement b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Statement (f a) -> f (Statement a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Statement (f a) -> f (Statement a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Statement a -> m (Statement b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Statement a -> m (Statement b)
$csequence :: forall (m :: * -> *) a.
Monad m =>
Statement (m a) -> m (Statement a)
sequence :: forall (m :: * -> *) a.
Monad m =>
Statement (m a) -> m (Statement a)
Traversable)  

-- | Returns 'True' if the statement is an /IterationStatement/
-- according to spec 12.6.
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
  
-- | The ECMAScript standard defines certain syntactic restrictions on
-- programs (or, more precisely, statements) that aren't easily
-- enforced in the AST datatype. These restrictions have to do with
-- labeled statements and break/continue statement, as well as
-- identifier names. Thus, it is possible to manually generate AST's
-- that correspond to syntactically incorrect programs. Use this
-- predicate to check if an 'JavaScript' AST corresponds to a
-- syntactically correct ECMAScript program.
isValid :: forall a. (Data a, Typeable a) => JavaScript a -> Bool
-- =From ECMA-262-3=
-- A program is considered syntactically incorrect if either of the
-- following is true:
-- * The program contains a continue statement without the optional
-- Identifier, which is not nested, directly or indirectly (but not
-- crossing function boundaries), within an IterationStatement.
-- * The program contains a continue statement with the optional
-- Identifier, where Identifier does not appear in the label set of an
-- enclosing (but not crossing function boundaries) IterationStatement.
-- * The program contains a break statement without the optional
-- Identifier, which is not nested, directly or indirectly (but not
-- crossing function boundaries), within an IterationStatement or a
-- SwitchStatement.
-- * The program contains a break statement with the optional
-- Identifier, where Identifier does not appear in the label set of an
-- enclosing (but not crossing function boundaries) Statement.
-- * The program contains a LabelledStatement that is enclosed by a
-- LabelledStatement with the same Identifier as label. This does not
-- apply to labels appearing within the body of a FunctionDeclaration
-- that is nested, directly or indirectly, within a labelled
-- statement.
-- * The identifiers should be valid. See spec 7.6
isValid :: forall a. (Data a, Typeable a) => JavaScript a -> Bool
isValid JavaScript a
js = (Data a, Typeable a) => JavaScript a -> Bool
JavaScript a -> Bool
checkIdentifiers JavaScript a
js Bool -> Bool -> Bool
&& JavaScript a -> 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 =
          [Bool] -> Bool
forall (t :: * -> *). Foldable t => t Bool -> Bool
and ([Bool] -> Bool) -> [Bool] -> Bool
forall a b. (a -> b) -> a -> b
$ (String -> Bool) -> [String] -> [Bool]
forall a b. (a -> b) -> [a] -> [b]
map String -> Bool
isValidIdentifierName ([String] -> [Bool]) -> [String] -> [Bool]
forall a b. (a -> b) -> a -> b
$
          [String
n | (Id a
_ String
n) :: Id a <- JavaScript a -> [Id a]
forall from to. Biplate from to => from -> [to]
universeBi JavaScript a
js] [String] -> [String] -> [String]
forall a. [a] -> [a] -> [a]
++
          [String
n | (LVar a
_ String
n) :: LValue a <- JavaScript a -> [LValue a]
forall from to. Biplate from to => from -> [to]
universeBi JavaScript a
js] [String] -> [String] -> [String]
forall a. [a] -> [a] -> [a]
++
          [String
n | (LDot a
_ Expression a
_ String
n) :: LValue a <- JavaScript a -> [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) = [Bool] -> Bool
forall (t :: * -> *). Foldable t => t Bool -> Bool
and ([Bool] -> Bool) -> [Bool] -> Bool
forall a b. (a -> b) -> a -> b
$ (Statement a -> Bool) -> [Statement a] -> [Bool]
forall a b. (a -> b) -> [a] -> [b]
map Statement a -> Bool
forall a. Statement a -> Bool
checkStmt ([Statement a] -> [Bool]) -> [Statement a] -> [Bool]
forall a b. (a -> b) -> a -> b
$
           [Statement a]
body [Statement a] -> [Statement a] -> [Statement a]
forall a. [a] -> [a] -> [a]
++ [[Statement a]] -> [Statement a]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([[Statement a]
body | FuncExpr a
_ Maybe (Id a)
_ [Id a]
_ [Statement a]
body <- JavaScript a -> [Expression a]
forall from to. Biplate from to => from -> [to]
universeBi JavaScript a
js] [[Statement a]] -> [[Statement a]] -> [[Statement a]]
forall a. [a] -> [a] -> [a]
++
                           [[Statement a]
body | FunctionStmt a
_ Id a
_ [Id a]
_ [Statement a]
body <- JavaScript a -> [Statement a]
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 = State ([String], [EnclosingStatement]) Bool
-> ([String], [EnclosingStatement]) -> Bool
forall s a. State s a -> s -> a
evalState (Statement a -> State ([String], [EnclosingStatement]) Bool
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 <- (([String], [EnclosingStatement]) -> [EnclosingStatement])
-> StateT
     ([String], [EnclosingStatement]) Identity [EnclosingStatement]
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets ([String], [EnclosingStatement]) -> [EnclosingStatement]
forall a b. (a, b) -> b
snd
    let enIts :: [EnclosingStatement]
enIts = (EnclosingStatement -> Bool)
-> [EnclosingStatement] -> [EnclosingStatement]
forall a. (a -> Bool) -> [a] -> [a]
filter EnclosingStatement -> Bool
isIter [EnclosingStatement]
encls
    Bool -> State ([String], [EnclosingStatement]) Bool
forall a. a -> StateT ([String], [EnclosingStatement]) Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool -> State ([String], [EnclosingStatement]) Bool)
-> Bool -> State ([String], [EnclosingStatement]) Bool
forall a b. (a -> b) -> a -> b
$ case Maybe (Id a)
mlab of
      Maybe (Id a)
Nothing  -> Bool -> Bool
not (Bool -> Bool) -> Bool -> Bool
forall a b. (a -> b) -> a -> b
$ [EnclosingStatement] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [EnclosingStatement]
enIts
      Just Id a
lab -> (EnclosingStatement -> Bool) -> [EnclosingStatement] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any (String -> [String] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
elem (Id a -> String
forall a. Id a -> String
unId Id a
lab) ([String] -> Bool)
-> (EnclosingStatement -> [String]) -> EnclosingStatement -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. EnclosingStatement -> [String]
forall a. HasLabelSet a => a -> [String]
getLabelSet) [EnclosingStatement]
enIts
  BreakStmt a
a Maybe (Id a)
mlab -> do
    [EnclosingStatement]
encls <- (([String], [EnclosingStatement]) -> [EnclosingStatement])
-> StateT
     ([String], [EnclosingStatement]) Identity [EnclosingStatement]
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets ([String], [EnclosingStatement]) -> [EnclosingStatement]
forall a b. (a, b) -> b
snd
    Bool -> State ([String], [EnclosingStatement]) Bool
forall a. a -> StateT ([String], [EnclosingStatement]) Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool -> State ([String], [EnclosingStatement]) Bool)
-> Bool -> State ([String], [EnclosingStatement]) Bool
forall a b. (a -> b) -> a -> b
$ case Maybe (Id a)
mlab of
      Maybe (Id a)
Nothing  -> (EnclosingStatement -> Bool) -> [EnclosingStatement] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any EnclosingStatement -> Bool
isIterSwitch [EnclosingStatement]
encls
      Just Id a
lab -> (EnclosingStatement -> Bool) -> [EnclosingStatement] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any (String -> [String] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
elem (Id a -> String
forall a. Id a -> String
unId Id a
lab) ([String] -> Bool)
-> (EnclosingStatement -> [String]) -> EnclosingStatement -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. EnclosingStatement -> [String]
forall a. HasLabelSet a => a -> [String]
getLabelSet) [EnclosingStatement]
encls
  LabelledStmt a
_ Id a
lab Statement a
s -> do
    [String]
labs <- (([String], [EnclosingStatement]) -> [String])
-> StateT ([String], [EnclosingStatement]) Identity [String]
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets ([String], [EnclosingStatement]) -> [String]
forall a b. (a, b) -> a
fst
    if (Id a -> String
forall a. Id a -> String
unId Id a
lab) String -> [String] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [String]
labs then Bool -> State ([String], [EnclosingStatement]) Bool
forall a. a -> StateT ([String], [EnclosingStatement]) Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
False
      else Id a
-> State ([String], [EnclosingStatement]) Bool
-> State ([String], [EnclosingStatement]) Bool
forall (m :: * -> *) b a.
Monad m =>
Id b
-> StateT ([String], [EnclosingStatement]) m a
-> StateT ([String], [EnclosingStatement]) m a
pushLabel Id a
lab (State ([String], [EnclosingStatement]) Bool
 -> State ([String], [EnclosingStatement]) Bool)
-> State ([String], [EnclosingStatement]) Bool
-> State ([String], [EnclosingStatement]) Bool
forall a b. (a -> b) -> a -> b
$ Statement a -> State ([String], [EnclosingStatement]) Bool
forall a.
Statement a -> State ([String], [EnclosingStatement]) Bool
checkStmtM Statement a
s
  WhileStmt a
_ Expression a
_ Statement a
s   -> Statement a -> State ([String], [EnclosingStatement]) Bool
forall a.
Statement a -> State ([String], [EnclosingStatement]) Bool
iterCommon Statement a
s
  DoWhileStmt a
_ Statement a
s Expression a
_ -> Statement a -> State ([String], [EnclosingStatement]) Bool
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 -> Statement a -> State ([String], [EnclosingStatement]) Bool
forall a.
Statement a -> State ([String], [EnclosingStatement]) Bool
iterCommon Statement a
s
  ForInStmt a
_ ForInInit a
_ Expression a
_ Statement a
s -> Statement a -> State ([String], [EnclosingStatement]) Bool
forall a.
Statement a -> State ([String], [EnclosingStatement]) Bool
iterCommon Statement a
s
  SwitchStmt a
_ Expression a
_ [CaseClause a]
cs -> ([String] -> EnclosingStatement)
-> State ([String], [EnclosingStatement]) Bool
-> State ([String], [EnclosingStatement]) Bool
forall (m :: * -> *) a.
Monad m =>
([String] -> EnclosingStatement)
-> StateT ([String], [EnclosingStatement]) m a
-> StateT ([String], [EnclosingStatement]) m a
pushEnclosing [String] -> EnclosingStatement
EnclosingSwitch (State ([String], [EnclosingStatement]) Bool
 -> State ([String], [EnclosingStatement]) Bool)
-> State ([String], [EnclosingStatement]) Bool
-> State ([String], [EnclosingStatement]) Bool
forall a b. (a -> b) -> a -> b
$ ([Bool] -> Bool)
-> StateT ([String], [EnclosingStatement]) Identity [Bool]
-> State ([String], [EnclosingStatement]) Bool
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM [Bool] -> Bool
forall (t :: * -> *). Foldable t => t Bool -> Bool
and (StateT ([String], [EnclosingStatement]) Identity [Bool]
 -> State ([String], [EnclosingStatement]) Bool)
-> StateT ([String], [EnclosingStatement]) Identity [Bool]
-> State ([String], [EnclosingStatement]) Bool
forall a b. (a -> b) -> a -> b
$ (CaseClause a -> State ([String], [EnclosingStatement]) Bool)
-> [CaseClause a]
-> StateT ([String], [EnclosingStatement]) Identity [Bool]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM CaseClause a -> State ([String], [EnclosingStatement]) Bool
forall {a}.
CaseClause a -> State ([String], [EnclosingStatement]) Bool
checkCaseM [CaseClause a]
cs
  BlockStmt a
_ [Statement a]
ss -> ([String] -> EnclosingStatement)
-> State ([String], [EnclosingStatement]) Bool
-> State ([String], [EnclosingStatement]) Bool
forall (m :: * -> *) a.
Monad m =>
([String] -> EnclosingStatement)
-> StateT ([String], [EnclosingStatement]) m a
-> StateT ([String], [EnclosingStatement]) m a
pushEnclosing [String] -> EnclosingStatement
EnclosingOther (State ([String], [EnclosingStatement]) Bool
 -> State ([String], [EnclosingStatement]) Bool)
-> State ([String], [EnclosingStatement]) Bool
-> State ([String], [EnclosingStatement]) Bool
forall a b. (a -> b) -> a -> b
$ ([Bool] -> Bool)
-> StateT ([String], [EnclosingStatement]) Identity [Bool]
-> State ([String], [EnclosingStatement]) Bool
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM [Bool] -> Bool
forall (t :: * -> *). Foldable t => t Bool -> Bool
and (StateT ([String], [EnclosingStatement]) Identity [Bool]
 -> State ([String], [EnclosingStatement]) Bool)
-> StateT ([String], [EnclosingStatement]) Identity [Bool]
-> State ([String], [EnclosingStatement]) Bool
forall a b. (a -> b) -> a -> b
$ (Statement a -> State ([String], [EnclosingStatement]) Bool)
-> [Statement a]
-> StateT ([String], [EnclosingStatement]) Identity [Bool]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM Statement a -> State ([String], [EnclosingStatement]) Bool
forall a.
Statement a -> State ([String], [EnclosingStatement]) Bool
checkStmtM [Statement a]
ss
  IfStmt a
_ Expression a
_ Statement a
t Statement a
e -> (Bool -> Bool -> Bool)
-> State ([String], [EnclosingStatement]) Bool
-> State ([String], [EnclosingStatement]) Bool
-> State ([String], [EnclosingStatement]) Bool
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 Bool -> Bool -> Bool
(&&) (Statement a -> State ([String], [EnclosingStatement]) Bool
forall a.
Statement a -> State ([String], [EnclosingStatement]) Bool
checkStmtM Statement a
t) (Statement a -> State ([String], [EnclosingStatement]) Bool
forall a.
Statement a -> State ([String], [EnclosingStatement]) Bool
checkStmtM Statement a
e)
  IfSingleStmt a
_ Expression a
_ Statement a
t -> Statement a -> State ([String], [EnclosingStatement]) Bool
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 -> (Bool -> Bool -> Bool)
-> State ([String], [EnclosingStatement]) Bool
-> State ([String], [EnclosingStatement]) Bool
-> State ([String], [EnclosingStatement]) Bool
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 Bool -> Bool -> Bool
(&&) (Statement a -> State ([String], [EnclosingStatement]) Bool
forall a.
Statement a -> State ([String], [EnclosingStatement]) Bool
checkStmtM Statement a
body) (State ([String], [EnclosingStatement]) Bool
 -> State ([String], [EnclosingStatement]) Bool)
-> State ([String], [EnclosingStatement]) Bool
-> State ([String], [EnclosingStatement]) Bool
forall a b. (a -> b) -> a -> b
$
    (Bool -> Bool -> Bool)
-> State ([String], [EnclosingStatement]) Bool
-> State ([String], [EnclosingStatement]) Bool
-> State ([String], [EnclosingStatement]) Bool
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 Bool -> Bool -> Bool
(&&) (State ([String], [EnclosingStatement]) Bool
-> (CatchClause a -> State ([String], [EnclosingStatement]) Bool)
-> Maybe (CatchClause a)
-> State ([String], [EnclosingStatement]) Bool
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (Bool -> State ([String], [EnclosingStatement]) Bool
forall a. a -> StateT ([String], [EnclosingStatement]) Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True) CatchClause a -> State ([String], [EnclosingStatement]) Bool
forall {a}.
CatchClause a -> State ([String], [EnclosingStatement]) Bool
checkCatchM Maybe (CatchClause a)
mcatch)
                (State ([String], [EnclosingStatement]) Bool
-> (Statement a -> State ([String], [EnclosingStatement]) Bool)
-> Maybe (Statement a)
-> State ([String], [EnclosingStatement]) Bool
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (Bool -> State ([String], [EnclosingStatement]) Bool
forall a. a -> StateT ([String], [EnclosingStatement]) Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True) Statement a -> State ([String], [EnclosingStatement]) Bool
forall a.
Statement a -> State ([String], [EnclosingStatement]) Bool
checkStmtM Maybe (Statement a)
mfinally)
  WithStmt a
_ Expression a
_ Statement a
body -> Statement a -> State ([String], [EnclosingStatement]) Bool
forall a.
Statement a -> State ([String], [EnclosingStatement]) Bool
checkStmtM Statement a
body
  Statement a
_ -> Bool -> State ([String], [EnclosingStatement]) Bool
forall a. a -> StateT ([String], [EnclosingStatement]) Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True

iterCommon :: Statement a -> State ([String], [EnclosingStatement]) Bool
iterCommon Statement a
s = ([String] -> EnclosingStatement)
-> State ([String], [EnclosingStatement]) Bool
-> State ([String], [EnclosingStatement]) Bool
forall (m :: * -> *) a.
Monad m =>
([String] -> EnclosingStatement)
-> StateT ([String], [EnclosingStatement]) m a
-> StateT ([String], [EnclosingStatement]) m a
pushEnclosing [String] -> EnclosingStatement
EnclosingIter (State ([String], [EnclosingStatement]) Bool
 -> State ([String], [EnclosingStatement]) Bool)
-> State ([String], [EnclosingStatement]) Bool
-> State ([String], [EnclosingStatement]) Bool
forall a b. (a -> b) -> a -> b
$ Statement a -> State ([String], [EnclosingStatement]) Bool
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 = (([String], [EnclosingStatement])
 -> ([String], [EnclosingStatement]))
-> StateT ([String], [EnclosingStatement]) m a
-> StateT ([String], [EnclosingStatement]) m a
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]
labsEnclosingStatement -> [EnclosingStatement] -> [EnclosingStatement]
forall 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 = (([String], [EnclosingStatement])
 -> ([String], [EnclosingStatement]))
-> StateT ([String], [EnclosingStatement]) m a
-> StateT ([String], [EnclosingStatement]) m a
forall (m :: * -> *) s a.
Monad m =>
(s -> s) -> StateT s m a -> StateT s m a
bracketState (([String] -> [String])
-> ([String], [EnclosingStatement])
-> ([String], [EnclosingStatement])
forall b c d. (b -> c) -> (b, d) -> (c, d)
forall (a :: * -> * -> *) b c d.
Arrow a =>
a b c -> a (b, d) (c, d)
first (Id b -> String
forall a. Id a -> String
unId Id b
lString -> [String] -> [String]
forall 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 ([Bool] -> Bool)
-> StateT ([String], [EnclosingStatement]) Identity [Bool]
-> State ([String], [EnclosingStatement]) Bool
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM [Bool] -> Bool
forall (t :: * -> *). Foldable t => t Bool -> Bool
and (StateT ([String], [EnclosingStatement]) Identity [Bool]
 -> State ([String], [EnclosingStatement]) Bool)
-> StateT ([String], [EnclosingStatement]) Identity [Bool]
-> State ([String], [EnclosingStatement]) Bool
forall a b. (a -> b) -> a -> b
$ (Statement a -> State ([String], [EnclosingStatement]) Bool)
-> [Statement a]
-> StateT ([String], [EnclosingStatement]) Identity [Bool]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM Statement a -> State ([String], [EnclosingStatement]) Bool
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) = Statement a -> State ([String], [EnclosingStatement]) Bool
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 <- StateT s m s
forall s (m :: * -> *). MonadState s m => m s
get
                      (s -> s) -> StateT s m ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify s -> s
f
                      a
rv <- StateT s m a
m
                      s -> StateT s m ()
forall s (m :: * -> *). MonadState s m => s -> m ()
put s
original
                      a -> StateT s m a
forall a. a -> StateT s m a
forall (m :: * -> *) a. Monad m => a -> m a
return a
rv

-- | Checks if an identifier name is valid according to the spec
isValidIdentifier :: Id a -> Bool
isValidIdentifier :: forall a. Id a -> Bool
isValidIdentifier (Id a
_ String
name) = String -> Bool
isValidIdentifierName String
name

-- | Checks if the 'String' represents a valid identifier 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
&& [Bool] -> Bool
forall (t :: * -> *). Foldable t => t Bool -> Bool
and ((Char -> Bool) -> String -> [Bool]
forall a b. (a -> b) -> [a] -> [b]
map Char -> Bool
isValidIdPart String
cs) Bool -> Bool -> Bool
&& (Bool -> Bool
not (Bool -> Bool) -> Bool -> Bool
forall a b. (a -> b) -> a -> b
$ String -> Bool
isReservedWord String
name)

-- | Checks if a string is in the list of reserved ECMAScript words
isReservedWord :: String -> Bool
isReservedWord :: String -> Bool
isReservedWord = (String -> [String] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [String]
reservedWords)
  where reservedWords :: [String]
reservedWords = [String]
keyword [String] -> [String] -> [String]
forall a. [a] -> [a] -> [a]
++ [String]
futureReservedWord [String] -> [String] -> [String]
forall a. [a] -> [a] -> [a]
++ [String]
nullKw [String] -> [String] -> [String]
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"]

-- | Checks if a character is valid at the start of an identifier
isValidIdStart :: Char -> Bool
isValidIdStart :: Char -> Bool
isValidIdStart Char
c = Char -> Bool
unicodeLetter Char
c Bool -> Bool -> Bool
|| Char
c Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'$' Bool -> Bool -> Bool
|| Char
c Char -> Char -> Bool
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

-- | Checks if a character is valid in an identifier part
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]
                          -- ^ The enclosing statement is an iteration statement
                        | EnclosingSwitch [Label]
                          -- ^ The enclosing statement is a switch statement
                        | EnclosingOther [Label]
                          -- ^ The enclosing statement is some other
                          -- statement.  Note, `EnclosingOther` is
                          -- never pushed if the current `labelSet` is
                          -- empty, so the list of labels in this
                          -- constructor should always be non-empty

instance Show EnclosingStatement where
  show :: EnclosingStatement -> String
show (EnclosingIter [String]
ls) = String
"iteration" String -> ShowS
forall a. [a] -> [a] -> [a]
++ [String] -> String
forall a. Show a => a -> String
show [String]
ls
  show (EnclosingSwitch [String]
ls) = String
"switch" String -> ShowS
forall a. [a] -> [a] -> [a]
++ [String] -> String
forall a. Show a => a -> String
show [String]
ls
  show (EnclosingOther [String]
ls) = String
"statement" String -> ShowS
forall a. [a] -> [a] -> [a]
++ [String] -> String
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 = [String] -> a -> a
forall a. HasLabelSet a => [String] -> a -> a
setLabelSet ([String] -> [String]
f ([String] -> [String]) -> [String] -> [String]
forall a b. (a -> b) -> a -> b
$ a -> [String]
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