{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveFoldable     #-}
{-# LANGUAGE FlexibleInstances  #-}
{-# OPTIONS_HADDOCK show-extensions #-}

-- |
-- Module      :  Yi.Syntax.JavaScript
-- License     :  GPL-2
-- Maintainer  :  yi-devel@googlegroups.com
-- Stability   :  experimental
-- Portability :  portable
--
-- Parser for the JavaScript language as described at
-- <http://publications.lib.chalmers.se/records/fulltext/112284.pdf Dogan 2009>.
--
-- The mode using this parser can be found at "Yi.Mode.JavaScript".

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)

-- * Data types, classes and instances

-- | Instances of @Strokable@ are datatypes which can be syntax highlighted.
class Strokable a where
    toStrokes :: a -> Endo [Stroke]

-- | Instances of @Failable@ can represent failure.  This is a useful class for
--   future work, since then we can make stroking much easier.
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)

-- | Represents either a variable name or a variable name assigned to an
--   expression.  @AssBeg@ is a variable name /maybe/ followed by an assignment.
--   @AssRst@ is an equals sign and an expression.  @(AssBeg 'x' (Just (AssRst
--   '=' '5')))@ means @x = 5@.
data VarDecAss t = AssBeg t (Maybe (VarDecAss t))
                 | AssRst t (Expr t)
                 | AssErr t
                   deriving (Int -> VarDecAss t -> ShowS
[VarDecAss t] -> ShowS
VarDecAss t -> String
(Int -> VarDecAss t -> ShowS)
-> (VarDecAss t -> String)
-> ([VarDecAss t] -> ShowS)
-> Show (VarDecAss t)
forall t. Show t => Int -> VarDecAss t -> ShowS
forall t. Show t => [VarDecAss t] -> ShowS
forall t. Show t => VarDecAss t -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [VarDecAss t] -> ShowS
$cshowList :: forall t. Show t => [VarDecAss t] -> ShowS
show :: VarDecAss t -> String
$cshow :: forall t. Show t => VarDecAss t -> String
showsPrec :: Int -> VarDecAss t -> ShowS
$cshowsPrec :: forall t. Show t => Int -> VarDecAss t -> ShowS
Show, Typeable (VarDecAss t)
DataType
Constr
Typeable (VarDecAss t)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> VarDecAss t -> c (VarDecAss t))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (VarDecAss t))
-> (VarDecAss t -> Constr)
-> (VarDecAss t -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (VarDecAss t)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (VarDecAss t)))
-> ((forall b. Data b => b -> b) -> VarDecAss t -> VarDecAss t)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> VarDecAss t -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> VarDecAss t -> r)
-> (forall u. (forall d. Data d => d -> u) -> VarDecAss t -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> VarDecAss t -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> VarDecAss t -> m (VarDecAss t))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> VarDecAss t -> m (VarDecAss t))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> VarDecAss t -> m (VarDecAss t))
-> Data (VarDecAss t)
VarDecAss t -> DataType
VarDecAss t -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (VarDecAss t))
(forall b. Data b => b -> b) -> VarDecAss t -> VarDecAss t
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> VarDecAss t -> c (VarDecAss t)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (VarDecAss t)
forall t. Data t => Typeable (VarDecAss t)
forall t. Data t => VarDecAss t -> DataType
forall t. Data t => VarDecAss t -> Constr
forall t.
Data t =>
(forall b. Data b => b -> b) -> VarDecAss t -> VarDecAss t
forall t u.
Data t =>
Int -> (forall d. Data d => d -> u) -> VarDecAss t -> u
forall t u.
Data t =>
(forall d. Data d => d -> u) -> VarDecAss t -> [u]
forall t r r'.
Data t =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> VarDecAss t -> r
forall t r r'.
Data t =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> VarDecAss t -> r
forall t (m :: * -> *).
(Data t, Monad m) =>
(forall d. Data d => d -> m d) -> VarDecAss t -> m (VarDecAss t)
forall t (m :: * -> *).
(Data t, MonadPlus m) =>
(forall d. Data d => d -> m d) -> VarDecAss t -> m (VarDecAss t)
forall t (c :: * -> *).
Data t =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (VarDecAss t)
forall t (c :: * -> *).
Data t =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> VarDecAss t -> c (VarDecAss t)
forall t (t :: * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (VarDecAss t))
forall t (t :: * -> * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (VarDecAss t))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> VarDecAss t -> u
forall u. (forall d. Data d => d -> u) -> VarDecAss t -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> VarDecAss t -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> VarDecAss t -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> VarDecAss t -> m (VarDecAss t)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> VarDecAss t -> m (VarDecAss t)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (VarDecAss t)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> VarDecAss t -> c (VarDecAss t)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (VarDecAss t))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (VarDecAss t))
$cAssErr :: Constr
$cAssRst :: Constr
$cAssBeg :: Constr
$tVarDecAss :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> VarDecAss t -> m (VarDecAss t)
$cgmapMo :: forall t (m :: * -> *).
(Data t, MonadPlus m) =>
(forall d. Data d => d -> m d) -> VarDecAss t -> m (VarDecAss t)
gmapMp :: (forall d. Data d => d -> m d) -> VarDecAss t -> m (VarDecAss t)
$cgmapMp :: forall t (m :: * -> *).
(Data t, MonadPlus m) =>
(forall d. Data d => d -> m d) -> VarDecAss t -> m (VarDecAss t)
gmapM :: (forall d. Data d => d -> m d) -> VarDecAss t -> m (VarDecAss t)
$cgmapM :: forall t (m :: * -> *).
(Data t, Monad m) =>
(forall d. Data d => d -> m d) -> VarDecAss t -> m (VarDecAss t)
gmapQi :: Int -> (forall d. Data d => d -> u) -> VarDecAss t -> u
$cgmapQi :: forall t u.
Data t =>
Int -> (forall d. Data d => d -> u) -> VarDecAss t -> u
gmapQ :: (forall d. Data d => d -> u) -> VarDecAss t -> [u]
$cgmapQ :: forall t u.
Data t =>
(forall d. Data d => d -> u) -> VarDecAss t -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> VarDecAss t -> r
$cgmapQr :: forall t r r'.
Data t =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> VarDecAss t -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> VarDecAss t -> r
$cgmapQl :: forall t r r'.
Data t =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> VarDecAss t -> r
gmapT :: (forall b. Data b => b -> b) -> VarDecAss t -> VarDecAss t
$cgmapT :: forall t.
Data t =>
(forall b. Data b => b -> b) -> VarDecAss t -> VarDecAss t
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (VarDecAss t))
$cdataCast2 :: forall t (t :: * -> * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (VarDecAss t))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (VarDecAss t))
$cdataCast1 :: forall t (t :: * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (VarDecAss t))
dataTypeOf :: VarDecAss t -> DataType
$cdataTypeOf :: forall t. Data t => VarDecAss t -> DataType
toConstr :: VarDecAss t -> Constr
$ctoConstr :: forall t. Data t => VarDecAss t -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (VarDecAss t)
$cgunfold :: forall t (c :: * -> *).
Data t =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (VarDecAss t)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> VarDecAss t -> c (VarDecAss t)
$cgfoldl :: forall t (c :: * -> *).
Data t =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> VarDecAss t -> c (VarDecAss t)
$cp1Data :: forall t. Data t => Typeable (VarDecAss t)
Data, Typeable, VarDecAss a -> Bool
(a -> m) -> VarDecAss a -> m
(a -> b -> b) -> b -> VarDecAss a -> b
(forall m. Monoid m => VarDecAss m -> m)
-> (forall m a. Monoid m => (a -> m) -> VarDecAss a -> m)
-> (forall m a. Monoid m => (a -> m) -> VarDecAss a -> m)
-> (forall a b. (a -> b -> b) -> b -> VarDecAss a -> b)
-> (forall a b. (a -> b -> b) -> b -> VarDecAss a -> b)
-> (forall b a. (b -> a -> b) -> b -> VarDecAss a -> b)
-> (forall b a. (b -> a -> b) -> b -> VarDecAss a -> b)
-> (forall a. (a -> a -> a) -> VarDecAss a -> a)
-> (forall a. (a -> a -> a) -> VarDecAss a -> a)
-> (forall a. VarDecAss a -> [a])
-> (forall a. VarDecAss a -> Bool)
-> (forall a. VarDecAss a -> Int)
-> (forall a. Eq a => a -> VarDecAss a -> Bool)
-> (forall a. Ord a => VarDecAss a -> a)
-> (forall a. Ord a => VarDecAss a -> a)
-> (forall a. Num a => VarDecAss a -> a)
-> (forall a. Num a => VarDecAss a -> a)
-> Foldable VarDecAss
forall a. Eq a => a -> VarDecAss a -> Bool
forall a. Num a => VarDecAss a -> a
forall a. Ord a => VarDecAss a -> a
forall m. Monoid m => VarDecAss m -> m
forall a. VarDecAss a -> Bool
forall a. VarDecAss a -> Int
forall a. VarDecAss a -> [a]
forall a. (a -> a -> a) -> VarDecAss a -> a
forall m a. Monoid m => (a -> m) -> VarDecAss a -> m
forall b a. (b -> a -> b) -> b -> VarDecAss a -> b
forall a b. (a -> b -> b) -> b -> VarDecAss a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: VarDecAss a -> a
$cproduct :: forall a. Num a => VarDecAss a -> a
sum :: VarDecAss a -> a
$csum :: forall a. Num a => VarDecAss a -> a
minimum :: VarDecAss a -> a
$cminimum :: forall a. Ord a => VarDecAss a -> a
maximum :: VarDecAss a -> a
$cmaximum :: forall a. Ord a => VarDecAss a -> a
elem :: a -> VarDecAss a -> Bool
$celem :: forall a. Eq a => a -> VarDecAss a -> Bool
length :: VarDecAss a -> Int
$clength :: forall a. VarDecAss a -> Int
null :: VarDecAss a -> Bool
$cnull :: forall a. VarDecAss a -> Bool
toList :: VarDecAss a -> [a]
$ctoList :: forall a. VarDecAss a -> [a]
foldl1 :: (a -> a -> a) -> VarDecAss a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> VarDecAss a -> a
foldr1 :: (a -> a -> a) -> VarDecAss a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> VarDecAss a -> a
foldl' :: (b -> a -> b) -> b -> VarDecAss a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> VarDecAss a -> b
foldl :: (b -> a -> b) -> b -> VarDecAss a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> VarDecAss a -> b
foldr' :: (a -> b -> b) -> b -> VarDecAss a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> VarDecAss a -> b
foldr :: (a -> b -> b) -> b -> VarDecAss a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> VarDecAss a -> b
foldMap' :: (a -> m) -> VarDecAss a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> VarDecAss a -> m
foldMap :: (a -> m) -> VarDecAss a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> VarDecAss a -> m
fold :: VarDecAss m -> m
$cfold :: forall m. Monoid m => VarDecAss m -> m
Foldable)

