{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveFoldable #-}
{-# LANGUAGE FlexibleInstances #-}
{-# OPTIONS_HADDOCK show-extensions #-}
module Yi.Syntax.JavaScript where
import Prelude hiding (elem,error,any,exp)
import qualified Prelude
import Control.Applicative (Alternative ((<|>), many), optional)
import Data.Data (Data)
import Data.Foldable (any, elem, toList)
import Data.Monoid (Endo (..), (<>))
import qualified Data.Text as T (cons)
import Data.Typeable (Typeable)
import Yi.Buffer.Basic (Point (..))
import Yi.Debug (trace)
import Yi.IncrementalParse (P, eof, recoverWith, symbol)
import Yi.Lexer.Alex (Stroke, Tok (..), tokFromT, tokToSpan)
import Yi.Lexer.JavaScript
import Yi.String (showT)
import Yi.Style (StyleName, errorStyle)
import Yi.Syntax.Tree (IsTree (..), sepBy, sepBy1)
class Strokable a where
toStrokes :: a -> Endo [Stroke]
class Failable f where
stupid :: t -> f t
hasFailed :: f t -> Bool
type BList a = [a]
type Tree t = BList (Statement t)
type Semicolon t = Maybe t
data Statement t = FunDecl t t (Parameters t) (Block t)
| VarDecl t (BList (VarDecAss t)) (Semicolon t)
| Return t (Maybe (Expr t)) (Semicolon t)
| While t (ParExpr t) (Block t)
| DoWhile t (Block t) t (ParExpr t) (Semicolon t)
| For t t (Expr t) (ForContent t) t (Block t)
| If t (ParExpr t) (Block t) (Maybe (Statement t))
| Else t (Block t)
| With t (ParExpr t) (Block t)
| Comm t
| Expr (Expr t) (Semicolon t)
deriving (Int -> Statement t -> ShowS
[Statement t] -> ShowS
Statement t -> String
(Int -> Statement t -> ShowS)
-> (Statement t -> String)
-> ([Statement t] -> ShowS)
-> Show (Statement t)
forall t. Show t => Int -> Statement t -> ShowS
forall t. Show t => [Statement t] -> ShowS
forall t. Show t => Statement t -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Statement t] -> ShowS
$cshowList :: forall t. Show t => [Statement t] -> ShowS
show :: Statement t -> String
$cshow :: forall t. Show t => Statement t -> String
showsPrec :: Int -> Statement t -> ShowS
$cshowsPrec :: forall t. Show t => Int -> Statement t -> ShowS
Show, Typeable (Statement t)
DataType
Constr
Typeable (Statement t)
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Statement t -> c (Statement t))
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Statement t))
-> (Statement t -> Constr)
-> (Statement t -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Statement t)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Statement t)))
-> ((forall b. Data b => b -> b) -> Statement t -> Statement t)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Statement t -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Statement t -> r)
-> (forall u. (forall d. Data d => d -> u) -> Statement t -> [u])
-> (forall u.
Int -> (forall d. Data d => d -> u) -> Statement t -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Statement t -> m (Statement t))
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Statement t -> m (Statement t))
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Statement t -> m (Statement t))
-> Data (Statement t)
Statement t -> DataType
Statement t -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (Statement t))
(forall b. Data b => b -> b) -> Statement t -> Statement t
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Statement t -> c (Statement t)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Statement t)
forall t. Data t => Typeable (Statement t)
forall t. Data t => Statement t -> DataType
forall t. Data t => Statement t -> Constr
forall t.
Data t =>
(forall b. Data b => b -> b) -> Statement t -> Statement t
forall t u.
Data t =>
Int -> (forall d. Data d => d -> u) -> Statement t -> u
forall t u.
Data t =>
(forall d. Data d => d -> u) -> Statement t -> [u]
forall t r r'.
Data t =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Statement t -> r
forall t r r'.
Data t =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Statement t -> r
forall t (m :: * -> *).
(Data t, Monad m) =>
(forall d. Data d => d -> m d) -> Statement t -> m (Statement t)
forall t (m :: * -> *).
(Data t, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Statement t -> m (Statement t)
forall t (c :: * -> *).
Data t =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Statement t)
forall t (c :: * -> *).
Data t =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Statement t -> c (Statement t)
forall t (t :: * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Statement t))
forall t (t :: * -> * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Statement t))
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 t -> u
forall u. (forall d. Data d => d -> u) -> Statement t -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Statement t -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Statement t -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Statement t -> m (Statement t)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Statement t -> m (Statement t)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Statement t)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Statement t -> c (Statement t)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Statement t))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Statement t))
$cExpr :: Constr
$cComm :: Constr
$cWith :: Constr
$cElse :: Constr
$cIf :: Constr
$cFor :: Constr
$cDoWhile :: Constr
$cWhile :: Constr
$cReturn :: Constr
$cVarDecl :: Constr
$cFunDecl :: Constr
$tStatement :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Statement t -> m (Statement t)
$cgmapMo :: forall t (m :: * -> *).
(Data t, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Statement t -> m (Statement t)
gmapMp :: (forall d. Data d => d -> m d) -> Statement t -> m (Statement t)
$cgmapMp :: forall t (m :: * -> *).
(Data t, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Statement t -> m (Statement t)
gmapM :: (forall d. Data d => d -> m d) -> Statement t -> m (Statement t)
$cgmapM :: forall t (m :: * -> *).
(Data t, Monad m) =>
(forall d. Data d => d -> m d) -> Statement t -> m (Statement t)
gmapQi :: Int -> (forall d. Data d => d -> u) -> Statement t -> u
$cgmapQi :: forall t u.
Data t =>
Int -> (forall d. Data d => d -> u) -> Statement t -> u
gmapQ :: (forall d. Data d => d -> u) -> Statement t -> [u]
$cgmapQ :: forall t u.
Data t =>
(forall d. Data d => d -> u) -> Statement t -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Statement t -> r
$cgmapQr :: forall t r r'.
Data t =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Statement t -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Statement t -> r
$cgmapQl :: forall t r r'.
Data t =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Statement t -> r
gmapT :: (forall b. Data b => b -> b) -> Statement t -> Statement t
$cgmapT :: forall t.
Data t =>
(forall b. Data b => b -> b) -> Statement t -> Statement t
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Statement t))
$cdataCast2 :: forall t (t :: * -> * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Statement t))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (Statement t))
$cdataCast1 :: forall t (t :: * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Statement t))
dataTypeOf :: Statement t -> DataType
$cdataTypeOf :: forall t. Data t => Statement t -> DataType
toConstr :: Statement t -> Constr
$ctoConstr :: forall t. Data t => Statement t -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Statement t)
$cgunfold :: forall t (c :: * -> *).
Data t =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Statement t)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Statement t -> c (Statement t)
$cgfoldl :: forall t (c :: * -> *).
Data t =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Statement t -> c (Statement t)
$cp1Data :: forall t. Data t => Typeable (Statement t)
Data, Typeable, Statement a -> Bool
(a -> m) -> Statement a -> m
(a -> b -> b) -> b -> Statement a -> b
(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
product :: Statement a -> a
$cproduct :: forall a. Num a => Statement a -> a
sum :: Statement a -> a
$csum :: forall a. Num a => Statement a -> a
minimum :: Statement a -> a
$cminimum :: forall a. Ord a => Statement a -> a
maximum :: Statement a -> a
$cmaximum :: forall a. Ord a => Statement a -> a
elem :: a -> Statement a -> Bool
$celem :: forall a. Eq a => a -> Statement a -> Bool
length :: Statement a -> Int
$clength :: forall a. Statement a -> Int
null :: Statement a -> Bool
$cnull :: forall a. Statement a -> Bool
toList :: Statement a -> [a]
$ctoList :: forall a. Statement a -> [a]
foldl1 :: (a -> a -> a) -> Statement a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Statement a -> a
foldr1 :: (a -> a -> a) -> Statement a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Statement a -> a
foldl' :: (b -> a -> b) -> b -> Statement a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Statement a -> b
foldl :: (b -> a -> b) -> b -> Statement a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Statement a -> b
foldr' :: (a -> b -> b) -> b -> Statement a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Statement a -> b
foldr :: (a -> b -> b) -> b -> Statement a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> Statement a -> b
foldMap' :: (a -> m) -> Statement a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Statement a -> m
foldMap :: (a -> m) -> Statement a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Statement a -> m
fold :: Statement m -> m
$cfold :: forall m. Monoid m => Statement m -> m
Foldable)
data Parameters t = Parameters t (BList t) t
| ParErr t
deriving (Int -> Parameters t -> ShowS
[Parameters t] -> ShowS
Parameters t -> String
(Int -> Parameters t -> ShowS)
-> (Parameters t -> String)
-> ([Parameters t] -> ShowS)
-> Show (Parameters t)
forall t. Show t => Int -> Parameters t -> ShowS
forall t. Show t => [Parameters t] -> ShowS
forall t. Show t => Parameters t -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Parameters t] -> ShowS
$cshowList :: forall t. Show t => [Parameters t] -> ShowS
show :: Parameters t -> String
$cshow :: forall t. Show t => Parameters t -> String
showsPrec :: Int -> Parameters t -> ShowS
$cshowsPrec :: forall t. Show t => Int -> Parameters t -> ShowS
Show, Typeable (Parameters t)
DataType
Constr
Typeable (Parameters t)
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Parameters t -> c (Parameters t))
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Parameters t))
-> (Parameters t -> Constr)
-> (Parameters t -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Parameters t)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Parameters t)))
-> ((forall b. Data b => b -> b) -> Parameters t -> Parameters t)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Parameters t -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Parameters t -> r)
-> (forall u. (forall d. Data d => d -> u) -> Parameters t -> [u])
-> (forall u.
Int -> (forall d. Data d => d -> u) -> Parameters t -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Parameters t -> m (Parameters t))
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Parameters t -> m (Parameters t))
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Parameters t -> m (Parameters t))
-> Data (Parameters t)
Parameters t -> DataType
Parameters t -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (Parameters t))
(forall b. Data b => b -> b) -> Parameters t -> Parameters t
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Parameters t -> c (Parameters t)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Parameters t)
forall t. Data t => Typeable (Parameters t)
forall t. Data t => Parameters t -> DataType
forall t. Data t => Parameters t -> Constr
forall t.
Data t =>
(forall b. Data b => b -> b) -> Parameters t -> Parameters t
forall t u.
Data t =>
Int -> (forall d. Data d => d -> u) -> Parameters t -> u
forall t u.
Data t =>
(forall d. Data d => d -> u) -> Parameters t -> [u]
forall t r r'.
Data t =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Parameters t -> r
forall t r r'.
Data t =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Parameters t -> r
forall t (m :: * -> *).
(Data t, Monad m) =>
(forall d. Data d => d -> m d) -> Parameters t -> m (Parameters t)
forall t (m :: * -> *).
(Data t, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Parameters t -> m (Parameters t)
forall t (c :: * -> *).
Data t =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Parameters t)
forall t (c :: * -> *).
Data t =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Parameters t -> c (Parameters t)
forall t (t :: * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Parameters t))
forall t (t :: * -> * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Parameters t))
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) -> Parameters t -> u
forall u. (forall d. Data d => d -> u) -> Parameters t -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Parameters t -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Parameters t -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Parameters t -> m (Parameters t)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Parameters t -> m (Parameters t)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Parameters t)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Parameters t -> c (Parameters t)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Parameters t))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Parameters t))
$cParErr :: Constr
$cParameters :: Constr
$tParameters :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Parameters t -> m (Parameters t)
$cgmapMo :: forall t (m :: * -> *).
(Data t, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Parameters t -> m (Parameters t)
gmapMp :: (forall d. Data d => d -> m d) -> Parameters t -> m (Parameters t)
$cgmapMp :: forall t (m :: * -> *).
(Data t, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Parameters t -> m (Parameters t)
gmapM :: (forall d. Data d => d -> m d) -> Parameters t -> m (Parameters t)
$cgmapM :: forall t (m :: * -> *).
(Data t, Monad m) =>
(forall d. Data d => d -> m d) -> Parameters t -> m (Parameters t)
gmapQi :: Int -> (forall d. Data d => d -> u) -> Parameters t -> u
$cgmapQi :: forall t u.
Data t =>
Int -> (forall d. Data d => d -> u) -> Parameters t -> u
gmapQ :: (forall d. Data d => d -> u) -> Parameters t -> [u]
$cgmapQ :: forall t u.
Data t =>
(forall d. Data d => d -> u) -> Parameters t -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Parameters t -> r
$cgmapQr :: forall t r r'.
Data t =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Parameters t -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Parameters t -> r
$cgmapQl :: forall t r r'.
Data t =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Parameters t -> r
gmapT :: (forall b. Data b => b -> b) -> Parameters t -> Parameters t
$cgmapT :: forall t.
Data t =>
(forall b. Data b => b -> b) -> Parameters t -> Parameters t
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Parameters t))
$cdataCast2 :: forall t (t :: * -> * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Parameters t))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (Parameters t))
$cdataCast1 :: forall t (t :: * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Parameters t))
dataTypeOf :: Parameters t -> DataType
$cdataTypeOf :: forall t. Data t => Parameters t -> DataType
toConstr :: Parameters t -> Constr
$ctoConstr :: forall t. Data t => Parameters t -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Parameters t)
$cgunfold :: forall t (c :: * -> *).
Data t =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Parameters t)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Parameters t -> c (Parameters t)
$cgfoldl :: forall t (c :: * -> *).
Data t =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Parameters t -> c (Parameters t)
$cp1Data :: forall t. Data t => Typeable (Parameters t)
Data, Typeable, Parameters a -> Bool
(a -> m) -> Parameters a -> m
(a -> b -> b) -> b -> Parameters a -> b
(forall m. Monoid m => Parameters m -> m)
-> (forall m a. Monoid m => (a -> m) -> Parameters a -> m)
-> (forall m a. Monoid m => (a -> m) -> Parameters a -> m)
-> (forall a b. (a -> b -> b) -> b -> Parameters a -> b)
-> (forall a b. (a -> b -> b) -> b -> Parameters a -> b)
-> (forall b a. (b -> a -> b) -> b -> Parameters a -> b)
-> (forall b a. (b -> a -> b) -> b -> Parameters a -> b)
-> (forall a. (a -> a -> a) -> Parameters a -> a)
-> (forall a. (a -> a -> a) -> Parameters a -> a)
-> (forall a. Parameters a -> [a])
-> (forall a. Parameters a -> Bool)
-> (forall a. Parameters a -> Int)
-> (forall a. Eq a => a -> Parameters a -> Bool)
-> (forall a. Ord a => Parameters a -> a)
-> (forall a. Ord a => Parameters a -> a)
-> (forall a. Num a => Parameters a -> a)
-> (forall a. Num a => Parameters a -> a)
-> Foldable Parameters
forall a. Eq a => a -> Parameters a -> Bool
forall a. Num a => Parameters a -> a
forall a. Ord a => Parameters a -> a
forall m. Monoid m => Parameters m -> m
forall a. Parameters a -> Bool
forall a. Parameters a -> Int
forall a. Parameters a -> [a]
forall a. (a -> a -> a) -> Parameters a -> a
forall m a. Monoid m => (a -> m) -> Parameters a -> m
forall b a. (b -> a -> b) -> b -> Parameters a -> b
forall a b. (a -> b -> b) -> b -> Parameters a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: Parameters a -> a
$cproduct :: forall a. Num a => Parameters a -> a
sum :: Parameters a -> a
$csum :: forall a. Num a => Parameters a -> a
minimum :: Parameters a -> a
$cminimum :: forall a. Ord a => Parameters a -> a
maximum :: Parameters a -> a
$cmaximum :: forall a. Ord a => Parameters a -> a
elem :: a -> Parameters a -> Bool
$celem :: forall a. Eq a => a -> Parameters a -> Bool
length :: Parameters a -> Int
$clength :: forall a. Parameters a -> Int
null :: Parameters a -> Bool
$cnull :: forall a. Parameters a -> Bool
toList :: Parameters a -> [a]
$ctoList :: forall a. Parameters a -> [a]
foldl1 :: (a -> a -> a) -> Parameters a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Parameters a -> a
foldr1 :: (a -> a -> a) -> Parameters a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Parameters a -> a
foldl' :: (b -> a -> b) -> b -> Parameters a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Parameters a -> b
foldl :: (b -> a -> b) -> b -> Parameters a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Parameters a -> b
foldr' :: (a -> b -> b) -> b -> Parameters a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Parameters a -> b
foldr :: (a -> b -> b) -> b -> Parameters a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> Parameters a -> b
foldMap' :: (a -> m) -> Parameters a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Parameters a -> m
foldMap :: (a -> m) -> Parameters a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Parameters a -> m
fold :: Parameters m -> m
$cfold :: forall m. Monoid m => Parameters m -> m
Foldable)
data ParExpr t = ParExpr t (BList (Expr t)) t
| ParExprErr t
deriving (Int -> ParExpr t -> ShowS
[ParExpr t] -> ShowS
ParExpr t -> String
(Int -> ParExpr t -> ShowS)
-> (ParExpr t -> String)
-> ([ParExpr t] -> ShowS)
-> Show (ParExpr t)
forall t. Show t => Int -> ParExpr t -> ShowS
forall t. Show t => [ParExpr t] -> ShowS
forall t. Show t => ParExpr t -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ParExpr t] -> ShowS
$cshowList :: forall t. Show t => [ParExpr t] -> ShowS
show :: ParExpr t -> String
$cshow :: forall t. Show t => ParExpr t -> String
showsPrec :: Int -> ParExpr t -> ShowS
$cshowsPrec :: forall t. Show t => Int -> ParExpr t -> ShowS
Show, Typeable (ParExpr t)
DataType
Constr
Typeable (ParExpr t)
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ParExpr t -> c (ParExpr t))
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ParExpr t))
-> (ParExpr t -> Constr)
-> (ParExpr t -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (ParExpr t)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ParExpr t)))
-> ((forall b. Data b => b -> b) -> ParExpr t -> ParExpr t)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ParExpr t -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ParExpr t -> r)
-> (forall u. (forall d. Data d => d -> u) -> ParExpr t -> [u])
-> (forall u.
Int -> (forall d. Data d => d -> u) -> ParExpr t -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ParExpr t -> m (ParExpr t))
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ParExpr t -> m (ParExpr t))
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ParExpr t -> m (ParExpr t))
-> Data (ParExpr t)
ParExpr t -> DataType
ParExpr t -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (ParExpr t))
(forall b. Data b => b -> b) -> ParExpr t -> ParExpr t
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ParExpr t -> c (ParExpr t)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ParExpr t)
forall t. Data t => Typeable (ParExpr t)
forall t. Data t => ParExpr t -> DataType
forall t. Data t => ParExpr t -> Constr
forall t.
Data t =>
(forall b. Data b => b -> b) -> ParExpr t -> ParExpr t
forall t u.
Data t =>
Int -> (forall d. Data d => d -> u) -> ParExpr t -> u
forall t u.
Data t =>
(forall d. Data d => d -> u) -> ParExpr t -> [u]
forall t r r'.
Data t =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ParExpr t -> r
forall t r r'.
Data t =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ParExpr t -> r
forall t (m :: * -> *).
(Data t, Monad m) =>
(forall d. Data d => d -> m d) -> ParExpr t -> m (ParExpr t)
forall t (m :: * -> *).
(Data t, MonadPlus m) =>
(forall d. Data d => d -> m d) -> ParExpr t -> m (ParExpr t)
forall t (c :: * -> *).
Data t =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ParExpr t)
forall t (c :: * -> *).
Data t =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ParExpr t -> c (ParExpr t)
forall t (t :: * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (ParExpr t))
forall t (t :: * -> * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ParExpr t))
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) -> ParExpr t -> u
forall u. (forall d. Data d => d -> u) -> ParExpr t -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ParExpr t -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ParExpr t -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ParExpr t -> m (ParExpr t)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ParExpr t -> m (ParExpr t)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ParExpr t)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ParExpr t -> c (ParExpr t)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (ParExpr t))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ParExpr t))
$cParExprErr :: Constr
$cParExpr :: Constr
$tParExpr :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> ParExpr t -> m (ParExpr t)
$cgmapMo :: forall t (m :: * -> *).
(Data t, MonadPlus m) =>
(forall d. Data d => d -> m d) -> ParExpr t -> m (ParExpr t)
gmapMp :: (forall d. Data d => d -> m d) -> ParExpr t -> m (ParExpr t)
$cgmapMp :: forall t (m :: * -> *).
(Data t, MonadPlus m) =>
(forall d. Data d => d -> m d) -> ParExpr t -> m (ParExpr t)
gmapM :: (forall d. Data d => d -> m d) -> ParExpr t -> m (ParExpr t)
$cgmapM :: forall t (m :: * -> *).
(Data t, Monad m) =>
(forall d. Data d => d -> m d) -> ParExpr t -> m (ParExpr t)
gmapQi :: Int -> (forall d. Data d => d -> u) -> ParExpr t -> u
$cgmapQi :: forall t u.
Data t =>
Int -> (forall d. Data d => d -> u) -> ParExpr t -> u
gmapQ :: (forall d. Data d => d -> u) -> ParExpr t -> [u]
$cgmapQ :: forall t u.
Data t =>
(forall d. Data d => d -> u) -> ParExpr t -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ParExpr t -> r
$cgmapQr :: forall t r r'.
Data t =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ParExpr t -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ParExpr t -> r
$cgmapQl :: forall t r r'.
Data t =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ParExpr t -> r
gmapT :: (forall b. Data b => b -> b) -> ParExpr t -> ParExpr t
$cgmapT :: forall t.
Data t =>
(forall b. Data b => b -> b) -> ParExpr t -> ParExpr t
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ParExpr t))
$cdataCast2 :: forall t (t :: * -> * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ParExpr t))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (ParExpr t))
$cdataCast1 :: forall t (t :: * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (ParExpr t))
dataTypeOf :: ParExpr t -> DataType
$cdataTypeOf :: forall t. Data t => ParExpr t -> DataType
toConstr :: ParExpr t -> Constr
$ctoConstr :: forall t. Data t => ParExpr t -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ParExpr t)
$cgunfold :: forall t (c :: * -> *).
Data t =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ParExpr t)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ParExpr t -> c (ParExpr t)
$cgfoldl :: forall t (c :: * -> *).
Data t =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ParExpr t -> c (ParExpr t)
$cp1Data :: forall t. Data t => Typeable (ParExpr t)
Data, Typeable, ParExpr a -> Bool
(a -> m) -> ParExpr a -> m
(a -> b -> b) -> b -> ParExpr a -> b
(forall m. Monoid m => ParExpr m -> m)
-> (forall m a. Monoid m => (a -> m) -> ParExpr a -> m)
-> (forall m a. Monoid m => (a -> m) -> ParExpr a -> m)
-> (forall a b. (a -> b -> b) -> b -> ParExpr a -> b)
-> (forall a b. (a -> b -> b) -> b -> ParExpr a -> b)
-> (forall b a. (b -> a -> b) -> b -> ParExpr a -> b)
-> (forall b a. (b -> a -> b) -> b -> ParExpr a -> b)
-> (forall a. (a -> a -> a) -> ParExpr a -> a)
-> (forall a. (a -> a -> a) -> ParExpr a -> a)
-> (forall a. ParExpr a -> [a])
-> (forall a. ParExpr a -> Bool)
-> (forall a. ParExpr a -> Int)
-> (forall a. Eq a => a -> ParExpr a -> Bool)
-> (forall a. Ord a => ParExpr a -> a)
-> (forall a. Ord a => ParExpr a -> a)
-> (forall a. Num a => ParExpr a -> a)
-> (forall a. Num a => ParExpr a -> a)
-> Foldable ParExpr
forall a. Eq a => a -> ParExpr a -> Bool
forall a. Num a => ParExpr a -> a
forall a. Ord a => ParExpr a -> a
forall m. Monoid m => ParExpr m -> m
forall a. ParExpr a -> Bool
forall a. ParExpr a -> Int
forall a. ParExpr a -> [a]
forall a. (a -> a -> a) -> ParExpr a -> a
forall m a. Monoid m => (a -> m) -> ParExpr a -> m
forall b a. (b -> a -> b) -> b -> ParExpr a -> b
forall a b. (a -> b -> b) -> b -> ParExpr a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: ParExpr a -> a
$cproduct :: forall a. Num a => ParExpr a -> a
sum :: ParExpr a -> a
$csum :: forall a. Num a => ParExpr a -> a
minimum :: ParExpr a -> a
$cminimum :: forall a. Ord a => ParExpr a -> a
maximum :: ParExpr a -> a
$cmaximum :: forall a. Ord a => ParExpr a -> a
elem :: a -> ParExpr a -> Bool
$celem :: forall a. Eq a => a -> ParExpr a -> Bool
length :: ParExpr a -> Int
$clength :: forall a. ParExpr a -> Int
null :: ParExpr a -> Bool
$cnull :: forall a. ParExpr a -> Bool
toList :: ParExpr a -> [a]
$ctoList :: forall a. ParExpr a -> [a]
foldl1 :: (a -> a -> a) -> ParExpr a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> ParExpr a -> a
foldr1 :: (a -> a -> a) -> ParExpr a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> ParExpr a -> a
foldl' :: (b -> a -> b) -> b -> ParExpr a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> ParExpr a -> b
foldl :: (b -> a -> b) -> b -> ParExpr a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> ParExpr a -> b
foldr' :: (a -> b -> b) -> b -> ParExpr a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> ParExpr a -> b
foldr :: (a -> b -> b) -> b -> ParExpr a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> ParExpr a -> b
foldMap' :: (a -> m) -> ParExpr a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> ParExpr a -> m
foldMap :: (a -> m) -> ParExpr a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> ParExpr a -> m
fold :: ParExpr m -> m
$cfold :: forall m. Monoid m => ParExpr m -> m
Foldable)
data ForContent t = ForNormal t (Expr t) t (Expr t)
| ForIn t (Expr t)
| ForErr t
deriving (Int -> ForContent t -> ShowS
[ForContent t] -> ShowS
ForContent t -> String
(Int -> ForContent t -> ShowS)
-> (ForContent t -> String)
-> ([ForContent t] -> ShowS)
-> Show (ForContent t)
forall t. Show t => Int -> ForContent t -> ShowS
forall t. Show t => [ForContent t] -> ShowS
forall t. Show t => ForContent t -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ForContent t] -> ShowS
$cshowList :: forall t. Show t => [ForContent t] -> ShowS
show :: ForContent t -> String
$cshow :: forall t. Show t => ForContent t -> String
showsPrec :: Int -> ForContent t -> ShowS
$cshowsPrec :: forall t. Show t => Int -> ForContent t -> ShowS
Show, Typeable (ForContent t)
DataType
Constr
Typeable (ForContent t)
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ForContent t -> c (ForContent t))
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ForContent t))
-> (ForContent t -> Constr)
-> (ForContent t -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (ForContent t)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ForContent t)))
-> ((forall b. Data b => b -> b) -> ForContent t -> ForContent t)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ForContent t -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ForContent t -> r)
-> (forall u. (forall d. Data d => d -> u) -> ForContent t -> [u])
-> (forall u.
Int -> (forall d. Data d => d -> u) -> ForContent t -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ForContent t -> m (ForContent t))
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ForContent t -> m (ForContent t))
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ForContent t -> m (ForContent t))
-> Data (ForContent t)
ForContent t -> DataType
ForContent t -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (ForContent t))
(forall b. Data b => b -> b) -> ForContent t -> ForContent t
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ForContent t -> c (ForContent t)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ForContent t)
forall t. Data t => Typeable (ForContent t)
forall t. Data t => ForContent t -> DataType
forall t. Data t => ForContent t -> Constr
forall t.
Data t =>
(forall b. Data b => b -> b) -> ForContent t -> ForContent t
forall t u.
Data t =>
Int -> (forall d. Data d => d -> u) -> ForContent t -> u
forall t u.
Data t =>
(forall d. Data d => d -> u) -> ForContent t -> [u]
forall t r r'.
Data t =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ForContent t -> r
forall t r r'.
Data t =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ForContent t -> r
forall t (m :: * -> *).
(Data t, Monad m) =>
(forall d. Data d => d -> m d) -> ForContent t -> m (ForContent t)
forall t (m :: * -> *).
(Data t, MonadPlus m) =>
(forall d. Data d => d -> m d) -> ForContent t -> m (ForContent t)
forall t (c :: * -> *).
Data t =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ForContent t)
forall t (c :: * -> *).
Data t =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ForContent t -> c (ForContent t)
forall t (t :: * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (ForContent t))
forall t (t :: * -> * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ForContent t))
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) -> ForContent t -> u
forall u. (forall d. Data d => d -> u) -> ForContent t -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ForContent t -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ForContent t -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ForContent t -> m (ForContent t)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ForContent t -> m (ForContent t)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ForContent t)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ForContent t -> c (ForContent t)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (ForContent t))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ForContent t))
$cForErr :: Constr
$cForIn :: Constr
$cForNormal :: Constr
$tForContent :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> ForContent t -> m (ForContent t)
$cgmapMo :: forall t (m :: * -> *).
(Data t, MonadPlus m) =>
(forall d. Data d => d -> m d) -> ForContent t -> m (ForContent t)
gmapMp :: (forall d. Data d => d -> m d) -> ForContent t -> m (ForContent t)
$cgmapMp :: forall t (m :: * -> *).
(Data t, MonadPlus m) =>
(forall d. Data d => d -> m d) -> ForContent t -> m (ForContent t)
gmapM :: (forall d. Data d => d -> m d) -> ForContent t -> m (ForContent t)
$cgmapM :: forall t (m :: * -> *).
(Data t, Monad m) =>
(forall d. Data d => d -> m d) -> ForContent t -> m (ForContent t)
gmapQi :: Int -> (forall d. Data d => d -> u) -> ForContent t -> u
$cgmapQi :: forall t u.
Data t =>
Int -> (forall d. Data d => d -> u) -> ForContent t -> u
gmapQ :: (forall d. Data d => d -> u) -> ForContent t -> [u]
$cgmapQ :: forall t u.
Data t =>
(forall d. Data d => d -> u) -> ForContent t -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ForContent t -> r
$cgmapQr :: forall t r r'.
Data t =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ForContent t -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ForContent t -> r
$cgmapQl :: forall t r r'.
Data t =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ForContent t -> r
gmapT :: (forall b. Data b => b -> b) -> ForContent t -> ForContent t
$cgmapT :: forall t.
Data t =>
(forall b. Data b => b -> b) -> ForContent t -> ForContent t
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ForContent t))
$cdataCast2 :: forall t (t :: * -> * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ForContent t))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (ForContent t))
$cdataCast1 :: forall t (t :: * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (ForContent t))
dataTypeOf :: ForContent t -> DataType
$cdataTypeOf :: forall t. Data t => ForContent t -> DataType
toConstr :: ForContent t -> Constr
$ctoConstr :: forall t. Data t => ForContent t -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ForContent t)
$cgunfold :: forall t (c :: * -> *).
Data t =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ForContent t)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ForContent t -> c (ForContent t)
$cgfoldl :: forall t (c :: * -> *).
Data t =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ForContent t -> c (ForContent t)
$cp1Data :: forall t. Data t => Typeable (ForContent t)
Data, Typeable, ForContent a -> Bool
(a -> m) -> ForContent a -> m
(a -> b -> b) -> b -> ForContent a -> b
(forall m. Monoid m => ForContent m -> m)
-> (forall m a. Monoid m => (a -> m) -> ForContent a -> m)
-> (forall m a. Monoid m => (a -> m) -> ForContent a -> m)
-> (forall a b. (a -> b -> b) -> b -> ForContent a -> b)
-> (forall a b. (a -> b -> b) -> b -> ForContent a -> b)
-> (forall b a. (b -> a -> b) -> b -> ForContent a -> b)
-> (forall b a. (b -> a -> b) -> b -> ForContent a -> b)
-> (forall a. (a -> a -> a) -> ForContent a -> a)
-> (forall a. (a -> a -> a) -> ForContent a -> a)
-> (forall a. ForContent a -> [a])
-> (forall a. ForContent a -> Bool)
-> (forall a. ForContent a -> Int)
-> (forall a. Eq a => a -> ForContent a -> Bool)
-> (forall a. Ord a => ForContent a -> a)
-> (forall a. Ord a => ForContent a -> a)
-> (forall a. Num a => ForContent a -> a)
-> (forall a. Num a => ForContent a -> a)
-> Foldable ForContent
forall a. Eq a => a -> ForContent a -> Bool
forall a. Num a => ForContent a -> a
forall a. Ord a => ForContent a -> a
forall m. Monoid m => ForContent m -> m
forall a. ForContent a -> Bool
forall a. ForContent a -> Int
forall a. ForContent a -> [a]
forall a. (a -> a -> a) -> ForContent a -> a
forall m a. Monoid m => (a -> m) -> ForContent a -> m
forall b a. (b -> a -> b) -> b -> ForContent a -> b
forall a b. (a -> b -> b) -> b -> ForContent a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: ForContent a -> a
$cproduct :: forall a. Num a => ForContent a -> a
sum :: ForContent a -> a
$csum :: forall a. Num a => ForContent a -> a
minimum :: ForContent a -> a
$cminimum :: forall a. Ord a => ForContent a -> a
maximum :: ForContent a -> a
$cmaximum :: forall a. Ord a => ForContent a -> a
elem :: a -> ForContent a -> Bool
$celem :: forall a. Eq a => a -> ForContent a -> Bool
length :: ForContent a -> Int
$clength :: forall a. ForContent a -> Int
null :: ForContent a -> Bool
$cnull :: forall a. ForContent a -> Bool
toList :: ForContent a -> [a]
$ctoList :: forall a. ForContent a -> [a]
foldl1 :: (a -> a -> a) -> ForContent a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> ForContent a -> a
foldr1 :: (a -> a -> a) -> ForContent a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> ForContent a -> a
foldl' :: (b -> a -> b) -> b -> ForContent a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> ForContent a -> b
foldl :: (b -> a -> b) -> b -> ForContent a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> ForContent a -> b
foldr' :: (a -> b -> b) -> b -> ForContent a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> ForContent a -> b
foldr :: (a -> b -> b) -> b -> ForContent a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> ForContent a -> b
foldMap' :: (a -> m) -> ForContent a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> ForContent a -> m
foldMap :: (a -> m) -> ForContent a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> ForContent a -> m
fold :: ForContent m -> m
$cfold :: forall m. Monoid m => ForContent m -> m
Foldable)
data Block t = Block t (BList (Statement t)) t
| BlockOne (Statement t)
| BlockErr t
deriving (Int -> Block t -> ShowS
[Block t] -> ShowS
Block t -> String
(Int -> Block t -> ShowS)
-> (Block t -> String) -> ([Block t] -> ShowS) -> Show (Block t)
forall t. Show t => Int -> Block t -> ShowS
forall t. Show t => [Block t] -> ShowS
forall t. Show t => Block t -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Block t] -> ShowS
$cshowList :: forall t. Show t => [Block t] -> ShowS
show :: Block t -> String
$cshow :: forall t. Show t => Block t -> String
showsPrec :: Int -> Block t -> ShowS
$cshowsPrec :: forall t. Show t => Int -> Block t -> ShowS
Show, Typeable (Block t)
DataType
Constr
Typeable (Block t)
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Block t -> c (Block t))
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Block t))
-> (Block t -> Constr)
-> (Block t -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Block t)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Block t)))
-> ((forall b. Data b => b -> b) -> Block t -> Block t)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Block t -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Block t -> r)
-> (forall u. (forall d. Data d => d -> u) -> Block t -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Block t -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Block t -> m (Block t))
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Block t -> m (Block t))
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Block t -> m (Block t))
-> Data (Block t)
Block t -> DataType
Block t -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (Block t))
(forall b. Data b => b -> b) -> Block t -> Block t
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Block t -> c (Block t)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Block t)
forall t. Data t => Typeable (Block t)
forall t. Data t => Block t -> DataType
forall t. Data t => Block t -> Constr
forall t.
Data t =>
(forall b. Data b => b -> b) -> Block t -> Block t
forall t u.
Data t =>
Int -> (forall d. Data d => d -> u) -> Block t -> u
forall t u.
Data t =>
(forall d. Data d => d -> u) -> Block t -> [u]
forall t r r'.
Data t =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Block t -> r
forall t r r'.
Data t =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Block t -> r
forall t (m :: * -> *).
(Data t, Monad m) =>
(forall d. Data d => d -> m d) -> Block t -> m (Block t)
forall t (m :: * -> *).
(Data t, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Block t -> m (Block t)
forall t (c :: * -> *).
Data t =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Block t)
forall t (c :: * -> *).
Data t =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Block t -> c (Block t)
forall t (t :: * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Block t))
forall t (t :: * -> * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Block t))
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) -> Block t -> u
forall u. (forall d. Data d => d -> u) -> Block t -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Block t -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Block t -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Block t -> m (Block t)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Block t -> m (Block t)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Block t)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Block t -> c (Block t)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Block t))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Block t))
$cBlockErr :: Constr
$cBlockOne :: Constr
$cBlock :: Constr
$tBlock :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Block t -> m (Block t)
$cgmapMo :: forall t (m :: * -> *).
(Data t, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Block t -> m (Block t)
gmapMp :: (forall d. Data d => d -> m d) -> Block t -> m (Block t)
$cgmapMp :: forall t (m :: * -> *).
(Data t, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Block t -> m (Block t)
gmapM :: (forall d. Data d => d -> m d) -> Block t -> m (Block t)
$cgmapM :: forall t (m :: * -> *).
(Data t, Monad m) =>
(forall d. Data d => d -> m d) -> Block t -> m (Block t)
gmapQi :: Int -> (forall d. Data d => d -> u) -> Block t -> u
$cgmapQi :: forall t u.
Data t =>
Int -> (forall d. Data d => d -> u) -> Block t -> u
gmapQ :: (forall d. Data d => d -> u) -> Block t -> [u]
$cgmapQ :: forall t u.
Data t =>
(forall d. Data d => d -> u) -> Block t -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Block t -> r
$cgmapQr :: forall t r r'.
Data t =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Block t -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Block t -> r
$cgmapQl :: forall t r r'.
Data t =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Block t -> r
gmapT :: (forall b. Data b => b -> b) -> Block t -> Block t
$cgmapT :: forall t.
Data t =>
(forall b. Data b => b -> b) -> Block t -> Block t
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Block t))
$cdataCast2 :: forall t (t :: * -> * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Block t))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (Block t))
$cdataCast1 :: forall t (t :: * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Block t))
dataTypeOf :: Block t -> DataType
$cdataTypeOf :: forall t. Data t => Block t -> DataType
toConstr :: Block t -> Constr
$ctoConstr :: forall t. Data t => Block t -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Block t)
$cgunfold :: forall t (c :: * -> *).
Data t =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Block t)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Block t -> c (Block t)
$cgfoldl :: forall t (c :: * -> *).
Data t =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Block t -> c (Block t)
$cp1Data :: forall t. Data t => Typeable (Block t)
Data, Typeable, Block a -> Bool
(a -> m) -> Block a -> m
(a -> b -> b) -> b -> Block a -> b
(forall m. Monoid m => Block m -> m)
-> (forall m a. Monoid m => (a -> m) -> Block a -> m)
-> (forall m a. Monoid m => (a -> m) -> Block a -> m)
-> (forall a b. (a -> b -> b) -> b -> Block a -> b)
-> (forall a b. (a -> b -> b) -> b -> Block a -> b)
-> (forall b a. (b -> a -> b) -> b -> Block a -> b)
-> (forall b a. (b -> a -> b) -> b -> Block a -> b)
-> (forall a. (a -> a -> a) -> Block a -> a)
-> (forall a. (a -> a -> a) -> Block a -> a)
-> (forall a. Block a -> [a])
-> (forall a. Block a -> Bool)
-> (forall a. Block a -> Int)
-> (forall a. Eq a => a -> Block a -> Bool)
-> (forall a. Ord a => Block a -> a)
-> (forall a. Ord a => Block a -> a)
-> (forall a. Num a => Block a -> a)
-> (forall a. Num a => Block a -> a)
-> Foldable Block
forall a. Eq a => a -> Block a -> Bool
forall a. Num a => Block a -> a
forall a. Ord a => Block a -> a
forall m. Monoid m => Block m -> m
forall a. Block a -> Bool
forall a. Block a -> Int
forall a. Block a -> [a]
forall a. (a -> a -> a) -> Block a -> a
forall m a. Monoid m => (a -> m) -> Block a -> m
forall b a. (b -> a -> b) -> b -> Block a -> b
forall a b. (a -> b -> b) -> b -> Block a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: Block a -> a
$cproduct :: forall a. Num a => Block a -> a
sum :: Block a -> a
$csum :: forall a. Num a => Block a -> a
minimum :: Block a -> a
$cminimum :: forall a. Ord a => Block a -> a
maximum :: Block a -> a
$cmaximum :: forall a. Ord a => Block a -> a
elem :: a -> Block a -> Bool
$celem :: forall a. Eq a => a -> Block a -> Bool
length :: Block a -> Int
$clength :: forall a. Block a -> Int
null :: Block a -> Bool
$cnull :: forall a. Block a -> Bool
toList :: Block a -> [a]
$ctoList :: forall a. Block a -> [a]
foldl1 :: (a -> a -> a) -> Block a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Block a -> a
foldr1 :: (a -> a -> a) -> Block a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Block a -> a
foldl' :: (b -> a -> b) -> b -> Block a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Block a -> b
foldl :: (b -> a -> b) -> b -> Block a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Block a -> b
foldr' :: (a -> b -> b) -> b -> Block a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Block a -> b
foldr :: (a -> b -> b) -> b -> Block a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> Block a -> b
foldMap' :: (a -> m) -> Block a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Block a -> m
foldMap :: (a -> m) -> Block a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Block a -> m
fold :: Block m -> m
$cfold :: forall m. Monoid m => Block m -> m
Foldable)
data VarDecAss t = AssBeg t (Maybe (VarDecAss t))
| AssRst t (Expr t)
| AssErr t
deriving (Int -> VarDecAss t -> ShowS
[VarDecAss t] -> ShowS
VarDecAss t -> String
(Int -> VarDecAss t -> ShowS)
-> (VarDecAss t -> String)
-> ([VarDecAss t] -> ShowS)
-> Show (VarDecAss t)
forall t. Show t => Int -> VarDecAss t -> ShowS
forall t. Show t => [VarDecAss t] -> ShowS
forall t. Show t => VarDecAss t -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [VarDecAss t] -> ShowS
$cshowList :: forall t. Show t => [VarDecAss t] -> ShowS
show :: VarDecAss t -> String
$cshow :: forall t. Show t => VarDecAss t -> String
showsPrec :: Int -> VarDecAss t -> ShowS
$cshowsPrec :: forall t. Show t => Int -> VarDecAss t -> ShowS
Show, Typeable (VarDecAss t)
DataType
Constr
Typeable (VarDecAss t)
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> VarDecAss t -> c (VarDecAss t))
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (VarDecAss t))
-> (VarDecAss t -> Constr)
-> (VarDecAss t -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (VarDecAss t)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (VarDecAss t)))
-> ((forall b. Data b => b -> b) -> VarDecAss t -> VarDecAss t)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> VarDecAss t -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> VarDecAss t -> r)
-> (forall u. (forall d. Data d => d -> u) -> VarDecAss t -> [u])
-> (forall u.
Int -> (forall d. Data d => d -> u) -> VarDecAss t -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> VarDecAss t -> m (VarDecAss t))
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> VarDecAss t -> m (VarDecAss t))
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> VarDecAss t -> m (VarDecAss t))
-> Data (VarDecAss t)
VarDecAss t -> DataType
VarDecAss t -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (VarDecAss t))
(forall b. Data b => b -> b) -> VarDecAss t -> VarDecAss t
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> VarDecAss t -> c (VarDecAss t)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (VarDecAss t)
forall t. Data t => Typeable (VarDecAss t)
forall t. Data t => VarDecAss t -> DataType
forall t. Data t => VarDecAss t -> Constr
forall t.
Data t =>
(forall b. Data b => b -> b) -> VarDecAss t -> VarDecAss t
forall t u.
Data t =>
Int -> (forall d. Data d => d -> u) -> VarDecAss t -> u
forall t u.
Data t =>
(forall d. Data d => d -> u) -> VarDecAss t -> [u]
forall t r r'.
Data t =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> VarDecAss t -> r
forall t r r'.
Data t =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> VarDecAss t -> r
forall t (m :: * -> *).
(Data t, Monad m) =>
(forall d. Data d => d -> m d) -> VarDecAss t -> m (VarDecAss t)
forall t (m :: * -> *).
(Data t, MonadPlus m) =>
(forall d. Data d => d -> m d) -> VarDecAss t -> m (VarDecAss t)
forall t (c :: * -> *).
Data t =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (VarDecAss t)
forall t (c :: * -> *).
Data t =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> VarDecAss t -> c (VarDecAss t)
forall t (t :: * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (VarDecAss t))
forall t (t :: * -> * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (VarDecAss t))
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) -> VarDecAss t -> u
forall u. (forall d. Data d => d -> u) -> VarDecAss t -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> VarDecAss t -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> VarDecAss t -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> VarDecAss t -> m (VarDecAss t)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> VarDecAss t -> m (VarDecAss t)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (VarDecAss t)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> VarDecAss t -> c (VarDecAss t)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (VarDecAss t))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (VarDecAss t))
$cAssErr :: Constr
$cAssRst :: Constr
$cAssBeg :: Constr
$tVarDecAss :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> VarDecAss t -> m (VarDecAss t)
$cgmapMo :: forall t (m :: * -> *).
(Data t, MonadPlus m) =>
(forall d. Data d => d -> m d) -> VarDecAss t -> m (VarDecAss t)
gmapMp :: (forall d. Data d => d -> m d) -> VarDecAss t -> m (VarDecAss t)
$cgmapMp :: forall t (m :: * -> *).
(Data t, MonadPlus m) =>
(forall d. Data d => d -> m d) -> VarDecAss t -> m (VarDecAss t)
gmapM :: (forall d. Data d => d -> m d) -> VarDecAss t -> m (VarDecAss t)
$cgmapM :: forall t (m :: * -> *).
(Data t, Monad m) =>
(forall d. Data d => d -> m d) -> VarDecAss t -> m (VarDecAss t)
gmapQi :: Int -> (forall d. Data d => d -> u) -> VarDecAss t -> u
$cgmapQi :: forall t u.
Data t =>
Int -> (forall d. Data d => d -> u) -> VarDecAss t -> u
gmapQ :: (forall d. Data d => d -> u) -> VarDecAss t -> [u]
$cgmapQ :: forall t u.
Data t =>
(forall d. Data d => d -> u) -> VarDecAss t -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> VarDecAss t -> r
$cgmapQr :: forall t r r'.
Data t =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> VarDecAss t -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> VarDecAss t -> r
$cgmapQl :: forall t r r'.
Data t =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> VarDecAss t -> r
gmapT :: (forall b. Data b => b -> b) -> VarDecAss t -> VarDecAss t
$cgmapT :: forall t.
Data t =>
(forall b. Data b => b -> b) -> VarDecAss t -> VarDecAss t
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (VarDecAss t))
$cdataCast2 :: forall t (t :: * -> * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (VarDecAss t))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (VarDecAss t))
$cdataCast1 :: forall t (t :: * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (VarDecAss t))
dataTypeOf :: VarDecAss t -> DataType
$cdataTypeOf :: forall t. Data t => VarDecAss t -> DataType
toConstr :: VarDecAss t -> Constr
$ctoConstr :: forall t. Data t => VarDecAss t -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (VarDecAss t)
$cgunfold :: forall t (c :: * -> *).
Data t =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (VarDecAss t)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> VarDecAss t -> c (VarDecAss t)
$cgfoldl :: forall t (c :: * -> *).
Data t =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> VarDecAss t -> c (VarDecAss t)
$cp1Data :: forall t. Data t => Typeable (VarDecAss t)
Data, Typeable, VarDecAss a -> Bool
(a -> m) -> VarDecAss a -> m
(a -> b -> b) -> b -> VarDecAss a -> b
(forall m. Monoid m => VarDecAss m -> m)
-> (forall m a. Monoid m => (a -> m) -> VarDecAss a -> m)
-> (forall m a. Monoid m => (a -> m) -> VarDecAss a -> m)
-> (forall a b. (a -> b -> b) -> b -> VarDecAss a -> b)
-> (forall a b. (a -> b -> b) -> b -> VarDecAss a -> b)
-> (forall b a. (b -> a -> b) -> b -> VarDecAss a -> b)
-> (forall b a. (b -> a -> b) -> b -> VarDecAss a -> b)
-> (forall a. (a -> a -> a) -> VarDecAss a -> a)
-> (forall a. (a -> a -> a) -> VarDecAss a -> a)
-> (forall a. VarDecAss a -> [a])
-> (forall a. VarDecAss a -> Bool)
-> (forall a. VarDecAss a -> Int)
-> (forall a. Eq a => a -> VarDecAss a -> Bool)
-> (forall a. Ord a => VarDecAss a -> a)
-> (forall a. Ord a => VarDecAss a -> a)
-> (forall a. Num a => VarDecAss a -> a)
-> (forall a. Num a => VarDecAss a -> a)
-> Foldable VarDecAss
forall a. Eq a => a -> VarDecAss a -> Bool
forall a. Num a => VarDecAss a -> a
forall a. Ord a => VarDecAss a -> a
forall m. Monoid m => VarDecAss m -> m
forall a. VarDecAss a -> Bool
forall a. VarDecAss a -> Int
forall a. VarDecAss a -> [a]
forall a. (a -> a -> a) -> VarDecAss a -> a
forall m a. Monoid m => (a -> m) -> VarDecAss a -> m
forall b a. (b -> a -> b) -> b -> VarDecAss a -> b
forall a b. (a -> b -> b) -> b -> VarDecAss a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: VarDecAss a -> a
$cproduct :: forall a. Num a => VarDecAss a -> a
sum :: VarDecAss a -> a
$csum :: forall a. Num a => VarDecAss a -> a
minimum :: VarDecAss a -> a
$cminimum :: forall a. Ord a => VarDecAss a -> a
maximum :: VarDecAss a -> a
$cmaximum :: forall a. Ord a => VarDecAss a -> a
elem :: a -> VarDecAss a -> Bool
$celem :: forall a. Eq a => a -> VarDecAss a -> Bool
length :: VarDecAss a -> Int
$clength :: forall a. VarDecAss a -> Int
null :: VarDecAss a -> Bool
$cnull :: forall a. VarDecAss a -> Bool
toList :: VarDecAss a -> [a]
$ctoList :: forall a. VarDecAss a -> [a]
foldl1 :: (a -> a -> a) -> VarDecAss a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> VarDecAss a -> a
foldr1 :: (a -> a -> a) -> VarDecAss a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> VarDecAss a -> a
foldl' :: (b -> a -> b) -> b -> VarDecAss a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> VarDecAss a -> b
foldl :: (b -> a -> b) -> b -> VarDecAss a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> VarDecAss a -> b
foldr' :: (a -> b -> b) -> b -> VarDecAss a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> VarDecAss a -> b
foldr :: (a -> b -> b) -> b -> VarDecAss a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> VarDecAss a -> b
foldMap' :: (a -> m) -> VarDecAss a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> VarDecAss a -> m
foldMap :: (a -> m) -> VarDecAss a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> VarDecAss a -> m
fold :: VarDecAss m -> m
$cfold :: forall m. Monoid m => VarDecAss m -> m
Foldable)
data Expr t = ExprObj t (BList (KeyValue t)) t
| ExprPrefix t (Expr t)
| ExprNew t (Expr t)
| ExprSimple t (Maybe (Expr t))
| ExprParen t (Expr t) t (Maybe (Expr t))
| ExprAnonFun t (Parameters t) (Block t)
| ExprTypeOf t (Expr t)
| ExprFunCall t (ParExpr t) (Maybe (Expr t))
| OpExpr t (Expr t)
| ExprCond t (Expr t) t (Expr t)
| ExprArr t (Maybe (Array t)) t (Maybe (Expr t))
| PostExpr t
| ExprErr t
deriving (Int -> Expr t -> ShowS
[Expr t] -> ShowS
Expr t -> String
(Int -> Expr t -> ShowS)
-> (Expr t -> String) -> ([Expr t] -> ShowS) -> Show (Expr t)
forall t. Show t => Int -> Expr t -> ShowS
forall t. Show t => [Expr t] -> ShowS
forall t. Show t => Expr t -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Expr t] -> ShowS
$cshowList :: forall t. Show t => [Expr t] -> ShowS
show :: Expr t -> String
$cshow :: forall t. Show t => Expr t -> String
showsPrec :: Int -> Expr t -> ShowS
$cshowsPrec :: forall t. Show t => Int -> Expr t -> ShowS
Show, Typeable (Expr t)
DataType
Constr
Typeable (Expr t)
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Expr t -> c (Expr t))
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Expr t))
-> (Expr t -> Constr)
-> (Expr t -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Expr t)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Expr t)))
-> ((forall b. Data b => b -> b) -> Expr t -> Expr t)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Expr t -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Expr t -> r)
-> (forall u. (forall d. Data d => d -> u) -> Expr t -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Expr t -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Expr t -> m (Expr t))
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Expr t -> m (Expr t))
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Expr t -> m (Expr t))
-> Data (Expr t)
Expr t -> DataType
Expr t -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (Expr t))
(forall b. Data b => b -> b) -> Expr t -> Expr t
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Expr t -> c (Expr t)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Expr t)
forall t. Data t => Typeable (Expr t)
forall t. Data t => Expr t -> DataType
forall t. Data t => Expr t -> Constr
forall t.
Data t =>
(forall b. Data b => b -> b) -> Expr t -> Expr t
forall t u.
Data t =>
Int -> (forall d. Data d => d -> u) -> Expr t -> u
forall t u. Data t => (forall d. Data d => d -> u) -> Expr t -> [u]
forall t r r'.
Data t =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Expr t -> r
forall t r r'.
Data t =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Expr t -> r
forall t (m :: * -> *).
(Data t, Monad m) =>
(forall d. Data d => d -> m d) -> Expr t -> m (Expr t)
forall t (m :: * -> *).
(Data t, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Expr t -> m (Expr t)
forall t (c :: * -> *).
Data t =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Expr t)
forall t (c :: * -> *).
Data t =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Expr t -> c (Expr t)
forall t (t :: * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Expr t))
forall t (t :: * -> * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Expr t))
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) -> Expr t -> u
forall u. (forall d. Data d => d -> u) -> Expr t -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Expr t -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Expr t -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Expr t -> m (Expr t)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Expr t -> m (Expr t)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Expr t)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Expr t -> c (Expr t)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Expr t))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Expr t))
$cExprErr :: Constr
$cPostExpr :: Constr
$cExprArr :: Constr
$cExprCond :: Constr
$cOpExpr :: Constr
$cExprFunCall :: Constr
$cExprTypeOf :: Constr
$cExprAnonFun :: Constr
$cExprParen :: Constr
$cExprSimple :: Constr
$cExprNew :: Constr
$cExprPrefix :: Constr
$cExprObj :: Constr
$tExpr :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Expr t -> m (Expr t)
$cgmapMo :: forall t (m :: * -> *).
(Data t, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Expr t -> m (Expr t)
gmapMp :: (forall d. Data d => d -> m d) -> Expr t -> m (Expr t)
$cgmapMp :: forall t (m :: * -> *).
(Data t, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Expr t -> m (Expr t)
gmapM :: (forall d. Data d => d -> m d) -> Expr t -> m (Expr t)
$cgmapM :: forall t (m :: * -> *).
(Data t, Monad m) =>
(forall d. Data d => d -> m d) -> Expr t -> m (Expr t)
gmapQi :: Int -> (forall d. Data d => d -> u) -> Expr t -> u
$cgmapQi :: forall t u.
Data t =>
Int -> (forall d. Data d => d -> u) -> Expr t -> u
gmapQ :: (forall d. Data d => d -> u) -> Expr t -> [u]
$cgmapQ :: forall t u. Data t => (forall d. Data d => d -> u) -> Expr t -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Expr t -> r
$cgmapQr :: forall t r r'.
Data t =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Expr t -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Expr t -> r
$cgmapQl :: forall t r r'.
Data t =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Expr t -> r
gmapT :: (forall b. Data b => b -> b) -> Expr t -> Expr t
$cgmapT :: forall t.
Data t =>
(forall b. Data b => b -> b) -> Expr t -> Expr t
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Expr t))
$cdataCast2 :: forall t (t :: * -> * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Expr t))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (Expr t))
$cdataCast1 :: forall t (t :: * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Expr t))
dataTypeOf :: Expr t -> DataType
$cdataTypeOf :: forall t. Data t => Expr t -> DataType
toConstr :: Expr t -> Constr
$ctoConstr :: forall t. Data t => Expr t -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Expr t)
$cgunfold :: forall t (c :: * -> *).
Data t =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Expr t)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Expr t -> c (Expr t)
$cgfoldl :: forall t (c :: * -> *).
Data t =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Expr t -> c (Expr t)
$cp1Data :: forall t. Data t => Typeable (Expr t)
Data, Typeable, Expr a -> Bool
(a -> m) -> Expr a -> m
(a -> b -> b) -> b -> Expr a -> b
(forall m. Monoid m => Expr m -> m)
-> (forall m a. Monoid m => (a -> m) -> Expr a -> m)
-> (forall m a. Monoid m => (a -> m) -> Expr a -> m)
-> (forall a b. (a -> b -> b) -> b -> Expr a -> b)
-> (forall a b. (a -> b -> b) -> b -> Expr a -> b)
-> (forall b a. (b -> a -> b) -> b -> Expr a -> b)
-> (forall b a. (b -> a -> b) -> b -> Expr a -> b)
-> (forall a. (a -> a -> a) -> Expr a -> a)
-> (forall a. (a -> a -> a) -> Expr a -> a)
-> (forall a. Expr a -> [a])
-> (forall a. Expr a -> Bool)
-> (forall a. Expr a -> Int)
-> (forall a. Eq a => a -> Expr a -> Bool)
-> (forall a. Ord a => Expr a -> a)
-> (forall a. Ord a => Expr a -> a)
-> (forall a. Num a => Expr a -> a)
-> (forall a. Num a => Expr a -> a)
-> Foldable Expr
forall a. Eq a => a -> Expr a -> Bool
forall a. Num a => Expr a -> a
forall a. Ord a => Expr a -> a
forall m. Monoid m => Expr m -> m
forall a. Expr a -> Bool
forall a. Expr a -> Int
forall a. Expr a -> [a]
forall a. (a -> a -> a) -> Expr a -> a
forall m a. Monoid m => (a -> m) -> Expr a -> m
forall b a. (b -> a -> b) -> b -> Expr a -> b
forall a b. (a -> b -> b) -> b -> Expr a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: Expr a -> a
$cproduct :: forall a. Num a => Expr a -> a
sum :: Expr a -> a
$csum :: forall a. Num a => Expr a -> a
minimum :: Expr a -> a
$cminimum :: forall a. Ord a => Expr a -> a
maximum :: Expr a -> a
$cmaximum :: forall a. Ord a => Expr a -> a
elem :: a -> Expr a -> Bool
$celem :: forall a. Eq a => a -> Expr a -> Bool
length :: Expr a -> Int
$clength :: forall a. Expr a -> Int
null :: Expr a -> Bool
$cnull :: forall a. Expr a -> Bool
toList :: Expr a -> [a]
$ctoList :: forall a. Expr a -> [a]
foldl1 :: (a -> a -> a) -> Expr a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Expr a -> a
foldr1 :: (a -> a -> a) -> Expr a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Expr a -> a
foldl' :: (b -> a -> b) -> b -> Expr a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Expr a -> b
foldl :: (b -> a -> b) -> b -> Expr a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Expr a -> b
foldr' :: (a -> b -> b) -> b -> Expr a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Expr a -> b
foldr :: (a -> b -> b) -> b -> Expr a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> Expr a -> b
foldMap' :: (a -> m) -> Expr a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Expr a -> m
foldMap :: (a -> m) -> Expr a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Expr a -> m
fold :: Expr m -> m
$cfold :: forall m. Monoid m => Expr m -> m
Foldable)
data Array t = ArrCont (Expr t) (Maybe (Array t))
| ArrRest t (Array t) (Maybe (Array t))
| ArrErr t
deriving (Int -> Array t -> ShowS
[Array t] -> ShowS
Array t -> String
(Int -> Array t -> ShowS)
-> (Array t -> String) -> ([Array t] -> ShowS) -> Show (Array t)
forall t. Show t => Int -> Array t -> ShowS
forall t. Show t => [Array t] -> ShowS
forall t. Show t => Array t -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Array t] -> ShowS
$cshowList :: forall t. Show t => [Array t] -> ShowS
show :: Array t -> String
$cshow :: forall t. Show t => Array t -> String
showsPrec :: Int -> Array t -> ShowS
$cshowsPrec :: forall t. Show t => Int -> Array t -> ShowS
Show, Typeable (Array t)
DataType
Constr
Typeable (Array t)
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Array t -> c (Array t))
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Array t))
-> (Array t -> Constr)
-> (Array t -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Array t)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Array t)))
-> ((forall b. Data b => b -> b) -> Array t -> Array t)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Array t -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Array t -> r)
-> (forall u. (forall d. Data d => d -> u) -> Array t -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Array t -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Array t -> m (Array t))
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Array t -> m (Array t))
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Array t -> m (Array t))
-> Data (Array t)
Array t -> DataType
Array t -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (Array t))
(forall b. Data b => b -> b) -> Array t -> Array t
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Array t -> c (Array t)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Array t)
forall t. Data t => Typeable (Array t)
forall t. Data t => Array t -> DataType
forall t. Data t => Array t -> Constr
forall t.
Data t =>
(forall b. Data b => b -> b) -> Array t -> Array t
forall t u.
Data t =>
Int -> (forall d. Data d => d -> u) -> Array t -> u
forall t u.
Data t =>
(forall d. Data d => d -> u) -> Array t -> [u]
forall t r r'.
Data t =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Array t -> r
forall t r r'.
Data t =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Array t -> r
forall t (m :: * -> *).
(Data t, Monad m) =>
(forall d. Data d => d -> m d) -> Array t -> m (Array t)
forall t (m :: * -> *).
(Data t, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Array t -> m (Array t)
forall t (c :: * -> *).
Data t =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Array t)
forall t (c :: * -> *).
Data t =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Array t -> c (Array t)
forall t (t :: * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Array t))
forall t (t :: * -> * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Array t))
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) -> Array t -> u
forall u. (forall d. Data d => d -> u) -> Array t -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Array t -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Array t -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Array t -> m (Array t)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Array t -> m (Array t)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Array t)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Array t -> c (Array t)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Array t))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Array t))
$cArrErr :: Constr
$cArrRest :: Constr
$cArrCont :: Constr
$tArray :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Array t -> m (Array t)
$cgmapMo :: forall t (m :: * -> *).
(Data t, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Array t -> m (Array t)
gmapMp :: (forall d. Data d => d -> m d) -> Array t -> m (Array t)
$cgmapMp :: forall t (m :: * -> *).
(Data t, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Array t -> m (Array t)
gmapM :: (forall d. Data d => d -> m d) -> Array t -> m (Array t)
$cgmapM :: forall t (m :: * -> *).
(Data t, Monad m) =>
(forall d. Data d => d -> m d) -> Array t -> m (Array t)
gmapQi :: Int -> (forall d. Data d => d -> u) -> Array t -> u
$cgmapQi :: forall t u.
Data t =>
Int -> (forall d. Data d => d -> u) -> Array t -> u
gmapQ :: (forall d. Data d => d -> u) -> Array t -> [u]
$cgmapQ :: forall t u.
Data t =>
(forall d. Data d => d -> u) -> Array t -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Array t -> r
$cgmapQr :: forall t r r'.
Data t =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Array t -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Array t -> r
$cgmapQl :: forall t r r'.
Data t =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Array t -> r
gmapT :: (forall b. Data b => b -> b) -> Array t -> Array t
$cgmapT :: forall t.
Data t =>
(forall b. Data b => b -> b) -> Array t -> Array t
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Array t))
$cdataCast2 :: forall t (t :: * -> * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Array t))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (Array t))
$cdataCast1 :: forall t (t :: * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Array t))
dataTypeOf :: Array t -> DataType
$cdataTypeOf :: forall t. Data t => Array t -> DataType
toConstr :: Array t -> Constr
$ctoConstr :: forall t. Data t => Array t -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Array t)
$cgunfold :: forall t (c :: * -> *).
Data t =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Array t)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Array t -> c (Array t)
$cgfoldl :: forall t (c :: * -> *).
Data t =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Array t -> c (Array t)
$cp1Data :: forall t. Data t => Typeable (Array t)
Data, Typeable, Array a -> Bool
(a -> m) -> Array a -> m
(a -> b -> b) -> b -> Array a -> b
(forall m. Monoid m => Array m -> m)
-> (forall m a. Monoid m => (a -> m) -> Array a -> m)
-> (forall m a. Monoid m => (a -> m) -> Array a -> m)
-> (forall a b. (a -> b -> b) -> b -> Array a -> b)
-> (forall a b. (a -> b -> b) -> b -> Array a -> b)
-> (forall b a. (b -> a -> b) -> b -> Array a -> b)
-> (forall b a. (b -> a -> b) -> b -> Array a -> b)
-> (forall a. (a -> a -> a) -> Array a -> a)
-> (forall a. (a -> a -> a) -> Array a -> a)
-> (forall a. Array a -> [a])
-> (forall a. Array a -> Bool)
-> (forall a. Array a -> Int)
-> (forall a. Eq a => a -> Array a -> Bool)
-> (forall a. Ord a => Array a -> a)
-> (forall a. Ord a => Array a -> a)
-> (forall a. Num a => Array a -> a)
-> (forall a. Num a => Array a -> a)
-> Foldable Array
forall a. Eq a => a -> Array a -> Bool
forall a. Num a => Array a -> a
forall a. Ord a => Array a -> a
forall m. Monoid m => Array m -> m
forall a. Array a -> Bool
forall a. Array a -> Int
forall a. Array a -> [a]
forall a. (a -> a -> a) -> Array a -> a
forall m a. Monoid m => (a -> m) -> Array a -> m
forall b a. (b -> a -> b) -> b -> Array a -> b
forall a b. (a -> b -> b) -> b -> Array a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: Array a -> a
$cproduct :: forall a. Num a => Array a -> a
sum :: Array a -> a
$csum :: forall a. Num a => Array a -> a
minimum :: Array a -> a
$cminimum :: forall a. Ord a => Array a -> a
maximum :: Array a -> a
$cmaximum :: forall a. Ord a => Array a -> a
elem :: a -> Array a -> Bool
$celem :: forall a. Eq a => a -> Array a -> Bool
length :: Array a -> Int
$clength :: forall a. Array a -> Int
null :: Array a -> Bool
$cnull :: forall a. Array a -> Bool
toList :: Array a -> [a]
$ctoList :: forall a. Array a -> [a]
foldl1 :: (a -> a -> a) -> Array a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Array a -> a
foldr1 :: (a -> a -> a) -> Array a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Array a -> a
foldl' :: (b -> a -> b) -> b -> Array a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Array a -> b
foldl :: (b -> a -> b) -> b -> Array a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Array a -> b
foldr' :: (a -> b -> b) -> b -> Array a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Array a -> b
foldr :: (a -> b -> b) -> b -> Array a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> Array a -> b
foldMap' :: (a -> m) -> Array a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Array a -> m
foldMap :: (a -> m) -> Array a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Array a -> m
fold :: Array m -> m
$cfold :: forall m. Monoid m => Array m -> m
Foldable)
data KeyValue t = KeyValue t t (Expr t)
| KeyValueErr t
deriving (Int -> KeyValue t -> ShowS
[KeyValue t] -> ShowS
KeyValue t -> String
(Int -> KeyValue t -> ShowS)
-> (KeyValue t -> String)
-> ([KeyValue t] -> ShowS)
-> Show (KeyValue t)
forall t. Show t => Int -> KeyValue t -> ShowS
forall t. Show t => [KeyValue t] -> ShowS
forall t. Show t => KeyValue t -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [KeyValue t] -> ShowS
$cshowList :: forall t. Show t => [KeyValue t] -> ShowS
show :: KeyValue t -> String
$cshow :: forall t. Show t => KeyValue t -> String
showsPrec :: Int -> KeyValue t -> ShowS
$cshowsPrec :: forall t. Show t => Int -> KeyValue t -> ShowS
Show, Typeable (KeyValue t)
DataType
Constr
Typeable (KeyValue t)
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> KeyValue t -> c (KeyValue t))
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (KeyValue t))
-> (KeyValue t -> Constr)
-> (KeyValue t -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (KeyValue t)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (KeyValue t)))
-> ((forall b. Data b => b -> b) -> KeyValue t -> KeyValue t)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> KeyValue t -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> KeyValue t -> r)
-> (forall u. (forall d. Data d => d -> u) -> KeyValue t -> [u])
-> (forall u.
Int -> (forall d. Data d => d -> u) -> KeyValue t -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> KeyValue t -> m (KeyValue t))
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> KeyValue t -> m (KeyValue t))
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> KeyValue t -> m (KeyValue t))
-> Data (KeyValue t)
KeyValue t -> DataType
KeyValue t -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (KeyValue t))
(forall b. Data b => b -> b) -> KeyValue t -> KeyValue t
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> KeyValue t -> c (KeyValue t)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (KeyValue t)
forall t. Data t => Typeable (KeyValue t)
forall t. Data t => KeyValue t -> DataType
forall t. Data t => KeyValue t -> Constr
forall t.
Data t =>
(forall b. Data b => b -> b) -> KeyValue t -> KeyValue t
forall t u.
Data t =>
Int -> (forall d. Data d => d -> u) -> KeyValue t -> u
forall t u.
Data t =>
(forall d. Data d => d -> u) -> KeyValue t -> [u]
forall t r r'.
Data t =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> KeyValue t -> r
forall t r r'.
Data t =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> KeyValue t -> r
forall t (m :: * -> *).
(Data t, Monad m) =>
(forall d. Data d => d -> m d) -> KeyValue t -> m (KeyValue t)
forall t (m :: * -> *).
(Data t, MonadPlus m) =>
(forall d. Data d => d -> m d) -> KeyValue t -> m (KeyValue t)
forall t (c :: * -> *).
Data t =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (KeyValue t)
forall t (c :: * -> *).
Data t =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> KeyValue t -> c (KeyValue t)
forall t (t :: * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (KeyValue t))
forall t (t :: * -> * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (KeyValue t))
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) -> KeyValue t -> u
forall u. (forall d. Data d => d -> u) -> KeyValue t -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> KeyValue t -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> KeyValue t -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> KeyValue t -> m (KeyValue t)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> KeyValue t -> m (KeyValue t)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (KeyValue t)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> KeyValue t -> c (KeyValue t)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (KeyValue t))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (KeyValue t))
$cKeyValueErr :: Constr
$cKeyValue :: Constr
$tKeyValue :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> KeyValue t -> m (KeyValue t)
$cgmapMo :: forall t (m :: * -> *).
(Data t, MonadPlus m) =>
(forall d. Data d => d -> m d) -> KeyValue t -> m (KeyValue t)
gmapMp :: (forall d. Data d => d -> m d) -> KeyValue t -> m (KeyValue t)
$cgmapMp :: forall t (m :: * -> *).
(Data t, MonadPlus m) =>
(forall d. Data d => d -> m d) -> KeyValue t -> m (KeyValue t)
gmapM :: (forall d. Data d => d -> m d) -> KeyValue t -> m (KeyValue t)
$cgmapM :: forall t (m :: * -> *).
(Data t, Monad m) =>
(forall d. Data d => d -> m d) -> KeyValue t -> m (KeyValue t)
gmapQi :: Int -> (forall d. Data d => d -> u) -> KeyValue t -> u
$cgmapQi :: forall t u.
Data t =>
Int -> (forall d. Data d => d -> u) -> KeyValue t -> u
gmapQ :: (forall d. Data d => d -> u) -> KeyValue t -> [u]
$cgmapQ :: forall t u.
Data t =>
(forall d. Data d => d -> u) -> KeyValue t -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> KeyValue t -> r
$cgmapQr :: forall t r r'.
Data t =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> KeyValue t -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> KeyValue t -> r
$cgmapQl :: forall t r r'.
Data t =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> KeyValue t -> r
gmapT :: (forall b. Data b => b -> b) -> KeyValue t -> KeyValue t
$cgmapT :: forall t.
Data t =>
(forall b. Data b => b -> b) -> KeyValue t -> KeyValue t
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (KeyValue t))
$cdataCast2 :: forall t (t :: * -> * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (KeyValue t))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (KeyValue t))
$cdataCast1 :: forall t (t :: * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (KeyValue t))
dataTypeOf :: KeyValue t -> DataType
$cdataTypeOf :: forall t. Data t => KeyValue t -> DataType
toConstr :: KeyValue t -> Constr
$ctoConstr :: forall t. Data t => KeyValue t -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (KeyValue t)
$cgunfold :: forall t (c :: * -> *).
Data t =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (KeyValue t)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> KeyValue t -> c (KeyValue t)
$cgfoldl :: forall t (c :: * -> *).
Data t =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> KeyValue t -> c (KeyValue t)
$cp1Data :: forall t. Data t => Typeable (KeyValue t)
Data, Typeable, KeyValue a -> Bool
(a -> m) -> KeyValue a -> m
(a -> b -> b) -> b -> KeyValue a -> b
(forall m. Monoid m => KeyValue m -> m)
-> (forall m a. Monoid m => (a -> m) -> KeyValue a -> m)
-> (forall m a. Monoid m => (a -> m) -> KeyValue a -> m)
-> (forall a b. (a -> b -> b) -> b -> KeyValue a -> b)
-> (forall a b. (a -> b -> b) -> b -> KeyValue a -> b)
-> (forall b a. (b -> a -> b) -> b -> KeyValue a -> b)
-> (forall b a. (b -> a -> b) -> b -> KeyValue a -> b)
-> (forall a. (a -> a -> a) -> KeyValue a -> a)
-> (forall a. (a -> a -> a) -> KeyValue a -> a)
-> (forall a. KeyValue a -> [a])
-> (forall a. KeyValue a -> Bool)
-> (forall a. KeyValue a -> Int)
-> (forall a. Eq a => a -> KeyValue a -> Bool)
-> (forall a. Ord a => KeyValue a -> a)
-> (forall a. Ord a => KeyValue a -> a)
-> (forall a. Num a => KeyValue a -> a)
-> (forall a. Num a => KeyValue a -> a)
-> Foldable KeyValue
forall a. Eq a => a -> KeyValue a -> Bool
forall a. Num a => KeyValue a -> a
forall a. Ord a => KeyValue a -> a
forall m. Monoid m => KeyValue m -> m
forall a. KeyValue a -> Bool
forall a. KeyValue a -> Int
forall a. KeyValue a -> [a]
forall a. (a -> a -> a) -> KeyValue a -> a
forall m a. Monoid m => (a -> m) -> KeyValue a -> m
forall b a. (b -> a -> b) -> b -> KeyValue a -> b
forall a b. (a -> b -> b) -> b -> KeyValue a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: KeyValue a -> a
$cproduct :: forall a. Num a => KeyValue a -> a
sum :: KeyValue a -> a
$csum :: forall a. Num a => KeyValue a -> a
minimum :: KeyValue a -> a
$cminimum :: forall a. Ord a => KeyValue a -> a
maximum :: KeyValue a -> a
$cmaximum :: forall a. Ord a => KeyValue a -> a
elem :: a -> KeyValue a -> Bool
$celem :: forall a. Eq a => a -> KeyValue a -> Bool
length :: KeyValue a -> Int
$clength :: forall a. KeyValue a -> Int
null :: KeyValue a -> Bool
$cnull :: forall a. KeyValue a -> Bool
toList :: KeyValue a -> [a]
$ctoList :: forall a. KeyValue a -> [a]
foldl1 :: (a -> a -> a) -> KeyValue a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> KeyValue a -> a
foldr1 :: (a -> a -> a) -> KeyValue a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> KeyValue a -> a
foldl' :: (b -> a -> b) -> b -> KeyValue a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> KeyValue a -> b
foldl :: (b -> a -> b) -> b -> KeyValue a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> KeyValue a -> b
foldr' :: (a -> b -> b) -> b -> KeyValue a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> KeyValue a -> b
foldr :: (a -> b -> b) -> b -> KeyValue a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> KeyValue a -> b
foldMap' :: (a -> m) -> KeyValue a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> KeyValue a -> m
foldMap :: (a -> m) -> KeyValue a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> KeyValue a -> m
fold :: KeyValue m -> m
$cfold :: forall m. Monoid m => KeyValue m -> m
Foldable)
instance IsTree Statement where
subtrees :: Statement t -> [Statement t]
subtrees (FunDecl t
_ t
_ Parameters t
_ Block t
x) = Block t -> [Statement t]
forall t. Block t -> [Statement t]
fromBlock Block t
x
subtrees (While t
_ ParExpr t
_ Block t
x) = Block t -> [Statement t]
forall t. Block t -> [Statement t]
fromBlock Block t
x
subtrees (DoWhile t
_ Block t
x t
_ ParExpr t
_ Semicolon t
_) = Block t -> [Statement t]
forall t. Block t -> [Statement t]
fromBlock Block t
x
subtrees (For t
_ t
_ Expr t
_ ForContent t
_ t
_ Block t
x) = Block t -> [Statement t]
forall t. Block t -> [Statement t]
fromBlock Block t
x
subtrees (If t
_ ParExpr t
_ Block t
x Maybe (Statement t)
mb) = Block t -> [Statement t]
forall t. Block t -> [Statement t]
fromBlock Block t
x [Statement t] -> [Statement t] -> [Statement t]
forall a. Semigroup a => a -> a -> a
<> [Statement t]
-> (Statement t -> [Statement t])
-> Maybe (Statement t)
-> [Statement t]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] Statement t -> [Statement t]
forall (tree :: * -> *) t. IsTree tree => tree t -> [tree t]
subtrees Maybe (Statement t)
mb
subtrees (Else t
_ Block t
x) = Block t -> [Statement t]
forall t. Block t -> [Statement t]
fromBlock Block t
x
subtrees (With t
_ ParExpr t
_ Block t
x) = Block t -> [Statement t]
forall t. Block t -> [Statement t]
fromBlock Block t
x
subtrees Statement t
_ = []
uniplate :: Statement t -> ([Statement t], [Statement t] -> Statement t)
uniplate = String
-> Statement t -> ([Statement t], [Statement t] -> Statement t)
forall a. HasCallStack => String -> a
Prelude.error String
"uniplate not implemented in IsTree (Yi.Syntax.JavaScript.Statement)"
emptyNode :: Statement t
emptyNode = String -> Statement t
forall a. HasCallStack => String -> a
Prelude.error String
"emptyNode not implemented in IsTree (Yi.Syntax.JavaScript.Statement)"
instance Failable ForContent where
stupid :: t -> ForContent t
stupid = t -> ForContent t
forall t. t -> ForContent t
ForErr
hasFailed :: ForContent t -> Bool
hasFailed ForContent t
t = case ForContent t
t of
ForErr t
_ -> Bool
True
ForContent t
_ -> Bool
False
instance Failable Block where
stupid :: t -> Block t
stupid = t -> Block t
forall t. t -> Block t
BlockErr
hasFailed :: Block t -> Bool
hasFailed Block t
t = case Block t
t of
BlockErr t
_ -> Bool
True
Block t
_ -> Bool
False
instance Failable VarDecAss where
stupid :: t -> VarDecAss t
stupid = t -> VarDecAss t
forall t. t -> VarDecAss t
AssErr
hasFailed :: VarDecAss t -> Bool
hasFailed VarDecAss t
t = case VarDecAss t
t of
AssErr t
_ -> Bool
True
VarDecAss t
_ -> Bool
False
instance Failable Parameters where
stupid :: t -> Parameters t
stupid = t -> Parameters t
forall t. t -> Parameters t
ParErr
hasFailed :: Parameters t -> Bool
hasFailed Parameters t
t = case Parameters t
t of
ParErr t
_ -> Bool
True
Parameters t
_ -> Bool
False
instance Failable ParExpr where
stupid :: t -> ParExpr t
stupid = t -> ParExpr t
forall t. t -> ParExpr t
ParExprErr
hasFailed :: ParExpr t -> Bool
hasFailed ParExpr t
t = case ParExpr t
t of
ParExprErr t
_ -> Bool
True
ParExpr t
_ -> Bool
False
instance Failable Expr where
stupid :: t -> Expr t
stupid = t -> Expr t
forall t. t -> Expr t
ExprErr
hasFailed :: Expr t -> Bool
hasFailed Expr t
t = case Expr t
t of
ExprErr t
_ -> Bool
True
Expr t
_ -> Bool
False
instance Failable KeyValue where
stupid :: t -> KeyValue t
stupid = t -> KeyValue t
forall t. t -> KeyValue t
KeyValueErr
hasFailed :: KeyValue t -> Bool
hasFailed KeyValue t
t = case KeyValue t
t of
KeyValueErr t
_ -> Bool
True
KeyValue t
_ -> Bool
False
instance Strokable (Statement TT) where
toStrokes :: Statement TT -> Endo [Stroke]
toStrokes (FunDecl TT
f TT
n Parameters TT
ps Block TT
blk) =
let s :: TT -> Endo [Stroke]
s = if Block TT -> Bool
forall (f :: * -> *) t. Failable f => f t -> Bool
hasFailed Block TT
blk then TT -> Endo [Stroke]
error else [TT] -> TT -> Endo [Stroke]
failStroker [TT
n] in
TT -> Endo [Stroke]
s TT
f Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> TT -> Endo [Stroke]
s TT
n Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Parameters TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Parameters TT
ps Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Block TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Block TT
blk
toStrokes (VarDecl TT
v BList (VarDecAss TT)
vs Semicolon TT
sc) =
let s :: TT -> Endo [Stroke]
s = if (VarDecAss TT -> Bool) -> BList (VarDecAss TT) -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any VarDecAss TT -> Bool
forall (f :: * -> *) t. Failable f => f t -> Bool
hasFailed BList (VarDecAss TT)
vs then TT -> Endo [Stroke]
error else TT -> Endo [Stroke]
normal in
TT -> Endo [Stroke]
s TT
v Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> (VarDecAss TT -> Endo [Stroke])
-> BList (VarDecAss TT) -> Endo [Stroke]
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap VarDecAss TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes BList (VarDecAss TT)
vs Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Endo [Stroke]
-> (TT -> Endo [Stroke]) -> Semicolon TT -> Endo [Stroke]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Endo [Stroke]
forall a. Monoid a => a
mempty TT -> Endo [Stroke]
s Semicolon TT
sc
toStrokes (Return TT
t Maybe (Expr TT)
exp Semicolon TT
sc) = TT -> Endo [Stroke]
normal TT
t Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Endo [Stroke]
-> (Expr TT -> Endo [Stroke]) -> Maybe (Expr TT) -> Endo [Stroke]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Endo [Stroke]
forall a. Monoid a => a
mempty Expr TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Maybe (Expr TT)
exp Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Endo [Stroke]
-> (TT -> Endo [Stroke]) -> Semicolon TT -> Endo [Stroke]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Endo [Stroke]
forall a. Monoid a => a
mempty TT -> Endo [Stroke]
normal Semicolon TT
sc
toStrokes (While TT
w ParExpr TT
exp Block TT
blk) =
let s :: TT -> Endo [Stroke]
s = if Block TT -> Bool
forall (f :: * -> *) t. Failable f => f t -> Bool
hasFailed Block TT
blk Bool -> Bool -> Bool
|| Block TT -> Bool
forall (f :: * -> *) t. Failable f => f t -> Bool
hasFailed Block TT
blk then TT -> Endo [Stroke]
error else TT -> Endo [Stroke]
normal in
TT -> Endo [Stroke]
s TT
w Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> ParExpr TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes ParExpr TT
exp Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Block TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Block TT
blk
toStrokes (DoWhile TT
d Block TT
blk TT
w ParExpr TT
exp Semicolon TT
sc) =
let s1 :: TT -> Endo [Stroke]
s1 = if Block TT -> Bool
forall (f :: * -> *) t. Failable f => f t -> Bool
hasFailed Block TT
blk then TT -> Endo [Stroke]
error else TT -> Endo [Stroke]
normal
s2 :: TT -> Endo [Stroke]
s2 = if ParExpr TT -> Bool
forall (f :: * -> *) t. Failable f => f t -> Bool
hasFailed ParExpr TT
exp then TT -> Endo [Stroke]
error else TT -> Endo [Stroke]
normal in
TT -> Endo [Stroke]
s1 TT
d Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Block TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Block TT
blk Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> TT -> Endo [Stroke]
s2 TT
w Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> ParExpr TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes ParExpr TT
exp Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Endo [Stroke]
-> (TT -> Endo [Stroke]) -> Semicolon TT -> Endo [Stroke]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Endo [Stroke]
forall a. Monoid a => a
mempty TT -> Endo [Stroke]
normal Semicolon TT
sc
toStrokes (For TT
f TT
l Expr TT
x ForContent TT
c TT
r Block TT
blk) =
let s :: TT -> Endo [Stroke]
s = if Block TT -> Bool
forall (f :: * -> *) t. Failable f => f t -> Bool
hasFailed Block TT
blk Bool -> Bool -> Bool
|| ForContent TT -> Bool
forall (f :: * -> *) t. Failable f => f t -> Bool
hasFailed ForContent TT
c Bool -> Bool -> Bool
|| Expr TT -> Bool
forall (f :: * -> *) t. Failable f => f t -> Bool
hasFailed Expr TT
x
then TT -> Endo [Stroke]
error
else [TT] -> TT -> Endo [Stroke]
failStroker [TT
f, TT
l, TT
r] in
TT -> Endo [Stroke]
s TT
f Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> TT -> Endo [Stroke]
s TT
l Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Expr TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Expr TT
x Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> ForContent TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes ForContent TT
c Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> TT -> Endo [Stroke]
s TT
r Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Block TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Block TT
blk
toStrokes (If TT
i ParExpr TT
x Block TT
blk Maybe (Statement TT)
e) =
let s :: TT -> Endo [Stroke]
s = if Block TT -> Bool
forall (f :: * -> *) t. Failable f => f t -> Bool
hasFailed Block TT
blk then TT -> Endo [Stroke]
error else TT -> Endo [Stroke]
normal in
TT -> Endo [Stroke]
s TT
i Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> ParExpr TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes ParExpr TT
x Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Block TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Block TT
blk Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Endo [Stroke]
-> (Statement TT -> Endo [Stroke])
-> Maybe (Statement TT)
-> Endo [Stroke]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Endo [Stroke]
forall a. Monoid a => a
mempty Statement TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Maybe (Statement TT)
e
toStrokes (Else TT
e Block TT
blk) = TT -> Endo [Stroke]
normal TT
e Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Block TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Block TT
blk
toStrokes (With TT
w ParExpr TT
x Block TT
blk) = TT -> Endo [Stroke]
normal TT
w Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> ParExpr TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes ParExpr TT
x Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Block TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Block TT
blk
toStrokes (Expr Expr TT
exp Semicolon TT
sc) = Expr TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Expr TT
exp Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Endo [Stroke]
-> (TT -> Endo [Stroke]) -> Semicolon TT -> Endo [Stroke]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Endo [Stroke]
forall a. Monoid a => a
mempty TT -> Endo [Stroke]
normal Semicolon TT
sc
toStrokes (Comm TT
t) = TT -> Endo [Stroke]
normal TT
t
instance Strokable (ForContent TT) where
toStrokes :: ForContent TT -> Endo [Stroke]
toStrokes (ForNormal TT
s1 Expr TT
x2 TT
s2 Expr TT
x3) =
let s :: TT -> Endo [Stroke]
s = if (Expr TT -> Bool) -> [Expr TT] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any Expr TT -> Bool
forall (f :: * -> *) t. Failable f => f t -> Bool
hasFailed [Expr TT
x2, Expr TT
x3] then TT -> Endo [Stroke]
error else [TT] -> TT -> Endo [Stroke]
failStroker [TT
s2] in
TT -> Endo [Stroke]
s TT
s1 Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Expr TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Expr TT
x2 Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> TT -> Endo [Stroke]
s TT
s2 Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Expr TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Expr TT
x3
toStrokes (ForIn TT
i Expr TT
x) =
let s :: TT -> Endo [Stroke]
s = if Expr TT -> Bool
forall (f :: * -> *) t. Failable f => f t -> Bool
hasFailed Expr TT
x then TT -> Endo [Stroke]
error else TT -> Endo [Stroke]
normal in
TT -> Endo [Stroke]
s TT
i Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Expr TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Expr TT
x
toStrokes (ForErr TT
t) = TT -> Endo [Stroke]
error TT
t
instance Strokable (Block TT) where
toStrokes :: Block TT -> Endo [Stroke]
toStrokes (BlockOne Statement TT
stmt) = Statement TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Statement TT
stmt
toStrokes (Block TT
l BList (Statement TT)
stmts TT
r) =
let s :: TT -> Endo [Stroke]
s = [TT] -> TT -> Endo [Stroke]
failStroker [TT
l, TT
r] in
TT -> Endo [Stroke]
s TT
l Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> (Statement TT -> Endo [Stroke])
-> BList (Statement TT) -> Endo [Stroke]
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap Statement TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes BList (Statement TT)
stmts Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> TT -> Endo [Stroke]
s TT
r
toStrokes (BlockErr TT
t) = TT -> Endo [Stroke]
error TT
t
instance Strokable (VarDecAss TT) where
toStrokes :: VarDecAss TT -> Endo [Stroke]
toStrokes (AssBeg TT
t Maybe (VarDecAss TT)
x) = TT -> Endo [Stroke]
normal TT
t Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Endo [Stroke]
-> (VarDecAss TT -> Endo [Stroke])
-> Maybe (VarDecAss TT)
-> Endo [Stroke]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Endo [Stroke]
forall a. Monoid a => a
mempty VarDecAss TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Maybe (VarDecAss TT)
x
toStrokes (AssRst TT
t Expr TT
exp) =
let s :: TT -> Endo [Stroke]
s = if Expr TT -> Bool
forall (f :: * -> *) t. Failable f => f t -> Bool
hasFailed Expr TT
exp then TT -> Endo [Stroke]
error else TT -> Endo [Stroke]
normal in
TT -> Endo [Stroke]
s TT
t Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Expr TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Expr TT
exp
toStrokes (AssErr TT
t) = TT -> Endo [Stroke]
error TT
t
instance Strokable (Expr TT) where
toStrokes :: Expr TT -> Endo [Stroke]
toStrokes (ExprSimple TT
x Maybe (Expr TT)
exp) = TT -> Endo [Stroke]
normal TT
x Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Endo [Stroke]
-> (Expr TT -> Endo [Stroke]) -> Maybe (Expr TT) -> Endo [Stroke]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Endo [Stroke]
forall a. Monoid a => a
mempty Expr TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Maybe (Expr TT)
exp
toStrokes (ExprObj TT
l BList (KeyValue TT)
kvs TT
r) =
let s :: TT -> Endo [Stroke]
s = [TT] -> TT -> Endo [Stroke]
failStroker [TT
l, TT
r] in
TT -> Endo [Stroke]
s TT
l Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> (KeyValue TT -> Endo [Stroke])
-> BList (KeyValue TT) -> Endo [Stroke]
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap KeyValue TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes BList (KeyValue TT)
kvs Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> TT -> Endo [Stroke]
s TT
r
toStrokes (ExprPrefix TT
t Expr TT
exp) = TT -> Endo [Stroke]
normal TT
t Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Expr TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Expr TT
exp
toStrokes (ExprNew TT
t Expr TT
x) = TT -> Endo [Stroke]
normal TT
t Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Expr TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Expr TT
x
toStrokes (ExprParen TT
l Expr TT
exp TT
r Maybe (Expr TT)
op) =
let s :: TT -> Endo [Stroke]
s = [TT] -> TT -> Endo [Stroke]
failStroker [TT
l, TT
r] in
TT -> Endo [Stroke]
s TT
l Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Expr TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Expr TT
exp Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> TT -> Endo [Stroke]
s TT
r Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Endo [Stroke]
-> (Expr TT -> Endo [Stroke]) -> Maybe (Expr TT) -> Endo [Stroke]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Endo [Stroke]
forall a. Monoid a => a
mempty Expr TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Maybe (Expr TT)
op
toStrokes (ExprAnonFun TT
f Parameters TT
ps Block TT
blk) =
TT -> Endo [Stroke]
normal TT
f Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Parameters TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Parameters TT
ps Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Block TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Block TT
blk
toStrokes (ExprTypeOf TT
t Expr TT
x) =
let s :: TT -> Endo [Stroke]
s = if Expr TT -> Bool
forall (f :: * -> *) t. Failable f => f t -> Bool
hasFailed Expr TT
x then TT -> Endo [Stroke]
error else TT -> Endo [Stroke]
normal in
TT -> Endo [Stroke]
s TT
t Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Expr TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Expr TT
x
toStrokes (ExprFunCall TT
n ParExpr TT
x Maybe (Expr TT)
m) =
let s :: TT -> Endo [Stroke]
s = if ParExpr TT -> Bool
forall (f :: * -> *) t. Failable f => f t -> Bool
hasFailed ParExpr TT
x then TT -> Endo [Stroke]
error else TT -> Endo [Stroke]
normal in
TT -> Endo [Stroke]
s TT
n Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> ParExpr TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes ParExpr TT
x Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Endo [Stroke]
-> (Expr TT -> Endo [Stroke]) -> Maybe (Expr TT) -> Endo [Stroke]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Endo [Stroke]
forall a. Monoid a => a
mempty Expr TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Maybe (Expr TT)
m
toStrokes (OpExpr TT
op Expr TT
exp) =
let s :: TT -> Endo [Stroke]
s = if Expr TT -> Bool
forall (f :: * -> *) t. Failable f => f t -> Bool
hasFailed Expr TT
exp then TT -> Endo [Stroke]
error else TT -> Endo [Stroke]
normal in
TT -> Endo [Stroke]
s TT
op Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Expr TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Expr TT
exp
toStrokes (PostExpr TT
t) = TT -> Endo [Stroke]
normal TT
t
toStrokes (ExprCond TT
a Expr TT
x TT
b Expr TT
y) =
let s :: TT -> Endo [Stroke]
s = [TT] -> TT -> Endo [Stroke]
failStroker [TT
a, TT
b] in
TT -> Endo [Stroke]
s TT
a Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Expr TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Expr TT
x Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> TT -> Endo [Stroke]
s TT
b Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Expr TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Expr TT
y
toStrokes (ExprArr TT
l Maybe (Array TT)
x TT
r Maybe (Expr TT)
m) =
let s :: TT -> Endo [Stroke]
s = [TT] -> TT -> Endo [Stroke]
failStroker [TT
l, TT
r] in
TT -> Endo [Stroke]
s TT
l Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Endo [Stroke]
-> (Array TT -> Endo [Stroke]) -> Maybe (Array TT) -> Endo [Stroke]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Endo [Stroke]
forall a. Monoid a => a
mempty Array TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Maybe (Array TT)
x Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> TT -> Endo [Stroke]
s TT
r Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Endo [Stroke]
-> (Expr TT -> Endo [Stroke]) -> Maybe (Expr TT) -> Endo [Stroke]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Endo [Stroke]
forall a. Monoid a => a
mempty Expr TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Maybe (Expr TT)
m
toStrokes (ExprErr TT
t) = TT -> Endo [Stroke]
error TT
t
instance Strokable (Parameters TT) where
toStrokes :: Parameters TT -> Endo [Stroke]
toStrokes (Parameters TT
l [TT]
ps TT
r) = TT -> Endo [Stroke]
normal TT
l Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> (TT -> Endo [Stroke]) -> [TT] -> Endo [Stroke]
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes [TT]
ps Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> TT -> Endo [Stroke]
normal TT
r
toStrokes (ParErr TT
t) = TT -> Endo [Stroke]
error TT
t
instance Strokable (ParExpr TT) where
toStrokes :: ParExpr TT -> Endo [Stroke]
toStrokes (ParExpr TT
l [Expr TT]
xs TT
r) =
let s :: TT -> Endo [Stroke]
s = if TT -> Bool
isError TT
r Bool -> Bool -> Bool
|| (Expr TT -> Bool) -> [Expr TT] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any Expr TT -> Bool
forall (f :: * -> *) t. Failable f => f t -> Bool
hasFailed [Expr TT]
xs
then TT -> Endo [Stroke]
error
else TT -> Endo [Stroke]
normal in
TT -> Endo [Stroke]
s TT
l Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> (Expr TT -> Endo [Stroke]) -> [Expr TT] -> Endo [Stroke]
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap Expr TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes [Expr TT]
xs Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> TT -> Endo [Stroke]
s TT
r
toStrokes (ParExprErr TT
t) = TT -> Endo [Stroke]
error TT
t
instance Strokable (KeyValue TT) where
toStrokes :: KeyValue TT -> Endo [Stroke]
toStrokes (KeyValue TT
n TT
c Expr TT
exp) =
let s :: TT -> Endo [Stroke]
s = [TT] -> TT -> Endo [Stroke]
failStroker [TT
n, TT
c] in
TT -> Endo [Stroke]
s TT
n Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> TT -> Endo [Stroke]
s TT
c Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Expr TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Expr TT
exp
toStrokes (KeyValueErr TT
t) = TT -> Endo [Stroke]
error TT
t
instance Strokable (Tok Token) where
toStrokes :: TT -> Endo [Stroke]
toStrokes TT
t = if TT -> Bool
isError TT
t
then (TT -> Stroke) -> TT -> Endo [Stroke]
forall t a. (t -> a) -> t -> Endo [a]
one (StyleName -> Stroke -> Stroke
modStroke StyleName
errorStyle (Stroke -> Stroke) -> (TT -> Stroke) -> TT -> Stroke
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TT -> Stroke
tokenToStroke) TT
t
else (TT -> Stroke) -> TT -> Endo [Stroke]
forall t a. (t -> a) -> t -> Endo [a]
one TT -> Stroke
tokenToStroke TT
t
instance Strokable (Array TT) where
toStrokes :: Array TT -> Endo [Stroke]
toStrokes (ArrCont Expr TT
x Maybe (Array TT)
m) = Expr TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Expr TT
x Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Endo [Stroke]
-> (Array TT -> Endo [Stroke]) -> Maybe (Array TT) -> Endo [Stroke]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Endo [Stroke]
forall a. Monoid a => a
mempty Array TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Maybe (Array TT)
m
toStrokes (ArrRest TT
c Array TT
a Maybe (Array TT)
m) = TT -> Endo [Stroke]
normal TT
c Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Array TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Array TT
a Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Endo [Stroke]
-> (Array TT -> Endo [Stroke]) -> Maybe (Array TT) -> Endo [Stroke]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Endo [Stroke]
forall a. Monoid a => a
mempty Array TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Maybe (Array TT)
m
toStrokes (ArrErr TT
t) = TT -> Endo [Stroke]
error TT
t
normal :: TT -> Endo [Stroke]
normal :: TT -> Endo [Stroke]
normal = (TT -> Stroke) -> TT -> Endo [Stroke]
forall t a. (t -> a) -> t -> Endo [a]
one TT -> Stroke
tokenToStroke
error :: TT -> Endo [Stroke]
error :: TT -> Endo [Stroke]
error = (TT -> Stroke) -> TT -> Endo [Stroke]
forall t a. (t -> a) -> t -> Endo [a]
one (StyleName -> Stroke -> Stroke
modStroke StyleName
errorStyle (Stroke -> Stroke) -> (TT -> Stroke) -> TT -> Stroke
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TT -> Stroke
tokenToStroke)
one :: (t -> a) -> t -> Endo [a]
one :: (t -> a) -> t -> Endo [a]
one t -> a
f t
x = ([a] -> [a]) -> Endo [a]
forall a. (a -> a) -> Endo a
Endo (t -> a
f t
x a -> [a] -> [a]
forall a. a -> [a] -> [a]
:)
modStroke :: StyleName -> Stroke -> Stroke
modStroke :: StyleName -> Stroke -> Stroke
modStroke StyleName
style = (StyleName -> StyleName) -> Stroke -> Stroke
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (StyleName
style StyleName -> StyleName -> StyleName
forall a. Semigroup a => a -> a -> a
<>)
nError :: [TT] -> [TT] -> Endo [Stroke]
nError :: [TT] -> [TT] -> Endo [Stroke]
nError [TT]
xs = (TT -> Endo [Stroke]) -> [TT] -> Endo [Stroke]
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap ([TT] -> TT -> Endo [Stroke]
failStroker [TT]
xs)
failStroker :: [TT] -> TT -> Endo [Stroke]
failStroker :: [TT] -> TT -> Endo [Stroke]
failStroker [TT]
xs = if (TT -> Bool) -> [TT] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any TT -> Bool
isError [TT]
xs then TT -> Endo [Stroke]
error else TT -> Endo [Stroke]
normal
tokenToStroke :: TT -> Stroke
tokenToStroke :: TT -> Stroke
tokenToStroke = (Token -> StyleName) -> Span Token -> Stroke
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Token -> StyleName
tokenToStyle (Span Token -> Stroke) -> (TT -> Span Token) -> TT -> Stroke
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TT -> Span Token
forall t. Tok t -> Span t
tokToSpan
getStrokes :: Tree TT -> Point -> Point -> Point -> [Stroke]
getStrokes :: BList (Statement TT) -> Point -> Point -> Point -> [Stroke]
getStrokes BList (Statement TT)
t0 Point
_point Point
_begin Point
_end = Text -> [Stroke] -> [Stroke]
forall a. Text -> a -> a
trace (Char
'\n' Char -> Text -> Text
`T.cons` BList (Statement TT) -> Text
forall a. Show a => a -> Text
showT BList (Statement TT)
t0) [Stroke]
result
where
result :: [Stroke]
result = Endo [Stroke] -> [Stroke] -> [Stroke]
forall a. Endo a -> a -> a
appEndo ((Statement TT -> Endo [Stroke])
-> BList (Statement TT) -> Endo [Stroke]
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap Statement TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes BList (Statement TT)
t0) []
parse :: P TT (Tree TT)
parse :: P TT (BList (Statement TT))
parse = Parser TT (Statement TT) -> P TT (BList (Statement TT))
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many Parser TT (Statement TT)
statement P TT (BList (Statement TT))
-> Parser TT () -> P TT (BList (Statement TT))
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Parser TT ()
forall s. Parser s ()
eof
statement :: P TT (Statement TT)
statement :: Parser TT (Statement TT)
statement = TT -> TT -> Parameters TT -> Block TT -> Statement TT
forall t. t -> t -> Parameters t -> Block t -> Statement t
FunDecl (TT -> TT -> Parameters TT -> Block TT -> Statement TT)
-> Parser TT TT
-> Parser TT (TT -> Parameters TT -> Block TT -> Statement TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Reserved -> Parser TT TT
res Reserved
Function' Parser TT (TT -> Parameters TT -> Block TT -> Statement TT)
-> Parser TT TT
-> Parser TT (Parameters TT -> Block TT -> Statement TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT TT -> Parser TT TT
plzTok Parser TT TT
name Parser TT (Parameters TT -> Block TT -> Statement TT)
-> Parser TT (Parameters TT)
-> Parser TT (Block TT -> Statement TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (Parameters TT)
parameters Parser TT (Block TT -> Statement TT)
-> Parser TT (Block TT) -> Parser TT (Statement TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (Block TT)
block
Parser TT (Statement TT)
-> Parser TT (Statement TT) -> Parser TT (Statement TT)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> TT -> BList (VarDecAss TT) -> Semicolon TT -> Statement TT
forall t. t -> BList (VarDecAss t) -> Semicolon t -> Statement t
VarDecl (TT -> BList (VarDecAss TT) -> Semicolon TT -> Statement TT)
-> Parser TT TT
-> Parser TT (BList (VarDecAss TT) -> Semicolon TT -> Statement TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Reserved -> Parser TT TT
res Reserved
Var' Parser TT (BList (VarDecAss TT) -> Semicolon TT -> Statement TT)
-> Parser TT (BList (VarDecAss TT))
-> Parser TT (Semicolon TT -> Statement TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> P TT (VarDecAss TT) -> P TT (VarDecAss TT)
forall (f :: * -> *). Failable f => P TT (f TT) -> P TT (f TT)
plz P TT (VarDecAss TT)
varDecAss P TT (VarDecAss TT)
-> Parser TT TT -> Parser TT (BList (VarDecAss TT))
forall (f :: * -> *) a v. Alternative f => f a -> f v -> f [a]
`sepBy1` Char -> Parser TT TT
spc Char
',' Parser TT (Semicolon TT -> Statement TT)
-> Parser TT (Semicolon TT) -> Parser TT (Statement TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (Semicolon TT)
semicolon
Parser TT (Statement TT)
-> Parser TT (Statement TT) -> Parser TT (Statement TT)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> TT -> Maybe (Expr TT) -> Semicolon TT -> Statement TT
forall t. t -> Maybe (Expr t) -> Semicolon t -> Statement t
Return (TT -> Maybe (Expr TT) -> Semicolon TT -> Statement TT)
-> Parser TT TT
-> Parser TT (Maybe (Expr TT) -> Semicolon TT -> Statement TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Reserved -> Parser TT TT
res Reserved
Return' Parser TT (Maybe (Expr TT) -> Semicolon TT -> Statement TT)
-> Parser TT (Maybe (Expr TT))
-> Parser TT (Semicolon TT -> Statement TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (Expr TT) -> Parser TT (Maybe (Expr TT))
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser TT (Expr TT)
expression Parser TT (Semicolon TT -> Statement TT)
-> Parser TT (Semicolon TT) -> Parser TT (Statement TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (Semicolon TT)
semicolon
Parser TT (Statement TT)
-> Parser TT (Statement TT) -> Parser TT (Statement TT)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> TT -> ParExpr TT -> Block TT -> Statement TT
forall t. t -> ParExpr t -> Block t -> Statement t
While (TT -> ParExpr TT -> Block TT -> Statement TT)
-> Parser TT TT
-> Parser TT (ParExpr TT -> Block TT -> Statement TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Reserved -> Parser TT TT
res Reserved
While' Parser TT (ParExpr TT -> Block TT -> Statement TT)
-> Parser TT (ParExpr TT) -> Parser TT (Block TT -> Statement TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (ParExpr TT)
parExpr Parser TT (Block TT -> Statement TT)
-> Parser TT (Block TT) -> Parser TT (Statement TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (Block TT)
block
Parser TT (Statement TT)
-> Parser TT (Statement TT) -> Parser TT (Statement TT)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> TT -> Block TT -> TT -> ParExpr TT -> Semicolon TT -> Statement TT
forall t.
t -> Block t -> t -> ParExpr t -> Semicolon t -> Statement t
DoWhile (TT
-> Block TT -> TT -> ParExpr TT -> Semicolon TT -> Statement TT)
-> Parser TT TT
-> Parser
TT (Block TT -> TT -> ParExpr TT -> Semicolon TT -> Statement TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Reserved -> Parser TT TT
res Reserved
Do' Parser
TT (Block TT -> TT -> ParExpr TT -> Semicolon TT -> Statement TT)
-> Parser TT (Block TT)
-> Parser TT (TT -> ParExpr TT -> Semicolon TT -> Statement TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (Block TT)
block Parser TT (TT -> ParExpr TT -> Semicolon TT -> Statement TT)
-> Parser TT TT
-> Parser TT (ParExpr TT -> Semicolon TT -> Statement TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT TT -> Parser TT TT
plzTok (Reserved -> Parser TT TT
res Reserved
While') Parser TT (ParExpr TT -> Semicolon TT -> Statement TT)
-> Parser TT (ParExpr TT)
-> Parser TT (Semicolon TT -> Statement TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (ParExpr TT)
parExpr Parser TT (Semicolon TT -> Statement TT)
-> Parser TT (Semicolon TT) -> Parser TT (Statement TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (Semicolon TT)
semicolon
Parser TT (Statement TT)
-> Parser TT (Statement TT) -> Parser TT (Statement TT)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> TT
-> TT -> Expr TT -> ForContent TT -> TT -> Block TT -> Statement TT
forall t.
t -> t -> Expr t -> ForContent t -> t -> Block t -> Statement t
For (TT
-> TT
-> Expr TT
-> ForContent TT
-> TT
-> Block TT
-> Statement TT)
-> Parser TT TT
-> Parser
TT
(TT -> Expr TT -> ForContent TT -> TT -> Block TT -> Statement TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Reserved -> Parser TT TT
res Reserved
For' Parser
TT
(TT -> Expr TT -> ForContent TT -> TT -> Block TT -> Statement TT)
-> Parser TT TT
-> Parser
TT (Expr TT -> ForContent TT -> TT -> Block TT -> Statement TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Char -> Parser TT TT
plzSpc Char
'(' Parser
TT (Expr TT -> ForContent TT -> TT -> Block TT -> Statement TT)
-> Parser TT (Expr TT)
-> Parser TT (ForContent TT -> TT -> Block TT -> Statement TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (Expr TT)
plzExpr Parser TT (ForContent TT -> TT -> Block TT -> Statement TT)
-> Parser TT (ForContent TT)
-> Parser TT (TT -> Block TT -> Statement TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (ForContent TT)
forContent
Parser TT (TT -> Block TT -> Statement TT)
-> Parser TT TT -> Parser TT (Block TT -> Statement TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Char -> Parser TT TT
plzSpc Char
')' Parser TT (Block TT -> Statement TT)
-> Parser TT (Block TT) -> Parser TT (Statement TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (Block TT)
block
Parser TT (Statement TT)
-> Parser TT (Statement TT) -> Parser TT (Statement TT)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> TT
-> ParExpr TT -> Block TT -> Maybe (Statement TT) -> Statement TT
forall t.
t -> ParExpr t -> Block t -> Maybe (Statement t) -> Statement t
If (TT
-> ParExpr TT -> Block TT -> Maybe (Statement TT) -> Statement TT)
-> Parser TT TT
-> Parser
TT (ParExpr TT -> Block TT -> Maybe (Statement TT) -> Statement TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Reserved -> Parser TT TT
res Reserved
If' Parser
TT (ParExpr TT -> Block TT -> Maybe (Statement TT) -> Statement TT)
-> Parser TT (ParExpr TT)
-> Parser TT (Block TT -> Maybe (Statement TT) -> Statement TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (ParExpr TT)
parExpr Parser TT (Block TT -> Maybe (Statement TT) -> Statement TT)
-> Parser TT (Block TT)
-> Parser TT (Maybe (Statement TT) -> Statement TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (Block TT)
block Parser TT (Maybe (Statement TT) -> Statement TT)
-> Parser TT (Maybe (Statement TT)) -> Parser TT (Statement TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (Statement TT) -> Parser TT (Maybe (Statement TT))
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (TT -> Block TT -> Statement TT
forall t. t -> Block t -> Statement t
Else (TT -> Block TT -> Statement TT)
-> Parser TT TT -> Parser TT (Block TT -> Statement TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Reserved -> Parser TT TT
res Reserved
Else' Parser TT (Block TT -> Statement TT)
-> Parser TT (Block TT) -> Parser TT (Statement TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (Block TT)
block)
Parser TT (Statement TT)
-> Parser TT (Statement TT) -> Parser TT (Statement TT)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> TT -> ParExpr TT -> Block TT -> Statement TT
forall t. t -> ParExpr t -> Block t -> Statement t
With (TT -> ParExpr TT -> Block TT -> Statement TT)
-> Parser TT TT
-> Parser TT (ParExpr TT -> Block TT -> Statement TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Reserved -> Parser TT TT
res Reserved
With' Parser TT (ParExpr TT -> Block TT -> Statement TT)
-> Parser TT (ParExpr TT) -> Parser TT (Block TT -> Statement TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (ParExpr TT)
parExpr Parser TT (Block TT -> Statement TT)
-> Parser TT (Block TT) -> Parser TT (Statement TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (Block TT)
block
Parser TT (Statement TT)
-> Parser TT (Statement TT) -> Parser TT (Statement TT)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> TT -> Statement TT
forall t. t -> Statement t
Comm (TT -> Statement TT) -> Parser TT TT -> Parser TT (Statement TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser TT TT
comment
Parser TT (Statement TT)
-> Parser TT (Statement TT) -> Parser TT (Statement TT)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Expr TT -> Semicolon TT -> Statement TT
forall t. Expr t -> Semicolon t -> Statement t
Expr (Expr TT -> Semicolon TT -> Statement TT)
-> Parser TT (Expr TT) -> Parser TT (Semicolon TT -> Statement TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser TT (Expr TT)
stmtExpr Parser TT (Semicolon TT -> Statement TT)
-> Parser TT (Semicolon TT) -> Parser TT (Statement TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (Semicolon TT)
semicolon
where
forContent :: P TT (ForContent TT)
forContent :: Parser TT (ForContent TT)
forContent = TT -> Expr TT -> TT -> Expr TT -> ForContent TT
forall t. t -> Expr t -> t -> Expr t -> ForContent t
ForNormal (TT -> Expr TT -> TT -> Expr TT -> ForContent TT)
-> Parser TT TT
-> Parser TT (Expr TT -> TT -> Expr TT -> ForContent TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Char -> Parser TT TT
spc Char
';' Parser TT (Expr TT -> TT -> Expr TT -> ForContent TT)
-> Parser TT (Expr TT)
-> Parser TT (TT -> Expr TT -> ForContent TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (Expr TT)
plzExpr Parser TT (TT -> Expr TT -> ForContent TT)
-> Parser TT TT -> Parser TT (Expr TT -> ForContent TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Char -> Parser TT TT
plzSpc Char
';' Parser TT (Expr TT -> ForContent TT)
-> Parser TT (Expr TT) -> Parser TT (ForContent TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (Expr TT)
plzExpr
Parser TT (ForContent TT)
-> Parser TT (ForContent TT) -> Parser TT (ForContent TT)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> TT -> Expr TT -> ForContent TT
forall t. t -> Expr t -> ForContent t
ForIn (TT -> Expr TT -> ForContent TT)
-> Parser TT TT -> Parser TT (Expr TT -> ForContent TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Reserved -> Parser TT TT
res Reserved
In' Parser TT (Expr TT -> ForContent TT)
-> Parser TT (Expr TT) -> Parser TT (ForContent TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (Expr TT)
plzExpr
Parser TT (ForContent TT)
-> Parser TT (ForContent TT) -> Parser TT (ForContent TT)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> TT -> ForContent TT
forall t. t -> ForContent t
ForErr (TT -> ForContent TT) -> Parser TT TT -> Parser TT (ForContent TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> Parser TT TT -> Parser TT TT
forall s a. Int -> P s a -> P s a
hate Int
1 ((TT -> Bool) -> Parser TT TT
forall s. (s -> Bool) -> Parser s s
symbol (Bool -> TT -> Bool
forall a b. a -> b -> a
const Bool
True))
Parser TT (ForContent TT)
-> Parser TT (ForContent TT) -> Parser TT (ForContent TT)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> TT -> ForContent TT
forall t. t -> ForContent t
ForErr (TT -> ForContent TT) -> Parser TT TT -> Parser TT (ForContent TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> Parser TT TT -> Parser TT TT
forall s a. Int -> P s a -> P s a
hate Int
2 (TT -> Parser TT TT
forall (f :: * -> *) a. Applicative f => a -> f a
pure TT
errorToken)
varDecAss :: P TT (VarDecAss TT)
varDecAss :: P TT (VarDecAss TT)
varDecAss = TT -> Maybe (VarDecAss TT) -> VarDecAss TT
forall t. t -> Maybe (VarDecAss t) -> VarDecAss t
AssBeg (TT -> Maybe (VarDecAss TT) -> VarDecAss TT)
-> Parser TT TT -> Parser TT (Maybe (VarDecAss TT) -> VarDecAss TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser TT TT
name Parser TT (Maybe (VarDecAss TT) -> VarDecAss TT)
-> Parser TT (Maybe (VarDecAss TT)) -> P TT (VarDecAss TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> P TT (VarDecAss TT) -> Parser TT (Maybe (VarDecAss TT))
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (TT -> Expr TT -> VarDecAss TT
forall t. t -> Expr t -> VarDecAss t
AssRst (TT -> Expr TT -> VarDecAss TT)
-> Parser TT TT -> Parser TT (Expr TT -> VarDecAss TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Operator -> Parser TT TT
oper Operator
Assign' Parser TT (Expr TT -> VarDecAss TT)
-> Parser TT (Expr TT) -> P TT (VarDecAss TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (Expr TT)
plzExpr)
block :: P TT (Block TT)
block :: Parser TT (Block TT)
block = TT -> BList (Statement TT) -> TT -> Block TT
forall t. t -> BList (Statement t) -> t -> Block t
Block (TT -> BList (Statement TT) -> TT -> Block TT)
-> Parser TT TT
-> Parser TT (BList (Statement TT) -> TT -> Block TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Char -> Parser TT TT
spc Char
'{' Parser TT (BList (Statement TT) -> TT -> Block TT)
-> P TT (BList (Statement TT)) -> Parser TT (TT -> Block TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (Statement TT) -> P TT (BList (Statement TT))
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many Parser TT (Statement TT)
statement Parser TT (TT -> Block TT) -> Parser TT TT -> Parser TT (Block TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Char -> Parser TT TT
plzSpc Char
'}'
Parser TT (Block TT)
-> Parser TT (Block TT) -> Parser TT (Block TT)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Statement TT -> Block TT
forall t. Statement t -> Block t
BlockOne (Statement TT -> Block TT)
-> Parser TT (Statement TT) -> Parser TT (Block TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> Parser TT (Statement TT) -> Parser TT (Statement TT)
forall s a. Int -> P s a -> P s a
hate Int
1 Parser TT (Statement TT)
statement
Parser TT (Block TT)
-> Parser TT (Block TT) -> Parser TT (Block TT)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> TT -> Block TT
forall t. t -> Block t
BlockErr (TT -> Block TT) -> Parser TT TT -> Parser TT (Block TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> Parser TT TT -> Parser TT TT
forall s a. Int -> P s a -> P s a
hate Int
2 (TT -> Parser TT TT
forall (f :: * -> *) a. Applicative f => a -> f a
pure TT
errorToken)
stmtExpr :: P TT (Expr TT)
stmtExpr :: Parser TT (Expr TT)
stmtExpr = TT -> Maybe (Expr TT) -> Expr TT
forall t. t -> Maybe (Expr t) -> Expr t
ExprSimple (TT -> Maybe (Expr TT) -> Expr TT)
-> Parser TT TT -> Parser TT (Maybe (Expr TT) -> Expr TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser TT TT
simpleTok Parser TT (Maybe (Expr TT) -> Expr TT)
-> Parser TT (Maybe (Expr TT)) -> Parser TT (Expr TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (Expr TT) -> Parser TT (Maybe (Expr TT))
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser TT (Expr TT)
opExpr
Parser TT (Expr TT) -> Parser TT (Expr TT) -> Parser TT (Expr TT)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> TT -> Expr TT -> Expr TT
forall t. t -> Expr t -> Expr t
ExprPrefix (TT -> Expr TT -> Expr TT)
-> Parser TT TT -> Parser TT (Expr TT -> Expr TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser TT TT
preOp Parser TT (Expr TT -> Expr TT)
-> Parser TT (Expr TT) -> Parser TT (Expr TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (Expr TT)
plzExpr
Parser TT (Expr TT) -> Parser TT (Expr TT) -> Parser TT (Expr TT)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> TT -> Expr TT -> Expr TT
forall t. t -> Expr t -> Expr t
ExprNew (TT -> Expr TT -> Expr TT)
-> Parser TT TT -> Parser TT (Expr TT -> Expr TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Reserved -> Parser TT TT
res Reserved
New' Parser TT (Expr TT -> Expr TT)
-> Parser TT (Expr TT) -> Parser TT (Expr TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (Expr TT) -> Parser TT (Expr TT)
forall (f :: * -> *). Failable f => P TT (f TT) -> P TT (f TT)
plz Parser TT (Expr TT)
funCall
Parser TT (Expr TT) -> Parser TT (Expr TT) -> Parser TT (Expr TT)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser TT (Expr TT)
funCall
Parser TT (Expr TT) -> Parser TT (Expr TT) -> Parser TT (Expr TT)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Int -> Parser TT (Expr TT) -> Parser TT (Expr TT)
forall s a. Int -> P s a -> P s a
hate Int
1 (TT -> Expr TT -> TT -> Maybe (Expr TT) -> Expr TT
forall t. t -> Expr t -> t -> Maybe (Expr t) -> Expr t
ExprParen (TT -> Expr TT -> TT -> Maybe (Expr TT) -> Expr TT)
-> Parser TT TT
-> Parser TT (Expr TT -> TT -> Maybe (Expr TT) -> Expr TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Char -> Parser TT TT
spc Char
'(' Parser TT (Expr TT -> TT -> Maybe (Expr TT) -> Expr TT)
-> Parser TT (Expr TT)
-> Parser TT (TT -> Maybe (Expr TT) -> Expr TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (Expr TT)
plzExpr Parser TT (TT -> Maybe (Expr TT) -> Expr TT)
-> Parser TT TT -> Parser TT (Maybe (Expr TT) -> Expr TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Char -> Parser TT TT
plzSpc Char
')'
Parser TT (Maybe (Expr TT) -> Expr TT)
-> Parser TT (Maybe (Expr TT)) -> Parser TT (Expr TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (Expr TT) -> Parser TT (Maybe (Expr TT))
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser TT (Expr TT)
opExpr)
Parser TT (Expr TT) -> Parser TT (Expr TT) -> Parser TT (Expr TT)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> TT -> Expr TT
forall t. t -> Expr t
ExprErr (TT -> Expr TT) -> Parser TT TT -> Parser TT (Expr TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> Parser TT TT -> Parser TT TT
forall s a. Int -> P s a -> P s a
hate Int
2 ((TT -> Bool) -> Parser TT TT
forall s. (s -> Bool) -> Parser s s
symbol (Bool -> TT -> Bool
forall a b. a -> b -> a
const Bool
True))
where
funCall :: P TT (Expr TT)
funCall :: Parser TT (Expr TT)
funCall = TT -> ParExpr TT -> Maybe (Expr TT) -> Expr TT
forall t. t -> ParExpr t -> Maybe (Expr t) -> Expr t
ExprFunCall (TT -> ParExpr TT -> Maybe (Expr TT) -> Expr TT)
-> Parser TT TT
-> Parser TT (ParExpr TT -> Maybe (Expr TT) -> Expr TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser TT TT
name Parser TT (ParExpr TT -> Maybe (Expr TT) -> Expr TT)
-> Parser TT (ParExpr TT) -> Parser TT (Maybe (Expr TT) -> Expr TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (ParExpr TT)
parExpr Parser TT (Maybe (Expr TT) -> Expr TT)
-> Parser TT (Maybe (Expr TT)) -> Parser TT (Expr TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (Expr TT) -> Parser TT (Maybe (Expr TT))
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser TT (Expr TT)
opExpr
opExpr :: P TT (Expr TT)
opExpr :: Parser TT (Expr TT)
opExpr = TT -> Expr TT -> Expr TT
forall t. t -> Expr t -> Expr t
OpExpr (TT -> Expr TT -> Expr TT)
-> Parser TT TT -> Parser TT (Expr TT -> Expr TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser TT TT
inOp Parser TT (Expr TT -> Expr TT)
-> Parser TT (Expr TT) -> Parser TT (Expr TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (Expr TT)
plzExpr
Parser TT (Expr TT) -> Parser TT (Expr TT) -> Parser TT (Expr TT)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> TT -> Expr TT -> TT -> Expr TT -> Expr TT
forall t. t -> Expr t -> t -> Expr t -> Expr t
ExprCond (TT -> Expr TT -> TT -> Expr TT -> Expr TT)
-> Parser TT TT -> Parser TT (Expr TT -> TT -> Expr TT -> Expr TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Char -> Parser TT TT
spc Char
'?' Parser TT (Expr TT -> TT -> Expr TT -> Expr TT)
-> Parser TT (Expr TT) -> Parser TT (TT -> Expr TT -> Expr TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (Expr TT)
plzExpr Parser TT (TT -> Expr TT -> Expr TT)
-> Parser TT TT -> Parser TT (Expr TT -> Expr TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Char -> Parser TT TT
plzSpc Char
':' Parser TT (Expr TT -> Expr TT)
-> Parser TT (Expr TT) -> Parser TT (Expr TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (Expr TT)
plzExpr
Parser TT (Expr TT) -> Parser TT (Expr TT) -> Parser TT (Expr TT)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> TT -> Expr TT
forall t. t -> Expr t
PostExpr (TT -> Expr TT) -> Parser TT TT -> Parser TT (Expr TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser TT TT
postOp
Parser TT (Expr TT) -> Parser TT (Expr TT) -> Parser TT (Expr TT)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser TT (Expr TT)
array
expression :: P TT (Expr TT)
expression :: Parser TT (Expr TT)
expression = TT -> BList (KeyValue TT) -> TT -> Expr TT
forall t. t -> BList (KeyValue t) -> t -> Expr t
ExprObj (TT -> BList (KeyValue TT) -> TT -> Expr TT)
-> Parser TT TT -> Parser TT (BList (KeyValue TT) -> TT -> Expr TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Char -> Parser TT TT
spc Char
'{' Parser TT (BList (KeyValue TT) -> TT -> Expr TT)
-> Parser TT (BList (KeyValue TT)) -> Parser TT (TT -> Expr TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> P TT (KeyValue TT)
keyValue P TT (KeyValue TT)
-> Parser TT TT -> Parser TT (BList (KeyValue TT))
forall (f :: * -> *) a v. Alternative f => f a -> f v -> f [a]
`sepBy` Char -> Parser TT TT
spc Char
',' Parser TT (TT -> Expr TT) -> Parser TT TT -> Parser TT (Expr TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Char -> Parser TT TT
plzSpc Char
'}'
Parser TT (Expr TT) -> Parser TT (Expr TT) -> Parser TT (Expr TT)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> TT -> Parameters TT -> Block TT -> Expr TT
forall t. t -> Parameters t -> Block t -> Expr t
ExprAnonFun (TT -> Parameters TT -> Block TT -> Expr TT)
-> Parser TT TT -> Parser TT (Parameters TT -> Block TT -> Expr TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Reserved -> Parser TT TT
res Reserved
Function' Parser TT (Parameters TT -> Block TT -> Expr TT)
-> Parser TT (Parameters TT) -> Parser TT (Block TT -> Expr TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (Parameters TT)
parameters Parser TT (Block TT -> Expr TT)
-> Parser TT (Block TT) -> Parser TT (Expr TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (Block TT)
block
Parser TT (Expr TT) -> Parser TT (Expr TT) -> Parser TT (Expr TT)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> TT -> Expr TT -> Expr TT
forall t. t -> Expr t -> Expr t
ExprTypeOf (TT -> Expr TT -> Expr TT)
-> Parser TT TT -> Parser TT (Expr TT -> Expr TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Reserved -> Parser TT TT
res Reserved
TypeOf' Parser TT (Expr TT -> Expr TT)
-> Parser TT (Expr TT) -> Parser TT (Expr TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (Expr TT)
plzExpr
Parser TT (Expr TT) -> Parser TT (Expr TT) -> Parser TT (Expr TT)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser TT (Expr TT)
stmtExpr
Parser TT (Expr TT) -> Parser TT (Expr TT) -> Parser TT (Expr TT)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser TT (Expr TT)
array
where
keyValue :: P TT (KeyValue TT)
keyValue :: P TT (KeyValue TT)
keyValue = TT -> TT -> Expr TT -> KeyValue TT
forall t. t -> t -> Expr t -> KeyValue t
KeyValue (TT -> TT -> Expr TT -> KeyValue TT)
-> Parser TT TT -> Parser TT (TT -> Expr TT -> KeyValue TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser TT TT
name Parser TT (TT -> Expr TT -> KeyValue TT)
-> Parser TT TT -> Parser TT (Expr TT -> KeyValue TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Char -> Parser TT TT
plzSpc Char
':' Parser TT (Expr TT -> KeyValue TT)
-> Parser TT (Expr TT) -> P TT (KeyValue TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (Expr TT)
plzExpr
P TT (KeyValue TT) -> P TT (KeyValue TT) -> P TT (KeyValue TT)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> TT -> KeyValue TT
forall t. t -> KeyValue t
KeyValueErr (TT -> KeyValue TT) -> Parser TT TT -> P TT (KeyValue TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> Parser TT TT -> Parser TT TT
forall s a. Int -> P s a -> P s a
hate Int
1 ((TT -> Bool) -> Parser TT TT
forall s. (s -> Bool) -> Parser s s
symbol (Bool -> TT -> Bool
forall a b. a -> b -> a
const Bool
True))
P TT (KeyValue TT) -> P TT (KeyValue TT) -> P TT (KeyValue TT)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> TT -> KeyValue TT
forall t. t -> KeyValue t
KeyValueErr (TT -> KeyValue TT) -> Parser TT TT -> P TT (KeyValue TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> Parser TT TT -> Parser TT TT
forall s a. Int -> P s a -> P s a
hate Int
2 (TT -> Parser TT TT
forall (f :: * -> *) a. Applicative f => a -> f a
pure TT
errorToken)
array :: P TT (Expr TT)
array :: Parser TT (Expr TT)
array = TT -> Maybe (Array TT) -> TT -> Maybe (Expr TT) -> Expr TT
forall t. t -> Maybe (Array t) -> t -> Maybe (Expr t) -> Expr t
ExprArr (TT -> Maybe (Array TT) -> TT -> Maybe (Expr TT) -> Expr TT)
-> Parser TT TT
-> Parser TT (Maybe (Array TT) -> TT -> Maybe (Expr TT) -> Expr TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Char -> Parser TT TT
spc Char
'[' Parser TT (Maybe (Array TT) -> TT -> Maybe (Expr TT) -> Expr TT)
-> Parser TT (Maybe (Array TT))
-> Parser TT (TT -> Maybe (Expr TT) -> Expr TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (Array TT) -> Parser TT (Maybe (Array TT))
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser TT (Array TT)
arrayContents Parser TT (TT -> Maybe (Expr TT) -> Expr TT)
-> Parser TT TT -> Parser TT (Maybe (Expr TT) -> Expr TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Char -> Parser TT TT
plzSpc Char
']'
Parser TT (Maybe (Expr TT) -> Expr TT)
-> Parser TT (Maybe (Expr TT)) -> Parser TT (Expr TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (Expr TT) -> Parser TT (Maybe (Expr TT))
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser TT (Expr TT)
opExpr
where
arrayContents :: P TT (Array TT)
arrayContents :: Parser TT (Array TT)
arrayContents = Expr TT -> Maybe (Array TT) -> Array TT
forall t. Expr t -> Maybe (Array t) -> Array t
ArrCont (Expr TT -> Maybe (Array TT) -> Array TT)
-> Parser TT (Expr TT) -> Parser TT (Maybe (Array TT) -> Array TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser TT (Expr TT)
expression Parser TT (Maybe (Array TT) -> Array TT)
-> Parser TT (Maybe (Array TT)) -> Parser TT (Array TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (Array TT) -> Parser TT (Maybe (Array TT))
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser TT (Array TT)
arrRest
arrRest :: P TT (Array TT)
arrRest :: Parser TT (Array TT)
arrRest = TT -> Array TT -> Maybe (Array TT) -> Array TT
forall t. t -> Array t -> Maybe (Array t) -> Array t
ArrRest (TT -> Array TT -> Maybe (Array TT) -> Array TT)
-> Parser TT TT
-> Parser TT (Array TT -> Maybe (Array TT) -> Array TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Char -> Parser TT TT
spc Char
',' Parser TT (Array TT -> Maybe (Array TT) -> Array TT)
-> Parser TT (Array TT) -> Parser TT (Maybe (Array TT) -> Array TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Parser TT (Array TT)
arrayContents
Parser TT (Array TT)
-> Parser TT (Array TT) -> Parser TT (Array TT)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> TT -> Array TT
forall t. t -> Array t
ArrErr (TT -> Array TT) -> Parser TT TT -> Parser TT (Array TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> Parser TT TT -> Parser TT TT
forall s a. Int -> P s a -> P s a
hate Int
1 ((TT -> Bool) -> Parser TT TT
forall s. (s -> Bool) -> Parser s s
symbol (Bool -> TT -> Bool
forall a b. a -> b -> a
const Bool
True))
Parser TT (Array TT)
-> Parser TT (Array TT) -> Parser TT (Array TT)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> TT -> Array TT
forall t. t -> Array t
ArrErr (TT -> Array TT) -> Parser TT TT -> Parser TT (Array TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> Parser TT TT -> Parser TT TT
forall s a. Int -> P s a -> P s a
hate Int
2 (TT -> Parser TT TT
forall (f :: * -> *) a. Applicative f => a -> f a
pure TT
errorToken))
Parser TT (Maybe (Array TT) -> Array TT)
-> Parser TT (Maybe (Array TT)) -> Parser TT (Array TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (Array TT) -> Parser TT (Maybe (Array TT))
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser TT (Array TT)
arrRest
semicolon :: P TT (Maybe TT)
semicolon :: Parser TT (Semicolon TT)
semicolon = Parser TT TT -> Parser TT (Semicolon TT)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (Parser TT TT -> Parser TT (Semicolon TT))
-> Parser TT TT -> Parser TT (Semicolon TT)
forall a b. (a -> b) -> a -> b
$ Char -> Parser TT TT
spc Char
';'
parameters :: P TT (Parameters TT)
parameters :: Parser TT (Parameters TT)
parameters = TT -> [TT] -> TT -> Parameters TT
forall t. t -> BList t -> t -> Parameters t
Parameters (TT -> [TT] -> TT -> Parameters TT)
-> Parser TT TT -> Parser TT ([TT] -> TT -> Parameters TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Char -> Parser TT TT
spc Char
'(' Parser TT ([TT] -> TT -> Parameters TT)
-> Parser TT [TT] -> Parser TT (TT -> Parameters TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT TT -> Parser TT TT
plzTok Parser TT TT
name Parser TT TT -> Parser TT TT -> Parser TT [TT]
forall (f :: * -> *) a v. Alternative f => f a -> f v -> f [a]
`sepBy` Char -> Parser TT TT
spc Char
',' Parser TT (TT -> Parameters TT)
-> Parser TT TT -> Parser TT (Parameters TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Char -> Parser TT TT
plzSpc Char
')'
Parser TT (Parameters TT)
-> Parser TT (Parameters TT) -> Parser TT (Parameters TT)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> TT -> Parameters TT
forall t. t -> Parameters t
ParErr (TT -> Parameters TT) -> Parser TT TT -> Parser TT (Parameters TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> Parser TT TT -> Parser TT TT
forall s a. Int -> P s a -> P s a
hate Int
1 ((TT -> Bool) -> Parser TT TT
forall s. (s -> Bool) -> Parser s s
symbol (Bool -> TT -> Bool
forall a b. a -> b -> a
const Bool
True))
Parser TT (Parameters TT)
-> Parser TT (Parameters TT) -> Parser TT (Parameters TT)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> TT -> Parameters TT
forall t. t -> Parameters t
ParErr (TT -> Parameters TT) -> Parser TT TT -> Parser TT (Parameters TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> Parser TT TT -> Parser TT TT
forall s a. Int -> P s a -> P s a
hate Int
2 (TT -> Parser TT TT
forall (f :: * -> *) a. Applicative f => a -> f a
pure TT
errorToken)
parExpr :: P TT (ParExpr TT)
parExpr :: Parser TT (ParExpr TT)
parExpr = TT -> [Expr TT] -> TT -> ParExpr TT
forall t. t -> BList (Expr t) -> t -> ParExpr t
ParExpr (TT -> [Expr TT] -> TT -> ParExpr TT)
-> Parser TT TT -> Parser TT ([Expr TT] -> TT -> ParExpr TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Char -> Parser TT TT
spc Char
'(' Parser TT ([Expr TT] -> TT -> ParExpr TT)
-> Parser TT [Expr TT] -> Parser TT (TT -> ParExpr TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (Expr TT)
plzExpr Parser TT (Expr TT) -> Parser TT TT -> Parser TT [Expr TT]
forall (f :: * -> *) a v. Alternative f => f a -> f v -> f [a]
`sepBy` Char -> Parser TT TT
spc Char
',' Parser TT (TT -> ParExpr TT)
-> Parser TT TT -> Parser TT (ParExpr TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Char -> Parser TT TT
plzSpc Char
')'
Parser TT (ParExpr TT)
-> Parser TT (ParExpr TT) -> Parser TT (ParExpr TT)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> TT -> ParExpr TT
forall t. t -> ParExpr t
ParExprErr (TT -> ParExpr TT) -> Parser TT TT -> Parser TT (ParExpr TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> Parser TT TT -> Parser TT TT
forall s a. Int -> P s a -> P s a
hate Int
1 ((TT -> Bool) -> Parser TT TT
forall s. (s -> Bool) -> Parser s s
symbol (Bool -> TT -> Bool
forall a b. a -> b -> a
const Bool
True))
Parser TT (ParExpr TT)
-> Parser TT (ParExpr TT) -> Parser TT (ParExpr TT)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> TT -> ParExpr TT
forall t. t -> ParExpr t
ParExprErr (TT -> ParExpr TT) -> Parser TT TT -> Parser TT (ParExpr TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> Parser TT TT -> Parser TT TT
forall s a. Int -> P s a -> P s a
hate Int
2 (TT -> Parser TT TT
forall (f :: * -> *) a. Applicative f => a -> f a
pure TT
errorToken)
comment :: P TT TT
= (TT -> Bool) -> Parser TT TT
forall s. (s -> Bool) -> Parser s s
symbol (\TT
t -> case TT -> Token
forall t. Tok t -> t
fromTT TT
t of
Comment CommentType
_ -> Bool
True
Token
_ -> Bool
False)
preOp :: P TT TT
preOp :: Parser TT TT
preOp = (TT -> Bool) -> Parser TT TT
forall s. (s -> Bool) -> Parser s s
symbol (\TT
t -> case TT -> Token
forall t. Tok t -> t
fromTT TT
t of
Op Operator
x -> Operator
x Operator -> [Operator] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Operator]
prefixOperators
Token
_ -> Bool
False)
inOp :: P TT TT
inOp :: Parser TT TT
inOp = (TT -> Bool) -> Parser TT TT
forall s. (s -> Bool) -> Parser s s
symbol (\TT
t -> case TT -> Token
forall t. Tok t -> t
fromTT TT
t of
Op Operator
x -> Operator
x Operator -> [Operator] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Operator]
infixOperators
Token
_ -> Bool
False)
postOp :: P TT TT
postOp :: Parser TT TT
postOp = (TT -> Bool) -> Parser TT TT
forall s. (s -> Bool) -> Parser s s
symbol (\TT
t -> case TT -> Token
forall t. Tok t -> t
fromTT TT
t of
Op Operator
x -> Operator
x Operator -> [Operator] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Operator]
postfixOperators
Token
_ -> Bool
False)
opTok :: P TT TT
opTok :: Parser TT TT
opTok = (TT -> Bool) -> Parser TT TT
forall s. (s -> Bool) -> Parser s s
symbol (\TT
t -> case TT -> Token
forall t. Tok t -> t
fromTT TT
t of
Op Operator
_ -> Bool
True
Token
_ -> Bool
False)
simpleTok :: P TT TT
simpleTok :: Parser TT TT
simpleTok = (TT -> Bool) -> Parser TT TT
forall s. (s -> Bool) -> Parser s s
symbol (\TT
t -> case TT -> Token
forall t. Tok t -> t
fromTT TT
t of
Str String
_ -> Bool
True
Number String
_ -> Bool
True
ValidName String
_ -> Bool
True
Const String
_ -> Bool
True
Rex String
_ -> Bool
True
Res Reserved
y -> Reserved
y Reserved -> [Reserved] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Reserved
True', Reserved
False', Reserved
Undefined', Reserved
Null', Reserved
This']
Token
_ -> Bool
False)
strTok :: P TT TT
strTok :: Parser TT TT
strTok = (TT -> Bool) -> Parser TT TT
forall s. (s -> Bool) -> Parser s s
symbol (\TT
t -> case TT -> Token
forall t. Tok t -> t
fromTT TT
t of
Str String
_ -> Bool
True
Token
_ -> Bool
False)
numTok :: P TT TT
numTok :: Parser TT TT
numTok = (TT -> Bool) -> Parser TT TT
forall s. (s -> Bool) -> Parser s s
symbol (\TT
t -> case TT -> Token
forall t. Tok t -> t
fromTT TT
t of
Number String
_ -> Bool
True
Token
_ -> Bool
False)
name :: P TT TT
name :: Parser TT TT
name = (TT -> Bool) -> Parser TT TT
forall s. (s -> Bool) -> Parser s s
symbol (\TT
t -> case TT -> Token
forall t. Tok t -> t
fromTT TT
t of
ValidName String
_ -> Bool
True
Const String
_ -> Bool
True
Token
_ -> Bool
False)
boolean :: P TT TT
boolean :: Parser TT TT
boolean = (TT -> Bool) -> Parser TT TT
forall s. (s -> Bool) -> Parser s s
symbol (\TT
t -> case TT -> Token
forall t. Tok t -> t
fromTT TT
t of
Res Reserved
y -> Reserved
y Reserved -> [Reserved] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Reserved
True', Reserved
False']
Token
_ -> Bool
False)
res :: Reserved -> P TT TT
res :: Reserved -> Parser TT TT
res Reserved
x = (TT -> Bool) -> Parser TT TT
forall s. (s -> Bool) -> Parser s s
symbol (\TT
t -> case TT -> Token
forall t. Tok t -> t
fromTT TT
t of
Res Reserved
y -> Reserved
x Reserved -> Reserved -> Bool
forall a. Eq a => a -> a -> Bool
== Reserved
y
Token
_ -> Bool
False)
spc :: Char -> P TT TT
spc :: Char -> Parser TT TT
spc Char
x = (TT -> Bool) -> Parser TT TT
forall s. (s -> Bool) -> Parser s s
symbol (\TT
t -> case TT -> Token
forall t. Tok t -> t
fromTT TT
t of
Special Char
y -> Char
x Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
y
Token
_ -> Bool
False)
oper :: Operator -> P TT TT
oper :: Operator -> Parser TT TT
oper Operator
x = (TT -> Bool) -> Parser TT TT
forall s. (s -> Bool) -> Parser s s
symbol (\TT
t -> case TT -> Token
forall t. Tok t -> t
fromTT TT
t of
Op Operator
y -> Operator
y Operator -> Operator -> Bool
forall a. Eq a => a -> a -> Bool
== Operator
x
Token
_ -> Bool
False)
plzTok :: P TT TT -> P TT TT
plzTok :: Parser TT TT -> Parser TT TT
plzTok Parser TT TT
x = Parser TT TT
x
Parser TT TT -> Parser TT TT -> Parser TT TT
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Int -> Parser TT TT -> Parser TT TT
forall s a. Int -> P s a -> P s a
hate Int
1 ((TT -> Bool) -> Parser TT TT
forall s. (s -> Bool) -> Parser s s
symbol (Bool -> TT -> Bool
forall a b. a -> b -> a
const Bool
True))
Parser TT TT -> Parser TT TT -> Parser TT TT
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Int -> Parser TT TT -> Parser TT TT
forall s a. Int -> P s a -> P s a
hate Int
2 (TT -> Parser TT TT
forall (f :: * -> *) a. Applicative f => a -> f a
pure TT
errorToken)
plzSpc :: Char -> P TT TT
plzSpc :: Char -> Parser TT TT
plzSpc Char
x = Parser TT TT -> Parser TT TT
plzTok (Char -> Parser TT TT
spc Char
x)
plzExpr :: P TT (Expr TT)
plzExpr :: Parser TT (Expr TT)
plzExpr = Parser TT (Expr TT) -> Parser TT (Expr TT)
forall (f :: * -> *). Failable f => P TT (f TT) -> P TT (f TT)
plz Parser TT (Expr TT)
expression
plz :: Failable f => P TT (f TT) -> P TT (f TT)
plz :: P TT (f TT) -> P TT (f TT)
plz P TT (f TT)
x = P TT (f TT)
x
P TT (f TT) -> P TT (f TT) -> P TT (f TT)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> TT -> f TT
forall (f :: * -> *) t. Failable f => t -> f t
stupid (TT -> f TT) -> Parser TT TT -> P TT (f TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> Parser TT TT -> Parser TT TT
forall s a. Int -> P s a -> P s a
hate Int
1 ((TT -> Bool) -> Parser TT TT
forall s. (s -> Bool) -> Parser s s
symbol (Bool -> TT -> Bool
forall a b. a -> b -> a
const Bool
True))
P TT (f TT) -> P TT (f TT) -> P TT (f TT)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> TT -> f TT
forall (f :: * -> *) t. Failable f => t -> f t
stupid (TT -> f TT) -> Parser TT TT -> P TT (f TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> Parser TT TT -> Parser TT TT
forall s a. Int -> P s a -> P s a
hate Int
2 (TT -> Parser TT TT
forall (f :: * -> *) a. Applicative f => a -> f a
pure TT
errorToken)
anything :: P s TT
anything :: P s TT
anything = P s TT -> P s TT
forall s a. Parser s a -> Parser s a
recoverWith (TT -> P s TT
forall (f :: * -> *) a. Applicative f => a -> f a
pure TT
errorToken)
hate :: Int -> P s a -> P s a
hate :: Int -> P s a -> P s a
hate Int
n = Int -> (P s a -> P s a) -> P s a -> P s a
forall t b. (Eq t, Num t) => t -> (b -> b) -> b -> b
power Int
n P s a -> P s a
forall s a. Parser s a -> Parser s a
recoverWith
where
power :: t -> (b -> b) -> b -> b
power t
0 b -> b
_ = b -> b
forall a. a -> a
id
power t
m b -> b
f = b -> b
f (b -> b) -> (b -> b) -> b -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. t -> (b -> b) -> b -> b
power (t
m t -> t -> t
forall a. Num a => a -> a -> a
- t
1) b -> b
f
fromBlock :: Block t -> [Statement t]
fromBlock :: Block t -> [Statement t]
fromBlock (Block t
_ [Statement t]
x t
_) = [Statement t] -> [Statement t]
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList [Statement t]
x
fromBlock (BlockOne Statement t
x) = [Statement t
x]
fromBlock (BlockErr t
_) = []
firstTok :: Foldable f => f t -> t
firstTok :: f t -> t
firstTok f t
x = [t] -> t
forall a. [a] -> a
head (f t -> [t]
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList f t
x)
errorToken :: TT
errorToken :: TT
errorToken = Token -> TT
forall t. t -> Tok t
toTT (Token -> TT) -> Token -> TT
forall a b. (a -> b) -> a -> b
$ Char -> Token
Special Char
'!'
isError :: TT -> Bool
isError :: TT -> Bool
isError (Tok (Special Char
'!') Size
_ Posn
_) = Bool
True
isError TT
_ = Bool
False
toTT :: t -> Tok t
toTT :: t -> Tok t
toTT = t -> Tok t
forall t. t -> Tok t
tokFromT
fromTT :: Tok t -> t
fromTT :: Tok t -> t
fromTT = Tok t -> t
forall t. Tok t -> t
tokT