Copyright	(C) CSIRO 2017-2019
License	BSD3
Maintainer	Isaac Elliott <isaace71295@gmail.com>
Stability	experimental
Portability	non-portable
Safe Haskell	None
Language	Haskell2010

Language.Python.Internal.Syntax.IR

Description

This module only exists as our current best solution to decoupling parts of the concrete syntax from abstract syntax. You won't need to care about its existence and hopefully it will be deleted soon.

Documentation

class AsIRError s a | s -> a where #

Minimal complete definition

_InvalidUnpacking

Methods

_InvalidUnpacking :: Prism' s a #

Instances

AsIRError (ParseError a) a #
Instance details Defined in Language.Python.Parse.Error Methods _InvalidUnpacking :: Prism' (ParseError a) a #

data IRError a #

Constructors

InvalidUnpacking a

Unpacking ( *value ) was used in an invalid position

Instances

Eq a => Eq (IRError a) #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods (==) :: IRError a -> IRError a -> Bool # (/=) :: IRError a -> IRError a -> Bool #
Show a => Show (IRError a) #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods showsPrec :: Int -> IRError a -> ShowS # show :: IRError a -> String # showList :: [IRError a] -> ShowS #

fromIRError :: AsIRError s a => IRError a -> s #

data SmallStatement a #

Constructors

MkSmallStatement (SimpleStatement a) [(Semicolon a, SimpleStatement a)] (Maybe (Semicolon a)) (Maybe (Comment a)) (Maybe Newline)

Instances

Functor SmallStatement #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods fmap :: (a -> b) -> SmallStatement a -> SmallStatement b # (<$) :: a -> SmallStatement b -> SmallStatement a #
Foldable SmallStatement #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods fold :: Monoid m => SmallStatement m -> m # foldMap :: Monoid m => (a -> m) -> SmallStatement a -> m # foldr :: (a -> b -> b) -> b -> SmallStatement a -> b # foldr' :: (a -> b -> b) -> b -> SmallStatement a -> b # foldl :: (b -> a -> b) -> b -> SmallStatement a -> b # foldl' :: (b -> a -> b) -> b -> SmallStatement a -> b # foldr1 :: (a -> a -> a) -> SmallStatement a -> a # foldl1 :: (a -> a -> a) -> SmallStatement a -> a # toList :: SmallStatement a -> [a] # null :: SmallStatement a -> Bool # length :: SmallStatement a -> Int # elem :: Eq a => a -> SmallStatement a -> Bool # maximum :: Ord a => SmallStatement a -> a # minimum :: Ord a => SmallStatement a -> a # sum :: Num a => SmallStatement a -> a # product :: Num a => SmallStatement a -> a #
Traversable SmallStatement #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods traverse :: Applicative f => (a -> f b) -> SmallStatement a -> f (SmallStatement b) # sequenceA :: Applicative f => SmallStatement (f a) -> f (SmallStatement a) # mapM :: Monad m => (a -> m b) -> SmallStatement a -> m (SmallStatement b) # sequence :: Monad m => SmallStatement (m a) -> m (SmallStatement a) #
Eq a => Eq (SmallStatement a) #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods (==) :: SmallStatement a -> SmallStatement a -> Bool # (/=) :: SmallStatement a -> SmallStatement a -> Bool #
Show a => Show (SmallStatement a) #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods showsPrec :: Int -> SmallStatement a -> ShowS # show :: SmallStatement a -> String # showList :: [SmallStatement a] -> ShowS #

data Statement a #

Constructors

SmallStatement (Indents a) (SmallStatement a)
CompoundStatement (CompoundStatement a)

Instances

Functor Statement #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods fmap :: (a -> b) -> Statement a -> Statement b # (<$) :: a -> Statement b -> Statement a #
Foldable Statement #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods fold :: Monoid m => Statement m -> m # foldMap :: Monoid m => (a -> m) -> Statement a -> m # foldr :: (a -> b -> b) -> b -> Statement a -> b # foldr' :: (a -> b -> b) -> b -> Statement a -> b # foldl :: (b -> a -> b) -> b -> Statement a -> b # foldl' :: (b -> a -> b) -> b -> Statement a -> b # foldr1 :: (a -> a -> a) -> Statement a -> a # foldl1 :: (a -> a -> a) -> Statement a -> a # toList :: Statement a -> [a] # null :: Statement a -> Bool # length :: Statement a -> Int # elem :: Eq a => a -> Statement a -> Bool # maximum :: Ord a => Statement a -> a # minimum :: Ord a => Statement a -> a # sum :: Num a => Statement a -> a # product :: Num a => Statement a -> a #
Traversable Statement #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods traverse :: Applicative f => (a -> f b) -> Statement a -> f (Statement b) # sequenceA :: Applicative f => Statement (f a) -> f (Statement a) # mapM :: Monad m => (a -> m b) -> Statement a -> m (Statement b) # sequence :: Monad m => Statement (m a) -> m (Statement a) #
Eq a => Eq (Statement a) #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods (==) :: Statement a -> Statement a -> Bool # (/=) :: Statement a -> Statement a -> Bool #
Show a => Show (Statement a) #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods showsPrec :: Int -> Statement a -> ShowS # show :: Statement a -> String # showList :: [Statement a] -> ShowS #

data CompoundStatement a #

Constructors