data Expr t = ExprObj t (BList (KeyValue t)) t
            | ExprPrefix t (Expr t)
            | ExprNew t (Expr t)
            | ExprSimple t (Maybe (Expr t))
            | ExprParen t (Expr t) t (Maybe (Expr t))
            | ExprAnonFun t (Parameters t) (Block t)
            | ExprTypeOf t (Expr t)
            | ExprFunCall t (ParExpr t) (Maybe (Expr t))
            | OpExpr t (Expr t)
            | ExprCond t (Expr t) t (Expr t)
            | ExprArr t (Maybe (Array t)) t (Maybe (Expr t))
            | PostExpr t
            | ExprErr t
              deriving (Int -> Expr t -> ShowS
[Expr t] -> ShowS
Expr t -> String
(Int -> Expr t -> ShowS)
-> (Expr t -> String) -> ([Expr t] -> ShowS) -> Show (Expr t)
forall t. Show t => Int -> Expr t -> ShowS
forall t. Show t => [Expr t] -> ShowS
forall t. Show t => Expr t -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Expr t] -> ShowS
$cshowList :: forall t. Show t => [Expr t] -> ShowS
show :: Expr t -> String
$cshow :: forall t. Show t => Expr t -> String
showsPrec :: Int -> Expr t -> ShowS
$cshowsPrec :: forall t. Show t => Int -> Expr t -> ShowS
Show, Typeable (Expr t)
DataType
Constr
Typeable (Expr t)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Expr t -> c (Expr t))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Expr t))
-> (Expr t -> Constr)
-> (Expr t -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Expr t)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Expr t)))
-> ((forall b. Data b => b -> b) -> Expr t -> Expr t)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Expr t -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Expr t -> r)
-> (forall u. (forall d. Data d => d -> u) -> Expr t -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Expr t -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Expr t -> m (Expr t))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Expr t -> m (Expr t))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Expr t -> m (Expr t))
-> Data (Expr t)
Expr t -> DataType
Expr t -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (Expr t))
(forall b. Data b => b -> b) -> Expr t -> Expr t
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Expr t -> c (Expr t)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Expr t)
forall t. Data t => Typeable (Expr t)
forall t. Data t => Expr t -> DataType
forall t. Data t => Expr t -> Constr
forall t.
Data t =>
(forall b. Data b => b -> b) -> Expr t -> Expr t
forall t u.
Data t =>
Int -> (forall d. Data d => d -> u) -> Expr t -> u
forall t u. Data t => (forall d. Data d => d -> u) -> Expr t -> [u]
forall t r r'.
Data t =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Expr t -> r
forall t r r'.
Data t =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Expr t -> r
forall t (m :: * -> *).
(Data t, Monad m) =>
(forall d. Data d => d -> m d) -> Expr t -> m (Expr t)
forall t (m :: * -> *).
(Data t, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Expr t -> m (Expr t)
forall t (c :: * -> *).
Data t =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Expr t)
forall t (c :: * -> *).
Data t =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Expr t -> c (Expr t)
forall t (t :: * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Expr t))
forall t (t :: * -> * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Expr t))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Expr t -> u
forall u. (forall d. Data d => d -> u) -> Expr t -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Expr t -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Expr t -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Expr t -> m (Expr t)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Expr t -> m (Expr t)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Expr t)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Expr t -> c (Expr t)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Expr t))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Expr t))
$cExprErr :: Constr
$cPostExpr :: Constr
$cExprArr :: Constr
$cExprCond :: Constr
$cOpExpr :: Constr
$cExprFunCall :: Constr
$cExprTypeOf :: Constr
$cExprAnonFun :: Constr
$cExprParen :: Constr
$cExprSimple :: Constr
$cExprNew :: Constr
$cExprPrefix :: Constr
$cExprObj :: Constr
$tExpr :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Expr t -> m (Expr t)
$cgmapMo :: forall t (m :: * -> *).
(Data t, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Expr t -> m (Expr t)
gmapMp :: (forall d. Data d => d -> m d) -> Expr t -> m (Expr t)
$cgmapMp :: forall t (m :: * -> *).
(Data t, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Expr t -> m (Expr t)
gmapM :: (forall d. Data d => d -> m d) -> Expr t -> m (Expr t)
$cgmapM :: forall t (m :: * -> *).
(Data t, Monad m) =>
(forall d. Data d => d -> m d) -> Expr t -> m (Expr t)
gmapQi :: Int -> (forall d. Data d => d -> u) -> Expr t -> u
$cgmapQi :: forall t u.
Data t =>
Int -> (forall d. Data d => d -> u) -> Expr t -> u
gmapQ :: (forall d. Data d => d -> u) -> Expr t -> [u]
$cgmapQ :: forall t u. Data t => (forall d. Data d => d -> u) -> Expr t -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Expr t -> r
$cgmapQr :: forall t r r'.
Data t =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Expr t -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Expr t -> r
$cgmapQl :: forall t r r'.
Data t =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Expr t -> r
gmapT :: (forall b. Data b => b -> b) -> Expr t -> Expr t
$cgmapT :: forall t.
Data t =>
(forall b. Data b => b -> b) -> Expr t -> Expr t
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Expr t))
$cdataCast2 :: forall t (t :: * -> * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Expr t))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (Expr t))
$cdataCast1 :: forall t (t :: * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Expr t))
dataTypeOf :: Expr t -> DataType
$cdataTypeOf :: forall t. Data t => Expr t -> DataType
toConstr :: Expr t -> Constr
$ctoConstr :: forall t. Data t => Expr t -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Expr t)
$cgunfold :: forall t (c :: * -> *).
Data t =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Expr t)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Expr t -> c (Expr t)
$cgfoldl :: forall t (c :: * -> *).
Data t =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Expr t -> c (Expr t)
$cp1Data :: forall t. Data t => Typeable (Expr t)
Data, Typeable, Expr a -> Bool
(a -> m) -> Expr a -> m
(a -> b -> b) -> b -> Expr a -> b
(forall m. Monoid m => Expr m -> m)
-> (forall m a. Monoid m => (a -> m) -> Expr a -> m)
-> (forall m a. Monoid m => (a -> m) -> Expr a -> m)
-> (forall a b. (a -> b -> b) -> b -> Expr a -> b)
-> (forall a b. (a -> b -> b) -> b -> Expr a -> b)
-> (forall b a. (b -> a -> b) -> b -> Expr a -> b)
-> (forall b a. (b -> a -> b) -> b -> Expr a -> b)
-> (forall a. (a -> a -> a) -> Expr a -> a)
-> (forall a. (a -> a -> a) -> Expr a -> a)
-> (forall a. Expr a -> [a])
-> (forall a. Expr a -> Bool)
-> (forall a. Expr a -> Int)
-> (forall a. Eq a => a -> Expr a -> Bool)
-> (forall a. Ord a => Expr a -> a)
-> (forall a. Ord a => Expr a -> a)
-> (forall a. Num a => Expr a -> a)
-> (forall a. Num a => Expr a -> a)
-> Foldable Expr
forall a. Eq a => a -> Expr a -> Bool
forall a. Num a => Expr a -> a
forall a. Ord a => Expr a -> a
forall m. Monoid m => Expr m -> m
forall a. Expr a -> Bool
forall a. Expr a -> Int
forall a. Expr a -> [a]
forall a. (a -> a -> a) -> Expr a -> a
forall m a. Monoid m => (a -> m) -> Expr a -> m
forall b a. (b -> a -> b) -> b -> Expr a -> b
forall a b. (a -> b -> b) -> b -> Expr a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: Expr a -> a
$cproduct :: forall a. Num a => Expr a -> a
sum :: Expr a -> a
$csum :: forall a. Num a => Expr a -> a
minimum :: Expr a -> a
$cminimum :: forall a. Ord a => Expr a -> a
maximum :: Expr a -> a
$cmaximum :: forall a. Ord a => Expr a -> a
elem :: a -> Expr a -> Bool
$celem :: forall a. Eq a => a -> Expr a -> Bool
length :: Expr a -> Int
$clength :: forall a. Expr a -> Int
null :: Expr a -> Bool
$cnull :: forall a. Expr a -> Bool
toList :: Expr a -> [a]
$ctoList :: forall a. Expr a -> [a]
foldl1 :: (a -> a -> a) -> Expr a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Expr a -> a
foldr1 :: (a -> a -> a) -> Expr a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Expr a -> a
foldl' :: (b -> a -> b) -> b -> Expr a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Expr a -> b
foldl :: (b -> a -> b) -> b -> Expr a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Expr a -> b
foldr' :: (a -> b -> b) -> b -> Expr a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Expr a -> b
foldr :: (a -> b -> b) -> b -> Expr a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> Expr a -> b
foldMap' :: (a -> m) -> Expr a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Expr a -> m
foldMap :: (a -> m) -> Expr a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Expr a -> m
fold :: Expr m -> m
$cfold :: forall m. Monoid m => Expr m -> m
Foldable)

data Array t = ArrCont (Expr t) (Maybe (Array t))
             | ArrRest t (Array t) (Maybe (Array t))
             | ArrErr t
               deriving (Int -> Array t -> ShowS
[Array t] -> ShowS
Array t -> String
(Int -> Array t -> ShowS)
-> (Array t -> String) -> ([Array t] -> ShowS) -> Show (Array t)
forall t. Show t => Int -> Array t -> ShowS
forall t. Show t => [Array t] -> ShowS
forall t. Show t => Array t -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Array t] -> ShowS
$cshowList :: forall t. Show t => [Array t] -> ShowS
show :: Array t -> String
$cshow :: forall t. Show t => Array t -> String
showsPrec :: Int -> Array t -> ShowS
$cshowsPrec :: forall t. Show t => Int -> Array t -> ShowS
Show, Typeable (Array t)
DataType
Constr
Typeable (Array t)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Array t -> c (Array t))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Array t))
-> (Array t -> Constr)
-> (Array t -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Array t)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Array t)))
-> ((forall b. Data b => b -> b) -> Array t -> Array t)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Array t -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Array t -> r)
-> (forall u. (forall d. Data d => d -> u) -> Array t -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Array t -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Array t -> m (Array t))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Array t -> m (Array t))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Array t -> m (Array t))
-> Data (Array t)
Array t -> DataType
Array t -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (Array t))
(forall b. Data b => b -> b) -> Array t -> Array t
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Array t -> c (Array t)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Array t)
forall t. Data t => Typeable (Array t)
forall t. Data t => Array t -> DataType
forall t. Data t => Array t -> Constr
forall t.
Data t =>
(forall b. Data b => b -> b) -> Array t -> Array t
forall t u.
Data t =>
Int -> (forall d. Data d => d -> u) -> Array t -> u
forall t u.
Data t =>
(forall d. Data d => d -> u) -> Array t -> [u]
forall t r r'.
Data t =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Array t -> r
forall t r r'.
Data t =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Array t -> r
forall t (m :: * -> *).
(Data t, Monad m) =>
(forall d. Data d => d -> m d) -> Array t -> m (Array t)
forall t (m :: * -> *).
(Data t, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Array t -> m (Array t)
forall t (c :: * -> *).
Data t =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Array t)
forall t (c :: * -> *).
Data t =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Array t -> c (Array t)
forall t (t :: * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Array t))
forall t (t :: * -> * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Array t))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Array t -> u
forall u. (forall d. Data d => d -> u) -> Array t -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Array t -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Array t -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Array t -> m (Array t)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Array t -> m (Array t)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Array t)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Array t -> c (Array t)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Array t))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Array t))
$cArrErr :: Constr
$cArrRest :: Constr
$cArrCont :: Constr
$tArray :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Array t -> m (Array t)
$cgmapMo :: forall t (m :: * -> *).
(Data t, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Array t -> m (Array t)
gmapMp :: (forall d. Data d => d -> m d) -> Array t -> m (Array t)
$cgmapMp :: forall t (m :: * -> *).
(Data t, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Array t -> m (Array t)
gmapM :: (forall d. Data d => d -> m d) -> Array t -> m (Array t)
$cgmapM :: forall t (m :: * -> *).
(Data t, Monad m) =>
(forall d. Data d => d -> m d) -> Array t -> m (Array t)
gmapQi :: Int -> (forall d. Data d => d -> u) -> Array t -> u
$cgmapQi :: forall t u.
Data t =>
Int -> (forall d. Data d => d -> u) -> Array t -> u
gmapQ :: (forall d. Data d => d -> u) -> Array t -> [u]
$cgmapQ :: forall t u.
Data t =>
(forall d. Data d => d -> u) -> Array t -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Array t -> r
$cgmapQr :: forall t r r'.
Data t =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Array t -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Array t -> r
$cgmapQl :: forall t r r'.
Data t =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Array t -> r
gmapT :: (forall b. Data b => b -> b) -> Array t -> Array t
$cgmapT :: forall t.
Data t =>
(forall b. Data b => b -> b) -> Array t -> Array t
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Array t))
$cdataCast2 :: forall t (t :: * -> * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Array t))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (Array t))
$cdataCast1 :: forall t (t :: * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Array t))
dataTypeOf :: Array t -> DataType
$cdataTypeOf :: forall t. Data t => Array t -> DataType
toConstr :: Array t -> Constr
$ctoConstr :: forall t. Data t => Array t -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Array t)
$cgunfold :: forall t (c :: * -> *).
Data t =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Array t)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Array t -> c (Array t)
$cgfoldl :: forall t (c :: * -> *).
Data t =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Array t -> c (Array t)
$cp1Data :: forall t. Data t => Typeable (Array t)
Data, Typeable, Array a -> Bool
(a -> m) -> Array a -> m
(a -> b -> b) -> b -> Array a -> b
(forall m. Monoid m => Array m -> m)
-> (forall m a. Monoid m => (a -> m) -> Array a -> m)
-> (forall m a. Monoid m => (a -> m) -> Array a -> m)
-> (forall a b. (a -> b -> b) -> b -> Array a -> b)
-> (forall a b. (a -> b -> b) -> b -> Array a -> b)
-> (forall b a. (b -> a -> b) -> b -> Array a -> b)
-> (forall b a. (b -> a -> b) -> b -> Array a -> b)
-> (forall a. (a -> a -> a) -> Array a -> a)
-> (forall a. (a -> a -> a) -> Array a -> a)
-> (forall a. Array a -> [a])
-> (forall a. Array a -> Bool)
-> (forall a. Array a -> Int)
-> (forall a. Eq a => a -> Array a -> Bool)
-> (forall a. Ord a => Array a -> a)
-> (forall a. Ord a => Array a -> a)
-> (forall a. Num a => Array a -> a)
-> (forall a. Num a => Array a -> a)
-> Foldable Array
forall a. Eq a => a -> Array a -> Bool
forall a. Num a => Array a -> a
forall a. Ord a => Array a -> a
forall m. Monoid m => Array m -> m
forall a. Array a -> Bool
forall a. Array a -> Int
forall a. Array a -> [a]
forall a. (a -> a -> a) -> Array a -> a
forall m a. Monoid m => (a -> m) -> Array a -> m
forall b a. (b -> a -> b) -> b -> Array a -> b
forall a b. (a -> b -> b) -> b -> Array a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: Array a -> a
$cproduct :: forall a. Num a => Array a -> a
sum :: Array a -> a
$csum :: forall a. Num a => Array a -> a
minimum :: Array a -> a
$cminimum :: forall a. Ord a => Array a -> a
maximum :: Array a -> a
$cmaximum :: forall a. Ord a => Array a -> a
elem :: a -> Array a -> Bool
$celem :: forall a. Eq a => a -> Array a -> Bool
length :: Array a -> Int
$clength :: forall a. Array a -> Int
null :: Array a -> Bool
$cnull :: forall a. Array a -> Bool
toList :: Array a -> [a]
$ctoList :: forall a. Array a -> [a]
foldl1 :: (a -> a -> a) -> Array a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Array a -> a
foldr1 :: (a -> a -> a) -> Array a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Array a -> a
foldl' :: (b -> a -> b) -> b -> Array a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Array a -> b
foldl :: (b -> a -> b) -> b -> Array a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Array a -> b
foldr' :: (a -> b -> b) -> b -> Array a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Array a -> b
foldr :: (a -> b -> b) -> b -> Array a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> Array a -> b
foldMap' :: (a -> m) -> Array a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Array a -> m
foldMap :: (a -> m) -> Array a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Array a -> m
fold :: Array m -> m
$cfold :: forall m. Monoid m => Array m -> m
Foldable)

