Copyright	(C) CSIRO 2017-2018
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 Source #

Methods

_InvalidUnpacking :: Prism' s a Source #

Instances

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

data IRError a Source #

Constructors

InvalidUnpacking a

Unpacking ( *value ) was used in an invalid position

Instances

Eq a => Eq (IRError a) Source #
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) Source #
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 Source #

data SmallStatement a Source #

Constructors

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

Instances

Functor SmallStatement Source #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods fmap :: (a -> b) -> SmallStatement a -> SmallStatement b # (<$) :: a -> SmallStatement b -> SmallStatement a #
Foldable SmallStatement Source #
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 Source #
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) Source #
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) Source #
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 Source #

Constructors

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

Instances

Functor Statement Source #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods fmap :: (a -> b) -> Statement a -> Statement b # (<$) :: a -> Statement b -> Statement a #
Foldable Statement Source #
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 Source #
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) Source #
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) Source #
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 Source #

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 Source #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods fmap :: (a -> b) -> CompoundStatement a -> CompoundStatement b # (<$) :: a -> CompoundStatement b -> CompoundStatement a #
Foldable CompoundStatement Source #
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 Source #
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) Source #
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) Source #
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 Source #

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 Source #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods fmap :: (a -> b) -> SimpleStatement a -> SimpleStatement b # (<$) :: a -> SimpleStatement b -> SimpleStatement a #
Foldable SimpleStatement Source #
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 Source #
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) Source #
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) Source #
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 Source #

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 Source #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods fmap :: (a -> b) -> Param a -> Param b # (<$) :: a -> Param b -> Param a #
Foldable Param Source #
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 Source #
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) Source #
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) Source #
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 Source #

Constructors

CompIf a [Whitespace] (Expr a)

'if' any_spaces expr

Instances

Functor CompIf Source #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods fmap :: (a -> b) -> CompIf a -> CompIf b # (<$) :: a -> CompIf b -> CompIf a #
Foldable CompIf Source #
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 Source #
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) Source #
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) Source #
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 Source #

Constructors

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

for any_spaces targets 'in' any_spaces expr

Instances

Functor CompFor Source #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods fmap :: (a -> b) -> CompFor a -> CompFor b # (<$) :: a -> CompFor b -> CompFor a #
Foldable CompFor Source #
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 Source #
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) Source #
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) Source #
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 Source #

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) Source #
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) Source #
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) Source #
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) Source #
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) Source #
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 Source #

Constructors

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

Instances

Functor Subscript Source #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods fmap :: (a -> b) -> Subscript a -> Subscript b # (<$) :: a -> Subscript b -> Subscript a #
Foldable Subscript Source #
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 Source #
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) Source #
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) Source #
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 Source #

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 Source #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods fmap :: (a -> b) -> DictItem a -> DictItem b # (<$) :: a -> DictItem b -> DictItem a #
Foldable DictItem Source #
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 Source #
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) Source #
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) Source #
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 Source #

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 Source #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods fmap :: (a -> b) -> Arg a -> Arg b # (<$) :: a -> Arg b -> Arg a #
Foldable Arg Source #
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 Source #
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) Source #
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) Source #
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 Source #

Constructors

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

Instances

Functor Expr Source #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods fmap :: (a -> b) -> Expr a -> Expr b # (<$) :: a -> Expr b -> Expr a #
Foldable Expr Source #
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 Source #
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) Source #
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) Source #
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 Source #

data Suite a Source #

Constructors

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

Instances

Functor Suite Source #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods fmap :: (a -> b) -> Suite a -> Suite b # (<$) :: a -> Suite b -> Suite a #
Foldable Suite Source #
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 Source #
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) Source #
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) Source #
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 Source #

Constructors

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

Instances

Functor Block Source #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods fmap :: (a -> b) -> Block a -> Block b # (<$) :: a -> Block b -> Block a #
Foldable Block Source #
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 Source #
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) Source #
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) Source #
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 Source #

Constructors

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

Instances