Fundef
Fields _csAnn :: a _unsafeCsFundefDecorators :: [Decorator a] _csIndents :: Indents a _unsafeCsFundefAsync :: Maybe (NonEmpty Whitespace) ['async' <spaces>] _unsafeCsFundefDef :: NonEmpty Whitespace 'def' <spaces> _unsafeCsFundefName :: Ident '[] a <ident> _unsafeCsFundefLeftParen :: [Whitespace] '(' <spaces> _unsafeCsFundefParameters :: CommaSep (Param a) <parameters> _unsafeCsFundefRightParen :: [Whitespace] ')' <spaces> _unsafeCsFundefReturnType :: Maybe ([Whitespace], Expr a) ['->' <spaces> <expr>] _unsafeCsFundefBody :: Suite a <suite>
If
Fields _csAnn :: a _csIndents :: Indents a _unsafeCsIfIf :: [Whitespace] 'if' <spaces> _unsafeCsIfCond :: Expr a <expr> _unsafeCsIfBody :: Suite a <suite> _unsafeCsIfElifs :: [(Indents a, [Whitespace], Expr a, Suite a)] ('elif' <spaces> <expr> <suite>)* _unsafeCsIfElse :: Maybe (Indents a, [Whitespace], Suite a) ['else' <spaces> <suite>]
While
Fields _csAnn :: a _csIndents :: Indents a _unsafeCsWhileWhile :: [Whitespace] 'while' <spaces> _unsafeCsWhileCond :: Expr a <expr> _unsafeCsWhileBody :: Suite a <suite> _unsafeCsWhileElse :: Maybe (Indents a, [Whitespace], Suite a) ['else' <spaces> <suite>]
TryExcept
Fields _csAnn :: a _csIndents :: Indents a _unsafeCsTryExceptTry :: [Whitespace] 'try' <spaces> _unsafeCsTryExceptBody :: Suite a <suite> _unsafeCsTryExceptExcepts :: NonEmpty (Indents a, [Whitespace], Maybe (ExceptAs a), Suite a) ('except' <spaces> <except_as> <suite>)+ _unsafeCsTryExceptElse :: Maybe (Indents a, [Whitespace], Suite a) ['else' <spaces> <suite>] _unsafeCsTryExceptFinally :: Maybe (Indents a, [Whitespace], Suite a) ['finally' <spaces> <suite>]
TryFinally
Fields _csAnn :: a _csIndents :: Indents a _unsafeCsTryFinallyTry :: [Whitespace] 'try' <spaces> _unsafeCsTryFinallyTryBody :: Suite a <suite> _unsafeCsTryFinallyFinallyIndents :: Indents a _unsafeCsTryFinallyFinally :: [Whitespace] 'finally' <spaces> _unsafeCsTryFinallyFinallyBody :: Suite a <suite>
For
Fields _csAnn :: a _csIndents :: Indents a _unsafeCsForAsync :: Maybe (NonEmpty Whitespace) ['async' <spaces>] _unsafeCsForFor :: [Whitespace] 'for' <spaces> _unsafeCsForBinder :: Expr a <expr> _unsafeCsForIn :: [Whitespace] 'in' <spaces> _unsafeCsForCollection :: CommaSep1' (Expr a) <exprs> _unsafeCsForBody :: Suite a <suite> _unsafeCsForElse :: Maybe (Indents a, [Whitespace], Suite a) ['else' <spaces> <suite>]
ClassDef
Fields _csAnn :: a _unsafeCsClassDefDecorators :: [Decorator a] _csIndents :: Indents a _unsafeCsClassDefClass :: NonEmpty Whitespace 'class' <spaces> _unsafeCsClassDefName :: Ident '[] a <ident> _unsafeCsClassDefArguments :: Maybe ([Whitespace], Maybe (CommaSep1' (Arg a)), [Whitespace]) ['(' <spaces> [<args>] ')' <spaces>] _unsafeCsClassDefBody :: Suite a <suite>
With
Fields _csAnn :: a _csIndents :: Indents a _unsafeCsWithAsync :: Maybe (NonEmpty Whitespace) ['async' <spaces>] _unsafeCsWithWith :: [Whitespace] 'with' <spaces> _unsafeCsWithItems :: CommaSep1 (WithItem a) <with_items> _unsafeCsWithBody :: Suite a <suite>

Instances

Functor CompoundStatement #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods fmap :: (a -> b) -> CompoundStatement a -> CompoundStatement b # (<$) :: a -> CompoundStatement b -> CompoundStatement a #
Foldable CompoundStatement #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods fold :: Monoid m => CompoundStatement m -> m # foldMap :: Monoid m => (a -> m) -> CompoundStatement a -> m # foldr :: (a -> b -> b) -> b -> CompoundStatement a -> b # foldr' :: (a -> b -> b) -> b -> CompoundStatement a -> b # foldl :: (b -> a -> b) -> b -> CompoundStatement a -> b # foldl' :: (b -> a -> b) -> b -> CompoundStatement a -> b # foldr1 :: (a -> a -> a) -> CompoundStatement a -> a # foldl1 :: (a -> a -> a) -> CompoundStatement a -> a # toList :: CompoundStatement a -> [a] # null :: CompoundStatement a -> Bool # length :: CompoundStatement a -> Int # elem :: Eq a => a -> CompoundStatement a -> Bool # maximum :: Ord a => CompoundStatement a -> a # minimum :: Ord a => CompoundStatement a -> a # sum :: Num a => CompoundStatement a -> a # product :: Num a => CompoundStatement a -> a #
Traversable CompoundStatement #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods traverse :: Applicative f => (a -> f b) -> CompoundStatement a -> f (CompoundStatement b) # sequenceA :: Applicative f => CompoundStatement (f a) -> f (CompoundStatement a) # mapM :: Monad m => (a -> m b) -> CompoundStatement a -> m (CompoundStatement b) # sequence :: Monad m => CompoundStatement (m a) -> m (CompoundStatement a) #
Eq a => Eq (CompoundStatement a) #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods (==) :: CompoundStatement a -> CompoundStatement a -> Bool # (/=) :: CompoundStatement a -> CompoundStatement a -> Bool #
Show a => Show (CompoundStatement a) #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods showsPrec :: Int -> CompoundStatement a -> ShowS # show :: CompoundStatement a -> String # showList :: [CompoundStatement a] -> ShowS #

data SimpleStatement a #

Constructors