data KeyValue t = KeyValue t t (Expr t)
                | KeyValueErr t
                  deriving (Int -> KeyValue t -> ShowS
[KeyValue t] -> ShowS
KeyValue t -> String
(Int -> KeyValue t -> ShowS)
-> (KeyValue t -> String)
-> ([KeyValue t] -> ShowS)
-> Show (KeyValue t)
forall t. Show t => Int -> KeyValue t -> ShowS
forall t. Show t => [KeyValue t] -> ShowS
forall t. Show t => KeyValue t -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [KeyValue t] -> ShowS
$cshowList :: forall t. Show t => [KeyValue t] -> ShowS
show :: KeyValue t -> String
$cshow :: forall t. Show t => KeyValue t -> String
showsPrec :: Int -> KeyValue t -> ShowS
$cshowsPrec :: forall t. Show t => Int -> KeyValue t -> ShowS
Show, Typeable (KeyValue t)
DataType
Constr
Typeable (KeyValue t)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> KeyValue t -> c (KeyValue t))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (KeyValue t))
-> (KeyValue t -> Constr)
-> (KeyValue t -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (KeyValue t)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (KeyValue t)))
-> ((forall b. Data b => b -> b) -> KeyValue t -> KeyValue t)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> KeyValue t -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> KeyValue t -> r)
-> (forall u. (forall d. Data d => d -> u) -> KeyValue t -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> KeyValue t -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> KeyValue t -> m (KeyValue t))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> KeyValue t -> m (KeyValue t))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> KeyValue t -> m (KeyValue t))
-> Data (KeyValue t)
KeyValue t -> DataType
KeyValue t -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (KeyValue t))
(forall b. Data b => b -> b) -> KeyValue t -> KeyValue t
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> KeyValue t -> c (KeyValue t)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (KeyValue t)
forall t. Data t => Typeable (KeyValue t)
forall t. Data t => KeyValue t -> DataType
forall t. Data t => KeyValue t -> Constr
forall t.
Data t =>
(forall b. Data b => b -> b) -> KeyValue t -> KeyValue t
forall t u.
Data t =>
Int -> (forall d. Data d => d -> u) -> KeyValue t -> u
forall t u.
Data t =>
(forall d. Data d => d -> u) -> KeyValue t -> [u]
forall t r r'.
Data t =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> KeyValue t -> r
forall t r r'.
Data t =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> KeyValue t -> r
forall t (m :: * -> *).
(Data t, Monad m) =>
(forall d. Data d => d -> m d) -> KeyValue t -> m (KeyValue t)
forall t (m :: * -> *).
(Data t, MonadPlus m) =>
(forall d. Data d => d -> m d) -> KeyValue t -> m (KeyValue t)
forall t (c :: * -> *).
Data t =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (KeyValue t)
forall t (c :: * -> *).
Data t =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> KeyValue t -> c (KeyValue t)
forall t (t :: * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (KeyValue t))
forall t (t :: * -> * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (KeyValue t))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> KeyValue t -> u
forall u. (forall d. Data d => d -> u) -> KeyValue t -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> KeyValue t -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> KeyValue t -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> KeyValue t -> m (KeyValue t)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> KeyValue t -> m (KeyValue t)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (KeyValue t)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> KeyValue t -> c (KeyValue t)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (KeyValue t))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (KeyValue t))
$cKeyValueErr :: Constr
$cKeyValue :: Constr
$tKeyValue :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> KeyValue t -> m (KeyValue t)
$cgmapMo :: forall t (m :: * -> *).
(Data t, MonadPlus m) =>
(forall d. Data d => d -> m d) -> KeyValue t -> m (KeyValue t)
gmapMp :: (forall d. Data d => d -> m d) -> KeyValue t -> m (KeyValue t)
$cgmapMp :: forall t (m :: * -> *).
(Data t, MonadPlus m) =>
(forall d. Data d => d -> m d) -> KeyValue t -> m (KeyValue t)
gmapM :: (forall d. Data d => d -> m d) -> KeyValue t -> m (KeyValue t)
$cgmapM :: forall t (m :: * -> *).
(Data t, Monad m) =>
(forall d. Data d => d -> m d) -> KeyValue t -> m (KeyValue t)
gmapQi :: Int -> (forall d. Data d => d -> u) -> KeyValue t -> u
$cgmapQi :: forall t u.
Data t =>
Int -> (forall d. Data d => d -> u) -> KeyValue t -> u
gmapQ :: (forall d. Data d => d -> u) -> KeyValue t -> [u]
$cgmapQ :: forall t u.
Data t =>
(forall d. Data d => d -> u) -> KeyValue t -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> KeyValue t -> r
$cgmapQr :: forall t r r'.
Data t =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> KeyValue t -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> KeyValue t -> r
$cgmapQl :: forall t r r'.
Data t =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> KeyValue t -> r
gmapT :: (forall b. Data b => b -> b) -> KeyValue t -> KeyValue t
$cgmapT :: forall t.
Data t =>
(forall b. Data b => b -> b) -> KeyValue t -> KeyValue t
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (KeyValue t))
$cdataCast2 :: forall t (t :: * -> * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (KeyValue t))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (KeyValue t))
$cdataCast1 :: forall t (t :: * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (KeyValue t))
dataTypeOf :: KeyValue t -> DataType
$cdataTypeOf :: forall t. Data t => KeyValue t -> DataType
toConstr :: KeyValue t -> Constr
$ctoConstr :: forall t. Data t => KeyValue t -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (KeyValue t)
$cgunfold :: forall t (c :: * -> *).
Data t =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (KeyValue t)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> KeyValue t -> c (KeyValue t)
$cgfoldl :: forall t (c :: * -> *).
Data t =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> KeyValue t -> c (KeyValue t)
$cp1Data :: forall t. Data t => Typeable (KeyValue t)
Data, Typeable, KeyValue a -> Bool
(a -> m) -> KeyValue a -> m
(a -> b -> b) -> b -> KeyValue a -> b
(forall m. Monoid m => KeyValue m -> m)
-> (forall m a. Monoid m => (a -> m) -> KeyValue a -> m)
-> (forall m a. Monoid m => (a -> m) -> KeyValue a -> m)
-> (forall a b. (a -> b -> b) -> b -> KeyValue a -> b)
-> (forall a b. (a -> b -> b) -> b -> KeyValue a -> b)
-> (forall b a. (b -> a -> b) -> b -> KeyValue a -> b)
-> (forall b a. (b -> a -> b) -> b -> KeyValue a -> b)
-> (forall a. (a -> a -> a) -> KeyValue a -> a)
-> (forall a. (a -> a -> a) -> KeyValue a -> a)
-> (forall a. KeyValue a -> [a])
-> (forall a. KeyValue a -> Bool)
-> (forall a. KeyValue a -> Int)
-> (forall a. Eq a => a -> KeyValue a -> Bool)
-> (forall a. Ord a => KeyValue a -> a)
-> (forall a. Ord a => KeyValue a -> a)
-> (forall a. Num a => KeyValue a -> a)
-> (forall a. Num a => KeyValue a -> a)
-> Foldable KeyValue
forall a. Eq a => a -> KeyValue a -> Bool
forall a. Num a => KeyValue a -> a
forall a. Ord a => KeyValue a -> a
forall m. Monoid m => KeyValue m -> m
forall a. KeyValue a -> Bool
forall a. KeyValue a -> Int
forall a. KeyValue a -> [a]
forall a. (a -> a -> a) -> KeyValue a -> a
forall m a. Monoid m => (a -> m) -> KeyValue a -> m
forall b a. (b -> a -> b) -> b -> KeyValue a -> b
forall a b. (a -> b -> b) -> b -> KeyValue a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: KeyValue a -> a
$cproduct :: forall a. Num a => KeyValue a -> a
sum :: KeyValue a -> a
$csum :: forall a. Num a => KeyValue a -> a
minimum :: KeyValue a -> a
$cminimum :: forall a. Ord a => KeyValue a -> a
maximum :: KeyValue a -> a
$cmaximum :: forall a. Ord a => KeyValue a -> a
elem :: a -> KeyValue a -> Bool
$celem :: forall a. Eq a => a -> KeyValue a -> Bool
length :: KeyValue a -> Int
$clength :: forall a. KeyValue a -> Int
null :: KeyValue a -> Bool
$cnull :: forall a. KeyValue a -> Bool
toList :: KeyValue a -> [a]
$ctoList :: forall a. KeyValue a -> [a]
foldl1 :: (a -> a -> a) -> KeyValue a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> KeyValue a -> a
foldr1 :: (a -> a -> a) -> KeyValue a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> KeyValue a -> a
foldl' :: (b -> a -> b) -> b -> KeyValue a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> KeyValue a -> b
foldl :: (b -> a -> b) -> b -> KeyValue a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> KeyValue a -> b
foldr' :: (a -> b -> b) -> b -> KeyValue a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> KeyValue a -> b
foldr :: (a -> b -> b) -> b -> KeyValue a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> KeyValue a -> b
foldMap' :: (a -> m) -> KeyValue a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> KeyValue a -> m
foldMap :: (a -> m) -> KeyValue a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> KeyValue a -> m
fold :: KeyValue m -> m
$cfold :: forall m. Monoid m => KeyValue m -> m
Foldable)


instance IsTree Statement where
    subtrees :: Statement t -> [Statement t]
subtrees (FunDecl t
_ t
_ Parameters t
_ Block t
x) = Block t -> [Statement t]
forall t. Block t -> [Statement t]
fromBlock Block t
x
    subtrees (While t
_ ParExpr t
_ Block t
x) = Block t -> [Statement t]
forall t. Block t -> [Statement t]
fromBlock Block t
x
    subtrees (DoWhile t
_ Block t
x t
_ ParExpr t
_ Semicolon t
_) = Block t -> [Statement t]
forall t. Block t -> [Statement t]
fromBlock Block t
x
    subtrees (For t
_ t
_ Expr t
_ ForContent t
_ t
_ Block t
x) = Block t -> [Statement t]
forall t. Block t -> [Statement t]
fromBlock Block t
x
    subtrees (If t
_ ParExpr t
_ Block t
x Maybe (Statement t)
mb) = Block t -> [Statement t]
forall t. Block t -> [Statement t]
fromBlock Block t
x [Statement t] -> [Statement t] -> [Statement t]
forall a. Semigroup a => a -> a -> a
<> [Statement t]
-> (Statement t -> [Statement t])
-> Maybe (Statement t)
-> [Statement t]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] Statement t -> [Statement t]
forall (tree :: * -> *) t. IsTree tree => tree t -> [tree t]
subtrees Maybe (Statement t)
mb
    subtrees (Else t
_ Block t
x) = Block t -> [Statement t]
forall t. Block t -> [Statement t]
fromBlock Block t
x
    subtrees (With t
_ ParExpr t
_ Block t
x) = Block t -> [Statement t]
forall t. Block t -> [Statement t]
fromBlock Block t
x
    subtrees Statement t
_ = []
    uniplate :: Statement t -> ([Statement t], [Statement t] -> Statement t)
uniplate = String
-> Statement t -> ([Statement t], [Statement t] -> Statement t)
forall a. HasCallStack => String -> a
Prelude.error String
"uniplate not implemented in IsTree (Yi.Syntax.JavaScript.Statement)"
    emptyNode :: Statement t
emptyNode = String -> Statement t
forall a. HasCallStack => String -> a
Prelude.error String
"emptyNode not implemented in IsTree (Yi.Syntax.JavaScript.Statement)"

instance Failable ForContent where
    stupid :: t -> ForContent t
stupid = t -> ForContent t
forall t. t -> ForContent t
ForErr
    hasFailed :: ForContent t -> Bool
hasFailed ForContent t
t = case ForContent t
t of
                    ForErr t
_ -> Bool
True
                    ForContent t
_        -> Bool
False

instance Failable Block where
    stupid :: t -> Block t
stupid = t -> Block t
forall t. t -> Block t
BlockErr
    hasFailed :: Block t -> Bool
hasFailed Block t
t = case Block t
t of
                    BlockErr t
_ -> Bool
True
                    Block t
_          -> Bool
False

instance Failable VarDecAss where
    stupid :: t -> VarDecAss t
stupid = t -> VarDecAss t
forall t. t -> VarDecAss t
AssErr
    hasFailed :: VarDecAss t -> Bool
hasFailed VarDecAss t
t = case VarDecAss t
t of
                    AssErr t
_ -> Bool
True
                    VarDecAss t
_        -> Bool
False

instance Failable Parameters where
    stupid :: t -> Parameters t
stupid = t -> Parameters t
forall t. t -> Parameters t
ParErr
    hasFailed :: Parameters t -> Bool
hasFailed Parameters t
t = case Parameters t
t of
                    ParErr t
_ -> Bool
True
                    Parameters t
_        -> Bool
False

instance Failable ParExpr where
    stupid :: t -> ParExpr t
stupid = t -> ParExpr t
forall t. t -> ParExpr t
ParExprErr
    hasFailed :: ParExpr t -> Bool
hasFailed ParExpr t
t = case ParExpr t
t of
                    ParExprErr t
_ -> Bool
True
                    ParExpr t
_            -> Bool
False

instance Failable Expr where
    stupid :: t -> Expr t
stupid = t -> Expr t
forall t. t -> Expr t
ExprErr
    hasFailed :: Expr t -> Bool
hasFailed Expr t
t = case Expr t
t of
                    ExprErr t
_ -> Bool
True
                    Expr t
_         -> Bool
False

instance Failable KeyValue where
    stupid :: t -> KeyValue t
