{-# 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 _ _ _ x :: Block t
x) = Block t -> [Statement t]
forall t. Block t -> [Statement t]
fromBlock Block t
x
subtrees (While _ _ x :: Block t
x) = Block t -> [Statement t]
forall t. Block t -> [Statement t]
fromBlock Block t
x
subtrees (DoWhile _ x :: Block t
x _ _ _) = Block t -> [Statement t]
forall t. Block t -> [Statement t]
fromBlock Block t
x
subtrees (For _ _ _ _ _ x :: Block t
x) = Block t -> [Statement t]
forall t. Block t -> [Statement t]
fromBlock Block t
x
subtrees (If _ _ x :: Block t
x mb :: 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 _ x :: Block t
x) = Block t -> [Statement t]
forall t. Block t -> [Statement t]
fromBlock Block t
x
subtrees (With _ _ x :: Block t
x) = Block t -> [Statement t]
forall t. Block t -> [Statement t]
fromBlock Block t
x
subtrees _ = []
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 "uniplate not implemented in IsTree (Yi.Syntax.JavaScript.Statement)"
emptyNode :: Statement t
emptyNode = String -> Statement t
forall a. HasCallStack => String -> a
Prelude.error "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 t :: ForContent t
t = case ForContent t
t of
ForErr _ -> Bool
True
_ -> 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 t :: Block t
t = case Block t
t of
BlockErr _ -> Bool
True
_ -> 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 t :: VarDecAss t
t = case VarDecAss t
t of
AssErr _ -> Bool
True
_ -> 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 t :: Parameters t
t = case Parameters t
t of
ParErr _ -> Bool
True
_ -> 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 t :: ParExpr t
t = case ParExpr t
t of
ParExprErr _ -> Bool
True
_ -> 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 t :: Expr t
t = case Expr t
t of
ExprErr _ -> Bool
True
_ -> 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 t :: KeyValue t
t = case KeyValue t
t of
KeyValueErr _ -> Bool
True
_ -> Bool
False
instance Strokable (Statement TT) where
toStrokes :: Statement TT -> Endo [Stroke]
toStrokes (FunDecl f :: TT
f n :: TT
n ps :: Parameters TT
ps blk :: 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 v :: TT
v vs :: BList (VarDecAss TT)
vs sc :: 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 t :: TT
t exp :: Maybe (Expr TT)
exp sc :: 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 w :: TT
w exp :: ParExpr TT
exp blk :: 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 d :: TT
d blk :: Block TT
blk w :: TT
w exp :: ParExpr TT
exp sc :: 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 f :: TT
f l :: TT
l x :: Expr TT
x c :: ForContent TT
c r :: TT
r blk :: 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 i :: TT
i x :: ParExpr TT
x blk :: Block TT
blk e :: 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 e :: TT
e blk :: 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 w :: TT
w x :: ParExpr TT
x blk :: 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 exp :: Expr TT
exp sc :: 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 t :: TT
t) = TT -> Endo [Stroke]
normal TT
t
instance Strokable (ForContent TT) where
toStrokes :: ForContent TT -> Endo [Stroke]
toStrokes (ForNormal s1 :: TT
s1 x2 :: Expr TT
x2 s2 :: TT
s2 x3 :: 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 i :: TT
i x :: 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 t :: TT
t) = TT -> Endo [Stroke]
error TT
t
instance Strokable (Block TT) where
toStrokes :: Block TT -> Endo [Stroke]
toStrokes (BlockOne stmt :: Statement TT
stmt) = Statement TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Statement TT
stmt
toStrokes (Block l :: TT
l stmts :: BList (Statement TT)
stmts r :: 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 t :: TT
t) = TT -> Endo [Stroke]
error TT
t
instance Strokable (VarDecAss TT) where
toStrokes :: VarDecAss TT -> Endo [Stroke]
toStrokes (AssBeg t :: TT
t x :: 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 t :: TT
t exp :: 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 t :: TT
t) = TT -> Endo [Stroke]
error TT
t
instance Strokable (Expr TT) where
toStrokes :: Expr TT -> Endo [Stroke]
toStrokes (ExprSimple x :: TT
x exp :: 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 l :: TT
l kvs :: BList (KeyValue TT)
kvs r :: 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 t :: TT
t exp :: 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 t :: TT
t x :: 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 l :: TT
l exp :: Expr TT
exp r :: TT
r op :: 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 f :: TT
f ps :: Parameters TT
ps blk :: 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 t :: TT
t x :: 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 n :: TT
n x :: ParExpr TT
x m :: 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 op :: TT
op exp :: 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 t :: TT
t) = TT -> Endo [Stroke]
normal TT
t
toStrokes (ExprCond a :: TT
a x :: Expr TT
x b :: TT
b y :: 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 l :: TT
l x :: Maybe (Array TT)
x r :: TT
r m :: 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 t :: TT
t) = TT -> Endo [Stroke]
error TT
t
instance Strokable (Parameters TT) where
toStrokes :: Parameters TT -> Endo [Stroke]
toStrokes (Parameters l :: TT
l ps :: [TT]
ps r :: 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 t :: TT
t) = TT -> Endo [Stroke]
error TT
t
instance Strokable (ParExpr TT) where
toStrokes :: ParExpr TT -> Endo [Stroke]
toStrokes (ParExpr l :: TT
l xs :: [Expr TT]
xs r :: 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 t :: TT
t) = TT -> Endo [Stroke]
error TT
t
instance Strokable (KeyValue TT) where
toStrokes :: KeyValue TT -> Endo [Stroke]
toStrokes (KeyValue n :: TT
n c :: TT
c exp :: 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 t :: TT
t) = TT -> Endo [Stroke]
error TT
t
instance Strokable (Tok Token) where
toStrokes :: TT -> Endo [Stroke]
toStrokes t :: 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 x :: Expr TT
x m :: 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 c :: TT
c a :: Array TT
a m :: 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 t :: 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 f :: t -> a
f x :: 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 style :: 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 xs :: [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 xs :: [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 t0 :: BList (Statement TT)
t0 _point :: Point
_point _begin :: Point
_begin _end :: Point
_end = Text -> [Stroke] -> [Stroke]
forall a. Text -> a -> a
trace ('\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 ',' 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 '(' 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 ')' 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 ';' 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 ';' 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 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 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 '{' 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 '}'
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 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 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 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 '(' 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 ')'
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 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 '?' 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 ':' 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 '{' 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 ',' 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 '}'
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 ':' 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 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 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 '[' 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 ']'
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 ',' 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 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 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 ';'
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 '(' 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 ',' 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 ')'
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 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 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 '(' 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 ',' 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 ')'
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 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 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 (\t :: TT
t -> case TT -> Token
forall t. Tok t -> t
fromTT TT
t of
Comment _ -> Bool
True
_ -> Bool
False)
preOp :: P TT TT
preOp :: Parser TT TT
preOp = (TT -> Bool) -> Parser TT TT
forall s. (s -> Bool) -> Parser s s
symbol (\t :: TT
t -> case TT -> Token
forall t. Tok t -> t
fromTT TT
t of
Op x :: Operator
x -> Operator
x Operator -> [Operator] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Operator]
prefixOperators
_ -> Bool
False)
inOp :: P TT TT
inOp :: Parser TT TT
inOp = (TT -> Bool) -> Parser TT TT
forall s. (s -> Bool) -> Parser s s
symbol (\t :: TT
t -> case TT -> Token
forall t. Tok t -> t
fromTT TT
t of
Op x :: Operator
x -> Operator
x Operator -> [Operator] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Operator]
infixOperators
_ -> Bool
False)
postOp :: P TT TT
postOp :: Parser TT TT
postOp = (TT -> Bool) -> Parser TT TT
forall s. (s -> Bool) -> Parser s s
symbol (\t :: TT
t -> case TT -> Token
forall t. Tok t -> t
fromTT TT
t of
Op x :: Operator
x -> Operator
x Operator -> [Operator] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Operator]
postfixOperators
_ -> Bool
False)
opTok :: P TT TT
opTok :: Parser TT TT
opTok = (TT -> Bool) -> Parser TT TT
forall s. (s -> Bool) -> Parser s s
symbol (\t :: TT
t -> case TT -> Token
forall t. Tok t -> t
fromTT TT
t of
Op _ -> Bool
True
_ -> Bool
False)
simpleTok :: P TT TT
simpleTok :: Parser TT TT
simpleTok = (TT -> Bool) -> Parser TT TT
forall s. (s -> Bool) -> Parser s s
symbol (\t :: TT
t -> case TT -> Token
forall t. Tok t -> t
fromTT TT
t of
Str _ -> Bool
True
Number _ -> Bool
True
ValidName _ -> Bool
True
Const _ -> Bool
True
Rex _ -> Bool
True
Res y :: 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']
_ -> Bool
False)
strTok :: P TT TT
strTok :: Parser TT TT
strTok = (TT -> Bool) -> Parser TT TT
forall s. (s -> Bool) -> Parser s s
symbol (\t :: TT
t -> case TT -> Token
forall t. Tok t -> t
fromTT TT
t of
Str _ -> Bool
True
_ -> Bool
False)
numTok :: P TT TT
numTok :: Parser TT TT
numTok = (TT -> Bool) -> Parser TT TT
forall s. (s -> Bool) -> Parser s s
symbol (\t :: TT
t -> case TT -> Token
forall t. Tok t -> t
fromTT TT
t of
Number _ -> Bool
True
_ -> Bool
False)
name :: P TT TT
name :: Parser TT TT
name = (TT -> Bool) -> Parser TT TT
forall s. (s -> Bool) -> Parser s s
symbol (\t :: TT
t -> case TT -> Token
forall t. Tok t -> t
fromTT TT
t of
ValidName _ -> Bool
True
Const _ -> Bool
True
_ -> Bool
False)
boolean :: P TT TT
boolean :: Parser TT TT
boolean = (TT -> Bool) -> Parser TT TT
forall s. (s -> Bool) -> Parser s s
symbol (\t :: TT
t -> case TT -> Token
forall t. Tok t -> t
fromTT TT
t of
Res y :: Reserved
y -> Reserved
y Reserved -> [Reserved] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Reserved
True', Reserved
False']
_ -> Bool
False)
res :: Reserved -> P TT TT
res :: Reserved -> Parser TT TT
res x :: Reserved
x = (TT -> Bool) -> Parser TT TT
forall s. (s -> Bool) -> Parser s s
symbol (\t :: TT
t -> case TT -> Token
forall t. Tok t -> t
fromTT TT
t of
Res y :: Reserved
y -> Reserved
x Reserved -> Reserved -> Bool
forall a. Eq a => a -> a -> Bool
== Reserved
y
_ -> Bool
False)
spc :: Char -> P TT TT
spc :: Char -> Parser TT TT
spc x :: Char
x = (TT -> Bool) -> Parser TT TT
forall s. (s -> Bool) -> Parser s s
symbol (\t :: TT
t -> case TT -> Token
forall t. Tok t -> t
fromTT TT
t of
Special y :: Char
y -> Char
x Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
y
_ -> Bool
False)
oper :: Operator -> P TT TT
oper :: Operator -> Parser TT TT
oper x :: Operator
x = (TT -> Bool) -> Parser TT TT
forall s. (s -> Bool) -> Parser s s
symbol (\t :: TT
t -> case TT -> Token
forall t. Tok t -> t
fromTT TT
t of
Op y :: Operator
y -> Operator
y Operator -> Operator -> Bool
forall a. Eq a => a -> a -> Bool
== Operator
x
_ -> Bool
False)
plzTok :: P TT TT -> P TT TT
plzTok :: Parser TT TT -> Parser TT TT
plzTok x :: 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 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 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 x :: 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 x :: 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 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 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 n :: 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 0 _ = b -> b
forall a. a -> a
id
power m :: t
m f :: 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
- 1) b -> b
f
fromBlock :: Block t -> [Statement t]
fromBlock :: Block t -> [Statement t]
fromBlock (Block _ x :: [Statement t]
x _) = [Statement t] -> [Statement t]
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList [Statement t]
x
fromBlock (BlockOne x :: Statement t
x) = [Statement t
x]
fromBlock (BlockErr _) = []
firstTok :: Foldable f => f t -> t
firstTok :: f t -> t
firstTok x :: 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 '!'
isError :: TT -> Bool
isError :: TT -> Bool
isError (Tok (Special '!') _ _) = Bool
True
isError _ = 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