Return a [Whitespace] (Maybe (Expr a))
Expr a (Expr a)
Assign a (Expr a) (NonEmpty (Equals, Expr a))
AugAssign a (Expr a) (AugAssign a) (Expr a)
Pass a [Whitespace]
Break a [Whitespace]
Continue a [Whitespace]
Global a (NonEmpty Whitespace) (CommaSep1 (Ident '[] a))
Nonlocal a (NonEmpty Whitespace) (CommaSep1 (Ident '[] a))
Del a [Whitespace] (CommaSep1' (Expr a))
Import a (NonEmpty Whitespace) (CommaSep1 (ImportAs ModuleName '[] a))
From a [Whitespace] (RelativeModuleName '[] a) [Whitespace] (ImportTargets '[] a)
Raise a [Whitespace] (Maybe (Expr a, Maybe ([Whitespace], Expr a)))
Assert a [Whitespace] (Expr a) (Maybe (Comma, Expr a))

Instances

Functor SimpleStatement #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods fmap :: (a -> b) -> SimpleStatement a -> SimpleStatement b # (<$) :: a -> SimpleStatement b -> SimpleStatement a #
Foldable SimpleStatement #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods fold :: Monoid m => SimpleStatement m -> m # foldMap :: Monoid m => (a -> m) -> SimpleStatement a -> m # foldr :: (a -> b -> b) -> b -> SimpleStatement a -> b # foldr' :: (a -> b -> b) -> b -> SimpleStatement a -> b # foldl :: (b -> a -> b) -> b -> SimpleStatement a -> b # foldl' :: (b -> a -> b) -> b -> SimpleStatement a -> b # foldr1 :: (a -> a -> a) -> SimpleStatement a -> a # foldl1 :: (a -> a -> a) -> SimpleStatement a -> a # toList :: SimpleStatement a -> [a] # null :: SimpleStatement a -> Bool # length :: SimpleStatement a -> Int # elem :: Eq a => a -> SimpleStatement a -> Bool # maximum :: Ord a => SimpleStatement a -> a # minimum :: Ord a => SimpleStatement a -> a # sum :: Num a => SimpleStatement a -> a # product :: Num a => SimpleStatement a -> a #
Traversable SimpleStatement #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods traverse :: Applicative f => (a -> f b) -> SimpleStatement a -> f (SimpleStatement b) # sequenceA :: Applicative f => SimpleStatement (f a) -> f (SimpleStatement a) # mapM :: Monad m => (a -> m b) -> SimpleStatement a -> m (SimpleStatement b) # sequence :: Monad m => SimpleStatement (m a) -> m (SimpleStatement a) #
Eq a => Eq (SimpleStatement a) #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods (==) :: SimpleStatement a -> SimpleStatement a -> Bool # (/=) :: SimpleStatement a -> SimpleStatement a -> Bool #
Show a => Show (SimpleStatement a) #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods showsPrec :: Int -> SimpleStatement a -> ShowS # show :: SimpleStatement a -> String # showList :: [SimpleStatement a] -> ShowS #

data Param a #

Constructors

PositionalParam
Fields _paramAnn :: a _paramName :: Ident '[] a _paramType :: Maybe (Colon, Expr a)
KeywordParam
Fields _paramAnn :: a _paramName :: Ident '[] a _paramType :: Maybe (Colon, Expr a) _unsafeKeywordParamWhitespaceRight :: [Whitespace] _unsafeKeywordParamExpr :: Expr a
StarParam
Fields _paramAnn :: a _unsafeStarParamWhitespace :: [Whitespace] _unsafeStarParamName :: Ident '[] a _paramType :: Maybe (Colon, Expr a)
UnnamedStarParam
Fields _paramAnn :: a _unsafeUnnamedStarParamWhitespace :: [Whitespace]
DoubleStarParam
Fields _paramAnn :: a _unsafeDoubleStarParamWhitespace :: [Whitespace] _paramName :: Ident '[] a _paramType :: Maybe (Colon, Expr a)

Instances

Functor Param #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods fmap :: (a -> b) -> Param a -> Param b # (<$) :: a -> Param b -> Param a #
Foldable Param #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods fold :: Monoid m => Param m -> m # foldMap :: Monoid m => (a -> m) -> Param a -> m # foldr :: (a -> b -> b) -> b -> Param a -> b # foldr' :: (a -> b -> b) -> b -> Param a -> b # foldl :: (b -> a -> b) -> b -> Param a -> b # foldl' :: (b -> a -> b) -> b -> Param a -> b # foldr1 :: (a -> a -> a) -> Param a -> a # foldl1 :: (a -> a -> a) -> Param a -> a # toList :: Param a -> [a] # null :: Param a -> Bool # length :: Param a -> Int # elem :: Eq a => a -> Param a -> Bool # maximum :: Ord a => Param a -> a # minimum :: Ord a => Param a -> a # sum :: Num a => Param a -> a # product :: Num a => Param a -> a #
Traversable Param #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods traverse :: Applicative f => (a -> f b) -> Param a -> f (Param b) # sequenceA :: Applicative f => Param (f a) -> f (Param a) # mapM :: Monad m => (a -> m b) -> Param a -> m (Param b) # sequence :: Monad m => Param (m a) -> m (Param a) #
Eq a => Eq (Param a) #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods (==) :: Param a -> Param a -> Bool # (/=) :: Param a -> Param a -> Bool #
Show a => Show (Param a) #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods showsPrec :: Int -> Param a -> ShowS # show :: Param a -> String # showList :: [Param a] -> ShowS #

data CompIf a #

Constructors

CompIf a [Whitespace] (Expr a)

'if' any_spaces expr

Instances

Functor CompIf #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods fmap :: (a -> b) -> CompIf a -> CompIf b # (<$) :: a -> CompIf b -> CompIf a #
Foldable CompIf #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods fold :: Monoid m => CompIf m -> m # foldMap :: Monoid m => (a -> m) -> CompIf a -> m # foldr :: (a -> b -> b) -> b -> CompIf a -> b # foldr' :: (a -> b -> b) -> b -> CompIf a -> b # foldl :: (b -> a -> b) -> b -> CompIf a -> b # foldl' :: (b -> a -> b) -> b -> CompIf a -> b # foldr1 :: (a -> a -> a) -> CompIf a -> a # foldl1 :: (a -> a -> a) -> CompIf a -> a # toList :: CompIf a -> [a] # null :: CompIf a -> Bool # length :: CompIf a -> Int # elem :: Eq a => a -> CompIf a -> Bool # maximum :: Ord a => CompIf a -> a # minimum :: Ord a => CompIf a -> a # sum :: Num a => CompIf a -> a # product :: Num a => CompIf a -> a #
Traversable CompIf #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods traverse :: Applicative f => (a -> f b) -> CompIf a -> f (CompIf b) # sequenceA :: Applicative f => CompIf (f a) -> f (CompIf a) # mapM :: Monad m => (a -> m b) -> CompIf a -> m (CompIf b) # sequence :: Monad m => CompIf (m a) -> m (CompIf a) #
Eq a => Eq (CompIf a) #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods (==) :: CompIf a -> CompIf a -> Bool # (/=) :: CompIf a -> CompIf a -> Bool #
Show a => Show (CompIf a) #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods showsPrec :: Int -> CompIf a -> ShowS # show :: CompIf a -> String # showList :: [CompIf a] -> ShowS #

data CompFor a #

Constructors

CompFor a [Whitespace] (Expr a) [Whitespace] (Expr a)

for any_spaces targets 'in' any_spaces expr

Instances

Functor CompFor #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods fmap :: (a -> b) -> CompFor a -> CompFor b # (<$) :: a -> CompFor b -> CompFor a #
Foldable CompFor #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods fold :: Monoid m => CompFor m -> m # foldMap :: Monoid m => (a -> m) -> CompFor a -> m # foldr :: (a -> b -> b) -> b -> CompFor a -> b # foldr' :: (a -> b -> b) -> b -> CompFor a -> b # foldl :: (b -> a -> b) -> b -> CompFor a -> b # foldl' :: (b -> a -> b) -> b -> CompFor a -> b # foldr1 :: (a -> a -> a) -> CompFor a -> a # foldl1 :: (a -> a -> a) -> CompFor a -> a # toList :: CompFor a -> [a] # null :: CompFor a -> Bool # length :: CompFor a -> Int # elem :: Eq a => a -> CompFor a -> Bool # maximum :: Ord a => CompFor a -> a # minimum :: Ord a => CompFor a -> a # sum :: Num a => CompFor a -> a # product :: Num a => CompFor a -> a #
Traversable CompFor #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods traverse :: Applicative f => (a -> f b) -> CompFor a -> f (CompFor b) # sequenceA :: Applicative f => CompFor (f a) -> f (CompFor a) # mapM :: Monad m => (a -> m b) -> CompFor a -> m (CompFor b) # sequence :: Monad m => CompFor (m a) -> m (CompFor a) #
Eq a => Eq (CompFor a) #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods (==) :: CompFor a -> CompFor a -> Bool # (/=) :: CompFor a -> CompFor a -> Bool #
Show a => Show (CompFor a) #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods showsPrec :: Int -> CompFor a -> ShowS # show :: CompFor a -> String # showList :: [CompFor a] -> ShowS #

data Comprehension e a #

Constructors

Comprehension a (e a) (CompFor a) [Either (CompFor a) (CompIf a)]

expr comp_for (comp_for | comp_if)*

Instances

Functor e => Functor (Comprehension e) #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods fmap :: (a -> b) -> Comprehension e a -> Comprehension e b # (<$) :: a -> Comprehension e b -> Comprehension e a #
Foldable e => Foldable (Comprehension e) #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods fold :: Monoid m => Comprehension e m -> m # foldMap :: Monoid m => (a -> m) -> Comprehension e a -> m # foldr :: (a -> b -> b) -> b -> Comprehension e a -> b # foldr' :: (a -> b -> b) -> b -> Comprehension e a -> b # foldl :: (b -> a -> b) -> b -> Comprehension e a -> b # foldl' :: (b -> a -> b) -> b -> Comprehension e a -> b # foldr1 :: (a -> a -> a) -> Comprehension e a -> a # foldl1 :: (a -> a -> a) -> Comprehension e a -> a # toList :: Comprehension e a -> [a] # null :: Comprehension e a -> Bool # length :: Comprehension e a -> Int # elem :: Eq a => a -> Comprehension e a -> Bool # maximum :: Ord a => Comprehension e a -> a # minimum :: Ord a => Comprehension e a -> a # sum :: Num a => Comprehension e a -> a # product :: Num a => Comprehension e a -> a #
Traversable e => Traversable (Comprehension e) #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods traverse :: Applicative f => (a -> f b) -> Comprehension e a -> f (Comprehension e b) # sequenceA :: Applicative f => Comprehension e (f a) -> f (Comprehension e a) # mapM :: Monad m => (a -> m b) -> Comprehension e a -> m (Comprehension e b) # sequence :: Monad m => Comprehension e (m a) -> m (Comprehension e a) #
(Eq a, Eq (e a)) => Eq (Comprehension e a) #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods (==) :: Comprehension e a -> Comprehension e a -> Bool # (/=) :: Comprehension e a -> Comprehension e a -> Bool #
(Show a, Show (e a)) => Show (Comprehension e a) #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods showsPrec :: Int -> Comprehension e a -> ShowS # show :: Comprehension e a -> String # showList :: [Comprehension e a] -> ShowS #

data Subscript a #

Constructors

SubscriptExpr (Expr a)
SubscriptSlice (Maybe (Expr a)) Colon (Maybe (Expr a)) (Maybe (Colon, Maybe (Expr a)))

Instances

Functor Subscript #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods fmap :: (a -> b) -> Subscript a -> Subscript b # (<$) :: a -> Subscript b -> Subscript a #
Foldable Subscript #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods fold :: Monoid m => Subscript m -> m # foldMap :: Monoid m => (a -> m) -> Subscript a -> m # foldr :: (a -> b -> b) -> b -> Subscript a -> b # foldr' :: (a -> b -> b) -> b -> Subscript a -> b # foldl :: (b -> a -> b) -> b -> Subscript a -> b # foldl' :: (b -> a -> b) -> b -> Subscript a -> b # foldr1 :: (a -> a -> a) -> Subscript a -> a # foldl1 :: (a -> a -> a) -> Subscript a -> a # toList :: Subscript a -> [a] # null :: Subscript a -> Bool # length :: Subscript a -> Int # elem :: Eq a => a -> Subscript a -> Bool # maximum :: Ord a => Subscript a -> a # minimum :: Ord a => Subscript a -> a # sum :: Num a => Subscript a -> a # product :: Num a => Subscript a -> a #
Traversable Subscript #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods traverse :: Applicative f => (a -> f b) -> Subscript a -> f (Subscript b) # sequenceA :: Applicative f => Subscript (f a) -> f (Subscript a) # mapM :: Monad m => (a -> m b) -> Subscript a -> m (Subscript b) # sequence :: Monad m => Subscript (m a) -> m (Subscript a) #
Eq a => Eq (Subscript a) #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods (==) :: Subscript a -> Subscript a -> Bool # (/=) :: Subscript a -> Subscript a -> Bool #
Show a => Show (Subscript a) #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods showsPrec :: Int -> Subscript a -> ShowS # show :: Subscript a -> String # showList :: [Subscript a] -> ShowS #

data DictItem a #

Constructors

DictItem
Fields _dictItemAnn :: a _unsafeDictItemKey :: Expr a _unsafeDictItemColon :: Colon _unsafeDictItemvalue :: Expr a
DictUnpack
Fields _dictItemAnn :: a _unsafeDictItemUnpackWhitespace :: [Whitespace] _unsafeDictItemUnpackValue :: Expr a

Instances

Functor DictItem #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods fmap :: (a -> b) -> DictItem a -> DictItem b # (<$) :: a -> DictItem b -> DictItem a #
Foldable DictItem #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods fold :: Monoid m => DictItem m -> m # foldMap :: Monoid m => (a -> m) -> DictItem a -> m # foldr :: (a -> b -> b) -> b -> DictItem a -> b # foldr' :: (a -> b -> b) -> b -> DictItem a -> b # foldl :: (b -> a -> b) -> b -> DictItem a -> b # foldl' :: (b -> a -> b) -> b -> DictItem a -> b # foldr1 :: (a -> a -> a) -> DictItem a -> a # foldl1 :: (a -> a -> a) -> DictItem a -> a # toList :: DictItem a -> [a] # null :: DictItem a -> Bool # length :: DictItem a -> Int # elem :: Eq a => a -> DictItem a -> Bool # maximum :: Ord a => DictItem a -> a # minimum :: Ord a => DictItem a -> a # sum :: Num a => DictItem a -> a # product :: Num a => DictItem a -> a #
Traversable DictItem #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods traverse :: Applicative f => (a -> f b) -> DictItem a -> f (DictItem b) # sequenceA :: Applicative f => DictItem (f a) -> f (DictItem a) # mapM :: Monad m => (a -> m b) -> DictItem a -> m (DictItem b) # sequence :: Monad m => DictItem (m a) -> m (DictItem a) #
Eq a => Eq (DictItem a) #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods (==) :: DictItem a -> DictItem a -> Bool # (/=) :: DictItem a -> DictItem a -> Bool #
Show a => Show (DictItem a) #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods showsPrec :: Int -> DictItem a -> ShowS # show :: DictItem a -> String # showList :: [DictItem a] -> ShowS #

data Arg a #

Constructors

PositionalArg
Fields _argAnn :: a _argExpr :: Expr a
KeywordArg
Fields _argAnn :: a _unsafeKeywordArgName :: Ident '[] a _unsafeKeywordArgWhitespaceRight :: [Whitespace] _argExpr :: Expr a
StarArg
Fields _argAnn :: a _unsafeStarArgWhitespace :: [Whitespace] _argExpr :: Expr a
DoubleStarArg
Fields _argAnn :: a _unsafeDoubleStarArgWhitespace :: [Whitespace] _argExpr :: Expr a

Instances

Functor Arg #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods fmap :: (a -> b) -> Arg a -> Arg b # (<$) :: a -> Arg b -> Arg a #
Foldable Arg #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods fold :: Monoid m => Arg m -> m # foldMap :: Monoid m => (a -> m) -> Arg a -> m # foldr :: (a -> b -> b) -> b -> Arg a -> b # foldr' :: (a -> b -> b) -> b -> Arg a -> b # foldl :: (b -> a -> b) -> b -> Arg a -> b # foldl' :: (b -> a -> b) -> b -> Arg a -> b # foldr1 :: (a -> a -> a) -> Arg a -> a # foldl1 :: (a -> a -> a) -> Arg a -> a # toList :: Arg a -> [a] # null :: Arg a -> Bool # length :: Arg a -> Int # elem :: Eq a => a -> Arg a -> Bool # maximum :: Ord a => Arg a -> a # minimum :: Ord a => Arg a -> a # sum :: Num a => Arg a -> a # product :: Num a => Arg a -> a #
Traversable Arg #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods traverse :: Applicative f => (a -> f b) -> Arg a -> f (Arg b) # sequenceA :: Applicative f => Arg (f a) -> f (Arg a) # mapM :: Monad m => (a -> m b) -> Arg a -> m (Arg b) # sequence :: Monad m => Arg (m a) -> m (Arg a) #
Eq a => Eq (Arg a) #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods (==) :: Arg a -> Arg a -> Bool # (/=) :: Arg a -> Arg a -> Bool #
Show a => Show (Arg a) #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods showsPrec :: Int -> Arg a -> ShowS # show :: Arg a -> String # showList :: [Arg a] -> ShowS #

data Expr a #

Constructors

StarExpr
Fields _exprAnn :: a _unsafeStarExprWhitespace :: [Whitespace] _unsafeStarExprValue :: Expr a
Unit
Fields _exprAnn :: a _unsafeUnitWhitespaceInner :: [Whitespace] _unsafeUnitWhitespaceRight :: [Whitespace]
Lambda
Fields _exprAnn :: a _unsafeLambdaWhitespace :: [Whitespace] _unsafeLambdaArgs :: CommaSep (Param a) _unsafeLambdaColon :: Colon _unsafeLambdaBody :: Expr a
Yield
Fields _exprAnn :: a _unsafeYieldWhitespace :: [Whitespace] _unsafeYieldValue :: CommaSep (Expr a)
YieldFrom
Fields _exprAnn :: a _unsafeYieldWhitespace :: [Whitespace] _unsafeFromWhitespace :: [Whitespace] _unsafeYieldFromValue :: Expr a
Ternary
Fields _exprAnn :: a _unsafeTernaryValue :: Expr a _unsafeTernaryWhitespaceIf :: [Whitespace] _unsafeTernaryCond :: Expr a _unsafeTernaryWhitespaceElse :: [Whitespace] _unsafeTernaryElse :: Expr a
ListComp
Fields _exprAnn :: a _unsafeListCompWhitespaceLeft :: [Whitespace] _unsafeListCompValue :: Comprehension Expr a _unsafeListCompWhitespaceRight :: [Whitespace]
List
Fields _exprAnn :: a _unsafeListWhitespaceLeft :: [Whitespace] _unsafeListValues :: Maybe (CommaSep1' (Expr a)) _unsafeListWhitespaceRight :: [Whitespace]
DictComp
Fields _exprAnn :: a _unsafeDictCompWhitespaceLeft :: [Whitespace] _unsafeDictCompValue :: Comprehension DictItem a _unsafeDictCompWhitespaceRight :: [Whitespace]
Dict
Fields _exprAnn :: a _unsafeDictWhitespaceLeft :: [Whitespace] _unsafeDictValues :: Maybe (CommaSep1' (DictItem a)) _unsafeDictWhitespaceRight :: [Whitespace]
SetComp
Fields _exprAnn :: a _unsafeSetCompWhitespaceLeft :: [Whitespace] _unsafeSetCompValue :: Comprehension Expr a _unsafeSetCompWhitespaceRight :: [Whitespace]
Set
Fields _exprAnn :: a _unsafeSetWhitespaceLeft :: [Whitespace] _unsafeSetValues :: CommaSep1' (Expr a) _unsafeSetWhitespaceRight :: [Whitespace]
Deref
Fields _exprAnn :: a _unsafeDerefValueLeft :: Expr a _unsafeDerefWhitespaceLeft :: [Whitespace] _unsafeDerefValueRight :: Ident '[] a
Subscript
Fields _exprAnn :: a _unsafeSubscriptValueLeft :: Expr a _unsafeSubscriptWhitespaceLeft :: [Whitespace] _unsafeSubscriptValueRight :: CommaSep1' (Subscript a) _unsafeSubscriptWhitespaceRight :: [Whitespace]
Call
Fields _exprAnn :: a _unsafeCallFunction :: Expr a _unsafeCallWhitespaceLeft :: [Whitespace] _unsafeCallArguments :: Maybe (CommaSep1' (Arg a)) _unsafeCallWhitespaceRight :: [Whitespace]
None
Fields _exprAnn :: a _unsafeNoneWhitespace :: [Whitespace]
Ellipsis
Fields _exprAnn :: a _unsafeEllipsisWhitespace :: [Whitespace]
BinOp
Fields _exprAnn :: a _unsafeBinOpExprLeft :: Expr a _unsafeBinOpOp :: BinOp a _unsafeBinOpExprRight :: Expr a
UnOp
Fields _exprAnn :: a _unsafeUnOpOp :: UnOp a _unsafeUnOpValue :: Expr a
Parens
Fields _exprAnn :: a _unsafeParensWhitespaceLeft :: [Whitespace] _unsafeParensValue :: Expr a _unsafeParensWhitespaceAfter :: [Whitespace]
Ident
Fields _exprAnn :: a _unsafeIdentValue :: Ident '[] a
Int
Fields _exprAnn :: a _unsafeIntValue :: IntLiteral a _unsafeIntWhitespace :: [Whitespace]
Float
Fields _exprAnn :: a _unsafeFloatValue :: FloatLiteral a _unsafeFloatWhitespace :: [Whitespace]
Imag
Fields _exprAnn :: a _unsafeImagValue :: ImagLiteral a _unsafeImagWhitespace :: [Whitespace]
Bool
Fields _exprAnn :: a _unsafeBoolValue :: Bool _unsafeBoolWhitespace :: [Whitespace]
String
Fields _exprAnn :: a _unsafeStringLiteralValue :: NonEmpty (StringLiteral a)
Tuple
Fields _exprAnn :: a _unsafeTupleHead :: Expr a _unsafeTupleWhitespace :: Comma _unsafeTupleTail :: Maybe (CommaSep1' (Expr a))
Not
Fields _exprAnn :: a _unsafeNotWhitespace :: [Whitespace] _unsafeNotValue :: Expr a
Generator
Fields _exprAnn :: a _generatorValue :: Comprehension Expr a
Await
Fields _exprAnn :: a _unsafeAwaitWhitespace :: [Whitespace] _unsafeAwaitValue :: Expr a

Instances

Functor Expr #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods fmap :: (a -> b) -> Expr a -> Expr b # (<$) :: a -> Expr b -> Expr a #
Foldable Expr #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods fold :: Monoid m => Expr m -> m # foldMap :: Monoid m => (a -> m) -> Expr a -> m # foldr :: (a -> b -> b) -> b -> Expr a -> b # foldr' :: (a -> b -> b) -> b -> Expr a -> b # foldl :: (b -> a -> b) -> b -> Expr a -> b # foldl' :: (b -> a -> b) -> b -> Expr a -> b # foldr1 :: (a -> a -> a) -> Expr a -> a # foldl1 :: (a -> a -> a) -> Expr a -> a # toList :: Expr a -> [a] # null :: Expr a -> Bool # length :: Expr a -> Int # elem :: Eq a => a -> Expr a -> Bool # maximum :: Ord a => Expr a -> a # minimum :: Ord a => Expr a -> a # sum :: Num a => Expr a -> a # product :: Num a => Expr a -> a #
Traversable Expr #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods traverse :: Applicative f => (a -> f b) -> Expr a -> f (Expr b) # sequenceA :: Applicative f => Expr (f a) -> f (Expr a) # mapM :: Monad m => (a -> m b) -> Expr a -> m (Expr b) # sequence :: Monad m => Expr (m a) -> m (Expr a) #
Eq a => Eq (Expr a) #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods (==) :: Expr a -> Expr a -> Bool # (/=) :: Expr a -> Expr a -> Bool #
Show a => Show (Expr a) #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods showsPrec :: Int -> Expr a -> ShowS # show :: Expr a -> String # showList :: [Expr a] -> ShowS #

exprAnn :: Lens' (Expr a) a #

data Suite a #

Constructors

SuiteOne a Colon (SmallStatement a)
SuiteMany a Colon (Maybe (Comment a)) Newline (Block a)

Instances

Functor Suite #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods fmap :: (a -> b) -> Suite a -> Suite b # (<$) :: a -> Suite b -> Suite a #
Foldable Suite #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods fold :: Monoid m => Suite m -> m # foldMap :: Monoid m => (a -> m) -> Suite a -> m # foldr :: (a -> b -> b) -> b -> Suite a -> b # foldr' :: (a -> b -> b) -> b -> Suite a -> b # foldl :: (b -> a -> b) -> b -> Suite a -> b # foldl' :: (b -> a -> b) -> b -> Suite a -> b # foldr1 :: (a -> a -> a) -> Suite a -> a # foldl1 :: (a -> a -> a) -> Suite a -> a # toList :: Suite a -> [a] # null :: Suite a -> Bool # length :: Suite a -> Int # elem :: Eq a => a -> Suite a -> Bool # maximum :: Ord a => Suite a -> a # minimum :: Ord a => Suite a -> a # sum :: Num a => Suite a -> a # product :: Num a => Suite a -> a #
Traversable Suite #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods traverse :: Applicative f => (a -> f b) -> Suite a -> f (Suite b) # sequenceA :: Applicative f => Suite (f a) -> f (Suite a) # mapM :: Monad m => (a -> m b) -> Suite a -> m (Suite b) # sequence :: Monad m => Suite (m a) -> m (Suite a) #
Eq a => Eq (Suite a) #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods (==) :: Suite a -> Suite a -> Bool # (/=) :: Suite a -> Suite a -> Bool #
Show a => Show (Suite a) #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods showsPrec :: Int -> Suite a -> ShowS # show :: Suite a -> String # showList :: [Suite a] -> ShowS #

data Block a #

Constructors

Block
Fields _blockBlankLines :: [(Blank a, Newline)] _blockHead :: Statement a _blockTail :: [Either (Blank a, Newline) (Statement a)]

Instances

Functor Block #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods fmap :: (a -> b) -> Block a -> Block b # (<$) :: a -> Block b -> Block a #
Foldable Block #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods fold :: Monoid m => Block m -> m # foldMap :: Monoid m => (a -> m) -> Block a -> m # foldr :: (a -> b -> b) -> b -> Block a -> b # foldr' :: (a -> b -> b) -> b -> Block a -> b # foldl :: (b -> a -> b) -> b -> Block a -> b # foldl' :: (b -> a -> b) -> b -> Block a -> b # foldr1 :: (a -> a -> a) -> Block a -> a # foldl1 :: (a -> a -> a) -> Block a -> a # toList :: Block a -> [a] # null :: Block a -> Bool # length :: Block a -> Int # elem :: Eq a => a -> Block a -> Bool # maximum :: Ord a => Block a -> a # minimum :: Ord a => Block a -> a # sum :: Num a => Block a -> a # product :: Num a => Block a -> a #
Traversable Block #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods traverse :: Applicative f => (a -> f b) -> Block a -> f (Block b) # sequenceA :: Applicative f => Block (f a) -> f (Block a) # mapM :: Monad m => (a -> m b) -> Block a -> m (Block b) # sequence :: Monad m => Block (m a) -> m (Block a) #
Eq a => Eq (Block a) #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods (==) :: Block a -> Block a -> Bool # (/=) :: Block a -> Block a -> Bool #
Show a => Show (Block a) #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods showsPrec :: Int -> Block a -> ShowS # show :: Block a -> String # showList :: [Block a] -> ShowS #

data WithItem a #

Constructors

WithItem
Fields _withItemAnn :: a _withItemValue :: Expr a _withItemBinder :: Maybe ([Whitespace], Expr a)

Instances

Functor WithItem #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods fmap :: (a -> b) -> WithItem a -> WithItem b # (<$) :: a -> WithItem b -> WithItem a #
Foldable WithItem #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods fold :: Monoid m => WithItem m -> m # foldMap :: Monoid m => (a -> m) -> WithItem a -> m # foldr :: (a -> b -> b) -> b -> WithItem a -> b # foldr' :: (a -> b -> b) -> b -> WithItem a -> b # foldl :: (b -> a -> b) -> b -> WithItem a -> b # foldl' :: (b -> a -> b) -> b -> WithItem a -> b # foldr1 :: (a -> a -> a) -> WithItem a -> a # foldl1 :: (a -> a -> a) -> WithItem a -> a # toList :: WithItem a -> [a] # null :: WithItem a -> Bool # length :: WithItem a -> Int # elem :: Eq a => a -> WithItem a -> Bool # maximum :: Ord a => WithItem a -> a # minimum :: Ord a => WithItem a -> a # sum :: Num a => WithItem a -> a # product :: Num a => WithItem a -> a #
Traversable WithItem #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods traverse :: Applicative f => (a -> f b) -> WithItem a -> f (WithItem b) # sequenceA :: Applicative f => WithItem (f a) -> f (WithItem a) # mapM :: Monad m => (a -> m b) -> WithItem a -> m (WithItem b) # sequence :: Monad m => WithItem (m a) -> m (WithItem a) #
Eq a => Eq (WithItem a) #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods (==) :: WithItem a -> WithItem a -> Bool # (/=) :: WithItem a -> WithItem a -> Bool #
Show a => Show (WithItem a) #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods showsPrec :: Int -> WithItem a -> ShowS # show :: WithItem a -> String # showList :: [WithItem a] -> ShowS #

data Decorator a #

Constructors

Decorator
Fields _decoratorAnn :: a _decoratorIndents :: Indents a _decoratorAt :: At _decoratorExpr :: Expr a _decoratorComment :: Maybe (Comment a) _decoratorNewline :: Newline _decoratorBlankLines :: [(Blank a, Newline)]

Instances

Functor Decorator #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods fmap :: (a -> b) -> Decorator a -> Decorator b # (<$) :: a -> Decorator b -> Decorator a #
Foldable Decorator #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods fold :: Monoid m => Decorator m -> m # foldMap :: Monoid m => (a -> m) -> Decorator a -> m # foldr :: (a -> b -> b) -> b -> Decorator a -> b # foldr' :: (a -> b -> b) -> b -> Decorator a -> b # foldl :: (b -> a -> b) -> b -> Decorator a -> b # foldl' :: (b -> a -> b) -> b -> Decorator a -> b # foldr1 :: (a -> a -> a) -> Decorator a -> a # foldl1 :: (a -> a -> a) -> Decorator a -> a # toList :: Decorator a -> [a] # null :: Decorator a -> Bool # length :: Decorator a -> Int # elem :: Eq a => a -> Decorator a -> Bool # maximum :: Ord a => Decorator a -> a # minimum :: Ord a => Decorator a -> a # sum :: Num a => Decorator a -> a # product :: Num a => Decorator a -> a #
Traversable Decorator #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods traverse :: Applicative f => (a -> f b) -> Decorator a -> f (Decorator b) # sequenceA :: Applicative f => Decorator (f a) -> f (Decorator a) # mapM :: Monad m => (a -> m b) -> Decorator a -> m (Decorator b) # sequence :: Monad m => Decorator (m a) -> m (Decorator a) #
Eq a => Eq (Decorator a) #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods (==) :: Decorator a -> Decorator a -> Bool # (/=) :: Decorator a -> Decorator a -> Bool #
Show a => Show (Decorator a) #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods showsPrec :: Int -> Decorator a -> ShowS # show :: Decorator a -> String # showList :: [Decorator a] -> ShowS #

data ExceptAs a #

Constructors

ExceptAs
Fields _exceptAsAnn :: a _exceptAsExpr :: Expr a _exceptAsName :: Maybe ([Whitespace], Ident '[] a)

Instances

Functor ExceptAs #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods fmap :: (a -> b) -> ExceptAs a -> ExceptAs b # (<$) :: a -> ExceptAs b -> ExceptAs a #
Foldable ExceptAs #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods fold :: Monoid m => ExceptAs m -> m # foldMap :: Monoid m => (a -> m) -> ExceptAs a -> m # foldr :: (a -> b -> b) -> b -> ExceptAs a -> b # foldr' :: (a -> b -> b) -> b -> ExceptAs a -> b # foldl :: (b -> a -> b) -> b -> ExceptAs a -> b # foldl' :: (b -> a -> b) -> b -> ExceptAs a -> b # foldr1 :: (a -> a -> a) -> ExceptAs a -> a # foldl1 :: (a -> a -> a) -> ExceptAs a -> a # toList :: ExceptAs a -> [a] # null :: ExceptAs a -> Bool # length :: ExceptAs a -> Int # elem :: Eq a => a -> ExceptAs a -> Bool # maximum :: Ord a => ExceptAs a -> a # minimum :: Ord a => ExceptAs a -> a # sum :: Num a => ExceptAs a -> a # product :: Num a => ExceptAs a -> a #
Traversable ExceptAs #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods traverse :: Applicative f => (a -> f b) -> ExceptAs a -> f (ExceptAs b) # sequenceA :: Applicative f => ExceptAs (f a) -> f (ExceptAs a) # mapM :: Monad m => (a -> m b) -> ExceptAs a -> m (ExceptAs b) # sequence :: Monad m => ExceptAs (m a) -> m (ExceptAs a) #
Eq a => Eq (ExceptAs a) #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods (==) :: ExceptAs a -> ExceptAs a -> Bool # (/=) :: ExceptAs a -> ExceptAs a -> Bool #
Show a => Show (ExceptAs a) #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods showsPrec :: Int -> ExceptAs a -> ShowS # show :: ExceptAs a -> String # showList :: [ExceptAs a] -> ShowS #

data Module a #

Constructors

ModuleEmpty
ModuleBlankFinal (Blank a)
ModuleBlank (Blank a) Newline (Module a)
ModuleStatement (Statement a) (Module a)

Instances

Functor Module #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods fmap :: (a -> b) -> Module a -> Module b # (<$) :: a -> Module b -> Module a #
Foldable Module #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods fold :: Monoid m => Module m -> m # foldMap :: Monoid m => (a -> m) -> Module a -> m # foldr :: (a -> b -> b) -> b -> Module a -> b # foldr' :: (a -> b -> b) -> b -> Module a -> b # foldl :: (b -> a -> b) -> b -> Module a -> b # foldl' :: (b -> a -> b) -> b -> Module a -> b # foldr1 :: (a -> a -> a) -> Module a -> a # foldl1 :: (a -> a -> a) -> Module a -> a # toList :: Module a -> [a] # null :: Module a -> Bool # length :: Module a -> Int # elem :: Eq a => a -> Module a -> Bool # maximum :: Ord a => Module a -> a # minimum :: Ord a => Module a -> a # sum :: Num a => Module a -> a # product :: Num a => Module a -> a #
Traversable Module #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods traverse :: Applicative f => (a -> f b) -> Module a -> f (Module b) # sequenceA :: Applicative f => Module (f a) -> f (Module a) # mapM :: Monad m => (a -> m b) -> Module a -> m (Module b) # sequence :: Monad m => Module (m a) -> m (Module a) #
Eq a => Eq (Module a) #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods (==) :: Module a -> Module a -> Bool # (/=) :: Module a -> Module a -> Bool #
Show a => Show (Module a) #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods showsPrec :: Int -> Module a -> ShowS # show :: Module a -> String # showList :: [Module a] -> ShowS #