stupid = t -> KeyValue t
forall t. t -> KeyValue t
KeyValueErr
    hasFailed :: KeyValue t -> Bool
hasFailed KeyValue t
t = case KeyValue t
t of
                    KeyValueErr t
_ -> Bool
True
                    KeyValue t
_             -> Bool
False


-- | TODO: This code is *screaming* for some generic programming.
--
--   TODO: Somehow fix Failable and failStroker to be more "generic".  This will
--   make these instances much nicer and we won't have to make ad-hoc stuff like
--   this.
instance Strokable (Statement TT) where
    toStrokes :: Statement TT -> Endo [Stroke]
toStrokes (FunDecl TT
f TT
n Parameters TT
ps Block TT
blk) =
        let s :: TT -> Endo [Stroke]
s = if Block TT -> Bool
forall (f :: * -> *) t. Failable f => f t -> Bool
hasFailed Block TT
blk then TT -> Endo [Stroke]
error else [TT] -> TT -> Endo [Stroke]
failStroker [TT
n] in
        TT -> Endo [Stroke]
s TT
f Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> TT -> Endo [Stroke]
s TT
n Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Parameters TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Parameters TT
ps Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Block TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Block TT
blk
    toStrokes (VarDecl TT
v BList (VarDecAss TT)
vs Semicolon TT
sc) =
        let s :: TT -> Endo [Stroke]
s = if (VarDecAss TT -> Bool) -> BList (VarDecAss TT) -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any VarDecAss TT -> Bool
forall (f :: * -> *) t. Failable f => f t -> Bool
hasFailed BList (VarDecAss TT)
vs then TT -> Endo [Stroke]
error else TT -> Endo [Stroke]
normal in
        TT -> Endo [Stroke]
s TT
v Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> (VarDecAss TT -> Endo [Stroke])
-> BList (VarDecAss TT) -> Endo [Stroke]
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap VarDecAss TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes BList (VarDecAss TT)
vs Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Endo [Stroke]
-> (TT -> Endo [Stroke]) -> Semicolon TT -> Endo [Stroke]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Endo [Stroke]
forall a. Monoid a => a
mempty TT -> Endo [Stroke]
s Semicolon TT
sc
    toStrokes (Return TT
t Maybe (Expr TT)
exp Semicolon TT
sc) = TT -> Endo [Stroke]
normal TT
t Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Endo [Stroke]
-> (Expr TT -> Endo [Stroke]) -> Maybe (Expr TT) -> Endo [Stroke]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Endo [Stroke]
forall a. Monoid a => a
mempty Expr TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Maybe (Expr TT)
exp Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Endo [Stroke]
-> (TT -> Endo [Stroke]) -> Semicolon TT -> Endo [Stroke]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Endo [Stroke]
forall a. Monoid a => a
mempty TT -> Endo [Stroke]
normal Semicolon TT
sc
    toStrokes (While TT
w ParExpr TT
exp Block TT
blk) =
        let s :: TT -> Endo [Stroke]
s = if Block TT -> Bool
forall (f :: * -> *) t. Failable f => f t -> Bool
hasFailed Block TT
blk Bool -> Bool -> Bool
|| Block TT -> Bool
forall (f :: * -> *) t. Failable f => f t -> Bool
hasFailed Block TT
blk then TT -> Endo [Stroke]
error else TT -> Endo [Stroke]
normal in
        TT -> Endo [Stroke]
s TT
w Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> ParExpr TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes ParExpr TT
exp Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Block TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Block TT
blk
    toStrokes (DoWhile TT
d Block TT
blk TT
w ParExpr TT
exp Semicolon TT
sc) =
        let s1 :: TT -> Endo [Stroke]
s1 = if Block TT -> Bool
forall (f :: * -> *) t. Failable f => f t -> Bool
hasFailed Block TT
blk then TT -> Endo [Stroke]
error else TT -> Endo [Stroke]
normal
            s2 :: TT -> Endo [Stroke]
s2 = if ParExpr TT -> Bool
forall (f :: * -> *) t. Failable f => f t -> Bool
hasFailed ParExpr TT
exp then TT -> Endo [Stroke]
error else TT -> Endo [Stroke]
normal in
        TT -> Endo [Stroke]
s1 TT
d Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Block TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Block TT
blk Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> TT -> Endo [Stroke]
s2 TT
w Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> ParExpr TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes ParExpr TT
exp Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Endo [Stroke]
-> (TT -> Endo [Stroke]) -> Semicolon TT -> Endo [Stroke]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Endo [Stroke]
forall a. Monoid a => a
mempty TT -> Endo [Stroke]
normal Semicolon TT
sc
    toStrokes (For TT
f TT
l Expr TT
x ForContent TT
c TT
r Block TT
blk) =
        let s :: TT -> Endo [Stroke]
s = if Block TT -> Bool
forall (f :: * -> *) t. Failable f => f t -> Bool
hasFailed Block TT
blk Bool -> Bool -> Bool
|| ForContent TT -> Bool
forall (f :: * -> *) t. Failable f => f t -> Bool
hasFailed ForContent TT
c Bool -> Bool -> Bool
|| Expr TT -> Bool
forall (f :: * -> *) t. Failable f => f t -> Bool
hasFailed Expr TT
x
                  then TT -> Endo [Stroke]
error
                  else [TT] -> TT -> Endo [Stroke]
failStroker [TT
f, TT
l, TT
r] in
        TT -> Endo [Stroke]
s TT
f Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> TT -> Endo [Stroke]
s TT
l Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Expr TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Expr TT
x Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> ForContent TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes ForContent TT
c Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> TT -> Endo [Stroke]
s TT
r Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Block TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Block TT
blk
    toStrokes (If TT
i ParExpr TT
x Block TT
blk Maybe (Statement TT)
e) =
        let s :: TT -> Endo [Stroke]
s = if Block TT -> Bool
forall (f :: * -> *) t. Failable f => f t -> Bool
hasFailed Block TT
blk then TT -> Endo [Stroke]
error else TT -> Endo [Stroke]
normal in
        TT -> Endo [Stroke]
s TT
i Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> ParExpr TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes ParExpr TT
x Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Block TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Block TT
blk Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Endo [Stroke]
-> (Statement TT -> Endo [Stroke])
-> Maybe (Statement TT)
-> Endo [Stroke]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Endo [Stroke]
forall a. Monoid a => a
mempty Statement TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Maybe (Statement TT)
e
    toStrokes (Else TT
e Block TT
blk) = TT -> Endo [Stroke]
normal TT
e Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Block TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Block TT
blk
    toStrokes (With TT
w ParExpr TT
x Block TT
blk) = TT -> Endo [Stroke]
normal TT
w Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> ParExpr TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes ParExpr TT
x Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Block TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Block TT
blk
    toStrokes (Expr Expr TT
exp Semicolon TT
sc) = Expr TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Expr TT
exp Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Endo [Stroke]
-> (TT -> Endo [Stroke]) -> Semicolon TT -> Endo [Stroke]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Endo [Stroke]
forall a. Monoid a => a
mempty TT -> Endo [Stroke]
normal Semicolon TT
sc
    toStrokes (Comm TT
t) = TT -> Endo [Stroke]
normal TT
t

instance Strokable (ForContent TT) where
    toStrokes :: ForContent TT -> Endo [Stroke]
toStrokes (ForNormal TT
s1 Expr TT
x2 TT
s2 Expr TT
x3) =
        let s :: TT -> Endo [Stroke]
s = if (Expr TT -> Bool) -> [Expr TT] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any Expr TT -> Bool
forall (f :: * -> *) t. Failable f => f t -> Bool
hasFailed [Expr TT
x2, Expr TT
x3] then TT -> Endo [Stroke]
error else [TT] -> TT -> Endo [Stroke]
failStroker [TT
s2] in
        TT -> Endo [Stroke]
s TT
s1 Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Expr TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Expr TT
x2 Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> TT -> Endo [Stroke]
s TT
s2 Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Expr TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Expr TT
x3
    toStrokes (ForIn TT
i Expr TT
x) =
        let s :: TT -> Endo [Stroke]
s = if Expr TT -> Bool
forall (f :: * -> *) t. Failable f => f t -> Bool
hasFailed Expr TT
x then TT -> Endo [Stroke]
error else TT -> Endo [Stroke]
normal in
        TT -> Endo [Stroke]
s TT
i Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Expr TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Expr TT
x
    toStrokes (ForErr TT
t) = TT -> Endo [Stroke]
error TT
t

instance Strokable (Block TT) where
    toStrokes :: Block TT -> Endo [Stroke]
toStrokes (BlockOne Statement TT
stmt) = Statement TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Statement TT
stmt
    toStrokes (Block TT
l BList (Statement TT)
stmts TT
r) =
        let s :: TT -> Endo [Stroke]
s = [TT] -> TT -> Endo [Stroke]
failStroker [TT
l, TT
r] in
        TT -> Endo [Stroke]
s TT
l Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> (Statement TT -> Endo [Stroke])
-> BList (Statement TT) -> Endo [Stroke]
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap Statement TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes BList (Statement TT)
stmts Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> TT -> Endo [Stroke]
s TT
r
    toStrokes (BlockErr TT
t) = TT -> Endo [Stroke]
error TT
t

instance Strokable (VarDecAss TT) where
    toStrokes :: VarDecAss TT -> Endo [Stroke]
toStrokes (AssBeg TT
t Maybe (VarDecAss TT)
x) = TT -> Endo [Stroke]
normal TT
t Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Endo [Stroke]
-> (VarDecAss TT -> Endo [Stroke])
-> Maybe (VarDecAss TT)
-> Endo [Stroke]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Endo [Stroke]
forall a. Monoid a => a
mempty VarDecAss TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Maybe (VarDecAss TT)
x
    toStrokes (AssRst TT
t Expr TT
exp) =
        let s :: TT -> Endo [Stroke]
s = if Expr TT -> Bool
forall (f :: * -> *) t. Failable f => f t -> Bool
hasFailed Expr TT
exp then TT -> Endo [Stroke]
error else TT -> Endo [Stroke]
normal in
        TT -> Endo [Stroke]
s TT
t Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Expr TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Expr TT
exp
    toStrokes (AssErr TT
t) = TT -> Endo [Stroke]
error TT
t

instance Strokable (Expr TT) where
    toStrokes :: Expr TT -> Endo [Stroke]
toStrokes (ExprSimple TT
x Maybe (Expr TT)
exp) = TT -> Endo [Stroke]
normal TT
x Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Endo [Stroke]
-> (Expr TT -> Endo [Stroke]) -> Maybe (Expr TT) -> Endo [Stroke]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Endo [Stroke]
forall a. Monoid a => a
mempty Expr TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Maybe (Expr TT)
exp
    toStrokes (ExprObj TT
l BList (KeyValue TT)
kvs TT
r) =
        let s :: TT -> Endo [Stroke]
s = [TT] -> TT -> Endo [Stroke]
failStroker [TT
l, TT
r] in
        TT -> Endo [Stroke]
s TT
l Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> (KeyValue TT -> Endo [Stroke])
-> BList (KeyValue TT) -> Endo [Stroke]
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap KeyValue TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes BList (KeyValue TT)
kvs Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> TT -> Endo [Stroke]
s TT
r
    toStrokes (ExprPrefix TT
t Expr TT
exp) = TT -> Endo [Stroke]
normal TT
t Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Expr TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Expr TT
exp
    toStrokes (ExprNew TT
t Expr TT
x) = TT -> Endo [Stroke]
normal TT
t Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Expr TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Expr TT
x
    toStrokes (ExprParen TT
l Expr TT
exp TT
r Maybe (Expr TT)
op) =
        let s :: TT -> Endo [Stroke]
s = [TT] -> TT -> Endo [Stroke]
failStroker [TT
l, TT
r] in
        TT -> Endo [Stroke]
s TT
l Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Expr TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Expr TT
exp Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> TT -> Endo [Stroke]
s TT
r Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Endo [Stroke]
-> (Expr TT -> Endo [Stroke]) -> Maybe (Expr TT) -> Endo [Stroke]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Endo [Stroke]
forall a. Monoid a => a
mempty Expr TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Maybe (Expr TT)
op
    toStrokes (ExprAnonFun TT
f Parameters TT
ps Block TT
blk) =
        TT -> Endo [Stroke]
normal TT
f Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Parameters TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Parameters TT
ps Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Block TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Block TT
blk
    toStrokes (ExprTypeOf TT
t Expr TT
x) =
        let s :: TT -> Endo [Stroke]
s = if Expr TT -> Bool
forall (f :: * -> *) t. Failable f => f t -> Bool
hasFailed Expr TT
x then TT -> Endo [Stroke]
error else TT -> Endo [Stroke]
normal in
        TT -> Endo [Stroke]
s TT
t Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Expr TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Expr TT
x
    toStrokes (ExprFunCall TT
n ParExpr TT
x Maybe (Expr TT)
m) =
        let s :: TT -> Endo [Stroke]
s = if ParExpr TT -> Bool
forall (f :: * -> *) t. Failable f => f t -> Bool
hasFailed ParExpr TT
x then TT -> Endo [Stroke]
error else TT -> Endo [Stroke]
normal in
        TT -> Endo [Stroke]
s TT
n Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> ParExpr TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes ParExpr TT
x Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Endo [Stroke]
-> (Expr TT -> Endo [Stroke]) -> Maybe (Expr TT) -> Endo [Stroke]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Endo [Stroke]
forall a. Monoid a => a
mempty Expr TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Maybe (Expr TT)
m
    toStrokes (OpExpr TT
op Expr TT
exp) =
        let s :: TT -> Endo [Stroke]
s = if Expr TT -> Bool
forall (f :: * -> *) t. Failable f => f t -> Bool
hasFailed Expr TT
exp then TT -> Endo [Stroke]
error else TT -> Endo [Stroke]
normal in
        TT -> Endo [Stroke]
