Language.Python.Internal.Syntax.IR

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

Methods

_InvalidUnpacking :: Prism' s a

Instances

AsIRError (ParseError a) a

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)

Defined in Language.Python.Internal.Syntax.IR

Methods

(==) :: IRError a -> IRError a -> Bool

(/=) :: IRError a -> IRError a -> Bool

Show a => Show (IRError a)

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

Defined in Language.Python.Internal.Syntax.IR

Methods

fmap :: (a -> b) -> SmallStatement a -> SmallStatement b

(<$) :: a -> SmallStatement b -> SmallStatement a

Foldable SmallStatement

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

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)

Defined in Language.Python.Internal.Syntax.IR

Methods

(==) :: SmallStatement a -> SmallStatement a -> Bool

(/=) :: SmallStatement a -> SmallStatement a -> Bool

Show a => Show (SmallStatement a)

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

Defined in Language.Python.Internal.Syntax.IR

Methods

fmap :: (a -> b) -> Statement a -> Statement b

(<$) :: a -> Statement b -> Statement a

Foldable Statement

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

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)

Defined in Language.Python.Internal.Syntax.IR

Methods

(==) :: Statement a -> Statement a -> Bool

(/=) :: Statement a -> Statement a -> Bool

Show a => Show (Statement a)

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

Defined in Language.Python.Internal.Syntax.IR

Methods

fmap :: (a -> b) -> CompoundStatement a -> CompoundStatement b

(<$) :: a -> CompoundStatement b -> CompoundStatement a

Foldable CompoundStatement

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

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)

Defined in Language.Python.Internal.Syntax.IR

Methods

(==) :: CompoundStatement a -> CompoundStatement a -> Bool

(/=) :: CompoundStatement a -> CompoundStatement a -> Bool

Show a => Show (CompoundStatement a)

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

Defined in Language.Python.Internal.Syntax.IR

Methods

fmap :: (a -> b) -> SimpleStatement a -> SimpleStatement b

(<$) :: a -> SimpleStatement b -> SimpleStatement a

Foldable SimpleStatement

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

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)

Defined in Language.Python.Internal.Syntax.IR

Methods

(==) :: SimpleStatement a -> SimpleStatement a -> Bool

(/=) :: SimpleStatement a -> SimpleStatement a -> Bool

Show a => Show (SimpleStatement a)

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

Defined in Language.Python.Internal.Syntax.IR

Methods

fmap :: (a -> b) -> Param a -> Param b

(<$) :: a -> Param b -> Param a

Foldable Param

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

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)

Defined in Language.Python.Internal.Syntax.IR

Methods

(==) :: Param a -> Param a -> Bool

(/=) :: Param a -> Param a -> Bool

Show a => Show (Param a)

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

Defined in Language.Python.Internal.Syntax.IR

Methods

fmap :: (a -> b) -> CompIf a -> CompIf b

(<$) :: a -> CompIf b -> CompIf a

Foldable CompIf

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

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)

Defined in Language.Python.Internal.Syntax.IR

Methods

(==) :: CompIf a -> CompIf a -> Bool

(/=) :: CompIf a -> CompIf a -> Bool

Show a => Show (CompIf a)

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

Defined in Language.Python.Internal.Syntax.IR

Methods

fmap :: (a -> b) -> CompFor a -> CompFor b

(<$) :: a -> CompFor b -> CompFor a

Foldable CompFor

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

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)

Defined in Language.Python.Internal.Syntax.IR

Methods

(==) :: CompFor a -> CompFor a -> Bool

(/=) :: CompFor a -> CompFor a -> Bool

Show a => Show (CompFor a)

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)

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)

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)

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)

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)

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

Defined in Language.Python.Internal.Syntax.IR

Methods

fmap :: (a -> b) -> Subscript a -> Subscript b

(<$) :: a -> Subscript b -> Subscript a

Foldable Subscript

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

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)

Defined in Language.Python.Internal.Syntax.IR

Methods

(==) :: Subscript a -> Subscript a -> Bool

(/=) :: Subscript a -> Subscript a -> Bool

Show a => Show (Subscript a)

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

Defined in Language.Python.Internal.Syntax.IR

Methods