Functor WithItem Source #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods fmap :: (a -> b) -> WithItem a -> WithItem b # (<$) :: a -> WithItem b -> WithItem a #
Foldable WithItem Source #
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 Source #
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) Source #
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) Source #
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 Source #

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 Source #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods fmap :: (a -> b) -> Decorator a -> Decorator b # (<$) :: a -> Decorator b -> Decorator a #
Foldable Decorator Source #
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 Source #
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) Source #
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) Source #
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 Source #

Constructors

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

Instances

Functor ExceptAs Source #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods fmap :: (a -> b) -> ExceptAs a -> ExceptAs b # (<$) :: a -> ExceptAs b -> ExceptAs a #
Foldable ExceptAs Source #
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 Source #
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) Source #
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) Source #
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 Source #

Constructors

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

Instances

Functor Module Source #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods fmap :: (a -> b) -> Module a -> Module b # (<$) :: a -> Module b -> Module a #
Foldable Module Source #
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 Source #
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) Source #
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) Source #
Instance details Defined in Language.Python.Internal.Syntax.IR Methods showsPrec :: Int -> Module a -> ShowS # show :: Module a -> String # showList :: [Module a] -> ShowS #

data FromIRContext Source #

Constructors

FromIRContext
Fields _allowStarred :: Bool

allowStarred :: Iso' FromIRContext Bool Source #

fromIR_expr :: AsIRError e a => Expr a -> Validation (NonEmpty e) (Expr '[] a) Source #

fromIR_suite :: AsIRError e a => Suite a -> Validation (NonEmpty e) (Suite '[] a) Source #

fromIR_param :: AsIRError e a => Param a -> Validation (NonEmpty e) (Param '[] a) Source #

fromIR_arg :: AsIRError e a => Arg a -> Validation (NonEmpty e) (Arg '[] a) Source #

fromIR_decorator :: AsIRError e a => Decorator a -> Validation (NonEmpty e) (Decorator '[] a) Source #

fromIR_exceptAs :: AsIRError e a => ExceptAs a -> Validation (NonEmpty e) (ExceptAs '[] a) Source #

fromIR_withItem :: AsIRError e a => WithItem a -> Validation (NonEmpty e) (WithItem '[] a) Source #

fromIR_comprehension :: AsIRError e a => (ex a -> Validation (NonEmpty e) (ex' '[] a)) -> Comprehension ex a -> Validation (NonEmpty e) (Comprehension ex' '[] a) Source #

fromIR_dictItem :: AsIRError e a => DictItem a -> Validation (NonEmpty e) (DictItem '[] a) Source #

fromIR_subscript :: AsIRError e a => Subscript a -> Validation (NonEmpty e) (Subscript '[] a) Source #

fromIR_block :: AsIRError e a => Block a -> Validation (NonEmpty e) (Block '[] a) Source #

fromIR_compFor :: AsIRError e a => CompFor a -> Validation (NonEmpty e) (CompFor '[] a) Source #

fromIR_compIf :: AsIRError e a => CompIf a -> Validation (NonEmpty e) (CompIf '[] a) Source #

fromIR_smallStatement :: AsIRError e a => SmallStatement a -> Validation (NonEmpty e) (SmallStatement '[] a) Source #

fromIR_statement :: AsIRError e a => Statement a -> Validation (NonEmpty e) (Statement '[] a) Source #

fromIR_SimpleStatement :: AsIRError e a => SimpleStatement a -> Validation (NonEmpty e) (SimpleStatement '[] a) Source #

fromIR_compoundStatement :: AsIRError e a => CompoundStatement a -> Validation (NonEmpty e) (CompoundStatement '[] a) Source #

fromIR_listItem :: AsIRError e a => Expr a -> Validation (NonEmpty e) (ListItem '[] a) Source #

fromIR_tupleItem :: AsIRError e a => Expr a -> Validation (NonEmpty e) (TupleItem '[] a) Source #

fromIR_setItem :: AsIRError e a => Expr a -> Validation (NonEmpty e) (SetItem '[] a) Source #

fromIR :: AsIRError e a => Module a -> Validation (NonEmpty e) (Module '[] a) Source #