s TT
op Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Expr TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Expr TT
exp
    toStrokes (PostExpr TT
t) = TT -> Endo [Stroke]
normal TT
t
    toStrokes (ExprCond TT
a Expr TT
x TT
b Expr TT
y) =
        let s :: TT -> Endo [Stroke]
s = [TT] -> TT -> Endo [Stroke]
failStroker [TT
a, TT
b] in
        TT -> Endo [Stroke]
s TT
a Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Expr TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Expr TT
x Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> TT -> Endo [Stroke]
s TT
b Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Expr TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Expr TT
y
    toStrokes (ExprArr TT
l Maybe (Array TT)
x TT
r Maybe (Expr TT)
m) =
        let s :: TT -> Endo [Stroke]
s = [TT] -> TT -> Endo [Stroke]
failStroker [TT
l, TT
r] in
        TT -> Endo [Stroke]
s TT
l Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Endo [Stroke]
-> (Array TT -> Endo [Stroke]) -> Maybe (Array TT) -> Endo [Stroke]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Endo [Stroke]
forall a. Monoid a => a
mempty Array TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Maybe (Array TT)
x Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> TT -> Endo [Stroke]
s TT
r Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Endo [Stroke]
-> (Expr TT -> Endo [Stroke]) -> Maybe (Expr TT) -> Endo [Stroke]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Endo [Stroke]
forall a. Monoid a => a
mempty Expr TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Maybe (Expr TT)
m
    toStrokes (ExprErr TT
t) = TT -> Endo [Stroke]
error TT
t

instance Strokable (Parameters TT) where
    toStrokes :: Parameters TT -> Endo [Stroke]
toStrokes (Parameters TT
l [TT]
ps TT
r) = TT -> Endo [Stroke]
normal TT
l Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> (TT -> Endo [Stroke]) -> [TT] -> Endo [Stroke]
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes [TT]
ps Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> TT -> Endo [Stroke]
normal TT
r
    toStrokes (ParErr TT
t) = TT -> Endo [Stroke]
error TT
t

instance Strokable (ParExpr TT) where
    toStrokes :: ParExpr TT -> Endo [Stroke]
toStrokes (ParExpr TT
l [Expr TT]
xs TT
r) =
        let s :: TT -> Endo [Stroke]
s = if TT -> Bool
isError TT
r Bool -> Bool -> Bool
|| (Expr TT -> Bool) -> [Expr TT] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any Expr TT -> Bool
forall (f :: * -> *) t. Failable f => f t -> Bool
hasFailed [Expr TT]
xs
                  then TT -> Endo [Stroke]
error
                  else TT -> Endo [Stroke]
normal in
        TT -> Endo [Stroke]
s TT
l Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> (Expr TT -> Endo [Stroke]) -> [Expr TT] -> Endo [Stroke]
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap Expr TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes [Expr TT]
xs Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> TT -> Endo [Stroke]
s TT
r
    toStrokes (ParExprErr TT
t) = TT -> Endo [Stroke]
error TT
t

instance Strokable (KeyValue TT) where
    toStrokes :: KeyValue TT -> Endo [Stroke]
toStrokes (KeyValue TT
n TT
c Expr TT
exp) =
        let s :: TT -> Endo [Stroke]
s = [TT] -> TT -> Endo [Stroke]
failStroker [TT
n, TT
c] in
        TT -> Endo [Stroke]
s TT
n Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> TT -> Endo [Stroke]
s TT
c Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Expr TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Expr TT
exp
    toStrokes (KeyValueErr TT
t) = TT -> Endo [Stroke]
error TT
t

instance Strokable (Tok Token) where
    toStrokes :: TT -> Endo [Stroke]
toStrokes TT
t = if TT -> Bool
isError TT
t
                      then (TT -> Stroke) -> TT -> Endo [Stroke]
forall t a. (t -> a) -> t -> Endo [a]
one (StyleName -> Stroke -> Stroke
modStroke StyleName
errorStyle (Stroke -> Stroke) -> (TT -> Stroke) -> TT -> Stroke
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TT -> Stroke
tokenToStroke) TT
t
                      else (TT -> Stroke) -> TT -> Endo [Stroke]
forall t a. (t -> a) -> t -> Endo [a]
one TT -> Stroke
tokenToStroke TT
t

instance Strokable (Array TT) where
    toStrokes :: Array TT -> Endo [Stroke]
toStrokes (ArrCont Expr TT
x Maybe (Array TT)
m) = Expr TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Expr TT
x Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Endo [Stroke]
-> (Array TT -> Endo [Stroke]) -> Maybe (Array TT) -> Endo [Stroke]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Endo [Stroke]
forall a. Monoid a => a
mempty Array TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Maybe (Array TT)
m
    toStrokes (ArrRest TT
c Array TT
a Maybe (Array TT)
m) = TT -> Endo [Stroke]
normal TT
c Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Array TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Array TT
a Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
forall a. Semigroup a => a -> a -> a
<> Endo [Stroke]
-> (Array TT -> Endo [Stroke]) -> Maybe (Array TT) -> Endo [Stroke]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Endo [Stroke]
forall a. Monoid a => a
mempty Array TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes Maybe (Array TT)
m
    toStrokes (ArrErr TT
t) = TT -> Endo [Stroke]
error TT
t


-- * Helper functions.

-- | Normal stroker.
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 stroker.
error :: TT -> Endo [Stroke]
error :: TT -> Endo [Stroke]
error = (TT -> Stroke) -> TT -> Endo [Stroke]
forall t a. (t -> a) -> t -> Endo [a]
one (StyleName -> Stroke -> Stroke
modStroke StyleName
errorStyle (Stroke -> Stroke) -> (TT -> Stroke) -> TT -> Stroke
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TT -> Stroke
tokenToStroke)

one :: (t -> a) -> t -> Endo [a]
one :: (t -> a) -> t -> Endo [a]
one t -> a
f t
x = ([a] -> [a]) -> Endo [a]
forall a. (a -> a) -> Endo a
Endo (t -> a
f t
x a -> [a] -> [a]
forall a. a -> [a] -> [a]
:)

-- | Given a new style and a stroke, return a stroke with the new style appended
--   to the old one.
modStroke :: StyleName -> Stroke -> Stroke
modStroke :: StyleName -> Stroke -> Stroke
modStroke StyleName
style = (StyleName -> StyleName) -> Stroke -> Stroke
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (StyleName
style StyleName -> StyleName -> StyleName
forall a. Semigroup a => a -> a -> a
<>)


-- * Stroking functions