fmap :: (a -> b) -> DictItem a -> DictItem b

(<$) :: a -> DictItem b -> DictItem a

Foldable DictItem

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

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)

Defined in Language.Python.Internal.Syntax.IR

Methods

(==) :: DictItem a -> DictItem a -> Bool

(/=) :: DictItem a -> DictItem a -> Bool

Show a => Show (DictItem a)

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

Defined in Language.Python.Internal.Syntax.IR

Methods

fmap :: (a -> b) -> Arg a -> Arg b

(<$) :: a -> Arg b -> Arg a

Foldable Arg

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

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)

Defined in Language.Python.Internal.Syntax.IR

Methods

(==) :: Arg a -> Arg a -> Bool

(/=) :: Arg a -> Arg a -> Bool

Show a => Show (Arg a)

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

• _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

Defined in Language.Python.Internal.Syntax.IR

Methods

fmap :: (a -> b) -> Expr a -> Expr b

(<$) :: a -> Expr b -> Expr a

Foldable Expr

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

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)

Defined in Language.Python.Internal.Syntax.IR

Methods

(==) :: Expr a -> Expr a -> Bool

(/=) :: Expr a -> Expr a -> Bool

Show a => Show (Expr a)

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

Defined in Language.Python.Internal.Syntax.IR

Methods

fmap :: (a -> b) -> Suite a -> Suite b

(<$) :: a -> Suite b -> Suite a

Foldable Suite

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

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)

Defined in Language.Python.Internal.Syntax.IR

Methods

(==) :: Suite a -> Suite a -> Bool

(/=) :: Suite a -> Suite a -> Bool

Show a => Show (Suite a)

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

Defined in Language.Python.Internal.Syntax.IR

Methods

fmap :: (a -> b) -> Block a -> Block b

(<$) :: a -> Block b -> Block a

Foldable Block

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

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)

Defined in Language.Python.Internal.Syntax.IR

Methods

(==) :: Block a -> Block a -> Bool

(/=) :: Block a -> Block a -> Bool

Show a => Show (Block a)

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

Defined in Language.Python.Internal.Syntax.IR

Methods

fmap :: (a -> b) -> WithItem a -> WithItem b

(<$) :: a -> WithItem b -> WithItem a

Foldable WithItem

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

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)

Defined in Language.Python.Internal.Syntax.IR

Methods

(==) :: WithItem a -> WithItem a -> Bool

(/=) :: WithItem a -> WithItem a -> Bool

Show a => Show (WithItem a)

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

Defined in Language.Python.Internal.Syntax.IR

Methods

fmap :: (a -> b) -> Decorator a -> Decorator b

(<$) :: a -> Decorator b -> Decorator a

Foldable Decorator

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

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)

Defined in Language.Python.Internal.Syntax.IR

Methods

(==) :: Decorator a -> Decorator a -> Bool

(/=) :: Decorator a -> Decorator a -> Bool

Show a => Show (Decorator a)

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

Defined in Language.Python.Internal.Syntax.IR

Methods

fmap :: (a -> b) -> ExceptAs a -> ExceptAs b

(<$) :: a -> ExceptAs b -> ExceptAs a

Foldable ExceptAs

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

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)

Defined in Language.Python.Internal.Syntax.IR

Methods

(==) :: ExceptAs a -> ExceptAs a -> Bool

(/=) :: ExceptAs a -> ExceptAs a -> Bool

Show a => Show (ExceptAs a)

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

Defined in Language.Python.Internal.Syntax.IR

Methods

fmap :: (a -> b) -> Module a -> Module b

(<$) :: a -> Module b -> Module a

Foldable Module

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

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)

Defined in Language.Python.Internal.Syntax.IR

Methods

(==) :: Module a -> Module a -> Bool

(/=) :: Module a -> Module a -> Bool

Show a => Show (Module a)

Defined in Language.Python.Internal.Syntax.IR

Methods

showsPrec :: Int -> Module a -> ShowS

show :: Module a -> String

showList :: [Module a] -> ShowS

data FromIRContext

Constructors

FromIRContext

Fields

• _allowStarred :: Bool

allowStarred :: Iso' FromIRContext Bool

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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