-- | Given a list of tokens to check for errors (@xs@) and a list of tokens to
--   stroke (@xs'@), returns normal strokes for @xs'@ if there were no errors.
--   Otherwise returns error strokes for @xs'@.
nError :: [TT] -> [TT] -> Endo [Stroke]
nError :: [TT] -> [TT] -> Endo [Stroke]
nError [TT]
xs = (TT -> Endo [Stroke]) -> [TT] -> Endo [Stroke]
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap ([TT] -> TT -> Endo [Stroke]
failStroker [TT]
xs)

-- | Given a list of @TT@, if any of them is an error, returns an error stroker,
--   otherwise a normal stroker.  Using e.g. existentials, we could make this
--   more general and have support for heterogeneous lists of elements which
--   implement Failable, but I haven't had the time to fix this.
failStroker :: [TT] -> TT -> Endo [Stroke]
failStroker :: [TT] -> TT -> Endo [Stroke]
failStroker [TT]
xs = if (TT -> Bool) -> [TT] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any TT -> Bool
isError [TT]
xs then TT -> Endo [Stroke]
error else TT -> Endo [Stroke]
normal

-- | Given a @TT@, return a @Stroke@ for it.
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

-- | The main stroking function.
getStrokes :: Tree TT -> Point -> Point -> Point -> [Stroke]
getStrokes :: BList (Statement TT) -> Point -> Point -> Point -> [Stroke]
getStrokes BList (Statement TT)
t0 Point
_point Point
_begin Point
_end = Text -> [Stroke] -> [Stroke]
forall a. Text -> a -> a
trace (Char
'\n' Char -> Text -> Text
`T.cons` BList (Statement TT) -> Text
forall a. Show a => a -> Text
showT BList (Statement TT)
t0) [Stroke]
result
    where
      result :: [Stroke]
result = Endo [Stroke] -> [Stroke] -> [Stroke]
forall a. Endo a -> a -> a
appEndo ((Statement TT -> Endo [Stroke])
-> BList (Statement TT) -> Endo [Stroke]
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap Statement TT -> Endo [Stroke]
forall a. Strokable a => a -> Endo [Stroke]
toStrokes BList (Statement TT)
t0) []


-- * The parser

-- | Main parser.
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

-- | Parser for statements such as "return", "while", "do-while", "for", etc.
statement :: P TT (Statement TT)
statement :: Parser TT (Statement TT)
statement = TT -> TT -> Parameters TT -> Block TT -> Statement TT
forall t. t -> t -> Parameters t -> Block t -> Statement t
FunDecl (TT -> TT -> Parameters TT -> Block TT -> Statement TT)
-> Parser TT TT
-> Parser TT (TT -> Parameters TT -> Block TT -> Statement TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Reserved -> Parser TT TT
res Reserved
Function' Parser TT (TT -> Parameters TT -> Block TT -> Statement TT)
-> Parser TT TT
-> Parser TT (Parameters TT -> Block TT -> Statement TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT TT -> Parser TT TT
plzTok Parser TT TT
name Parser TT (Parameters TT -> Block TT -> Statement TT)
-> Parser TT (Parameters TT)
-> Parser TT (Block TT -> Statement TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (Parameters TT)
parameters Parser TT (Block TT -> Statement TT)
-> Parser TT (Block TT) -> Parser TT (Statement TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (Block TT)
block
        Parser TT (Statement TT)
-> Parser TT (Statement TT) -> Parser TT (Statement TT)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> TT -> BList (VarDecAss TT) -> Semicolon TT -> Statement TT
forall t. t -> BList (VarDecAss t) -> Semicolon t -> Statement t
VarDecl (TT -> BList (VarDecAss TT) -> Semicolon TT -> Statement TT)
-> Parser TT TT
-> Parser TT (BList (VarDecAss TT) -> Semicolon TT -> Statement TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Reserved -> Parser TT TT
res Reserved
Var' Parser TT (BList (VarDecAss TT) -> Semicolon TT -> Statement TT)
-> Parser TT (BList (VarDecAss TT))
-> Parser TT (Semicolon TT -> Statement TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> P TT (VarDecAss TT) -> P TT (VarDecAss TT)
forall (f :: * -> *). Failable f => P TT (f TT) -> P TT (f TT)
plz P TT (VarDecAss TT)
varDecAss P TT (VarDecAss TT)
-> Parser TT TT -> Parser TT (BList (VarDecAss TT))
forall (f :: * -> *) a v. Alternative f => f a -> f v -> f [a]
`sepBy1` Char -> Parser TT TT
spc Char
',' Parser TT (Semicolon TT -> Statement TT)
-> Parser TT (Semicolon TT) -> Parser TT (Statement TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (Semicolon TT)
semicolon
        Parser TT (Statement TT)
-> Parser TT (Statement TT) -> Parser TT (Statement TT)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> TT -> Maybe (Expr TT) -> Semicolon TT -> Statement TT
forall t. t -> Maybe (Expr t) -> Semicolon t -> Statement t
Return  (TT -> Maybe (Expr TT) -> Semicolon TT -> Statement TT)
-> Parser TT TT
-> Parser TT (Maybe (Expr TT) -> Semicolon TT -> Statement TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Reserved -> Parser TT TT
res Reserved
Return' Parser TT (Maybe (Expr TT) -> Semicolon TT -> Statement TT)
-> Parser TT (Maybe (Expr TT))
-> Parser TT (Semicolon TT -> Statement TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (Expr TT) -> Parser TT (Maybe (Expr TT))
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser TT (Expr TT)
expression Parser TT (Semicolon TT -> Statement TT)
-> Parser TT (Semicolon TT) -> Parser TT (Statement TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (Semicolon TT)
semicolon
        Parser TT (Statement TT)
-> Parser TT (Statement TT) -> Parser TT (Statement TT)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> TT -> ParExpr TT -> Block TT -> Statement TT
forall t. t -> ParExpr t -> Block t -> Statement t
While   (TT -> ParExpr TT -> Block TT -> Statement TT)
-> Parser TT TT
-> Parser TT (ParExpr TT -> Block TT -> Statement TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Reserved -> Parser TT TT
res Reserved
While' Parser TT (ParExpr TT -> Block TT -> Statement TT)
-> Parser TT (ParExpr TT) -> Parser TT (Block TT -> Statement TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (ParExpr TT)
parExpr Parser TT (Block TT -> Statement TT)
-> Parser TT (Block TT) -> Parser TT (Statement TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (Block TT)
block
        Parser TT (Statement TT)
-> Parser TT (Statement TT) -> Parser TT (Statement TT)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> TT -> Block TT -> TT -> ParExpr TT -> Semicolon TT -> Statement TT
forall t.
t -> Block t -> t -> ParExpr t -> Semicolon t -> Statement t
DoWhile (TT
 -> Block TT -> TT -> ParExpr TT -> Semicolon TT -> Statement TT)
-> Parser TT TT
-> Parser
     TT (Block TT -> TT -> ParExpr TT -> Semicolon TT -> Statement TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Reserved -> Parser TT TT
res Reserved
Do' Parser
  TT (Block TT -> TT -> ParExpr TT -> Semicolon TT -> Statement TT)
-> Parser TT (Block TT)
-> Parser TT (TT -> ParExpr TT -> Semicolon TT -> Statement TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (Block TT)
block Parser TT (TT -> ParExpr TT -> Semicolon TT -> Statement TT)
-> Parser TT TT
-> Parser TT (ParExpr TT -> Semicolon TT -> Statement TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT TT -> Parser TT TT
plzTok (Reserved -> Parser TT TT
res Reserved
While') Parser TT (ParExpr TT -> Semicolon TT -> Statement TT)
-> Parser TT (ParExpr TT)
-> Parser TT (Semicolon TT -> Statement TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (ParExpr TT)
parExpr Parser TT (Semicolon TT -> Statement TT)
-> Parser TT (Semicolon TT) -> Parser TT (Statement TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (Semicolon TT)
semicolon
        Parser TT (Statement TT)
-> Parser TT (Statement TT) -> Parser TT (Statement TT)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> TT
-> TT -> Expr TT -> ForContent TT -> TT -> Block TT -> Statement TT
forall t.
t -> t -> Expr t -> ForContent t -> t -> Block t -> Statement t
For     (TT
 -> TT
 -> Expr TT
 -> ForContent TT
 -> TT
 -> Block TT
 -> Statement TT)
-> Parser TT TT
-> Parser
     TT
     (TT -> Expr TT -> ForContent TT -> TT -> Block TT -> Statement TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Reserved -> Parser TT TT
res Reserved
For' Parser
  TT
  (TT -> Expr TT -> ForContent TT -> TT -> Block TT -> Statement TT)
-> Parser TT TT
-> Parser
     TT (Expr TT -> ForContent TT -> TT -> Block TT -> Statement TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Char -> Parser TT TT
plzSpc Char
'(' Parser
  TT (Expr TT -> ForContent TT -> TT -> Block TT -> Statement TT)
-> Parser TT (Expr TT)
-> Parser TT (ForContent TT -> TT -> Block TT -> Statement TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (Expr TT)
plzExpr Parser TT (ForContent TT -> TT -> Block TT -> Statement TT)
-> Parser TT (ForContent TT)
-> Parser TT (TT -> Block TT -> Statement TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (ForContent TT)
forContent
                    Parser TT (TT -> Block TT -> Statement TT)
-> Parser TT TT -> Parser TT (Block TT -> Statement TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Char -> Parser TT TT
plzSpc Char
')' Parser TT (Block TT -> Statement TT)
-> Parser TT (Block TT) -> Parser TT (Statement TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (Block TT)
block
        Parser TT (Statement TT)
-> Parser TT (Statement TT) -> Parser TT (Statement TT)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> TT
-> ParExpr TT -> Block TT -> Maybe (Statement TT) -> Statement TT
forall t.
t -> ParExpr t -> Block t -> Maybe (Statement t) -> Statement t
If      (TT
 -> ParExpr TT -> Block TT -> Maybe (Statement TT) -> Statement TT)
-> Parser TT TT
-> Parser
     TT (ParExpr TT -> Block TT -> Maybe (Statement TT) -> Statement TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Reserved -> Parser TT TT
res Reserved
If' Parser
  TT (ParExpr TT -> Block TT -> Maybe (Statement TT) -> Statement TT)
-> Parser TT (ParExpr TT)
-> Parser TT (Block TT -> Maybe (Statement TT) -> Statement TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (ParExpr TT)
parExpr Parser TT (Block TT -> Maybe (Statement TT) -> Statement TT)
-> Parser TT (Block TT)
-> Parser TT (Maybe (Statement TT) -> Statement TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (Block TT)
block Parser TT (Maybe (Statement TT) -> Statement TT)
-> Parser TT (Maybe (Statement TT)) -> Parser TT (Statement TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (Statement TT) -> Parser TT (Maybe (Statement TT))
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (TT -> Block TT -> Statement TT
forall t. t -> Block t -> Statement t
Else (TT -> Block TT -> Statement TT)
-> Parser TT TT -> Parser TT (Block TT -> Statement TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Reserved -> Parser TT TT
res Reserved
Else' Parser TT (Block TT -> Statement TT)
-> Parser TT (Block TT) -> Parser TT (Statement TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (Block TT)
block)
        Parser TT (Statement TT)
-> Parser TT (Statement TT) -> Parser TT (Statement TT)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> TT -> ParExpr TT -> Block TT -> Statement TT
forall t. t -> ParExpr t -> Block t -> Statement t
With    (TT -> ParExpr TT -> Block TT -> Statement TT)
-> Parser TT TT
-> Parser TT (ParExpr TT -> Block TT -> Statement TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Reserved -> Parser TT TT
res Reserved
With' Parser TT (ParExpr TT -> Block TT -> Statement TT)
-> Parser TT (ParExpr TT) -> Parser TT (Block TT -> Statement TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (ParExpr TT)
parExpr Parser TT (Block TT -> Statement TT)
-> Parser TT (Block TT) -> Parser TT (Statement TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (Block TT)
block
        Parser TT (Statement TT)
-> Parser TT (Statement TT) -> Parser TT (Statement TT)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> TT -> Statement TT
forall t. t -> Statement t
Comm    (TT -> Statement TT) -> Parser TT TT -> Parser TT (Statement TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser TT TT
comment
        Parser TT (Statement TT)
-> Parser TT (Statement TT) -> Parser TT (Statement TT)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Expr TT -> Semicolon TT -> Statement TT
forall t. Expr t -> Semicolon t -> Statement t
Expr    (Expr TT -> Semicolon TT -> Statement TT)
-> Parser TT (Expr TT) -> Parser TT (Semicolon TT -> Statement TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser TT (Expr TT)
stmtExpr Parser TT (Semicolon TT -> Statement TT)
-> Parser TT (Semicolon TT) -> Parser TT (Statement TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (Semicolon TT)
semicolon
    where
      forContent :: P TT (ForContent TT)
      forContent :: Parser TT (ForContent TT)
forContent = TT -> Expr TT -> TT -> Expr TT -> ForContent TT
forall t. t -> Expr t -> t -> Expr t -> ForContent t
ForNormal (TT -> Expr TT -> TT -> Expr TT -> ForContent TT)
-> Parser TT TT
-> Parser TT (Expr TT -> TT -> Expr TT -> ForContent TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Char -> Parser TT TT
spc Char
';' Parser TT (Expr TT -> TT -> Expr TT -> ForContent TT)
-> Parser TT (Expr TT)
-> Parser TT (TT -> Expr TT -> ForContent TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (Expr TT)
plzExpr Parser TT (TT -> Expr TT -> ForContent TT)
-> Parser TT TT -> Parser TT (Expr TT -> ForContent TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Char -> Parser TT TT
plzSpc Char
';' Parser TT (Expr TT -> ForContent TT)
-> Parser TT (Expr TT) -> Parser TT (ForContent TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (Expr TT)
plzExpr
               Parser TT (ForContent TT)
-> Parser TT (ForContent TT) -> Parser TT (ForContent TT)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> TT -> Expr TT -> ForContent TT
forall t. t -> Expr t -> ForContent t
ForIn     (TT -> Expr TT -> ForContent TT)
-> Parser TT TT -> Parser TT (Expr TT -> ForContent TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Reserved -> Parser TT TT
res Reserved
In' Parser TT (Expr TT -> ForContent TT)
-> Parser TT (Expr TT) -> Parser TT (ForContent TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (Expr TT)
plzExpr
               Parser TT (ForContent TT)
-> Parser TT (ForContent TT) -> Parser TT (ForContent TT)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> TT -> ForContent TT
forall t. t -> ForContent t
ForErr    (TT -> ForContent TT) -> Parser TT TT -> Parser TT (ForContent TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> Parser TT TT -> Parser TT TT
forall s a. Int -> P s a -> P s a
hate Int
1 ((TT -> Bool) -> Parser TT TT
forall s. (s -> Bool) -> Parser s s
symbol (Bool -> TT -> Bool
forall a b. a -> b -> a
const Bool
True))
               Parser TT (ForContent TT)
-> Parser TT (ForContent TT) -> Parser TT (ForContent TT)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> TT -> ForContent TT
forall t. t -> ForContent t
ForErr    (TT -> ForContent TT) -> Parser TT TT -> Parser TT (ForContent TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> Parser TT TT -> Parser TT TT
forall s a. Int -> P s a -> P s a
hate Int
2 (TT -> Parser TT TT
forall (f :: * -> *) a. Applicative f => a -> f a
pure TT
errorToken)
      varDecAss :: P TT (VarDecAss TT)
      varDecAss :: P TT (VarDecAss TT)
varDecAss = TT -> Maybe (VarDecAss TT) -> VarDecAss TT
forall t. t -> Maybe (VarDecAss t) -> VarDecAss t
AssBeg (TT -> Maybe (VarDecAss TT) -> VarDecAss TT)
-> Parser TT TT -> Parser TT (Maybe (VarDecAss TT) -> VarDecAss TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser TT TT
name Parser TT (Maybe (VarDecAss TT) -> VarDecAss TT)
-> Parser TT (Maybe (VarDecAss TT)) -> P TT (VarDecAss TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> P TT (VarDecAss TT) -> Parser TT (Maybe (VarDecAss TT))
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (TT -> Expr TT -> VarDecAss TT
forall t. t -> Expr t -> VarDecAss t
AssRst (TT -> Expr TT -> VarDecAss TT)
-> Parser TT TT -> Parser TT (Expr TT -> VarDecAss TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Operator -> Parser TT TT
oper Operator
Assign' Parser TT (Expr TT -> VarDecAss TT)
-> Parser TT (Expr TT) -> P TT (VarDecAss TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (Expr TT)
plzExpr)

-- | Parser for "blocks", i.e. a bunch of statements wrapped in curly brackets
--   /or/ just a single statement.
--
--   Note that this works for JavaScript 1.8 "lambda" style function bodies as
--   well, e.g. "function hello() 5", since expressions are also statements and
--   we don't require a trailing semi-colon.
--
--   TODO: function hello() var x; is not a valid program.
block :: P TT (Block TT)
block :: Parser TT (Block TT)
block = TT -> BList (Statement TT) -> TT -> Block TT
forall t. t -> BList (Statement t) -> t -> Block t
Block    (TT -> BList (Statement TT) -> TT -> Block TT)
-> Parser TT TT
-> Parser TT (BList (Statement TT) -> TT -> Block TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Char -> Parser TT TT
spc Char
'{' Parser TT (BList (Statement TT) -> TT -> Block TT)
-> P TT (BList (Statement TT)) -> Parser TT (TT -> Block TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (Statement TT) -> P TT (BList (Statement TT))
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many Parser TT (Statement TT)
statement Parser TT (TT -> Block TT) -> Parser TT TT -> Parser TT (Block TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Char -> Parser TT TT
plzSpc Char
'}'
    Parser TT (Block TT)
-> Parser TT (Block TT) -> Parser TT (Block TT)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Statement TT -> Block TT
forall t. Statement t -> Block t
BlockOne (Statement TT -> Block TT)
-> Parser TT (Statement TT) -> Parser TT (Block TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> Parser TT (Statement TT) -> Parser TT (Statement TT)
forall s a. Int -> P s a -> P s a
hate Int
1 Parser TT (Statement TT)
statement
    Parser TT (Block TT)
-> Parser TT (Block TT) -> Parser TT (Block TT)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> TT -> Block TT
forall t. t -> Block t
BlockErr (TT -> Block TT) -> Parser TT TT -> Parser TT (Block TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> Parser TT TT -> Parser TT TT
forall s a. Int -> P s a -> P s a
hate Int
2 (TT -> Parser TT TT
forall (f :: * -> *) a. Applicative f => a -> f a
pure TT
errorToken)

-- | Parser for expressions which may be statements.  In reality, any expression
--   is also a valid statement, but this is a slight compromise to get rid of
--   the massive performance loss which is introduced when allowing JavaScript
--   objects to be valid statements.
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
       -- We hate the parenthesized expression just a tad because otherwise
       -- confirm('hello') will be seen as "confirm; ('hello');"
       Parser TT (Expr TT) -> Parser TT (Expr TT) -> Parser TT (Expr TT)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Int -> Parser TT (Expr TT) -> Parser TT (Expr TT)
forall s a. Int -> P s a -> P s a
hate Int
1 (TT -> Expr TT -> TT -> Maybe (Expr TT) -> Expr TT
forall t. t -> Expr t -> t -> Maybe (Expr t) -> Expr t
ExprParen  (TT -> Expr TT -> TT -> Maybe (Expr TT) -> Expr TT)
-> Parser TT TT
-> Parser TT (Expr TT -> TT -> Maybe (Expr TT) -> Expr TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Char -> Parser TT TT
spc Char
'(' Parser TT (Expr TT -> TT -> Maybe (Expr TT) -> Expr TT)
-> Parser TT (Expr TT)
-> Parser TT (TT -> Maybe (Expr TT) -> Expr TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (Expr TT)
plzExpr Parser TT (TT -> Maybe (Expr TT) -> Expr TT)
-> Parser TT TT -> Parser TT (Maybe (Expr TT) -> Expr TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Char -> Parser TT TT
plzSpc Char
')'
                              Parser TT (Maybe (Expr TT) -> Expr TT)
-> Parser TT (Maybe (Expr TT)) -> Parser TT (Expr TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (Expr TT) -> Parser TT (Maybe (Expr TT))
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser TT (Expr TT)
opExpr)
       Parser TT (Expr TT) -> Parser TT (Expr TT) -> Parser TT (Expr TT)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> TT -> Expr TT
forall t. t -> Expr t
ExprErr (TT -> Expr TT) -> Parser TT TT -> Parser TT (Expr TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> Parser TT TT -> Parser TT TT
forall s a. Int -> P s a -> P s a
hate Int
2 ((TT -> Bool) -> Parser TT TT
forall s. (s -> Bool) -> Parser s s
symbol (Bool -> TT -> Bool
forall a b. a -> b -> a
const Bool
True))
    where
      funCall :: P TT (Expr TT)
      funCall :: Parser TT (Expr TT)
funCall = TT -> ParExpr TT -> Maybe (Expr TT) -> Expr TT
forall t. t -> ParExpr t -> Maybe (Expr t) -> Expr t
ExprFunCall (TT -> ParExpr TT -> Maybe (Expr TT) -> Expr TT)
-> Parser TT TT
-> Parser TT (ParExpr TT -> Maybe (Expr TT) -> Expr TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser TT TT
name Parser TT (ParExpr TT -> Maybe (Expr TT) -> Expr TT)
-> Parser TT (ParExpr TT) -> Parser TT (Maybe (Expr TT) -> Expr TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (ParExpr TT)
parExpr Parser TT (Maybe (Expr TT) -> Expr TT)
-> Parser TT (Maybe (Expr TT)) -> Parser TT (Expr TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (Expr TT) -> Parser TT (Maybe (Expr TT))
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser TT (Expr TT)
opExpr

-- | The basic idea here is to parse "the rest" of expressions, e.g. @+ 3@ in @x
--   + 3@ or @[i]@ in @x[i]@.  Anything which is useful in such a scenario goes
--   here.  TODO: This accepts [], but shouldn't, since x[] is invalid.
opExpr :: P TT (Expr TT)
opExpr :: Parser TT (Expr TT)
opExpr = TT -> Expr TT -> Expr TT
forall t. t -> Expr t -> Expr t
OpExpr   (TT -> Expr TT -> Expr TT)
-> Parser TT TT -> Parser TT (Expr TT -> Expr TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser TT TT
inOp Parser TT (Expr TT -> Expr TT)
-> Parser TT (Expr TT) -> Parser TT (Expr TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (Expr TT)
plzExpr
     Parser TT (Expr TT) -> Parser TT (Expr TT) -> Parser TT (Expr TT)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> TT -> Expr TT -> TT -> Expr TT -> Expr TT
forall t. t -> Expr t -> t -> Expr t -> Expr t
ExprCond (TT -> Expr TT -> TT -> Expr TT -> Expr TT)
-> Parser TT TT -> Parser TT (Expr TT -> TT -> Expr TT -> Expr TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Char -> Parser TT TT
spc Char
'?' Parser TT (Expr TT -> TT -> Expr TT -> Expr TT)
-> Parser TT (Expr TT) -> Parser TT (TT -> Expr TT -> Expr TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (Expr TT)
plzExpr Parser TT (TT -> Expr TT -> Expr TT)
-> Parser TT TT -> Parser TT (Expr TT -> Expr TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Char -> Parser TT TT
plzSpc Char
':' Parser TT (Expr TT -> Expr TT)
-> Parser TT (Expr TT) -> Parser TT (Expr TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (Expr TT)
plzExpr
     Parser TT (Expr TT) -> Parser TT (Expr TT) -> Parser TT (Expr TT)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> TT -> Expr TT
forall t. t -> Expr t
PostExpr (TT -> Expr TT) -> Parser TT TT -> Parser TT (Expr TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser TT TT
postOp
     Parser TT (Expr TT) -> Parser TT (Expr TT) -> Parser TT (Expr TT)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser TT (Expr TT)
array

-- | Parser for expressions.
expression :: P TT (Expr TT)
expression :: Parser TT (Expr TT)
expression = TT -> BList (KeyValue TT) -> TT -> Expr TT
forall t. t -> BList (KeyValue t) -> t -> Expr t
ExprObj     (TT -> BList (KeyValue TT) -> TT -> Expr TT)
-> Parser TT TT -> Parser TT (BList (KeyValue TT) -> TT -> Expr TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Char -> Parser TT TT
spc Char
'{' Parser TT (BList (KeyValue TT) -> TT -> Expr TT)
-> Parser TT (BList (KeyValue TT)) -> Parser TT (TT -> Expr TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> P TT (KeyValue TT)
keyValue P TT (KeyValue TT)
-> Parser TT TT -> Parser TT (BList (KeyValue TT))
forall (f :: * -> *) a v. Alternative f => f a -> f v -> f [a]
`sepBy` Char -> Parser TT TT
spc Char
',' Parser TT (TT -> Expr TT) -> Parser TT TT -> Parser TT (Expr TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Char -> Parser TT TT
plzSpc Char
'}'
         Parser TT (Expr TT) -> Parser TT (Expr TT) -> Parser TT (Expr TT)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> TT -> Parameters TT -> Block TT -> Expr TT
forall t. t -> Parameters t -> Block t -> Expr t
ExprAnonFun (TT -> Parameters TT -> Block TT -> Expr TT)
-> Parser TT TT -> Parser TT (Parameters TT -> Block TT -> Expr TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Reserved -> Parser TT TT
res Reserved
Function' Parser TT (Parameters TT -> Block TT -> Expr TT)
-> Parser TT (Parameters TT) -> Parser TT (Block TT -> Expr TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (Parameters TT)
parameters Parser TT (Block TT -> Expr TT)
-> Parser TT (Block TT) -> Parser TT (Expr TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (Block TT)
block
         Parser TT (Expr TT) -> Parser TT (Expr TT) -> Parser TT (Expr TT)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> TT -> Expr TT -> Expr TT
forall t. t -> Expr t -> Expr t
ExprTypeOf  (TT -> Expr TT -> Expr TT)
-> Parser TT TT -> Parser TT (Expr TT -> Expr TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Reserved -> Parser TT TT
res Reserved
TypeOf' Parser TT (Expr TT -> Expr TT)
-> Parser TT (Expr TT) -> Parser TT (Expr TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (Expr TT)
plzExpr
         Parser TT (Expr TT) -> Parser TT (Expr TT) -> Parser TT (Expr TT)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser TT (Expr TT)
stmtExpr
         Parser TT (Expr TT) -> Parser TT (Expr TT) -> Parser TT (Expr TT)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser TT (Expr TT)
array
    where
      keyValue :: P TT (KeyValue TT)
      keyValue :: P TT (KeyValue TT)
keyValue = TT -> TT -> Expr TT -> KeyValue TT
forall t. t -> t -> Expr t -> KeyValue t
KeyValue    (TT -> TT -> Expr TT -> KeyValue TT)
-> Parser TT TT -> Parser TT (TT -> Expr TT -> KeyValue TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser TT TT
name Parser TT (TT -> Expr TT -> KeyValue TT)
-> Parser TT TT -> Parser TT (Expr TT -> KeyValue TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Char -> Parser TT TT
plzSpc Char
':' Parser TT (Expr TT -> KeyValue TT)
-> Parser TT (Expr TT) -> P TT (KeyValue TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (Expr TT)
plzExpr
             P TT (KeyValue TT) -> P TT (KeyValue TT) -> P TT (KeyValue TT)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> TT -> KeyValue TT
forall t. t -> KeyValue t
KeyValueErr (TT -> KeyValue TT) -> Parser TT TT -> P TT (KeyValue TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> Parser TT TT -> Parser TT TT
forall s a. Int -> P s a -> P s a
hate Int
1 ((TT -> Bool) -> Parser TT TT
forall s. (s -> Bool) -> Parser s s
symbol (Bool -> TT -> Bool
forall a b. a -> b -> a
const Bool
True))
             P TT (KeyValue TT) -> P TT (KeyValue TT) -> P TT (KeyValue TT)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> TT -> KeyValue TT
forall t. t -> KeyValue t
KeyValueErr (TT -> KeyValue TT) -> Parser TT TT -> P TT (KeyValue TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> Parser TT TT -> Parser TT TT
forall s a. Int -> P s a -> P s a
hate Int
2 (TT -> Parser TT TT
forall (f :: * -> *) a. Applicative f => a -> f a
pure TT
errorToken)

-- | Parses both empty and non-empty arrays.  Should probably be split up into
--   further parts to allow for the separation of @[]@ and @[1, 2, 3]@.
array :: P TT (Expr TT)
array :: Parser TT (Expr TT)
array = TT -> Maybe (Array TT) -> TT -> Maybe (Expr TT) -> Expr TT
forall t. t -> Maybe (Array t) -> t -> Maybe (Expr t) -> Expr t
ExprArr (TT -> Maybe (Array TT) -> TT -> Maybe (Expr TT) -> Expr TT)
-> Parser TT TT
-> Parser TT (Maybe (Array TT) -> TT -> Maybe (Expr TT) -> Expr TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Char -> Parser TT TT
spc Char
'[' Parser TT (Maybe (Array TT) -> TT -> Maybe (Expr TT) -> Expr TT)
-> Parser TT (Maybe (Array TT))
-> Parser TT (TT -> Maybe (Expr TT) -> Expr TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (Array TT) -> Parser TT (Maybe (Array TT))
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser TT (Array TT)
arrayContents Parser TT (TT -> Maybe (Expr TT) -> Expr TT)
-> Parser TT TT -> Parser TT (Maybe (Expr TT) -> Expr TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Char -> Parser TT TT
plzSpc Char
']'
                Parser TT (Maybe (Expr TT) -> Expr TT)
-> Parser TT (Maybe (Expr TT)) -> Parser TT (Expr TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (Expr TT) -> Parser TT (Maybe (Expr TT))
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser TT (Expr TT)
opExpr
    where
      arrayContents :: P TT (Array TT)
      arrayContents :: Parser TT (Array TT)
arrayContents = Expr TT -> Maybe (Array TT) -> Array TT
forall t. Expr t -> Maybe (Array t) -> Array t
ArrCont (Expr TT -> Maybe (Array TT) -> Array TT)
-> Parser TT (Expr TT) -> Parser TT (Maybe (Array TT) -> Array TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser TT (Expr TT)
expression Parser TT (Maybe (Array TT) -> Array TT)
-> Parser TT (Maybe (Array TT)) -> Parser TT (Array TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (Array TT) -> Parser TT (Maybe (Array TT))
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser TT (Array TT)
arrRest
      arrRest :: P TT (Array TT)
      arrRest :: Parser TT (Array TT)
arrRest = TT -> Array TT -> Maybe (Array TT) -> Array TT
forall t. t -> Array t -> Maybe (Array t) -> Array t
ArrRest (TT -> Array TT -> Maybe (Array TT) -> Array TT)
-> Parser TT TT
-> Parser TT (Array TT -> Maybe (Array TT) -> Array TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Char -> Parser TT TT
spc Char
',' Parser TT (Array TT -> Maybe (Array TT) -> Array TT)
-> Parser TT (Array TT) -> Parser TT (Maybe (Array TT) -> Array TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Parser TT (Array TT)
arrayContents
                                     Parser TT (Array TT)
-> Parser TT (Array TT) -> Parser TT (Array TT)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> TT -> Array TT
forall t. t -> Array t
ArrErr (TT -> Array TT) -> Parser TT TT -> Parser TT (Array TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> Parser TT TT -> Parser TT TT
forall s a. Int -> P s a -> P s a
hate Int
1 ((TT -> Bool) -> Parser TT TT
forall s. (s -> Bool) -> Parser s s
symbol (Bool -> TT -> Bool
forall a b. a -> b -> a
const Bool
True))
                                     Parser TT (Array TT)
-> Parser TT (Array TT) -> Parser TT (Array TT)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> TT -> Array TT
forall t. t -> Array t
ArrErr (TT -> Array TT) -> Parser TT TT -> Parser TT (Array TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> Parser TT TT -> Parser TT TT
forall s a. Int -> P s a -> P s a
hate Int
2 (TT -> Parser TT TT
forall (f :: * -> *) a. Applicative f => a -> f a
pure TT
errorToken))
                                    Parser TT (Maybe (Array TT) -> Array TT)
-> Parser TT (Maybe (Array TT)) -> Parser TT (Array TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (Array TT) -> Parser TT (Maybe (Array TT))
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser TT (Array TT)
arrRest


-- * Parsing helpers

-- | Parses a semicolon if it's there.
semicolon :: P TT (Maybe TT)
semicolon :: Parser TT (Semicolon TT)
semicolon = Parser TT TT -> Parser TT (Semicolon TT)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (Parser TT TT -> Parser TT (Semicolon TT))
-> Parser TT TT -> Parser TT (Semicolon TT)
forall a b. (a -> b) -> a -> b
$ Char -> Parser TT TT
spc Char
';'

-- | Parses a comma-separated list of valid identifiers.
parameters :: P TT (Parameters TT)
parameters :: Parser TT (Parameters TT)
parameters = TT -> [TT] -> TT -> Parameters TT
forall t. t -> BList t -> t -> Parameters t
Parameters (TT -> [TT] -> TT -> Parameters TT)
-> Parser TT TT -> Parser TT ([TT] -> TT -> Parameters TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Char -> Parser TT TT
spc Char
'(' Parser TT ([TT] -> TT -> Parameters TT)
-> Parser TT [TT] -> Parser TT (TT -> Parameters TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT TT -> Parser TT TT
plzTok Parser TT TT
name Parser TT TT -> Parser TT TT -> Parser TT [TT]
forall (f :: * -> *) a v. Alternative f => f a -> f v -> f [a]
`sepBy` Char -> Parser TT TT
spc Char
',' Parser TT (TT -> Parameters TT)
-> Parser TT TT -> Parser TT (Parameters TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Char -> Parser TT TT
plzSpc Char
')'
         Parser TT (Parameters TT)
-> Parser TT (Parameters TT) -> Parser TT (Parameters TT)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> TT -> Parameters TT
forall t. t -> Parameters t
ParErr (TT -> Parameters TT) -> Parser TT TT -> Parser TT (Parameters TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> Parser TT TT -> Parser TT TT
forall s a. Int -> P s a -> P s a
hate Int
1 ((TT -> Bool) -> Parser TT TT
forall s. (s -> Bool) -> Parser s s
symbol (Bool -> TT -> Bool
forall a b. a -> b -> a
const Bool
True))
         Parser TT (Parameters TT)
-> Parser TT (Parameters TT) -> Parser TT (Parameters TT)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> TT -> Parameters TT
forall t. t -> Parameters t
ParErr (TT -> Parameters TT) -> Parser TT TT -> Parser TT (Parameters TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> Parser TT TT -> Parser TT TT
forall s a. Int -> P s a -> P s a
hate Int
2 (TT -> Parser TT TT
forall (f :: * -> *) a. Applicative f => a -> f a
pure TT
errorToken)

parExpr :: P TT (ParExpr TT)
parExpr :: Parser TT (ParExpr TT)
parExpr = TT -> [Expr TT] -> TT -> ParExpr TT
forall t. t -> BList (Expr t) -> t -> ParExpr t
ParExpr (TT -> [Expr TT] -> TT -> ParExpr TT)
-> Parser TT TT -> Parser TT ([Expr TT] -> TT -> ParExpr TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Char -> Parser TT TT
spc Char
'(' Parser TT ([Expr TT] -> TT -> ParExpr TT)
-> Parser TT [Expr TT] -> Parser TT (TT -> ParExpr TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TT (Expr TT)
plzExpr Parser TT (Expr TT) -> Parser TT TT -> Parser TT [Expr TT]
forall (f :: * -> *) a v. Alternative f => f a -> f v -> f [a]
`sepBy` Char -> Parser TT TT
spc Char
',' Parser TT (TT -> ParExpr TT)
-> Parser TT TT -> Parser TT (ParExpr TT)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Char -> Parser TT TT
plzSpc Char
')'
      Parser TT (ParExpr TT)
-> Parser TT (ParExpr TT) -> Parser TT (ParExpr TT)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> TT -> ParExpr TT
forall t. t -> ParExpr t
ParExprErr (TT -> ParExpr TT) -> Parser TT TT -> Parser TT (ParExpr TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> Parser TT TT -> Parser TT TT
forall s a. Int -> P s a -> P s a
hate Int
1 ((TT -> Bool) -> Parser TT TT
forall s. (s -> Bool) -> Parser s s
symbol (Bool -> TT -> Bool
forall a b. a -> b -> a
const Bool
True))
      Parser TT (ParExpr TT)
-> Parser TT (ParExpr TT) -> Parser TT (ParExpr TT)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> TT -> ParExpr TT
forall t. t -> ParExpr t
ParExprErr (TT -> ParExpr TT) -> Parser TT TT -> Parser TT (ParExpr TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> Parser TT TT -> Parser TT TT
forall s a. Int -> P s a -> P s a
hate Int
2 (TT -> Parser TT TT
forall (f :: * -> *) a. Applicative f => a -> f a
pure TT
errorToken)


-- * Simple parsers

-- | Parses a comment.
comment :: P TT TT
comment :: Parser TT TT
comment = (TT -> Bool) -> Parser TT TT
forall s. (s -> Bool) -> Parser s s
symbol (\TT
t -> case TT -> Token
forall t. Tok t -> t
fromTT TT
t of
                          Comment CommentType
_ -> Bool
True
                          Token
_         -> Bool
False)

-- | Parses a prefix operator.
preOp :: P TT TT
preOp :: Parser TT TT
preOp = (TT -> Bool) -> Parser TT TT
forall s. (s -> Bool) -> Parser s s
symbol (\TT
t -> case TT -> Token
forall t. Tok t -> t
fromTT TT
t of
                        Op Operator
x -> Operator
x Operator -> [Operator] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Operator]
prefixOperators
                        Token
_    -> Bool
False)

-- | Parses a infix operator.
inOp :: P TT TT
inOp :: Parser TT TT
inOp = (TT -> Bool) -> Parser TT TT
forall s. (s -> Bool) -> Parser s s
symbol (\TT
t -> case TT -> Token
forall t. Tok t -> t
fromTT TT
t of
                       Op Operator
x -> Operator
x Operator -> [Operator] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Operator]
infixOperators
                       Token
_    -> Bool
False)

-- | Parses a postfix operator.
postOp :: P TT TT
postOp :: Parser TT TT
postOp = (TT -> Bool) -> Parser TT TT
forall s. (s -> Bool) -> Parser s s
symbol (\TT
t -> case TT -> Token
forall t. Tok t -> t
fromTT TT
t of
                         Op Operator
x -> Operator
x Operator -> [Operator] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Operator]
postfixOperators
                         Token
_    -> Bool
False)

-- | Parses any literal.
opTok :: P TT TT
opTok :: Parser TT TT
opTok = (TT -> Bool) -> Parser TT TT
forall s. (s -> Bool) -> Parser s s
symbol (\TT
t -> case TT -> Token
forall t. Tok t -> t
fromTT TT
t of
                        Op Operator
_ -> Bool
True
                        Token
_    -> Bool
False)

-- | Parses any literal.
simpleTok :: P TT TT
simpleTok :: Parser TT TT
simpleTok = (TT -> Bool) -> Parser TT TT
forall s. (s -> Bool) -> Parser s s
symbol (\TT
t -> case TT -> Token
forall t. Tok t -> t
fromTT TT
t of
            Str String
_       -> Bool
True
            Number String
_    -> Bool
True
            ValidName String
_ -> Bool
True
            Const String
_     -> Bool
True
            Rex String
_       -> Bool
True
            Res Reserved
y       -> Reserved
y Reserved -> [Reserved] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Reserved
True', Reserved
False', Reserved
Undefined', Reserved
Null', Reserved
This']
            Token
_           -> Bool
False)

-- | Parses any string.
strTok :: P TT TT
strTok :: Parser TT TT
strTok = (TT -> Bool) -> Parser TT TT
forall s. (s -> Bool) -> Parser s s
symbol (\TT
t -> case TT -> Token
forall t. Tok t -> t
fromTT TT
t of
                         Str String
_ -> Bool
True
                         Token
_     -> Bool
False)

-- | Parses any valid number.
numTok :: P TT TT
numTok :: Parser TT TT
numTok = (TT -> Bool) -> Parser TT TT
forall s. (s -> Bool) -> Parser s s
symbol (\TT
t -> case TT -> Token
forall t. Tok t -> t
fromTT TT
t of
                         Number String
_ -> Bool
True
                         Token
_        -> Bool
False)

-- | Parses any valid identifier.
name :: P TT TT
name :: Parser TT TT
name = (TT -> Bool) -> Parser TT TT
forall s. (s -> Bool) -> Parser s s
symbol (\TT
t -> case TT -> Token
forall t. Tok t -> t
fromTT TT
t of
                       ValidName String
_ -> Bool
True
                       Const     String
_ -> Bool
True
                       Token
_           -> Bool
False)

-- | Parses any boolean.
boolean :: P TT TT
boolean :: Parser TT TT
boolean = (TT -> Bool) -> Parser TT TT
forall s. (s -> Bool) -> Parser s s
symbol (\TT
t -> case TT -> Token
forall t. Tok t -> t
fromTT TT
t of
                          Res Reserved
y -> Reserved
y Reserved -> [Reserved] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Reserved
True', Reserved
False']
                          Token
_     -> Bool
False)

-- | Parses a reserved word.
res :: Reserved -> P TT TT
res :: Reserved -> Parser TT TT
res Reserved
x = (TT -> Bool) -> Parser TT TT
forall s. (s -> Bool) -> Parser s s
symbol (\TT
t -> case TT -> Token
forall t. Tok t -> t
fromTT TT
t of
                        Res Reserved
y -> Reserved
x Reserved -> Reserved -> Bool
forall a. Eq a => a -> a -> Bool
== Reserved
y
                        Token
_     -> Bool
False)

-- | Parses a special token.
spc :: Char -> P TT TT
spc :: Char -> Parser TT TT
spc Char
x = (TT -> Bool) -> Parser TT TT
forall s. (s -> Bool) -> Parser s s
symbol (\TT
t -> case TT -> Token
forall t. Tok t -> t
fromTT TT
t of
                        Special Char
y -> Char
x Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
y
                        Token
_         -> Bool
False)

-- | Parses an operator.
oper :: Operator -> P TT TT
oper :: Operator -> Parser TT TT
oper Operator
x = (TT -> Bool) -> Parser TT TT
forall s. (s -> Bool) -> Parser s s
symbol (\TT
t -> case TT -> Token
forall t. Tok t -> t
fromTT TT
t of
                         Op Operator
y -> Operator
y Operator -> Operator -> Bool
forall a. Eq a => a -> a -> Bool
== Operator
x
                         Token
_    -> Bool
False)


-- * Recovery parsers

-- | Expects a token x, recovers with 'errorToken'.
plzTok :: P TT TT -> P TT TT
plzTok :: Parser TT TT -> Parser TT TT
plzTok Parser TT TT
x = Parser TT TT
x
       Parser TT TT -> Parser TT TT -> Parser TT TT
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Int -> Parser TT TT -> Parser TT TT
forall s a. Int -> P s a -> P s a
hate Int
1 ((TT -> Bool) -> Parser TT TT
forall s. (s -> Bool) -> Parser s s
symbol (Bool -> TT -> Bool
forall a b. a -> b -> a
const Bool
True))
       Parser TT TT -> Parser TT TT -> Parser TT TT
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Int -> Parser TT TT -> Parser TT TT
forall s a. Int -> P s a -> P s a
hate Int
2 (TT -> Parser TT TT
forall (f :: * -> *) a. Applicative f => a -> f a
pure TT
errorToken)

-- | Expects a special token.
plzSpc :: Char -> P TT TT
plzSpc :: Char -> Parser TT TT
plzSpc Char
x = Parser TT TT -> Parser TT TT
plzTok (Char -> Parser TT TT
spc Char
x)

-- | Expects an expression.
plzExpr :: P TT (Expr TT)
plzExpr :: Parser TT (Expr TT)
plzExpr = Parser TT (Expr TT) -> Parser TT (Expr TT)
forall (f :: * -> *). Failable f => P TT (f TT) -> P TT (f TT)
plz Parser TT (Expr TT)
expression

plz :: Failable f => P TT (f TT) -> P TT (f TT)
plz :: P TT (f TT) -> P TT (f TT)
plz P TT (f TT)
x = P TT (f TT)
x
    P TT (f TT) -> P TT (f TT) -> P TT (f TT)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> TT -> f TT
forall (f :: * -> *) t. Failable f => t -> f t
stupid (TT -> f TT) -> Parser TT TT -> P TT (f TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> Parser TT TT -> Parser TT TT
forall s a. Int -> P s a -> P s a
hate Int
1 ((TT -> Bool) -> Parser TT TT
forall s. (s -> Bool) -> Parser s s
symbol (Bool -> TT -> Bool
forall a b. a -> b -> a
const Bool
True))
    P TT (f TT) -> P TT (f TT) -> P TT (f TT)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> TT -> f TT
forall (f :: * -> *) t. Failable f => t -> f t
stupid (TT -> f TT) -> Parser TT TT -> P TT (f TT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> Parser TT TT -> Parser TT TT
forall s a. Int -> P s a -> P s a
hate Int
2 (TT -> Parser TT TT
forall (f :: * -> *) a. Applicative f => a -> f a
pure TT
errorToken)

-- | General recovery parser, inserts an error token.
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)

-- | Weighted recovery.
hate :: Int -> P s a -> P s a
hate :: Int -> P s a -> P s a
hate Int
n = Int -> (P s a -> P s a) -> P s a -> P s a
forall t b. (Eq t, Num t) => t -> (b -> b) -> b -> b
power Int
n P s a -> P s a
forall s a. Parser s a -> Parser s a
recoverWith
    where
      power :: t -> (b -> b) -> b -> b
power t
0 b -> b
_ = b -> b
forall a. a -> a
id
      power t
m b -> b
f = b -> b
f (b -> b) -> (b -> b) -> b -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. t -> (b -> b) -> b -> b
power (t
m t -> t -> t
forall a. Num a => a -> a -> a
- t
1) b -> b
f


-- * Utility stuff

fromBlock :: Block t -> [Statement t]
fromBlock :: Block t -> [Statement t]
fromBlock (Block t
_ [Statement t]
x t
_) = [Statement t] -> [Statement t]
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList [Statement t]
x
fromBlock (BlockOne Statement t
x) = [Statement t
x]
fromBlock (BlockErr t
_) = []

firstTok :: Foldable f => f t -> t
firstTok :: f t -> t
firstTok f t
x = [t] -> t
forall a. [a] -> a
head (f t -> [t]
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList f t
x)

errorToken :: TT
errorToken :: TT
errorToken = Token -> TT
forall t. t -> Tok t
toTT (Token -> TT) -> Token -> TT
forall a b. (a -> b) -> a -> b
$ Char -> Token
Special Char
'!'

isError :: TT -> Bool
isError :: TT -> Bool
isError (Tok (Special Char
'!') Size
_ Posn
_) = Bool
True
isError TT
_ = Bool
False

-- | Better name for 'tokFromT'.
toTT :: t -> Tok t
toTT :: t -> Tok t
toTT = t -> Tok t
forall t. t -> Tok t
tokFromT

-- | Better name for 'tokT'.
fromTT :: Tok t -> t
fromTT :: Tok t -> t
fromTT = Tok t -> t
forall t. Tok t -> t
tokT