TreeSitter.Python.AST

Documentation

data BreakStatement a

Constructors

BreakStatement

Fields

• ann :: a
• bytes :: Text

Instances

Functor BreakStatement

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable BreakStatement

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => BreakStatement m -> m

foldMap :: Monoid m => (a -> m) -> BreakStatement a -> m

foldr :: (a -> b -> b) -> b -> BreakStatement a -> b

foldr' :: (a -> b -> b) -> b -> BreakStatement a -> b

foldl :: (b -> a -> b) -> b -> BreakStatement a -> b

foldl' :: (b -> a -> b) -> b -> BreakStatement a -> b

foldr1 :: (a -> a -> a) -> BreakStatement a -> a

foldl1 :: (a -> a -> a) -> BreakStatement a -> a

toList :: BreakStatement a -> [a]

null :: BreakStatement a -> Bool

length :: BreakStatement a -> Int

elem :: Eq a => a -> BreakStatement a -> Bool

maximum :: Ord a => BreakStatement a -> a

minimum :: Ord a => BreakStatement a -> a

sum :: Num a => BreakStatement a -> a

product :: Num a => BreakStatement a -> a

Traversable BreakStatement

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> BreakStatement a -> f (BreakStatement b)

sequenceA :: Applicative f => BreakStatement (f a) -> f (BreakStatement a)

mapM :: Monad m => (a -> m b) -> BreakStatement a -> m (BreakStatement b)

sequence :: Monad m => BreakStatement (m a) -> m (BreakStatement a)

SymbolMatching BreakStatement

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy BreakStatement -> Node -> Bool

showFailure :: Proxy BreakStatement -> Node -> String

Unmarshal BreakStatement

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (BreakStatement a)

Eq a => Eq (BreakStatement a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (BreakStatement a)

Defined in TreeSitter.Python.AST

Methods

compare :: BreakStatement a -> BreakStatement a -> Ordering

(<) :: BreakStatement a -> BreakStatement a -> Bool

(<=) :: BreakStatement a -> BreakStatement a -> Bool

(>) :: BreakStatement a -> BreakStatement a -> Bool

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

max :: BreakStatement a -> BreakStatement a -> BreakStatement a

min :: BreakStatement a -> BreakStatement a -> BreakStatement a

Show a => Show (BreakStatement a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> BreakStatement a -> ShowS

show :: BreakStatement a -> String

showList :: [BreakStatement a] -> ShowS

Generic (BreakStatement a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (BreakStatement a) :: Type -> Type

Methods

from :: BreakStatement a -> Rep (BreakStatement a) x

to :: Rep (BreakStatement a) x -> BreakStatement a

Generic1 BreakStatement

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 BreakStatement :: k -> Type

Methods

from1 :: BreakStatement a -> Rep1 BreakStatement a

to1 :: Rep1 BreakStatement a -> BreakStatement a

type Rep (BreakStatement a)

Defined in TreeSitter.Python.AST

type Rep (BreakStatement a) = D1 (MetaData "BreakStatement" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "BreakStatement" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: S1 (MetaSel (Just "bytes") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Text)))

type Rep1 BreakStatement

Defined in TreeSitter.Python.AST

type Rep1 BreakStatement = D1 (MetaData "BreakStatement" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "BreakStatement" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: S1 (MetaSel (Just "bytes") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Text)))

data ContinueStatement a

Constructors

ContinueStatement

Fields

• ann :: a
• bytes :: Text

Instances

Functor ContinueStatement

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable ContinueStatement

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => ContinueStatement m -> m

foldMap :: Monoid m => (a -> m) -> ContinueStatement a -> m

foldr :: (a -> b -> b) -> b -> ContinueStatement a -> b

foldr' :: (a -> b -> b) -> b -> ContinueStatement a -> b

foldl :: (b -> a -> b) -> b -> ContinueStatement a -> b

foldl' :: (b -> a -> b) -> b -> ContinueStatement a -> b

foldr1 :: (a -> a -> a) -> ContinueStatement a -> a

foldl1 :: (a -> a -> a) -> ContinueStatement a -> a

toList :: ContinueStatement a -> [a]

null :: ContinueStatement a -> Bool

length :: ContinueStatement a -> Int

elem :: Eq a => a -> ContinueStatement a -> Bool

maximum :: Ord a => ContinueStatement a -> a

minimum :: Ord a => ContinueStatement a -> a

sum :: Num a => ContinueStatement a -> a

product :: Num a => ContinueStatement a -> a

Traversable ContinueStatement

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> ContinueStatement a -> f (ContinueStatement b)

sequenceA :: Applicative f => ContinueStatement (f a) -> f (ContinueStatement a)

mapM :: Monad m => (a -> m b) -> ContinueStatement a -> m (ContinueStatement b)

sequence :: Monad m => ContinueStatement (m a) -> m (ContinueStatement a)

SymbolMatching ContinueStatement

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy ContinueStatement -> Node -> Bool

showFailure :: Proxy ContinueStatement -> Node -> String

Unmarshal ContinueStatement

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (ContinueStatement a)

Eq a => Eq (ContinueStatement a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (ContinueStatement a)

Defined in TreeSitter.Python.AST

Methods

compare :: ContinueStatement a -> ContinueStatement a -> Ordering

(<) :: ContinueStatement a -> ContinueStatement a -> Bool

(<=) :: ContinueStatement a -> ContinueStatement a -> Bool

(>) :: ContinueStatement a -> ContinueStatement a -> Bool

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

max :: ContinueStatement a -> ContinueStatement a -> ContinueStatement a

min :: ContinueStatement a -> ContinueStatement a -> ContinueStatement a

Show a => Show (ContinueStatement a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> ContinueStatement a -> ShowS

show :: ContinueStatement a -> String

showList :: [ContinueStatement a] -> ShowS

Generic (ContinueStatement a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (ContinueStatement a) :: Type -> Type

Methods

from :: ContinueStatement a -> Rep (ContinueStatement a) x

to :: Rep (ContinueStatement a) x -> ContinueStatement a

Generic1 ContinueStatement

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 ContinueStatement :: k -> Type

Methods

from1 :: ContinueStatement a -> Rep1 ContinueStatement a

to1 :: Rep1 ContinueStatement a -> ContinueStatement a

type Rep (ContinueStatement a)

Defined in TreeSitter.Python.AST

type Rep (ContinueStatement a) = D1 (MetaData "ContinueStatement" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "ContinueStatement" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: S1 (MetaSel (Just "bytes") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Text)))

type Rep1 ContinueStatement

Defined in TreeSitter.Python.AST

type Rep1 ContinueStatement = D1 (MetaData "ContinueStatement" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "ContinueStatement" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: S1 (MetaSel (Just "bytes") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Text)))

data ImportPrefix a

Constructors

ImportPrefix

Fields

• ann :: a
• bytes :: Text

Instances

Functor ImportPrefix

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable ImportPrefix

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => ImportPrefix m -> m

foldMap :: Monoid m => (a -> m) -> ImportPrefix a -> m

foldr :: (a -> b -> b) -> b -> ImportPrefix a -> b

foldr' :: (a -> b -> b) -> b -> ImportPrefix a -> b

foldl :: (b -> a -> b) -> b -> ImportPrefix a -> b

foldl' :: (b -> a -> b) -> b -> ImportPrefix a -> b

foldr1 :: (a -> a -> a) -> ImportPrefix a -> a

foldl1 :: (a -> a -> a) -> ImportPrefix a -> a

toList :: ImportPrefix a -> [a]

null :: ImportPrefix a -> Bool

length :: ImportPrefix a -> Int

elem :: Eq a => a -> ImportPrefix a -> Bool

maximum :: Ord a => ImportPrefix a -> a

minimum :: Ord a => ImportPrefix a -> a

sum :: Num a => ImportPrefix a -> a

product :: Num a => ImportPrefix a -> a

Traversable ImportPrefix

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> ImportPrefix a -> f (ImportPrefix b)

sequenceA :: Applicative f => ImportPrefix (f a) -> f (ImportPrefix a)

mapM :: Monad m => (a -> m b) -> ImportPrefix a -> m (ImportPrefix b)

sequence :: Monad m => ImportPrefix (m a) -> m (ImportPrefix a)

SymbolMatching ImportPrefix

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy ImportPrefix -> Node -> Bool

showFailure :: Proxy ImportPrefix -> Node -> String

Unmarshal ImportPrefix

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (ImportPrefix a)

Eq a => Eq (ImportPrefix a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (ImportPrefix a)

Defined in TreeSitter.Python.AST

Methods

compare :: ImportPrefix a -> ImportPrefix a -> Ordering

(<) :: ImportPrefix a -> ImportPrefix a -> Bool

(<=) :: ImportPrefix a -> ImportPrefix a -> Bool

(>) :: ImportPrefix a -> ImportPrefix a -> Bool

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

max :: ImportPrefix a -> ImportPrefix a -> ImportPrefix a

min :: ImportPrefix a -> ImportPrefix a -> ImportPrefix a

Show a => Show (ImportPrefix a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> ImportPrefix a -> ShowS

show :: ImportPrefix a -> String

showList :: [ImportPrefix a] -> ShowS

Generic (ImportPrefix a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (ImportPrefix a) :: Type -> Type

Methods

from :: ImportPrefix a -> Rep (ImportPrefix a) x

to :: Rep (ImportPrefix a) x -> ImportPrefix a

Generic1 ImportPrefix

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 ImportPrefix :: k -> Type

Methods

from1 :: ImportPrefix a -> Rep1 ImportPrefix a

to1 :: Rep1 ImportPrefix a -> ImportPrefix a

type Rep (ImportPrefix a)

Defined in TreeSitter.Python.AST

type Rep (ImportPrefix a) = D1 (MetaData "ImportPrefix" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "ImportPrefix" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: S1 (MetaSel (Just "bytes") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Text)))

type Rep1 ImportPrefix

Defined in TreeSitter.Python.AST

type Rep1 ImportPrefix = D1 (MetaData "ImportPrefix" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "ImportPrefix" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: S1 (MetaSel (Just "bytes") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Text)))

data PassStatement a

Constructors

PassStatement

Fields

• ann :: a
• bytes :: Text

Instances

Functor PassStatement

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable PassStatement

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => PassStatement m -> m

foldMap :: Monoid m => (a -> m) -> PassStatement a -> m

foldr :: (a -> b -> b) -> b -> PassStatement a -> b

foldr' :: (a -> b -> b) -> b -> PassStatement a -> b

foldl :: (b -> a -> b) -> b -> PassStatement a -> b

foldl' :: (b -> a -> b) -> b -> PassStatement a -> b

foldr1 :: (a -> a -> a) -> PassStatement a -> a

foldl1 :: (a -> a -> a) -> PassStatement a -> a

toList :: PassStatement a -> [a]

null :: PassStatement a -> Bool

length :: PassStatement a -> Int

elem :: Eq a => a -> PassStatement a -> Bool

maximum :: Ord a => PassStatement a -> a

minimum :: Ord a => PassStatement a -> a

sum :: Num a => PassStatement a -> a

product :: Num a => PassStatement a -> a

Traversable PassStatement

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> PassStatement a -> f (PassStatement b)

sequenceA :: Applicative f => PassStatement (f a) -> f (PassStatement a)

mapM :: Monad m => (a -> m b) -> PassStatement a -> m (PassStatement b)

sequence :: Monad m => PassStatement (m a) -> m (PassStatement a)

SymbolMatching PassStatement

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy PassStatement -> Node -> Bool

showFailure :: Proxy PassStatement -> Node -> String

Unmarshal PassStatement

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (PassStatement a)

Eq a => Eq (PassStatement a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (PassStatement a)

Defined in TreeSitter.Python.AST

Methods

compare :: PassStatement a -> PassStatement a -> Ordering

(<) :: PassStatement a -> PassStatement a -> Bool

(<=) :: PassStatement a -> PassStatement a -> Bool

(>) :: PassStatement a -> PassStatement a -> Bool

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

max :: PassStatement a -> PassStatement a -> PassStatement a

min :: PassStatement a -> PassStatement a -> PassStatement a

Show a => Show (PassStatement a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> PassStatement a -> ShowS

show :: PassStatement a -> String

showList :: [PassStatement a] -> ShowS

Generic (PassStatement a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (PassStatement a) :: Type -> Type

Methods

from :: PassStatement a -> Rep (PassStatement a) x

to :: Rep (PassStatement a) x -> PassStatement a

Generic1 PassStatement

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 PassStatement :: k -> Type

Methods

from1 :: PassStatement a -> Rep1 PassStatement a

to1 :: Rep1 PassStatement a -> PassStatement a

type Rep (PassStatement a)

Defined in TreeSitter.Python.AST

type Rep (PassStatement a) = D1 (MetaData "PassStatement" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "PassStatement" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: S1 (MetaSel (Just "bytes") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Text)))

type Rep1 PassStatement

Defined in TreeSitter.Python.AST

type Rep1 PassStatement = D1 (MetaData "PassStatement" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "PassStatement" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: S1 (MetaSel (Just "bytes") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Text)))

data WildcardImport a

Constructors

WildcardImport

Fields

• ann :: a
• bytes :: Text

Instances

Functor WildcardImport

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable WildcardImport

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => WildcardImport m -> m

foldMap :: Monoid m => (a -> m) -> WildcardImport a -> m

foldr :: (a -> b -> b) -> b -> WildcardImport a -> b

foldr' :: (a -> b -> b) -> b -> WildcardImport a -> b

foldl :: (b -> a -> b) -> b -> WildcardImport a -> b

foldl' :: (b -> a -> b) -> b -> WildcardImport a -> b

foldr1 :: (a -> a -> a) -> WildcardImport a -> a

foldl1 :: (a -> a -> a) -> WildcardImport a -> a

toList :: WildcardImport a -> [a]

null :: WildcardImport a -> Bool

length :: WildcardImport a -> Int

elem :: Eq a => a -> WildcardImport a -> Bool

maximum :: Ord a => WildcardImport a -> a

minimum :: Ord a => WildcardImport a -> a

sum :: Num a => WildcardImport a -> a

product :: Num a => WildcardImport a -> a

Traversable WildcardImport

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> WildcardImport a -> f (WildcardImport b)

sequenceA :: Applicative f => WildcardImport (f a) -> f (WildcardImport a)

mapM :: Monad m => (a -> m b) -> WildcardImport a -> m (WildcardImport b)

sequence :: Monad m => WildcardImport (m a) -> m (WildcardImport a)

SymbolMatching WildcardImport

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy WildcardImport -> Node -> Bool

showFailure :: Proxy WildcardImport -> Node -> String

Unmarshal WildcardImport

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (WildcardImport a)

Eq a => Eq (WildcardImport a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (WildcardImport a)

Defined in TreeSitter.Python.AST

Methods

compare :: WildcardImport a -> WildcardImport a -> Ordering

(<) :: WildcardImport a -> WildcardImport a -> Bool

(<=) :: WildcardImport a -> WildcardImport a -> Bool

(>) :: WildcardImport a -> WildcardImport a -> Bool

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

max :: WildcardImport a -> WildcardImport a -> WildcardImport a

min :: WildcardImport a -> WildcardImport a -> WildcardImport a

Show a => Show (WildcardImport a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> WildcardImport a -> ShowS

show :: WildcardImport a -> String

showList :: [WildcardImport a] -> ShowS

Generic (WildcardImport a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (WildcardImport a) :: Type -> Type

Methods

from :: WildcardImport a -> Rep (WildcardImport a) x

to :: Rep (WildcardImport a) x -> WildcardImport a

Generic1 WildcardImport

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 WildcardImport :: k -> Type

Methods

from1 :: WildcardImport a -> Rep1 WildcardImport a

to1 :: Rep1 WildcardImport a -> WildcardImport a

type Rep (WildcardImport a)

Defined in TreeSitter.Python.AST

type Rep (WildcardImport a) = D1 (MetaData "WildcardImport" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "WildcardImport" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: S1 (MetaSel (Just "bytes") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Text)))

type Rep1 WildcardImport

Defined in TreeSitter.Python.AST

type Rep1 WildcardImport = D1 (MetaData "WildcardImport" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "WildcardImport" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: S1 (MetaSel (Just "bytes") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Text)))

newtype AnonymousImport a

Constructors

AnonymousImport

Fields

• ann :: a

Instances

Functor AnonymousImport

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousImport

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousImport m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousImport a -> m

foldr :: (a -> b -> b) -> b -> AnonymousImport a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousImport a -> b

foldl :: (b -> a -> b) -> b -> AnonymousImport a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousImport a -> b

foldr1 :: (a -> a -> a) -> AnonymousImport a -> a

foldl1 :: (a -> a -> a) -> AnonymousImport a -> a

toList :: AnonymousImport a -> [a]

null :: AnonymousImport a -> Bool

length :: AnonymousImport a -> Int

elem :: Eq a => a -> AnonymousImport a -> Bool

maximum :: Ord a => AnonymousImport a -> a

minimum :: Ord a => AnonymousImport a -> a

sum :: Num a => AnonymousImport a -> a

product :: Num a => AnonymousImport a -> a

Traversable AnonymousImport

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousImport a -> f (AnonymousImport b)

sequenceA :: Applicative f => AnonymousImport (f a) -> f (AnonymousImport a)

mapM :: Monad m => (a -> m b) -> AnonymousImport a -> m (AnonymousImport b)

sequence :: Monad m => AnonymousImport (m a) -> m (AnonymousImport a)

SymbolMatching AnonymousImport

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousImport -> Node -> Bool

showFailure :: Proxy AnonymousImport -> Node -> String

Unmarshal AnonymousImport

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousImport a)

Eq a => Eq (AnonymousImport a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousImport a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousImport a -> AnonymousImport a -> Ordering

(<) :: AnonymousImport a -> AnonymousImport a -> Bool

(<=) :: AnonymousImport a -> AnonymousImport a -> Bool

(>) :: AnonymousImport a -> AnonymousImport a -> Bool

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

max :: AnonymousImport a -> AnonymousImport a -> AnonymousImport a

min :: AnonymousImport a -> AnonymousImport a -> AnonymousImport a

Show a => Show (AnonymousImport a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousImport a -> ShowS

show :: AnonymousImport a -> String

showList :: [AnonymousImport a] -> ShowS

Generic (AnonymousImport a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousImport a) :: Type -> Type

Methods

from :: AnonymousImport a -> Rep (AnonymousImport a) x

to :: Rep (AnonymousImport a) x -> AnonymousImport a

Generic1 AnonymousImport

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousImport :: k -> Type

Methods

from1 :: AnonymousImport a -> Rep1 AnonymousImport a

to1 :: Rep1 AnonymousImport a -> AnonymousImport a

type Rep (AnonymousImport a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousImport a) = D1 (MetaData "AnonymousImport" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousImport" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousImport

Defined in TreeSitter.Python.AST

type Rep1 AnonymousImport = D1 (MetaData "AnonymousImport" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousImport" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousDot a

Constructors

AnonymousDot

Fields

• ann :: a

Instances

Functor AnonymousDot

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousDot

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousDot m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousDot a -> m

foldr :: (a -> b -> b) -> b -> AnonymousDot a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousDot a -> b

foldl :: (b -> a -> b) -> b -> AnonymousDot a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousDot a -> b

foldr1 :: (a -> a -> a) -> AnonymousDot a -> a

foldl1 :: (a -> a -> a) -> AnonymousDot a -> a

toList :: AnonymousDot a -> [a]

null :: AnonymousDot a -> Bool

length :: AnonymousDot a -> Int

elem :: Eq a => a -> AnonymousDot a -> Bool

maximum :: Ord a => AnonymousDot a -> a

minimum :: Ord a => AnonymousDot a -> a

sum :: Num a => AnonymousDot a -> a

product :: Num a => AnonymousDot a -> a

Traversable AnonymousDot

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousDot a -> f (AnonymousDot b)

sequenceA :: Applicative f => AnonymousDot (f a) -> f (AnonymousDot a)

mapM :: Monad m => (a -> m b) -> AnonymousDot a -> m (AnonymousDot b)

sequence :: Monad m => AnonymousDot (m a) -> m (AnonymousDot a)

SymbolMatching AnonymousDot

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousDot -> Node -> Bool

showFailure :: Proxy AnonymousDot -> Node -> String

Unmarshal AnonymousDot

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousDot a)

Eq a => Eq (AnonymousDot a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousDot a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousDot a -> AnonymousDot a -> Ordering

(<) :: AnonymousDot a -> AnonymousDot a -> Bool

(<=) :: AnonymousDot a -> AnonymousDot a -> Bool

(>) :: AnonymousDot a -> AnonymousDot a -> Bool

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

max :: AnonymousDot a -> AnonymousDot a -> AnonymousDot a

min :: AnonymousDot a -> AnonymousDot a -> AnonymousDot a

Show a => Show (AnonymousDot a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousDot a -> ShowS

show :: AnonymousDot a -> String

showList :: [AnonymousDot a] -> ShowS

Generic (AnonymousDot a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousDot a) :: Type -> Type

Methods

from :: AnonymousDot a -> Rep (AnonymousDot a) x

to :: Rep (AnonymousDot a) x -> AnonymousDot a

Generic1 AnonymousDot

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousDot :: k -> Type

Methods

from1 :: AnonymousDot a -> Rep1 AnonymousDot a

to1 :: Rep1 AnonymousDot a -> AnonymousDot a

type Rep (AnonymousDot a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousDot a) = D1 (MetaData "AnonymousDot" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousDot" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousDot

Defined in TreeSitter.Python.AST

type Rep1 AnonymousDot = D1 (MetaData "AnonymousDot" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousDot" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousFrom a

Constructors

AnonymousFrom

Fields

• ann :: a

Instances

Functor AnonymousFrom

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousFrom

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousFrom m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousFrom a -> m

foldr :: (a -> b -> b) -> b -> AnonymousFrom a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousFrom a -> b

foldl :: (b -> a -> b) -> b -> AnonymousFrom a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousFrom a -> b

foldr1 :: (a -> a -> a) -> AnonymousFrom a -> a

foldl1 :: (a -> a -> a) -> AnonymousFrom a -> a

toList :: AnonymousFrom a -> [a]

null :: AnonymousFrom a -> Bool

length :: AnonymousFrom a -> Int

elem :: Eq a => a -> AnonymousFrom a -> Bool

maximum :: Ord a => AnonymousFrom a -> a

minimum :: Ord a => AnonymousFrom a -> a

sum :: Num a => AnonymousFrom a -> a

product :: Num a => AnonymousFrom a -> a

Traversable AnonymousFrom

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousFrom a -> f (AnonymousFrom b)

sequenceA :: Applicative f => AnonymousFrom (f a) -> f (AnonymousFrom a)

mapM :: Monad m => (a -> m b) -> AnonymousFrom a -> m (AnonymousFrom b)

sequence :: Monad m => AnonymousFrom (m a) -> m (AnonymousFrom a)

SymbolMatching AnonymousFrom

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousFrom -> Node -> Bool

showFailure :: Proxy AnonymousFrom -> Node -> String

Unmarshal AnonymousFrom

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousFrom a)

Eq a => Eq (AnonymousFrom a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousFrom a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousFrom a -> AnonymousFrom a -> Ordering

(<) :: AnonymousFrom a -> AnonymousFrom a -> Bool

(<=) :: AnonymousFrom a -> AnonymousFrom a -> Bool

(>) :: AnonymousFrom a -> AnonymousFrom a -> Bool

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

max :: AnonymousFrom a -> AnonymousFrom a -> AnonymousFrom a

min :: AnonymousFrom a -> AnonymousFrom a -> AnonymousFrom a

Show a => Show (AnonymousFrom a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousFrom a -> ShowS

show :: AnonymousFrom a -> String

showList :: [AnonymousFrom a] -> ShowS

Generic (AnonymousFrom a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousFrom a) :: Type -> Type

Methods

from :: AnonymousFrom a -> Rep (AnonymousFrom a) x

to :: Rep (AnonymousFrom a) x -> AnonymousFrom a

Generic1 AnonymousFrom

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousFrom :: k -> Type

Methods

from1 :: AnonymousFrom a -> Rep1 AnonymousFrom a

to1 :: Rep1 AnonymousFrom a -> AnonymousFrom a

type Rep (AnonymousFrom a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousFrom a) = D1 (MetaData "AnonymousFrom" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousFrom" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousFrom

Defined in TreeSitter.Python.AST

type Rep1 AnonymousFrom = D1 (MetaData "AnonymousFrom" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousFrom" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousFuture a

Constructors

AnonymousFuture

Fields

• ann :: a

Instances

Functor AnonymousFuture

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousFuture

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousFuture m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousFuture a -> m

foldr :: (a -> b -> b) -> b -> AnonymousFuture a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousFuture a -> b

foldl :: (b -> a -> b) -> b -> AnonymousFuture a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousFuture a -> b

foldr1 :: (a -> a -> a) -> AnonymousFuture a -> a

foldl1 :: (a -> a -> a) -> AnonymousFuture a -> a

toList :: AnonymousFuture a -> [a]

null :: AnonymousFuture a -> Bool

length :: AnonymousFuture a -> Int

elem :: Eq a => a -> AnonymousFuture a -> Bool

maximum :: Ord a => AnonymousFuture a -> a

minimum :: Ord a => AnonymousFuture a -> a

sum :: Num a => AnonymousFuture a -> a

product :: Num a => AnonymousFuture a -> a

Traversable AnonymousFuture

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousFuture a -> f (AnonymousFuture b)

sequenceA :: Applicative f => AnonymousFuture (f a) -> f (AnonymousFuture a)

mapM :: Monad m => (a -> m b) -> AnonymousFuture a -> m (AnonymousFuture b)

sequence :: Monad m => AnonymousFuture (m a) -> m (AnonymousFuture a)

SymbolMatching AnonymousFuture

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousFuture -> Node -> Bool

showFailure :: Proxy AnonymousFuture -> Node -> String

Unmarshal AnonymousFuture

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousFuture a)

Eq a => Eq (AnonymousFuture a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousFuture a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousFuture a -> AnonymousFuture a -> Ordering

(<) :: AnonymousFuture a -> AnonymousFuture a -> Bool

(<=) :: AnonymousFuture a -> AnonymousFuture a -> Bool

(>) :: AnonymousFuture a -> AnonymousFuture a -> Bool

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

max :: AnonymousFuture a -> AnonymousFuture a -> AnonymousFuture a

min :: AnonymousFuture a -> AnonymousFuture a -> AnonymousFuture a

Show a => Show (AnonymousFuture a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousFuture a -> ShowS

show :: AnonymousFuture a -> String

showList :: [AnonymousFuture a] -> ShowS

Generic (AnonymousFuture a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousFuture a) :: Type -> Type

Methods

from :: AnonymousFuture a -> Rep (AnonymousFuture a) x

to :: Rep (AnonymousFuture a) x -> AnonymousFuture a

Generic1 AnonymousFuture

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousFuture :: k -> Type

Methods

from1 :: AnonymousFuture a -> Rep1 AnonymousFuture a

to1 :: Rep1 AnonymousFuture a -> AnonymousFuture a

type Rep (AnonymousFuture a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousFuture a) = D1 (MetaData "AnonymousFuture" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousFuture" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousFuture

Defined in TreeSitter.Python.AST

type Rep1 AnonymousFuture = D1 (MetaData "AnonymousFuture" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousFuture" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousLParen a

Constructors

AnonymousLParen

Fields

• ann :: a

Instances

Functor AnonymousLParen

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousLParen

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousLParen m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousLParen a -> m

foldr :: (a -> b -> b) -> b -> AnonymousLParen a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousLParen a -> b

foldl :: (b -> a -> b) -> b -> AnonymousLParen a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousLParen a -> b

foldr1 :: (a -> a -> a) -> AnonymousLParen a -> a

foldl1 :: (a -> a -> a) -> AnonymousLParen a -> a

toList :: AnonymousLParen a -> [a]

null :: AnonymousLParen a -> Bool

length :: AnonymousLParen a -> Int

elem :: Eq a => a -> AnonymousLParen a -> Bool

maximum :: Ord a => AnonymousLParen a -> a

minimum :: Ord a => AnonymousLParen a -> a

sum :: Num a => AnonymousLParen a -> a

product :: Num a => AnonymousLParen a -> a

Traversable AnonymousLParen

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousLParen a -> f (AnonymousLParen b)

sequenceA :: Applicative f => AnonymousLParen (f a) -> f (AnonymousLParen a)

mapM :: Monad m => (a -> m b) -> AnonymousLParen a -> m (AnonymousLParen b)

sequence :: Monad m => AnonymousLParen (m a) -> m (AnonymousLParen a)

SymbolMatching AnonymousLParen

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousLParen -> Node -> Bool

showFailure :: Proxy AnonymousLParen -> Node -> String

Unmarshal AnonymousLParen

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousLParen a)

Eq a => Eq (AnonymousLParen a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousLParen a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousLParen a -> AnonymousLParen a -> Ordering

(<) :: AnonymousLParen a -> AnonymousLParen a -> Bool

(<=) :: AnonymousLParen a -> AnonymousLParen a -> Bool

(>) :: AnonymousLParen a -> AnonymousLParen a -> Bool

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

max :: AnonymousLParen a -> AnonymousLParen a -> AnonymousLParen a

min :: AnonymousLParen a -> AnonymousLParen a -> AnonymousLParen a

Show a => Show (AnonymousLParen a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousLParen a -> ShowS

show :: AnonymousLParen a -> String

showList :: [AnonymousLParen a] -> ShowS

Generic (AnonymousLParen a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousLParen a) :: Type -> Type

Methods

from :: AnonymousLParen a -> Rep (AnonymousLParen a) x

to :: Rep (AnonymousLParen a) x -> AnonymousLParen a

Generic1 AnonymousLParen

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousLParen :: k -> Type

Methods

from1 :: AnonymousLParen a -> Rep1 AnonymousLParen a

to1 :: Rep1 AnonymousLParen a -> AnonymousLParen a

type Rep (AnonymousLParen a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousLParen a) = D1 (MetaData "AnonymousLParen" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousLParen" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousLParen

Defined in TreeSitter.Python.AST

type Rep1 AnonymousLParen = D1 (MetaData "AnonymousLParen" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousLParen" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousRParen a

Constructors

AnonymousRParen

Fields

• ann :: a

Instances

Functor AnonymousRParen

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousRParen

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousRParen m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousRParen a -> m

foldr :: (a -> b -> b) -> b -> AnonymousRParen a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousRParen a -> b

foldl :: (b -> a -> b) -> b -> AnonymousRParen a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousRParen a -> b

foldr1 :: (a -> a -> a) -> AnonymousRParen a -> a

foldl1 :: (a -> a -> a) -> AnonymousRParen a -> a

toList :: AnonymousRParen a -> [a]

null :: AnonymousRParen a -> Bool

length :: AnonymousRParen a -> Int

elem :: Eq a => a -> AnonymousRParen a -> Bool

maximum :: Ord a => AnonymousRParen a -> a

minimum :: Ord a => AnonymousRParen a -> a

sum :: Num a => AnonymousRParen a -> a

product :: Num a => AnonymousRParen a -> a

Traversable AnonymousRParen

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousRParen a -> f (AnonymousRParen b)

sequenceA :: Applicative f => AnonymousRParen (f a) -> f (AnonymousRParen a)

mapM :: Monad m => (a -> m b) -> AnonymousRParen a -> m (AnonymousRParen b)

sequence :: Monad m => AnonymousRParen (m a) -> m (AnonymousRParen a)

SymbolMatching AnonymousRParen

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousRParen -> Node -> Bool

showFailure :: Proxy AnonymousRParen -> Node -> String

Unmarshal AnonymousRParen

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousRParen a)

Eq a => Eq (AnonymousRParen a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousRParen a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousRParen a -> AnonymousRParen a -> Ordering

(<) :: AnonymousRParen a -> AnonymousRParen a -> Bool

(<=) :: AnonymousRParen a -> AnonymousRParen a -> Bool

(>) :: AnonymousRParen a -> AnonymousRParen a -> Bool

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

max :: AnonymousRParen a -> AnonymousRParen a -> AnonymousRParen a

min :: AnonymousRParen a -> AnonymousRParen a -> AnonymousRParen a

Show a => Show (AnonymousRParen a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousRParen a -> ShowS

show :: AnonymousRParen a -> String

showList :: [AnonymousRParen a] -> ShowS

Generic (AnonymousRParen a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousRParen a) :: Type -> Type

Methods

from :: AnonymousRParen a -> Rep (AnonymousRParen a) x

to :: Rep (AnonymousRParen a) x -> AnonymousRParen a

Generic1 AnonymousRParen

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousRParen :: k -> Type

Methods

from1 :: AnonymousRParen a -> Rep1 AnonymousRParen a

to1 :: Rep1 AnonymousRParen a -> AnonymousRParen a

type Rep (AnonymousRParen a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousRParen a) = D1 (MetaData "AnonymousRParen" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousRParen" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousRParen

Defined in TreeSitter.Python.AST

type Rep1 AnonymousRParen = D1 (MetaData "AnonymousRParen" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousRParen" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousComma a

Constructors

AnonymousComma

Fields

• ann :: a

Instances

Functor AnonymousComma

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousComma

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousComma m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousComma a -> m

foldr :: (a -> b -> b) -> b -> AnonymousComma a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousComma a -> b

foldl :: (b -> a -> b) -> b -> AnonymousComma a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousComma a -> b

foldr1 :: (a -> a -> a) -> AnonymousComma a -> a

foldl1 :: (a -> a -> a) -> AnonymousComma a -> a

toList :: AnonymousComma a -> [a]

null :: AnonymousComma a -> Bool

length :: AnonymousComma a -> Int

elem :: Eq a => a -> AnonymousComma a -> Bool

maximum :: Ord a => AnonymousComma a -> a

minimum :: Ord a => AnonymousComma a -> a

sum :: Num a => AnonymousComma a -> a

product :: Num a => AnonymousComma a -> a

Traversable AnonymousComma

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousComma a -> f (AnonymousComma b)

sequenceA :: Applicative f => AnonymousComma (f a) -> f (AnonymousComma a)

mapM :: Monad m => (a -> m b) -> AnonymousComma a -> m (AnonymousComma b)

sequence :: Monad m => AnonymousComma (m a) -> m (AnonymousComma a)

SymbolMatching AnonymousComma

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousComma -> Node -> Bool

showFailure :: Proxy AnonymousComma -> Node -> String

Unmarshal AnonymousComma

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousComma a)

Eq a => Eq (AnonymousComma a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousComma a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousComma a -> AnonymousComma a -> Ordering

(<) :: AnonymousComma a -> AnonymousComma a -> Bool

(<=) :: AnonymousComma a -> AnonymousComma a -> Bool

(>) :: AnonymousComma a -> AnonymousComma a -> Bool

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

max :: AnonymousComma a -> AnonymousComma a -> AnonymousComma a

min :: AnonymousComma a -> AnonymousComma a -> AnonymousComma a

Show a => Show (AnonymousComma a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousComma a -> ShowS

show :: AnonymousComma a -> String

showList :: [AnonymousComma a] -> ShowS

Generic (AnonymousComma a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousComma a) :: Type -> Type

Methods

from :: AnonymousComma a -> Rep (AnonymousComma a) x

to :: Rep (AnonymousComma a) x -> AnonymousComma a

Generic1 AnonymousComma

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousComma :: k -> Type

Methods

from1 :: AnonymousComma a -> Rep1 AnonymousComma a

to1 :: Rep1 AnonymousComma a -> AnonymousComma a

type Rep (AnonymousComma a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousComma a) = D1 (MetaData "AnonymousComma" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousComma" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousComma

Defined in TreeSitter.Python.AST

type Rep1 AnonymousComma = D1 (MetaData "AnonymousComma" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousComma" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousAs a

Constructors

AnonymousAs

Fields

• ann :: a

Instances

Functor AnonymousAs

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousAs

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousAs m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousAs a -> m

foldr :: (a -> b -> b) -> b -> AnonymousAs a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousAs a -> b

foldl :: (b -> a -> b) -> b -> AnonymousAs a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousAs a -> b

foldr1 :: (a -> a -> a) -> AnonymousAs a -> a

foldl1 :: (a -> a -> a) -> AnonymousAs a -> a

toList :: AnonymousAs a -> [a]

null :: AnonymousAs a -> Bool

length :: AnonymousAs a -> Int

elem :: Eq a => a -> AnonymousAs a -> Bool

maximum :: Ord a => AnonymousAs a -> a

minimum :: Ord a => AnonymousAs a -> a

sum :: Num a => AnonymousAs a -> a

product :: Num a => AnonymousAs a -> a

Traversable AnonymousAs

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousAs a -> f (AnonymousAs b)

sequenceA :: Applicative f => AnonymousAs (f a) -> f (AnonymousAs a)

mapM :: Monad m => (a -> m b) -> AnonymousAs a -> m (AnonymousAs b)

sequence :: Monad m => AnonymousAs (m a) -> m (AnonymousAs a)

SymbolMatching AnonymousAs

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousAs -> Node -> Bool

showFailure :: Proxy AnonymousAs -> Node -> String

Unmarshal AnonymousAs

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousAs a)

Eq a => Eq (AnonymousAs a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousAs a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousAs a -> AnonymousAs a -> Ordering

(<) :: AnonymousAs a -> AnonymousAs a -> Bool

(<=) :: AnonymousAs a -> AnonymousAs a -> Bool

(>) :: AnonymousAs a -> AnonymousAs a -> Bool

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

max :: AnonymousAs a -> AnonymousAs a -> AnonymousAs a

min :: AnonymousAs a -> AnonymousAs a -> AnonymousAs a

Show a => Show (AnonymousAs a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousAs a -> ShowS

show :: AnonymousAs a -> String

showList :: [AnonymousAs a] -> ShowS

Generic (AnonymousAs a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousAs a) :: Type -> Type

Methods

from :: AnonymousAs a -> Rep (AnonymousAs a) x

to :: Rep (AnonymousAs a) x -> AnonymousAs a

Generic1 AnonymousAs

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousAs :: k -> Type

Methods

from1 :: AnonymousAs a -> Rep1 AnonymousAs a

to1 :: Rep1 AnonymousAs a -> AnonymousAs a

type Rep (AnonymousAs a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousAs a) = D1 (MetaData "AnonymousAs" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousAs" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousAs

Defined in TreeSitter.Python.AST

type Rep1 AnonymousAs = D1 (MetaData "AnonymousAs" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousAs" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousStar a

Constructors

AnonymousStar

Fields

• ann :: a

Instances

Functor AnonymousStar

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousStar

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousStar m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousStar a -> m

foldr :: (a -> b -> b) -> b -> AnonymousStar a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousStar a -> b

foldl :: (b -> a -> b) -> b -> AnonymousStar a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousStar a -> b

foldr1 :: (a -> a -> a) -> AnonymousStar a -> a

foldl1 :: (a -> a -> a) -> AnonymousStar a -> a

toList :: AnonymousStar a -> [a]

null :: AnonymousStar a -> Bool

length :: AnonymousStar a -> Int

elem :: Eq a => a -> AnonymousStar a -> Bool

maximum :: Ord a => AnonymousStar a -> a

minimum :: Ord a => AnonymousStar a -> a

sum :: Num a => AnonymousStar a -> a

product :: Num a => AnonymousStar a -> a

Traversable AnonymousStar

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousStar a -> f (AnonymousStar b)

sequenceA :: Applicative f => AnonymousStar (f a) -> f (AnonymousStar a)

mapM :: Monad m => (a -> m b) -> AnonymousStar a -> m (AnonymousStar b)

sequence :: Monad m => AnonymousStar (m a) -> m (AnonymousStar a)

SymbolMatching AnonymousStar

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousStar -> Node -> Bool

showFailure :: Proxy AnonymousStar -> Node -> String

Unmarshal AnonymousStar

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousStar a)

Eq a => Eq (AnonymousStar a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousStar a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousStar a -> AnonymousStar a -> Ordering

(<) :: AnonymousStar a -> AnonymousStar a -> Bool

(<=) :: AnonymousStar a -> AnonymousStar a -> Bool

(>) :: AnonymousStar a -> AnonymousStar a -> Bool

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

max :: AnonymousStar a -> AnonymousStar a -> AnonymousStar a

min :: AnonymousStar a -> AnonymousStar a -> AnonymousStar a

Show a => Show (AnonymousStar a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousStar a -> ShowS

show :: AnonymousStar a -> String

showList :: [AnonymousStar a] -> ShowS

Generic (AnonymousStar a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousStar a) :: Type -> Type

Methods

from :: AnonymousStar a -> Rep (AnonymousStar a) x

to :: Rep (AnonymousStar a) x -> AnonymousStar a

Generic1 AnonymousStar

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousStar :: k -> Type

Methods

from1 :: AnonymousStar a -> Rep1 AnonymousStar a

to1 :: Rep1 AnonymousStar a -> AnonymousStar a

type Rep (AnonymousStar a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousStar a) = D1 (MetaData "AnonymousStar" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousStar" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousStar

Defined in TreeSitter.Python.AST

type Rep1 AnonymousStar = D1 (MetaData "AnonymousStar" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousStar" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousPrint a

Constructors

AnonymousPrint

Fields

• ann :: a

Instances

Functor AnonymousPrint

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousPrint

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousPrint m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousPrint a -> m

foldr :: (a -> b -> b) -> b -> AnonymousPrint a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousPrint a -> b

foldl :: (b -> a -> b) -> b -> AnonymousPrint a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousPrint a -> b

foldr1 :: (a -> a -> a) -> AnonymousPrint a -> a

foldl1 :: (a -> a -> a) -> AnonymousPrint a -> a

toList :: AnonymousPrint a -> [a]

null :: AnonymousPrint a -> Bool

length :: AnonymousPrint a -> Int

elem :: Eq a => a -> AnonymousPrint a -> Bool

maximum :: Ord a => AnonymousPrint a -> a

minimum :: Ord a => AnonymousPrint a -> a

sum :: Num a => AnonymousPrint a -> a

product :: Num a => AnonymousPrint a -> a

Traversable AnonymousPrint

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousPrint a -> f (AnonymousPrint b)

sequenceA :: Applicative f => AnonymousPrint (f a) -> f (AnonymousPrint a)

mapM :: Monad m => (a -> m b) -> AnonymousPrint a -> m (AnonymousPrint b)

sequence :: Monad m => AnonymousPrint (m a) -> m (AnonymousPrint a)

SymbolMatching AnonymousPrint

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousPrint -> Node -> Bool

showFailure :: Proxy AnonymousPrint -> Node -> String

Unmarshal AnonymousPrint

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousPrint a)

Eq a => Eq (AnonymousPrint a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousPrint a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousPrint a -> AnonymousPrint a -> Ordering

(<) :: AnonymousPrint a -> AnonymousPrint a -> Bool

(<=) :: AnonymousPrint a -> AnonymousPrint a -> Bool

(>) :: AnonymousPrint a -> AnonymousPrint a -> Bool

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

max :: AnonymousPrint a -> AnonymousPrint a -> AnonymousPrint a

min :: AnonymousPrint a -> AnonymousPrint a -> AnonymousPrint a

Show a => Show (AnonymousPrint a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousPrint a -> ShowS

show :: AnonymousPrint a -> String

showList :: [AnonymousPrint a] -> ShowS

Generic (AnonymousPrint a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousPrint a) :: Type -> Type

Methods

from :: AnonymousPrint a -> Rep (AnonymousPrint a) x

to :: Rep (AnonymousPrint a) x -> AnonymousPrint a

Generic1 AnonymousPrint

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousPrint :: k -> Type

Methods

from1 :: AnonymousPrint a -> Rep1 AnonymousPrint a

to1 :: Rep1 AnonymousPrint a -> AnonymousPrint a

type Rep (AnonymousPrint a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousPrint a) = D1 (MetaData "AnonymousPrint" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousPrint" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousPrint

Defined in TreeSitter.Python.AST

type Rep1 AnonymousPrint = D1 (MetaData "AnonymousPrint" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousPrint" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousRAngleRAngle a

Constructors

AnonymousRAngleRAngle

Fields

• ann :: a

Instances

Functor AnonymousRAngleRAngle

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousRAngleRAngle

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousRAngleRAngle m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousRAngleRAngle a -> m

foldr :: (a -> b -> b) -> b -> AnonymousRAngleRAngle a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousRAngleRAngle a -> b

foldl :: (b -> a -> b) -> b -> AnonymousRAngleRAngle a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousRAngleRAngle a -> b

foldr1 :: (a -> a -> a) -> AnonymousRAngleRAngle a -> a

foldl1 :: (a -> a -> a) -> AnonymousRAngleRAngle a -> a

toList :: AnonymousRAngleRAngle a -> [a]

null :: AnonymousRAngleRAngle a -> Bool

length :: AnonymousRAngleRAngle a -> Int

elem :: Eq a => a -> AnonymousRAngleRAngle a -> Bool

maximum :: Ord a => AnonymousRAngleRAngle a -> a

minimum :: Ord a => AnonymousRAngleRAngle a -> a

sum :: Num a => AnonymousRAngleRAngle a -> a

product :: Num a => AnonymousRAngleRAngle a -> a

Traversable AnonymousRAngleRAngle

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousRAngleRAngle a -> f (AnonymousRAngleRAngle b)

sequenceA :: Applicative f => AnonymousRAngleRAngle (f a) -> f (AnonymousRAngleRAngle a)

mapM :: Monad m => (a -> m b) -> AnonymousRAngleRAngle a -> m (AnonymousRAngleRAngle b)

sequence :: Monad m => AnonymousRAngleRAngle (m a) -> m (AnonymousRAngleRAngle a)

SymbolMatching AnonymousRAngleRAngle

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousRAngleRAngle -> Node -> Bool

showFailure :: Proxy AnonymousRAngleRAngle -> Node -> String

Unmarshal AnonymousRAngleRAngle

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousRAngleRAngle a)

Eq a => Eq (AnonymousRAngleRAngle a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousRAngleRAngle a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousRAngleRAngle a -> AnonymousRAngleRAngle a -> Ordering

(<) :: AnonymousRAngleRAngle a -> AnonymousRAngleRAngle a -> Bool

(<=) :: AnonymousRAngleRAngle a -> AnonymousRAngleRAngle a -> Bool

(>) :: AnonymousRAngleRAngle a -> AnonymousRAngleRAngle a -> Bool

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

max :: AnonymousRAngleRAngle a -> AnonymousRAngleRAngle a -> AnonymousRAngleRAngle a

min :: AnonymousRAngleRAngle a -> AnonymousRAngleRAngle a -> AnonymousRAngleRAngle a

Show a => Show (AnonymousRAngleRAngle a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousRAngleRAngle a -> ShowS

show :: AnonymousRAngleRAngle a -> String

showList :: [AnonymousRAngleRAngle a] -> ShowS

Generic (AnonymousRAngleRAngle a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousRAngleRAngle a) :: Type -> Type

Methods

from :: AnonymousRAngleRAngle a -> Rep (AnonymousRAngleRAngle a) x

to :: Rep (AnonymousRAngleRAngle a) x -> AnonymousRAngleRAngle a

Generic1 AnonymousRAngleRAngle

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousRAngleRAngle :: k -> Type

Methods

from1 :: AnonymousRAngleRAngle a -> Rep1 AnonymousRAngleRAngle a

to1 :: Rep1 AnonymousRAngleRAngle a -> AnonymousRAngleRAngle a

type Rep (AnonymousRAngleRAngle a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousRAngleRAngle a) = D1 (MetaData "AnonymousRAngleRAngle" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousRAngleRAngle" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousRAngleRAngle

Defined in TreeSitter.Python.AST

type Rep1 AnonymousRAngleRAngle = D1 (MetaData "AnonymousRAngleRAngle" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousRAngleRAngle" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousAssert a

Constructors

AnonymousAssert

Fields

• ann :: a

Instances

Functor AnonymousAssert

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousAssert

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousAssert m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousAssert a -> m

foldr :: (a -> b -> b) -> b -> AnonymousAssert a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousAssert a -> b

foldl :: (b -> a -> b) -> b -> AnonymousAssert a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousAssert a -> b

foldr1 :: (a -> a -> a) -> AnonymousAssert a -> a

foldl1 :: (a -> a -> a) -> AnonymousAssert a -> a

toList :: AnonymousAssert a -> [a]

null :: AnonymousAssert a -> Bool

length :: AnonymousAssert a -> Int

elem :: Eq a => a -> AnonymousAssert a -> Bool

maximum :: Ord a => AnonymousAssert a -> a

minimum :: Ord a => AnonymousAssert a -> a

sum :: Num a => AnonymousAssert a -> a

product :: Num a => AnonymousAssert a -> a

Traversable AnonymousAssert

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousAssert a -> f (AnonymousAssert b)

sequenceA :: Applicative f => AnonymousAssert (f a) -> f (AnonymousAssert a)

mapM :: Monad m => (a -> m b) -> AnonymousAssert a -> m (AnonymousAssert b)

sequence :: Monad m => AnonymousAssert (m a) -> m (AnonymousAssert a)

SymbolMatching AnonymousAssert

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousAssert -> Node -> Bool

showFailure :: Proxy AnonymousAssert -> Node -> String

Unmarshal AnonymousAssert

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousAssert a)

Eq a => Eq (AnonymousAssert a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousAssert a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousAssert a -> AnonymousAssert a -> Ordering

(<) :: AnonymousAssert a -> AnonymousAssert a -> Bool

(<=) :: AnonymousAssert a -> AnonymousAssert a -> Bool

(>) :: AnonymousAssert a -> AnonymousAssert a -> Bool

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

max :: AnonymousAssert a -> AnonymousAssert a -> AnonymousAssert a

min :: AnonymousAssert a -> AnonymousAssert a -> AnonymousAssert a

Show a => Show (AnonymousAssert a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousAssert a -> ShowS

show :: AnonymousAssert a -> String

showList :: [AnonymousAssert a] -> ShowS

Generic (AnonymousAssert a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousAssert a) :: Type -> Type

Methods

from :: AnonymousAssert a -> Rep (AnonymousAssert a) x

to :: Rep (AnonymousAssert a) x -> AnonymousAssert a

Generic1 AnonymousAssert

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousAssert :: k -> Type

Methods

from1 :: AnonymousAssert a -> Rep1 AnonymousAssert a

to1 :: Rep1 AnonymousAssert a -> AnonymousAssert a

type Rep (AnonymousAssert a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousAssert a) = D1 (MetaData "AnonymousAssert" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousAssert" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousAssert

Defined in TreeSitter.Python.AST

type Rep1 AnonymousAssert = D1 (MetaData "AnonymousAssert" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousAssert" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousColonEqual a

Constructors

AnonymousColonEqual

Fields

• ann :: a

Instances

Functor AnonymousColonEqual

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousColonEqual

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousColonEqual m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousColonEqual a -> m

foldr :: (a -> b -> b) -> b -> AnonymousColonEqual a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousColonEqual a -> b

foldl :: (b -> a -> b) -> b -> AnonymousColonEqual a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousColonEqual a -> b

foldr1 :: (a -> a -> a) -> AnonymousColonEqual a -> a

foldl1 :: (a -> a -> a) -> AnonymousColonEqual a -> a

toList :: AnonymousColonEqual a -> [a]

null :: AnonymousColonEqual a -> Bool

length :: AnonymousColonEqual a -> Int

elem :: Eq a => a -> AnonymousColonEqual a -> Bool

maximum :: Ord a => AnonymousColonEqual a -> a

minimum :: Ord a => AnonymousColonEqual a -> a

sum :: Num a => AnonymousColonEqual a -> a

product :: Num a => AnonymousColonEqual a -> a

Traversable AnonymousColonEqual

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousColonEqual a -> f (AnonymousColonEqual b)

sequenceA :: Applicative f => AnonymousColonEqual (f a) -> f (AnonymousColonEqual a)

mapM :: Monad m => (a -> m b) -> AnonymousColonEqual a -> m (AnonymousColonEqual b)

sequence :: Monad m => AnonymousColonEqual (m a) -> m (AnonymousColonEqual a)

SymbolMatching AnonymousColonEqual

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousColonEqual -> Node -> Bool

showFailure :: Proxy AnonymousColonEqual -> Node -> String

Unmarshal AnonymousColonEqual

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousColonEqual a)

Eq a => Eq (AnonymousColonEqual a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousColonEqual a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousColonEqual a -> AnonymousColonEqual a -> Ordering

(<) :: AnonymousColonEqual a -> AnonymousColonEqual a -> Bool

(<=) :: AnonymousColonEqual a -> AnonymousColonEqual a -> Bool

(>) :: AnonymousColonEqual a -> AnonymousColonEqual a -> Bool

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

max :: AnonymousColonEqual a -> AnonymousColonEqual a -> AnonymousColonEqual a

min :: AnonymousColonEqual a -> AnonymousColonEqual a -> AnonymousColonEqual a

Show a => Show (AnonymousColonEqual a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousColonEqual a -> ShowS

show :: AnonymousColonEqual a -> String

showList :: [AnonymousColonEqual a] -> ShowS

Generic (AnonymousColonEqual a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousColonEqual a) :: Type -> Type

Methods

from :: AnonymousColonEqual a -> Rep (AnonymousColonEqual a) x

to :: Rep (AnonymousColonEqual a) x -> AnonymousColonEqual a

Generic1 AnonymousColonEqual

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousColonEqual :: k -> Type

Methods

from1 :: AnonymousColonEqual a -> Rep1 AnonymousColonEqual a

to1 :: Rep1 AnonymousColonEqual a -> AnonymousColonEqual a

type Rep (AnonymousColonEqual a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousColonEqual a) = D1 (MetaData "AnonymousColonEqual" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousColonEqual" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousColonEqual

Defined in TreeSitter.Python.AST

type Rep1 AnonymousColonEqual = D1 (MetaData "AnonymousColonEqual" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousColonEqual" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousReturn a

Constructors

AnonymousReturn

Fields

• ann :: a

Instances

Functor AnonymousReturn

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousReturn

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousReturn m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousReturn a -> m

foldr :: (a -> b -> b) -> b -> AnonymousReturn a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousReturn a -> b

foldl :: (b -> a -> b) -> b -> AnonymousReturn a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousReturn a -> b

foldr1 :: (a -> a -> a) -> AnonymousReturn a -> a

foldl1 :: (a -> a -> a) -> AnonymousReturn a -> a

toList :: AnonymousReturn a -> [a]

null :: AnonymousReturn a -> Bool

length :: AnonymousReturn a -> Int

elem :: Eq a => a -> AnonymousReturn a -> Bool

maximum :: Ord a => AnonymousReturn a -> a

minimum :: Ord a => AnonymousReturn a -> a

sum :: Num a => AnonymousReturn a -> a

product :: Num a => AnonymousReturn a -> a

Traversable AnonymousReturn

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousReturn a -> f (AnonymousReturn b)

sequenceA :: Applicative f => AnonymousReturn (f a) -> f (AnonymousReturn a)

mapM :: Monad m => (a -> m b) -> AnonymousReturn a -> m (AnonymousReturn b)

sequence :: Monad m => AnonymousReturn (m a) -> m (AnonymousReturn a)

SymbolMatching AnonymousReturn

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousReturn -> Node -> Bool

showFailure :: Proxy AnonymousReturn -> Node -> String

Unmarshal AnonymousReturn

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousReturn a)

Eq a => Eq (AnonymousReturn a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousReturn a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousReturn a -> AnonymousReturn a -> Ordering

(<) :: AnonymousReturn a -> AnonymousReturn a -> Bool

(<=) :: AnonymousReturn a -> AnonymousReturn a -> Bool

(>) :: AnonymousReturn a -> AnonymousReturn a -> Bool

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

max :: AnonymousReturn a -> AnonymousReturn a -> AnonymousReturn a

min :: AnonymousReturn a -> AnonymousReturn a -> AnonymousReturn a

Show a => Show (AnonymousReturn a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousReturn a -> ShowS

show :: AnonymousReturn a -> String

showList :: [AnonymousReturn a] -> ShowS

Generic (AnonymousReturn a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousReturn a) :: Type -> Type

Methods

from :: AnonymousReturn a -> Rep (AnonymousReturn a) x

to :: Rep (AnonymousReturn a) x -> AnonymousReturn a

Generic1 AnonymousReturn

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousReturn :: k -> Type

Methods

from1 :: AnonymousReturn a -> Rep1 AnonymousReturn a

to1 :: Rep1 AnonymousReturn a -> AnonymousReturn a

type Rep (AnonymousReturn a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousReturn a) = D1 (MetaData "AnonymousReturn" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousReturn" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousReturn

Defined in TreeSitter.Python.AST

type Rep1 AnonymousReturn = D1 (MetaData "AnonymousReturn" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousReturn" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousDel a

Constructors

AnonymousDel

Fields

• ann :: a

Instances

Functor AnonymousDel

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousDel

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousDel m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousDel a -> m

foldr :: (a -> b -> b) -> b -> AnonymousDel a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousDel a -> b

foldl :: (b -> a -> b) -> b -> AnonymousDel a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousDel a -> b

foldr1 :: (a -> a -> a) -> AnonymousDel a -> a

foldl1 :: (a -> a -> a) -> AnonymousDel a -> a

toList :: AnonymousDel a -> [a]

null :: AnonymousDel a -> Bool

length :: AnonymousDel a -> Int

elem :: Eq a => a -> AnonymousDel a -> Bool

maximum :: Ord a => AnonymousDel a -> a

minimum :: Ord a => AnonymousDel a -> a

sum :: Num a => AnonymousDel a -> a

product :: Num a => AnonymousDel a -> a

Traversable AnonymousDel

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousDel a -> f (AnonymousDel b)

sequenceA :: Applicative f => AnonymousDel (f a) -> f (AnonymousDel a)

mapM :: Monad m => (a -> m b) -> AnonymousDel a -> m (AnonymousDel b)

sequence :: Monad m => AnonymousDel (m a) -> m (AnonymousDel a)

SymbolMatching AnonymousDel

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousDel -> Node -> Bool

showFailure :: Proxy AnonymousDel -> Node -> String

Unmarshal AnonymousDel

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousDel a)

Eq a => Eq (AnonymousDel a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousDel a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousDel a -> AnonymousDel a -> Ordering

(<) :: AnonymousDel a -> AnonymousDel a -> Bool

(<=) :: AnonymousDel a -> AnonymousDel a -> Bool

(>) :: AnonymousDel a -> AnonymousDel a -> Bool

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

max :: AnonymousDel a -> AnonymousDel a -> AnonymousDel a

min :: AnonymousDel a -> AnonymousDel a -> AnonymousDel a

Show a => Show (AnonymousDel a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousDel a -> ShowS

show :: AnonymousDel a -> String

showList :: [AnonymousDel a] -> ShowS

Generic (AnonymousDel a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousDel a) :: Type -> Type

Methods

from :: AnonymousDel a -> Rep (AnonymousDel a) x

to :: Rep (AnonymousDel a) x -> AnonymousDel a

Generic1 AnonymousDel

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousDel :: k -> Type

Methods

from1 :: AnonymousDel a -> Rep1 AnonymousDel a

to1 :: Rep1 AnonymousDel a -> AnonymousDel a

type Rep (AnonymousDel a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousDel a) = D1 (MetaData "AnonymousDel" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousDel" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousDel

Defined in TreeSitter.Python.AST

type Rep1 AnonymousDel = D1 (MetaData "AnonymousDel" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousDel" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousRaise a

Constructors

AnonymousRaise

Fields

• ann :: a

Instances

Functor AnonymousRaise

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousRaise

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousRaise m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousRaise a -> m

foldr :: (a -> b -> b) -> b -> AnonymousRaise a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousRaise a -> b

foldl :: (b -> a -> b) -> b -> AnonymousRaise a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousRaise a -> b

foldr1 :: (a -> a -> a) -> AnonymousRaise a -> a

foldl1 :: (a -> a -> a) -> AnonymousRaise a -> a

toList :: AnonymousRaise a -> [a]

null :: AnonymousRaise a -> Bool

length :: AnonymousRaise a -> Int

elem :: Eq a => a -> AnonymousRaise a -> Bool

maximum :: Ord a => AnonymousRaise a -> a

minimum :: Ord a => AnonymousRaise a -> a

sum :: Num a => AnonymousRaise a -> a

product :: Num a => AnonymousRaise a -> a

Traversable AnonymousRaise

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousRaise a -> f (AnonymousRaise b)

sequenceA :: Applicative f => AnonymousRaise (f a) -> f (AnonymousRaise a)

mapM :: Monad m => (a -> m b) -> AnonymousRaise a -> m (AnonymousRaise b)

sequence :: Monad m => AnonymousRaise (m a) -> m (AnonymousRaise a)

SymbolMatching AnonymousRaise

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousRaise -> Node -> Bool

showFailure :: Proxy AnonymousRaise -> Node -> String

Unmarshal AnonymousRaise

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousRaise a)

Eq a => Eq (AnonymousRaise a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousRaise a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousRaise a -> AnonymousRaise a -> Ordering

(<) :: AnonymousRaise a -> AnonymousRaise a -> Bool

(<=) :: AnonymousRaise a -> AnonymousRaise a -> Bool

(>) :: AnonymousRaise a -> AnonymousRaise a -> Bool

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

max :: AnonymousRaise a -> AnonymousRaise a -> AnonymousRaise a

min :: AnonymousRaise a -> AnonymousRaise a -> AnonymousRaise a

Show a => Show (AnonymousRaise a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousRaise a -> ShowS

show :: AnonymousRaise a -> String

showList :: [AnonymousRaise a] -> ShowS

Generic (AnonymousRaise a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousRaise a) :: Type -> Type

Methods

from :: AnonymousRaise a -> Rep (AnonymousRaise a) x

to :: Rep (AnonymousRaise a) x -> AnonymousRaise a

Generic1 AnonymousRaise

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousRaise :: k -> Type

Methods

from1 :: AnonymousRaise a -> Rep1 AnonymousRaise a

to1 :: Rep1 AnonymousRaise a -> AnonymousRaise a

type Rep (AnonymousRaise a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousRaise a) = D1 (MetaData "AnonymousRaise" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousRaise" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousRaise

Defined in TreeSitter.Python.AST

type Rep1 AnonymousRaise = D1 (MetaData "AnonymousRaise" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousRaise" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousPass a

Constructors

AnonymousPass

Fields

• ann :: a

Instances

Functor AnonymousPass

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousPass

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousPass m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousPass a -> m

foldr :: (a -> b -> b) -> b -> AnonymousPass a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousPass a -> b

foldl :: (b -> a -> b) -> b -> AnonymousPass a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousPass a -> b

foldr1 :: (a -> a -> a) -> AnonymousPass a -> a

foldl1 :: (a -> a -> a) -> AnonymousPass a -> a

toList :: AnonymousPass a -> [a]

null :: AnonymousPass a -> Bool

length :: AnonymousPass a -> Int

elem :: Eq a => a -> AnonymousPass a -> Bool

maximum :: Ord a => AnonymousPass a -> a

minimum :: Ord a => AnonymousPass a -> a

sum :: Num a => AnonymousPass a -> a

product :: Num a => AnonymousPass a -> a

Traversable AnonymousPass

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousPass a -> f (AnonymousPass b)

sequenceA :: Applicative f => AnonymousPass (f a) -> f (AnonymousPass a)

mapM :: Monad m => (a -> m b) -> AnonymousPass a -> m (AnonymousPass b)

sequence :: Monad m => AnonymousPass (m a) -> m (AnonymousPass a)

SymbolMatching AnonymousPass

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousPass -> Node -> Bool

showFailure :: Proxy AnonymousPass -> Node -> String

Unmarshal AnonymousPass

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousPass a)

Eq a => Eq (AnonymousPass a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousPass a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousPass a -> AnonymousPass a -> Ordering

(<) :: AnonymousPass a -> AnonymousPass a -> Bool

(<=) :: AnonymousPass a -> AnonymousPass a -> Bool

(>) :: AnonymousPass a -> AnonymousPass a -> Bool

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

max :: AnonymousPass a -> AnonymousPass a -> AnonymousPass a

min :: AnonymousPass a -> AnonymousPass a -> AnonymousPass a

Show a => Show (AnonymousPass a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousPass a -> ShowS

show :: AnonymousPass a -> String

showList :: [AnonymousPass a] -> ShowS

Generic (AnonymousPass a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousPass a) :: Type -> Type

Methods

from :: AnonymousPass a -> Rep (AnonymousPass a) x

to :: Rep (AnonymousPass a) x -> AnonymousPass a

Generic1 AnonymousPass

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousPass :: k -> Type

Methods

from1 :: AnonymousPass a -> Rep1 AnonymousPass a

to1 :: Rep1 AnonymousPass a -> AnonymousPass a

type Rep (AnonymousPass a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousPass a) = D1 (MetaData "AnonymousPass" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousPass" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousPass

Defined in TreeSitter.Python.AST

type Rep1 AnonymousPass = D1 (MetaData "AnonymousPass" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousPass" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousBreak a

Constructors

AnonymousBreak

Fields

• ann :: a

Instances

Functor AnonymousBreak

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousBreak

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousBreak m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousBreak a -> m

foldr :: (a -> b -> b) -> b -> AnonymousBreak a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousBreak a -> b

foldl :: (b -> a -> b) -> b -> AnonymousBreak a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousBreak a -> b

foldr1 :: (a -> a -> a) -> AnonymousBreak a -> a

foldl1 :: (a -> a -> a) -> AnonymousBreak a -> a

toList :: AnonymousBreak a -> [a]

null :: AnonymousBreak a -> Bool

length :: AnonymousBreak a -> Int

elem :: Eq a => a -> AnonymousBreak a -> Bool

maximum :: Ord a => AnonymousBreak a -> a

minimum :: Ord a => AnonymousBreak a -> a

sum :: Num a => AnonymousBreak a -> a

product :: Num a => AnonymousBreak a -> a

Traversable AnonymousBreak

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousBreak a -> f (AnonymousBreak b)

sequenceA :: Applicative f => AnonymousBreak (f a) -> f (AnonymousBreak a)

mapM :: Monad m => (a -> m b) -> AnonymousBreak a -> m (AnonymousBreak b)

sequence :: Monad m => AnonymousBreak (m a) -> m (AnonymousBreak a)

SymbolMatching AnonymousBreak

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousBreak -> Node -> Bool

showFailure :: Proxy AnonymousBreak -> Node -> String

Unmarshal AnonymousBreak

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousBreak a)

Eq a => Eq (AnonymousBreak a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousBreak a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousBreak a -> AnonymousBreak a -> Ordering

(<) :: AnonymousBreak a -> AnonymousBreak a -> Bool

(<=) :: AnonymousBreak a -> AnonymousBreak a -> Bool

(>) :: AnonymousBreak a -> AnonymousBreak a -> Bool

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

max :: AnonymousBreak a -> AnonymousBreak a -> AnonymousBreak a

min :: AnonymousBreak a -> AnonymousBreak a -> AnonymousBreak a

Show a => Show (AnonymousBreak a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousBreak a -> ShowS

show :: AnonymousBreak a -> String

showList :: [AnonymousBreak a] -> ShowS

Generic (AnonymousBreak a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousBreak a) :: Type -> Type

Methods

from :: AnonymousBreak a -> Rep (AnonymousBreak a) x

to :: Rep (AnonymousBreak a) x -> AnonymousBreak a

Generic1 AnonymousBreak

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousBreak :: k -> Type

Methods

from1 :: AnonymousBreak a -> Rep1 AnonymousBreak a

to1 :: Rep1 AnonymousBreak a -> AnonymousBreak a

type Rep (AnonymousBreak a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousBreak a) = D1 (MetaData "AnonymousBreak" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousBreak" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousBreak

Defined in TreeSitter.Python.AST

type Rep1 AnonymousBreak = D1 (MetaData "AnonymousBreak" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousBreak" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousContinue a

Constructors

AnonymousContinue

Fields

• ann :: a

Instances

Functor AnonymousContinue

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousContinue

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousContinue m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousContinue a -> m

foldr :: (a -> b -> b) -> b -> AnonymousContinue a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousContinue a -> b

foldl :: (b -> a -> b) -> b -> AnonymousContinue a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousContinue a -> b

foldr1 :: (a -> a -> a) -> AnonymousContinue a -> a

foldl1 :: (a -> a -> a) -> AnonymousContinue a -> a

toList :: AnonymousContinue a -> [a]

null :: AnonymousContinue a -> Bool

length :: AnonymousContinue a -> Int

elem :: Eq a => a -> AnonymousContinue a -> Bool

maximum :: Ord a => AnonymousContinue a -> a

minimum :: Ord a => AnonymousContinue a -> a

sum :: Num a => AnonymousContinue a -> a

product :: Num a => AnonymousContinue a -> a

Traversable AnonymousContinue

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousContinue a -> f (AnonymousContinue b)

sequenceA :: Applicative f => AnonymousContinue (f a) -> f (AnonymousContinue a)

mapM :: Monad m => (a -> m b) -> AnonymousContinue a -> m (AnonymousContinue b)

sequence :: Monad m => AnonymousContinue (m a) -> m (AnonymousContinue a)

SymbolMatching AnonymousContinue

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousContinue -> Node -> Bool

showFailure :: Proxy AnonymousContinue -> Node -> String

Unmarshal AnonymousContinue

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousContinue a)

Eq a => Eq (AnonymousContinue a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousContinue a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousContinue a -> AnonymousContinue a -> Ordering

(<) :: AnonymousContinue a -> AnonymousContinue a -> Bool

(<=) :: AnonymousContinue a -> AnonymousContinue a -> Bool

(>) :: AnonymousContinue a -> AnonymousContinue a -> Bool

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

max :: AnonymousContinue a -> AnonymousContinue a -> AnonymousContinue a

min :: AnonymousContinue a -> AnonymousContinue a -> AnonymousContinue a

Show a => Show (AnonymousContinue a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousContinue a -> ShowS

show :: AnonymousContinue a -> String

showList :: [AnonymousContinue a] -> ShowS

Generic (AnonymousContinue a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousContinue a) :: Type -> Type

Methods

from :: AnonymousContinue a -> Rep (AnonymousContinue a) x

to :: Rep (AnonymousContinue a) x -> AnonymousContinue a

Generic1 AnonymousContinue

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousContinue :: k -> Type

Methods

from1 :: AnonymousContinue a -> Rep1 AnonymousContinue a

to1 :: Rep1 AnonymousContinue a -> AnonymousContinue a

type Rep (AnonymousContinue a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousContinue a) = D1 (MetaData "AnonymousContinue" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousContinue" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousContinue

Defined in TreeSitter.Python.AST

type Rep1 AnonymousContinue = D1 (MetaData "AnonymousContinue" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousContinue" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousIf a

Constructors

AnonymousIf

Fields

• ann :: a

Instances

Functor AnonymousIf

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousIf

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousIf m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousIf a -> m

foldr :: (a -> b -> b) -> b -> AnonymousIf a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousIf a -> b

foldl :: (b -> a -> b) -> b -> AnonymousIf a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousIf a -> b

foldr1 :: (a -> a -> a) -> AnonymousIf a -> a

foldl1 :: (a -> a -> a) -> AnonymousIf a -> a

toList :: AnonymousIf a -> [a]

null :: AnonymousIf a -> Bool

length :: AnonymousIf a -> Int

elem :: Eq a => a -> AnonymousIf a -> Bool

maximum :: Ord a => AnonymousIf a -> a

minimum :: Ord a => AnonymousIf a -> a

sum :: Num a => AnonymousIf a -> a

product :: Num a => AnonymousIf a -> a

Traversable AnonymousIf

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousIf a -> f (AnonymousIf b)

sequenceA :: Applicative f => AnonymousIf (f a) -> f (AnonymousIf a)

mapM :: Monad m => (a -> m b) -> AnonymousIf a -> m (AnonymousIf b)

sequence :: Monad m => AnonymousIf (m a) -> m (AnonymousIf a)

SymbolMatching AnonymousIf

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousIf -> Node -> Bool

showFailure :: Proxy AnonymousIf -> Node -> String

Unmarshal AnonymousIf

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousIf a)

Eq a => Eq (AnonymousIf a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousIf a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousIf a -> AnonymousIf a -> Ordering

(<) :: AnonymousIf a -> AnonymousIf a -> Bool

(<=) :: AnonymousIf a -> AnonymousIf a -> Bool

(>) :: AnonymousIf a -> AnonymousIf a -> Bool

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

max :: AnonymousIf a -> AnonymousIf a -> AnonymousIf a

min :: AnonymousIf a -> AnonymousIf a -> AnonymousIf a

Show a => Show (AnonymousIf a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousIf a -> ShowS

show :: AnonymousIf a -> String

showList :: [AnonymousIf a] -> ShowS

Generic (AnonymousIf a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousIf a) :: Type -> Type

Methods

from :: AnonymousIf a -> Rep (AnonymousIf a) x

to :: Rep (AnonymousIf a) x -> AnonymousIf a

Generic1 AnonymousIf

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousIf :: k -> Type

Methods

from1 :: AnonymousIf a -> Rep1 AnonymousIf a

to1 :: Rep1 AnonymousIf a -> AnonymousIf a

type Rep (AnonymousIf a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousIf a) = D1 (MetaData "AnonymousIf" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousIf" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousIf

Defined in TreeSitter.Python.AST

type Rep1 AnonymousIf = D1 (MetaData "AnonymousIf" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousIf" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousColon a

Constructors

AnonymousColon

Fields

• ann :: a

Instances

Functor AnonymousColon

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousColon

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousColon m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousColon a -> m

foldr :: (a -> b -> b) -> b -> AnonymousColon a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousColon a -> b

foldl :: (b -> a -> b) -> b -> AnonymousColon a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousColon a -> b

foldr1 :: (a -> a -> a) -> AnonymousColon a -> a

foldl1 :: (a -> a -> a) -> AnonymousColon a -> a

toList :: AnonymousColon a -> [a]

null :: AnonymousColon a -> Bool

length :: AnonymousColon a -> Int

elem :: Eq a => a -> AnonymousColon a -> Bool

maximum :: Ord a => AnonymousColon a -> a

minimum :: Ord a => AnonymousColon a -> a

sum :: Num a => AnonymousColon a -> a

product :: Num a => AnonymousColon a -> a

Traversable AnonymousColon

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousColon a -> f (AnonymousColon b)

sequenceA :: Applicative f => AnonymousColon (f a) -> f (AnonymousColon a)

mapM :: Monad m => (a -> m b) -> AnonymousColon a -> m (AnonymousColon b)

sequence :: Monad m => AnonymousColon (m a) -> m (AnonymousColon a)

SymbolMatching AnonymousColon

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousColon -> Node -> Bool

showFailure :: Proxy AnonymousColon -> Node -> String

Unmarshal AnonymousColon

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousColon a)

Eq a => Eq (AnonymousColon a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousColon a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousColon a -> AnonymousColon a -> Ordering

(<) :: AnonymousColon a -> AnonymousColon a -> Bool

(<=) :: AnonymousColon a -> AnonymousColon a -> Bool

(>) :: AnonymousColon a -> AnonymousColon a -> Bool

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

max :: AnonymousColon a -> AnonymousColon a -> AnonymousColon a

min :: AnonymousColon a -> AnonymousColon a -> AnonymousColon a

Show a => Show (AnonymousColon a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousColon a -> ShowS

show :: AnonymousColon a -> String

showList :: [AnonymousColon a] -> ShowS

Generic (AnonymousColon a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousColon a) :: Type -> Type

Methods

from :: AnonymousColon a -> Rep (AnonymousColon a) x

to :: Rep (AnonymousColon a) x -> AnonymousColon a

Generic1 AnonymousColon

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousColon :: k -> Type

Methods

from1 :: AnonymousColon a -> Rep1 AnonymousColon a

to1 :: Rep1 AnonymousColon a -> AnonymousColon a

type Rep (AnonymousColon a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousColon a) = D1 (MetaData "AnonymousColon" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousColon" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousColon

Defined in TreeSitter.Python.AST

type Rep1 AnonymousColon = D1 (MetaData "AnonymousColon" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousColon" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousElif a

Constructors

AnonymousElif

Fields

• ann :: a

Instances

Functor AnonymousElif

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousElif

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousElif m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousElif a -> m

foldr :: (a -> b -> b) -> b -> AnonymousElif a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousElif a -> b

foldl :: (b -> a -> b) -> b -> AnonymousElif a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousElif a -> b

foldr1 :: (a -> a -> a) -> AnonymousElif a -> a

foldl1 :: (a -> a -> a) -> AnonymousElif a -> a

toList :: AnonymousElif a -> [a]

null :: AnonymousElif a -> Bool

length :: AnonymousElif a -> Int

elem :: Eq a => a -> AnonymousElif a -> Bool

maximum :: Ord a => AnonymousElif a -> a

minimum :: Ord a => AnonymousElif a -> a

sum :: Num a => AnonymousElif a -> a

product :: Num a => AnonymousElif a -> a

Traversable AnonymousElif

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousElif a -> f (AnonymousElif b)

sequenceA :: Applicative f => AnonymousElif (f a) -> f (AnonymousElif a)

mapM :: Monad m => (a -> m b) -> AnonymousElif a -> m (AnonymousElif b)

sequence :: Monad m => AnonymousElif (m a) -> m (AnonymousElif a)

SymbolMatching AnonymousElif

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousElif -> Node -> Bool

showFailure :: Proxy AnonymousElif -> Node -> String

Unmarshal AnonymousElif

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousElif a)

Eq a => Eq (AnonymousElif a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousElif a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousElif a -> AnonymousElif a -> Ordering

(<) :: AnonymousElif a -> AnonymousElif a -> Bool

(<=) :: AnonymousElif a -> AnonymousElif a -> Bool

(>) :: AnonymousElif a -> AnonymousElif a -> Bool

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

max :: AnonymousElif a -> AnonymousElif a -> AnonymousElif a

min :: AnonymousElif a -> AnonymousElif a -> AnonymousElif a

Show a => Show (AnonymousElif a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousElif a -> ShowS

show :: AnonymousElif a -> String

showList :: [AnonymousElif a] -> ShowS

Generic (AnonymousElif a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousElif a) :: Type -> Type

Methods

from :: AnonymousElif a -> Rep (AnonymousElif a) x

to :: Rep (AnonymousElif a) x -> AnonymousElif a

Generic1 AnonymousElif

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousElif :: k -> Type

Methods

from1 :: AnonymousElif a -> Rep1 AnonymousElif a

to1 :: Rep1 AnonymousElif a -> AnonymousElif a

type Rep (AnonymousElif a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousElif a) = D1 (MetaData "AnonymousElif" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousElif" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousElif

Defined in TreeSitter.Python.AST

type Rep1 AnonymousElif = D1 (MetaData "AnonymousElif" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousElif" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousElse a

Constructors

AnonymousElse

Fields

• ann :: a

Instances

Functor AnonymousElse

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousElse

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousElse m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousElse a -> m

foldr :: (a -> b -> b) -> b -> AnonymousElse a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousElse a -> b

foldl :: (b -> a -> b) -> b -> AnonymousElse a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousElse a -> b

foldr1 :: (a -> a -> a) -> AnonymousElse a -> a

foldl1 :: (a -> a -> a) -> AnonymousElse a -> a

toList :: AnonymousElse a -> [a]

null :: AnonymousElse a -> Bool

length :: AnonymousElse a -> Int

elem :: Eq a => a -> AnonymousElse a -> Bool

maximum :: Ord a => AnonymousElse a -> a

minimum :: Ord a => AnonymousElse a -> a

sum :: Num a => AnonymousElse a -> a

product :: Num a => AnonymousElse a -> a

Traversable AnonymousElse

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousElse a -> f (AnonymousElse b)

sequenceA :: Applicative f => AnonymousElse (f a) -> f (AnonymousElse a)

mapM :: Monad m => (a -> m b) -> AnonymousElse a -> m (AnonymousElse b)

sequence :: Monad m => AnonymousElse (m a) -> m (AnonymousElse a)

SymbolMatching AnonymousElse

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousElse -> Node -> Bool

showFailure :: Proxy AnonymousElse -> Node -> String

Unmarshal AnonymousElse

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousElse a)

Eq a => Eq (AnonymousElse a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousElse a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousElse a -> AnonymousElse a -> Ordering

(<) :: AnonymousElse a -> AnonymousElse a -> Bool

(<=) :: AnonymousElse a -> AnonymousElse a -> Bool

(>) :: AnonymousElse a -> AnonymousElse a -> Bool

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

max :: AnonymousElse a -> AnonymousElse a -> AnonymousElse a

min :: AnonymousElse a -> AnonymousElse a -> AnonymousElse a

Show a => Show (AnonymousElse a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousElse a -> ShowS

show :: AnonymousElse a -> String

showList :: [AnonymousElse a] -> ShowS

Generic (AnonymousElse a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousElse a) :: Type -> Type

Methods

from :: AnonymousElse a -> Rep (AnonymousElse a) x

to :: Rep (AnonymousElse a) x -> AnonymousElse a

Generic1 AnonymousElse

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousElse :: k -> Type

Methods

from1 :: AnonymousElse a -> Rep1 AnonymousElse a

to1 :: Rep1 AnonymousElse a -> AnonymousElse a

type Rep (AnonymousElse a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousElse a) = D1 (MetaData "AnonymousElse" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousElse" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousElse

Defined in TreeSitter.Python.AST

type Rep1 AnonymousElse = D1 (MetaData "AnonymousElse" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousElse" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousAsync a

Constructors

AnonymousAsync

Fields

• ann :: a

Instances

Functor AnonymousAsync

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousAsync

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousAsync m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousAsync a -> m

foldr :: (a -> b -> b) -> b -> AnonymousAsync a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousAsync a -> b

foldl :: (b -> a -> b) -> b -> AnonymousAsync a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousAsync a -> b

foldr1 :: (a -> a -> a) -> AnonymousAsync a -> a

foldl1 :: (a -> a -> a) -> AnonymousAsync a -> a

toList :: AnonymousAsync a -> [a]

null :: AnonymousAsync a -> Bool

length :: AnonymousAsync a -> Int

elem :: Eq a => a -> AnonymousAsync a -> Bool

maximum :: Ord a => AnonymousAsync a -> a

minimum :: Ord a => AnonymousAsync a -> a

sum :: Num a => AnonymousAsync a -> a

product :: Num a => AnonymousAsync a -> a

Traversable AnonymousAsync

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousAsync a -> f (AnonymousAsync b)

sequenceA :: Applicative f => AnonymousAsync (f a) -> f (AnonymousAsync a)

mapM :: Monad m => (a -> m b) -> AnonymousAsync a -> m (AnonymousAsync b)

sequence :: Monad m => AnonymousAsync (m a) -> m (AnonymousAsync a)

SymbolMatching AnonymousAsync

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousAsync -> Node -> Bool

showFailure :: Proxy AnonymousAsync -> Node -> String

Unmarshal AnonymousAsync

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousAsync a)

Eq a => Eq (AnonymousAsync a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousAsync a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousAsync a -> AnonymousAsync a -> Ordering

(<) :: AnonymousAsync a -> AnonymousAsync a -> Bool

(<=) :: AnonymousAsync a -> AnonymousAsync a -> Bool

(>) :: AnonymousAsync a -> AnonymousAsync a -> Bool

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

max :: AnonymousAsync a -> AnonymousAsync a -> AnonymousAsync a

min :: AnonymousAsync a -> AnonymousAsync a -> AnonymousAsync a

Show a => Show (AnonymousAsync a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousAsync a -> ShowS

show :: AnonymousAsync a -> String

showList :: [AnonymousAsync a] -> ShowS

Generic (AnonymousAsync a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousAsync a) :: Type -> Type

Methods

from :: AnonymousAsync a -> Rep (AnonymousAsync a) x

to :: Rep (AnonymousAsync a) x -> AnonymousAsync a

Generic1 AnonymousAsync

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousAsync :: k -> Type

Methods

from1 :: AnonymousAsync a -> Rep1 AnonymousAsync a

to1 :: Rep1 AnonymousAsync a -> AnonymousAsync a

type Rep (AnonymousAsync a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousAsync a) = D1 (MetaData "AnonymousAsync" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousAsync" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousAsync

Defined in TreeSitter.Python.AST

type Rep1 AnonymousAsync = D1 (MetaData "AnonymousAsync" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousAsync" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousFor a

Constructors

AnonymousFor

Fields

• ann :: a

Instances

Functor AnonymousFor

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousFor

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousFor m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousFor a -> m

foldr :: (a -> b -> b) -> b -> AnonymousFor a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousFor a -> b

foldl :: (b -> a -> b) -> b -> AnonymousFor a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousFor a -> b

foldr1 :: (a -> a -> a) -> AnonymousFor a -> a

foldl1 :: (a -> a -> a) -> AnonymousFor a -> a

toList :: AnonymousFor a -> [a]

null :: AnonymousFor a -> Bool

length :: AnonymousFor a -> Int

elem :: Eq a => a -> AnonymousFor a -> Bool

maximum :: Ord a => AnonymousFor a -> a

minimum :: Ord a => AnonymousFor a -> a

sum :: Num a => AnonymousFor a -> a

product :: Num a => AnonymousFor a -> a

Traversable AnonymousFor

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousFor a -> f (AnonymousFor b)

sequenceA :: Applicative f => AnonymousFor (f a) -> f (AnonymousFor a)

mapM :: Monad m => (a -> m b) -> AnonymousFor a -> m (AnonymousFor b)

sequence :: Monad m => AnonymousFor (m a) -> m (AnonymousFor a)

SymbolMatching AnonymousFor

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousFor -> Node -> Bool

showFailure :: Proxy AnonymousFor -> Node -> String

Unmarshal AnonymousFor

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousFor a)

Eq a => Eq (AnonymousFor a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousFor a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousFor a -> AnonymousFor a -> Ordering

(<) :: AnonymousFor a -> AnonymousFor a -> Bool

(<=) :: AnonymousFor a -> AnonymousFor a -> Bool

(>) :: AnonymousFor a -> AnonymousFor a -> Bool

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

max :: AnonymousFor a -> AnonymousFor a -> AnonymousFor a

min :: AnonymousFor a -> AnonymousFor a -> AnonymousFor a

Show a => Show (AnonymousFor a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousFor a -> ShowS

show :: AnonymousFor a -> String

showList :: [AnonymousFor a] -> ShowS

Generic (AnonymousFor a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousFor a) :: Type -> Type

Methods

from :: AnonymousFor a -> Rep (AnonymousFor a) x

to :: Rep (AnonymousFor a) x -> AnonymousFor a

Generic1 AnonymousFor

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousFor :: k -> Type

Methods

from1 :: AnonymousFor a -> Rep1 AnonymousFor a

to1 :: Rep1 AnonymousFor a -> AnonymousFor a

type Rep (AnonymousFor a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousFor a) = D1 (MetaData "AnonymousFor" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousFor" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousFor

Defined in TreeSitter.Python.AST

type Rep1 AnonymousFor = D1 (MetaData "AnonymousFor" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousFor" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousIn a

Constructors

AnonymousIn

Fields

• ann :: a

Instances

Functor AnonymousIn

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousIn

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousIn m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousIn a -> m

foldr :: (a -> b -> b) -> b -> AnonymousIn a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousIn a -> b

foldl :: (b -> a -> b) -> b -> AnonymousIn a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousIn a -> b

foldr1 :: (a -> a -> a) -> AnonymousIn a -> a

foldl1 :: (a -> a -> a) -> AnonymousIn a -> a

toList :: AnonymousIn a -> [a]

null :: AnonymousIn a -> Bool

length :: AnonymousIn a -> Int

elem :: Eq a => a -> AnonymousIn a -> Bool

maximum :: Ord a => AnonymousIn a -> a

minimum :: Ord a => AnonymousIn a -> a

sum :: Num a => AnonymousIn a -> a

product :: Num a => AnonymousIn a -> a

Traversable AnonymousIn

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousIn a -> f (AnonymousIn b)

sequenceA :: Applicative f => AnonymousIn (f a) -> f (AnonymousIn a)

mapM :: Monad m => (a -> m b) -> AnonymousIn a -> m (AnonymousIn b)

sequence :: Monad m => AnonymousIn (m a) -> m (AnonymousIn a)

SymbolMatching AnonymousIn

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousIn -> Node -> Bool

showFailure :: Proxy AnonymousIn -> Node -> String

Unmarshal AnonymousIn

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousIn a)

Eq a => Eq (AnonymousIn a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousIn a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousIn a -> AnonymousIn a -> Ordering

(<) :: AnonymousIn a -> AnonymousIn a -> Bool

(<=) :: AnonymousIn a -> AnonymousIn a -> Bool

(>) :: AnonymousIn a -> AnonymousIn a -> Bool

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

max :: AnonymousIn a -> AnonymousIn a -> AnonymousIn a

min :: AnonymousIn a -> AnonymousIn a -> AnonymousIn a

Show a => Show (AnonymousIn a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousIn a -> ShowS

show :: AnonymousIn a -> String

showList :: [AnonymousIn a] -> ShowS

Generic (AnonymousIn a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousIn a) :: Type -> Type

Methods

from :: AnonymousIn a -> Rep (AnonymousIn a) x

to :: Rep (AnonymousIn a) x -> AnonymousIn a

Generic1 AnonymousIn

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousIn :: k -> Type

Methods

from1 :: AnonymousIn a -> Rep1 AnonymousIn a

to1 :: Rep1 AnonymousIn a -> AnonymousIn a

type Rep (AnonymousIn a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousIn a) = D1 (MetaData "AnonymousIn" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousIn" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousIn

Defined in TreeSitter.Python.AST

type Rep1 AnonymousIn = D1 (MetaData "AnonymousIn" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousIn" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousWhile a

Constructors

AnonymousWhile

Fields

• ann :: a

Instances

Functor AnonymousWhile

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousWhile

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousWhile m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousWhile a -> m

foldr :: (a -> b -> b) -> b -> AnonymousWhile a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousWhile a -> b

foldl :: (b -> a -> b) -> b -> AnonymousWhile a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousWhile a -> b

foldr1 :: (a -> a -> a) -> AnonymousWhile a -> a

foldl1 :: (a -> a -> a) -> AnonymousWhile a -> a

toList :: AnonymousWhile a -> [a]

null :: AnonymousWhile a -> Bool

length :: AnonymousWhile a -> Int

elem :: Eq a => a -> AnonymousWhile a -> Bool

maximum :: Ord a => AnonymousWhile a -> a

minimum :: Ord a => AnonymousWhile a -> a

sum :: Num a => AnonymousWhile a -> a

product :: Num a => AnonymousWhile a -> a

Traversable AnonymousWhile

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousWhile a -> f (AnonymousWhile b)

sequenceA :: Applicative f => AnonymousWhile (f a) -> f (AnonymousWhile a)

mapM :: Monad m => (a -> m b) -> AnonymousWhile a -> m (AnonymousWhile b)

sequence :: Monad m => AnonymousWhile (m a) -> m (AnonymousWhile a)

SymbolMatching AnonymousWhile

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousWhile -> Node -> Bool

showFailure :: Proxy AnonymousWhile -> Node -> String

Unmarshal AnonymousWhile

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousWhile a)

Eq a => Eq (AnonymousWhile a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousWhile a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousWhile a -> AnonymousWhile a -> Ordering

(<) :: AnonymousWhile a -> AnonymousWhile a -> Bool

(<=) :: AnonymousWhile a -> AnonymousWhile a -> Bool

(>) :: AnonymousWhile a -> AnonymousWhile a -> Bool

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

max :: AnonymousWhile a -> AnonymousWhile a -> AnonymousWhile a

min :: AnonymousWhile a -> AnonymousWhile a -> AnonymousWhile a

Show a => Show (AnonymousWhile a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousWhile a -> ShowS

show :: AnonymousWhile a -> String

showList :: [AnonymousWhile a] -> ShowS

Generic (AnonymousWhile a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousWhile a) :: Type -> Type

Methods

from :: AnonymousWhile a -> Rep (AnonymousWhile a) x

to :: Rep (AnonymousWhile a) x -> AnonymousWhile a

Generic1 AnonymousWhile

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousWhile :: k -> Type

Methods

from1 :: AnonymousWhile a -> Rep1 AnonymousWhile a

to1 :: Rep1 AnonymousWhile a -> AnonymousWhile a

type Rep (AnonymousWhile a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousWhile a) = D1 (MetaData "AnonymousWhile" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousWhile" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousWhile

Defined in TreeSitter.Python.AST

type Rep1 AnonymousWhile = D1 (MetaData "AnonymousWhile" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousWhile" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousTry a

Constructors

AnonymousTry

Fields

• ann :: a

Instances

Functor AnonymousTry

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousTry

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousTry m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousTry a -> m

foldr :: (a -> b -> b) -> b -> AnonymousTry a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousTry a -> b

foldl :: (b -> a -> b) -> b -> AnonymousTry a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousTry a -> b

foldr1 :: (a -> a -> a) -> AnonymousTry a -> a

foldl1 :: (a -> a -> a) -> AnonymousTry a -> a

toList :: AnonymousTry a -> [a]

null :: AnonymousTry a -> Bool

length :: AnonymousTry a -> Int

elem :: Eq a => a -> AnonymousTry a -> Bool

maximum :: Ord a => AnonymousTry a -> a

minimum :: Ord a => AnonymousTry a -> a

sum :: Num a => AnonymousTry a -> a

product :: Num a => AnonymousTry a -> a

Traversable AnonymousTry

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousTry a -> f (AnonymousTry b)

sequenceA :: Applicative f => AnonymousTry (f a) -> f (AnonymousTry a)

mapM :: Monad m => (a -> m b) -> AnonymousTry a -> m (AnonymousTry b)

sequence :: Monad m => AnonymousTry (m a) -> m (AnonymousTry a)

SymbolMatching AnonymousTry

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousTry -> Node -> Bool

showFailure :: Proxy AnonymousTry -> Node -> String

Unmarshal AnonymousTry

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousTry a)

Eq a => Eq (AnonymousTry a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousTry a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousTry a -> AnonymousTry a -> Ordering

(<) :: AnonymousTry a -> AnonymousTry a -> Bool

(<=) :: AnonymousTry a -> AnonymousTry a -> Bool

(>) :: AnonymousTry a -> AnonymousTry a -> Bool

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

max :: AnonymousTry a -> AnonymousTry a -> AnonymousTry a

min :: AnonymousTry a -> AnonymousTry a -> AnonymousTry a

Show a => Show (AnonymousTry a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousTry a -> ShowS

show :: AnonymousTry a -> String

showList :: [AnonymousTry a] -> ShowS

Generic (AnonymousTry a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousTry a) :: Type -> Type

Methods

from :: AnonymousTry a -> Rep (AnonymousTry a) x

to :: Rep (AnonymousTry a) x -> AnonymousTry a

Generic1 AnonymousTry

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousTry :: k -> Type

Methods

from1 :: AnonymousTry a -> Rep1 AnonymousTry a

to1 :: Rep1 AnonymousTry a -> AnonymousTry a

type Rep (AnonymousTry a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousTry a) = D1 (MetaData "AnonymousTry" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousTry" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousTry

Defined in TreeSitter.Python.AST

type Rep1 AnonymousTry = D1 (MetaData "AnonymousTry" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousTry" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousExcept a

Constructors

AnonymousExcept

Fields

• ann :: a

Instances

Functor AnonymousExcept

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousExcept

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousExcept m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousExcept a -> m

foldr :: (a -> b -> b) -> b -> AnonymousExcept a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousExcept a -> b

foldl :: (b -> a -> b) -> b -> AnonymousExcept a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousExcept a -> b

foldr1 :: (a -> a -> a) -> AnonymousExcept a -> a

foldl1 :: (a -> a -> a) -> AnonymousExcept a -> a

toList :: AnonymousExcept a -> [a]

null :: AnonymousExcept a -> Bool

length :: AnonymousExcept a -> Int

elem :: Eq a => a -> AnonymousExcept a -> Bool

maximum :: Ord a => AnonymousExcept a -> a

minimum :: Ord a => AnonymousExcept a -> a

sum :: Num a => AnonymousExcept a -> a

product :: Num a => AnonymousExcept a -> a

Traversable AnonymousExcept

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousExcept a -> f (AnonymousExcept b)

sequenceA :: Applicative f => AnonymousExcept (f a) -> f (AnonymousExcept a)

mapM :: Monad m => (a -> m b) -> AnonymousExcept a -> m (AnonymousExcept b)

sequence :: Monad m => AnonymousExcept (m a) -> m (AnonymousExcept a)

SymbolMatching AnonymousExcept

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousExcept -> Node -> Bool

showFailure :: Proxy AnonymousExcept -> Node -> String

Unmarshal AnonymousExcept

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousExcept a)

Eq a => Eq (AnonymousExcept a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousExcept a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousExcept a -> AnonymousExcept a -> Ordering

(<) :: AnonymousExcept a -> AnonymousExcept a -> Bool

(<=) :: AnonymousExcept a -> AnonymousExcept a -> Bool

(>) :: AnonymousExcept a -> AnonymousExcept a -> Bool

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

max :: AnonymousExcept a -> AnonymousExcept a -> AnonymousExcept a

min :: AnonymousExcept a -> AnonymousExcept a -> AnonymousExcept a

Show a => Show (AnonymousExcept a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousExcept a -> ShowS

show :: AnonymousExcept a -> String

showList :: [AnonymousExcept a] -> ShowS

Generic (AnonymousExcept a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousExcept a) :: Type -> Type

Methods

from :: AnonymousExcept a -> Rep (AnonymousExcept a) x

to :: Rep (AnonymousExcept a) x -> AnonymousExcept a

Generic1 AnonymousExcept

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousExcept :: k -> Type

Methods

from1 :: AnonymousExcept a -> Rep1 AnonymousExcept a

to1 :: Rep1 AnonymousExcept a -> AnonymousExcept a

type Rep (AnonymousExcept a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousExcept a) = D1 (MetaData "AnonymousExcept" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousExcept" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousExcept

Defined in TreeSitter.Python.AST

type Rep1 AnonymousExcept = D1 (MetaData "AnonymousExcept" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousExcept" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousFinally a

Constructors

AnonymousFinally

Fields

• ann :: a

Instances

Functor AnonymousFinally

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousFinally

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousFinally m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousFinally a -> m

foldr :: (a -> b -> b) -> b -> AnonymousFinally a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousFinally a -> b

foldl :: (b -> a -> b) -> b -> AnonymousFinally a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousFinally a -> b

foldr1 :: (a -> a -> a) -> AnonymousFinally a -> a

foldl1 :: (a -> a -> a) -> AnonymousFinally a -> a

toList :: AnonymousFinally a -> [a]

null :: AnonymousFinally a -> Bool

length :: AnonymousFinally a -> Int

elem :: Eq a => a -> AnonymousFinally a -> Bool

maximum :: Ord a => AnonymousFinally a -> a

minimum :: Ord a => AnonymousFinally a -> a

sum :: Num a => AnonymousFinally a -> a

product :: Num a => AnonymousFinally a -> a

Traversable AnonymousFinally

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousFinally a -> f (AnonymousFinally b)

sequenceA :: Applicative f => AnonymousFinally (f a) -> f (AnonymousFinally a)

mapM :: Monad m => (a -> m b) -> AnonymousFinally a -> m (AnonymousFinally b)

sequence :: Monad m => AnonymousFinally (m a) -> m (AnonymousFinally a)

SymbolMatching AnonymousFinally

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousFinally -> Node -> Bool

showFailure :: Proxy AnonymousFinally -> Node -> String

Unmarshal AnonymousFinally

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousFinally a)

Eq a => Eq (AnonymousFinally a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousFinally a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousFinally a -> AnonymousFinally a -> Ordering

(<) :: AnonymousFinally a -> AnonymousFinally a -> Bool

(<=) :: AnonymousFinally a -> AnonymousFinally a -> Bool

(>) :: AnonymousFinally a -> AnonymousFinally a -> Bool

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

max :: AnonymousFinally a -> AnonymousFinally a -> AnonymousFinally a

min :: AnonymousFinally a -> AnonymousFinally a -> AnonymousFinally a

Show a => Show (AnonymousFinally a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousFinally a -> ShowS

show :: AnonymousFinally a -> String

showList :: [AnonymousFinally a] -> ShowS

Generic (AnonymousFinally a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousFinally a) :: Type -> Type

Methods

from :: AnonymousFinally a -> Rep (AnonymousFinally a) x

to :: Rep (AnonymousFinally a) x -> AnonymousFinally a

Generic1 AnonymousFinally

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousFinally :: k -> Type

Methods

from1 :: AnonymousFinally a -> Rep1 AnonymousFinally a

to1 :: Rep1 AnonymousFinally a -> AnonymousFinally a

type Rep (AnonymousFinally a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousFinally a) = D1 (MetaData "AnonymousFinally" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousFinally" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousFinally

Defined in TreeSitter.Python.AST

type Rep1 AnonymousFinally = D1 (MetaData "AnonymousFinally" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousFinally" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousWith a

Constructors

AnonymousWith

Fields

• ann :: a

Instances

Functor AnonymousWith

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousWith

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousWith m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousWith a -> m

foldr :: (a -> b -> b) -> b -> AnonymousWith a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousWith a -> b

foldl :: (b -> a -> b) -> b -> AnonymousWith a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousWith a -> b

foldr1 :: (a -> a -> a) -> AnonymousWith a -> a

foldl1 :: (a -> a -> a) -> AnonymousWith a -> a

toList :: AnonymousWith a -> [a]

null :: AnonymousWith a -> Bool

length :: AnonymousWith a -> Int

elem :: Eq a => a -> AnonymousWith a -> Bool

maximum :: Ord a => AnonymousWith a -> a

minimum :: Ord a => AnonymousWith a -> a

sum :: Num a => AnonymousWith a -> a

product :: Num a => AnonymousWith a -> a

Traversable AnonymousWith

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousWith a -> f (AnonymousWith b)

sequenceA :: Applicative f => AnonymousWith (f a) -> f (AnonymousWith a)

mapM :: Monad m => (a -> m b) -> AnonymousWith a -> m (AnonymousWith b)

sequence :: Monad m => AnonymousWith (m a) -> m (AnonymousWith a)

SymbolMatching AnonymousWith

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousWith -> Node -> Bool

showFailure :: Proxy AnonymousWith -> Node -> String

Unmarshal AnonymousWith

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousWith a)

Eq a => Eq (AnonymousWith a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousWith a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousWith a -> AnonymousWith a -> Ordering

(<) :: AnonymousWith a -> AnonymousWith a -> Bool

(<=) :: AnonymousWith a -> AnonymousWith a -> Bool

(>) :: AnonymousWith a -> AnonymousWith a -> Bool

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

max :: AnonymousWith a -> AnonymousWith a -> AnonymousWith a

min :: AnonymousWith a -> AnonymousWith a -> AnonymousWith a

Show a => Show (AnonymousWith a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousWith a -> ShowS

show :: AnonymousWith a -> String

showList :: [AnonymousWith a] -> ShowS

Generic (AnonymousWith a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousWith a) :: Type -> Type

Methods

from :: AnonymousWith a -> Rep (AnonymousWith a) x

to :: Rep (AnonymousWith a) x -> AnonymousWith a

Generic1 AnonymousWith

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousWith :: k -> Type

Methods

from1 :: AnonymousWith a -> Rep1 AnonymousWith a

to1 :: Rep1 AnonymousWith a -> AnonymousWith a

type Rep (AnonymousWith a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousWith a) = D1 (MetaData "AnonymousWith" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousWith" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousWith

Defined in TreeSitter.Python.AST

type Rep1 AnonymousWith = D1 (MetaData "AnonymousWith" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousWith" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousDef a

Constructors

AnonymousDef

Fields

• ann :: a

Instances

Functor AnonymousDef

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousDef

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousDef m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousDef a -> m

foldr :: (a -> b -> b) -> b -> AnonymousDef a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousDef a -> b

foldl :: (b -> a -> b) -> b -> AnonymousDef a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousDef a -> b

foldr1 :: (a -> a -> a) -> AnonymousDef a -> a

foldl1 :: (a -> a -> a) -> AnonymousDef a -> a

toList :: AnonymousDef a -> [a]

null :: AnonymousDef a -> Bool

length :: AnonymousDef a -> Int

elem :: Eq a => a -> AnonymousDef a -> Bool

maximum :: Ord a => AnonymousDef a -> a

minimum :: Ord a => AnonymousDef a -> a

sum :: Num a => AnonymousDef a -> a

product :: Num a => AnonymousDef a -> a

Traversable AnonymousDef

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousDef a -> f (AnonymousDef b)

sequenceA :: Applicative f => AnonymousDef (f a) -> f (AnonymousDef a)

mapM :: Monad m => (a -> m b) -> AnonymousDef a -> m (AnonymousDef b)

sequence :: Monad m => AnonymousDef (m a) -> m (AnonymousDef a)

SymbolMatching AnonymousDef

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousDef -> Node -> Bool

showFailure :: Proxy AnonymousDef -> Node -> String

Unmarshal AnonymousDef

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousDef a)

Eq a => Eq (AnonymousDef a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousDef a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousDef a -> AnonymousDef a -> Ordering

(<) :: AnonymousDef a -> AnonymousDef a -> Bool

(<=) :: AnonymousDef a -> AnonymousDef a -> Bool

(>) :: AnonymousDef a -> AnonymousDef a -> Bool

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

max :: AnonymousDef a -> AnonymousDef a -> AnonymousDef a

min :: AnonymousDef a -> AnonymousDef a -> AnonymousDef a

Show a => Show (AnonymousDef a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousDef a -> ShowS

show :: AnonymousDef a -> String

showList :: [AnonymousDef a] -> ShowS

Generic (AnonymousDef a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousDef a) :: Type -> Type

Methods

from :: AnonymousDef a -> Rep (AnonymousDef a) x

to :: Rep (AnonymousDef a) x -> AnonymousDef a

Generic1 AnonymousDef

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousDef :: k -> Type

Methods

from1 :: AnonymousDef a -> Rep1 AnonymousDef a

to1 :: Rep1 AnonymousDef a -> AnonymousDef a

type Rep (AnonymousDef a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousDef a) = D1 (MetaData "AnonymousDef" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousDef" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousDef

Defined in TreeSitter.Python.AST

type Rep1 AnonymousDef = D1 (MetaData "AnonymousDef" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousDef" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousMinusRAngle a

Constructors

AnonymousMinusRAngle

Fields

• ann :: a

Instances

Functor AnonymousMinusRAngle

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousMinusRAngle

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousMinusRAngle m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousMinusRAngle a -> m

foldr :: (a -> b -> b) -> b -> AnonymousMinusRAngle a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousMinusRAngle a -> b

foldl :: (b -> a -> b) -> b -> AnonymousMinusRAngle a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousMinusRAngle a -> b

foldr1 :: (a -> a -> a) -> AnonymousMinusRAngle a -> a

foldl1 :: (a -> a -> a) -> AnonymousMinusRAngle a -> a

toList :: AnonymousMinusRAngle a -> [a]

null :: AnonymousMinusRAngle a -> Bool

length :: AnonymousMinusRAngle a -> Int

elem :: Eq a => a -> AnonymousMinusRAngle a -> Bool

maximum :: Ord a => AnonymousMinusRAngle a -> a

minimum :: Ord a => AnonymousMinusRAngle a -> a

sum :: Num a => AnonymousMinusRAngle a -> a

product :: Num a => AnonymousMinusRAngle a -> a

Traversable AnonymousMinusRAngle

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousMinusRAngle a -> f (AnonymousMinusRAngle b)

sequenceA :: Applicative f => AnonymousMinusRAngle (f a) -> f (AnonymousMinusRAngle a)

mapM :: Monad m => (a -> m b) -> AnonymousMinusRAngle a -> m (AnonymousMinusRAngle b)

sequence :: Monad m => AnonymousMinusRAngle (m a) -> m (AnonymousMinusRAngle a)

SymbolMatching AnonymousMinusRAngle

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousMinusRAngle -> Node -> Bool

showFailure :: Proxy AnonymousMinusRAngle -> Node -> String

Unmarshal AnonymousMinusRAngle

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousMinusRAngle a)

Eq a => Eq (AnonymousMinusRAngle a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousMinusRAngle a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousMinusRAngle a -> AnonymousMinusRAngle a -> Ordering

(<) :: AnonymousMinusRAngle a -> AnonymousMinusRAngle a -> Bool

(<=) :: AnonymousMinusRAngle a -> AnonymousMinusRAngle a -> Bool

(>) :: AnonymousMinusRAngle a -> AnonymousMinusRAngle a -> Bool

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

max :: AnonymousMinusRAngle a -> AnonymousMinusRAngle a -> AnonymousMinusRAngle a

min :: AnonymousMinusRAngle a -> AnonymousMinusRAngle a -> AnonymousMinusRAngle a

Show a => Show (AnonymousMinusRAngle a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousMinusRAngle a -> ShowS

show :: AnonymousMinusRAngle a -> String

showList :: [AnonymousMinusRAngle a] -> ShowS

Generic (AnonymousMinusRAngle a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousMinusRAngle a) :: Type -> Type

Methods

from :: AnonymousMinusRAngle a -> Rep (AnonymousMinusRAngle a) x

to :: Rep (AnonymousMinusRAngle a) x -> AnonymousMinusRAngle a

Generic1 AnonymousMinusRAngle

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousMinusRAngle :: k -> Type

Methods

from1 :: AnonymousMinusRAngle a -> Rep1 AnonymousMinusRAngle a

to1 :: Rep1 AnonymousMinusRAngle a -> AnonymousMinusRAngle a

type Rep (AnonymousMinusRAngle a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousMinusRAngle a) = D1 (MetaData "AnonymousMinusRAngle" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousMinusRAngle" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousMinusRAngle

Defined in TreeSitter.Python.AST

type Rep1 AnonymousMinusRAngle = D1 (MetaData "AnonymousMinusRAngle" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousMinusRAngle" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousEqual a

Constructors

AnonymousEqual

Fields

• ann :: a

Instances

Functor AnonymousEqual

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousEqual

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousEqual m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousEqual a -> m

foldr :: (a -> b -> b) -> b -> AnonymousEqual a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousEqual a -> b

foldl :: (b -> a -> b) -> b -> AnonymousEqual a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousEqual a -> b

foldr1 :: (a -> a -> a) -> AnonymousEqual a -> a

foldl1 :: (a -> a -> a) -> AnonymousEqual a -> a

toList :: AnonymousEqual a -> [a]

null :: AnonymousEqual a -> Bool

length :: AnonymousEqual a -> Int

elem :: Eq a => a -> AnonymousEqual a -> Bool

maximum :: Ord a => AnonymousEqual a -> a

minimum :: Ord a => AnonymousEqual a -> a

sum :: Num a => AnonymousEqual a -> a

product :: Num a => AnonymousEqual a -> a

Traversable AnonymousEqual

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousEqual a -> f (AnonymousEqual b)

sequenceA :: Applicative f => AnonymousEqual (f a) -> f (AnonymousEqual a)

mapM :: Monad m => (a -> m b) -> AnonymousEqual a -> m (AnonymousEqual b)

sequence :: Monad m => AnonymousEqual (m a) -> m (AnonymousEqual a)

SymbolMatching AnonymousEqual

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousEqual -> Node -> Bool

showFailure :: Proxy AnonymousEqual -> Node -> String

Unmarshal AnonymousEqual

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousEqual a)

Eq a => Eq (AnonymousEqual a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousEqual a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousEqual a -> AnonymousEqual a -> Ordering

(<) :: AnonymousEqual a -> AnonymousEqual a -> Bool

(<=) :: AnonymousEqual a -> AnonymousEqual a -> Bool

(>) :: AnonymousEqual a -> AnonymousEqual a -> Bool

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

max :: AnonymousEqual a -> AnonymousEqual a -> AnonymousEqual a

min :: AnonymousEqual a -> AnonymousEqual a -> AnonymousEqual a

Show a => Show (AnonymousEqual a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousEqual a -> ShowS

show :: AnonymousEqual a -> String

showList :: [AnonymousEqual a] -> ShowS

Generic (AnonymousEqual a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousEqual a) :: Type -> Type

Methods

from :: AnonymousEqual a -> Rep (AnonymousEqual a) x

to :: Rep (AnonymousEqual a) x -> AnonymousEqual a

Generic1 AnonymousEqual

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousEqual :: k -> Type

Methods

from1 :: AnonymousEqual a -> Rep1 AnonymousEqual a

to1 :: Rep1 AnonymousEqual a -> AnonymousEqual a

type Rep (AnonymousEqual a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousEqual a) = D1 (MetaData "AnonymousEqual" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousEqual" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousEqual

Defined in TreeSitter.Python.AST

type Rep1 AnonymousEqual = D1 (MetaData "AnonymousEqual" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousEqual" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousGlobal a

Constructors

AnonymousGlobal

Fields

• ann :: a

Instances

Functor AnonymousGlobal

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousGlobal

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousGlobal m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousGlobal a -> m

foldr :: (a -> b -> b) -> b -> AnonymousGlobal a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousGlobal a -> b

foldl :: (b -> a -> b) -> b -> AnonymousGlobal a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousGlobal a -> b

foldr1 :: (a -> a -> a) -> AnonymousGlobal a -> a

foldl1 :: (a -> a -> a) -> AnonymousGlobal a -> a

toList :: AnonymousGlobal a -> [a]

null :: AnonymousGlobal a -> Bool

length :: AnonymousGlobal a -> Int

elem :: Eq a => a -> AnonymousGlobal a -> Bool

maximum :: Ord a => AnonymousGlobal a -> a

minimum :: Ord a => AnonymousGlobal a -> a

sum :: Num a => AnonymousGlobal a -> a

product :: Num a => AnonymousGlobal a -> a

Traversable AnonymousGlobal

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousGlobal a -> f (AnonymousGlobal b)

sequenceA :: Applicative f => AnonymousGlobal (f a) -> f (AnonymousGlobal a)

mapM :: Monad m => (a -> m b) -> AnonymousGlobal a -> m (AnonymousGlobal b)

sequence :: Monad m => AnonymousGlobal (m a) -> m (AnonymousGlobal a)

SymbolMatching AnonymousGlobal

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousGlobal -> Node -> Bool

showFailure :: Proxy AnonymousGlobal -> Node -> String

Unmarshal AnonymousGlobal

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousGlobal a)

Eq a => Eq (AnonymousGlobal a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousGlobal a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousGlobal a -> AnonymousGlobal a -> Ordering

(<) :: AnonymousGlobal a -> AnonymousGlobal a -> Bool

(<=) :: AnonymousGlobal a -> AnonymousGlobal a -> Bool

(>) :: AnonymousGlobal a -> AnonymousGlobal a -> Bool

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

max :: AnonymousGlobal a -> AnonymousGlobal a -> AnonymousGlobal a

min :: AnonymousGlobal a -> AnonymousGlobal a -> AnonymousGlobal a

Show a => Show (AnonymousGlobal a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousGlobal a -> ShowS

show :: AnonymousGlobal a -> String

showList :: [AnonymousGlobal a] -> ShowS

Generic (AnonymousGlobal a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousGlobal a) :: Type -> Type

Methods

from :: AnonymousGlobal a -> Rep (AnonymousGlobal a) x

to :: Rep (AnonymousGlobal a) x -> AnonymousGlobal a

Generic1 AnonymousGlobal

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousGlobal :: k -> Type

Methods

from1 :: AnonymousGlobal a -> Rep1 AnonymousGlobal a

to1 :: Rep1 AnonymousGlobal a -> AnonymousGlobal a

type Rep (AnonymousGlobal a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousGlobal a) = D1 (MetaData "AnonymousGlobal" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousGlobal" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousGlobal

Defined in TreeSitter.Python.AST

type Rep1 AnonymousGlobal = D1 (MetaData "AnonymousGlobal" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousGlobal" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousNonlocal a

Constructors

AnonymousNonlocal

Fields

• ann :: a

Instances

Functor AnonymousNonlocal

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousNonlocal

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousNonlocal m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousNonlocal a -> m

foldr :: (a -> b -> b) -> b -> AnonymousNonlocal a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousNonlocal a -> b

foldl :: (b -> a -> b) -> b -> AnonymousNonlocal a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousNonlocal a -> b

foldr1 :: (a -> a -> a) -> AnonymousNonlocal a -> a

foldl1 :: (a -> a -> a) -> AnonymousNonlocal a -> a

toList :: AnonymousNonlocal a -> [a]

null :: AnonymousNonlocal a -> Bool

length :: AnonymousNonlocal a -> Int

elem :: Eq a => a -> AnonymousNonlocal a -> Bool

maximum :: Ord a => AnonymousNonlocal a -> a

minimum :: Ord a => AnonymousNonlocal a -> a

sum :: Num a => AnonymousNonlocal a -> a

product :: Num a => AnonymousNonlocal a -> a

Traversable AnonymousNonlocal

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousNonlocal a -> f (AnonymousNonlocal b)

sequenceA :: Applicative f => AnonymousNonlocal (f a) -> f (AnonymousNonlocal a)

mapM :: Monad m => (a -> m b) -> AnonymousNonlocal a -> m (AnonymousNonlocal b)

sequence :: Monad m => AnonymousNonlocal (m a) -> m (AnonymousNonlocal a)

SymbolMatching AnonymousNonlocal

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousNonlocal -> Node -> Bool

showFailure :: Proxy AnonymousNonlocal -> Node -> String

Unmarshal AnonymousNonlocal

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousNonlocal a)

Eq a => Eq (AnonymousNonlocal a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousNonlocal a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousNonlocal a -> AnonymousNonlocal a -> Ordering

(<) :: AnonymousNonlocal a -> AnonymousNonlocal a -> Bool

(<=) :: AnonymousNonlocal a -> AnonymousNonlocal a -> Bool

(>) :: AnonymousNonlocal a -> AnonymousNonlocal a -> Bool

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

max :: AnonymousNonlocal a -> AnonymousNonlocal a -> AnonymousNonlocal a

min :: AnonymousNonlocal a -> AnonymousNonlocal a -> AnonymousNonlocal a

Show a => Show (AnonymousNonlocal a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousNonlocal a -> ShowS

show :: AnonymousNonlocal a -> String

showList :: [AnonymousNonlocal a] -> ShowS

Generic (AnonymousNonlocal a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousNonlocal a) :: Type -> Type

Methods

from :: AnonymousNonlocal a -> Rep (AnonymousNonlocal a) x

to :: Rep (AnonymousNonlocal a) x -> AnonymousNonlocal a

Generic1 AnonymousNonlocal

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousNonlocal :: k -> Type

Methods

from1 :: AnonymousNonlocal a -> Rep1 AnonymousNonlocal a

to1 :: Rep1 AnonymousNonlocal a -> AnonymousNonlocal a

type Rep (AnonymousNonlocal a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousNonlocal a) = D1 (MetaData "AnonymousNonlocal" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousNonlocal" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousNonlocal

Defined in TreeSitter.Python.AST

type Rep1 AnonymousNonlocal = D1 (MetaData "AnonymousNonlocal" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousNonlocal" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousExec a

Constructors

AnonymousExec

Fields

• ann :: a

Instances

Functor AnonymousExec

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousExec

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousExec m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousExec a -> m

foldr :: (a -> b -> b) -> b -> AnonymousExec a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousExec a -> b

foldl :: (b -> a -> b) -> b -> AnonymousExec a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousExec a -> b

foldr1 :: (a -> a -> a) -> AnonymousExec a -> a

foldl1 :: (a -> a -> a) -> AnonymousExec a -> a

toList :: AnonymousExec a -> [a]

null :: AnonymousExec a -> Bool

length :: AnonymousExec a -> Int

elem :: Eq a => a -> AnonymousExec a -> Bool

maximum :: Ord a => AnonymousExec a -> a

minimum :: Ord a => AnonymousExec a -> a

sum :: Num a => AnonymousExec a -> a

product :: Num a => AnonymousExec a -> a

Traversable AnonymousExec

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousExec a -> f (AnonymousExec b)

sequenceA :: Applicative f => AnonymousExec (f a) -> f (AnonymousExec a)

mapM :: Monad m => (a -> m b) -> AnonymousExec a -> m (AnonymousExec b)

sequence :: Monad m => AnonymousExec (m a) -> m (AnonymousExec a)

SymbolMatching AnonymousExec

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousExec -> Node -> Bool

showFailure :: Proxy AnonymousExec -> Node -> String

Unmarshal AnonymousExec

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousExec a)

Eq a => Eq (AnonymousExec a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousExec a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousExec a -> AnonymousExec a -> Ordering

(<) :: AnonymousExec a -> AnonymousExec a -> Bool

(<=) :: AnonymousExec a -> AnonymousExec a -> Bool

(>) :: AnonymousExec a -> AnonymousExec a -> Bool

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

max :: AnonymousExec a -> AnonymousExec a -> AnonymousExec a

min :: AnonymousExec a -> AnonymousExec a -> AnonymousExec a

Show a => Show (AnonymousExec a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousExec a -> ShowS

show :: AnonymousExec a -> String

showList :: [AnonymousExec a] -> ShowS

Generic (AnonymousExec a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousExec a) :: Type -> Type

Methods

from :: AnonymousExec a -> Rep (AnonymousExec a) x

to :: Rep (AnonymousExec a) x -> AnonymousExec a

Generic1 AnonymousExec

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousExec :: k -> Type

Methods

from1 :: AnonymousExec a -> Rep1 AnonymousExec a

to1 :: Rep1 AnonymousExec a -> AnonymousExec a

type Rep (AnonymousExec a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousExec a) = D1 (MetaData "AnonymousExec" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousExec" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousExec

Defined in TreeSitter.Python.AST

type Rep1 AnonymousExec = D1 (MetaData "AnonymousExec" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousExec" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousClass a

Constructors

AnonymousClass

Fields

• ann :: a

Instances

Functor AnonymousClass

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousClass

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousClass m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousClass a -> m

foldr :: (a -> b -> b) -> b -> AnonymousClass a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousClass a -> b

foldl :: (b -> a -> b) -> b -> AnonymousClass a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousClass a -> b

foldr1 :: (a -> a -> a) -> AnonymousClass a -> a

foldl1 :: (a -> a -> a) -> AnonymousClass a -> a

toList :: AnonymousClass a -> [a]

null :: AnonymousClass a -> Bool

length :: AnonymousClass a -> Int

elem :: Eq a => a -> AnonymousClass a -> Bool

maximum :: Ord a => AnonymousClass a -> a

minimum :: Ord a => AnonymousClass a -> a

sum :: Num a => AnonymousClass a -> a

product :: Num a => AnonymousClass a -> a

Traversable AnonymousClass

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousClass a -> f (AnonymousClass b)

sequenceA :: Applicative f => AnonymousClass (f a) -> f (AnonymousClass a)

mapM :: Monad m => (a -> m b) -> AnonymousClass a -> m (AnonymousClass b)

sequence :: Monad m => AnonymousClass (m a) -> m (AnonymousClass a)

SymbolMatching AnonymousClass

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousClass -> Node -> Bool

showFailure :: Proxy AnonymousClass -> Node -> String

Unmarshal AnonymousClass

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousClass a)

Eq a => Eq (AnonymousClass a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousClass a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousClass a -> AnonymousClass a -> Ordering

(<) :: AnonymousClass a -> AnonymousClass a -> Bool

(<=) :: AnonymousClass a -> AnonymousClass a -> Bool

(>) :: AnonymousClass a -> AnonymousClass a -> Bool

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

max :: AnonymousClass a -> AnonymousClass a -> AnonymousClass a

min :: AnonymousClass a -> AnonymousClass a -> AnonymousClass a

Show a => Show (AnonymousClass a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousClass a -> ShowS

show :: AnonymousClass a -> String

showList :: [AnonymousClass a] -> ShowS

Generic (AnonymousClass a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousClass a) :: Type -> Type

Methods

from :: AnonymousClass a -> Rep (AnonymousClass a) x

to :: Rep (AnonymousClass a) x -> AnonymousClass a

Generic1 AnonymousClass

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousClass :: k -> Type

Methods

from1 :: AnonymousClass a -> Rep1 AnonymousClass a

to1 :: Rep1 AnonymousClass a -> AnonymousClass a

type Rep (AnonymousClass a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousClass a) = D1 (MetaData "AnonymousClass" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousClass" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousClass

Defined in TreeSitter.Python.AST

type Rep1 AnonymousClass = D1 (MetaData "AnonymousClass" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousClass" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousAt a

Constructors

AnonymousAt

Fields

• ann :: a

Instances

Functor AnonymousAt

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousAt

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousAt m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousAt a -> m

foldr :: (a -> b -> b) -> b -> AnonymousAt a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousAt a -> b

foldl :: (b -> a -> b) -> b -> AnonymousAt a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousAt a -> b

foldr1 :: (a -> a -> a) -> AnonymousAt a -> a

foldl1 :: (a -> a -> a) -> AnonymousAt a -> a

toList :: AnonymousAt a -> [a]

null :: AnonymousAt a -> Bool

length :: AnonymousAt a -> Int

elem :: Eq a => a -> AnonymousAt a -> Bool

maximum :: Ord a => AnonymousAt a -> a

minimum :: Ord a => AnonymousAt a -> a

sum :: Num a => AnonymousAt a -> a

product :: Num a => AnonymousAt a -> a

Traversable AnonymousAt

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousAt a -> f (AnonymousAt b)

sequenceA :: Applicative f => AnonymousAt (f a) -> f (AnonymousAt a)

mapM :: Monad m => (a -> m b) -> AnonymousAt a -> m (AnonymousAt b)

sequence :: Monad m => AnonymousAt (m a) -> m (AnonymousAt a)

SymbolMatching AnonymousAt

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousAt -> Node -> Bool

showFailure :: Proxy AnonymousAt -> Node -> String

Unmarshal AnonymousAt

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousAt a)

Eq a => Eq (AnonymousAt a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousAt a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousAt a -> AnonymousAt a -> Ordering

(<) :: AnonymousAt a -> AnonymousAt a -> Bool

(<=) :: AnonymousAt a -> AnonymousAt a -> Bool

(>) :: AnonymousAt a -> AnonymousAt a -> Bool

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

max :: AnonymousAt a -> AnonymousAt a -> AnonymousAt a

min :: AnonymousAt a -> AnonymousAt a -> AnonymousAt a

Show a => Show (AnonymousAt a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousAt a -> ShowS

show :: AnonymousAt a -> String

showList :: [AnonymousAt a] -> ShowS

Generic (AnonymousAt a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousAt a) :: Type -> Type

Methods

from :: AnonymousAt a -> Rep (AnonymousAt a) x

to :: Rep (AnonymousAt a) x -> AnonymousAt a

Generic1 AnonymousAt

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousAt :: k -> Type

Methods

from1 :: AnonymousAt a -> Rep1 AnonymousAt a

to1 :: Rep1 AnonymousAt a -> AnonymousAt a

type Rep (AnonymousAt a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousAt a) = D1 (MetaData "AnonymousAt" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousAt" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousAt

Defined in TreeSitter.Python.AST

type Rep1 AnonymousAt = D1 (MetaData "AnonymousAt" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousAt" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousNot a

Constructors

AnonymousNot

Fields

• ann :: a

Instances

Functor AnonymousNot

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousNot

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousNot m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousNot a -> m

foldr :: (a -> b -> b) -> b -> AnonymousNot a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousNot a -> b

foldl :: (b -> a -> b) -> b -> AnonymousNot a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousNot a -> b

foldr1 :: (a -> a -> a) -> AnonymousNot a -> a

foldl1 :: (a -> a -> a) -> AnonymousNot a -> a

toList :: AnonymousNot a -> [a]

null :: AnonymousNot a -> Bool

length :: AnonymousNot a -> Int

elem :: Eq a => a -> AnonymousNot a -> Bool

maximum :: Ord a => AnonymousNot a -> a

minimum :: Ord a => AnonymousNot a -> a

sum :: Num a => AnonymousNot a -> a

product :: Num a => AnonymousNot a -> a

Traversable AnonymousNot

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousNot a -> f (AnonymousNot b)

sequenceA :: Applicative f => AnonymousNot (f a) -> f (AnonymousNot a)

mapM :: Monad m => (a -> m b) -> AnonymousNot a -> m (AnonymousNot b)

sequence :: Monad m => AnonymousNot (m a) -> m (AnonymousNot a)

SymbolMatching AnonymousNot

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousNot -> Node -> Bool

showFailure :: Proxy AnonymousNot -> Node -> String

Unmarshal AnonymousNot

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousNot a)

Eq a => Eq (AnonymousNot a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousNot a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousNot a -> AnonymousNot a -> Ordering

(<) :: AnonymousNot a -> AnonymousNot a -> Bool

(<=) :: AnonymousNot a -> AnonymousNot a -> Bool

(>) :: AnonymousNot a -> AnonymousNot a -> Bool

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

max :: AnonymousNot a -> AnonymousNot a -> AnonymousNot a

min :: AnonymousNot a -> AnonymousNot a -> AnonymousNot a

Show a => Show (AnonymousNot a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousNot a -> ShowS

show :: AnonymousNot a -> String

showList :: [AnonymousNot a] -> ShowS

Generic (AnonymousNot a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousNot a) :: Type -> Type

Methods

from :: AnonymousNot a -> Rep (AnonymousNot a) x

to :: Rep (AnonymousNot a) x -> AnonymousNot a

Generic1 AnonymousNot

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousNot :: k -> Type

Methods

from1 :: AnonymousNot a -> Rep1 AnonymousNot a

to1 :: Rep1 AnonymousNot a -> AnonymousNot a

type Rep (AnonymousNot a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousNot a) = D1 (MetaData "AnonymousNot" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousNot" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousNot

Defined in TreeSitter.Python.AST

type Rep1 AnonymousNot = D1 (MetaData "AnonymousNot" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousNot" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousAnd a

Constructors

AnonymousAnd

Fields

• ann :: a

Instances

Functor AnonymousAnd

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousAnd

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousAnd m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousAnd a -> m

foldr :: (a -> b -> b) -> b -> AnonymousAnd a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousAnd a -> b

foldl :: (b -> a -> b) -> b -> AnonymousAnd a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousAnd a -> b

foldr1 :: (a -> a -> a) -> AnonymousAnd a -> a

foldl1 :: (a -> a -> a) -> AnonymousAnd a -> a

toList :: AnonymousAnd a -> [a]

null :: AnonymousAnd a -> Bool

length :: AnonymousAnd a -> Int

elem :: Eq a => a -> AnonymousAnd a -> Bool

maximum :: Ord a => AnonymousAnd a -> a

minimum :: Ord a => AnonymousAnd a -> a

sum :: Num a => AnonymousAnd a -> a

product :: Num a => AnonymousAnd a -> a

Traversable AnonymousAnd

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousAnd a -> f (AnonymousAnd b)

sequenceA :: Applicative f => AnonymousAnd (f a) -> f (AnonymousAnd a)

mapM :: Monad m => (a -> m b) -> AnonymousAnd a -> m (AnonymousAnd b)

sequence :: Monad m => AnonymousAnd (m a) -> m (AnonymousAnd a)

SymbolMatching AnonymousAnd

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousAnd -> Node -> Bool

showFailure :: Proxy AnonymousAnd -> Node -> String

Unmarshal AnonymousAnd

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousAnd a)

Eq a => Eq (AnonymousAnd a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousAnd a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousAnd a -> AnonymousAnd a -> Ordering

(<) :: AnonymousAnd a -> AnonymousAnd a -> Bool

(<=) :: AnonymousAnd a -> AnonymousAnd a -> Bool

(>) :: AnonymousAnd a -> AnonymousAnd a -> Bool

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

max :: AnonymousAnd a -> AnonymousAnd a -> AnonymousAnd a

min :: AnonymousAnd a -> AnonymousAnd a -> AnonymousAnd a

Show a => Show (AnonymousAnd a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousAnd a -> ShowS

show :: AnonymousAnd a -> String

showList :: [AnonymousAnd a] -> ShowS

Generic (AnonymousAnd a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousAnd a) :: Type -> Type

Methods

from :: AnonymousAnd a -> Rep (AnonymousAnd a) x

to :: Rep (AnonymousAnd a) x -> AnonymousAnd a

Generic1 AnonymousAnd

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousAnd :: k -> Type

Methods

from1 :: AnonymousAnd a -> Rep1 AnonymousAnd a

to1 :: Rep1 AnonymousAnd a -> AnonymousAnd a

type Rep (AnonymousAnd a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousAnd a) = D1 (MetaData "AnonymousAnd" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousAnd" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousAnd

Defined in TreeSitter.Python.AST

type Rep1 AnonymousAnd = D1 (MetaData "AnonymousAnd" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousAnd" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousOr a

Constructors

AnonymousOr

Fields

• ann :: a

Instances

Functor AnonymousOr

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousOr

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousOr m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousOr a -> m

foldr :: (a -> b -> b) -> b -> AnonymousOr a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousOr a -> b

foldl :: (b -> a -> b) -> b -> AnonymousOr a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousOr a -> b

foldr1 :: (a -> a -> a) -> AnonymousOr a -> a

foldl1 :: (a -> a -> a) -> AnonymousOr a -> a

toList :: AnonymousOr a -> [a]

null :: AnonymousOr a -> Bool

length :: AnonymousOr a -> Int

elem :: Eq a => a -> AnonymousOr a -> Bool

maximum :: Ord a => AnonymousOr a -> a

minimum :: Ord a => AnonymousOr a -> a

sum :: Num a => AnonymousOr a -> a

product :: Num a => AnonymousOr a -> a

Traversable AnonymousOr

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousOr a -> f (AnonymousOr b)

sequenceA :: Applicative f => AnonymousOr (f a) -> f (AnonymousOr a)

mapM :: Monad m => (a -> m b) -> AnonymousOr a -> m (AnonymousOr b)

sequence :: Monad m => AnonymousOr (m a) -> m (AnonymousOr a)

SymbolMatching AnonymousOr

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousOr -> Node -> Bool

showFailure :: Proxy AnonymousOr -> Node -> String

Unmarshal AnonymousOr

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousOr a)

Eq a => Eq (AnonymousOr a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousOr a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousOr a -> AnonymousOr a -> Ordering

(<) :: AnonymousOr a -> AnonymousOr a -> Bool

(<=) :: AnonymousOr a -> AnonymousOr a -> Bool

(>) :: AnonymousOr a -> AnonymousOr a -> Bool

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

max :: AnonymousOr a -> AnonymousOr a -> AnonymousOr a

min :: AnonymousOr a -> AnonymousOr a -> AnonymousOr a

Show a => Show (AnonymousOr a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousOr a -> ShowS

show :: AnonymousOr a -> String

showList :: [AnonymousOr a] -> ShowS

Generic (AnonymousOr a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousOr a) :: Type -> Type

Methods

from :: AnonymousOr a -> Rep (AnonymousOr a) x

to :: Rep (AnonymousOr a) x -> AnonymousOr a

Generic1 AnonymousOr

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousOr :: k -> Type

Methods

from1 :: AnonymousOr a -> Rep1 AnonymousOr a

to1 :: Rep1 AnonymousOr a -> AnonymousOr a

type Rep (AnonymousOr a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousOr a) = D1 (MetaData "AnonymousOr" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousOr" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousOr

Defined in TreeSitter.Python.AST

type Rep1 AnonymousOr = D1 (MetaData "AnonymousOr" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousOr" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousPlus a

Constructors

AnonymousPlus

Fields

• ann :: a

Instances

Functor AnonymousPlus

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousPlus

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousPlus m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousPlus a -> m

foldr :: (a -> b -> b) -> b -> AnonymousPlus a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousPlus a -> b

foldl :: (b -> a -> b) -> b -> AnonymousPlus a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousPlus a -> b

foldr1 :: (a -> a -> a) -> AnonymousPlus a -> a

foldl1 :: (a -> a -> a) -> AnonymousPlus a -> a

toList :: AnonymousPlus a -> [a]

null :: AnonymousPlus a -> Bool

length :: AnonymousPlus a -> Int

elem :: Eq a => a -> AnonymousPlus a -> Bool

maximum :: Ord a => AnonymousPlus a -> a

minimum :: Ord a => AnonymousPlus a -> a

sum :: Num a => AnonymousPlus a -> a

product :: Num a => AnonymousPlus a -> a

Traversable AnonymousPlus

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousPlus a -> f (AnonymousPlus b)

sequenceA :: Applicative f => AnonymousPlus (f a) -> f (AnonymousPlus a)

mapM :: Monad m => (a -> m b) -> AnonymousPlus a -> m (AnonymousPlus b)

sequence :: Monad m => AnonymousPlus (m a) -> m (AnonymousPlus a)

SymbolMatching AnonymousPlus

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousPlus -> Node -> Bool

showFailure :: Proxy AnonymousPlus -> Node -> String

Unmarshal AnonymousPlus

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousPlus a)

Eq a => Eq (AnonymousPlus a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousPlus a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousPlus a -> AnonymousPlus a -> Ordering

(<) :: AnonymousPlus a -> AnonymousPlus a -> Bool

(<=) :: AnonymousPlus a -> AnonymousPlus a -> Bool

(>) :: AnonymousPlus a -> AnonymousPlus a -> Bool

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

max :: AnonymousPlus a -> AnonymousPlus a -> AnonymousPlus a

min :: AnonymousPlus a -> AnonymousPlus a -> AnonymousPlus a

Show a => Show (AnonymousPlus a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousPlus a -> ShowS

show :: AnonymousPlus a -> String

showList :: [AnonymousPlus a] -> ShowS

Generic (AnonymousPlus a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousPlus a) :: Type -> Type

Methods

from :: AnonymousPlus a -> Rep (AnonymousPlus a) x

to :: Rep (AnonymousPlus a) x -> AnonymousPlus a

Generic1 AnonymousPlus

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousPlus :: k -> Type

Methods

from1 :: AnonymousPlus a -> Rep1 AnonymousPlus a

to1 :: Rep1 AnonymousPlus a -> AnonymousPlus a

type Rep (AnonymousPlus a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousPlus a) = D1 (MetaData "AnonymousPlus" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousPlus" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousPlus

Defined in TreeSitter.Python.AST

type Rep1 AnonymousPlus = D1 (MetaData "AnonymousPlus" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousPlus" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousMinus a

Constructors

AnonymousMinus

Fields

• ann :: a

Instances

Functor AnonymousMinus

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousMinus

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousMinus m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousMinus a -> m

foldr :: (a -> b -> b) -> b -> AnonymousMinus a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousMinus a -> b

foldl :: (b -> a -> b) -> b -> AnonymousMinus a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousMinus a -> b

foldr1 :: (a -> a -> a) -> AnonymousMinus a -> a

foldl1 :: (a -> a -> a) -> AnonymousMinus a -> a

toList :: AnonymousMinus a -> [a]

null :: AnonymousMinus a -> Bool

length :: AnonymousMinus a -> Int

elem :: Eq a => a -> AnonymousMinus a -> Bool

maximum :: Ord a => AnonymousMinus a -> a

minimum :: Ord a => AnonymousMinus a -> a

sum :: Num a => AnonymousMinus a -> a

product :: Num a => AnonymousMinus a -> a

Traversable AnonymousMinus

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousMinus a -> f (AnonymousMinus b)

sequenceA :: Applicative f => AnonymousMinus (f a) -> f (AnonymousMinus a)

mapM :: Monad m => (a -> m b) -> AnonymousMinus a -> m (AnonymousMinus b)

sequence :: Monad m => AnonymousMinus (m a) -> m (AnonymousMinus a)

SymbolMatching AnonymousMinus

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousMinus -> Node -> Bool

showFailure :: Proxy AnonymousMinus -> Node -> String

Unmarshal AnonymousMinus

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousMinus a)

Eq a => Eq (AnonymousMinus a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousMinus a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousMinus a -> AnonymousMinus a -> Ordering

(<) :: AnonymousMinus a -> AnonymousMinus a -> Bool

(<=) :: AnonymousMinus a -> AnonymousMinus a -> Bool

(>) :: AnonymousMinus a -> AnonymousMinus a -> Bool

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

max :: AnonymousMinus a -> AnonymousMinus a -> AnonymousMinus a

min :: AnonymousMinus a -> AnonymousMinus a -> AnonymousMinus a

Show a => Show (AnonymousMinus a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousMinus a -> ShowS

show :: AnonymousMinus a -> String

showList :: [AnonymousMinus a] -> ShowS

Generic (AnonymousMinus a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousMinus a) :: Type -> Type

Methods

from :: AnonymousMinus a -> Rep (AnonymousMinus a) x

to :: Rep (AnonymousMinus a) x -> AnonymousMinus a

Generic1 AnonymousMinus

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousMinus :: k -> Type

Methods

from1 :: AnonymousMinus a -> Rep1 AnonymousMinus a

to1 :: Rep1 AnonymousMinus a -> AnonymousMinus a

type Rep (AnonymousMinus a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousMinus a) = D1 (MetaData "AnonymousMinus" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousMinus" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousMinus

Defined in TreeSitter.Python.AST

type Rep1 AnonymousMinus = D1 (MetaData "AnonymousMinus" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousMinus" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousSlash a

Constructors

AnonymousSlash

Fields

• ann :: a

Instances

Functor AnonymousSlash

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousSlash

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousSlash m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousSlash a -> m

foldr :: (a -> b -> b) -> b -> AnonymousSlash a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousSlash a -> b

foldl :: (b -> a -> b) -> b -> AnonymousSlash a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousSlash a -> b

foldr1 :: (a -> a -> a) -> AnonymousSlash a -> a

foldl1 :: (a -> a -> a) -> AnonymousSlash a -> a

toList :: AnonymousSlash a -> [a]

null :: AnonymousSlash a -> Bool

length :: AnonymousSlash a -> Int

elem :: Eq a => a -> AnonymousSlash a -> Bool

maximum :: Ord a => AnonymousSlash a -> a

minimum :: Ord a => AnonymousSlash a -> a

sum :: Num a => AnonymousSlash a -> a

product :: Num a => AnonymousSlash a -> a

Traversable AnonymousSlash

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousSlash a -> f (AnonymousSlash b)

sequenceA :: Applicative f => AnonymousSlash (f a) -> f (AnonymousSlash a)

mapM :: Monad m => (a -> m b) -> AnonymousSlash a -> m (AnonymousSlash b)

sequence :: Monad m => AnonymousSlash (m a) -> m (AnonymousSlash a)

SymbolMatching AnonymousSlash

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousSlash -> Node -> Bool

showFailure :: Proxy AnonymousSlash -> Node -> String

Unmarshal AnonymousSlash

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousSlash a)

Eq a => Eq (AnonymousSlash a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousSlash a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousSlash a -> AnonymousSlash a -> Ordering

(<) :: AnonymousSlash a -> AnonymousSlash a -> Bool

(<=) :: AnonymousSlash a -> AnonymousSlash a -> Bool

(>) :: AnonymousSlash a -> AnonymousSlash a -> Bool

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

max :: AnonymousSlash a -> AnonymousSlash a -> AnonymousSlash a

min :: AnonymousSlash a -> AnonymousSlash a -> AnonymousSlash a

Show a => Show (AnonymousSlash a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousSlash a -> ShowS

show :: AnonymousSlash a -> String

showList :: [AnonymousSlash a] -> ShowS

Generic (AnonymousSlash a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousSlash a) :: Type -> Type

Methods

from :: AnonymousSlash a -> Rep (AnonymousSlash a) x

to :: Rep (AnonymousSlash a) x -> AnonymousSlash a

Generic1 AnonymousSlash

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousSlash :: k -> Type

Methods

from1 :: AnonymousSlash a -> Rep1 AnonymousSlash a

to1 :: Rep1 AnonymousSlash a -> AnonymousSlash a

type Rep (AnonymousSlash a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousSlash a) = D1 (MetaData "AnonymousSlash" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousSlash" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousSlash

Defined in TreeSitter.Python.AST

type Rep1 AnonymousSlash = D1 (MetaData "AnonymousSlash" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousSlash" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousPercent a

Constructors

AnonymousPercent

Fields

• ann :: a

Instances

Functor AnonymousPercent

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousPercent

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousPercent m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousPercent a -> m

foldr :: (a -> b -> b) -> b -> AnonymousPercent a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousPercent a -> b

foldl :: (b -> a -> b) -> b -> AnonymousPercent a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousPercent a -> b

foldr1 :: (a -> a -> a) -> AnonymousPercent a -> a

foldl1 :: (a -> a -> a) -> AnonymousPercent a -> a

toList :: AnonymousPercent a -> [a]

null :: AnonymousPercent a -> Bool

length :: AnonymousPercent a -> Int

elem :: Eq a => a -> AnonymousPercent a -> Bool

maximum :: Ord a => AnonymousPercent a -> a

minimum :: Ord a => AnonymousPercent a -> a

sum :: Num a => AnonymousPercent a -> a

product :: Num a => AnonymousPercent a -> a

Traversable AnonymousPercent

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousPercent a -> f (AnonymousPercent b)

sequenceA :: Applicative f => AnonymousPercent (f a) -> f (AnonymousPercent a)

mapM :: Monad m => (a -> m b) -> AnonymousPercent a -> m (AnonymousPercent b)

sequence :: Monad m => AnonymousPercent (m a) -> m (AnonymousPercent a)

SymbolMatching AnonymousPercent

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousPercent -> Node -> Bool

showFailure :: Proxy AnonymousPercent -> Node -> String

Unmarshal AnonymousPercent

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousPercent a)

Eq a => Eq (AnonymousPercent a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousPercent a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousPercent a -> AnonymousPercent a -> Ordering

(<) :: AnonymousPercent a -> AnonymousPercent a -> Bool

(<=) :: AnonymousPercent a -> AnonymousPercent a -> Bool

(>) :: AnonymousPercent a -> AnonymousPercent a -> Bool

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

max :: AnonymousPercent a -> AnonymousPercent a -> AnonymousPercent a

min :: AnonymousPercent a -> AnonymousPercent a -> AnonymousPercent a

Show a => Show (AnonymousPercent a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousPercent a -> ShowS

show :: AnonymousPercent a -> String

showList :: [AnonymousPercent a] -> ShowS

Generic (AnonymousPercent a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousPercent a) :: Type -> Type

Methods

from :: AnonymousPercent a -> Rep (AnonymousPercent a) x

to :: Rep (AnonymousPercent a) x -> AnonymousPercent a

Generic1 AnonymousPercent

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousPercent :: k -> Type

Methods

from1 :: AnonymousPercent a -> Rep1 AnonymousPercent a

to1 :: Rep1 AnonymousPercent a -> AnonymousPercent a

type Rep (AnonymousPercent a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousPercent a) = D1 (MetaData "AnonymousPercent" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousPercent" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousPercent

Defined in TreeSitter.Python.AST

type Rep1 AnonymousPercent = D1 (MetaData "AnonymousPercent" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousPercent" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousSlashSlash a

Constructors

AnonymousSlashSlash

Fields

• ann :: a

Instances

Functor AnonymousSlashSlash

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousSlashSlash

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousSlashSlash m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousSlashSlash a -> m

foldr :: (a -> b -> b) -> b -> AnonymousSlashSlash a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousSlashSlash a -> b

foldl :: (b -> a -> b) -> b -> AnonymousSlashSlash a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousSlashSlash a -> b

foldr1 :: (a -> a -> a) -> AnonymousSlashSlash a -> a

foldl1 :: (a -> a -> a) -> AnonymousSlashSlash a -> a

toList :: AnonymousSlashSlash a -> [a]

null :: AnonymousSlashSlash a -> Bool

length :: AnonymousSlashSlash a -> Int

elem :: Eq a => a -> AnonymousSlashSlash a -> Bool

maximum :: Ord a => AnonymousSlashSlash a -> a

minimum :: Ord a => AnonymousSlashSlash a -> a

sum :: Num a => AnonymousSlashSlash a -> a

product :: Num a => AnonymousSlashSlash a -> a

Traversable AnonymousSlashSlash

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousSlashSlash a -> f (AnonymousSlashSlash b)

sequenceA :: Applicative f => AnonymousSlashSlash (f a) -> f (AnonymousSlashSlash a)

mapM :: Monad m => (a -> m b) -> AnonymousSlashSlash a -> m (AnonymousSlashSlash b)

sequence :: Monad m => AnonymousSlashSlash (m a) -> m (AnonymousSlashSlash a)

SymbolMatching AnonymousSlashSlash

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousSlashSlash -> Node -> Bool

showFailure :: Proxy AnonymousSlashSlash -> Node -> String

Unmarshal AnonymousSlashSlash

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousSlashSlash a)

Eq a => Eq (AnonymousSlashSlash a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousSlashSlash a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousSlashSlash a -> AnonymousSlashSlash a -> Ordering

(<) :: AnonymousSlashSlash a -> AnonymousSlashSlash a -> Bool

(<=) :: AnonymousSlashSlash a -> AnonymousSlashSlash a -> Bool

(>) :: AnonymousSlashSlash a -> AnonymousSlashSlash a -> Bool

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

max :: AnonymousSlashSlash a -> AnonymousSlashSlash a -> AnonymousSlashSlash a

min :: AnonymousSlashSlash a -> AnonymousSlashSlash a -> AnonymousSlashSlash a

Show a => Show (AnonymousSlashSlash a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousSlashSlash a -> ShowS

show :: AnonymousSlashSlash a -> String

showList :: [AnonymousSlashSlash a] -> ShowS

Generic (AnonymousSlashSlash a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousSlashSlash a) :: Type -> Type

Methods

from :: AnonymousSlashSlash a -> Rep (AnonymousSlashSlash a) x

to :: Rep (AnonymousSlashSlash a) x -> AnonymousSlashSlash a

Generic1 AnonymousSlashSlash

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousSlashSlash :: k -> Type

Methods

from1 :: AnonymousSlashSlash a -> Rep1 AnonymousSlashSlash a

to1 :: Rep1 AnonymousSlashSlash a -> AnonymousSlashSlash a

type Rep (AnonymousSlashSlash a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousSlashSlash a) = D1 (MetaData "AnonymousSlashSlash" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousSlashSlash" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousSlashSlash

Defined in TreeSitter.Python.AST

type Rep1 AnonymousSlashSlash = D1 (MetaData "AnonymousSlashSlash" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousSlashSlash" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousStarStar a

Constructors

AnonymousStarStar

Fields

• ann :: a

Instances

Functor AnonymousStarStar

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousStarStar

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousStarStar m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousStarStar a -> m

foldr :: (a -> b -> b) -> b -> AnonymousStarStar a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousStarStar a -> b

foldl :: (b -> a -> b) -> b -> AnonymousStarStar a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousStarStar a -> b

foldr1 :: (a -> a -> a) -> AnonymousStarStar a -> a

foldl1 :: (a -> a -> a) -> AnonymousStarStar a -> a

toList :: AnonymousStarStar a -> [a]

null :: AnonymousStarStar a -> Bool

length :: AnonymousStarStar a -> Int

elem :: Eq a => a -> AnonymousStarStar a -> Bool

maximum :: Ord a => AnonymousStarStar a -> a

minimum :: Ord a => AnonymousStarStar a -> a

sum :: Num a => AnonymousStarStar a -> a

product :: Num a => AnonymousStarStar a -> a

Traversable AnonymousStarStar

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousStarStar a -> f (AnonymousStarStar b)

sequenceA :: Applicative f => AnonymousStarStar (f a) -> f (AnonymousStarStar a)

mapM :: Monad m => (a -> m b) -> AnonymousStarStar a -> m (AnonymousStarStar b)

sequence :: Monad m => AnonymousStarStar (m a) -> m (AnonymousStarStar a)

SymbolMatching AnonymousStarStar

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousStarStar -> Node -> Bool

showFailure :: Proxy AnonymousStarStar -> Node -> String

Unmarshal AnonymousStarStar

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousStarStar a)

Eq a => Eq (AnonymousStarStar a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousStarStar a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousStarStar a -> AnonymousStarStar a -> Ordering

(<) :: AnonymousStarStar a -> AnonymousStarStar a -> Bool

(<=) :: AnonymousStarStar a -> AnonymousStarStar a -> Bool

(>) :: AnonymousStarStar a -> AnonymousStarStar a -> Bool

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

max :: AnonymousStarStar a -> AnonymousStarStar a -> AnonymousStarStar a

min :: AnonymousStarStar a -> AnonymousStarStar a -> AnonymousStarStar a

Show a => Show (AnonymousStarStar a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousStarStar a -> ShowS

show :: AnonymousStarStar a -> String

showList :: [AnonymousStarStar a] -> ShowS

Generic (AnonymousStarStar a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousStarStar a) :: Type -> Type

Methods

from :: AnonymousStarStar a -> Rep (AnonymousStarStar a) x

to :: Rep (AnonymousStarStar a) x -> AnonymousStarStar a

Generic1 AnonymousStarStar

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousStarStar :: k -> Type

Methods

from1 :: AnonymousStarStar a -> Rep1 AnonymousStarStar a

to1 :: Rep1 AnonymousStarStar a -> AnonymousStarStar a

type Rep (AnonymousStarStar a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousStarStar a) = D1 (MetaData "AnonymousStarStar" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousStarStar" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousStarStar

Defined in TreeSitter.Python.AST

type Rep1 AnonymousStarStar = D1 (MetaData "AnonymousStarStar" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousStarStar" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousPipe a

Constructors

AnonymousPipe

Fields

• ann :: a

Instances

Functor AnonymousPipe

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousPipe

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousPipe m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousPipe a -> m

foldr :: (a -> b -> b) -> b -> AnonymousPipe a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousPipe a -> b

foldl :: (b -> a -> b) -> b -> AnonymousPipe a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousPipe a -> b

foldr1 :: (a -> a -> a) -> AnonymousPipe a -> a

foldl1 :: (a -> a -> a) -> AnonymousPipe a -> a

toList :: AnonymousPipe a -> [a]

null :: AnonymousPipe a -> Bool

length :: AnonymousPipe a -> Int

elem :: Eq a => a -> AnonymousPipe a -> Bool

maximum :: Ord a => AnonymousPipe a -> a

minimum :: Ord a => AnonymousPipe a -> a

sum :: Num a => AnonymousPipe a -> a

product :: Num a => AnonymousPipe a -> a

Traversable AnonymousPipe

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousPipe a -> f (AnonymousPipe b)

sequenceA :: Applicative f => AnonymousPipe (f a) -> f (AnonymousPipe a)

mapM :: Monad m => (a -> m b) -> AnonymousPipe a -> m (AnonymousPipe b)

sequence :: Monad m => AnonymousPipe (m a) -> m (AnonymousPipe a)

SymbolMatching AnonymousPipe

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousPipe -> Node -> Bool

showFailure :: Proxy AnonymousPipe -> Node -> String

Unmarshal AnonymousPipe

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousPipe a)

Eq a => Eq (AnonymousPipe a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousPipe a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousPipe a -> AnonymousPipe a -> Ordering

(<) :: AnonymousPipe a -> AnonymousPipe a -> Bool

(<=) :: AnonymousPipe a -> AnonymousPipe a -> Bool

(>) :: AnonymousPipe a -> AnonymousPipe a -> Bool

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

max :: AnonymousPipe a -> AnonymousPipe a -> AnonymousPipe a

min :: AnonymousPipe a -> AnonymousPipe a -> AnonymousPipe a

Show a => Show (AnonymousPipe a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousPipe a -> ShowS

show :: AnonymousPipe a -> String

showList :: [AnonymousPipe a] -> ShowS

Generic (AnonymousPipe a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousPipe a) :: Type -> Type

Methods

from :: AnonymousPipe a -> Rep (AnonymousPipe a) x

to :: Rep (AnonymousPipe a) x -> AnonymousPipe a

Generic1 AnonymousPipe

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousPipe :: k -> Type

Methods

from1 :: AnonymousPipe a -> Rep1 AnonymousPipe a

to1 :: Rep1 AnonymousPipe a -> AnonymousPipe a

type Rep (AnonymousPipe a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousPipe a) = D1 (MetaData "AnonymousPipe" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousPipe" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousPipe

Defined in TreeSitter.Python.AST

type Rep1 AnonymousPipe = D1 (MetaData "AnonymousPipe" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousPipe" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousAmpersand a

Constructors

AnonymousAmpersand

Fields

• ann :: a

Instances

Functor AnonymousAmpersand

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousAmpersand

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousAmpersand m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousAmpersand a -> m

foldr :: (a -> b -> b) -> b -> AnonymousAmpersand a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousAmpersand a -> b

foldl :: (b -> a -> b) -> b -> AnonymousAmpersand a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousAmpersand a -> b

foldr1 :: (a -> a -> a) -> AnonymousAmpersand a -> a

foldl1 :: (a -> a -> a) -> AnonymousAmpersand a -> a

toList :: AnonymousAmpersand a -> [a]

null :: AnonymousAmpersand a -> Bool

length :: AnonymousAmpersand a -> Int

elem :: Eq a => a -> AnonymousAmpersand a -> Bool

maximum :: Ord a => AnonymousAmpersand a -> a

minimum :: Ord a => AnonymousAmpersand a -> a

sum :: Num a => AnonymousAmpersand a -> a

product :: Num a => AnonymousAmpersand a -> a

Traversable AnonymousAmpersand

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousAmpersand a -> f (AnonymousAmpersand b)

sequenceA :: Applicative f => AnonymousAmpersand (f a) -> f (AnonymousAmpersand a)

mapM :: Monad m => (a -> m b) -> AnonymousAmpersand a -> m (AnonymousAmpersand b)

sequence :: Monad m => AnonymousAmpersand (m a) -> m (AnonymousAmpersand a)

SymbolMatching AnonymousAmpersand

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousAmpersand -> Node -> Bool

showFailure :: Proxy AnonymousAmpersand -> Node -> String

Unmarshal AnonymousAmpersand

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousAmpersand a)

Eq a => Eq (AnonymousAmpersand a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousAmpersand a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousAmpersand a -> AnonymousAmpersand a -> Ordering

(<) :: AnonymousAmpersand a -> AnonymousAmpersand a -> Bool

(<=) :: AnonymousAmpersand a -> AnonymousAmpersand a -> Bool

(>) :: AnonymousAmpersand a -> AnonymousAmpersand a -> Bool

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

max :: AnonymousAmpersand a -> AnonymousAmpersand a -> AnonymousAmpersand a

min :: AnonymousAmpersand a -> AnonymousAmpersand a -> AnonymousAmpersand a

Show a => Show (AnonymousAmpersand a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousAmpersand a -> ShowS

show :: AnonymousAmpersand a -> String

showList :: [AnonymousAmpersand a] -> ShowS

Generic (AnonymousAmpersand a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousAmpersand a) :: Type -> Type

Methods

from :: AnonymousAmpersand a -> Rep (AnonymousAmpersand a) x

to :: Rep (AnonymousAmpersand a) x -> AnonymousAmpersand a

Generic1 AnonymousAmpersand

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousAmpersand :: k -> Type

Methods

from1 :: AnonymousAmpersand a -> Rep1 AnonymousAmpersand a

to1 :: Rep1 AnonymousAmpersand a -> AnonymousAmpersand a

type Rep (AnonymousAmpersand a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousAmpersand a) = D1 (MetaData "AnonymousAmpersand" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousAmpersand" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousAmpersand

Defined in TreeSitter.Python.AST

type Rep1 AnonymousAmpersand = D1 (MetaData "AnonymousAmpersand" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousAmpersand" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousCaret a

Constructors

AnonymousCaret

Fields

• ann :: a

Instances

Functor AnonymousCaret

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousCaret

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousCaret m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousCaret a -> m

foldr :: (a -> b -> b) -> b -> AnonymousCaret a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousCaret a -> b

foldl :: (b -> a -> b) -> b -> AnonymousCaret a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousCaret a -> b

foldr1 :: (a -> a -> a) -> AnonymousCaret a -> a

foldl1 :: (a -> a -> a) -> AnonymousCaret a -> a

toList :: AnonymousCaret a -> [a]

null :: AnonymousCaret a -> Bool

length :: AnonymousCaret a -> Int

elem :: Eq a => a -> AnonymousCaret a -> Bool

maximum :: Ord a => AnonymousCaret a -> a

minimum :: Ord a => AnonymousCaret a -> a

sum :: Num a => AnonymousCaret a -> a

product :: Num a => AnonymousCaret a -> a

Traversable AnonymousCaret

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousCaret a -> f (AnonymousCaret b)

sequenceA :: Applicative f => AnonymousCaret (f a) -> f (AnonymousCaret a)

mapM :: Monad m => (a -> m b) -> AnonymousCaret a -> m (AnonymousCaret b)

sequence :: Monad m => AnonymousCaret (m a) -> m (AnonymousCaret a)

SymbolMatching AnonymousCaret

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousCaret -> Node -> Bool

showFailure :: Proxy AnonymousCaret -> Node -> String

Unmarshal AnonymousCaret

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousCaret a)

Eq a => Eq (AnonymousCaret a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousCaret a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousCaret a -> AnonymousCaret a -> Ordering

(<) :: AnonymousCaret a -> AnonymousCaret a -> Bool

(<=) :: AnonymousCaret a -> AnonymousCaret a -> Bool

(>) :: AnonymousCaret a -> AnonymousCaret a -> Bool

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

max :: AnonymousCaret a -> AnonymousCaret a -> AnonymousCaret a

min :: AnonymousCaret a -> AnonymousCaret a -> AnonymousCaret a

Show a => Show (AnonymousCaret a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousCaret a -> ShowS

show :: AnonymousCaret a -> String

showList :: [AnonymousCaret a] -> ShowS

Generic (AnonymousCaret a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousCaret a) :: Type -> Type

Methods

from :: AnonymousCaret a -> Rep (AnonymousCaret a) x

to :: Rep (AnonymousCaret a) x -> AnonymousCaret a

Generic1 AnonymousCaret

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousCaret :: k -> Type

Methods

from1 :: AnonymousCaret a -> Rep1 AnonymousCaret a

to1 :: Rep1 AnonymousCaret a -> AnonymousCaret a

type Rep (AnonymousCaret a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousCaret a) = D1 (MetaData "AnonymousCaret" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousCaret" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousCaret

Defined in TreeSitter.Python.AST

type Rep1 AnonymousCaret = D1 (MetaData "AnonymousCaret" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousCaret" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousLAngleLAngle a

Constructors

AnonymousLAngleLAngle

Fields

• ann :: a

Instances

Functor AnonymousLAngleLAngle

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousLAngleLAngle

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousLAngleLAngle m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousLAngleLAngle a -> m

foldr :: (a -> b -> b) -> b -> AnonymousLAngleLAngle a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousLAngleLAngle a -> b

foldl :: (b -> a -> b) -> b -> AnonymousLAngleLAngle a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousLAngleLAngle a -> b

foldr1 :: (a -> a -> a) -> AnonymousLAngleLAngle a -> a

foldl1 :: (a -> a -> a) -> AnonymousLAngleLAngle a -> a

toList :: AnonymousLAngleLAngle a -> [a]

null :: AnonymousLAngleLAngle a -> Bool

length :: AnonymousLAngleLAngle a -> Int

elem :: Eq a => a -> AnonymousLAngleLAngle a -> Bool

maximum :: Ord a => AnonymousLAngleLAngle a -> a

minimum :: Ord a => AnonymousLAngleLAngle a -> a

sum :: Num a => AnonymousLAngleLAngle a -> a

product :: Num a => AnonymousLAngleLAngle a -> a

Traversable AnonymousLAngleLAngle

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousLAngleLAngle a -> f (AnonymousLAngleLAngle b)

sequenceA :: Applicative f => AnonymousLAngleLAngle (f a) -> f (AnonymousLAngleLAngle a)

mapM :: Monad m => (a -> m b) -> AnonymousLAngleLAngle a -> m (AnonymousLAngleLAngle b)

sequence :: Monad m => AnonymousLAngleLAngle (m a) -> m (AnonymousLAngleLAngle a)

SymbolMatching AnonymousLAngleLAngle

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousLAngleLAngle -> Node -> Bool

showFailure :: Proxy AnonymousLAngleLAngle -> Node -> String

Unmarshal AnonymousLAngleLAngle

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousLAngleLAngle a)

Eq a => Eq (AnonymousLAngleLAngle a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousLAngleLAngle a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousLAngleLAngle a -> AnonymousLAngleLAngle a -> Ordering

(<) :: AnonymousLAngleLAngle a -> AnonymousLAngleLAngle a -> Bool

(<=) :: AnonymousLAngleLAngle a -> AnonymousLAngleLAngle a -> Bool

(>) :: AnonymousLAngleLAngle a -> AnonymousLAngleLAngle a -> Bool

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

max :: AnonymousLAngleLAngle a -> AnonymousLAngleLAngle a -> AnonymousLAngleLAngle a

min :: AnonymousLAngleLAngle a -> AnonymousLAngleLAngle a -> AnonymousLAngleLAngle a

Show a => Show (AnonymousLAngleLAngle a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousLAngleLAngle a -> ShowS

show :: AnonymousLAngleLAngle a -> String

showList :: [AnonymousLAngleLAngle a] -> ShowS

Generic (AnonymousLAngleLAngle a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousLAngleLAngle a) :: Type -> Type

Methods

from :: AnonymousLAngleLAngle a -> Rep (AnonymousLAngleLAngle a) x

to :: Rep (AnonymousLAngleLAngle a) x -> AnonymousLAngleLAngle a

Generic1 AnonymousLAngleLAngle

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousLAngleLAngle :: k -> Type

Methods

from1 :: AnonymousLAngleLAngle a -> Rep1 AnonymousLAngleLAngle a

to1 :: Rep1 AnonymousLAngleLAngle a -> AnonymousLAngleLAngle a

type Rep (AnonymousLAngleLAngle a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousLAngleLAngle a) = D1 (MetaData "AnonymousLAngleLAngle" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousLAngleLAngle" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousLAngleLAngle

Defined in TreeSitter.Python.AST

type Rep1 AnonymousLAngleLAngle = D1 (MetaData "AnonymousLAngleLAngle" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousLAngleLAngle" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousTilde a

Constructors

AnonymousTilde

Fields

• ann :: a

Instances

Functor AnonymousTilde

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousTilde

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousTilde m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousTilde a -> m

foldr :: (a -> b -> b) -> b -> AnonymousTilde a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousTilde a -> b

foldl :: (b -> a -> b) -> b -> AnonymousTilde a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousTilde a -> b

foldr1 :: (a -> a -> a) -> AnonymousTilde a -> a

foldl1 :: (a -> a -> a) -> AnonymousTilde a -> a

toList :: AnonymousTilde a -> [a]

null :: AnonymousTilde a -> Bool

length :: AnonymousTilde a -> Int

elem :: Eq a => a -> AnonymousTilde a -> Bool

maximum :: Ord a => AnonymousTilde a -> a

minimum :: Ord a => AnonymousTilde a -> a

sum :: Num a => AnonymousTilde a -> a

product :: Num a => AnonymousTilde a -> a

Traversable AnonymousTilde

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousTilde a -> f (AnonymousTilde b)

sequenceA :: Applicative f => AnonymousTilde (f a) -> f (AnonymousTilde a)

mapM :: Monad m => (a -> m b) -> AnonymousTilde a -> m (AnonymousTilde b)

sequence :: Monad m => AnonymousTilde (m a) -> m (AnonymousTilde a)

SymbolMatching AnonymousTilde

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousTilde -> Node -> Bool

showFailure :: Proxy AnonymousTilde -> Node -> String

Unmarshal AnonymousTilde

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousTilde a)

Eq a => Eq (AnonymousTilde a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousTilde a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousTilde a -> AnonymousTilde a -> Ordering

(<) :: AnonymousTilde a -> AnonymousTilde a -> Bool

(<=) :: AnonymousTilde a -> AnonymousTilde a -> Bool

(>) :: AnonymousTilde a -> AnonymousTilde a -> Bool

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

max :: AnonymousTilde a -> AnonymousTilde a -> AnonymousTilde a

min :: AnonymousTilde a -> AnonymousTilde a -> AnonymousTilde a

Show a => Show (AnonymousTilde a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousTilde a -> ShowS

show :: AnonymousTilde a -> String

showList :: [AnonymousTilde a] -> ShowS

Generic (AnonymousTilde a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousTilde a) :: Type -> Type

Methods

from :: AnonymousTilde a -> Rep (AnonymousTilde a) x

to :: Rep (AnonymousTilde a) x -> AnonymousTilde a

Generic1 AnonymousTilde

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousTilde :: k -> Type

Methods

from1 :: AnonymousTilde a -> Rep1 AnonymousTilde a

to1 :: Rep1 AnonymousTilde a -> AnonymousTilde a

type Rep (AnonymousTilde a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousTilde a) = D1 (MetaData "AnonymousTilde" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousTilde" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousTilde

Defined in TreeSitter.Python.AST

type Rep1 AnonymousTilde = D1 (MetaData "AnonymousTilde" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousTilde" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousLAngle a

Constructors

AnonymousLAngle

Fields

• ann :: a

Instances

Functor AnonymousLAngle

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousLAngle

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousLAngle m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousLAngle a -> m

foldr :: (a -> b -> b) -> b -> AnonymousLAngle a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousLAngle a -> b

foldl :: (b -> a -> b) -> b -> AnonymousLAngle a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousLAngle a -> b

foldr1 :: (a -> a -> a) -> AnonymousLAngle a -> a

foldl1 :: (a -> a -> a) -> AnonymousLAngle a -> a

toList :: AnonymousLAngle a -> [a]

null :: AnonymousLAngle a -> Bool

length :: AnonymousLAngle a -> Int

elem :: Eq a => a -> AnonymousLAngle a -> Bool

maximum :: Ord a => AnonymousLAngle a -> a

minimum :: Ord a => AnonymousLAngle a -> a

sum :: Num a => AnonymousLAngle a -> a

product :: Num a => AnonymousLAngle a -> a

Traversable AnonymousLAngle

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousLAngle a -> f (AnonymousLAngle b)

sequenceA :: Applicative f => AnonymousLAngle (f a) -> f (AnonymousLAngle a)

mapM :: Monad m => (a -> m b) -> AnonymousLAngle a -> m (AnonymousLAngle b)

sequence :: Monad m => AnonymousLAngle (m a) -> m (AnonymousLAngle a)

SymbolMatching AnonymousLAngle

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousLAngle -> Node -> Bool

showFailure :: Proxy AnonymousLAngle -> Node -> String

Unmarshal AnonymousLAngle

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousLAngle a)

Eq a => Eq (AnonymousLAngle a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousLAngle a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousLAngle a -> AnonymousLAngle a -> Ordering

(<) :: AnonymousLAngle a -> AnonymousLAngle a -> Bool

(<=) :: AnonymousLAngle a -> AnonymousLAngle a -> Bool

(>) :: AnonymousLAngle a -> AnonymousLAngle a -> Bool

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

max :: AnonymousLAngle a -> AnonymousLAngle a -> AnonymousLAngle a

min :: AnonymousLAngle a -> AnonymousLAngle a -> AnonymousLAngle a

Show a => Show (AnonymousLAngle a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousLAngle a -> ShowS

show :: AnonymousLAngle a -> String

showList :: [AnonymousLAngle a] -> ShowS

Generic (AnonymousLAngle a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousLAngle a) :: Type -> Type

Methods

from :: AnonymousLAngle a -> Rep (AnonymousLAngle a) x

to :: Rep (AnonymousLAngle a) x -> AnonymousLAngle a

Generic1 AnonymousLAngle

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousLAngle :: k -> Type

Methods

from1 :: AnonymousLAngle a -> Rep1 AnonymousLAngle a

to1 :: Rep1 AnonymousLAngle a -> AnonymousLAngle a

type Rep (AnonymousLAngle a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousLAngle a) = D1 (MetaData "AnonymousLAngle" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousLAngle" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousLAngle

Defined in TreeSitter.Python.AST

type Rep1 AnonymousLAngle = D1 (MetaData "AnonymousLAngle" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousLAngle" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousLAngleEqual a

Constructors

AnonymousLAngleEqual

Fields

• ann :: a

Instances

Functor AnonymousLAngleEqual

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousLAngleEqual

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousLAngleEqual m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousLAngleEqual a -> m

foldr :: (a -> b -> b) -> b -> AnonymousLAngleEqual a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousLAngleEqual a -> b

foldl :: (b -> a -> b) -> b -> AnonymousLAngleEqual a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousLAngleEqual a -> b

foldr1 :: (a -> a -> a) -> AnonymousLAngleEqual a -> a

foldl1 :: (a -> a -> a) -> AnonymousLAngleEqual a -> a

toList :: AnonymousLAngleEqual a -> [a]

null :: AnonymousLAngleEqual a -> Bool

length :: AnonymousLAngleEqual a -> Int

elem :: Eq a => a -> AnonymousLAngleEqual a -> Bool

maximum :: Ord a => AnonymousLAngleEqual a -> a

minimum :: Ord a => AnonymousLAngleEqual a -> a

sum :: Num a => AnonymousLAngleEqual a -> a

product :: Num a => AnonymousLAngleEqual a -> a

Traversable AnonymousLAngleEqual

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousLAngleEqual a -> f (AnonymousLAngleEqual b)

sequenceA :: Applicative f => AnonymousLAngleEqual (f a) -> f (AnonymousLAngleEqual a)

mapM :: Monad m => (a -> m b) -> AnonymousLAngleEqual a -> m (AnonymousLAngleEqual b)

sequence :: Monad m => AnonymousLAngleEqual (m a) -> m (AnonymousLAngleEqual a)

SymbolMatching AnonymousLAngleEqual

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousLAngleEqual -> Node -> Bool

showFailure :: Proxy AnonymousLAngleEqual -> Node -> String

Unmarshal AnonymousLAngleEqual

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousLAngleEqual a)

Eq a => Eq (AnonymousLAngleEqual a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousLAngleEqual a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousLAngleEqual a -> AnonymousLAngleEqual a -> Ordering

(<) :: AnonymousLAngleEqual a -> AnonymousLAngleEqual a -> Bool

(<=) :: AnonymousLAngleEqual a -> AnonymousLAngleEqual a -> Bool

(>) :: AnonymousLAngleEqual a -> AnonymousLAngleEqual a -> Bool

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

max :: AnonymousLAngleEqual a -> AnonymousLAngleEqual a -> AnonymousLAngleEqual a

min :: AnonymousLAngleEqual a -> AnonymousLAngleEqual a -> AnonymousLAngleEqual a

Show a => Show (AnonymousLAngleEqual a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousLAngleEqual a -> ShowS

show :: AnonymousLAngleEqual a -> String

showList :: [AnonymousLAngleEqual a] -> ShowS

Generic (AnonymousLAngleEqual a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousLAngleEqual a) :: Type -> Type

Methods

from :: AnonymousLAngleEqual a -> Rep (AnonymousLAngleEqual a) x

to :: Rep (AnonymousLAngleEqual a) x -> AnonymousLAngleEqual a

Generic1 AnonymousLAngleEqual

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousLAngleEqual :: k -> Type

Methods

from1 :: AnonymousLAngleEqual a -> Rep1 AnonymousLAngleEqual a

to1 :: Rep1 AnonymousLAngleEqual a -> AnonymousLAngleEqual a

type Rep (AnonymousLAngleEqual a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousLAngleEqual a) = D1 (MetaData "AnonymousLAngleEqual" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousLAngleEqual" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousLAngleEqual

Defined in TreeSitter.Python.AST

type Rep1 AnonymousLAngleEqual = D1 (MetaData "AnonymousLAngleEqual" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousLAngleEqual" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousEqualEqual a

Constructors

AnonymousEqualEqual

Fields

• ann :: a

Instances

Functor AnonymousEqualEqual

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousEqualEqual

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousEqualEqual m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousEqualEqual a -> m

foldr :: (a -> b -> b) -> b -> AnonymousEqualEqual a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousEqualEqual a -> b

foldl :: (b -> a -> b) -> b -> AnonymousEqualEqual a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousEqualEqual a -> b

foldr1 :: (a -> a -> a) -> AnonymousEqualEqual a -> a

foldl1 :: (a -> a -> a) -> AnonymousEqualEqual a -> a

toList :: AnonymousEqualEqual a -> [a]

null :: AnonymousEqualEqual a -> Bool

length :: AnonymousEqualEqual a -> Int

elem :: Eq a => a -> AnonymousEqualEqual a -> Bool

maximum :: Ord a => AnonymousEqualEqual a -> a

minimum :: Ord a => AnonymousEqualEqual a -> a

sum :: Num a => AnonymousEqualEqual a -> a

product :: Num a => AnonymousEqualEqual a -> a

Traversable AnonymousEqualEqual

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousEqualEqual a -> f (AnonymousEqualEqual b)

sequenceA :: Applicative f => AnonymousEqualEqual (f a) -> f (AnonymousEqualEqual a)

mapM :: Monad m => (a -> m b) -> AnonymousEqualEqual a -> m (AnonymousEqualEqual b)

sequence :: Monad m => AnonymousEqualEqual (m a) -> m (AnonymousEqualEqual a)

SymbolMatching AnonymousEqualEqual

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousEqualEqual -> Node -> Bool

showFailure :: Proxy AnonymousEqualEqual -> Node -> String

Unmarshal AnonymousEqualEqual

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousEqualEqual a)

Eq a => Eq (AnonymousEqualEqual a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousEqualEqual a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousEqualEqual a -> AnonymousEqualEqual a -> Ordering

(<) :: AnonymousEqualEqual a -> AnonymousEqualEqual a -> Bool

(<=) :: AnonymousEqualEqual a -> AnonymousEqualEqual a -> Bool

(>) :: AnonymousEqualEqual a -> AnonymousEqualEqual a -> Bool

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

max :: AnonymousEqualEqual a -> AnonymousEqualEqual a -> AnonymousEqualEqual a

min :: AnonymousEqualEqual a -> AnonymousEqualEqual a -> AnonymousEqualEqual a

Show a => Show (AnonymousEqualEqual a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousEqualEqual a -> ShowS

show :: AnonymousEqualEqual a -> String

showList :: [AnonymousEqualEqual a] -> ShowS

Generic (AnonymousEqualEqual a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousEqualEqual a) :: Type -> Type

Methods

from :: AnonymousEqualEqual a -> Rep (AnonymousEqualEqual a) x

to :: Rep (AnonymousEqualEqual a) x -> AnonymousEqualEqual a

Generic1 AnonymousEqualEqual

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousEqualEqual :: k -> Type

Methods

from1 :: AnonymousEqualEqual a -> Rep1 AnonymousEqualEqual a

to1 :: Rep1 AnonymousEqualEqual a -> AnonymousEqualEqual a

type Rep (AnonymousEqualEqual a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousEqualEqual a) = D1 (MetaData "AnonymousEqualEqual" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousEqualEqual" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousEqualEqual

Defined in TreeSitter.Python.AST

type Rep1 AnonymousEqualEqual = D1 (MetaData "AnonymousEqualEqual" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousEqualEqual" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousBangEqual a

Constructors

AnonymousBangEqual

Fields

• ann :: a

Instances

Functor AnonymousBangEqual

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousBangEqual

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousBangEqual m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousBangEqual a -> m

foldr :: (a -> b -> b) -> b -> AnonymousBangEqual a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousBangEqual a -> b

foldl :: (b -> a -> b) -> b -> AnonymousBangEqual a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousBangEqual a -> b

foldr1 :: (a -> a -> a) -> AnonymousBangEqual a -> a

foldl1 :: (a -> a -> a) -> AnonymousBangEqual a -> a

toList :: AnonymousBangEqual a -> [a]

null :: AnonymousBangEqual a -> Bool

length :: AnonymousBangEqual a -> Int

elem :: Eq a => a -> AnonymousBangEqual a -> Bool

maximum :: Ord a => AnonymousBangEqual a -> a

minimum :: Ord a => AnonymousBangEqual a -> a

sum :: Num a => AnonymousBangEqual a -> a

product :: Num a => AnonymousBangEqual a -> a

Traversable AnonymousBangEqual

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousBangEqual a -> f (AnonymousBangEqual b)

sequenceA :: Applicative f => AnonymousBangEqual (f a) -> f (AnonymousBangEqual a)

mapM :: Monad m => (a -> m b) -> AnonymousBangEqual a -> m (AnonymousBangEqual b)

sequence :: Monad m => AnonymousBangEqual (m a) -> m (AnonymousBangEqual a)

SymbolMatching AnonymousBangEqual

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousBangEqual -> Node -> Bool

showFailure :: Proxy AnonymousBangEqual -> Node -> String

Unmarshal AnonymousBangEqual

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousBangEqual a)

Eq a => Eq (AnonymousBangEqual a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousBangEqual a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousBangEqual a -> AnonymousBangEqual a -> Ordering

(<) :: AnonymousBangEqual a -> AnonymousBangEqual a -> Bool

(<=) :: AnonymousBangEqual a -> AnonymousBangEqual a -> Bool

(>) :: AnonymousBangEqual a -> AnonymousBangEqual a -> Bool

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

max :: AnonymousBangEqual a -> AnonymousBangEqual a -> AnonymousBangEqual a

min :: AnonymousBangEqual a -> AnonymousBangEqual a -> AnonymousBangEqual a

Show a => Show (AnonymousBangEqual a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousBangEqual a -> ShowS

show :: AnonymousBangEqual a -> String

showList :: [AnonymousBangEqual a] -> ShowS

Generic (AnonymousBangEqual a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousBangEqual a) :: Type -> Type

Methods

from :: AnonymousBangEqual a -> Rep (AnonymousBangEqual a) x

to :: Rep (AnonymousBangEqual a) x -> AnonymousBangEqual a

Generic1 AnonymousBangEqual

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousBangEqual :: k -> Type

Methods

from1 :: AnonymousBangEqual a -> Rep1 AnonymousBangEqual a

to1 :: Rep1 AnonymousBangEqual a -> AnonymousBangEqual a

type Rep (AnonymousBangEqual a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousBangEqual a) = D1 (MetaData "AnonymousBangEqual" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousBangEqual" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousBangEqual

Defined in TreeSitter.Python.AST

type Rep1 AnonymousBangEqual = D1 (MetaData "AnonymousBangEqual" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousBangEqual" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousRAngleEqual a

Constructors

AnonymousRAngleEqual

Fields

• ann :: a

Instances

Functor AnonymousRAngleEqual

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousRAngleEqual

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousRAngleEqual m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousRAngleEqual a -> m

foldr :: (a -> b -> b) -> b -> AnonymousRAngleEqual a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousRAngleEqual a -> b

foldl :: (b -> a -> b) -> b -> AnonymousRAngleEqual a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousRAngleEqual a -> b

foldr1 :: (a -> a -> a) -> AnonymousRAngleEqual a -> a

foldl1 :: (a -> a -> a) -> AnonymousRAngleEqual a -> a

toList :: AnonymousRAngleEqual a -> [a]

null :: AnonymousRAngleEqual a -> Bool

length :: AnonymousRAngleEqual a -> Int

elem :: Eq a => a -> AnonymousRAngleEqual a -> Bool

maximum :: Ord a => AnonymousRAngleEqual a -> a

minimum :: Ord a => AnonymousRAngleEqual a -> a

sum :: Num a => AnonymousRAngleEqual a -> a

product :: Num a => AnonymousRAngleEqual a -> a

Traversable AnonymousRAngleEqual

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousRAngleEqual a -> f (AnonymousRAngleEqual b)

sequenceA :: Applicative f => AnonymousRAngleEqual (f a) -> f (AnonymousRAngleEqual a)

mapM :: Monad m => (a -> m b) -> AnonymousRAngleEqual a -> m (AnonymousRAngleEqual b)

sequence :: Monad m => AnonymousRAngleEqual (m a) -> m (AnonymousRAngleEqual a)

SymbolMatching AnonymousRAngleEqual

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousRAngleEqual -> Node -> Bool

showFailure :: Proxy AnonymousRAngleEqual -> Node -> String

Unmarshal AnonymousRAngleEqual

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousRAngleEqual a)

Eq a => Eq (AnonymousRAngleEqual a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousRAngleEqual a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousRAngleEqual a -> AnonymousRAngleEqual a -> Ordering

(<) :: AnonymousRAngleEqual a -> AnonymousRAngleEqual a -> Bool

(<=) :: AnonymousRAngleEqual a -> AnonymousRAngleEqual a -> Bool

(>) :: AnonymousRAngleEqual a -> AnonymousRAngleEqual a -> Bool

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

max :: AnonymousRAngleEqual a -> AnonymousRAngleEqual a -> AnonymousRAngleEqual a

min :: AnonymousRAngleEqual a -> AnonymousRAngleEqual a -> AnonymousRAngleEqual a

Show a => Show (AnonymousRAngleEqual a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousRAngleEqual a -> ShowS

show :: AnonymousRAngleEqual a -> String

showList :: [AnonymousRAngleEqual a] -> ShowS

Generic (AnonymousRAngleEqual a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousRAngleEqual a) :: Type -> Type

Methods

from :: AnonymousRAngleEqual a -> Rep (AnonymousRAngleEqual a) x

to :: Rep (AnonymousRAngleEqual a) x -> AnonymousRAngleEqual a

Generic1 AnonymousRAngleEqual

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousRAngleEqual :: k -> Type

Methods

from1 :: AnonymousRAngleEqual a -> Rep1 AnonymousRAngleEqual a

to1 :: Rep1 AnonymousRAngleEqual a -> AnonymousRAngleEqual a

type Rep (AnonymousRAngleEqual a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousRAngleEqual a) = D1 (MetaData "AnonymousRAngleEqual" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousRAngleEqual" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousRAngleEqual

Defined in TreeSitter.Python.AST

type Rep1 AnonymousRAngleEqual = D1 (MetaData "AnonymousRAngleEqual" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousRAngleEqual" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousRAngle a

Constructors

AnonymousRAngle

Fields

• ann :: a

Instances

Functor AnonymousRAngle

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousRAngle

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousRAngle m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousRAngle a -> m

foldr :: (a -> b -> b) -> b -> AnonymousRAngle a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousRAngle a -> b

foldl :: (b -> a -> b) -> b -> AnonymousRAngle a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousRAngle a -> b

foldr1 :: (a -> a -> a) -> AnonymousRAngle a -> a

foldl1 :: (a -> a -> a) -> AnonymousRAngle a -> a

toList :: AnonymousRAngle a -> [a]

null :: AnonymousRAngle a -> Bool

length :: AnonymousRAngle a -> Int

elem :: Eq a => a -> AnonymousRAngle a -> Bool

maximum :: Ord a => AnonymousRAngle a -> a

minimum :: Ord a => AnonymousRAngle a -> a

sum :: Num a => AnonymousRAngle a -> a

product :: Num a => AnonymousRAngle a -> a

Traversable AnonymousRAngle

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousRAngle a -> f (AnonymousRAngle b)

sequenceA :: Applicative f => AnonymousRAngle (f a) -> f (AnonymousRAngle a)

mapM :: Monad m => (a -> m b) -> AnonymousRAngle a -> m (AnonymousRAngle b)

sequence :: Monad m => AnonymousRAngle (m a) -> m (AnonymousRAngle a)

SymbolMatching AnonymousRAngle

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousRAngle -> Node -> Bool

showFailure :: Proxy AnonymousRAngle -> Node -> String

Unmarshal AnonymousRAngle

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousRAngle a)

Eq a => Eq (AnonymousRAngle a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousRAngle a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousRAngle a -> AnonymousRAngle a -> Ordering

(<) :: AnonymousRAngle a -> AnonymousRAngle a -> Bool

(<=) :: AnonymousRAngle a -> AnonymousRAngle a -> Bool

(>) :: AnonymousRAngle a -> AnonymousRAngle a -> Bool

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

max :: AnonymousRAngle a -> AnonymousRAngle a -> AnonymousRAngle a

min :: AnonymousRAngle a -> AnonymousRAngle a -> AnonymousRAngle a

Show a => Show (AnonymousRAngle a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousRAngle a -> ShowS

show :: AnonymousRAngle a -> String

showList :: [AnonymousRAngle a] -> ShowS

Generic (AnonymousRAngle a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousRAngle a) :: Type -> Type

Methods

from :: AnonymousRAngle a -> Rep (AnonymousRAngle a) x

to :: Rep (AnonymousRAngle a) x -> AnonymousRAngle a

Generic1 AnonymousRAngle

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousRAngle :: k -> Type

Methods

from1 :: AnonymousRAngle a -> Rep1 AnonymousRAngle a

to1 :: Rep1 AnonymousRAngle a -> AnonymousRAngle a

type Rep (AnonymousRAngle a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousRAngle a) = D1 (MetaData "AnonymousRAngle" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousRAngle" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousRAngle

Defined in TreeSitter.Python.AST

type Rep1 AnonymousRAngle = D1 (MetaData "AnonymousRAngle" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousRAngle" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousLAngleRAngle a

Constructors

AnonymousLAngleRAngle

Fields

• ann :: a

Instances

Functor AnonymousLAngleRAngle

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousLAngleRAngle

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousLAngleRAngle m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousLAngleRAngle a -> m

foldr :: (a -> b -> b) -> b -> AnonymousLAngleRAngle a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousLAngleRAngle a -> b

foldl :: (b -> a -> b) -> b -> AnonymousLAngleRAngle a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousLAngleRAngle a -> b

foldr1 :: (a -> a -> a) -> AnonymousLAngleRAngle a -> a

foldl1 :: (a -> a -> a) -> AnonymousLAngleRAngle a -> a

toList :: AnonymousLAngleRAngle a -> [a]

null :: AnonymousLAngleRAngle a -> Bool

length :: AnonymousLAngleRAngle a -> Int

elem :: Eq a => a -> AnonymousLAngleRAngle a -> Bool

maximum :: Ord a => AnonymousLAngleRAngle a -> a

minimum :: Ord a => AnonymousLAngleRAngle a -> a

sum :: Num a => AnonymousLAngleRAngle a -> a

product :: Num a => AnonymousLAngleRAngle a -> a

Traversable AnonymousLAngleRAngle

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousLAngleRAngle a -> f (AnonymousLAngleRAngle b)

sequenceA :: Applicative f => AnonymousLAngleRAngle (f a) -> f (AnonymousLAngleRAngle a)

mapM :: Monad m => (a -> m b) -> AnonymousLAngleRAngle a -> m (AnonymousLAngleRAngle b)

sequence :: Monad m => AnonymousLAngleRAngle (m a) -> m (AnonymousLAngleRAngle a)

SymbolMatching AnonymousLAngleRAngle

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousLAngleRAngle -> Node -> Bool

showFailure :: Proxy AnonymousLAngleRAngle -> Node -> String

Unmarshal AnonymousLAngleRAngle

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousLAngleRAngle a)

Eq a => Eq (AnonymousLAngleRAngle a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousLAngleRAngle a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousLAngleRAngle a -> AnonymousLAngleRAngle a -> Ordering

(<) :: AnonymousLAngleRAngle a -> AnonymousLAngleRAngle a -> Bool

(<=) :: AnonymousLAngleRAngle a -> AnonymousLAngleRAngle a -> Bool

(>) :: AnonymousLAngleRAngle a -> AnonymousLAngleRAngle a -> Bool

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

max :: AnonymousLAngleRAngle a -> AnonymousLAngleRAngle a -> AnonymousLAngleRAngle a

min :: AnonymousLAngleRAngle a -> AnonymousLAngleRAngle a -> AnonymousLAngleRAngle a

Show a => Show (AnonymousLAngleRAngle a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousLAngleRAngle a -> ShowS

show :: AnonymousLAngleRAngle a -> String

showList :: [AnonymousLAngleRAngle a] -> ShowS

Generic (AnonymousLAngleRAngle a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousLAngleRAngle a) :: Type -> Type

Methods

from :: AnonymousLAngleRAngle a -> Rep (AnonymousLAngleRAngle a) x

to :: Rep (AnonymousLAngleRAngle a) x -> AnonymousLAngleRAngle a

Generic1 AnonymousLAngleRAngle

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousLAngleRAngle :: k -> Type

Methods

from1 :: AnonymousLAngleRAngle a -> Rep1 AnonymousLAngleRAngle a

to1 :: Rep1 AnonymousLAngleRAngle a -> AnonymousLAngleRAngle a

type Rep (AnonymousLAngleRAngle a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousLAngleRAngle a) = D1 (MetaData "AnonymousLAngleRAngle" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousLAngleRAngle" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousLAngleRAngle

Defined in TreeSitter.Python.AST

type Rep1 AnonymousLAngleRAngle = D1 (MetaData "AnonymousLAngleRAngle" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousLAngleRAngle" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousIs a

Constructors

AnonymousIs

Fields

• ann :: a

Instances

Functor AnonymousIs

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousIs

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousIs m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousIs a -> m

foldr :: (a -> b -> b) -> b -> AnonymousIs a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousIs a -> b

foldl :: (b -> a -> b) -> b -> AnonymousIs a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousIs a -> b

foldr1 :: (a -> a -> a) -> AnonymousIs a -> a

foldl1 :: (a -> a -> a) -> AnonymousIs a -> a

toList :: AnonymousIs a -> [a]

null :: AnonymousIs a -> Bool

length :: AnonymousIs a -> Int

elem :: Eq a => a -> AnonymousIs a -> Bool

maximum :: Ord a => AnonymousIs a -> a

minimum :: Ord a => AnonymousIs a -> a

sum :: Num a => AnonymousIs a -> a

product :: Num a => AnonymousIs a -> a

Traversable AnonymousIs

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousIs a -> f (AnonymousIs b)

sequenceA :: Applicative f => AnonymousIs (f a) -> f (AnonymousIs a)

mapM :: Monad m => (a -> m b) -> AnonymousIs a -> m (AnonymousIs b)

sequence :: Monad m => AnonymousIs (m a) -> m (AnonymousIs a)

SymbolMatching AnonymousIs

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousIs -> Node -> Bool

showFailure :: Proxy AnonymousIs -> Node -> String

Unmarshal AnonymousIs

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousIs a)

Eq a => Eq (AnonymousIs a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousIs a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousIs a -> AnonymousIs a -> Ordering

(<) :: AnonymousIs a -> AnonymousIs a -> Bool

(<=) :: AnonymousIs a -> AnonymousIs a -> Bool

(>) :: AnonymousIs a -> AnonymousIs a -> Bool

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

max :: AnonymousIs a -> AnonymousIs a -> AnonymousIs a

min :: AnonymousIs a -> AnonymousIs a -> AnonymousIs a

Show a => Show (AnonymousIs a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousIs a -> ShowS

show :: AnonymousIs a -> String

showList :: [AnonymousIs a] -> ShowS

Generic (AnonymousIs a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousIs a) :: Type -> Type

Methods

from :: AnonymousIs a -> Rep (AnonymousIs a) x

to :: Rep (AnonymousIs a) x -> AnonymousIs a

Generic1 AnonymousIs

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousIs :: k -> Type

Methods

from1 :: AnonymousIs a -> Rep1 AnonymousIs a

to1 :: Rep1 AnonymousIs a -> AnonymousIs a

type Rep (AnonymousIs a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousIs a) = D1 (MetaData "AnonymousIs" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousIs" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousIs

Defined in TreeSitter.Python.AST

type Rep1 AnonymousIs = D1 (MetaData "AnonymousIs" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousIs" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousLambda a

Constructors

AnonymousLambda

Fields

• ann :: a

Instances

Functor AnonymousLambda

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousLambda

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousLambda m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousLambda a -> m

foldr :: (a -> b -> b) -> b -> AnonymousLambda a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousLambda a -> b

foldl :: (b -> a -> b) -> b -> AnonymousLambda a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousLambda a -> b

foldr1 :: (a -> a -> a) -> AnonymousLambda a -> a

foldl1 :: (a -> a -> a) -> AnonymousLambda a -> a

toList :: AnonymousLambda a -> [a]

null :: AnonymousLambda a -> Bool

length :: AnonymousLambda a -> Int

elem :: Eq a => a -> AnonymousLambda a -> Bool

maximum :: Ord a => AnonymousLambda a -> a

minimum :: Ord a => AnonymousLambda a -> a

sum :: Num a => AnonymousLambda a -> a

product :: Num a => AnonymousLambda a -> a

Traversable AnonymousLambda

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousLambda a -> f (AnonymousLambda b)

sequenceA :: Applicative f => AnonymousLambda (f a) -> f (AnonymousLambda a)

mapM :: Monad m => (a -> m b) -> AnonymousLambda a -> m (AnonymousLambda b)

sequence :: Monad m => AnonymousLambda (m a) -> m (AnonymousLambda a)

SymbolMatching AnonymousLambda

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousLambda -> Node -> Bool

showFailure :: Proxy AnonymousLambda -> Node -> String

Unmarshal AnonymousLambda

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousLambda a)

Eq a => Eq (AnonymousLambda a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousLambda a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousLambda a -> AnonymousLambda a -> Ordering

(<) :: AnonymousLambda a -> AnonymousLambda a -> Bool

(<=) :: AnonymousLambda a -> AnonymousLambda a -> Bool

(>) :: AnonymousLambda a -> AnonymousLambda a -> Bool

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

max :: AnonymousLambda a -> AnonymousLambda a -> AnonymousLambda a

min :: AnonymousLambda a -> AnonymousLambda a -> AnonymousLambda a

Show a => Show (AnonymousLambda a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousLambda a -> ShowS

show :: AnonymousLambda a -> String

showList :: [AnonymousLambda a] -> ShowS

Generic (AnonymousLambda a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousLambda a) :: Type -> Type

Methods

from :: AnonymousLambda a -> Rep (AnonymousLambda a) x

to :: Rep (AnonymousLambda a) x -> AnonymousLambda a

Generic1 AnonymousLambda

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousLambda :: k -> Type

Methods

from1 :: AnonymousLambda a -> Rep1 AnonymousLambda a

to1 :: Rep1 AnonymousLambda a -> AnonymousLambda a

type Rep (AnonymousLambda a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousLambda a) = D1 (MetaData "AnonymousLambda" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousLambda" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousLambda

Defined in TreeSitter.Python.AST

type Rep1 AnonymousLambda = D1 (MetaData "AnonymousLambda" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousLambda" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousPlusEqual a

Constructors

AnonymousPlusEqual

Fields

• ann :: a

Instances

Functor AnonymousPlusEqual

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousPlusEqual

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousPlusEqual m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousPlusEqual a -> m

foldr :: (a -> b -> b) -> b -> AnonymousPlusEqual a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousPlusEqual a -> b

foldl :: (b -> a -> b) -> b -> AnonymousPlusEqual a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousPlusEqual a -> b

foldr1 :: (a -> a -> a) -> AnonymousPlusEqual a -> a

foldl1 :: (a -> a -> a) -> AnonymousPlusEqual a -> a

toList :: AnonymousPlusEqual a -> [a]

null :: AnonymousPlusEqual a -> Bool

length :: AnonymousPlusEqual a -> Int

elem :: Eq a => a -> AnonymousPlusEqual a -> Bool

maximum :: Ord a => AnonymousPlusEqual a -> a

minimum :: Ord a => AnonymousPlusEqual a -> a

sum :: Num a => AnonymousPlusEqual a -> a

product :: Num a => AnonymousPlusEqual a -> a

Traversable AnonymousPlusEqual

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousPlusEqual a -> f (AnonymousPlusEqual b)

sequenceA :: Applicative f => AnonymousPlusEqual (f a) -> f (AnonymousPlusEqual a)

mapM :: Monad m => (a -> m b) -> AnonymousPlusEqual a -> m (AnonymousPlusEqual b)

sequence :: Monad m => AnonymousPlusEqual (m a) -> m (AnonymousPlusEqual a)

SymbolMatching AnonymousPlusEqual

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousPlusEqual -> Node -> Bool

showFailure :: Proxy AnonymousPlusEqual -> Node -> String

Unmarshal AnonymousPlusEqual

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousPlusEqual a)

Eq a => Eq (AnonymousPlusEqual a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousPlusEqual a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousPlusEqual a -> AnonymousPlusEqual a -> Ordering

(<) :: AnonymousPlusEqual a -> AnonymousPlusEqual a -> Bool

(<=) :: AnonymousPlusEqual a -> AnonymousPlusEqual a -> Bool

(>) :: AnonymousPlusEqual a -> AnonymousPlusEqual a -> Bool

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

max :: AnonymousPlusEqual a -> AnonymousPlusEqual a -> AnonymousPlusEqual a

min :: AnonymousPlusEqual a -> AnonymousPlusEqual a -> AnonymousPlusEqual a

Show a => Show (AnonymousPlusEqual a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousPlusEqual a -> ShowS

show :: AnonymousPlusEqual a -> String

showList :: [AnonymousPlusEqual a] -> ShowS

Generic (AnonymousPlusEqual a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousPlusEqual a) :: Type -> Type

Methods

from :: AnonymousPlusEqual a -> Rep (AnonymousPlusEqual a) x

to :: Rep (AnonymousPlusEqual a) x -> AnonymousPlusEqual a

Generic1 AnonymousPlusEqual

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousPlusEqual :: k -> Type

Methods

from1 :: AnonymousPlusEqual a -> Rep1 AnonymousPlusEqual a

to1 :: Rep1 AnonymousPlusEqual a -> AnonymousPlusEqual a

type Rep (AnonymousPlusEqual a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousPlusEqual a) = D1 (MetaData "AnonymousPlusEqual" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousPlusEqual" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousPlusEqual

Defined in TreeSitter.Python.AST

type Rep1 AnonymousPlusEqual = D1 (MetaData "AnonymousPlusEqual" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousPlusEqual" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousMinusEqual a

Constructors

AnonymousMinusEqual

Fields

• ann :: a

Instances

Functor AnonymousMinusEqual

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousMinusEqual

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousMinusEqual m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousMinusEqual a -> m

foldr :: (a -> b -> b) -> b -> AnonymousMinusEqual a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousMinusEqual a -> b

foldl :: (b -> a -> b) -> b -> AnonymousMinusEqual a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousMinusEqual a -> b

foldr1 :: (a -> a -> a) -> AnonymousMinusEqual a -> a

foldl1 :: (a -> a -> a) -> AnonymousMinusEqual a -> a

toList :: AnonymousMinusEqual a -> [a]

null :: AnonymousMinusEqual a -> Bool

length :: AnonymousMinusEqual a -> Int

elem :: Eq a => a -> AnonymousMinusEqual a -> Bool

maximum :: Ord a => AnonymousMinusEqual a -> a

minimum :: Ord a => AnonymousMinusEqual a -> a

sum :: Num a => AnonymousMinusEqual a -> a

product :: Num a => AnonymousMinusEqual a -> a

Traversable AnonymousMinusEqual

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousMinusEqual a -> f (AnonymousMinusEqual b)

sequenceA :: Applicative f => AnonymousMinusEqual (f a) -> f (AnonymousMinusEqual a)

mapM :: Monad m => (a -> m b) -> AnonymousMinusEqual a -> m (AnonymousMinusEqual b)

sequence :: Monad m => AnonymousMinusEqual (m a) -> m (AnonymousMinusEqual a)

SymbolMatching AnonymousMinusEqual

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousMinusEqual -> Node -> Bool

showFailure :: Proxy AnonymousMinusEqual -> Node -> String

Unmarshal AnonymousMinusEqual

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousMinusEqual a)

Eq a => Eq (AnonymousMinusEqual a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousMinusEqual a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousMinusEqual a -> AnonymousMinusEqual a -> Ordering

(<) :: AnonymousMinusEqual a -> AnonymousMinusEqual a -> Bool

(<=) :: AnonymousMinusEqual a -> AnonymousMinusEqual a -> Bool

(>) :: AnonymousMinusEqual a -> AnonymousMinusEqual a -> Bool

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

max :: AnonymousMinusEqual a -> AnonymousMinusEqual a -> AnonymousMinusEqual a

min :: AnonymousMinusEqual a -> AnonymousMinusEqual a -> AnonymousMinusEqual a

Show a => Show (AnonymousMinusEqual a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousMinusEqual a -> ShowS

show :: AnonymousMinusEqual a -> String

showList :: [AnonymousMinusEqual a] -> ShowS

Generic (AnonymousMinusEqual a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousMinusEqual a) :: Type -> Type

Methods

from :: AnonymousMinusEqual a -> Rep (AnonymousMinusEqual a) x

to :: Rep (AnonymousMinusEqual a) x -> AnonymousMinusEqual a

Generic1 AnonymousMinusEqual

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousMinusEqual :: k -> Type

Methods

from1 :: AnonymousMinusEqual a -> Rep1 AnonymousMinusEqual a

to1 :: Rep1 AnonymousMinusEqual a -> AnonymousMinusEqual a

type Rep (AnonymousMinusEqual a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousMinusEqual a) = D1 (MetaData "AnonymousMinusEqual" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousMinusEqual" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousMinusEqual

Defined in TreeSitter.Python.AST

type Rep1 AnonymousMinusEqual = D1 (MetaData "AnonymousMinusEqual" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousMinusEqual" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousStarEqual a

Constructors

AnonymousStarEqual

Fields

• ann :: a

Instances

Functor AnonymousStarEqual

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousStarEqual

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousStarEqual m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousStarEqual a -> m

foldr :: (a -> b -> b) -> b -> AnonymousStarEqual a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousStarEqual a -> b

foldl :: (b -> a -> b) -> b -> AnonymousStarEqual a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousStarEqual a -> b

foldr1 :: (a -> a -> a) -> AnonymousStarEqual a -> a

foldl1 :: (a -> a -> a) -> AnonymousStarEqual a -> a

toList :: AnonymousStarEqual a -> [a]

null :: AnonymousStarEqual a -> Bool

length :: AnonymousStarEqual a -> Int

elem :: Eq a => a -> AnonymousStarEqual a -> Bool

maximum :: Ord a => AnonymousStarEqual a -> a

minimum :: Ord a => AnonymousStarEqual a -> a

sum :: Num a => AnonymousStarEqual a -> a

product :: Num a => AnonymousStarEqual a -> a

Traversable AnonymousStarEqual

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousStarEqual a -> f (AnonymousStarEqual b)

sequenceA :: Applicative f => AnonymousStarEqual (f a) -> f (AnonymousStarEqual a)

mapM :: Monad m => (a -> m b) -> AnonymousStarEqual a -> m (AnonymousStarEqual b)

sequence :: Monad m => AnonymousStarEqual (m a) -> m (AnonymousStarEqual a)

SymbolMatching AnonymousStarEqual

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousStarEqual -> Node -> Bool

showFailure :: Proxy AnonymousStarEqual -> Node -> String

Unmarshal AnonymousStarEqual

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousStarEqual a)

Eq a => Eq (AnonymousStarEqual a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousStarEqual a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousStarEqual a -> AnonymousStarEqual a -> Ordering

(<) :: AnonymousStarEqual a -> AnonymousStarEqual a -> Bool

(<=) :: AnonymousStarEqual a -> AnonymousStarEqual a -> Bool

(>) :: AnonymousStarEqual a -> AnonymousStarEqual a -> Bool

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

max :: AnonymousStarEqual a -> AnonymousStarEqual a -> AnonymousStarEqual a

min :: AnonymousStarEqual a -> AnonymousStarEqual a -> AnonymousStarEqual a

Show a => Show (AnonymousStarEqual a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousStarEqual a -> ShowS

show :: AnonymousStarEqual a -> String

showList :: [AnonymousStarEqual a] -> ShowS

Generic (AnonymousStarEqual a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousStarEqual a) :: Type -> Type

Methods

from :: AnonymousStarEqual a -> Rep (AnonymousStarEqual a) x

to :: Rep (AnonymousStarEqual a) x -> AnonymousStarEqual a

Generic1 AnonymousStarEqual

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousStarEqual :: k -> Type

Methods

from1 :: AnonymousStarEqual a -> Rep1 AnonymousStarEqual a

to1 :: Rep1 AnonymousStarEqual a -> AnonymousStarEqual a

type Rep (AnonymousStarEqual a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousStarEqual a) = D1 (MetaData "AnonymousStarEqual" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousStarEqual" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousStarEqual

Defined in TreeSitter.Python.AST

type Rep1 AnonymousStarEqual = D1 (MetaData "AnonymousStarEqual" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousStarEqual" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousSlashEqual a

Constructors

AnonymousSlashEqual

Fields

• ann :: a

Instances

Functor AnonymousSlashEqual

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousSlashEqual

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousSlashEqual m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousSlashEqual a -> m

foldr :: (a -> b -> b) -> b -> AnonymousSlashEqual a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousSlashEqual a -> b

foldl :: (b -> a -> b) -> b -> AnonymousSlashEqual a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousSlashEqual a -> b

foldr1 :: (a -> a -> a) -> AnonymousSlashEqual a -> a

foldl1 :: (a -> a -> a) -> AnonymousSlashEqual a -> a

toList :: AnonymousSlashEqual a -> [a]

null :: AnonymousSlashEqual a -> Bool

length :: AnonymousSlashEqual a -> Int

elem :: Eq a => a -> AnonymousSlashEqual a -> Bool

maximum :: Ord a => AnonymousSlashEqual a -> a

minimum :: Ord a => AnonymousSlashEqual a -> a

sum :: Num a => AnonymousSlashEqual a -> a

product :: Num a => AnonymousSlashEqual a -> a

Traversable AnonymousSlashEqual

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousSlashEqual a -> f (AnonymousSlashEqual b)

sequenceA :: Applicative f => AnonymousSlashEqual (f a) -> f (AnonymousSlashEqual a)

mapM :: Monad m => (a -> m b) -> AnonymousSlashEqual a -> m (AnonymousSlashEqual b)

sequence :: Monad m => AnonymousSlashEqual (m a) -> m (AnonymousSlashEqual a)

SymbolMatching AnonymousSlashEqual

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousSlashEqual -> Node -> Bool

showFailure :: Proxy AnonymousSlashEqual -> Node -> String

Unmarshal AnonymousSlashEqual

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousSlashEqual a)

Eq a => Eq (AnonymousSlashEqual a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousSlashEqual a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousSlashEqual a -> AnonymousSlashEqual a -> Ordering

(<) :: AnonymousSlashEqual a -> AnonymousSlashEqual a -> Bool

(<=) :: AnonymousSlashEqual a -> AnonymousSlashEqual a -> Bool

(>) :: AnonymousSlashEqual a -> AnonymousSlashEqual a -> Bool

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

max :: AnonymousSlashEqual a -> AnonymousSlashEqual a -> AnonymousSlashEqual a

min :: AnonymousSlashEqual a -> AnonymousSlashEqual a -> AnonymousSlashEqual a

Show a => Show (AnonymousSlashEqual a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousSlashEqual a -> ShowS

show :: AnonymousSlashEqual a -> String

showList :: [AnonymousSlashEqual a] -> ShowS

Generic (AnonymousSlashEqual a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousSlashEqual a) :: Type -> Type

Methods

from :: AnonymousSlashEqual a -> Rep (AnonymousSlashEqual a) x

to :: Rep (AnonymousSlashEqual a) x -> AnonymousSlashEqual a

Generic1 AnonymousSlashEqual

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousSlashEqual :: k -> Type

Methods

from1 :: AnonymousSlashEqual a -> Rep1 AnonymousSlashEqual a

to1 :: Rep1 AnonymousSlashEqual a -> AnonymousSlashEqual a

type Rep (AnonymousSlashEqual a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousSlashEqual a) = D1 (MetaData "AnonymousSlashEqual" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousSlashEqual" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousSlashEqual

Defined in TreeSitter.Python.AST

type Rep1 AnonymousSlashEqual = D1 (MetaData "AnonymousSlashEqual" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousSlashEqual" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousAtEqual a

Constructors

AnonymousAtEqual

Fields

• ann :: a

Instances

Functor AnonymousAtEqual

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousAtEqual

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousAtEqual m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousAtEqual a -> m

foldr :: (a -> b -> b) -> b -> AnonymousAtEqual a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousAtEqual a -> b

foldl :: (b -> a -> b) -> b -> AnonymousAtEqual a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousAtEqual a -> b

foldr1 :: (a -> a -> a) -> AnonymousAtEqual a -> a

foldl1 :: (a -> a -> a) -> AnonymousAtEqual a -> a

toList :: AnonymousAtEqual a -> [a]

null :: AnonymousAtEqual a -> Bool

length :: AnonymousAtEqual a -> Int

elem :: Eq a => a -> AnonymousAtEqual a -> Bool

maximum :: Ord a => AnonymousAtEqual a -> a

minimum :: Ord a => AnonymousAtEqual a -> a

sum :: Num a => AnonymousAtEqual a -> a

product :: Num a => AnonymousAtEqual a -> a

Traversable AnonymousAtEqual

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousAtEqual a -> f (AnonymousAtEqual b)

sequenceA :: Applicative f => AnonymousAtEqual (f a) -> f (AnonymousAtEqual a)

mapM :: Monad m => (a -> m b) -> AnonymousAtEqual a -> m (AnonymousAtEqual b)

sequence :: Monad m => AnonymousAtEqual (m a) -> m (AnonymousAtEqual a)

SymbolMatching AnonymousAtEqual

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousAtEqual -> Node -> Bool

showFailure :: Proxy AnonymousAtEqual -> Node -> String

Unmarshal AnonymousAtEqual

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousAtEqual a)

Eq a => Eq (AnonymousAtEqual a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousAtEqual a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousAtEqual a -> AnonymousAtEqual a -> Ordering

(<) :: AnonymousAtEqual a -> AnonymousAtEqual a -> Bool

(<=) :: AnonymousAtEqual a -> AnonymousAtEqual a -> Bool

(>) :: AnonymousAtEqual a -> AnonymousAtEqual a -> Bool

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

max :: AnonymousAtEqual a -> AnonymousAtEqual a -> AnonymousAtEqual a

min :: AnonymousAtEqual a -> AnonymousAtEqual a -> AnonymousAtEqual a

Show a => Show (AnonymousAtEqual a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousAtEqual a -> ShowS

show :: AnonymousAtEqual a -> String

showList :: [AnonymousAtEqual a] -> ShowS

Generic (AnonymousAtEqual a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousAtEqual a) :: Type -> Type

Methods

from :: AnonymousAtEqual a -> Rep (AnonymousAtEqual a) x

to :: Rep (AnonymousAtEqual a) x -> AnonymousAtEqual a

Generic1 AnonymousAtEqual

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousAtEqual :: k -> Type

Methods

from1 :: AnonymousAtEqual a -> Rep1 AnonymousAtEqual a

to1 :: Rep1 AnonymousAtEqual a -> AnonymousAtEqual a

type Rep (AnonymousAtEqual a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousAtEqual a) = D1 (MetaData "AnonymousAtEqual" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousAtEqual" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousAtEqual

Defined in TreeSitter.Python.AST

type Rep1 AnonymousAtEqual = D1 (MetaData "AnonymousAtEqual" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousAtEqual" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousSlashSlashEqual a

Constructors

AnonymousSlashSlashEqual

Fields

• ann :: a

Instances

Functor AnonymousSlashSlashEqual

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousSlashSlashEqual

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousSlashSlashEqual m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousSlashSlashEqual a -> m

foldr :: (a -> b -> b) -> b -> AnonymousSlashSlashEqual a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousSlashSlashEqual a -> b

foldl :: (b -> a -> b) -> b -> AnonymousSlashSlashEqual a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousSlashSlashEqual a -> b

foldr1 :: (a -> a -> a) -> AnonymousSlashSlashEqual a -> a

foldl1 :: (a -> a -> a) -> AnonymousSlashSlashEqual a -> a

toList :: AnonymousSlashSlashEqual a -> [a]

null :: AnonymousSlashSlashEqual a -> Bool

length :: AnonymousSlashSlashEqual a -> Int

elem :: Eq a => a -> AnonymousSlashSlashEqual a -> Bool

maximum :: Ord a => AnonymousSlashSlashEqual a -> a

minimum :: Ord a => AnonymousSlashSlashEqual a -> a

sum :: Num a => AnonymousSlashSlashEqual a -> a

product :: Num a => AnonymousSlashSlashEqual a -> a

Traversable AnonymousSlashSlashEqual

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousSlashSlashEqual a -> f (AnonymousSlashSlashEqual b)

sequenceA :: Applicative f => AnonymousSlashSlashEqual (f a) -> f (AnonymousSlashSlashEqual a)

mapM :: Monad m => (a -> m b) -> AnonymousSlashSlashEqual a -> m (AnonymousSlashSlashEqual b)

sequence :: Monad m => AnonymousSlashSlashEqual (m a) -> m (AnonymousSlashSlashEqual a)

SymbolMatching AnonymousSlashSlashEqual

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousSlashSlashEqual -> Node -> Bool

showFailure :: Proxy AnonymousSlashSlashEqual -> Node -> String

Unmarshal AnonymousSlashSlashEqual

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousSlashSlashEqual a)

Eq a => Eq (AnonymousSlashSlashEqual a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousSlashSlashEqual a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousSlashSlashEqual a -> AnonymousSlashSlashEqual a -> Ordering

(<) :: AnonymousSlashSlashEqual a -> AnonymousSlashSlashEqual a -> Bool

(<=) :: AnonymousSlashSlashEqual a -> AnonymousSlashSlashEqual a -> Bool

(>) :: AnonymousSlashSlashEqual a -> AnonymousSlashSlashEqual a -> Bool

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

max :: AnonymousSlashSlashEqual a -> AnonymousSlashSlashEqual a -> AnonymousSlashSlashEqual a

min :: AnonymousSlashSlashEqual a -> AnonymousSlashSlashEqual a -> AnonymousSlashSlashEqual a

Show a => Show (AnonymousSlashSlashEqual a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousSlashSlashEqual a -> ShowS

show :: AnonymousSlashSlashEqual a -> String

showList :: [AnonymousSlashSlashEqual a] -> ShowS

Generic (AnonymousSlashSlashEqual a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousSlashSlashEqual a) :: Type -> Type

Methods

from :: AnonymousSlashSlashEqual a -> Rep (AnonymousSlashSlashEqual a) x

to :: Rep (AnonymousSlashSlashEqual a) x -> AnonymousSlashSlashEqual a

Generic1 AnonymousSlashSlashEqual

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousSlashSlashEqual :: k -> Type

Methods

from1 :: AnonymousSlashSlashEqual a -> Rep1 AnonymousSlashSlashEqual a

to1 :: Rep1 AnonymousSlashSlashEqual a -> AnonymousSlashSlashEqual a

type Rep (AnonymousSlashSlashEqual a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousSlashSlashEqual a) = D1 (MetaData "AnonymousSlashSlashEqual" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousSlashSlashEqual" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousSlashSlashEqual

Defined in TreeSitter.Python.AST

type Rep1 AnonymousSlashSlashEqual = D1 (MetaData "AnonymousSlashSlashEqual" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousSlashSlashEqual" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousPercentEqual a

Constructors

AnonymousPercentEqual

Fields

• ann :: a

Instances

Functor AnonymousPercentEqual

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousPercentEqual

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousPercentEqual m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousPercentEqual a -> m

foldr :: (a -> b -> b) -> b -> AnonymousPercentEqual a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousPercentEqual a -> b

foldl :: (b -> a -> b) -> b -> AnonymousPercentEqual a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousPercentEqual a -> b

foldr1 :: (a -> a -> a) -> AnonymousPercentEqual a -> a

foldl1 :: (a -> a -> a) -> AnonymousPercentEqual a -> a

toList :: AnonymousPercentEqual a -> [a]

null :: AnonymousPercentEqual a -> Bool

length :: AnonymousPercentEqual a -> Int

elem :: Eq a => a -> AnonymousPercentEqual a -> Bool

maximum :: Ord a => AnonymousPercentEqual a -> a

minimum :: Ord a => AnonymousPercentEqual a -> a

sum :: Num a => AnonymousPercentEqual a -> a

product :: Num a => AnonymousPercentEqual a -> a

Traversable AnonymousPercentEqual

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousPercentEqual a -> f (AnonymousPercentEqual b)

sequenceA :: Applicative f => AnonymousPercentEqual (f a) -> f (AnonymousPercentEqual a)

mapM :: Monad m => (a -> m b) -> AnonymousPercentEqual a -> m (AnonymousPercentEqual b)

sequence :: Monad m => AnonymousPercentEqual (m a) -> m (AnonymousPercentEqual a)

SymbolMatching AnonymousPercentEqual

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousPercentEqual -> Node -> Bool

showFailure :: Proxy AnonymousPercentEqual -> Node -> String

Unmarshal AnonymousPercentEqual

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousPercentEqual a)

Eq a => Eq (AnonymousPercentEqual a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousPercentEqual a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousPercentEqual a -> AnonymousPercentEqual a -> Ordering

(<) :: AnonymousPercentEqual a -> AnonymousPercentEqual a -> Bool

(<=) :: AnonymousPercentEqual a -> AnonymousPercentEqual a -> Bool

(>) :: AnonymousPercentEqual a -> AnonymousPercentEqual a -> Bool

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

max :: AnonymousPercentEqual a -> AnonymousPercentEqual a -> AnonymousPercentEqual a

min :: AnonymousPercentEqual a -> AnonymousPercentEqual a -> AnonymousPercentEqual a

Show a => Show (AnonymousPercentEqual a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousPercentEqual a -> ShowS

show :: AnonymousPercentEqual a -> String

showList :: [AnonymousPercentEqual a] -> ShowS

Generic (AnonymousPercentEqual a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousPercentEqual a) :: Type -> Type

Methods

from :: AnonymousPercentEqual a -> Rep (AnonymousPercentEqual a) x

to :: Rep (AnonymousPercentEqual a) x -> AnonymousPercentEqual a

Generic1 AnonymousPercentEqual

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousPercentEqual :: k -> Type

Methods

from1 :: AnonymousPercentEqual a -> Rep1 AnonymousPercentEqual a

to1 :: Rep1 AnonymousPercentEqual a -> AnonymousPercentEqual a

type Rep (AnonymousPercentEqual a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousPercentEqual a) = D1 (MetaData "AnonymousPercentEqual" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousPercentEqual" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousPercentEqual

Defined in TreeSitter.Python.AST

type Rep1 AnonymousPercentEqual = D1 (MetaData "AnonymousPercentEqual" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousPercentEqual" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousStarStarEqual a

Constructors

AnonymousStarStarEqual

Fields

• ann :: a

Instances

Functor AnonymousStarStarEqual

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousStarStarEqual

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousStarStarEqual m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousStarStarEqual a -> m

foldr :: (a -> b -> b) -> b -> AnonymousStarStarEqual a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousStarStarEqual a -> b

foldl :: (b -> a -> b) -> b -> AnonymousStarStarEqual a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousStarStarEqual a -> b

foldr1 :: (a -> a -> a) -> AnonymousStarStarEqual a -> a

foldl1 :: (a -> a -> a) -> AnonymousStarStarEqual a -> a

toList :: AnonymousStarStarEqual a -> [a]

null :: AnonymousStarStarEqual a -> Bool

length :: AnonymousStarStarEqual a -> Int

elem :: Eq a => a -> AnonymousStarStarEqual a -> Bool

maximum :: Ord a => AnonymousStarStarEqual a -> a

minimum :: Ord a => AnonymousStarStarEqual a -> a

sum :: Num a => AnonymousStarStarEqual a -> a

product :: Num a => AnonymousStarStarEqual a -> a

Traversable AnonymousStarStarEqual

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousStarStarEqual a -> f (AnonymousStarStarEqual b)

sequenceA :: Applicative f => AnonymousStarStarEqual (f a) -> f (AnonymousStarStarEqual a)

mapM :: Monad m => (a -> m b) -> AnonymousStarStarEqual a -> m (AnonymousStarStarEqual b)

sequence :: Monad m => AnonymousStarStarEqual (m a) -> m (AnonymousStarStarEqual a)

SymbolMatching AnonymousStarStarEqual

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousStarStarEqual -> Node -> Bool

showFailure :: Proxy AnonymousStarStarEqual -> Node -> String

Unmarshal AnonymousStarStarEqual

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousStarStarEqual a)

Eq a => Eq (AnonymousStarStarEqual a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousStarStarEqual a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousStarStarEqual a -> AnonymousStarStarEqual a -> Ordering

(<) :: AnonymousStarStarEqual a -> AnonymousStarStarEqual a -> Bool

(<=) :: AnonymousStarStarEqual a -> AnonymousStarStarEqual a -> Bool

(>) :: AnonymousStarStarEqual a -> AnonymousStarStarEqual a -> Bool

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

max :: AnonymousStarStarEqual a -> AnonymousStarStarEqual a -> AnonymousStarStarEqual a

min :: AnonymousStarStarEqual a -> AnonymousStarStarEqual a -> AnonymousStarStarEqual a

Show a => Show (AnonymousStarStarEqual a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousStarStarEqual a -> ShowS

show :: AnonymousStarStarEqual a -> String

showList :: [AnonymousStarStarEqual a] -> ShowS

Generic (AnonymousStarStarEqual a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousStarStarEqual a) :: Type -> Type

Methods

from :: AnonymousStarStarEqual a -> Rep (AnonymousStarStarEqual a) x

to :: Rep (AnonymousStarStarEqual a) x -> AnonymousStarStarEqual a

Generic1 AnonymousStarStarEqual

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousStarStarEqual :: k -> Type

Methods

from1 :: AnonymousStarStarEqual a -> Rep1 AnonymousStarStarEqual a

to1 :: Rep1 AnonymousStarStarEqual a -> AnonymousStarStarEqual a

type Rep (AnonymousStarStarEqual a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousStarStarEqual a) = D1 (MetaData "AnonymousStarStarEqual" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousStarStarEqual" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousStarStarEqual

Defined in TreeSitter.Python.AST

type Rep1 AnonymousStarStarEqual = D1 (MetaData "AnonymousStarStarEqual" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousStarStarEqual" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousRAngleRAngleEqual a

Constructors

AnonymousRAngleRAngleEqual

Fields

• ann :: a

Instances

Functor AnonymousRAngleRAngleEqual

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousRAngleRAngleEqual

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousRAngleRAngleEqual m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousRAngleRAngleEqual a -> m

foldr :: (a -> b -> b) -> b -> AnonymousRAngleRAngleEqual a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousRAngleRAngleEqual a -> b

foldl :: (b -> a -> b) -> b -> AnonymousRAngleRAngleEqual a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousRAngleRAngleEqual a -> b

foldr1 :: (a -> a -> a) -> AnonymousRAngleRAngleEqual a -> a

foldl1 :: (a -> a -> a) -> AnonymousRAngleRAngleEqual a -> a

toList :: AnonymousRAngleRAngleEqual a -> [a]

null :: AnonymousRAngleRAngleEqual a -> Bool

length :: AnonymousRAngleRAngleEqual a -> Int

elem :: Eq a => a -> AnonymousRAngleRAngleEqual a -> Bool

maximum :: Ord a => AnonymousRAngleRAngleEqual a -> a

minimum :: Ord a => AnonymousRAngleRAngleEqual a -> a

sum :: Num a => AnonymousRAngleRAngleEqual a -> a

product :: Num a => AnonymousRAngleRAngleEqual a -> a

Traversable AnonymousRAngleRAngleEqual

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousRAngleRAngleEqual a -> f (AnonymousRAngleRAngleEqual b)

sequenceA :: Applicative f => AnonymousRAngleRAngleEqual (f a) -> f (AnonymousRAngleRAngleEqual a)

mapM :: Monad m => (a -> m b) -> AnonymousRAngleRAngleEqual a -> m (AnonymousRAngleRAngleEqual b)

sequence :: Monad m => AnonymousRAngleRAngleEqual (m a) -> m (AnonymousRAngleRAngleEqual a)

SymbolMatching AnonymousRAngleRAngleEqual

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousRAngleRAngleEqual -> Node -> Bool

showFailure :: Proxy AnonymousRAngleRAngleEqual -> Node -> String

Unmarshal AnonymousRAngleRAngleEqual

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousRAngleRAngleEqual a)

Eq a => Eq (AnonymousRAngleRAngleEqual a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousRAngleRAngleEqual a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousRAngleRAngleEqual a -> AnonymousRAngleRAngleEqual a -> Ordering

(<) :: AnonymousRAngleRAngleEqual a -> AnonymousRAngleRAngleEqual a -> Bool

(<=) :: AnonymousRAngleRAngleEqual a -> AnonymousRAngleRAngleEqual a -> Bool

(>) :: AnonymousRAngleRAngleEqual a -> AnonymousRAngleRAngleEqual a -> Bool

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

max :: AnonymousRAngleRAngleEqual a -> AnonymousRAngleRAngleEqual a -> AnonymousRAngleRAngleEqual a

min :: AnonymousRAngleRAngleEqual a -> AnonymousRAngleRAngleEqual a -> AnonymousRAngleRAngleEqual a

Show a => Show (AnonymousRAngleRAngleEqual a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousRAngleRAngleEqual a -> ShowS

show :: AnonymousRAngleRAngleEqual a -> String

showList :: [AnonymousRAngleRAngleEqual a] -> ShowS

Generic (AnonymousRAngleRAngleEqual a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousRAngleRAngleEqual a) :: Type -> Type

Methods

from :: AnonymousRAngleRAngleEqual a -> Rep (AnonymousRAngleRAngleEqual a) x

to :: Rep (AnonymousRAngleRAngleEqual a) x -> AnonymousRAngleRAngleEqual a

Generic1 AnonymousRAngleRAngleEqual

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousRAngleRAngleEqual :: k -> Type

Methods

from1 :: AnonymousRAngleRAngleEqual a -> Rep1 AnonymousRAngleRAngleEqual a

to1 :: Rep1 AnonymousRAngleRAngleEqual a -> AnonymousRAngleRAngleEqual a

type Rep (AnonymousRAngleRAngleEqual a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousRAngleRAngleEqual a) = D1 (MetaData "AnonymousRAngleRAngleEqual" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousRAngleRAngleEqual" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousRAngleRAngleEqual

Defined in TreeSitter.Python.AST

type Rep1 AnonymousRAngleRAngleEqual = D1 (MetaData "AnonymousRAngleRAngleEqual" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousRAngleRAngleEqual" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousLAngleLAngleEqual a

Constructors

AnonymousLAngleLAngleEqual

Fields

• ann :: a

Instances

Functor AnonymousLAngleLAngleEqual

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousLAngleLAngleEqual

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousLAngleLAngleEqual m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousLAngleLAngleEqual a -> m

foldr :: (a -> b -> b) -> b -> AnonymousLAngleLAngleEqual a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousLAngleLAngleEqual a -> b

foldl :: (b -> a -> b) -> b -> AnonymousLAngleLAngleEqual a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousLAngleLAngleEqual a -> b

foldr1 :: (a -> a -> a) -> AnonymousLAngleLAngleEqual a -> a

foldl1 :: (a -> a -> a) -> AnonymousLAngleLAngleEqual a -> a

toList :: AnonymousLAngleLAngleEqual a -> [a]

null :: AnonymousLAngleLAngleEqual a -> Bool

length :: AnonymousLAngleLAngleEqual a -> Int

elem :: Eq a => a -> AnonymousLAngleLAngleEqual a -> Bool

maximum :: Ord a => AnonymousLAngleLAngleEqual a -> a

minimum :: Ord a => AnonymousLAngleLAngleEqual a -> a

sum :: Num a => AnonymousLAngleLAngleEqual a -> a

product :: Num a => AnonymousLAngleLAngleEqual a -> a

Traversable AnonymousLAngleLAngleEqual

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousLAngleLAngleEqual a -> f (AnonymousLAngleLAngleEqual b)

sequenceA :: Applicative f => AnonymousLAngleLAngleEqual (f a) -> f (AnonymousLAngleLAngleEqual a)

mapM :: Monad m => (a -> m b) -> AnonymousLAngleLAngleEqual a -> m (AnonymousLAngleLAngleEqual b)

sequence :: Monad m => AnonymousLAngleLAngleEqual (m a) -> m (AnonymousLAngleLAngleEqual a)

SymbolMatching AnonymousLAngleLAngleEqual

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousLAngleLAngleEqual -> Node -> Bool

showFailure :: Proxy AnonymousLAngleLAngleEqual -> Node -> String

Unmarshal AnonymousLAngleLAngleEqual

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousLAngleLAngleEqual a)

Eq a => Eq (AnonymousLAngleLAngleEqual a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousLAngleLAngleEqual a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousLAngleLAngleEqual a -> AnonymousLAngleLAngleEqual a -> Ordering

(<) :: AnonymousLAngleLAngleEqual a -> AnonymousLAngleLAngleEqual a -> Bool

(<=) :: AnonymousLAngleLAngleEqual a -> AnonymousLAngleLAngleEqual a -> Bool

(>) :: AnonymousLAngleLAngleEqual a -> AnonymousLAngleLAngleEqual a -> Bool

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

max :: AnonymousLAngleLAngleEqual a -> AnonymousLAngleLAngleEqual a -> AnonymousLAngleLAngleEqual a

min :: AnonymousLAngleLAngleEqual a -> AnonymousLAngleLAngleEqual a -> AnonymousLAngleLAngleEqual a

Show a => Show (AnonymousLAngleLAngleEqual a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousLAngleLAngleEqual a -> ShowS

show :: AnonymousLAngleLAngleEqual a -> String

showList :: [AnonymousLAngleLAngleEqual a] -> ShowS

Generic (AnonymousLAngleLAngleEqual a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousLAngleLAngleEqual a) :: Type -> Type

Methods

from :: AnonymousLAngleLAngleEqual a -> Rep (AnonymousLAngleLAngleEqual a) x

to :: Rep (AnonymousLAngleLAngleEqual a) x -> AnonymousLAngleLAngleEqual a

Generic1 AnonymousLAngleLAngleEqual

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousLAngleLAngleEqual :: k -> Type

Methods

from1 :: AnonymousLAngleLAngleEqual a -> Rep1 AnonymousLAngleLAngleEqual a

to1 :: Rep1 AnonymousLAngleLAngleEqual a -> AnonymousLAngleLAngleEqual a

type Rep (AnonymousLAngleLAngleEqual a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousLAngleLAngleEqual a) = D1 (MetaData "AnonymousLAngleLAngleEqual" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousLAngleLAngleEqual" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousLAngleLAngleEqual

Defined in TreeSitter.Python.AST

type Rep1 AnonymousLAngleLAngleEqual = D1 (MetaData "AnonymousLAngleLAngleEqual" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousLAngleLAngleEqual" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousAmpersandEqual a

Constructors

AnonymousAmpersandEqual

Fields

• ann :: a

Instances

Functor AnonymousAmpersandEqual

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousAmpersandEqual

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousAmpersandEqual m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousAmpersandEqual a -> m

foldr :: (a -> b -> b) -> b -> AnonymousAmpersandEqual a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousAmpersandEqual a -> b

foldl :: (b -> a -> b) -> b -> AnonymousAmpersandEqual a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousAmpersandEqual a -> b

foldr1 :: (a -> a -> a) -> AnonymousAmpersandEqual a -> a

foldl1 :: (a -> a -> a) -> AnonymousAmpersandEqual a -> a

toList :: AnonymousAmpersandEqual a -> [a]

null :: AnonymousAmpersandEqual a -> Bool

length :: AnonymousAmpersandEqual a -> Int

elem :: Eq a => a -> AnonymousAmpersandEqual a -> Bool

maximum :: Ord a => AnonymousAmpersandEqual a -> a

minimum :: Ord a => AnonymousAmpersandEqual a -> a

sum :: Num a => AnonymousAmpersandEqual a -> a

product :: Num a => AnonymousAmpersandEqual a -> a

Traversable AnonymousAmpersandEqual

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousAmpersandEqual a -> f (AnonymousAmpersandEqual b)

sequenceA :: Applicative f => AnonymousAmpersandEqual (f a) -> f (AnonymousAmpersandEqual a)

mapM :: Monad m => (a -> m b) -> AnonymousAmpersandEqual a -> m (AnonymousAmpersandEqual b)

sequence :: Monad m => AnonymousAmpersandEqual (m a) -> m (AnonymousAmpersandEqual a)

SymbolMatching AnonymousAmpersandEqual

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousAmpersandEqual -> Node -> Bool

showFailure :: Proxy AnonymousAmpersandEqual -> Node -> String

Unmarshal AnonymousAmpersandEqual

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousAmpersandEqual a)

Eq a => Eq (AnonymousAmpersandEqual a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousAmpersandEqual a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousAmpersandEqual a -> AnonymousAmpersandEqual a -> Ordering

(<) :: AnonymousAmpersandEqual a -> AnonymousAmpersandEqual a -> Bool

(<=) :: AnonymousAmpersandEqual a -> AnonymousAmpersandEqual a -> Bool

(>) :: AnonymousAmpersandEqual a -> AnonymousAmpersandEqual a -> Bool

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

max :: AnonymousAmpersandEqual a -> AnonymousAmpersandEqual a -> AnonymousAmpersandEqual a

min :: AnonymousAmpersandEqual a -> AnonymousAmpersandEqual a -> AnonymousAmpersandEqual a

Show a => Show (AnonymousAmpersandEqual a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousAmpersandEqual a -> ShowS

show :: AnonymousAmpersandEqual a -> String

showList :: [AnonymousAmpersandEqual a] -> ShowS

Generic (AnonymousAmpersandEqual a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousAmpersandEqual a) :: Type -> Type

Methods

from :: AnonymousAmpersandEqual a -> Rep (AnonymousAmpersandEqual a) x

to :: Rep (AnonymousAmpersandEqual a) x -> AnonymousAmpersandEqual a

Generic1 AnonymousAmpersandEqual

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousAmpersandEqual :: k -> Type

Methods

from1 :: AnonymousAmpersandEqual a -> Rep1 AnonymousAmpersandEqual a

to1 :: Rep1 AnonymousAmpersandEqual a -> AnonymousAmpersandEqual a

type Rep (AnonymousAmpersandEqual a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousAmpersandEqual a) = D1 (MetaData "AnonymousAmpersandEqual" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousAmpersandEqual" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousAmpersandEqual

Defined in TreeSitter.Python.AST

type Rep1 AnonymousAmpersandEqual = D1 (MetaData "AnonymousAmpersandEqual" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousAmpersandEqual" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousCaretEqual a

Constructors

AnonymousCaretEqual

Fields

• ann :: a

Instances

Functor AnonymousCaretEqual

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousCaretEqual

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousCaretEqual m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousCaretEqual a -> m

foldr :: (a -> b -> b) -> b -> AnonymousCaretEqual a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousCaretEqual a -> b

foldl :: (b -> a -> b) -> b -> AnonymousCaretEqual a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousCaretEqual a -> b

foldr1 :: (a -> a -> a) -> AnonymousCaretEqual a -> a

foldl1 :: (a -> a -> a) -> AnonymousCaretEqual a -> a

toList :: AnonymousCaretEqual a -> [a]

null :: AnonymousCaretEqual a -> Bool

length :: AnonymousCaretEqual a -> Int

elem :: Eq a => a -> AnonymousCaretEqual a -> Bool

maximum :: Ord a => AnonymousCaretEqual a -> a

minimum :: Ord a => AnonymousCaretEqual a -> a

sum :: Num a => AnonymousCaretEqual a -> a

product :: Num a => AnonymousCaretEqual a -> a

Traversable AnonymousCaretEqual

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousCaretEqual a -> f (AnonymousCaretEqual b)

sequenceA :: Applicative f => AnonymousCaretEqual (f a) -> f (AnonymousCaretEqual a)

mapM :: Monad m => (a -> m b) -> AnonymousCaretEqual a -> m (AnonymousCaretEqual b)

sequence :: Monad m => AnonymousCaretEqual (m a) -> m (AnonymousCaretEqual a)

SymbolMatching AnonymousCaretEqual

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousCaretEqual -> Node -> Bool

showFailure :: Proxy AnonymousCaretEqual -> Node -> String

Unmarshal AnonymousCaretEqual

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousCaretEqual a)

Eq a => Eq (AnonymousCaretEqual a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousCaretEqual a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousCaretEqual a -> AnonymousCaretEqual a -> Ordering

(<) :: AnonymousCaretEqual a -> AnonymousCaretEqual a -> Bool

(<=) :: AnonymousCaretEqual a -> AnonymousCaretEqual a -> Bool

(>) :: AnonymousCaretEqual a -> AnonymousCaretEqual a -> Bool

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

max :: AnonymousCaretEqual a -> AnonymousCaretEqual a -> AnonymousCaretEqual a

min :: AnonymousCaretEqual a -> AnonymousCaretEqual a -> AnonymousCaretEqual a

Show a => Show (AnonymousCaretEqual a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousCaretEqual a -> ShowS

show :: AnonymousCaretEqual a -> String

showList :: [AnonymousCaretEqual a] -> ShowS

Generic (AnonymousCaretEqual a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousCaretEqual a) :: Type -> Type

Methods

from :: AnonymousCaretEqual a -> Rep (AnonymousCaretEqual a) x

to :: Rep (AnonymousCaretEqual a) x -> AnonymousCaretEqual a

Generic1 AnonymousCaretEqual

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousCaretEqual :: k -> Type

Methods

from1 :: AnonymousCaretEqual a -> Rep1 AnonymousCaretEqual a

to1 :: Rep1 AnonymousCaretEqual a -> AnonymousCaretEqual a

type Rep (AnonymousCaretEqual a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousCaretEqual a) = D1 (MetaData "AnonymousCaretEqual" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousCaretEqual" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousCaretEqual

Defined in TreeSitter.Python.AST

type Rep1 AnonymousCaretEqual = D1 (MetaData "AnonymousCaretEqual" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousCaretEqual" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousPipeEqual a

Constructors

AnonymousPipeEqual

Fields

• ann :: a

Instances

Functor AnonymousPipeEqual

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousPipeEqual

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousPipeEqual m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousPipeEqual a -> m

foldr :: (a -> b -> b) -> b -> AnonymousPipeEqual a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousPipeEqual a -> b

foldl :: (b -> a -> b) -> b -> AnonymousPipeEqual a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousPipeEqual a -> b

foldr1 :: (a -> a -> a) -> AnonymousPipeEqual a -> a

foldl1 :: (a -> a -> a) -> AnonymousPipeEqual a -> a

toList :: AnonymousPipeEqual a -> [a]

null :: AnonymousPipeEqual a -> Bool

length :: AnonymousPipeEqual a -> Int

elem :: Eq a => a -> AnonymousPipeEqual a -> Bool

maximum :: Ord a => AnonymousPipeEqual a -> a

minimum :: Ord a => AnonymousPipeEqual a -> a

sum :: Num a => AnonymousPipeEqual a -> a

product :: Num a => AnonymousPipeEqual a -> a

Traversable AnonymousPipeEqual

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousPipeEqual a -> f (AnonymousPipeEqual b)

sequenceA :: Applicative f => AnonymousPipeEqual (f a) -> f (AnonymousPipeEqual a)

mapM :: Monad m => (a -> m b) -> AnonymousPipeEqual a -> m (AnonymousPipeEqual b)

sequence :: Monad m => AnonymousPipeEqual (m a) -> m (AnonymousPipeEqual a)

SymbolMatching AnonymousPipeEqual

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousPipeEqual -> Node -> Bool

showFailure :: Proxy AnonymousPipeEqual -> Node -> String

Unmarshal AnonymousPipeEqual

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousPipeEqual a)

Eq a => Eq (AnonymousPipeEqual a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousPipeEqual a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousPipeEqual a -> AnonymousPipeEqual a -> Ordering

(<) :: AnonymousPipeEqual a -> AnonymousPipeEqual a -> Bool

(<=) :: AnonymousPipeEqual a -> AnonymousPipeEqual a -> Bool

(>) :: AnonymousPipeEqual a -> AnonymousPipeEqual a -> Bool

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

max :: AnonymousPipeEqual a -> AnonymousPipeEqual a -> AnonymousPipeEqual a

min :: AnonymousPipeEqual a -> AnonymousPipeEqual a -> AnonymousPipeEqual a

Show a => Show (AnonymousPipeEqual a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousPipeEqual a -> ShowS

show :: AnonymousPipeEqual a -> String

showList :: [AnonymousPipeEqual a] -> ShowS

Generic (AnonymousPipeEqual a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousPipeEqual a) :: Type -> Type

Methods

from :: AnonymousPipeEqual a -> Rep (AnonymousPipeEqual a) x

to :: Rep (AnonymousPipeEqual a) x -> AnonymousPipeEqual a

Generic1 AnonymousPipeEqual

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousPipeEqual :: k -> Type

Methods

from1 :: AnonymousPipeEqual a -> Rep1 AnonymousPipeEqual a

to1 :: Rep1 AnonymousPipeEqual a -> AnonymousPipeEqual a

type Rep (AnonymousPipeEqual a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousPipeEqual a) = D1 (MetaData "AnonymousPipeEqual" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousPipeEqual" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousPipeEqual

Defined in TreeSitter.Python.AST

type Rep1 AnonymousPipeEqual = D1 (MetaData "AnonymousPipeEqual" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousPipeEqual" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousYield a

Constructors

AnonymousYield

Fields

• ann :: a

Instances

Functor AnonymousYield

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousYield

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousYield m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousYield a -> m

foldr :: (a -> b -> b) -> b -> AnonymousYield a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousYield a -> b

foldl :: (b -> a -> b) -> b -> AnonymousYield a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousYield a -> b

foldr1 :: (a -> a -> a) -> AnonymousYield a -> a

foldl1 :: (a -> a -> a) -> AnonymousYield a -> a

toList :: AnonymousYield a -> [a]

null :: AnonymousYield a -> Bool

length :: AnonymousYield a -> Int

elem :: Eq a => a -> AnonymousYield a -> Bool

maximum :: Ord a => AnonymousYield a -> a

minimum :: Ord a => AnonymousYield a -> a

sum :: Num a => AnonymousYield a -> a

product :: Num a => AnonymousYield a -> a

Traversable AnonymousYield

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousYield a -> f (AnonymousYield b)

sequenceA :: Applicative f => AnonymousYield (f a) -> f (AnonymousYield a)

mapM :: Monad m => (a -> m b) -> AnonymousYield a -> m (AnonymousYield b)

sequence :: Monad m => AnonymousYield (m a) -> m (AnonymousYield a)

SymbolMatching AnonymousYield

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousYield -> Node -> Bool

showFailure :: Proxy AnonymousYield -> Node -> String

Unmarshal AnonymousYield

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousYield a)

Eq a => Eq (AnonymousYield a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousYield a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousYield a -> AnonymousYield a -> Ordering

(<) :: AnonymousYield a -> AnonymousYield a -> Bool

(<=) :: AnonymousYield a -> AnonymousYield a -> Bool

(>) :: AnonymousYield a -> AnonymousYield a -> Bool

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

max :: AnonymousYield a -> AnonymousYield a -> AnonymousYield a

min :: AnonymousYield a -> AnonymousYield a -> AnonymousYield a

Show a => Show (AnonymousYield a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousYield a -> ShowS

show :: AnonymousYield a -> String

showList :: [AnonymousYield a] -> ShowS

Generic (AnonymousYield a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousYield a) :: Type -> Type

Methods

from :: AnonymousYield a -> Rep (AnonymousYield a) x

to :: Rep (AnonymousYield a) x -> AnonymousYield a

Generic1 AnonymousYield

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousYield :: k -> Type

Methods

from1 :: AnonymousYield a -> Rep1 AnonymousYield a

to1 :: Rep1 AnonymousYield a -> AnonymousYield a

type Rep (AnonymousYield a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousYield a) = D1 (MetaData "AnonymousYield" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousYield" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousYield

Defined in TreeSitter.Python.AST

type Rep1 AnonymousYield = D1 (MetaData "AnonymousYield" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousYield" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousLBracket a

Constructors

AnonymousLBracket

Fields

• ann :: a

Instances

Functor AnonymousLBracket

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousLBracket

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousLBracket m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousLBracket a -> m

foldr :: (a -> b -> b) -> b -> AnonymousLBracket a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousLBracket a -> b

foldl :: (b -> a -> b) -> b -> AnonymousLBracket a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousLBracket a -> b

foldr1 :: (a -> a -> a) -> AnonymousLBracket a -> a

foldl1 :: (a -> a -> a) -> AnonymousLBracket a -> a

toList :: AnonymousLBracket a -> [a]

null :: AnonymousLBracket a -> Bool

length :: AnonymousLBracket a -> Int

elem :: Eq a => a -> AnonymousLBracket a -> Bool

maximum :: Ord a => AnonymousLBracket a -> a

minimum :: Ord a => AnonymousLBracket a -> a

sum :: Num a => AnonymousLBracket a -> a

product :: Num a => AnonymousLBracket a -> a

Traversable AnonymousLBracket

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousLBracket a -> f (AnonymousLBracket b)

sequenceA :: Applicative f => AnonymousLBracket (f a) -> f (AnonymousLBracket a)

mapM :: Monad m => (a -> m b) -> AnonymousLBracket a -> m (AnonymousLBracket b)

sequence :: Monad m => AnonymousLBracket (m a) -> m (AnonymousLBracket a)

SymbolMatching AnonymousLBracket

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousLBracket -> Node -> Bool

showFailure :: Proxy AnonymousLBracket -> Node -> String

Unmarshal AnonymousLBracket

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousLBracket a)

Eq a => Eq (AnonymousLBracket a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousLBracket a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousLBracket a -> AnonymousLBracket a -> Ordering

(<) :: AnonymousLBracket a -> AnonymousLBracket a -> Bool

(<=) :: AnonymousLBracket a -> AnonymousLBracket a -> Bool

(>) :: AnonymousLBracket a -> AnonymousLBracket a -> Bool

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

max :: AnonymousLBracket a -> AnonymousLBracket a -> AnonymousLBracket a

min :: AnonymousLBracket a -> AnonymousLBracket a -> AnonymousLBracket a

Show a => Show (AnonymousLBracket a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousLBracket a -> ShowS

show :: AnonymousLBracket a -> String

showList :: [AnonymousLBracket a] -> ShowS

Generic (AnonymousLBracket a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousLBracket a) :: Type -> Type

Methods

from :: AnonymousLBracket a -> Rep (AnonymousLBracket a) x

to :: Rep (AnonymousLBracket a) x -> AnonymousLBracket a

Generic1 AnonymousLBracket

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousLBracket :: k -> Type

Methods

from1 :: AnonymousLBracket a -> Rep1 AnonymousLBracket a

to1 :: Rep1 AnonymousLBracket a -> AnonymousLBracket a

type Rep (AnonymousLBracket a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousLBracket a) = D1 (MetaData "AnonymousLBracket" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousLBracket" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousLBracket

Defined in TreeSitter.Python.AST

type Rep1 AnonymousLBracket = D1 (MetaData "AnonymousLBracket" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousLBracket" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousRBracket a

Constructors

AnonymousRBracket

Fields

• ann :: a

Instances

Functor AnonymousRBracket

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousRBracket

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousRBracket m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousRBracket a -> m

foldr :: (a -> b -> b) -> b -> AnonymousRBracket a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousRBracket a -> b

foldl :: (b -> a -> b) -> b -> AnonymousRBracket a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousRBracket a -> b

foldr1 :: (a -> a -> a) -> AnonymousRBracket a -> a

foldl1 :: (a -> a -> a) -> AnonymousRBracket a -> a

toList :: AnonymousRBracket a -> [a]

null :: AnonymousRBracket a -> Bool

length :: AnonymousRBracket a -> Int

elem :: Eq a => a -> AnonymousRBracket a -> Bool

maximum :: Ord a => AnonymousRBracket a -> a

minimum :: Ord a => AnonymousRBracket a -> a

sum :: Num a => AnonymousRBracket a -> a

product :: Num a => AnonymousRBracket a -> a

Traversable AnonymousRBracket

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousRBracket a -> f (AnonymousRBracket b)

sequenceA :: Applicative f => AnonymousRBracket (f a) -> f (AnonymousRBracket a)

mapM :: Monad m => (a -> m b) -> AnonymousRBracket a -> m (AnonymousRBracket b)

sequence :: Monad m => AnonymousRBracket (m a) -> m (AnonymousRBracket a)

SymbolMatching AnonymousRBracket

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousRBracket -> Node -> Bool

showFailure :: Proxy AnonymousRBracket -> Node -> String

Unmarshal AnonymousRBracket

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousRBracket a)

Eq a => Eq (AnonymousRBracket a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousRBracket a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousRBracket a -> AnonymousRBracket a -> Ordering

(<) :: AnonymousRBracket a -> AnonymousRBracket a -> Bool

(<=) :: AnonymousRBracket a -> AnonymousRBracket a -> Bool

(>) :: AnonymousRBracket a -> AnonymousRBracket a -> Bool

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

max :: AnonymousRBracket a -> AnonymousRBracket a -> AnonymousRBracket a

min :: AnonymousRBracket a -> AnonymousRBracket a -> AnonymousRBracket a

Show a => Show (AnonymousRBracket a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousRBracket a -> ShowS

show :: AnonymousRBracket a -> String

showList :: [AnonymousRBracket a] -> ShowS

Generic (AnonymousRBracket a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousRBracket a) :: Type -> Type

Methods

from :: AnonymousRBracket a -> Rep (AnonymousRBracket a) x

to :: Rep (AnonymousRBracket a) x -> AnonymousRBracket a

Generic1 AnonymousRBracket

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousRBracket :: k -> Type

Methods

from1 :: AnonymousRBracket a -> Rep1 AnonymousRBracket a

to1 :: Rep1 AnonymousRBracket a -> AnonymousRBracket a

type Rep (AnonymousRBracket a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousRBracket a) = D1 (MetaData "AnonymousRBracket" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousRBracket" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousRBracket

Defined in TreeSitter.Python.AST

type Rep1 AnonymousRBracket = D1 (MetaData "AnonymousRBracket" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousRBracket" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

data Ellipsis a

Constructors

Ellipsis

Fields

• ann :: a
• bytes :: Text

Instances

Functor Ellipsis

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable Ellipsis

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => Ellipsis m -> m

foldMap :: Monoid m => (a -> m) -> Ellipsis a -> m

foldr :: (a -> b -> b) -> b -> Ellipsis a -> b

foldr' :: (a -> b -> b) -> b -> Ellipsis a -> b

foldl :: (b -> a -> b) -> b -> Ellipsis a -> b

foldl' :: (b -> a -> b) -> b -> Ellipsis a -> b

foldr1 :: (a -> a -> a) -> Ellipsis a -> a

foldl1 :: (a -> a -> a) -> Ellipsis a -> a

toList :: Ellipsis a -> [a]

null :: Ellipsis a -> Bool

length :: Ellipsis a -> Int

elem :: Eq a => a -> Ellipsis a -> Bool

maximum :: Ord a => Ellipsis a -> a

minimum :: Ord a => Ellipsis a -> a

sum :: Num a => Ellipsis a -> a

product :: Num a => Ellipsis a -> a

Traversable Ellipsis

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> Ellipsis a -> f (Ellipsis b)

sequenceA :: Applicative f => Ellipsis (f a) -> f (Ellipsis a)

mapM :: Monad m => (a -> m b) -> Ellipsis a -> m (Ellipsis b)

sequence :: Monad m => Ellipsis (m a) -> m (Ellipsis a)

SymbolMatching Ellipsis

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy Ellipsis -> Node -> Bool

showFailure :: Proxy Ellipsis -> Node -> String

Unmarshal Ellipsis

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Ellipsis a)

Eq a => Eq (Ellipsis a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (Ellipsis a)

Defined in TreeSitter.Python.AST

Methods

compare :: Ellipsis a -> Ellipsis a -> Ordering

(<) :: Ellipsis a -> Ellipsis a -> Bool

(<=) :: Ellipsis a -> Ellipsis a -> Bool

(>) :: Ellipsis a -> Ellipsis a -> Bool

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

max :: Ellipsis a -> Ellipsis a -> Ellipsis a

min :: Ellipsis a -> Ellipsis a -> Ellipsis a

Show a => Show (Ellipsis a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> Ellipsis a -> ShowS

show :: Ellipsis a -> String

showList :: [Ellipsis a] -> ShowS

Generic (Ellipsis a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (Ellipsis a) :: Type -> Type

Methods

from :: Ellipsis a -> Rep (Ellipsis a) x

to :: Rep (Ellipsis a) x -> Ellipsis a

Generic1 Ellipsis

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 Ellipsis :: k -> Type

Methods

from1 :: Ellipsis a -> Rep1 Ellipsis a

to1 :: Rep1 Ellipsis a -> Ellipsis a

type Rep (Ellipsis a)

Defined in TreeSitter.Python.AST

type Rep (Ellipsis a) = D1 (MetaData "Ellipsis" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "Ellipsis" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: S1 (MetaSel (Just "bytes") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Text)))

type Rep1 Ellipsis

Defined in TreeSitter.Python.AST

type Rep1 Ellipsis = D1 (MetaData "Ellipsis" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "Ellipsis" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: S1 (MetaSel (Just "bytes") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Text)))

newtype AnonymousLBrace a

Constructors

AnonymousLBrace

Fields

• ann :: a

Instances

Functor AnonymousLBrace

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousLBrace

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousLBrace m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousLBrace a -> m

foldr :: (a -> b -> b) -> b -> AnonymousLBrace a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousLBrace a -> b

foldl :: (b -> a -> b) -> b -> AnonymousLBrace a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousLBrace a -> b

foldr1 :: (a -> a -> a) -> AnonymousLBrace a -> a

foldl1 :: (a -> a -> a) -> AnonymousLBrace a -> a

toList :: AnonymousLBrace a -> [a]

null :: AnonymousLBrace a -> Bool

length :: AnonymousLBrace a -> Int

elem :: Eq a => a -> AnonymousLBrace a -> Bool

maximum :: Ord a => AnonymousLBrace a -> a

minimum :: Ord a => AnonymousLBrace a -> a

sum :: Num a => AnonymousLBrace a -> a

product :: Num a => AnonymousLBrace a -> a

Traversable AnonymousLBrace

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousLBrace a -> f (AnonymousLBrace b)

sequenceA :: Applicative f => AnonymousLBrace (f a) -> f (AnonymousLBrace a)

mapM :: Monad m => (a -> m b) -> AnonymousLBrace a -> m (AnonymousLBrace b)

sequence :: Monad m => AnonymousLBrace (m a) -> m (AnonymousLBrace a)

SymbolMatching AnonymousLBrace

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousLBrace -> Node -> Bool

showFailure :: Proxy AnonymousLBrace -> Node -> String

Unmarshal AnonymousLBrace

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousLBrace a)

Eq a => Eq (AnonymousLBrace a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousLBrace a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousLBrace a -> AnonymousLBrace a -> Ordering

(<) :: AnonymousLBrace a -> AnonymousLBrace a -> Bool

(<=) :: AnonymousLBrace a -> AnonymousLBrace a -> Bool

(>) :: AnonymousLBrace a -> AnonymousLBrace a -> Bool

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

max :: AnonymousLBrace a -> AnonymousLBrace a -> AnonymousLBrace a

min :: AnonymousLBrace a -> AnonymousLBrace a -> AnonymousLBrace a

Show a => Show (AnonymousLBrace a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousLBrace a -> ShowS

show :: AnonymousLBrace a -> String

showList :: [AnonymousLBrace a] -> ShowS

Generic (AnonymousLBrace a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousLBrace a) :: Type -> Type

Methods

from :: AnonymousLBrace a -> Rep (AnonymousLBrace a) x

to :: Rep (AnonymousLBrace a) x -> AnonymousLBrace a

Generic1 AnonymousLBrace

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousLBrace :: k -> Type

Methods

from1 :: AnonymousLBrace a -> Rep1 AnonymousLBrace a

to1 :: Rep1 AnonymousLBrace a -> AnonymousLBrace a

type Rep (AnonymousLBrace a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousLBrace a) = D1 (MetaData "AnonymousLBrace" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousLBrace" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousLBrace

Defined in TreeSitter.Python.AST

type Rep1 AnonymousLBrace = D1 (MetaData "AnonymousLBrace" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousLBrace" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype AnonymousRBrace a

Constructors

AnonymousRBrace

Fields

• ann :: a

Instances

Functor AnonymousRBrace

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AnonymousRBrace

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousRBrace m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousRBrace a -> m

foldr :: (a -> b -> b) -> b -> AnonymousRBrace a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousRBrace a -> b

foldl :: (b -> a -> b) -> b -> AnonymousRBrace a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousRBrace a -> b

foldr1 :: (a -> a -> a) -> AnonymousRBrace a -> a

foldl1 :: (a -> a -> a) -> AnonymousRBrace a -> a

toList :: AnonymousRBrace a -> [a]

null :: AnonymousRBrace a -> Bool

length :: AnonymousRBrace a -> Int

elem :: Eq a => a -> AnonymousRBrace a -> Bool

maximum :: Ord a => AnonymousRBrace a -> a

minimum :: Ord a => AnonymousRBrace a -> a

sum :: Num a => AnonymousRBrace a -> a

product :: Num a => AnonymousRBrace a -> a

Traversable AnonymousRBrace

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousRBrace a -> f (AnonymousRBrace b)

sequenceA :: Applicative f => AnonymousRBrace (f a) -> f (AnonymousRBrace a)

mapM :: Monad m => (a -> m b) -> AnonymousRBrace a -> m (AnonymousRBrace b)

sequence :: Monad m => AnonymousRBrace (m a) -> m (AnonymousRBrace a)

SymbolMatching AnonymousRBrace

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousRBrace -> Node -> Bool

showFailure :: Proxy AnonymousRBrace -> Node -> String

Unmarshal AnonymousRBrace

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousRBrace a)

Eq a => Eq (AnonymousRBrace a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AnonymousRBrace a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousRBrace a -> AnonymousRBrace a -> Ordering

(<) :: AnonymousRBrace a -> AnonymousRBrace a -> Bool

(<=) :: AnonymousRBrace a -> AnonymousRBrace a -> Bool

(>) :: AnonymousRBrace a -> AnonymousRBrace a -> Bool

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

max :: AnonymousRBrace a -> AnonymousRBrace a -> AnonymousRBrace a

min :: AnonymousRBrace a -> AnonymousRBrace a -> AnonymousRBrace a

Show a => Show (AnonymousRBrace a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousRBrace a -> ShowS

show :: AnonymousRBrace a -> String

showList :: [AnonymousRBrace a] -> ShowS

Generic (AnonymousRBrace a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousRBrace a) :: Type -> Type

Methods

from :: AnonymousRBrace a -> Rep (AnonymousRBrace a) x

to :: Rep (AnonymousRBrace a) x -> AnonymousRBrace a

Generic1 AnonymousRBrace

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousRBrace :: k -> Type

Methods

from1 :: AnonymousRBrace a -> Rep1 AnonymousRBrace a

to1 :: Rep1 AnonymousRBrace a -> AnonymousRBrace a

type Rep (AnonymousRBrace a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousRBrace a) = D1 (MetaData "AnonymousRBrace" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousRBrace" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousRBrace

Defined in TreeSitter.Python.AST

type Rep1 AnonymousRBrace = D1 (MetaData "AnonymousRBrace" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousRBrace" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

data EscapeSequence a

Constructors

EscapeSequence

Fields

• ann :: a
• bytes :: Text

Instances

Functor EscapeSequence

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable EscapeSequence

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => EscapeSequence m -> m

foldMap :: Monoid m => (a -> m) -> EscapeSequence a -> m

foldr :: (a -> b -> b) -> b -> EscapeSequence a -> b

foldr' :: (a -> b -> b) -> b -> EscapeSequence a -> b

foldl :: (b -> a -> b) -> b -> EscapeSequence a -> b

foldl' :: (b -> a -> b) -> b -> EscapeSequence a -> b

foldr1 :: (a -> a -> a) -> EscapeSequence a -> a

foldl1 :: (a -> a -> a) -> EscapeSequence a -> a

toList :: EscapeSequence a -> [a]

null :: EscapeSequence a -> Bool

length :: EscapeSequence a -> Int

elem :: Eq a => a -> EscapeSequence a -> Bool

maximum :: Ord a => EscapeSequence a -> a

minimum :: Ord a => EscapeSequence a -> a

sum :: Num a => EscapeSequence a -> a

product :: Num a => EscapeSequence a -> a

Traversable EscapeSequence

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> EscapeSequence a -> f (EscapeSequence b)

sequenceA :: Applicative f => EscapeSequence (f a) -> f (EscapeSequence a)

mapM :: Monad m => (a -> m b) -> EscapeSequence a -> m (EscapeSequence b)

sequence :: Monad m => EscapeSequence (m a) -> m (EscapeSequence a)

SymbolMatching EscapeSequence

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy EscapeSequence -> Node -> Bool

showFailure :: Proxy EscapeSequence -> Node -> String

Unmarshal EscapeSequence

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (EscapeSequence a)

Eq a => Eq (EscapeSequence a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (EscapeSequence a)

Defined in TreeSitter.Python.AST

Methods

compare :: EscapeSequence a -> EscapeSequence a -> Ordering

(<) :: EscapeSequence a -> EscapeSequence a -> Bool

(<=) :: EscapeSequence a -> EscapeSequence a -> Bool

(>) :: EscapeSequence a -> EscapeSequence a -> Bool

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

max :: EscapeSequence a -> EscapeSequence a -> EscapeSequence a

min :: EscapeSequence a -> EscapeSequence a -> EscapeSequence a

Show a => Show (EscapeSequence a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> EscapeSequence a -> ShowS

show :: EscapeSequence a -> String

showList :: [EscapeSequence a] -> ShowS

Generic (EscapeSequence a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (EscapeSequence a) :: Type -> Type

Methods

from :: EscapeSequence a -> Rep (EscapeSequence a) x

to :: Rep (EscapeSequence a) x -> EscapeSequence a

Generic1 EscapeSequence

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 EscapeSequence :: k -> Type

Methods

from1 :: EscapeSequence a -> Rep1 EscapeSequence a

to1 :: Rep1 EscapeSequence a -> EscapeSequence a

type Rep (EscapeSequence a)

Defined in TreeSitter.Python.AST

type Rep (EscapeSequence a) = D1 (MetaData "EscapeSequence" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "EscapeSequence" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: S1 (MetaSel (Just "bytes") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Text)))

type Rep1 EscapeSequence

Defined in TreeSitter.Python.AST

type Rep1 EscapeSequence = D1 (MetaData "EscapeSequence" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "EscapeSequence" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: S1 (MetaSel (Just "bytes") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Text)))

data TypeConversion a

Constructors

TypeConversion

Fields

• ann :: a
• bytes :: Text

Instances

Functor TypeConversion

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable TypeConversion

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => TypeConversion m -> m

foldMap :: Monoid m => (a -> m) -> TypeConversion a -> m

foldr :: (a -> b -> b) -> b -> TypeConversion a -> b

foldr' :: (a -> b -> b) -> b -> TypeConversion a -> b

foldl :: (b -> a -> b) -> b -> TypeConversion a -> b

foldl' :: (b -> a -> b) -> b -> TypeConversion a -> b

foldr1 :: (a -> a -> a) -> TypeConversion a -> a

foldl1 :: (a -> a -> a) -> TypeConversion a -> a

toList :: TypeConversion a -> [a]

null :: TypeConversion a -> Bool

length :: TypeConversion a -> Int

elem :: Eq a => a -> TypeConversion a -> Bool

maximum :: Ord a => TypeConversion a -> a

minimum :: Ord a => TypeConversion a -> a

sum :: Num a => TypeConversion a -> a

product :: Num a => TypeConversion a -> a

Traversable TypeConversion

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> TypeConversion a -> f (TypeConversion b)

sequenceA :: Applicative f => TypeConversion (f a) -> f (TypeConversion a)

mapM :: Monad m => (a -> m b) -> TypeConversion a -> m (TypeConversion b)

sequence :: Monad m => TypeConversion (m a) -> m (TypeConversion a)

SymbolMatching TypeConversion

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy TypeConversion -> Node -> Bool

showFailure :: Proxy TypeConversion -> Node -> String

Unmarshal TypeConversion

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (TypeConversion a)

Eq a => Eq (TypeConversion a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (TypeConversion a)

Defined in TreeSitter.Python.AST

Methods

compare :: TypeConversion a -> TypeConversion a -> Ordering

(<) :: TypeConversion a -> TypeConversion a -> Bool

(<=) :: TypeConversion a -> TypeConversion a -> Bool

(>) :: TypeConversion a -> TypeConversion a -> Bool

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

max :: TypeConversion a -> TypeConversion a -> TypeConversion a

min :: TypeConversion a -> TypeConversion a -> TypeConversion a

Show a => Show (TypeConversion a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> TypeConversion a -> ShowS

show :: TypeConversion a -> String

showList :: [TypeConversion a] -> ShowS

Generic (TypeConversion a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (TypeConversion a) :: Type -> Type

Methods

from :: TypeConversion a -> Rep (TypeConversion a) x

to :: Rep (TypeConversion a) x -> TypeConversion a

Generic1 TypeConversion

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 TypeConversion :: k -> Type

Methods

from1 :: TypeConversion a -> Rep1 TypeConversion a

to1 :: Rep1 TypeConversion a -> TypeConversion a

type Rep (TypeConversion a)

Defined in TreeSitter.Python.AST

type Rep (TypeConversion a) = D1 (MetaData "TypeConversion" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "TypeConversion" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: S1 (MetaSel (Just "bytes") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Text)))

type Rep1 TypeConversion

Defined in TreeSitter.Python.AST

type Rep1 TypeConversion = D1 (MetaData "TypeConversion" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "TypeConversion" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: S1 (MetaSel (Just "bytes") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Text)))

data Integer a

Constructors

Integer

Fields

• ann :: a
• bytes :: Text

Instances

Functor Integer

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable Integer

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => Integer m -> m

foldMap :: Monoid m => (a -> m) -> Integer a -> m

foldr :: (a -> b -> b) -> b -> Integer a -> b

foldr' :: (a -> b -> b) -> b -> Integer a -> b

foldl :: (b -> a -> b) -> b -> Integer a -> b

foldl' :: (b -> a -> b) -> b -> Integer a -> b

foldr1 :: (a -> a -> a) -> Integer a -> a

foldl1 :: (a -> a -> a) -> Integer a -> a

toList :: Integer a -> [a]

null :: Integer a -> Bool

length :: Integer a -> Int

elem :: Eq a => a -> Integer a -> Bool

maximum :: Ord a => Integer a -> a

minimum :: Ord a => Integer a -> a

sum :: Num a => Integer a -> a

product :: Num a => Integer a -> a

Traversable Integer

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> Integer a -> f (Integer b)

sequenceA :: Applicative f => Integer (f a) -> f (Integer a)

mapM :: Monad m => (a -> m b) -> Integer a -> m (Integer b)

sequence :: Monad m => Integer (m a) -> m (Integer a)

SymbolMatching Integer

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy Integer -> Node -> Bool

showFailure :: Proxy Integer -> Node -> String

Unmarshal Integer

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Integer a)

Eq a => Eq (Integer a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (Integer a)

Defined in TreeSitter.Python.AST

Methods

compare :: Integer a -> Integer a -> Ordering

(<) :: Integer a -> Integer a -> Bool

(<=) :: Integer a -> Integer a -> Bool

(>) :: Integer a -> Integer a -> Bool

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

max :: Integer a -> Integer a -> Integer a

min :: Integer a -> Integer a -> Integer a

Show a => Show (Integer a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> Integer a -> ShowS

show :: Integer a -> String

showList :: [Integer a] -> ShowS

Generic (Integer a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (Integer a) :: Type -> Type

Methods

from :: Integer a -> Rep (Integer a) x

to :: Rep (Integer a) x -> Integer a

Generic1 Integer

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 Integer :: k -> Type

Methods

from1 :: Integer a -> Rep1 Integer a

to1 :: Rep1 Integer a -> Integer a

type Rep (Integer a)

Defined in TreeSitter.Python.AST

type Rep (Integer a) = D1 (MetaData "Integer" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "Integer" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: S1 (MetaSel (Just "bytes") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Text)))

type Rep1 Integer

Defined in TreeSitter.Python.AST

type Rep1 Integer = D1 (MetaData "Integer" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "Integer" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: S1 (MetaSel (Just "bytes") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Text)))

data Float a

Constructors

Float

Fields

• ann :: a
• bytes :: Text

Instances

Functor Float

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable Float

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => Float m -> m

foldMap :: Monoid m => (a -> m) -> Float a -> m

foldr :: (a -> b -> b) -> b -> Float a -> b

foldr' :: (a -> b -> b) -> b -> Float a -> b

foldl :: (b -> a -> b) -> b -> Float a -> b

foldl' :: (b -> a -> b) -> b -> Float a -> b

foldr1 :: (a -> a -> a) -> Float a -> a

foldl1 :: (a -> a -> a) -> Float a -> a

toList :: Float a -> [a]

null :: Float a -> Bool

length :: Float a -> Int

elem :: Eq a => a -> Float a -> Bool

maximum :: Ord a => Float a -> a

minimum :: Ord a => Float a -> a

sum :: Num a => Float a -> a

product :: Num a => Float a -> a

Traversable Float

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> Float a -> f (Float b)

sequenceA :: Applicative f => Float (f a) -> f (Float a)

mapM :: Monad m => (a -> m b) -> Float a -> m (Float b)

sequence :: Monad m => Float (m a) -> m (Float a)

SymbolMatching Float

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy Float -> Node -> Bool

showFailure :: Proxy Float -> Node -> String

Unmarshal Float

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Float a)

Eq a => Eq (Float a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (Float a)

Defined in TreeSitter.Python.AST

Methods

compare :: Float a -> Float a -> Ordering

(<) :: Float a -> Float a -> Bool

(<=) :: Float a -> Float a -> Bool

(>) :: Float a -> Float a -> Bool

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

max :: Float a -> Float a -> Float a

min :: Float a -> Float a -> Float a

Show a => Show (Float a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> Float a -> ShowS

show :: Float a -> String

showList :: [Float a] -> ShowS

Generic (Float a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (Float a) :: Type -> Type

Methods

from :: Float a -> Rep (Float a) x

to :: Rep (Float a) x -> Float a

Generic1 Float

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 Float :: k -> Type

Methods

from1 :: Float a -> Rep1 Float a

to1 :: Rep1 Float a -> Float a

type Rep (Float a)

Defined in TreeSitter.Python.AST

type Rep (Float a) = D1 (MetaData "Float" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "Float" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: S1 (MetaSel (Just "bytes") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Text)))

type Rep1 Float

Defined in TreeSitter.Python.AST

type Rep1 Float = D1 (MetaData "Float" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "Float" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: S1 (MetaSel (Just "bytes") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Text)))

data Identifier a

Constructors

Identifier

Fields

• ann :: a
• bytes :: Text

Instances

Functor Identifier

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable Identifier

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => Identifier m -> m

foldMap :: Monoid m => (a -> m) -> Identifier a -> m

foldr :: (a -> b -> b) -> b -> Identifier a -> b

foldr' :: (a -> b -> b) -> b -> Identifier a -> b

foldl :: (b -> a -> b) -> b -> Identifier a -> b

foldl' :: (b -> a -> b) -> b -> Identifier a -> b

foldr1 :: (a -> a -> a) -> Identifier a -> a

foldl1 :: (a -> a -> a) -> Identifier a -> a

toList :: Identifier a -> [a]

null :: Identifier a -> Bool

length :: Identifier a -> Int

elem :: Eq a => a -> Identifier a -> Bool

maximum :: Ord a => Identifier a -> a

minimum :: Ord a => Identifier a -> a

sum :: Num a => Identifier a -> a

product :: Num a => Identifier a -> a

Traversable Identifier

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> Identifier a -> f (Identifier b)

sequenceA :: Applicative f => Identifier (f a) -> f (Identifier a)

mapM :: Monad m => (a -> m b) -> Identifier a -> m (Identifier b)

sequence :: Monad m => Identifier (m a) -> m (Identifier a)

SymbolMatching Identifier

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy Identifier -> Node -> Bool

showFailure :: Proxy Identifier -> Node -> String

Unmarshal Identifier

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Identifier a)

Eq a => Eq (Identifier a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (Identifier a)

Defined in TreeSitter.Python.AST

Methods

compare :: Identifier a -> Identifier a -> Ordering

(<) :: Identifier a -> Identifier a -> Bool

(<=) :: Identifier a -> Identifier a -> Bool

(>) :: Identifier a -> Identifier a -> Bool

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

max :: Identifier a -> Identifier a -> Identifier a

min :: Identifier a -> Identifier a -> Identifier a

Show a => Show (Identifier a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> Identifier a -> ShowS

show :: Identifier a -> String

showList :: [Identifier a] -> ShowS

Generic (Identifier a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (Identifier a) :: Type -> Type

Methods

from :: Identifier a -> Rep (Identifier a) x

to :: Rep (Identifier a) x -> Identifier a

Generic1 Identifier

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 Identifier :: k -> Type

Methods

from1 :: Identifier a -> Rep1 Identifier a

to1 :: Rep1 Identifier a -> Identifier a

type Rep (Identifier a)

Defined in TreeSitter.Python.AST

type Rep (Identifier a) = D1 (MetaData "Identifier" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "Identifier" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: S1 (MetaSel (Just "bytes") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Text)))

type Rep1 Identifier

Defined in TreeSitter.Python.AST

type Rep1 Identifier = D1 (MetaData "Identifier" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "Identifier" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: S1 (MetaSel (Just "bytes") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Text)))

data NonlocalStatement a

Constructors

NonlocalStatement

Fields

• ann :: a
• extraChildren :: (NonEmpty (Identifier a))

Instances

Functor NonlocalStatement

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable NonlocalStatement

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => NonlocalStatement m -> m

foldMap :: Monoid m => (a -> m) -> NonlocalStatement a -> m

foldr :: (a -> b -> b) -> b -> NonlocalStatement a -> b

foldr' :: (a -> b -> b) -> b -> NonlocalStatement a -> b

foldl :: (b -> a -> b) -> b -> NonlocalStatement a -> b

foldl' :: (b -> a -> b) -> b -> NonlocalStatement a -> b

foldr1 :: (a -> a -> a) -> NonlocalStatement a -> a

foldl1 :: (a -> a -> a) -> NonlocalStatement a -> a

toList :: NonlocalStatement a -> [a]

null :: NonlocalStatement a -> Bool

length :: NonlocalStatement a -> Int

elem :: Eq a => a -> NonlocalStatement a -> Bool

maximum :: Ord a => NonlocalStatement a -> a

minimum :: Ord a => NonlocalStatement a -> a

sum :: Num a => NonlocalStatement a -> a

product :: Num a => NonlocalStatement a -> a

Traversable NonlocalStatement

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> NonlocalStatement a -> f (NonlocalStatement b)

sequenceA :: Applicative f => NonlocalStatement (f a) -> f (NonlocalStatement a)

mapM :: Monad m => (a -> m b) -> NonlocalStatement a -> m (NonlocalStatement b)

sequence :: Monad m => NonlocalStatement (m a) -> m (NonlocalStatement a)

SymbolMatching NonlocalStatement

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy NonlocalStatement -> Node -> Bool

showFailure :: Proxy NonlocalStatement -> Node -> String

Unmarshal NonlocalStatement

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (NonlocalStatement a)

Eq a => Eq (NonlocalStatement a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (NonlocalStatement a)

Defined in TreeSitter.Python.AST

Methods

compare :: NonlocalStatement a -> NonlocalStatement a -> Ordering

(<) :: NonlocalStatement a -> NonlocalStatement a -> Bool

(<=) :: NonlocalStatement a -> NonlocalStatement a -> Bool

(>) :: NonlocalStatement a -> NonlocalStatement a -> Bool

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

max :: NonlocalStatement a -> NonlocalStatement a -> NonlocalStatement a

min :: NonlocalStatement a -> NonlocalStatement a -> NonlocalStatement a

Show a => Show (NonlocalStatement a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> NonlocalStatement a -> ShowS

show :: NonlocalStatement a -> String

showList :: [NonlocalStatement a] -> ShowS

Generic (NonlocalStatement a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (NonlocalStatement a) :: Type -> Type

Methods

from :: NonlocalStatement a -> Rep (NonlocalStatement a) x

to :: Rep (NonlocalStatement a) x -> NonlocalStatement a

Generic1 NonlocalStatement

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 NonlocalStatement :: k -> Type

Methods

from1 :: NonlocalStatement a -> Rep1 NonlocalStatement a

to1 :: Rep1 NonlocalStatement a -> NonlocalStatement a

type Rep (NonlocalStatement a)

Defined in TreeSitter.Python.AST

type Rep (NonlocalStatement a) = D1 (MetaData "NonlocalStatement" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "NonlocalStatement" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (NonEmpty (Identifier a)))))

type Rep1 NonlocalStatement

Defined in TreeSitter.Python.AST

type Rep1 NonlocalStatement = D1 (MetaData "NonlocalStatement" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "NonlocalStatement" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (NonEmpty :.: Rec1 Identifier)))

data GlobalStatement a

Constructors

GlobalStatement

Fields

• ann :: a
• extraChildren :: (NonEmpty (Identifier a))

Instances

Functor GlobalStatement

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable GlobalStatement

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => GlobalStatement m -> m

foldMap :: Monoid m => (a -> m) -> GlobalStatement a -> m

foldr :: (a -> b -> b) -> b -> GlobalStatement a -> b

foldr' :: (a -> b -> b) -> b -> GlobalStatement a -> b

foldl :: (b -> a -> b) -> b -> GlobalStatement a -> b

foldl' :: (b -> a -> b) -> b -> GlobalStatement a -> b

foldr1 :: (a -> a -> a) -> GlobalStatement a -> a

foldl1 :: (a -> a -> a) -> GlobalStatement a -> a

toList :: GlobalStatement a -> [a]

null :: GlobalStatement a -> Bool

length :: GlobalStatement a -> Int

elem :: Eq a => a -> GlobalStatement a -> Bool

maximum :: Ord a => GlobalStatement a -> a

minimum :: Ord a => GlobalStatement a -> a

sum :: Num a => GlobalStatement a -> a

product :: Num a => GlobalStatement a -> a

Traversable GlobalStatement

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> GlobalStatement a -> f (GlobalStatement b)

sequenceA :: Applicative f => GlobalStatement (f a) -> f (GlobalStatement a)

mapM :: Monad m => (a -> m b) -> GlobalStatement a -> m (GlobalStatement b)

sequence :: Monad m => GlobalStatement (m a) -> m (GlobalStatement a)

SymbolMatching GlobalStatement

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy GlobalStatement -> Node -> Bool

showFailure :: Proxy GlobalStatement -> Node -> String

Unmarshal GlobalStatement

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (GlobalStatement a)

Eq a => Eq (GlobalStatement a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (GlobalStatement a)

Defined in TreeSitter.Python.AST

Methods

compare :: GlobalStatement a -> GlobalStatement a -> Ordering

(<) :: GlobalStatement a -> GlobalStatement a -> Bool

(<=) :: GlobalStatement a -> GlobalStatement a -> Bool

(>) :: GlobalStatement a -> GlobalStatement a -> Bool

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

max :: GlobalStatement a -> GlobalStatement a -> GlobalStatement a

min :: GlobalStatement a -> GlobalStatement a -> GlobalStatement a

Show a => Show (GlobalStatement a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> GlobalStatement a -> ShowS

show :: GlobalStatement a -> String

showList :: [GlobalStatement a] -> ShowS

Generic (GlobalStatement a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (GlobalStatement a) :: Type -> Type

Methods

from :: GlobalStatement a -> Rep (GlobalStatement a) x

to :: Rep (GlobalStatement a) x -> GlobalStatement a

Generic1 GlobalStatement

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 GlobalStatement :: k -> Type

Methods

from1 :: GlobalStatement a -> Rep1 GlobalStatement a

to1 :: Rep1 GlobalStatement a -> GlobalStatement a

type Rep (GlobalStatement a)

Defined in TreeSitter.Python.AST

type Rep (GlobalStatement a) = D1 (MetaData "GlobalStatement" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "GlobalStatement" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (NonEmpty (Identifier a)))))

type Rep1 GlobalStatement

Defined in TreeSitter.Python.AST

type Rep1 GlobalStatement = D1 (MetaData "GlobalStatement" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "GlobalStatement" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (NonEmpty :.: Rec1 Identifier)))

data DottedName a

Constructors

DottedName

Fields

• ann :: a
• extraChildren :: (NonEmpty (Identifier a))

Instances

Functor DottedName

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable DottedName

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => DottedName m -> m

foldMap :: Monoid m => (a -> m) -> DottedName a -> m

foldr :: (a -> b -> b) -> b -> DottedName a -> b

foldr' :: (a -> b -> b) -> b -> DottedName a -> b

foldl :: (b -> a -> b) -> b -> DottedName a -> b

foldl' :: (b -> a -> b) -> b -> DottedName a -> b

foldr1 :: (a -> a -> a) -> DottedName a -> a

foldl1 :: (a -> a -> a) -> DottedName a -> a

toList :: DottedName a -> [a]

null :: DottedName a -> Bool

length :: DottedName a -> Int

elem :: Eq a => a -> DottedName a -> Bool

maximum :: Ord a => DottedName a -> a

minimum :: Ord a => DottedName a -> a

sum :: Num a => DottedName a -> a

product :: Num a => DottedName a -> a

Traversable DottedName

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> DottedName a -> f (DottedName b)

sequenceA :: Applicative f => DottedName (f a) -> f (DottedName a)

mapM :: Monad m => (a -> m b) -> DottedName a -> m (DottedName b)

sequence :: Monad m => DottedName (m a) -> m (DottedName a)

SymbolMatching DottedName

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy DottedName -> Node -> Bool

showFailure :: Proxy DottedName -> Node -> String

Unmarshal DottedName

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (DottedName a)

Eq a => Eq (DottedName a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (DottedName a)

Defined in TreeSitter.Python.AST

Methods

compare :: DottedName a -> DottedName a -> Ordering

(<) :: DottedName a -> DottedName a -> Bool

(<=) :: DottedName a -> DottedName a -> Bool

(>) :: DottedName a -> DottedName a -> Bool

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

max :: DottedName a -> DottedName a -> DottedName a

min :: DottedName a -> DottedName a -> DottedName a

Show a => Show (DottedName a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> DottedName a -> ShowS

show :: DottedName a -> String

showList :: [DottedName a] -> ShowS

Generic (DottedName a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (DottedName a) :: Type -> Type

Methods

from :: DottedName a -> Rep (DottedName a) x

to :: Rep (DottedName a) x -> DottedName a

Generic1 DottedName

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 DottedName :: k -> Type

Methods

from1 :: DottedName a -> Rep1 DottedName a

to1 :: Rep1 DottedName a -> DottedName a

type Rep (DottedName a)

Defined in TreeSitter.Python.AST

type Rep (DottedName a) = D1 (MetaData "DottedName" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "DottedName" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (NonEmpty (Identifier a)))))

type Rep1 DottedName

Defined in TreeSitter.Python.AST

type Rep1 DottedName = D1 (MetaData "DottedName" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "DottedName" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (NonEmpty :.: Rec1 Identifier)))

data RelativeImport a

Constructors

RelativeImport

Fields

• ann :: a
• extraChildren :: (NonEmpty ((:+:) DottedName ImportPrefix a))

Instances

Functor RelativeImport

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable RelativeImport

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => RelativeImport m -> m

foldMap :: Monoid m => (a -> m) -> RelativeImport a -> m

foldr :: (a -> b -> b) -> b -> RelativeImport a -> b

foldr' :: (a -> b -> b) -> b -> RelativeImport a -> b

foldl :: (b -> a -> b) -> b -> RelativeImport a -> b

foldl' :: (b -> a -> b) -> b -> RelativeImport a -> b

foldr1 :: (a -> a -> a) -> RelativeImport a -> a

foldl1 :: (a -> a -> a) -> RelativeImport a -> a

toList :: RelativeImport a -> [a]

null :: RelativeImport a -> Bool

length :: RelativeImport a -> Int

elem :: Eq a => a -> RelativeImport a -> Bool

maximum :: Ord a => RelativeImport a -> a

minimum :: Ord a => RelativeImport a -> a

sum :: Num a => RelativeImport a -> a

product :: Num a => RelativeImport a -> a

Traversable RelativeImport

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> RelativeImport a -> f (RelativeImport b)

sequenceA :: Applicative f => RelativeImport (f a) -> f (RelativeImport a)

mapM :: Monad m => (a -> m b) -> RelativeImport a -> m (RelativeImport b)

sequence :: Monad m => RelativeImport (m a) -> m (RelativeImport a)

SymbolMatching RelativeImport

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy RelativeImport -> Node -> Bool

showFailure :: Proxy RelativeImport -> Node -> String

Unmarshal RelativeImport

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (RelativeImport a)

Eq a => Eq (RelativeImport a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (RelativeImport a)

Defined in TreeSitter.Python.AST

Methods

compare :: RelativeImport a -> RelativeImport a -> Ordering

(<) :: RelativeImport a -> RelativeImport a -> Bool

(<=) :: RelativeImport a -> RelativeImport a -> Bool

(>) :: RelativeImport a -> RelativeImport a -> Bool

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

max :: RelativeImport a -> RelativeImport a -> RelativeImport a

min :: RelativeImport a -> RelativeImport a -> RelativeImport a

Show a => Show (RelativeImport a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> RelativeImport a -> ShowS

show :: RelativeImport a -> String

showList :: [RelativeImport a] -> ShowS

Generic (RelativeImport a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (RelativeImport a) :: Type -> Type

Methods

from :: RelativeImport a -> Rep (RelativeImport a) x

to :: Rep (RelativeImport a) x -> RelativeImport a

Generic1 RelativeImport

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 RelativeImport :: k -> Type

Methods

from1 :: RelativeImport a -> Rep1 RelativeImport a

to1 :: Rep1 RelativeImport a -> RelativeImport a

type Rep (RelativeImport a)

Defined in TreeSitter.Python.AST

type Rep (RelativeImport a) = D1 (MetaData "RelativeImport" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "RelativeImport" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (NonEmpty ((DottedName :+: ImportPrefix) a)))))

type Rep1 RelativeImport

Defined in TreeSitter.Python.AST

type Rep1 RelativeImport = D1 (MetaData "RelativeImport" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "RelativeImport" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (NonEmpty :.: Rec1 (DottedName :+: ImportPrefix))))

data AliasedImport a

Constructors

AliasedImport

Fields

• ann :: a
• alias :: (Identifier a)
• name :: (DottedName a)

Instances

Functor AliasedImport

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AliasedImport

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AliasedImport m -> m

foldMap :: Monoid m => (a -> m) -> AliasedImport a -> m

foldr :: (a -> b -> b) -> b -> AliasedImport a -> b

foldr' :: (a -> b -> b) -> b -> AliasedImport a -> b

foldl :: (b -> a -> b) -> b -> AliasedImport a -> b

foldl' :: (b -> a -> b) -> b -> AliasedImport a -> b

foldr1 :: (a -> a -> a) -> AliasedImport a -> a

foldl1 :: (a -> a -> a) -> AliasedImport a -> a

toList :: AliasedImport a -> [a]

null :: AliasedImport a -> Bool

length :: AliasedImport a -> Int

elem :: Eq a => a -> AliasedImport a -> Bool

maximum :: Ord a => AliasedImport a -> a

minimum :: Ord a => AliasedImport a -> a

sum :: Num a => AliasedImport a -> a

product :: Num a => AliasedImport a -> a

Traversable AliasedImport

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AliasedImport a -> f (AliasedImport b)

sequenceA :: Applicative f => AliasedImport (f a) -> f (AliasedImport a)

mapM :: Monad m => (a -> m b) -> AliasedImport a -> m (AliasedImport b)

sequence :: Monad m => AliasedImport (m a) -> m (AliasedImport a)

SymbolMatching AliasedImport

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AliasedImport -> Node -> Bool

showFailure :: Proxy AliasedImport -> Node -> String

Unmarshal AliasedImport

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AliasedImport a)

Eq a => Eq (AliasedImport a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AliasedImport a)

Defined in TreeSitter.Python.AST

Methods

compare :: AliasedImport a -> AliasedImport a -> Ordering

(<) :: AliasedImport a -> AliasedImport a -> Bool

(<=) :: AliasedImport a -> AliasedImport a -> Bool

(>) :: AliasedImport a -> AliasedImport a -> Bool

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

max :: AliasedImport a -> AliasedImport a -> AliasedImport a

min :: AliasedImport a -> AliasedImport a -> AliasedImport a

Show a => Show (AliasedImport a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AliasedImport a -> ShowS

show :: AliasedImport a -> String

showList :: [AliasedImport a] -> ShowS

Generic (AliasedImport a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AliasedImport a) :: Type -> Type

Methods

from :: AliasedImport a -> Rep (AliasedImport a) x

to :: Rep (AliasedImport a) x -> AliasedImport a

Generic1 AliasedImport

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AliasedImport :: k -> Type

Methods

from1 :: AliasedImport a -> Rep1 AliasedImport a

to1 :: Rep1 AliasedImport a -> AliasedImport a

type Rep (AliasedImport a)

Defined in TreeSitter.Python.AST

type Rep (AliasedImport a) = D1 (MetaData "AliasedImport" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "AliasedImport" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: (S1 (MetaSel (Just "alias") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Identifier a)) :*: S1 (MetaSel (Just "name") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (DottedName a)))))

type Rep1 AliasedImport

Defined in TreeSitter.Python.AST

type Rep1 AliasedImport = D1 (MetaData "AliasedImport" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "AliasedImport" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: (S1 (MetaSel (Just "alias") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 Identifier) :*: S1 (MetaSel (Just "name") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 DottedName))))

data ImportStatement a

Constructors

ImportStatement

Fields

• ann :: a
• name :: ([] ((:+:) AliasedImport DottedName a))

Instances

Functor ImportStatement

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable ImportStatement

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => ImportStatement m -> m

foldMap :: Monoid m => (a -> m) -> ImportStatement a -> m

foldr :: (a -> b -> b) -> b -> ImportStatement a -> b

foldr' :: (a -> b -> b) -> b -> ImportStatement a -> b

foldl :: (b -> a -> b) -> b -> ImportStatement a -> b

foldl' :: (b -> a -> b) -> b -> ImportStatement a -> b

foldr1 :: (a -> a -> a) -> ImportStatement a -> a

foldl1 :: (a -> a -> a) -> ImportStatement a -> a

toList :: ImportStatement a -> [a]

null :: ImportStatement a -> Bool

length :: ImportStatement a -> Int

elem :: Eq a => a -> ImportStatement a -> Bool

maximum :: Ord a => ImportStatement a -> a

minimum :: Ord a => ImportStatement a -> a

sum :: Num a => ImportStatement a -> a

product :: Num a => ImportStatement a -> a

Traversable ImportStatement

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> ImportStatement a -> f (ImportStatement b)

sequenceA :: Applicative f => ImportStatement (f a) -> f (ImportStatement a)

mapM :: Monad m => (a -> m b) -> ImportStatement a -> m (ImportStatement b)

sequence :: Monad m => ImportStatement (m a) -> m (ImportStatement a)

SymbolMatching ImportStatement

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy ImportStatement -> Node -> Bool

showFailure :: Proxy ImportStatement -> Node -> String

Unmarshal ImportStatement

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (ImportStatement a)

Eq a => Eq (ImportStatement a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (ImportStatement a)

Defined in TreeSitter.Python.AST

Methods

compare :: ImportStatement a -> ImportStatement a -> Ordering

(<) :: ImportStatement a -> ImportStatement a -> Bool

(<=) :: ImportStatement a -> ImportStatement a -> Bool

(>) :: ImportStatement a -> ImportStatement a -> Bool

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

max :: ImportStatement a -> ImportStatement a -> ImportStatement a

min :: ImportStatement a -> ImportStatement a -> ImportStatement a

Show a => Show (ImportStatement a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> ImportStatement a -> ShowS

show :: ImportStatement a -> String

showList :: [ImportStatement a] -> ShowS

Generic (ImportStatement a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (ImportStatement a) :: Type -> Type

Methods

from :: ImportStatement a -> Rep (ImportStatement a) x

to :: Rep (ImportStatement a) x -> ImportStatement a

Generic1 ImportStatement

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 ImportStatement :: k -> Type

Methods

from1 :: ImportStatement a -> Rep1 ImportStatement a

to1 :: Rep1 ImportStatement a -> ImportStatement a

type Rep (ImportStatement a)

Defined in TreeSitter.Python.AST

type Rep (ImportStatement a) = D1 (MetaData "ImportStatement" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "ImportStatement" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: S1 (MetaSel (Just "name") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [(AliasedImport :+: DottedName) a])))

type Rep1 ImportStatement

Defined in TreeSitter.Python.AST

type Rep1 ImportStatement = D1 (MetaData "ImportStatement" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "ImportStatement" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: S1 (MetaSel (Just "name") NoSourceUnpackedness NoSourceStrictness DecidedLazy) ([] :.: Rec1 (AliasedImport :+: DottedName))))

data ImportFromStatement a

Constructors

ImportFromStatement

Fields

• ann :: a
• name :: ([] ((:+:) AliasedImport DottedName a))
• moduleName :: ((:+:) DottedName RelativeImport a)
• extraChildren :: (NonEmpty (WildcardImport a))

Instances

Functor ImportFromStatement

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable ImportFromStatement

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => ImportFromStatement m -> m

foldMap :: Monoid m => (a -> m) -> ImportFromStatement a -> m

foldr :: (a -> b -> b) -> b -> ImportFromStatement a -> b

foldr' :: (a -> b -> b) -> b -> ImportFromStatement a -> b

foldl :: (b -> a -> b) -> b -> ImportFromStatement a -> b

foldl' :: (b -> a -> b) -> b -> ImportFromStatement a -> b

foldr1 :: (a -> a -> a) -> ImportFromStatement a -> a

foldl1 :: (a -> a -> a) -> ImportFromStatement a -> a

toList :: ImportFromStatement a -> [a]

null :: ImportFromStatement a -> Bool

length :: ImportFromStatement a -> Int

elem :: Eq a => a -> ImportFromStatement a -> Bool

maximum :: Ord a => ImportFromStatement a -> a

minimum :: Ord a => ImportFromStatement a -> a

sum :: Num a => ImportFromStatement a -> a

product :: Num a => ImportFromStatement a -> a

Traversable ImportFromStatement

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> ImportFromStatement a -> f (ImportFromStatement b)

sequenceA :: Applicative f => ImportFromStatement (f a) -> f (ImportFromStatement a)

mapM :: Monad m => (a -> m b) -> ImportFromStatement a -> m (ImportFromStatement b)

sequence :: Monad m => ImportFromStatement (m a) -> m (ImportFromStatement a)

SymbolMatching ImportFromStatement

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy ImportFromStatement -> Node -> Bool

showFailure :: Proxy ImportFromStatement -> Node -> String

Unmarshal ImportFromStatement

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (ImportFromStatement a)

Eq a => Eq (ImportFromStatement a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (ImportFromStatement a)

Defined in TreeSitter.Python.AST

Methods

compare :: ImportFromStatement a -> ImportFromStatement a -> Ordering

(<) :: ImportFromStatement a -> ImportFromStatement a -> Bool

(<=) :: ImportFromStatement a -> ImportFromStatement a -> Bool

(>) :: ImportFromStatement a -> ImportFromStatement a -> Bool

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

max :: ImportFromStatement a -> ImportFromStatement a -> ImportFromStatement a

min :: ImportFromStatement a -> ImportFromStatement a -> ImportFromStatement a

Show a => Show (ImportFromStatement a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> ImportFromStatement a -> ShowS

show :: ImportFromStatement a -> String

showList :: [ImportFromStatement a] -> ShowS

Generic (ImportFromStatement a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (ImportFromStatement a) :: Type -> Type

Methods

from :: ImportFromStatement a -> Rep (ImportFromStatement a) x

to :: Rep (ImportFromStatement a) x -> ImportFromStatement a

Generic1 ImportFromStatement

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 ImportFromStatement :: k -> Type

Methods

from1 :: ImportFromStatement a -> Rep1 ImportFromStatement a

to1 :: Rep1 ImportFromStatement a -> ImportFromStatement a

type Rep (ImportFromStatement a)

Defined in TreeSitter.Python.AST

type Rep (ImportFromStatement a) = D1 (MetaData "ImportFromStatement" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "ImportFromStatement" PrefixI True) ((S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: S1 (MetaSel (Just "name") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [(AliasedImport :+: DottedName) a])) :*: (S1 (MetaSel (Just "moduleName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ((DottedName :+: RelativeImport) a)) :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (NonEmpty (WildcardImport a))))))

type Rep1 ImportFromStatement

Defined in TreeSitter.Python.AST

type Rep1 ImportFromStatement = D1 (MetaData "ImportFromStatement" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "ImportFromStatement" PrefixI True) ((S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: S1 (MetaSel (Just "name") NoSourceUnpackedness NoSourceStrictness DecidedLazy) ([] :.: Rec1 (AliasedImport :+: DottedName))) :*: (S1 (MetaSel (Just "moduleName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 (DottedName :+: RelativeImport)) :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (NonEmpty :.: Rec1 WildcardImport))))

data FutureImportStatement a

Constructors

FutureImportStatement

Fields

• ann :: a
• name :: ([] ((:+:) AliasedImport DottedName a))

Instances

Functor FutureImportStatement

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable FutureImportStatement

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => FutureImportStatement m -> m

foldMap :: Monoid m => (a -> m) -> FutureImportStatement a -> m

foldr :: (a -> b -> b) -> b -> FutureImportStatement a -> b

foldr' :: (a -> b -> b) -> b -> FutureImportStatement a -> b

foldl :: (b -> a -> b) -> b -> FutureImportStatement a -> b

foldl' :: (b -> a -> b) -> b -> FutureImportStatement a -> b

foldr1 :: (a -> a -> a) -> FutureImportStatement a -> a

foldl1 :: (a -> a -> a) -> FutureImportStatement a -> a

toList :: FutureImportStatement a -> [a]

null :: FutureImportStatement a -> Bool

length :: FutureImportStatement a -> Int

elem :: Eq a => a -> FutureImportStatement a -> Bool

maximum :: Ord a => FutureImportStatement a -> a

minimum :: Ord a => FutureImportStatement a -> a

sum :: Num a => FutureImportStatement a -> a

product :: Num a => FutureImportStatement a -> a

Traversable FutureImportStatement

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> FutureImportStatement a -> f (FutureImportStatement b)

sequenceA :: Applicative f => FutureImportStatement (f a) -> f (FutureImportStatement a)

mapM :: Monad m => (a -> m b) -> FutureImportStatement a -> m (FutureImportStatement b)

sequence :: Monad m => FutureImportStatement (m a) -> m (FutureImportStatement a)

SymbolMatching FutureImportStatement

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy FutureImportStatement -> Node -> Bool

showFailure :: Proxy FutureImportStatement -> Node -> String

Unmarshal FutureImportStatement

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (FutureImportStatement a)

Eq a => Eq (FutureImportStatement a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (FutureImportStatement a)

Defined in TreeSitter.Python.AST

Methods

compare :: FutureImportStatement a -> FutureImportStatement a -> Ordering

(<) :: FutureImportStatement a -> FutureImportStatement a -> Bool

(<=) :: FutureImportStatement a -> FutureImportStatement a -> Bool

(>) :: FutureImportStatement a -> FutureImportStatement a -> Bool

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

max :: FutureImportStatement a -> FutureImportStatement a -> FutureImportStatement a

min :: FutureImportStatement a -> FutureImportStatement a -> FutureImportStatement a

Show a => Show (FutureImportStatement a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> FutureImportStatement a -> ShowS

show :: FutureImportStatement a -> String

showList :: [FutureImportStatement a] -> ShowS

Generic (FutureImportStatement a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (FutureImportStatement a) :: Type -> Type

Methods

from :: FutureImportStatement a -> Rep (FutureImportStatement a) x

to :: Rep (FutureImportStatement a) x -> FutureImportStatement a

Generic1 FutureImportStatement

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 FutureImportStatement :: k -> Type

Methods

from1 :: FutureImportStatement a -> Rep1 FutureImportStatement a

to1 :: Rep1 FutureImportStatement a -> FutureImportStatement a

type Rep (FutureImportStatement a)

Defined in TreeSitter.Python.AST

type Rep (FutureImportStatement a) = D1 (MetaData "FutureImportStatement" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "FutureImportStatement" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: S1 (MetaSel (Just "name") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [(AliasedImport :+: DottedName) a])))

type Rep1 FutureImportStatement

Defined in TreeSitter.Python.AST

type Rep1 FutureImportStatement = D1 (MetaData "FutureImportStatement" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "FutureImportStatement" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: S1 (MetaSel (Just "name") NoSourceUnpackedness NoSourceStrictness DecidedLazy) ([] :.: Rec1 (AliasedImport :+: DottedName))))

data True a

Constructors

True

Fields

• ann :: a
• bytes :: Text

Instances

Functor True

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable True

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => True m -> m

foldMap :: Monoid m => (a -> m) -> True a -> m

foldr :: (a -> b -> b) -> b -> True a -> b

foldr' :: (a -> b -> b) -> b -> True a -> b

foldl :: (b -> a -> b) -> b -> True a -> b

foldl' :: (b -> a -> b) -> b -> True a -> b

foldr1 :: (a -> a -> a) -> True a -> a

foldl1 :: (a -> a -> a) -> True a -> a

toList :: True a -> [a]

null :: True a -> Bool

length :: True a -> Int

elem :: Eq a => a -> True a -> Bool

maximum :: Ord a => True a -> a

minimum :: Ord a => True a -> a

sum :: Num a => True a -> a

product :: Num a => True a -> a

Traversable True

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> True a -> f (True b)

sequenceA :: Applicative f => True (f a) -> f (True a)

mapM :: Monad m => (a -> m b) -> True a -> m (True b)

sequence :: Monad m => True (m a) -> m (True a)

SymbolMatching True

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy True -> Node -> Bool

showFailure :: Proxy True -> Node -> String

Unmarshal True

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (True a)

Eq a => Eq (True a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (True a)

Defined in TreeSitter.Python.AST

Methods

compare :: True a -> True a -> Ordering

(<) :: True a -> True a -> Bool

(<=) :: True a -> True a -> Bool

(>) :: True a -> True a -> Bool

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

max :: True a -> True a -> True a

min :: True a -> True a -> True a

Show a => Show (True a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> True a -> ShowS

show :: True a -> String

showList :: [True a] -> ShowS

Generic (True a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (True a) :: Type -> Type

Methods

from :: True a -> Rep (True a) x

to :: Rep (True a) x -> True a

Generic1 True

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 True :: k -> Type

Methods

from1 :: True a -> Rep1 True a

to1 :: Rep1 True a -> True a

type Rep (True a)

Defined in TreeSitter.Python.AST

type Rep (True a) = D1 (MetaData "True" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "True" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: S1 (MetaSel (Just "bytes") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Text)))

type Rep1 True

Defined in TreeSitter.Python.AST

type Rep1 True = D1 (MetaData "True" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "True" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: S1 (MetaSel (Just "bytes") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Text)))

data False a

Constructors

False

Fields

• ann :: a
• bytes :: Text

Instances

Functor False

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable False

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => False m -> m

foldMap :: Monoid m => (a -> m) -> False a -> m

foldr :: (a -> b -> b) -> b -> False a -> b

foldr' :: (a -> b -> b) -> b -> False a -> b

foldl :: (b -> a -> b) -> b -> False a -> b

foldl' :: (b -> a -> b) -> b -> False a -> b

foldr1 :: (a -> a -> a) -> False a -> a

foldl1 :: (a -> a -> a) -> False a -> a

toList :: False a -> [a]

null :: False a -> Bool

length :: False a -> Int

elem :: Eq a => a -> False a -> Bool

maximum :: Ord a => False a -> a

minimum :: Ord a => False a -> a

sum :: Num a => False a -> a

product :: Num a => False a -> a

Traversable False

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> False a -> f (False b)

sequenceA :: Applicative f => False (f a) -> f (False a)

mapM :: Monad m => (a -> m b) -> False a -> m (False b)

sequence :: Monad m => False (m a) -> m (False a)

SymbolMatching False

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy False -> Node -> Bool

showFailure :: Proxy False -> Node -> String

Unmarshal False

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (False a)

Eq a => Eq (False a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (False a)

Defined in TreeSitter.Python.AST

Methods

compare :: False a -> False a -> Ordering

(<) :: False a -> False a -> Bool

(<=) :: False a -> False a -> Bool

(>) :: False a -> False a -> Bool

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

max :: False a -> False a -> False a

min :: False a -> False a -> False a

Show a => Show (False a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> False a -> ShowS

show :: False a -> String

showList :: [False a] -> ShowS

Generic (False a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (False a) :: Type -> Type

Methods

from :: False a -> Rep (False a) x

to :: Rep (False a) x -> False a

Generic1 False

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 False :: k -> Type

Methods

from1 :: False a -> Rep1 False a

to1 :: Rep1 False a -> False a

type Rep (False a)

Defined in TreeSitter.Python.AST

type Rep (False a) = D1 (MetaData "False" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "False" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: S1 (MetaSel (Just "bytes") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Text)))

type Rep1 False

Defined in TreeSitter.Python.AST

type Rep1 False = D1 (MetaData "False" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "False" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: S1 (MetaSel (Just "bytes") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Text)))

data None a

Constructors

None

Fields

• ann :: a
• bytes :: Text

Instances

Functor None

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable None

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => None m -> m

foldMap :: Monoid m => (a -> m) -> None a -> m

foldr :: (a -> b -> b) -> b -> None a -> b

foldr' :: (a -> b -> b) -> b -> None a -> b

foldl :: (b -> a -> b) -> b -> None a -> b

foldl' :: (b -> a -> b) -> b -> None a -> b

foldr1 :: (a -> a -> a) -> None a -> a

foldl1 :: (a -> a -> a) -> None a -> a

toList :: None a -> [a]

null :: None a -> Bool

length :: None a -> Int

elem :: Eq a => a -> None a -> Bool

maximum :: Ord a => None a -> a

minimum :: Ord a => None a -> a

sum :: Num a => None a -> a

product :: Num a => None a -> a

Traversable None

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> None a -> f (None b)

sequenceA :: Applicative f => None (f a) -> f (None a)

mapM :: Monad m => (a -> m b) -> None a -> m (None b)

sequence :: Monad m => None (m a) -> m (None a)

SymbolMatching None

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy None -> Node -> Bool

showFailure :: Proxy None -> Node -> String

Unmarshal None

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (None a)

Eq a => Eq (None a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (None a)

Defined in TreeSitter.Python.AST

Methods

compare :: None a -> None a -> Ordering

(<) :: None a -> None a -> Bool

(<=) :: None a -> None a -> Bool

(>) :: None a -> None a -> Bool

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

max :: None a -> None a -> None a

min :: None a -> None a -> None a

Show a => Show (None a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> None a -> ShowS

show :: None a -> String

showList :: [None a] -> ShowS

Generic (None a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (None a) :: Type -> Type

Methods

from :: None a -> Rep (None a) x

to :: Rep (None a) x -> None a

Generic1 None

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 None :: k -> Type

Methods

from1 :: None a -> Rep1 None a

to1 :: Rep1 None a -> None a

type Rep (None a)

Defined in TreeSitter.Python.AST

type Rep (None a) = D1 (MetaData "None" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "None" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: S1 (MetaSel (Just "bytes") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Text)))

type Rep1 None

Defined in TreeSitter.Python.AST

type Rep1 None = D1 (MetaData "None" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "None" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: S1 (MetaSel (Just "bytes") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Text)))

data PrimaryExpression a

Constructors

AttributePrimaryExpression (Attribute a)

BinaryOperatorPrimaryExpression (BinaryOperator a)

CallPrimaryExpression (Call a)

ConcatenatedStringPrimaryExpression (ConcatenatedString a)

DictionaryPrimaryExpression (Dictionary a)

DictionaryComprehensionPrimaryExpression (DictionaryComprehension a)

EllipsisPrimaryExpression (Ellipsis a)

FalsePrimaryExpression (False a)

FloatPrimaryExpression (Float a)

GeneratorExpressionPrimaryExpression (GeneratorExpression a)

IdentifierPrimaryExpression (Identifier a)

IntegerPrimaryExpression (Integer a)

ListPrimaryExpression (List a)

ListComprehensionPrimaryExpression (ListComprehension a)

NonePrimaryExpression (None a)

ParenthesizedExpressionPrimaryExpression (ParenthesizedExpression a)

SetPrimaryExpression (Set a)

SetComprehensionPrimaryExpression (SetComprehension a)

StringPrimaryExpression (String a)

SubscriptPrimaryExpression (Subscript a)

TruePrimaryExpression (True a)

TuplePrimaryExpression (Tuple a)

UnaryOperatorPrimaryExpression (UnaryOperator a)

Instances

Functor PrimaryExpression

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable PrimaryExpression

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => PrimaryExpression m -> m

foldMap :: Monoid m => (a -> m) -> PrimaryExpression a -> m

foldr :: (a -> b -> b) -> b -> PrimaryExpression a -> b

foldr' :: (a -> b -> b) -> b -> PrimaryExpression a -> b

foldl :: (b -> a -> b) -> b -> PrimaryExpression a -> b

foldl' :: (b -> a -> b) -> b -> PrimaryExpression a -> b

foldr1 :: (a -> a -> a) -> PrimaryExpression a -> a

foldl1 :: (a -> a -> a) -> PrimaryExpression a -> a

toList :: PrimaryExpression a -> [a]

null :: PrimaryExpression a -> Bool

length :: PrimaryExpression a -> Int

elem :: Eq a => a -> PrimaryExpression a -> Bool

maximum :: Ord a => PrimaryExpression a -> a

minimum :: Ord a => PrimaryExpression a -> a

sum :: Num a => PrimaryExpression a -> a

product :: Num a => PrimaryExpression a -> a

Traversable PrimaryExpression

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> PrimaryExpression a -> f (PrimaryExpression b)

sequenceA :: Applicative f => PrimaryExpression (f a) -> f (PrimaryExpression a)

mapM :: Monad m => (a -> m b) -> PrimaryExpression a -> m (PrimaryExpression b)

sequence :: Monad m => PrimaryExpression (m a) -> m (PrimaryExpression a)

SymbolMatching PrimaryExpression

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy PrimaryExpression -> Node -> Bool

showFailure :: Proxy PrimaryExpression -> Node -> String

Unmarshal PrimaryExpression

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (PrimaryExpression a)

Eq a => Eq (PrimaryExpression a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (PrimaryExpression a)

Defined in TreeSitter.Python.AST

Methods

compare :: PrimaryExpression a -> PrimaryExpression a -> Ordering

(<) :: PrimaryExpression a -> PrimaryExpression a -> Bool

(<=) :: PrimaryExpression a -> PrimaryExpression a -> Bool

(>) :: PrimaryExpression a -> PrimaryExpression a -> Bool

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

max :: PrimaryExpression a -> PrimaryExpression a -> PrimaryExpression a

min :: PrimaryExpression a -> PrimaryExpression a -> PrimaryExpression a

Show a => Show (PrimaryExpression a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> PrimaryExpression a -> ShowS

show :: PrimaryExpression a -> String

showList :: [PrimaryExpression a] -> ShowS

Generic (PrimaryExpression a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (PrimaryExpression a) :: Type -> Type

Methods

from :: PrimaryExpression a -> Rep (PrimaryExpression a) x

to :: Rep (PrimaryExpression a) x -> PrimaryExpression a

Generic1 PrimaryExpression

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 PrimaryExpression :: k -> Type

Methods

from1 :: PrimaryExpression a -> Rep1 PrimaryExpression a

to1 :: Rep1 PrimaryExpression a -> PrimaryExpression a

type Rep (PrimaryExpression a)

Defined in TreeSitter.Python.AST

type Rep (PrimaryExpression a) = D1 (MetaData "PrimaryExpression" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) ((((C1 (MetaCons "AttributePrimaryExpression" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Attribute a))) :+: C1 (MetaCons "BinaryOperatorPrimaryExpression" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (BinaryOperator a)))) :+: (C1 (MetaCons "CallPrimaryExpression" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Call a))) :+: (C1 (MetaCons "ConcatenatedStringPrimaryExpression" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (ConcatenatedString a))) :+: C1 (MetaCons "DictionaryPrimaryExpression" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Dictionary a)))))) :+: ((C1 (MetaCons "DictionaryComprehensionPrimaryExpression" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (DictionaryComprehension a))) :+: (C1 (MetaCons "EllipsisPrimaryExpression" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ellipsis a))) :+: C1 (MetaCons "FalsePrimaryExpression" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (False a))))) :+: (C1 (MetaCons "FloatPrimaryExpression" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Float a))) :+: (C1 (MetaCons "GeneratorExpressionPrimaryExpression" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (GeneratorExpression a))) :+: C1 (MetaCons "IdentifierPrimaryExpression" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Identifier a))))))) :+: (((C1 (MetaCons "IntegerPrimaryExpression" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Integer a))) :+: (C1 (MetaCons "ListPrimaryExpression" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (List a))) :+: C1 (MetaCons "ListComprehensionPrimaryExpression" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (ListComprehension a))))) :+: (C1 (MetaCons "NonePrimaryExpression" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (None a))) :+: (C1 (MetaCons "ParenthesizedExpressionPrimaryExpression" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (ParenthesizedExpression a))) :+: C1 (MetaCons "SetPrimaryExpression" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Set a)))))) :+: ((C1 (MetaCons "SetComprehensionPrimaryExpression" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (SetComprehension a))) :+: (C1 (MetaCons "StringPrimaryExpression" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (String a))) :+: C1 (MetaCons "SubscriptPrimaryExpression" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Subscript a))))) :+: (C1 (MetaCons "TruePrimaryExpression" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (True a))) :+: (C1 (MetaCons "TuplePrimaryExpression" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Tuple a))) :+: C1 (MetaCons "UnaryOperatorPrimaryExpression" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (UnaryOperator a))))))))

type Rep1 PrimaryExpression

Defined in TreeSitter.Python.AST

type Rep1 PrimaryExpression = D1 (MetaData "PrimaryExpression" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) ((((C1 (MetaCons "AttributePrimaryExpression" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 Attribute)) :+: C1 (MetaCons "BinaryOperatorPrimaryExpression" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 BinaryOperator))) :+: (C1 (MetaCons "CallPrimaryExpression" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 Call)) :+: (C1 (MetaCons "ConcatenatedStringPrimaryExpression" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 ConcatenatedString)) :+: C1 (MetaCons "DictionaryPrimaryExpression" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 Dictionary))))) :+: ((C1 (MetaCons "DictionaryComprehensionPrimaryExpression" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 DictionaryComprehension)) :+: (C1 (MetaCons "EllipsisPrimaryExpression" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 Ellipsis)) :+: C1 (MetaCons "FalsePrimaryExpression" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 False)))) :+: (C1 (MetaCons "FloatPrimaryExpression" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 Float)) :+: (C1 (MetaCons "GeneratorExpressionPrimaryExpression" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 GeneratorExpression)) :+: C1 (MetaCons "IdentifierPrimaryExpression" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 Identifier)))))) :+: (((C1 (MetaCons "IntegerPrimaryExpression" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 Integer)) :+: (C1 (MetaCons "ListPrimaryExpression" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 List)) :+: C1 (MetaCons "ListComprehensionPrimaryExpression" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 ListComprehension)))) :+: (C1 (MetaCons "NonePrimaryExpression" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 None)) :+: (C1 (MetaCons "ParenthesizedExpressionPrimaryExpression" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 ParenthesizedExpression)) :+: C1 (MetaCons "SetPrimaryExpression" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 Set))))) :+: ((C1 (MetaCons "SetComprehensionPrimaryExpression" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 SetComprehension)) :+: (C1 (MetaCons "StringPrimaryExpression" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 String)) :+: C1 (MetaCons "SubscriptPrimaryExpression" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 Subscript)))) :+: (C1 (MetaCons "TruePrimaryExpression" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 True)) :+: (C1 (MetaCons "TuplePrimaryExpression" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 Tuple)) :+: C1 (MetaCons "UnaryOperatorPrimaryExpression" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 UnaryOperator)))))))

data UnaryOperator a

Constructors

UnaryOperator

Fields

• ann :: a
• operator :: ((:+:) AnonymousPlus ((:+:) AnonymousMinus AnonymousTilde) a)
• argument :: (PrimaryExpression a)

Instances

Functor UnaryOperator

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable UnaryOperator

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => UnaryOperator m -> m

foldMap :: Monoid m => (a -> m) -> UnaryOperator a -> m

foldr :: (a -> b -> b) -> b -> UnaryOperator a -> b

foldr' :: (a -> b -> b) -> b -> UnaryOperator a -> b

foldl :: (b -> a -> b) -> b -> UnaryOperator a -> b

foldl' :: (b -> a -> b) -> b -> UnaryOperator a -> b

foldr1 :: (a -> a -> a) -> UnaryOperator a -> a

foldl1 :: (a -> a -> a) -> UnaryOperator a -> a

toList :: UnaryOperator a -> [a]

null :: UnaryOperator a -> Bool

length :: UnaryOperator a -> Int

elem :: Eq a => a -> UnaryOperator a -> Bool

maximum :: Ord a => UnaryOperator a -> a

minimum :: Ord a => UnaryOperator a -> a

sum :: Num a => UnaryOperator a -> a

product :: Num a => UnaryOperator a -> a

Traversable UnaryOperator

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> UnaryOperator a -> f (UnaryOperator b)

sequenceA :: Applicative f => UnaryOperator (f a) -> f (UnaryOperator a)

mapM :: Monad m => (a -> m b) -> UnaryOperator a -> m (UnaryOperator b)

sequence :: Monad m => UnaryOperator (m a) -> m (UnaryOperator a)

SymbolMatching UnaryOperator

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy UnaryOperator -> Node -> Bool

showFailure :: Proxy UnaryOperator -> Node -> String

Unmarshal UnaryOperator

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (UnaryOperator a)

Eq a => Eq (UnaryOperator a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (UnaryOperator a)

Defined in TreeSitter.Python.AST

Methods

compare :: UnaryOperator a -> UnaryOperator a -> Ordering

(<) :: UnaryOperator a -> UnaryOperator a -> Bool

(<=) :: UnaryOperator a -> UnaryOperator a -> Bool

(>) :: UnaryOperator a -> UnaryOperator a -> Bool

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

max :: UnaryOperator a -> UnaryOperator a -> UnaryOperator a

min :: UnaryOperator a -> UnaryOperator a -> UnaryOperator a

Show a => Show (UnaryOperator a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> UnaryOperator a -> ShowS

show :: UnaryOperator a -> String

showList :: [UnaryOperator a] -> ShowS

Generic (UnaryOperator a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (UnaryOperator a) :: Type -> Type

Methods

from :: UnaryOperator a -> Rep (UnaryOperator a) x

to :: Rep (UnaryOperator a) x -> UnaryOperator a

Generic1 UnaryOperator

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 UnaryOperator :: k -> Type

Methods

from1 :: UnaryOperator a -> Rep1 UnaryOperator a

to1 :: Rep1 UnaryOperator a -> UnaryOperator a

type Rep (UnaryOperator a)

Defined in TreeSitter.Python.AST

type Rep (UnaryOperator a) = D1 (MetaData "UnaryOperator" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "UnaryOperator" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: (S1 (MetaSel (Just "operator") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ((AnonymousPlus :+: (AnonymousMinus :+: AnonymousTilde)) a)) :*: S1 (MetaSel (Just "argument") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (PrimaryExpression a)))))

type Rep1 UnaryOperator

Defined in TreeSitter.Python.AST

type Rep1 UnaryOperator = D1 (MetaData "UnaryOperator" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "UnaryOperator" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: (S1 (MetaSel (Just "operator") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 (AnonymousPlus :+: (AnonymousMinus :+: AnonymousTilde))) :*: S1 (MetaSel (Just "argument") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 PrimaryExpression))))

data Tuple a

Constructors

Tuple

Fields

• ann :: a
• extraChildren :: ([] ((:+:) Expression Yield a))

Instances

Functor Tuple

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable Tuple

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => Tuple m -> m

foldMap :: Monoid m => (a -> m) -> Tuple a -> m

foldr :: (a -> b -> b) -> b -> Tuple a -> b

foldr' :: (a -> b -> b) -> b -> Tuple a -> b

foldl :: (b -> a -> b) -> b -> Tuple a -> b

foldl' :: (b -> a -> b) -> b -> Tuple a -> b

foldr1 :: (a -> a -> a) -> Tuple a -> a

foldl1 :: (a -> a -> a) -> Tuple a -> a

toList :: Tuple a -> [a]

null :: Tuple a -> Bool

length :: Tuple a -> Int

elem :: Eq a => a -> Tuple a -> Bool

maximum :: Ord a => Tuple a -> a

minimum :: Ord a => Tuple a -> a

sum :: Num a => Tuple a -> a

product :: Num a => Tuple a -> a

Traversable Tuple

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> Tuple a -> f (Tuple b)

sequenceA :: Applicative f => Tuple (f a) -> f (Tuple a)

mapM :: Monad m => (a -> m b) -> Tuple a -> m (Tuple b)

sequence :: Monad m => Tuple (m a) -> m (Tuple a)

SymbolMatching Tuple

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy Tuple -> Node -> Bool

showFailure :: Proxy Tuple -> Node -> String

Unmarshal Tuple

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Tuple a)

Eq a => Eq (Tuple a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (Tuple a)

Defined in TreeSitter.Python.AST

Methods

compare :: Tuple a -> Tuple a -> Ordering

(<) :: Tuple a -> Tuple a -> Bool

(<=) :: Tuple a -> Tuple a -> Bool

(>) :: Tuple a -> Tuple a -> Bool

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

max :: Tuple a -> Tuple a -> Tuple a

min :: Tuple a -> Tuple a -> Tuple a

Show a => Show (Tuple a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> Tuple a -> ShowS

show :: Tuple a -> String

showList :: [Tuple a] -> ShowS

Generic (Tuple a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (Tuple a) :: Type -> Type

Methods

from :: Tuple a -> Rep (Tuple a) x

to :: Rep (Tuple a) x -> Tuple a

Generic1 Tuple

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 Tuple :: k -> Type

Methods

from1 :: Tuple a -> Rep1 Tuple a

to1 :: Rep1 Tuple a -> Tuple a

type Rep (Tuple a)

Defined in TreeSitter.Python.AST

type Rep (Tuple a) = D1 (MetaData "Tuple" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "Tuple" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [(Expression :+: Yield) a])))

type Rep1 Tuple

Defined in TreeSitter.Python.AST

type Rep1 Tuple = D1 (MetaData "Tuple" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "Tuple" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) ([] :.: Rec1 (Expression :+: Yield))))

data Yield a

Constructors

Yield

Fields

• ann :: a
• extraChildren :: (Maybe ((:+:) Expression ExpressionList a))

Instances

Functor Yield

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable Yield

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => Yield m -> m

foldMap :: Monoid m => (a -> m) -> Yield a -> m

foldr :: (a -> b -> b) -> b -> Yield a -> b

foldr' :: (a -> b -> b) -> b -> Yield a -> b

foldl :: (b -> a -> b) -> b -> Yield a -> b

foldl' :: (b -> a -> b) -> b -> Yield a -> b

foldr1 :: (a -> a -> a) -> Yield a -> a

foldl1 :: (a -> a -> a) -> Yield a -> a

toList :: Yield a -> [a]

null :: Yield a -> Bool

length :: Yield a -> Int

elem :: Eq a => a -> Yield a -> Bool

maximum :: Ord a => Yield a -> a

minimum :: Ord a => Yield a -> a

sum :: Num a => Yield a -> a

product :: Num a => Yield a -> a

Traversable Yield

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> Yield a -> f (Yield b)

sequenceA :: Applicative f => Yield (f a) -> f (Yield a)

mapM :: Monad m => (a -> m b) -> Yield a -> m (Yield b)

sequence :: Monad m => Yield (m a) -> m (Yield a)

SymbolMatching Yield

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy Yield -> Node -> Bool

showFailure :: Proxy Yield -> Node -> String

Unmarshal Yield

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Yield a)

Eq a => Eq (Yield a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (Yield a)

Defined in TreeSitter.Python.AST

Methods

compare :: Yield a -> Yield a -> Ordering

(<) :: Yield a -> Yield a -> Bool

(<=) :: Yield a -> Yield a -> Bool

(>) :: Yield a -> Yield a -> Bool

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

max :: Yield a -> Yield a -> Yield a

min :: Yield a -> Yield a -> Yield a

Show a => Show (Yield a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> Yield a -> ShowS

show :: Yield a -> String

showList :: [Yield a] -> ShowS

Generic (Yield a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (Yield a) :: Type -> Type

Methods

from :: Yield a -> Rep (Yield a) x

to :: Rep (Yield a) x -> Yield a

Generic1 Yield

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 Yield :: k -> Type

Methods

from1 :: Yield a -> Rep1 Yield a

to1 :: Rep1 Yield a -> Yield a

type Rep (Yield a)

Defined in TreeSitter.Python.AST

type Rep (Yield a) = D1 (MetaData "Yield" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "Yield" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe ((Expression :+: ExpressionList) a)))))

type Rep1 Yield

Defined in TreeSitter.Python.AST

type Rep1 Yield = D1 (MetaData "Yield" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "Yield" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Maybe :.: Rec1 (Expression :+: ExpressionList))))

data ExpressionList a

Constructors

ExpressionList

Fields

• ann :: a
• extraChildren :: (NonEmpty (Expression a))

Instances

Functor ExpressionList

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable ExpressionList

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => ExpressionList m -> m

foldMap :: Monoid m => (a -> m) -> ExpressionList a -> m

foldr :: (a -> b -> b) -> b -> ExpressionList a -> b

foldr' :: (a -> b -> b) -> b -> ExpressionList a -> b

foldl :: (b -> a -> b) -> b -> ExpressionList a -> b

foldl' :: (b -> a -> b) -> b -> ExpressionList a -> b

foldr1 :: (a -> a -> a) -> ExpressionList a -> a

foldl1 :: (a -> a -> a) -> ExpressionList a -> a

toList :: ExpressionList a -> [a]

null :: ExpressionList a -> Bool

length :: ExpressionList a -> Int

elem :: Eq a => a -> ExpressionList a -> Bool

maximum :: Ord a => ExpressionList a -> a

minimum :: Ord a => ExpressionList a -> a

sum :: Num a => ExpressionList a -> a

product :: Num a => ExpressionList a -> a

Traversable ExpressionList

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> ExpressionList a -> f (ExpressionList b)

sequenceA :: Applicative f => ExpressionList (f a) -> f (ExpressionList a)

mapM :: Monad m => (a -> m b) -> ExpressionList a -> m (ExpressionList b)

sequence :: Monad m => ExpressionList (m a) -> m (ExpressionList a)

SymbolMatching ExpressionList

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy ExpressionList -> Node -> Bool

showFailure :: Proxy ExpressionList -> Node -> String

Unmarshal ExpressionList

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (ExpressionList a)

Eq a => Eq (ExpressionList a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (ExpressionList a)

Defined in TreeSitter.Python.AST

Methods

compare :: ExpressionList a -> ExpressionList a -> Ordering

(<) :: ExpressionList a -> ExpressionList a -> Bool

(<=) :: ExpressionList a -> ExpressionList a -> Bool

(>) :: ExpressionList a -> ExpressionList a -> Bool

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

max :: ExpressionList a -> ExpressionList a -> ExpressionList a

min :: ExpressionList a -> ExpressionList a -> ExpressionList a

Show a => Show (ExpressionList a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> ExpressionList a -> ShowS

show :: ExpressionList a -> String

showList :: [ExpressionList a] -> ShowS

Generic (ExpressionList a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (ExpressionList a) :: Type -> Type

Methods

from :: ExpressionList a -> Rep (ExpressionList a) x

to :: Rep (ExpressionList a) x -> ExpressionList a

Generic1 ExpressionList

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 ExpressionList :: k -> Type

Methods

from1 :: ExpressionList a -> Rep1 ExpressionList a

to1 :: Rep1 ExpressionList a -> ExpressionList a

type Rep (ExpressionList a)

Defined in TreeSitter.Python.AST

type Rep (ExpressionList a) = D1 (MetaData "ExpressionList" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "ExpressionList" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (NonEmpty (Expression a)))))

type Rep1 ExpressionList

Defined in TreeSitter.Python.AST

type Rep1 ExpressionList = D1 (MetaData "ExpressionList" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "ExpressionList" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (NonEmpty :.: Rec1 Expression)))

data Expression a

Constructors

PrimaryExpressionExpression (PrimaryExpression a)

AwaitExpression (Await a)

BooleanOperatorExpression (BooleanOperator a)

ComparisonOperatorExpression (ComparisonOperator a)

ConditionalExpressionExpression (ConditionalExpression a)

LambdaExpression (Lambda a)

NamedExpressionExpression (NamedExpression a)

NotOperatorExpression (NotOperator a)

Instances

Functor Expression

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable Expression

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => Expression m -> m

foldMap :: Monoid m => (a -> m) -> Expression a -> m

foldr :: (a -> b -> b) -> b -> Expression a -> b

foldr' :: (a -> b -> b) -> b -> Expression a -> b

foldl :: (b -> a -> b) -> b -> Expression a -> b

foldl' :: (b -> a -> b) -> b -> Expression a -> b

foldr1 :: (a -> a -> a) -> Expression a -> a

foldl1 :: (a -> a -> a) -> Expression a -> a

toList :: Expression a -> [a]

null :: Expression a -> Bool

length :: Expression a -> Int

elem :: Eq a => a -> Expression a -> Bool

maximum :: Ord a => Expression a -> a

minimum :: Ord a => Expression a -> a

sum :: Num a => Expression a -> a

product :: Num a => Expression a -> a

Traversable Expression

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> Expression a -> f (Expression b)

sequenceA :: Applicative f => Expression (f a) -> f (Expression a)

mapM :: Monad m => (a -> m b) -> Expression a -> m (Expression b)

sequence :: Monad m => Expression (m a) -> m (Expression a)

SymbolMatching Expression

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy Expression -> Node -> Bool

showFailure :: Proxy Expression -> Node -> String

Unmarshal Expression

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Expression a)

Eq a => Eq (Expression a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (Expression a)

Defined in TreeSitter.Python.AST

Methods

compare :: Expression a -> Expression a -> Ordering

(<) :: Expression a -> Expression a -> Bool

(<=) :: Expression a -> Expression a -> Bool

(>) :: Expression a -> Expression a -> Bool

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

max :: Expression a -> Expression a -> Expression a

min :: Expression a -> Expression a -> Expression a

Show a => Show (Expression a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> Expression a -> ShowS

show :: Expression a -> String

showList :: [Expression a] -> ShowS

Generic (Expression a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (Expression a) :: Type -> Type

Methods

from :: Expression a -> Rep (Expression a) x

to :: Rep (Expression a) x -> Expression a

Generic1 Expression

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 Expression :: k -> Type

Methods

from1 :: Expression a -> Rep1 Expression a

to1 :: Rep1 Expression a -> Expression a

type Rep (Expression a)

Defined in TreeSitter.Python.AST

type Rep (Expression a) = D1 (MetaData "Expression" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (((C1 (MetaCons "PrimaryExpressionExpression" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (PrimaryExpression a))) :+: C1 (MetaCons "AwaitExpression" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Await a)))) :+: (C1 (MetaCons "BooleanOperatorExpression" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (BooleanOperator a))) :+: C1 (MetaCons "ComparisonOperatorExpression" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (ComparisonOperator a))))) :+: ((C1 (MetaCons "ConditionalExpressionExpression" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (ConditionalExpression a))) :+: C1 (MetaCons "LambdaExpression" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Lambda a)))) :+: (C1 (MetaCons "NamedExpressionExpression" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (NamedExpression a))) :+: C1 (MetaCons "NotOperatorExpression" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (NotOperator a))))))

type Rep1 Expression

Defined in TreeSitter.Python.AST

type Rep1 Expression = D1 (MetaData "Expression" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (((C1 (MetaCons "PrimaryExpressionExpression" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 PrimaryExpression)) :+: C1 (MetaCons "AwaitExpression" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 Await))) :+: (C1 (MetaCons "BooleanOperatorExpression" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 BooleanOperator)) :+: C1 (MetaCons "ComparisonOperatorExpression" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 ComparisonOperator)))) :+: ((C1 (MetaCons "ConditionalExpressionExpression" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 ConditionalExpression)) :+: C1 (MetaCons "LambdaExpression" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 Lambda))) :+: (C1 (MetaCons "NamedExpressionExpression" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 NamedExpression)) :+: C1 (MetaCons "NotOperatorExpression" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 NotOperator)))))

data NotOperator a

Constructors

NotOperator

Fields

• ann :: a
• argument :: (Expression a)

Instances

Functor NotOperator

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable NotOperator

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => NotOperator m -> m

foldMap :: Monoid m => (a -> m) -> NotOperator a -> m

foldr :: (a -> b -> b) -> b -> NotOperator a -> b

foldr' :: (a -> b -> b) -> b -> NotOperator a -> b

foldl :: (b -> a -> b) -> b -> NotOperator a -> b

foldl' :: (b -> a -> b) -> b -> NotOperator a -> b

foldr1 :: (a -> a -> a) -> NotOperator a -> a

foldl1 :: (a -> a -> a) -> NotOperator a -> a

toList :: NotOperator a -> [a]

null :: NotOperator a -> Bool

length :: NotOperator a -> Int

elem :: Eq a => a -> NotOperator a -> Bool

maximum :: Ord a => NotOperator a -> a

minimum :: Ord a => NotOperator a -> a

sum :: Num a => NotOperator a -> a

product :: Num a => NotOperator a -> a

Traversable NotOperator

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> NotOperator a -> f (NotOperator b)

sequenceA :: Applicative f => NotOperator (f a) -> f (NotOperator a)

mapM :: Monad m => (a -> m b) -> NotOperator a -> m (NotOperator b)

sequence :: Monad m => NotOperator (m a) -> m (NotOperator a)

SymbolMatching NotOperator

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy NotOperator -> Node -> Bool

showFailure :: Proxy NotOperator -> Node -> String

Unmarshal NotOperator

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (NotOperator a)

Eq a => Eq (NotOperator a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (NotOperator a)

Defined in TreeSitter.Python.AST

Methods

compare :: NotOperator a -> NotOperator a -> Ordering

(<) :: NotOperator a -> NotOperator a -> Bool

(<=) :: NotOperator a -> NotOperator a -> Bool

(>) :: NotOperator a -> NotOperator a -> Bool

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

max :: NotOperator a -> NotOperator a -> NotOperator a

min :: NotOperator a -> NotOperator a -> NotOperator a

Show a => Show (NotOperator a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> NotOperator a -> ShowS

show :: NotOperator a -> String

showList :: [NotOperator a] -> ShowS

Generic (NotOperator a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (NotOperator a) :: Type -> Type

Methods

from :: NotOperator a -> Rep (NotOperator a) x

to :: Rep (NotOperator a) x -> NotOperator a

Generic1 NotOperator

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 NotOperator :: k -> Type

Methods

from1 :: NotOperator a -> Rep1 NotOperator a

to1 :: Rep1 NotOperator a -> NotOperator a

type Rep (NotOperator a)

Defined in TreeSitter.Python.AST

type Rep (NotOperator a) = D1 (MetaData "NotOperator" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "NotOperator" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: S1 (MetaSel (Just "argument") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Expression a))))

type Rep1 NotOperator

Defined in TreeSitter.Python.AST

type Rep1 NotOperator = D1 (MetaData "NotOperator" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "NotOperator" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: S1 (MetaSel (Just "argument") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 Expression)))

data NamedExpression a

Constructors

NamedExpression

Fields

• ann :: a
• value :: (Expression a)
• name :: (Identifier a)

Instances

Functor NamedExpression

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable NamedExpression

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => NamedExpression m -> m

foldMap :: Monoid m => (a -> m) -> NamedExpression a -> m

foldr :: (a -> b -> b) -> b -> NamedExpression a -> b

foldr' :: (a -> b -> b) -> b -> NamedExpression a -> b

foldl :: (b -> a -> b) -> b -> NamedExpression a -> b

foldl' :: (b -> a -> b) -> b -> NamedExpression a -> b

foldr1 :: (a -> a -> a) -> NamedExpression a -> a

foldl1 :: (a -> a -> a) -> NamedExpression a -> a

toList :: NamedExpression a -> [a]

null :: NamedExpression a -> Bool

length :: NamedExpression a -> Int

elem :: Eq a => a -> NamedExpression a -> Bool

maximum :: Ord a => NamedExpression a -> a

minimum :: Ord a => NamedExpression a -> a

sum :: Num a => NamedExpression a -> a

product :: Num a => NamedExpression a -> a

Traversable NamedExpression

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> NamedExpression a -> f (NamedExpression b)

sequenceA :: Applicative f => NamedExpression (f a) -> f (NamedExpression a)

mapM :: Monad m => (a -> m b) -> NamedExpression a -> m (NamedExpression b)

sequence :: Monad m => NamedExpression (m a) -> m (NamedExpression a)

SymbolMatching NamedExpression

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy NamedExpression -> Node -> Bool

showFailure :: Proxy NamedExpression -> Node -> String

Unmarshal NamedExpression

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (NamedExpression a)

Eq a => Eq (NamedExpression a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (NamedExpression a)

Defined in TreeSitter.Python.AST

Methods

compare :: NamedExpression a -> NamedExpression a -> Ordering

(<) :: NamedExpression a -> NamedExpression a -> Bool

(<=) :: NamedExpression a -> NamedExpression a -> Bool

(>) :: NamedExpression a -> NamedExpression a -> Bool

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

max :: NamedExpression a -> NamedExpression a -> NamedExpression a

min :: NamedExpression a -> NamedExpression a -> NamedExpression a

Show a => Show (NamedExpression a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> NamedExpression a -> ShowS

show :: NamedExpression a -> String

showList :: [NamedExpression a] -> ShowS

Generic (NamedExpression a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (NamedExpression a) :: Type -> Type

Methods

from :: NamedExpression a -> Rep (NamedExpression a) x

to :: Rep (NamedExpression a) x -> NamedExpression a

Generic1 NamedExpression

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 NamedExpression :: k -> Type

Methods

from1 :: NamedExpression a -> Rep1 NamedExpression a

to1 :: Rep1 NamedExpression a -> NamedExpression a

type Rep (NamedExpression a)

Defined in TreeSitter.Python.AST

type Rep (NamedExpression a) = D1 (MetaData "NamedExpression" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "NamedExpression" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: (S1 (MetaSel (Just "value") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Expression a)) :*: S1 (MetaSel (Just "name") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Identifier a)))))

type Rep1 NamedExpression

Defined in TreeSitter.Python.AST

type Rep1 NamedExpression = D1 (MetaData "NamedExpression" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "NamedExpression" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: (S1 (MetaSel (Just "value") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 Expression) :*: S1 (MetaSel (Just "name") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 Identifier))))

data Lambda a

Constructors

Lambda

Fields

• ann :: a
• body :: ((:+:) Expression Lambda a)
• parameters :: (Maybe (LambdaParameters a))

Instances

Functor Lambda

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable Lambda

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => Lambda m -> m

foldMap :: Monoid m => (a -> m) -> Lambda a -> m

foldr :: (a -> b -> b) -> b -> Lambda a -> b

foldr' :: (a -> b -> b) -> b -> Lambda a -> b

foldl :: (b -> a -> b) -> b -> Lambda a -> b

foldl' :: (b -> a -> b) -> b -> Lambda a -> b

foldr1 :: (a -> a -> a) -> Lambda a -> a

foldl1 :: (a -> a -> a) -> Lambda a -> a

toList :: Lambda a -> [a]

null :: Lambda a -> Bool

length :: Lambda a -> Int

elem :: Eq a => a -> Lambda a -> Bool

maximum :: Ord a => Lambda a -> a

minimum :: Ord a => Lambda a -> a

sum :: Num a => Lambda a -> a

product :: Num a => Lambda a -> a

Traversable Lambda

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> Lambda a -> f (Lambda b)

sequenceA :: Applicative f => Lambda (f a) -> f (Lambda a)

mapM :: Monad m => (a -> m b) -> Lambda a -> m (Lambda b)

sequence :: Monad m => Lambda (m a) -> m (Lambda a)

SymbolMatching Lambda

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy Lambda -> Node -> Bool

showFailure :: Proxy Lambda -> Node -> String

Unmarshal Lambda

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Lambda a)

Eq a => Eq (Lambda a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (Lambda a)

Defined in TreeSitter.Python.AST

Methods

compare :: Lambda a -> Lambda a -> Ordering

(<) :: Lambda a -> Lambda a -> Bool

(<=) :: Lambda a -> Lambda a -> Bool

(>) :: Lambda a -> Lambda a -> Bool

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

max :: Lambda a -> Lambda a -> Lambda a

min :: Lambda a -> Lambda a -> Lambda a

Show a => Show (Lambda a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> Lambda a -> ShowS

show :: Lambda a -> String

showList :: [Lambda a] -> ShowS

Generic (Lambda a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (Lambda a) :: Type -> Type

Methods

from :: Lambda a -> Rep (Lambda a) x

to :: Rep (Lambda a) x -> Lambda a

Generic1 Lambda

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 Lambda :: k -> Type

Methods

from1 :: Lambda a -> Rep1 Lambda a

to1 :: Rep1 Lambda a -> Lambda a

type Rep (Lambda a)

Defined in TreeSitter.Python.AST

type Rep (Lambda a) = D1 (MetaData "Lambda" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "Lambda" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: (S1 (MetaSel (Just "body") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ((Expression :+: Lambda) a)) :*: S1 (MetaSel (Just "parameters") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (LambdaParameters a))))))

type Rep1 Lambda

Defined in TreeSitter.Python.AST

type Rep1 Lambda = D1 (MetaData "Lambda" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "Lambda" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: (S1 (MetaSel (Just "body") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 (Expression :+: Lambda)) :*: S1 (MetaSel (Just "parameters") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Maybe :.: Rec1 LambdaParameters))))

data LambdaParameters a

Constructors

LambdaParameters

Fields

• ann :: a
• extraChildren :: (NonEmpty (Parameter a))

Instances

Functor LambdaParameters

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable LambdaParameters

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => LambdaParameters m -> m

foldMap :: Monoid m => (a -> m) -> LambdaParameters a -> m

foldr :: (a -> b -> b) -> b -> LambdaParameters a -> b

foldr' :: (a -> b -> b) -> b -> LambdaParameters a -> b

foldl :: (b -> a -> b) -> b -> LambdaParameters a -> b

foldl' :: (b -> a -> b) -> b -> LambdaParameters a -> b

foldr1 :: (a -> a -> a) -> LambdaParameters a -> a

foldl1 :: (a -> a -> a) -> LambdaParameters a -> a

toList :: LambdaParameters a -> [a]

null :: LambdaParameters a -> Bool

length :: LambdaParameters a -> Int

elem :: Eq a => a -> LambdaParameters a -> Bool

maximum :: Ord a => LambdaParameters a -> a

minimum :: Ord a => LambdaParameters a -> a

sum :: Num a => LambdaParameters a -> a

product :: Num a => LambdaParameters a -> a

Traversable LambdaParameters

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> LambdaParameters a -> f (LambdaParameters b)

sequenceA :: Applicative f => LambdaParameters (f a) -> f (LambdaParameters a)

mapM :: Monad m => (a -> m b) -> LambdaParameters a -> m (LambdaParameters b)

sequence :: Monad m => LambdaParameters (m a) -> m (LambdaParameters a)

SymbolMatching LambdaParameters

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy LambdaParameters -> Node -> Bool

showFailure :: Proxy LambdaParameters -> Node -> String

Unmarshal LambdaParameters

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (LambdaParameters a)

Eq a => Eq (LambdaParameters a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (LambdaParameters a)

Defined in TreeSitter.Python.AST

Methods

compare :: LambdaParameters a -> LambdaParameters a -> Ordering

(<) :: LambdaParameters a -> LambdaParameters a -> Bool

(<=) :: LambdaParameters a -> LambdaParameters a -> Bool

(>) :: LambdaParameters a -> LambdaParameters a -> Bool

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

max :: LambdaParameters a -> LambdaParameters a -> LambdaParameters a

min :: LambdaParameters a -> LambdaParameters a -> LambdaParameters a

Show a => Show (LambdaParameters a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> LambdaParameters a -> ShowS

show :: LambdaParameters a -> String

showList :: [LambdaParameters a] -> ShowS

Generic (LambdaParameters a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (LambdaParameters a) :: Type -> Type

Methods

from :: LambdaParameters a -> Rep (LambdaParameters a) x

to :: Rep (LambdaParameters a) x -> LambdaParameters a

Generic1 LambdaParameters

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 LambdaParameters :: k -> Type

Methods

from1 :: LambdaParameters a -> Rep1 LambdaParameters a

to1 :: Rep1 LambdaParameters a -> LambdaParameters a

type Rep (LambdaParameters a)

Defined in TreeSitter.Python.AST

type Rep (LambdaParameters a) = D1 (MetaData "LambdaParameters" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "LambdaParameters" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (NonEmpty (Parameter a)))))

type Rep1 LambdaParameters

Defined in TreeSitter.Python.AST

type Rep1 LambdaParameters = D1 (MetaData "LambdaParameters" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "LambdaParameters" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (NonEmpty :.: Rec1 Parameter)))

data Parameter a

Constructors

DefaultParameterParameter (DefaultParameter a)

DictionarySplatParameter (DictionarySplat a)

IdentifierParameter (Identifier a)

ListSplatParameter (ListSplat a)

TupleParameter (Tuple a)

TypedDefaultParameterParameter (TypedDefaultParameter a)

TypedParameterParameter (TypedParameter a)

Instances

Functor Parameter

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable Parameter

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => Parameter m -> m

foldMap :: Monoid m => (a -> m) -> Parameter a -> m

foldr :: (a -> b -> b) -> b -> Parameter a -> b

foldr' :: (a -> b -> b) -> b -> Parameter a -> b

foldl :: (b -> a -> b) -> b -> Parameter a -> b

foldl' :: (b -> a -> b) -> b -> Parameter a -> b

foldr1 :: (a -> a -> a) -> Parameter a -> a

foldl1 :: (a -> a -> a) -> Parameter a -> a

toList :: Parameter a -> [a]

null :: Parameter a -> Bool

length :: Parameter a -> Int

elem :: Eq a => a -> Parameter a -> Bool

maximum :: Ord a => Parameter a -> a

minimum :: Ord a => Parameter a -> a

sum :: Num a => Parameter a -> a

product :: Num a => Parameter a -> a

Traversable Parameter

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> Parameter a -> f (Parameter b)

sequenceA :: Applicative f => Parameter (f a) -> f (Parameter a)

mapM :: Monad m => (a -> m b) -> Parameter a -> m (Parameter b)

sequence :: Monad m => Parameter (m a) -> m (Parameter a)

SymbolMatching Parameter

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy Parameter -> Node -> Bool

showFailure :: Proxy Parameter -> Node -> String

Unmarshal Parameter

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Parameter a)

Eq a => Eq (Parameter a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (Parameter a)

Defined in TreeSitter.Python.AST

Methods

compare :: Parameter a -> Parameter a -> Ordering

(<) :: Parameter a -> Parameter a -> Bool

(<=) :: Parameter a -> Parameter a -> Bool

(>) :: Parameter a -> Parameter a -> Bool

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

max :: Parameter a -> Parameter a -> Parameter a

min :: Parameter a -> Parameter a -> Parameter a

Show a => Show (Parameter a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> Parameter a -> ShowS

show :: Parameter a -> String

showList :: [Parameter a] -> ShowS

Generic (Parameter a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (Parameter a) :: Type -> Type

Methods

from :: Parameter a -> Rep (Parameter a) x

to :: Rep (Parameter a) x -> Parameter a

Generic1 Parameter

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 Parameter :: k -> Type

Methods

from1 :: Parameter a -> Rep1 Parameter a

to1 :: Rep1 Parameter a -> Parameter a

type Rep (Parameter a)

Defined in TreeSitter.Python.AST

type Rep (Parameter a) = D1 (MetaData "Parameter" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) ((C1 (MetaCons "DefaultParameterParameter" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (DefaultParameter a))) :+: (C1 (MetaCons "DictionarySplatParameter" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (DictionarySplat a))) :+: C1 (MetaCons "IdentifierParameter" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Identifier a))))) :+: ((C1 (MetaCons "ListSplatParameter" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (ListSplat a))) :+: C1 (MetaCons "TupleParameter" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Tuple a)))) :+: (C1 (MetaCons "TypedDefaultParameterParameter" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (TypedDefaultParameter a))) :+: C1 (MetaCons "TypedParameterParameter" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (TypedParameter a))))))

type Rep1 Parameter

Defined in TreeSitter.Python.AST

type Rep1 Parameter = D1 (MetaData "Parameter" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) ((C1 (MetaCons "DefaultParameterParameter" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 DefaultParameter)) :+: (C1 (MetaCons "DictionarySplatParameter" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 DictionarySplat)) :+: C1 (MetaCons "IdentifierParameter" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 Identifier)))) :+: ((C1 (MetaCons "ListSplatParameter" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 ListSplat)) :+: C1 (MetaCons "TupleParameter" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 Tuple))) :+: (C1 (MetaCons "TypedDefaultParameterParameter" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 TypedDefaultParameter)) :+: C1 (MetaCons "TypedParameterParameter" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 TypedParameter)))))

data TypedParameter a

Constructors

TypedParameter

Fields

• ann :: a
• type' :: (Type a)
• extraChildren :: ((:+:) DictionarySplat ((:+:) Identifier ListSplat) a)

Instances

Functor TypedParameter

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable TypedParameter

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => TypedParameter m -> m

foldMap :: Monoid m => (a -> m) -> TypedParameter a -> m

foldr :: (a -> b -> b) -> b -> TypedParameter a -> b

foldr' :: (a -> b -> b) -> b -> TypedParameter a -> b

foldl :: (b -> a -> b) -> b -> TypedParameter a -> b

foldl' :: (b -> a -> b) -> b -> TypedParameter a -> b

foldr1 :: (a -> a -> a) -> TypedParameter a -> a

foldl1 :: (a -> a -> a) -> TypedParameter a -> a

toList :: TypedParameter a -> [a]

null :: TypedParameter a -> Bool

length :: TypedParameter a -> Int

elem :: Eq a => a -> TypedParameter a -> Bool

maximum :: Ord a => TypedParameter a -> a

minimum :: Ord a => TypedParameter a -> a

sum :: Num a => TypedParameter a -> a

product :: Num a => TypedParameter a -> a

Traversable TypedParameter

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> TypedParameter a -> f (TypedParameter b)

sequenceA :: Applicative f => TypedParameter (f a) -> f (TypedParameter a)

mapM :: Monad m => (a -> m b) -> TypedParameter a -> m (TypedParameter b)

sequence :: Monad m => TypedParameter (m a) -> m (TypedParameter a)

SymbolMatching TypedParameter

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy TypedParameter -> Node -> Bool

showFailure :: Proxy TypedParameter -> Node -> String

Unmarshal TypedParameter

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (TypedParameter a)

Eq a => Eq (TypedParameter a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (TypedParameter a)

Defined in TreeSitter.Python.AST

Methods

compare :: TypedParameter a -> TypedParameter a -> Ordering

(<) :: TypedParameter a -> TypedParameter a -> Bool

(<=) :: TypedParameter a -> TypedParameter a -> Bool

(>) :: TypedParameter a -> TypedParameter a -> Bool

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

max :: TypedParameter a -> TypedParameter a -> TypedParameter a

min :: TypedParameter a -> TypedParameter a -> TypedParameter a

Show a => Show (TypedParameter a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> TypedParameter a -> ShowS

show :: TypedParameter a -> String

showList :: [TypedParameter a] -> ShowS

Generic (TypedParameter a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (TypedParameter a) :: Type -> Type

Methods

from :: TypedParameter a -> Rep (TypedParameter a) x

to :: Rep (TypedParameter a) x -> TypedParameter a

Generic1 TypedParameter

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 TypedParameter :: k -> Type

Methods

from1 :: TypedParameter a -> Rep1 TypedParameter a

to1 :: Rep1 TypedParameter a -> TypedParameter a

type Rep (TypedParameter a)

Defined in TreeSitter.Python.AST

type Rep (TypedParameter a) = D1 (MetaData "TypedParameter" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "TypedParameter" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: (S1 (MetaSel (Just "type'") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type a)) :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ((DictionarySplat :+: (Identifier :+: ListSplat)) a)))))

type Rep1 TypedParameter

Defined in TreeSitter.Python.AST

type Rep1 TypedParameter = D1 (MetaData "TypedParameter" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "TypedParameter" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: (S1 (MetaSel (Just "type'") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 Type) :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 (DictionarySplat :+: (Identifier :+: ListSplat))))))

data Type a

Constructors

Type

Fields

• ann :: a
• extraChildren :: (Expression a)

Instances

Functor Type

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable Type

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => Type m -> m

foldMap :: Monoid m => (a -> m) -> Type a -> m

foldr :: (a -> b -> b) -> b -> Type a -> b

foldr' :: (a -> b -> b) -> b -> Type a -> b

foldl :: (b -> a -> b) -> b -> Type a -> b

foldl' :: (b -> a -> b) -> b -> Type a -> b

foldr1 :: (a -> a -> a) -> Type a -> a

foldl1 :: (a -> a -> a) -> Type a -> a

toList :: Type a -> [a]

null :: Type a -> Bool

length :: Type a -> Int

elem :: Eq a => a -> Type a -> Bool

maximum :: Ord a => Type a -> a

minimum :: Ord a => Type a -> a

sum :: Num a => Type a -> a

product :: Num a => Type a -> a

Traversable Type

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> Type a -> f (Type b)

sequenceA :: Applicative f => Type (f a) -> f (Type a)

mapM :: Monad m => (a -> m b) -> Type a -> m (Type b)

sequence :: Monad m => Type (m a) -> m (Type a)

SymbolMatching Type

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy Type -> Node -> Bool

showFailure :: Proxy Type -> Node -> String

Unmarshal Type

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Type a)

Eq a => Eq (Type a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (Type a)

Defined in TreeSitter.Python.AST

Methods

compare :: Type a -> Type a -> Ordering

(<) :: Type a -> Type a -> Bool

(<=) :: Type a -> Type a -> Bool

(>) :: Type a -> Type a -> Bool

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

max :: Type a -> Type a -> Type a

min :: Type a -> Type a -> Type a

Show a => Show (Type a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> Type a -> ShowS

show :: Type a -> String

showList :: [Type a] -> ShowS

Generic (Type a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (Type a) :: Type -> Type

Methods

from :: Type a -> Rep (Type a) x

to :: Rep (Type a) x -> Type a

Generic1 Type

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 Type :: k -> Type

Methods

from1 :: Type a -> Rep1 Type a

to1 :: Rep1 Type a -> Type a

type Rep (Type a)

Defined in TreeSitter.Python.AST

type Rep (Type a) = D1 (MetaData "Type" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "Type" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Expression a))))

type Rep1 Type

Defined in TreeSitter.Python.AST

type Rep1 Type = D1 (MetaData "Type" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "Type" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 Expression)))

data ListSplat a

Constructors

ListSplat

Fields

• ann :: a
• extraChildren :: (Maybe (Expression a))

Instances

Functor ListSplat

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable ListSplat

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => ListSplat m -> m

foldMap :: Monoid m => (a -> m) -> ListSplat a -> m

foldr :: (a -> b -> b) -> b -> ListSplat a -> b

foldr' :: (a -> b -> b) -> b -> ListSplat a -> b

foldl :: (b -> a -> b) -> b -> ListSplat a -> b

foldl' :: (b -> a -> b) -> b -> ListSplat a -> b

foldr1 :: (a -> a -> a) -> ListSplat a -> a

foldl1 :: (a -> a -> a) -> ListSplat a -> a

toList :: ListSplat a -> [a]

null :: ListSplat a -> Bool

length :: ListSplat a -> Int

elem :: Eq a => a -> ListSplat a -> Bool

maximum :: Ord a => ListSplat a -> a

minimum :: Ord a => ListSplat a -> a

sum :: Num a => ListSplat a -> a

product :: Num a => ListSplat a -> a

Traversable ListSplat

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> ListSplat a -> f (ListSplat b)

sequenceA :: Applicative f => ListSplat (f a) -> f (ListSplat a)

mapM :: Monad m => (a -> m b) -> ListSplat a -> m (ListSplat b)

sequence :: Monad m => ListSplat (m a) -> m (ListSplat a)

SymbolMatching ListSplat

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy ListSplat -> Node -> Bool

showFailure :: Proxy ListSplat -> Node -> String

Unmarshal ListSplat

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (ListSplat a)

Eq a => Eq (ListSplat a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (ListSplat a)

Defined in TreeSitter.Python.AST

Methods

compare :: ListSplat a -> ListSplat a -> Ordering

(<) :: ListSplat a -> ListSplat a -> Bool

(<=) :: ListSplat a -> ListSplat a -> Bool

(>) :: ListSplat a -> ListSplat a -> Bool

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

max :: ListSplat a -> ListSplat a -> ListSplat a

min :: ListSplat a -> ListSplat a -> ListSplat a

Show a => Show (ListSplat a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> ListSplat a -> ShowS

show :: ListSplat a -> String

showList :: [ListSplat a] -> ShowS

Generic (ListSplat a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (ListSplat a) :: Type -> Type

Methods

from :: ListSplat a -> Rep (ListSplat a) x

to :: Rep (ListSplat a) x -> ListSplat a

Generic1 ListSplat

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 ListSplat :: k -> Type

Methods

from1 :: ListSplat a -> Rep1 ListSplat a

to1 :: Rep1 ListSplat a -> ListSplat a

type Rep (ListSplat a)

Defined in TreeSitter.Python.AST

type Rep (ListSplat a) = D1 (MetaData "ListSplat" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "ListSplat" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Expression a)))))

type Rep1 ListSplat

Defined in TreeSitter.Python.AST

type Rep1 ListSplat = D1 (MetaData "ListSplat" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "ListSplat" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Maybe :.: Rec1 Expression)))

data DictionarySplat a

Constructors

DictionarySplat

Fields

• ann :: a
• extraChildren :: (Expression a)

Instances

Functor DictionarySplat

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable DictionarySplat

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => DictionarySplat m -> m

foldMap :: Monoid m => (a -> m) -> DictionarySplat a -> m

foldr :: (a -> b -> b) -> b -> DictionarySplat a -> b

foldr' :: (a -> b -> b) -> b -> DictionarySplat a -> b

foldl :: (b -> a -> b) -> b -> DictionarySplat a -> b

foldl' :: (b -> a -> b) -> b -> DictionarySplat a -> b

foldr1 :: (a -> a -> a) -> DictionarySplat a -> a

foldl1 :: (a -> a -> a) -> DictionarySplat a -> a

toList :: DictionarySplat a -> [a]

null :: DictionarySplat a -> Bool

length :: DictionarySplat a -> Int

elem :: Eq a => a -> DictionarySplat a -> Bool

maximum :: Ord a => DictionarySplat a -> a

minimum :: Ord a => DictionarySplat a -> a

sum :: Num a => DictionarySplat a -> a

product :: Num a => DictionarySplat a -> a

Traversable DictionarySplat

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> DictionarySplat a -> f (DictionarySplat b)

sequenceA :: Applicative f => DictionarySplat (f a) -> f (DictionarySplat a)

mapM :: Monad m => (a -> m b) -> DictionarySplat a -> m (DictionarySplat b)

sequence :: Monad m => DictionarySplat (m a) -> m (DictionarySplat a)

SymbolMatching DictionarySplat

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy DictionarySplat -> Node -> Bool

showFailure :: Proxy DictionarySplat -> Node -> String

Unmarshal DictionarySplat

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (DictionarySplat a)

Eq a => Eq (DictionarySplat a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (DictionarySplat a)

Defined in TreeSitter.Python.AST

Methods

compare :: DictionarySplat a -> DictionarySplat a -> Ordering

(<) :: DictionarySplat a -> DictionarySplat a -> Bool

(<=) :: DictionarySplat a -> DictionarySplat a -> Bool

(>) :: DictionarySplat a -> DictionarySplat a -> Bool

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

max :: DictionarySplat a -> DictionarySplat a -> DictionarySplat a

min :: DictionarySplat a -> DictionarySplat a -> DictionarySplat a

Show a => Show (DictionarySplat a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> DictionarySplat a -> ShowS

show :: DictionarySplat a -> String

showList :: [DictionarySplat a] -> ShowS

Generic (DictionarySplat a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (DictionarySplat a) :: Type -> Type

Methods

from :: DictionarySplat a -> Rep (DictionarySplat a) x

to :: Rep (DictionarySplat a) x -> DictionarySplat a

Generic1 DictionarySplat

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 DictionarySplat :: k -> Type

Methods

from1 :: DictionarySplat a -> Rep1 DictionarySplat a

to1 :: Rep1 DictionarySplat a -> DictionarySplat a

type Rep (DictionarySplat a)

Defined in TreeSitter.Python.AST

type Rep (DictionarySplat a) = D1 (MetaData "DictionarySplat" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "DictionarySplat" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Expression a))))

type Rep1 DictionarySplat

Defined in TreeSitter.Python.AST

type Rep1 DictionarySplat = D1 (MetaData "DictionarySplat" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "DictionarySplat" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 Expression)))

data TypedDefaultParameter a

Constructors

TypedDefaultParameter

Fields

• ann :: a
• value :: (Expression a)
• name :: (Identifier a)
• type' :: (Type a)

Instances

Functor TypedDefaultParameter

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable TypedDefaultParameter

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => TypedDefaultParameter m -> m

foldMap :: Monoid m => (a -> m) -> TypedDefaultParameter a -> m

foldr :: (a -> b -> b) -> b -> TypedDefaultParameter a -> b

foldr' :: (a -> b -> b) -> b -> TypedDefaultParameter a -> b

foldl :: (b -> a -> b) -> b -> TypedDefaultParameter a -> b

foldl' :: (b -> a -> b) -> b -> TypedDefaultParameter a -> b

foldr1 :: (a -> a -> a) -> TypedDefaultParameter a -> a

foldl1 :: (a -> a -> a) -> TypedDefaultParameter a -> a

toList :: TypedDefaultParameter a -> [a]

null :: TypedDefaultParameter a -> Bool

length :: TypedDefaultParameter a -> Int

elem :: Eq a => a -> TypedDefaultParameter a -> Bool

maximum :: Ord a => TypedDefaultParameter a -> a

minimum :: Ord a => TypedDefaultParameter a -> a

sum :: Num a => TypedDefaultParameter a -> a

product :: Num a => TypedDefaultParameter a -> a

Traversable TypedDefaultParameter

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> TypedDefaultParameter a -> f (TypedDefaultParameter b)

sequenceA :: Applicative f => TypedDefaultParameter (f a) -> f (TypedDefaultParameter a)

mapM :: Monad m => (a -> m b) -> TypedDefaultParameter a -> m (TypedDefaultParameter b)

sequence :: Monad m => TypedDefaultParameter (m a) -> m (TypedDefaultParameter a)

SymbolMatching TypedDefaultParameter

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy TypedDefaultParameter -> Node -> Bool

showFailure :: Proxy TypedDefaultParameter -> Node -> String

Unmarshal TypedDefaultParameter

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (TypedDefaultParameter a)

Eq a => Eq (TypedDefaultParameter a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (TypedDefaultParameter a)

Defined in TreeSitter.Python.AST

Methods

compare :: TypedDefaultParameter a -> TypedDefaultParameter a -> Ordering

(<) :: TypedDefaultParameter a -> TypedDefaultParameter a -> Bool

(<=) :: TypedDefaultParameter a -> TypedDefaultParameter a -> Bool

(>) :: TypedDefaultParameter a -> TypedDefaultParameter a -> Bool

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

max :: TypedDefaultParameter a -> TypedDefaultParameter a -> TypedDefaultParameter a

min :: TypedDefaultParameter a -> TypedDefaultParameter a -> TypedDefaultParameter a

Show a => Show (TypedDefaultParameter a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> TypedDefaultParameter a -> ShowS

show :: TypedDefaultParameter a -> String

showList :: [TypedDefaultParameter a] -> ShowS

Generic (TypedDefaultParameter a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (TypedDefaultParameter a) :: Type -> Type

Methods

from :: TypedDefaultParameter a -> Rep (TypedDefaultParameter a) x

to :: Rep (TypedDefaultParameter a) x -> TypedDefaultParameter a

Generic1 TypedDefaultParameter

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 TypedDefaultParameter :: k -> Type

Methods

from1 :: TypedDefaultParameter a -> Rep1 TypedDefaultParameter a

to1 :: Rep1 TypedDefaultParameter a -> TypedDefaultParameter a

type Rep (TypedDefaultParameter a)

Defined in TreeSitter.Python.AST

type Rep (TypedDefaultParameter a) = D1 (MetaData "TypedDefaultParameter" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "TypedDefaultParameter" PrefixI True) ((S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: S1 (MetaSel (Just "value") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Expression a))) :*: (S1 (MetaSel (Just "name") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Identifier a)) :*: S1 (MetaSel (Just "type'") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type a)))))

type Rep1 TypedDefaultParameter

Defined in TreeSitter.Python.AST

type Rep1 TypedDefaultParameter = D1 (MetaData "TypedDefaultParameter" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "TypedDefaultParameter" PrefixI True) ((S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: S1 (MetaSel (Just "value") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 Expression)) :*: (S1 (MetaSel (Just "name") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 Identifier) :*: S1 (MetaSel (Just "type'") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 Type))))

data DefaultParameter a

Constructors

DefaultParameter

Fields

• ann :: a
• value :: (Expression a)
• name :: (Identifier a)

Instances

Functor DefaultParameter

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable DefaultParameter

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => DefaultParameter m -> m

foldMap :: Monoid m => (a -> m) -> DefaultParameter a -> m

foldr :: (a -> b -> b) -> b -> DefaultParameter a -> b

foldr' :: (a -> b -> b) -> b -> DefaultParameter a -> b

foldl :: (b -> a -> b) -> b -> DefaultParameter a -> b

foldl' :: (b -> a -> b) -> b -> DefaultParameter a -> b

foldr1 :: (a -> a -> a) -> DefaultParameter a -> a

foldl1 :: (a -> a -> a) -> DefaultParameter a -> a

toList :: DefaultParameter a -> [a]

null :: DefaultParameter a -> Bool

length :: DefaultParameter a -> Int

elem :: Eq a => a -> DefaultParameter a -> Bool

maximum :: Ord a => DefaultParameter a -> a

minimum :: Ord a => DefaultParameter a -> a

sum :: Num a => DefaultParameter a -> a

product :: Num a => DefaultParameter a -> a

Traversable DefaultParameter

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> DefaultParameter a -> f (DefaultParameter b)

sequenceA :: Applicative f => DefaultParameter (f a) -> f (DefaultParameter a)

mapM :: Monad m => (a -> m b) -> DefaultParameter a -> m (DefaultParameter b)

sequence :: Monad m => DefaultParameter (m a) -> m (DefaultParameter a)

SymbolMatching DefaultParameter

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy DefaultParameter -> Node -> Bool

showFailure :: Proxy DefaultParameter -> Node -> String

Unmarshal DefaultParameter

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (DefaultParameter a)

Eq a => Eq (DefaultParameter a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (DefaultParameter a)

Defined in TreeSitter.Python.AST

Methods

compare :: DefaultParameter a -> DefaultParameter a -> Ordering

(<) :: DefaultParameter a -> DefaultParameter a -> Bool

(<=) :: DefaultParameter a -> DefaultParameter a -> Bool

(>) :: DefaultParameter a -> DefaultParameter a -> Bool

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

max :: DefaultParameter a -> DefaultParameter a -> DefaultParameter a

min :: DefaultParameter a -> DefaultParameter a -> DefaultParameter a

Show a => Show (DefaultParameter a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> DefaultParameter a -> ShowS

show :: DefaultParameter a -> String

showList :: [DefaultParameter a] -> ShowS

Generic (DefaultParameter a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (DefaultParameter a) :: Type -> Type

Methods

from :: DefaultParameter a -> Rep (DefaultParameter a) x

to :: Rep (DefaultParameter a) x -> DefaultParameter a

Generic1 DefaultParameter

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 DefaultParameter :: k -> Type

Methods

from1 :: DefaultParameter a -> Rep1 DefaultParameter a

to1 :: Rep1 DefaultParameter a -> DefaultParameter a

type Rep (DefaultParameter a)

Defined in TreeSitter.Python.AST

type Rep (DefaultParameter a) = D1 (MetaData "DefaultParameter" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "DefaultParameter" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: (S1 (MetaSel (Just "value") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Expression a)) :*: S1 (MetaSel (Just "name") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Identifier a)))))

type Rep1 DefaultParameter

Defined in TreeSitter.Python.AST

type Rep1 DefaultParameter = D1 (MetaData "DefaultParameter" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "DefaultParameter" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: (S1 (MetaSel (Just "value") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 Expression) :*: S1 (MetaSel (Just "name") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 Identifier))))

data ConditionalExpression a

Constructors

ConditionalExpression

Fields

• ann :: a
• extraChildren :: (NonEmpty (Expression a))

Instances

Functor ConditionalExpression

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable ConditionalExpression

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => ConditionalExpression m -> m

foldMap :: Monoid m => (a -> m) -> ConditionalExpression a -> m

foldr :: (a -> b -> b) -> b -> ConditionalExpression a -> b

foldr' :: (a -> b -> b) -> b -> ConditionalExpression a -> b

foldl :: (b -> a -> b) -> b -> ConditionalExpression a -> b

foldl' :: (b -> a -> b) -> b -> ConditionalExpression a -> b

foldr1 :: (a -> a -> a) -> ConditionalExpression a -> a

foldl1 :: (a -> a -> a) -> ConditionalExpression a -> a

toList :: ConditionalExpression a -> [a]

null :: ConditionalExpression a -> Bool

length :: ConditionalExpression a -> Int

elem :: Eq a => a -> ConditionalExpression a -> Bool

maximum :: Ord a => ConditionalExpression a -> a

minimum :: Ord a => ConditionalExpression a -> a

sum :: Num a => ConditionalExpression a -> a

product :: Num a => ConditionalExpression a -> a

Traversable ConditionalExpression

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> ConditionalExpression a -> f (ConditionalExpression b)

sequenceA :: Applicative f => ConditionalExpression (f a) -> f (ConditionalExpression a)

mapM :: Monad m => (a -> m b) -> ConditionalExpression a -> m (ConditionalExpression b)

sequence :: Monad m => ConditionalExpression (m a) -> m (ConditionalExpression a)

SymbolMatching ConditionalExpression

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy ConditionalExpression -> Node -> Bool

showFailure :: Proxy ConditionalExpression -> Node -> String

Unmarshal ConditionalExpression

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (ConditionalExpression a)

Eq a => Eq (ConditionalExpression a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (ConditionalExpression a)

Defined in TreeSitter.Python.AST

Methods

compare :: ConditionalExpression a -> ConditionalExpression a -> Ordering

(<) :: ConditionalExpression a -> ConditionalExpression a -> Bool

(<=) :: ConditionalExpression a -> ConditionalExpression a -> Bool

(>) :: ConditionalExpression a -> ConditionalExpression a -> Bool

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

max :: ConditionalExpression a -> ConditionalExpression a -> ConditionalExpression a

min :: ConditionalExpression a -> ConditionalExpression a -> ConditionalExpression a

Show a => Show (ConditionalExpression a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> ConditionalExpression a -> ShowS

show :: ConditionalExpression a -> String

showList :: [ConditionalExpression a] -> ShowS

Generic (ConditionalExpression a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (ConditionalExpression a) :: Type -> Type

Methods

from :: ConditionalExpression a -> Rep (ConditionalExpression a) x

to :: Rep (ConditionalExpression a) x -> ConditionalExpression a

Generic1 ConditionalExpression

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 ConditionalExpression :: k -> Type

Methods

from1 :: ConditionalExpression a -> Rep1 ConditionalExpression a

to1 :: Rep1 ConditionalExpression a -> ConditionalExpression a

type Rep (ConditionalExpression a)

Defined in TreeSitter.Python.AST

type Rep (ConditionalExpression a) = D1 (MetaData "ConditionalExpression" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "ConditionalExpression" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (NonEmpty (Expression a)))))

type Rep1 ConditionalExpression

Defined in TreeSitter.Python.AST

type Rep1 ConditionalExpression = D1 (MetaData "ConditionalExpression" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "ConditionalExpression" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (NonEmpty :.: Rec1 Expression)))

data ComparisonOperator a

Constructors

ComparisonOperator

Fields

• ann :: a
• extraChildren :: (NonEmpty (PrimaryExpression a))

Instances

Functor ComparisonOperator

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable ComparisonOperator

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => ComparisonOperator m -> m

foldMap :: Monoid m => (a -> m) -> ComparisonOperator a -> m

foldr :: (a -> b -> b) -> b -> ComparisonOperator a -> b

foldr' :: (a -> b -> b) -> b -> ComparisonOperator a -> b

foldl :: (b -> a -> b) -> b -> ComparisonOperator a -> b

foldl' :: (b -> a -> b) -> b -> ComparisonOperator a -> b

foldr1 :: (a -> a -> a) -> ComparisonOperator a -> a

foldl1 :: (a -> a -> a) -> ComparisonOperator a -> a

toList :: ComparisonOperator a -> [a]

null :: ComparisonOperator a -> Bool

length :: ComparisonOperator a -> Int

elem :: Eq a => a -> ComparisonOperator a -> Bool

maximum :: Ord a => ComparisonOperator a -> a

minimum :: Ord a => ComparisonOperator a -> a

sum :: Num a => ComparisonOperator a -> a

product :: Num a => ComparisonOperator a -> a

Traversable ComparisonOperator

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> ComparisonOperator a -> f (ComparisonOperator b)

sequenceA :: Applicative f => ComparisonOperator (f a) -> f (ComparisonOperator a)

mapM :: Monad m => (a -> m b) -> ComparisonOperator a -> m (ComparisonOperator b)

sequence :: Monad m => ComparisonOperator (m a) -> m (ComparisonOperator a)

SymbolMatching ComparisonOperator

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy ComparisonOperator -> Node -> Bool

showFailure :: Proxy ComparisonOperator -> Node -> String

Unmarshal ComparisonOperator

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (ComparisonOperator a)

Eq a => Eq (ComparisonOperator a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (ComparisonOperator a)

Defined in TreeSitter.Python.AST

Methods

compare :: ComparisonOperator a -> ComparisonOperator a -> Ordering

(<) :: ComparisonOperator a -> ComparisonOperator a -> Bool

(<=) :: ComparisonOperator a -> ComparisonOperator a -> Bool

(>) :: ComparisonOperator a -> ComparisonOperator a -> Bool

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

max :: ComparisonOperator a -> ComparisonOperator a -> ComparisonOperator a

min :: ComparisonOperator a -> ComparisonOperator a -> ComparisonOperator a

Show a => Show (ComparisonOperator a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> ComparisonOperator a -> ShowS

show :: ComparisonOperator a -> String

showList :: [ComparisonOperator a] -> ShowS

Generic (ComparisonOperator a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (ComparisonOperator a) :: Type -> Type

Methods

from :: ComparisonOperator a -> Rep (ComparisonOperator a) x

to :: Rep (ComparisonOperator a) x -> ComparisonOperator a

Generic1 ComparisonOperator

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 ComparisonOperator :: k -> Type

Methods

from1 :: ComparisonOperator a -> Rep1 ComparisonOperator a

to1 :: Rep1 ComparisonOperator a -> ComparisonOperator a

type Rep (ComparisonOperator a)

Defined in TreeSitter.Python.AST

type Rep (ComparisonOperator a) = D1 (MetaData "ComparisonOperator" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "ComparisonOperator" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (NonEmpty (PrimaryExpression a)))))

type Rep1 ComparisonOperator

Defined in TreeSitter.Python.AST

type Rep1 ComparisonOperator = D1 (MetaData "ComparisonOperator" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "ComparisonOperator" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (NonEmpty :.: Rec1 PrimaryExpression)))

data BooleanOperator a

Constructors

BooleanOperator

Fields

• ann :: a
• operator :: ((:+:) AnonymousAnd AnonymousOr a)
• left :: (NonEmpty (Expression a))
• right :: (Maybe (Expression a))

Instances

Functor BooleanOperator

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable BooleanOperator

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => BooleanOperator m -> m

foldMap :: Monoid m => (a -> m) -> BooleanOperator a -> m

foldr :: (a -> b -> b) -> b -> BooleanOperator a -> b

foldr' :: (a -> b -> b) -> b -> BooleanOperator a -> b

foldl :: (b -> a -> b) -> b -> BooleanOperator a -> b

foldl' :: (b -> a -> b) -> b -> BooleanOperator a -> b

foldr1 :: (a -> a -> a) -> BooleanOperator a -> a

foldl1 :: (a -> a -> a) -> BooleanOperator a -> a

toList :: BooleanOperator a -> [a]

null :: BooleanOperator a -> Bool

length :: BooleanOperator a -> Int

elem :: Eq a => a -> BooleanOperator a -> Bool

maximum :: Ord a => BooleanOperator a -> a

minimum :: Ord a => BooleanOperator a -> a

sum :: Num a => BooleanOperator a -> a

product :: Num a => BooleanOperator a -> a

Traversable BooleanOperator

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> BooleanOperator a -> f (BooleanOperator b)

sequenceA :: Applicative f => BooleanOperator (f a) -> f (BooleanOperator a)

mapM :: Monad m => (a -> m b) -> BooleanOperator a -> m (BooleanOperator b)

sequence :: Monad m => BooleanOperator (m a) -> m (BooleanOperator a)

SymbolMatching BooleanOperator

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy BooleanOperator -> Node -> Bool

showFailure :: Proxy BooleanOperator -> Node -> String

Unmarshal BooleanOperator

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (BooleanOperator a)

Eq a => Eq (BooleanOperator a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (BooleanOperator a)

Defined in TreeSitter.Python.AST

Methods

compare :: BooleanOperator a -> BooleanOperator a -> Ordering

(<) :: BooleanOperator a -> BooleanOperator a -> Bool

(<=) :: BooleanOperator a -> BooleanOperator a -> Bool

(>) :: BooleanOperator a -> BooleanOperator a -> Bool

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

max :: BooleanOperator a -> BooleanOperator a -> BooleanOperator a

min :: BooleanOperator a -> BooleanOperator a -> BooleanOperator a

Show a => Show (BooleanOperator a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> BooleanOperator a -> ShowS

show :: BooleanOperator a -> String

showList :: [BooleanOperator a] -> ShowS

Generic (BooleanOperator a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (BooleanOperator a) :: Type -> Type

Methods

from :: BooleanOperator a -> Rep (BooleanOperator a) x

to :: Rep (BooleanOperator a) x -> BooleanOperator a

Generic1 BooleanOperator

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 BooleanOperator :: k -> Type

Methods

from1 :: BooleanOperator a -> Rep1 BooleanOperator a

to1 :: Rep1 BooleanOperator a -> BooleanOperator a

type Rep (BooleanOperator a)

Defined in TreeSitter.Python.AST

type Rep (BooleanOperator a) = D1 (MetaData "BooleanOperator" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "BooleanOperator" PrefixI True) ((S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: S1 (MetaSel (Just "operator") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ((AnonymousAnd :+: AnonymousOr) a))) :*: (S1 (MetaSel (Just "left") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (NonEmpty (Expression a))) :*: S1 (MetaSel (Just "right") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Expression a))))))

type Rep1 BooleanOperator

Defined in TreeSitter.Python.AST

type Rep1 BooleanOperator = D1 (MetaData "BooleanOperator" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "BooleanOperator" PrefixI True) ((S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: S1 (MetaSel (Just "operator") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 (AnonymousAnd :+: AnonymousOr))) :*: (S1 (MetaSel (Just "left") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (NonEmpty :.: Rec1 Expression) :*: S1 (MetaSel (Just "right") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Maybe :.: Rec1 Expression))))

data Await a

Constructors

Await

Fields

• ann :: a
• extraChildren :: (Expression a)

Instances

Functor Await

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable Await

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => Await m -> m

foldMap :: Monoid m => (a -> m) -> Await a -> m

foldr :: (a -> b -> b) -> b -> Await a -> b

foldr' :: (a -> b -> b) -> b -> Await a -> b

foldl :: (b -> a -> b) -> b -> Await a -> b

foldl' :: (b -> a -> b) -> b -> Await a -> b

foldr1 :: (a -> a -> a) -> Await a -> a

foldl1 :: (a -> a -> a) -> Await a -> a

toList :: Await a -> [a]

null :: Await a -> Bool

length :: Await a -> Int

elem :: Eq a => a -> Await a -> Bool

maximum :: Ord a => Await a -> a

minimum :: Ord a => Await a -> a

sum :: Num a => Await a -> a

product :: Num a => Await a -> a

Traversable Await

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> Await a -> f (Await b)

sequenceA :: Applicative f => Await (f a) -> f (Await a)

mapM :: Monad m => (a -> m b) -> Await a -> m (Await b)

sequence :: Monad m => Await (m a) -> m (Await a)

SymbolMatching Await

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy Await -> Node -> Bool

showFailure :: Proxy Await -> Node -> String

Unmarshal Await

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Await a)

Eq a => Eq (Await a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (Await a)

Defined in TreeSitter.Python.AST

Methods

compare :: Await a -> Await a -> Ordering

(<) :: Await a -> Await a -> Bool

(<=) :: Await a -> Await a -> Bool

(>) :: Await a -> Await a -> Bool

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

max :: Await a -> Await a -> Await a

min :: Await a -> Await a -> Await a

Show a => Show (Await a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> Await a -> ShowS

show :: Await a -> String

showList :: [Await a] -> ShowS

Generic (Await a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (Await a) :: Type -> Type

Methods

from :: Await a -> Rep (Await a) x

to :: Rep (Await a) x -> Await a

Generic1 Await

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 Await :: k -> Type

Methods

from1 :: Await a -> Rep1 Await a

to1 :: Rep1 Await a -> Await a

type Rep (Await a)

Defined in TreeSitter.Python.AST

type Rep (Await a) = D1 (MetaData "Await" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "Await" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Expression a))))

type Rep1 Await

Defined in TreeSitter.Python.AST

type Rep1 Await = D1 (MetaData "Await" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "Await" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 Expression)))

data Subscript a

Constructors

Subscript

Fields

• ann :: a
• subscript :: (NonEmpty ((:+:) AnonymousComma ((:+:) Expression Slice) a))
• value :: (PrimaryExpression a)

Instances

Functor Subscript

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable Subscript

Defined in TreeSitter.Python.AST

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 TreeSitter.Python.AST

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)

SymbolMatching Subscript

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy Subscript -> Node -> Bool

showFailure :: Proxy Subscript -> Node -> String

Unmarshal Subscript

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Subscript a)

Eq a => Eq (Subscript a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (Subscript a)

Defined in TreeSitter.Python.AST

Methods

compare :: Subscript a -> Subscript a -> Ordering

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

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

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

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

max :: Subscript a -> Subscript a -> Subscript a

min :: Subscript a -> Subscript a -> Subscript a

Show a => Show (Subscript a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> Subscript a -> ShowS

show :: Subscript a -> String

showList :: [Subscript a] -> ShowS

Generic (Subscript a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (Subscript a) :: Type -> Type

Methods

from :: Subscript a -> Rep (Subscript a) x

to :: Rep (Subscript a) x -> Subscript a

Generic1 Subscript

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 Subscript :: k -> Type

Methods

from1 :: Subscript a -> Rep1 Subscript a

to1 :: Rep1 Subscript a -> Subscript a

type Rep (Subscript a)

Defined in TreeSitter.Python.AST

type Rep (Subscript a) = D1 (MetaData "Subscript" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "Subscript" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: (S1 (MetaSel (Just "subscript") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (NonEmpty ((AnonymousComma :+: (Expression :+: Slice)) a))) :*: S1 (MetaSel (Just "value") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (PrimaryExpression a)))))

type Rep1 Subscript

Defined in TreeSitter.Python.AST

type Rep1 Subscript = D1 (MetaData "Subscript" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "Subscript" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: (S1 (MetaSel (Just "subscript") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (NonEmpty :.: Rec1 (AnonymousComma :+: (Expression :+: Slice))) :*: S1 (MetaSel (Just "value") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 PrimaryExpression))))

data Slice a

Constructors

Slice

Fields

• ann :: a
• extraChildren :: ([] (Expression a))

Instances

Functor Slice

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable Slice

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => Slice m -> m

foldMap :: Monoid m => (a -> m) -> Slice a -> m

foldr :: (a -> b -> b) -> b -> Slice a -> b

foldr' :: (a -> b -> b) -> b -> Slice a -> b

foldl :: (b -> a -> b) -> b -> Slice a -> b

foldl' :: (b -> a -> b) -> b -> Slice a -> b

foldr1 :: (a -> a -> a) -> Slice a -> a

foldl1 :: (a -> a -> a) -> Slice a -> a

toList :: Slice a -> [a]

null :: Slice a -> Bool

length :: Slice a -> Int

elem :: Eq a => a -> Slice a -> Bool

maximum :: Ord a => Slice a -> a

minimum :: Ord a => Slice a -> a

sum :: Num a => Slice a -> a

product :: Num a => Slice a -> a

Traversable Slice

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> Slice a -> f (Slice b)

sequenceA :: Applicative f => Slice (f a) -> f (Slice a)

mapM :: Monad m => (a -> m b) -> Slice a -> m (Slice b)

sequence :: Monad m => Slice (m a) -> m (Slice a)

SymbolMatching Slice

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy Slice -> Node -> Bool

showFailure :: Proxy Slice -> Node -> String

Unmarshal Slice

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Slice a)

Eq a => Eq (Slice a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (Slice a)

Defined in TreeSitter.Python.AST

Methods

compare :: Slice a -> Slice a -> Ordering

(<) :: Slice a -> Slice a -> Bool

(<=) :: Slice a -> Slice a -> Bool

(>) :: Slice a -> Slice a -> Bool

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

max :: Slice a -> Slice a -> Slice a

min :: Slice a -> Slice a -> Slice a

Show a => Show (Slice a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> Slice a -> ShowS

show :: Slice a -> String

showList :: [Slice a] -> ShowS

Generic (Slice a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (Slice a) :: Type -> Type

Methods

from :: Slice a -> Rep (Slice a) x

to :: Rep (Slice a) x -> Slice a

Generic1 Slice

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 Slice :: k -> Type

Methods

from1 :: Slice a -> Rep1 Slice a

to1 :: Rep1 Slice a -> Slice a

type Rep (Slice a)

Defined in TreeSitter.Python.AST

type Rep (Slice a) = D1 (MetaData "Slice" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "Slice" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Expression a])))

type Rep1 Slice

Defined in TreeSitter.Python.AST

type Rep1 Slice = D1 (MetaData "Slice" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "Slice" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) ([] :.: Rec1 Expression)))

data String a

Constructors

String

Fields

• ann :: a
• extraChildren :: ([] ((:+:) EscapeSequence Interpolation a))

Instances

Functor String

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable String

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => String m -> m

foldMap :: Monoid m => (a -> m) -> String a -> m

foldr :: (a -> b -> b) -> b -> String a -> b

foldr' :: (a -> b -> b) -> b -> String a -> b

foldl :: (b -> a -> b) -> b -> String a -> b

foldl' :: (b -> a -> b) -> b -> String a -> b

foldr1 :: (a -> a -> a) -> String a -> a

foldl1 :: (a -> a -> a) -> String a -> a

toList :: String a -> [a]

null :: String a -> Bool

length :: String a -> Int

elem :: Eq a => a -> String a -> Bool

maximum :: Ord a => String a -> a

minimum :: Ord a => String a -> a

sum :: Num a => String a -> a

product :: Num a => String a -> a

Traversable String

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> String a -> f (String b)

sequenceA :: Applicative f => String (f a) -> f (String a)

mapM :: Monad m => (a -> m b) -> String a -> m (String b)

sequence :: Monad m => String (m a) -> m (String a)

SymbolMatching String

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy String -> Node -> Bool

showFailure :: Proxy String -> Node -> String0

Unmarshal String

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (String a)

Eq a => Eq (String a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (String a)

Defined in TreeSitter.Python.AST

Methods

compare :: String a -> String a -> Ordering

(<) :: String a -> String a -> Bool

(<=) :: String a -> String a -> Bool

(>) :: String a -> String a -> Bool

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

max :: String a -> String a -> String a

min :: String a -> String a -> String a

Show a => Show (String a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> String a -> ShowS

show :: String a -> String0

showList :: [String a] -> ShowS

Generic (String a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (String a) :: Type -> Type

Methods

from :: String a -> Rep (String a) x

to :: Rep (String a) x -> String a

Generic1 String

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 String :: k -> Type

Methods

from1 :: String a -> Rep1 String a

to1 :: Rep1 String a -> String a

type Rep (String a)

Defined in TreeSitter.Python.AST

type Rep (String a) = D1 (MetaData "String" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "String" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [(EscapeSequence :+: Interpolation) a])))

type Rep1 String

Defined in TreeSitter.Python.AST

type Rep1 String = D1 (MetaData "String" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "String" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) ([] :.: Rec1 (EscapeSequence :+: Interpolation))))

data Interpolation a

Constructors

Interpolation

Fields

• ann :: a
• extraChildren :: (NonEmpty ((:+:) Expression ((:+:) FormatSpecifier TypeConversion) a))

Instances

Functor Interpolation

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable Interpolation

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => Interpolation m -> m

foldMap :: Monoid m => (a -> m) -> Interpolation a -> m

foldr :: (a -> b -> b) -> b -> Interpolation a -> b

foldr' :: (a -> b -> b) -> b -> Interpolation a -> b

foldl :: (b -> a -> b) -> b -> Interpolation a -> b

foldl' :: (b -> a -> b) -> b -> Interpolation a -> b

foldr1 :: (a -> a -> a) -> Interpolation a -> a

foldl1 :: (a -> a -> a) -> Interpolation a -> a

toList :: Interpolation a -> [a]

null :: Interpolation a -> Bool

length :: Interpolation a -> Int

elem :: Eq a => a -> Interpolation a -> Bool

maximum :: Ord a => Interpolation a -> a

minimum :: Ord a => Interpolation a -> a

sum :: Num a => Interpolation a -> a

product :: Num a => Interpolation a -> a

Traversable Interpolation

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> Interpolation a -> f (Interpolation b)

sequenceA :: Applicative f => Interpolation (f a) -> f (Interpolation a)

mapM :: Monad m => (a -> m b) -> Interpolation a -> m (Interpolation b)

sequence :: Monad m => Interpolation (m a) -> m (Interpolation a)

SymbolMatching Interpolation

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy Interpolation -> Node -> Bool

showFailure :: Proxy Interpolation -> Node -> String

Unmarshal Interpolation

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Interpolation a)

Eq a => Eq (Interpolation a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (Interpolation a)

Defined in TreeSitter.Python.AST

Methods

compare :: Interpolation a -> Interpolation a -> Ordering

(<) :: Interpolation a -> Interpolation a -> Bool

(<=) :: Interpolation a -> Interpolation a -> Bool

(>) :: Interpolation a -> Interpolation a -> Bool

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

max :: Interpolation a -> Interpolation a -> Interpolation a

min :: Interpolation a -> Interpolation a -> Interpolation a

Show a => Show (Interpolation a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> Interpolation a -> ShowS

show :: Interpolation a -> String

showList :: [Interpolation a] -> ShowS

Generic (Interpolation a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (Interpolation a) :: Type -> Type

Methods

from :: Interpolation a -> Rep (Interpolation a) x

to :: Rep (Interpolation a) x -> Interpolation a

Generic1 Interpolation

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 Interpolation :: k -> Type

Methods

from1 :: Interpolation a -> Rep1 Interpolation a

to1 :: Rep1 Interpolation a -> Interpolation a

type Rep (Interpolation a)

Defined in TreeSitter.Python.AST

type Rep (Interpolation a) = D1 (MetaData "Interpolation" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "Interpolation" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (NonEmpty ((Expression :+: (FormatSpecifier :+: TypeConversion)) a)))))

type Rep1 Interpolation

Defined in TreeSitter.Python.AST

type Rep1 Interpolation = D1 (MetaData "Interpolation" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "Interpolation" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (NonEmpty :.: Rec1 (Expression :+: (FormatSpecifier :+: TypeConversion)))))

data FormatSpecifier a

Constructors

FormatSpecifier

Fields

• ann :: a
• extraChildren :: ([] (FormatExpression a))

Instances

Functor FormatSpecifier

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable FormatSpecifier

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => FormatSpecifier m -> m

foldMap :: Monoid m => (a -> m) -> FormatSpecifier a -> m

foldr :: (a -> b -> b) -> b -> FormatSpecifier a -> b

foldr' :: (a -> b -> b) -> b -> FormatSpecifier a -> b

foldl :: (b -> a -> b) -> b -> FormatSpecifier a -> b

foldl' :: (b -> a -> b) -> b -> FormatSpecifier a -> b

foldr1 :: (a -> a -> a) -> FormatSpecifier a -> a

foldl1 :: (a -> a -> a) -> FormatSpecifier a -> a

toList :: FormatSpecifier a -> [a]

null :: FormatSpecifier a -> Bool

length :: FormatSpecifier a -> Int

elem :: Eq a => a -> FormatSpecifier a -> Bool

maximum :: Ord a => FormatSpecifier a -> a

minimum :: Ord a => FormatSpecifier a -> a

sum :: Num a => FormatSpecifier a -> a

product :: Num a => FormatSpecifier a -> a

Traversable FormatSpecifier

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> FormatSpecifier a -> f (FormatSpecifier b)

sequenceA :: Applicative f => FormatSpecifier (f a) -> f (FormatSpecifier a)

mapM :: Monad m => (a -> m b) -> FormatSpecifier a -> m (FormatSpecifier b)

sequence :: Monad m => FormatSpecifier (m a) -> m (FormatSpecifier a)

SymbolMatching FormatSpecifier

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy FormatSpecifier -> Node -> Bool

showFailure :: Proxy FormatSpecifier -> Node -> String

Unmarshal FormatSpecifier

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (FormatSpecifier a)

Eq a => Eq (FormatSpecifier a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (FormatSpecifier a)

Defined in TreeSitter.Python.AST

Methods

compare :: FormatSpecifier a -> FormatSpecifier a -> Ordering

(<) :: FormatSpecifier a -> FormatSpecifier a -> Bool

(<=) :: FormatSpecifier a -> FormatSpecifier a -> Bool

(>) :: FormatSpecifier a -> FormatSpecifier a -> Bool

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

max :: FormatSpecifier a -> FormatSpecifier a -> FormatSpecifier a

min :: FormatSpecifier a -> FormatSpecifier a -> FormatSpecifier a

Show a => Show (FormatSpecifier a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> FormatSpecifier a -> ShowS

show :: FormatSpecifier a -> String

showList :: [FormatSpecifier a] -> ShowS

Generic (FormatSpecifier a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (FormatSpecifier a) :: Type -> Type

Methods

from :: FormatSpecifier a -> Rep (FormatSpecifier a) x

to :: Rep (FormatSpecifier a) x -> FormatSpecifier a

Generic1 FormatSpecifier

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 FormatSpecifier :: k -> Type

Methods

from1 :: FormatSpecifier a -> Rep1 FormatSpecifier a

to1 :: Rep1 FormatSpecifier a -> FormatSpecifier a

type Rep (FormatSpecifier a)

Defined in TreeSitter.Python.AST

type Rep (FormatSpecifier a) = D1 (MetaData "FormatSpecifier" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "FormatSpecifier" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [FormatExpression a])))

type Rep1 FormatSpecifier

Defined in TreeSitter.Python.AST

type Rep1 FormatSpecifier = D1 (MetaData "FormatSpecifier" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "FormatSpecifier" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) ([] :.: Rec1 FormatExpression)))

data FormatExpression a

Constructors

FormatExpression

Fields

• ann :: a
• extraChildren :: (Expression a)

Instances

Functor FormatExpression

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable FormatExpression

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => FormatExpression m -> m

foldMap :: Monoid m => (a -> m) -> FormatExpression a -> m

foldr :: (a -> b -> b) -> b -> FormatExpression a -> b

foldr' :: (a -> b -> b) -> b -> FormatExpression a -> b

foldl :: (b -> a -> b) -> b -> FormatExpression a -> b

foldl' :: (b -> a -> b) -> b -> FormatExpression a -> b

foldr1 :: (a -> a -> a) -> FormatExpression a -> a

foldl1 :: (a -> a -> a) -> FormatExpression a -> a

toList :: FormatExpression a -> [a]

null :: FormatExpression a -> Bool

length :: FormatExpression a -> Int

elem :: Eq a => a -> FormatExpression a -> Bool

maximum :: Ord a => FormatExpression a -> a

minimum :: Ord a => FormatExpression a -> a

sum :: Num a => FormatExpression a -> a

product :: Num a => FormatExpression a -> a

Traversable FormatExpression

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> FormatExpression a -> f (FormatExpression b)

sequenceA :: Applicative f => FormatExpression (f a) -> f (FormatExpression a)

mapM :: Monad m => (a -> m b) -> FormatExpression a -> m (FormatExpression b)

sequence :: Monad m => FormatExpression (m a) -> m (FormatExpression a)

SymbolMatching FormatExpression

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy FormatExpression -> Node -> Bool

showFailure :: Proxy FormatExpression -> Node -> String

Unmarshal FormatExpression

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (FormatExpression a)

Eq a => Eq (FormatExpression a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (FormatExpression a)

Defined in TreeSitter.Python.AST

Methods

compare :: FormatExpression a -> FormatExpression a -> Ordering

(<) :: FormatExpression a -> FormatExpression a -> Bool

(<=) :: FormatExpression a -> FormatExpression a -> Bool

(>) :: FormatExpression a -> FormatExpression a -> Bool

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

max :: FormatExpression a -> FormatExpression a -> FormatExpression a

min :: FormatExpression a -> FormatExpression a -> FormatExpression a

Show a => Show (FormatExpression a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> FormatExpression a -> ShowS

show :: FormatExpression a -> String

showList :: [FormatExpression a] -> ShowS

Generic (FormatExpression a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (FormatExpression a) :: Type -> Type

Methods

from :: FormatExpression a -> Rep (FormatExpression a) x

to :: Rep (FormatExpression a) x -> FormatExpression a

Generic1 FormatExpression

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 FormatExpression :: k -> Type

Methods

from1 :: FormatExpression a -> Rep1 FormatExpression a

to1 :: Rep1 FormatExpression a -> FormatExpression a

type Rep (FormatExpression a)

Defined in TreeSitter.Python.AST

type Rep (FormatExpression a) = D1 (MetaData "FormatExpression" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "FormatExpression" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Expression a))))

type Rep1 FormatExpression

Defined in TreeSitter.Python.AST

type Rep1 FormatExpression = D1 (MetaData "FormatExpression" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "FormatExpression" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 Expression)))

data SetComprehension a

Constructors

SetComprehension

Fields

• ann :: a
• body :: (Expression a)
• extraChildren :: (NonEmpty ((:+:) ForInClause IfClause a))

Instances

Functor SetComprehension

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable SetComprehension

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => SetComprehension m -> m

foldMap :: Monoid m => (a -> m) -> SetComprehension a -> m

foldr :: (a -> b -> b) -> b -> SetComprehension a -> b

foldr' :: (a -> b -> b) -> b -> SetComprehension a -> b

foldl :: (b -> a -> b) -> b -> SetComprehension a -> b

foldl' :: (b -> a -> b) -> b -> SetComprehension a -> b

foldr1 :: (a -> a -> a) -> SetComprehension a -> a

foldl1 :: (a -> a -> a) -> SetComprehension a -> a

toList :: SetComprehension a -> [a]

null :: SetComprehension a -> Bool

length :: SetComprehension a -> Int

elem :: Eq a => a -> SetComprehension a -> Bool

maximum :: Ord a => SetComprehension a -> a

minimum :: Ord a => SetComprehension a -> a

sum :: Num a => SetComprehension a -> a

product :: Num a => SetComprehension a -> a

Traversable SetComprehension

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> SetComprehension a -> f (SetComprehension b)

sequenceA :: Applicative f => SetComprehension (f a) -> f (SetComprehension a)

mapM :: Monad m => (a -> m b) -> SetComprehension a -> m (SetComprehension b)

sequence :: Monad m => SetComprehension (m a) -> m (SetComprehension a)

SymbolMatching SetComprehension

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy SetComprehension -> Node -> Bool

showFailure :: Proxy SetComprehension -> Node -> String

Unmarshal SetComprehension

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (SetComprehension a)

Eq a => Eq (SetComprehension a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (SetComprehension a)

Defined in TreeSitter.Python.AST

Methods

compare :: SetComprehension a -> SetComprehension a -> Ordering

(<) :: SetComprehension a -> SetComprehension a -> Bool

(<=) :: SetComprehension a -> SetComprehension a -> Bool

(>) :: SetComprehension a -> SetComprehension a -> Bool

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

max :: SetComprehension a -> SetComprehension a -> SetComprehension a

min :: SetComprehension a -> SetComprehension a -> SetComprehension a

Show a => Show (SetComprehension a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> SetComprehension a -> ShowS

show :: SetComprehension a -> String

showList :: [SetComprehension a] -> ShowS

Generic (SetComprehension a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (SetComprehension a) :: Type -> Type

Methods

from :: SetComprehension a -> Rep (SetComprehension a) x

to :: Rep (SetComprehension a) x -> SetComprehension a

Generic1 SetComprehension

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 SetComprehension :: k -> Type

Methods

from1 :: SetComprehension a -> Rep1 SetComprehension a

to1 :: Rep1 SetComprehension a -> SetComprehension a

type Rep (SetComprehension a)

Defined in TreeSitter.Python.AST

type Rep (SetComprehension a) = D1 (MetaData "SetComprehension" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "SetComprehension" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: (S1 (MetaSel (Just "body") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Expression a)) :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (NonEmpty ((ForInClause :+: IfClause) a))))))

type Rep1 SetComprehension

Defined in TreeSitter.Python.AST

type Rep1 SetComprehension = D1 (MetaData "SetComprehension" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "SetComprehension" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: (S1 (MetaSel (Just "body") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 Expression) :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (NonEmpty :.: Rec1 (ForInClause :+: IfClause)))))

data IfClause a

Constructors

IfClause

Fields

• ann :: a
• extraChildren :: (Expression a)

Instances

Functor IfClause

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable IfClause

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => IfClause m -> m

foldMap :: Monoid m => (a -> m) -> IfClause a -> m

foldr :: (a -> b -> b) -> b -> IfClause a -> b

foldr' :: (a -> b -> b) -> b -> IfClause a -> b

foldl :: (b -> a -> b) -> b -> IfClause a -> b

foldl' :: (b -> a -> b) -> b -> IfClause a -> b

foldr1 :: (a -> a -> a) -> IfClause a -> a

foldl1 :: (a -> a -> a) -> IfClause a -> a

toList :: IfClause a -> [a]

null :: IfClause a -> Bool

length :: IfClause a -> Int

elem :: Eq a => a -> IfClause a -> Bool

maximum :: Ord a => IfClause a -> a

minimum :: Ord a => IfClause a -> a

sum :: Num a => IfClause a -> a

product :: Num a => IfClause a -> a

Traversable IfClause

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> IfClause a -> f (IfClause b)

sequenceA :: Applicative f => IfClause (f a) -> f (IfClause a)

mapM :: Monad m => (a -> m b) -> IfClause a -> m (IfClause b)

sequence :: Monad m => IfClause (m a) -> m (IfClause a)

SymbolMatching IfClause

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy IfClause -> Node -> Bool

showFailure :: Proxy IfClause -> Node -> String

Unmarshal IfClause

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (IfClause a)

Eq a => Eq (IfClause a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (IfClause a)

Defined in TreeSitter.Python.AST

Methods

compare :: IfClause a -> IfClause a -> Ordering

(<) :: IfClause a -> IfClause a -> Bool

(<=) :: IfClause a -> IfClause a -> Bool

(>) :: IfClause a -> IfClause a -> Bool

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

max :: IfClause a -> IfClause a -> IfClause a

min :: IfClause a -> IfClause a -> IfClause a

Show a => Show (IfClause a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> IfClause a -> ShowS

show :: IfClause a -> String

showList :: [IfClause a] -> ShowS

Generic (IfClause a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (IfClause a) :: Type -> Type

Methods

from :: IfClause a -> Rep (IfClause a) x

to :: Rep (IfClause a) x -> IfClause a

Generic1 IfClause

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 IfClause :: k -> Type

Methods

from1 :: IfClause a -> Rep1 IfClause a

to1 :: Rep1 IfClause a -> IfClause a

type Rep (IfClause a)

Defined in TreeSitter.Python.AST

type Rep (IfClause a) = D1 (MetaData "IfClause" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "IfClause" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Expression a))))

type Rep1 IfClause

Defined in TreeSitter.Python.AST

type Rep1 IfClause = D1 (MetaData "IfClause" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "IfClause" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 Expression)))

data ForInClause a

Constructors

ForInClause

Fields

• ann :: a
• left :: (Variables a)
• right :: (NonEmpty ((:+:) AnonymousComma ((:+:) Expression Lambda) a))

Instances

Functor ForInClause

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable ForInClause

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => ForInClause m -> m

foldMap :: Monoid m => (a -> m) -> ForInClause a -> m

foldr :: (a -> b -> b) -> b -> ForInClause a -> b

foldr' :: (a -> b -> b) -> b -> ForInClause a -> b

foldl :: (b -> a -> b) -> b -> ForInClause a -> b

foldl' :: (b -> a -> b) -> b -> ForInClause a -> b

foldr1 :: (a -> a -> a) -> ForInClause a -> a

foldl1 :: (a -> a -> a) -> ForInClause a -> a

toList :: ForInClause a -> [a]

null :: ForInClause a -> Bool

length :: ForInClause a -> Int

elem :: Eq a => a -> ForInClause a -> Bool

maximum :: Ord a => ForInClause a -> a

minimum :: Ord a => ForInClause a -> a

sum :: Num a => ForInClause a -> a

product :: Num a => ForInClause a -> a

Traversable ForInClause

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> ForInClause a -> f (ForInClause b)

sequenceA :: Applicative f => ForInClause (f a) -> f (ForInClause a)

mapM :: Monad m => (a -> m b) -> ForInClause a -> m (ForInClause b)

sequence :: Monad m => ForInClause (m a) -> m (ForInClause a)

SymbolMatching ForInClause

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy ForInClause -> Node -> Bool

showFailure :: Proxy ForInClause -> Node -> String

Unmarshal ForInClause

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (ForInClause a)

Eq a => Eq (ForInClause a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (ForInClause a)

Defined in TreeSitter.Python.AST

Methods

compare :: ForInClause a -> ForInClause a -> Ordering

(<) :: ForInClause a -> ForInClause a -> Bool

(<=) :: ForInClause a -> ForInClause a -> Bool

(>) :: ForInClause a -> ForInClause a -> Bool

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

max :: ForInClause a -> ForInClause a -> ForInClause a

min :: ForInClause a -> ForInClause a -> ForInClause a

Show a => Show (ForInClause a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> ForInClause a -> ShowS

show :: ForInClause a -> String

showList :: [ForInClause a] -> ShowS

Generic (ForInClause a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (ForInClause a) :: Type -> Type

Methods

from :: ForInClause a -> Rep (ForInClause a) x

to :: Rep (ForInClause a) x -> ForInClause a

Generic1 ForInClause

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 ForInClause :: k -> Type

Methods

from1 :: ForInClause a -> Rep1 ForInClause a

to1 :: Rep1 ForInClause a -> ForInClause a

type Rep (ForInClause a)

Defined in TreeSitter.Python.AST

type Rep (ForInClause a) = D1 (MetaData "ForInClause" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "ForInClause" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: (S1 (MetaSel (Just "left") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Variables a)) :*: S1 (MetaSel (Just "right") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (NonEmpty ((AnonymousComma :+: (Expression :+: Lambda)) a))))))

type Rep1 ForInClause

Defined in TreeSitter.Python.AST

type Rep1 ForInClause = D1 (MetaData "ForInClause" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "ForInClause" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: (S1 (MetaSel (Just "left") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 Variables) :*: S1 (MetaSel (Just "right") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (NonEmpty :.: Rec1 (AnonymousComma :+: (Expression :+: Lambda))))))

data Variables a

Constructors

Variables

Fields

• ann :: a
• extraChildren :: (NonEmpty (PrimaryExpression a))

Instances

Functor Variables

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable Variables

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => Variables m -> m

foldMap :: Monoid m => (a -> m) -> Variables a -> m

foldr :: (a -> b -> b) -> b -> Variables a -> b

foldr' :: (a -> b -> b) -> b -> Variables a -> b

foldl :: (b -> a -> b) -> b -> Variables a -> b

foldl' :: (b -> a -> b) -> b -> Variables a -> b

foldr1 :: (a -> a -> a) -> Variables a -> a

foldl1 :: (a -> a -> a) -> Variables a -> a

toList :: Variables a -> [a]

null :: Variables a -> Bool

length :: Variables a -> Int

elem :: Eq a => a -> Variables a -> Bool

maximum :: Ord a => Variables a -> a

minimum :: Ord a => Variables a -> a

sum :: Num a => Variables a -> a

product :: Num a => Variables a -> a

Traversable Variables

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> Variables a -> f (Variables b)

sequenceA :: Applicative f => Variables (f a) -> f (Variables a)

mapM :: Monad m => (a -> m b) -> Variables a -> m (Variables b)

sequence :: Monad m => Variables (m a) -> m (Variables a)

SymbolMatching Variables

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy Variables -> Node -> Bool

showFailure :: Proxy Variables -> Node -> String

Unmarshal Variables

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Variables a)

Eq a => Eq (Variables a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (Variables a)

Defined in TreeSitter.Python.AST

Methods

compare :: Variables a -> Variables a -> Ordering

(<) :: Variables a -> Variables a -> Bool

(<=) :: Variables a -> Variables a -> Bool

(>) :: Variables a -> Variables a -> Bool

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

max :: Variables a -> Variables a -> Variables a

min :: Variables a -> Variables a -> Variables a

Show a => Show (Variables a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> Variables a -> ShowS

show :: Variables a -> String

showList :: [Variables a] -> ShowS

Generic (Variables a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (Variables a) :: Type -> Type

Methods

from :: Variables a -> Rep (Variables a) x

to :: Rep (Variables a) x -> Variables a

Generic1 Variables

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 Variables :: k -> Type

Methods

from1 :: Variables a -> Rep1 Variables a

to1 :: Rep1 Variables a -> Variables a

type Rep (Variables a)

Defined in TreeSitter.Python.AST

type Rep (Variables a) = D1 (MetaData "Variables" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "Variables" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (NonEmpty (PrimaryExpression a)))))

type Rep1 Variables

Defined in TreeSitter.Python.AST

type Rep1 Variables = D1 (MetaData "Variables" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "Variables" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (NonEmpty :.: Rec1 PrimaryExpression)))

data Set a

Constructors

Set

Fields

• ann :: a
• extraChildren :: (NonEmpty ((:+:) Expression ListSplat a))

Instances

Functor Set

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable Set

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => Set m -> m

foldMap :: Monoid m => (a -> m) -> Set a -> m

foldr :: (a -> b -> b) -> b -> Set a -> b

foldr' :: (a -> b -> b) -> b -> Set a -> b

foldl :: (b -> a -> b) -> b -> Set a -> b

foldl' :: (b -> a -> b) -> b -> Set a -> b

foldr1 :: (a -> a -> a) -> Set a -> a

foldl1 :: (a -> a -> a) -> Set a -> a

toList :: Set a -> [a]

null :: Set a -> Bool

length :: Set a -> Int

elem :: Eq a => a -> Set a -> Bool

maximum :: Ord a => Set a -> a

minimum :: Ord a => Set a -> a

sum :: Num a => Set a -> a

product :: Num a => Set a -> a

Traversable Set

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> Set a -> f (Set b)

sequenceA :: Applicative f => Set (f a) -> f (Set a)

mapM :: Monad m => (a -> m b) -> Set a -> m (Set b)

sequence :: Monad m => Set (m a) -> m (Set a)

SymbolMatching Set

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy Set -> Node -> Bool

showFailure :: Proxy Set -> Node -> String

Unmarshal Set

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Set a)

Eq a => Eq (Set a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (Set a)

Defined in TreeSitter.Python.AST

Methods

compare :: Set a -> Set a -> Ordering

(<) :: Set a -> Set a -> Bool

(<=) :: Set a -> Set a -> Bool

(>) :: Set a -> Set a -> Bool

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

max :: Set a -> Set a -> Set a

min :: Set a -> Set a -> Set a

Show a => Show (Set a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> Set a -> ShowS

show :: Set a -> String

showList :: [Set a] -> ShowS

Generic (Set a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (Set a) :: Type -> Type

Methods

from :: Set a -> Rep (Set a) x

to :: Rep (Set a) x -> Set a

Generic1 Set

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 Set :: k -> Type

Methods

from1 :: Set a -> Rep1 Set a

to1 :: Rep1 Set a -> Set a

type Rep (Set a)

Defined in TreeSitter.Python.AST

type Rep (Set a) = D1 (MetaData "Set" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "Set" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (NonEmpty ((Expression :+: ListSplat) a)))))

type Rep1 Set

Defined in TreeSitter.Python.AST

type Rep1 Set = D1 (MetaData "Set" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "Set" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (NonEmpty :.: Rec1 (Expression :+: ListSplat))))

data ParenthesizedExpression a

Constructors

ParenthesizedExpression

Fields

• ann :: a
• extraChildren :: ((:+:) Expression Yield a)

Instances

Functor ParenthesizedExpression

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable ParenthesizedExpression

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => ParenthesizedExpression m -> m

foldMap :: Monoid m => (a -> m) -> ParenthesizedExpression a -> m

foldr :: (a -> b -> b) -> b -> ParenthesizedExpression a -> b

foldr' :: (a -> b -> b) -> b -> ParenthesizedExpression a -> b

foldl :: (b -> a -> b) -> b -> ParenthesizedExpression a -> b

foldl' :: (b -> a -> b) -> b -> ParenthesizedExpression a -> b

foldr1 :: (a -> a -> a) -> ParenthesizedExpression a -> a

foldl1 :: (a -> a -> a) -> ParenthesizedExpression a -> a

toList :: ParenthesizedExpression a -> [a]

null :: ParenthesizedExpression a -> Bool

length :: ParenthesizedExpression a -> Int

elem :: Eq a => a -> ParenthesizedExpression a -> Bool

maximum :: Ord a => ParenthesizedExpression a -> a

minimum :: Ord a => ParenthesizedExpression a -> a

sum :: Num a => ParenthesizedExpression a -> a

product :: Num a => ParenthesizedExpression a -> a

Traversable ParenthesizedExpression

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> ParenthesizedExpression a -> f (ParenthesizedExpression b)

sequenceA :: Applicative f => ParenthesizedExpression (f a) -> f (ParenthesizedExpression a)

mapM :: Monad m => (a -> m b) -> ParenthesizedExpression a -> m (ParenthesizedExpression b)

sequence :: Monad m => ParenthesizedExpression (m a) -> m (ParenthesizedExpression a)

SymbolMatching ParenthesizedExpression

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy ParenthesizedExpression -> Node -> Bool

showFailure :: Proxy ParenthesizedExpression -> Node -> String

Unmarshal ParenthesizedExpression

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (ParenthesizedExpression a)

Eq a => Eq (ParenthesizedExpression a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (ParenthesizedExpression a)

Defined in TreeSitter.Python.AST

Methods

compare :: ParenthesizedExpression a -> ParenthesizedExpression a -> Ordering

(<) :: ParenthesizedExpression a -> ParenthesizedExpression a -> Bool

(<=) :: ParenthesizedExpression a -> ParenthesizedExpression a -> Bool

(>) :: ParenthesizedExpression a -> ParenthesizedExpression a -> Bool

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

max :: ParenthesizedExpression a -> ParenthesizedExpression a -> ParenthesizedExpression a

min :: ParenthesizedExpression a -> ParenthesizedExpression a -> ParenthesizedExpression a

Show a => Show (ParenthesizedExpression a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> ParenthesizedExpression a -> ShowS

show :: ParenthesizedExpression a -> String

showList :: [ParenthesizedExpression a] -> ShowS

Generic (ParenthesizedExpression a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (ParenthesizedExpression a) :: Type -> Type

Methods

from :: ParenthesizedExpression a -> Rep (ParenthesizedExpression a) x

to :: Rep (ParenthesizedExpression a) x -> ParenthesizedExpression a

Generic1 ParenthesizedExpression

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 ParenthesizedExpression :: k -> Type

Methods

from1 :: ParenthesizedExpression a -> Rep1 ParenthesizedExpression a

to1 :: Rep1 ParenthesizedExpression a -> ParenthesizedExpression a

type Rep (ParenthesizedExpression a)

Defined in TreeSitter.Python.AST

type Rep (ParenthesizedExpression a) = D1 (MetaData "ParenthesizedExpression" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "ParenthesizedExpression" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ((Expression :+: Yield) a))))

type Rep1 ParenthesizedExpression

Defined in TreeSitter.Python.AST

type Rep1 ParenthesizedExpression = D1 (MetaData "ParenthesizedExpression" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "ParenthesizedExpression" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 (Expression :+: Yield))))

data ListComprehension a

Constructors

ListComprehension

Fields

• ann :: a
• body :: (Expression a)
• extraChildren :: (NonEmpty ((:+:) ForInClause IfClause a))

Instances

Functor ListComprehension

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable ListComprehension

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => ListComprehension m -> m

foldMap :: Monoid m => (a -> m) -> ListComprehension a -> m

foldr :: (a -> b -> b) -> b -> ListComprehension a -> b

foldr' :: (a -> b -> b) -> b -> ListComprehension a -> b

foldl :: (b -> a -> b) -> b -> ListComprehension a -> b

foldl' :: (b -> a -> b) -> b -> ListComprehension a -> b

foldr1 :: (a -> a -> a) -> ListComprehension a -> a

foldl1 :: (a -> a -> a) -> ListComprehension a -> a

toList :: ListComprehension a -> [a]

null :: ListComprehension a -> Bool

length :: ListComprehension a -> Int

elem :: Eq a => a -> ListComprehension a -> Bool

maximum :: Ord a => ListComprehension a -> a

minimum :: Ord a => ListComprehension a -> a

sum :: Num a => ListComprehension a -> a

product :: Num a => ListComprehension a -> a

Traversable ListComprehension

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> ListComprehension a -> f (ListComprehension b)

sequenceA :: Applicative f => ListComprehension (f a) -> f (ListComprehension a)

mapM :: Monad m => (a -> m b) -> ListComprehension a -> m (ListComprehension b)

sequence :: Monad m => ListComprehension (m a) -> m (ListComprehension a)

SymbolMatching ListComprehension

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy ListComprehension -> Node -> Bool

showFailure :: Proxy ListComprehension -> Node -> String

Unmarshal ListComprehension

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (ListComprehension a)

Eq a => Eq (ListComprehension a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (ListComprehension a)

Defined in TreeSitter.Python.AST

Methods

compare :: ListComprehension a -> ListComprehension a -> Ordering

(<) :: ListComprehension a -> ListComprehension a -> Bool

(<=) :: ListComprehension a -> ListComprehension a -> Bool

(>) :: ListComprehension a -> ListComprehension a -> Bool

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

max :: ListComprehension a -> ListComprehension a -> ListComprehension a

min :: ListComprehension a -> ListComprehension a -> ListComprehension a

Show a => Show (ListComprehension a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> ListComprehension a -> ShowS

show :: ListComprehension a -> String

showList :: [ListComprehension a] -> ShowS

Generic (ListComprehension a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (ListComprehension a) :: Type -> Type

Methods

from :: ListComprehension a -> Rep (ListComprehension a) x

to :: Rep (ListComprehension a) x -> ListComprehension a

Generic1 ListComprehension

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 ListComprehension :: k -> Type

Methods

from1 :: ListComprehension a -> Rep1 ListComprehension a

to1 :: Rep1 ListComprehension a -> ListComprehension a

type Rep (ListComprehension a)

Defined in TreeSitter.Python.AST

type Rep (ListComprehension a) = D1 (MetaData "ListComprehension" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "ListComprehension" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: (S1 (MetaSel (Just "body") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Expression a)) :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (NonEmpty ((ForInClause :+: IfClause) a))))))

type Rep1 ListComprehension

Defined in TreeSitter.Python.AST

type Rep1 ListComprehension = D1 (MetaData "ListComprehension" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "ListComprehension" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: (S1 (MetaSel (Just "body") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 Expression) :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (NonEmpty :.: Rec1 (ForInClause :+: IfClause)))))

data List a

Constructors

List

Fields

• ann :: a
• extraChildren :: ([] ((:+:) Expression ListSplat a))

Instances

Functor List

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable List

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => List m -> m

foldMap :: Monoid m => (a -> m) -> List a -> m

foldr :: (a -> b -> b) -> b -> List a -> b

foldr' :: (a -> b -> b) -> b -> List a -> b

foldl :: (b -> a -> b) -> b -> List a -> b

foldl' :: (b -> a -> b) -> b -> List a -> b

foldr1 :: (a -> a -> a) -> List a -> a

foldl1 :: (a -> a -> a) -> List a -> a

toList :: List a -> [a]

null :: List a -> Bool

length :: List a -> Int

elem :: Eq a => a -> List a -> Bool

maximum :: Ord a => List a -> a

minimum :: Ord a => List a -> a

sum :: Num a => List a -> a

product :: Num a => List a -> a

Traversable List

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> List a -> f (List b)

sequenceA :: Applicative f => List (f a) -> f (List a)

mapM :: Monad m => (a -> m b) -> List a -> m (List b)

sequence :: Monad m => List (m a) -> m (List a)

SymbolMatching List

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy List -> Node -> Bool

showFailure :: Proxy List -> Node -> String

Unmarshal List

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (List a)

Eq a => Eq (List a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (List a)

Defined in TreeSitter.Python.AST

Methods

compare :: List a -> List a -> Ordering

(<) :: List a -> List a -> Bool

(<=) :: List a -> List a -> Bool

(>) :: List a -> List a -> Bool

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

max :: List a -> List a -> List a

min :: List a -> List a -> List a

Show a => Show (List a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> List a -> ShowS

show :: List a -> String

showList :: [List a] -> ShowS

Generic (List a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (List a) :: Type -> Type

Methods

from :: List a -> Rep (List a) x

to :: Rep (List a) x -> List a

Generic1 List

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 List :: k -> Type

Methods

from1 :: List a -> Rep1 List a

to1 :: Rep1 List a -> List a

type Rep (List a)

Defined in TreeSitter.Python.AST

type Rep (List a) = D1 (MetaData "List" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "List" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [(Expression :+: ListSplat) a])))

type Rep1 List

Defined in TreeSitter.Python.AST

type Rep1 List = D1 (MetaData "List" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "List" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) ([] :.: Rec1 (Expression :+: ListSplat))))

data GeneratorExpression a

Constructors

GeneratorExpression

Fields

• ann :: a
• body :: (Expression a)
• extraChildren :: (NonEmpty ((:+:) ForInClause IfClause a))

Instances

Functor GeneratorExpression

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable GeneratorExpression

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => GeneratorExpression m -> m

foldMap :: Monoid m => (a -> m) -> GeneratorExpression a -> m

foldr :: (a -> b -> b) -> b -> GeneratorExpression a -> b

foldr' :: (a -> b -> b) -> b -> GeneratorExpression a -> b

foldl :: (b -> a -> b) -> b -> GeneratorExpression a -> b

foldl' :: (b -> a -> b) -> b -> GeneratorExpression a -> b

foldr1 :: (a -> a -> a) -> GeneratorExpression a -> a

foldl1 :: (a -> a -> a) -> GeneratorExpression a -> a

toList :: GeneratorExpression a -> [a]

null :: GeneratorExpression a -> Bool

length :: GeneratorExpression a -> Int

elem :: Eq a => a -> GeneratorExpression a -> Bool

maximum :: Ord a => GeneratorExpression a -> a

minimum :: Ord a => GeneratorExpression a -> a

sum :: Num a => GeneratorExpression a -> a

product :: Num a => GeneratorExpression a -> a

Traversable GeneratorExpression

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> GeneratorExpression a -> f (GeneratorExpression b)

sequenceA :: Applicative f => GeneratorExpression (f a) -> f (GeneratorExpression a)

mapM :: Monad m => (a -> m b) -> GeneratorExpression a -> m (GeneratorExpression b)

sequence :: Monad m => GeneratorExpression (m a) -> m (GeneratorExpression a)

SymbolMatching GeneratorExpression

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy GeneratorExpression -> Node -> Bool

showFailure :: Proxy GeneratorExpression -> Node -> String

Unmarshal GeneratorExpression

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (GeneratorExpression a)

Eq a => Eq (GeneratorExpression a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (GeneratorExpression a)

Defined in TreeSitter.Python.AST

Methods

compare :: GeneratorExpression a -> GeneratorExpression a -> Ordering

(<) :: GeneratorExpression a -> GeneratorExpression a -> Bool

(<=) :: GeneratorExpression a -> GeneratorExpression a -> Bool

(>) :: GeneratorExpression a -> GeneratorExpression a -> Bool

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

max :: GeneratorExpression a -> GeneratorExpression a -> GeneratorExpression a

min :: GeneratorExpression a -> GeneratorExpression a -> GeneratorExpression a

Show a => Show (GeneratorExpression a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> GeneratorExpression a -> ShowS

show :: GeneratorExpression a -> String

showList :: [GeneratorExpression a] -> ShowS

Generic (GeneratorExpression a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (GeneratorExpression a) :: Type -> Type

Methods

from :: GeneratorExpression a -> Rep (GeneratorExpression a) x

to :: Rep (GeneratorExpression a) x -> GeneratorExpression a

Generic1 GeneratorExpression

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 GeneratorExpression :: k -> Type

Methods

from1 :: GeneratorExpression a -> Rep1 GeneratorExpression a

to1 :: Rep1 GeneratorExpression a -> GeneratorExpression a

type Rep (GeneratorExpression a)

Defined in TreeSitter.Python.AST

type Rep (GeneratorExpression a) = D1 (MetaData "GeneratorExpression" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "GeneratorExpression" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: (S1 (MetaSel (Just "body") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Expression a)) :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (NonEmpty ((ForInClause :+: IfClause) a))))))

type Rep1 GeneratorExpression

Defined in TreeSitter.Python.AST

type Rep1 GeneratorExpression = D1 (MetaData "GeneratorExpression" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "GeneratorExpression" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: (S1 (MetaSel (Just "body") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 Expression) :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (NonEmpty :.: Rec1 (ForInClause :+: IfClause)))))

data DictionaryComprehension a

Constructors

DictionaryComprehension

Fields

• ann :: a
• body :: (Pair a)
• extraChildren :: (NonEmpty ((:+:) ForInClause IfClause a))

Instances

Functor DictionaryComprehension

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable DictionaryComprehension

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => DictionaryComprehension m -> m

foldMap :: Monoid m => (a -> m) -> DictionaryComprehension a -> m

foldr :: (a -> b -> b) -> b -> DictionaryComprehension a -> b

foldr' :: (a -> b -> b) -> b -> DictionaryComprehension a -> b

foldl :: (b -> a -> b) -> b -> DictionaryComprehension a -> b

foldl' :: (b -> a -> b) -> b -> DictionaryComprehension a -> b

foldr1 :: (a -> a -> a) -> DictionaryComprehension a -> a

foldl1 :: (a -> a -> a) -> DictionaryComprehension a -> a

toList :: DictionaryComprehension a -> [a]

null :: DictionaryComprehension a -> Bool

length :: DictionaryComprehension a -> Int

elem :: Eq a => a -> DictionaryComprehension a -> Bool

maximum :: Ord a => DictionaryComprehension a -> a

minimum :: Ord a => DictionaryComprehension a -> a

sum :: Num a => DictionaryComprehension a -> a

product :: Num a => DictionaryComprehension a -> a

Traversable DictionaryComprehension

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> DictionaryComprehension a -> f (DictionaryComprehension b)

sequenceA :: Applicative f => DictionaryComprehension (f a) -> f (DictionaryComprehension a)

mapM :: Monad m => (a -> m b) -> DictionaryComprehension a -> m (DictionaryComprehension b)

sequence :: Monad m => DictionaryComprehension (m a) -> m (DictionaryComprehension a)

SymbolMatching DictionaryComprehension

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy DictionaryComprehension -> Node -> Bool

showFailure :: Proxy DictionaryComprehension -> Node -> String

Unmarshal DictionaryComprehension

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (DictionaryComprehension a)

Eq a => Eq (DictionaryComprehension a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (DictionaryComprehension a)

Defined in TreeSitter.Python.AST

Methods

compare :: DictionaryComprehension a -> DictionaryComprehension a -> Ordering

(<) :: DictionaryComprehension a -> DictionaryComprehension a -> Bool

(<=) :: DictionaryComprehension a -> DictionaryComprehension a -> Bool

(>) :: DictionaryComprehension a -> DictionaryComprehension a -> Bool

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

max :: DictionaryComprehension a -> DictionaryComprehension a -> DictionaryComprehension a

min :: DictionaryComprehension a -> DictionaryComprehension a -> DictionaryComprehension a

Show a => Show (DictionaryComprehension a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> DictionaryComprehension a -> ShowS

show :: DictionaryComprehension a -> String

showList :: [DictionaryComprehension a] -> ShowS

Generic (DictionaryComprehension a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (DictionaryComprehension a) :: Type -> Type

Methods

from :: DictionaryComprehension a -> Rep (DictionaryComprehension a) x

to :: Rep (DictionaryComprehension a) x -> DictionaryComprehension a

Generic1 DictionaryComprehension

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 DictionaryComprehension :: k -> Type

Methods

from1 :: DictionaryComprehension a -> Rep1 DictionaryComprehension a

to1 :: Rep1 DictionaryComprehension a -> DictionaryComprehension a

type Rep (DictionaryComprehension a)

Defined in TreeSitter.Python.AST

type Rep (DictionaryComprehension a) = D1 (MetaData "DictionaryComprehension" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "DictionaryComprehension" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: (S1 (MetaSel (Just "body") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Pair a)) :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (NonEmpty ((ForInClause :+: IfClause) a))))))

type Rep1 DictionaryComprehension

Defined in TreeSitter.Python.AST

type Rep1 DictionaryComprehension = D1 (MetaData "DictionaryComprehension" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "DictionaryComprehension" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: (S1 (MetaSel (Just "body") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 Pair) :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (NonEmpty :.: Rec1 (ForInClause :+: IfClause)))))

data Pair a

Constructors

Pair

Fields

• ann :: a
• value :: (Expression a)
• key :: (Expression a)

Instances

Functor Pair

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable Pair

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => Pair m -> m

foldMap :: Monoid m => (a -> m) -> Pair a -> m

foldr :: (a -> b -> b) -> b -> Pair a -> b

foldr' :: (a -> b -> b) -> b -> Pair a -> b

foldl :: (b -> a -> b) -> b -> Pair a -> b

foldl' :: (b -> a -> b) -> b -> Pair a -> b

foldr1 :: (a -> a -> a) -> Pair a -> a

foldl1 :: (a -> a -> a) -> Pair a -> a

toList :: Pair a -> [a]

null :: Pair a -> Bool

length :: Pair a -> Int

elem :: Eq a => a -> Pair a -> Bool

maximum :: Ord a => Pair a -> a

minimum :: Ord a => Pair a -> a

sum :: Num a => Pair a -> a

product :: Num a => Pair a -> a

Traversable Pair

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> Pair a -> f (Pair b)

sequenceA :: Applicative f => Pair (f a) -> f (Pair a)

mapM :: Monad m => (a -> m b) -> Pair a -> m (Pair b)

sequence :: Monad m => Pair (m a) -> m (Pair a)

SymbolMatching Pair

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy Pair -> Node -> Bool

showFailure :: Proxy Pair -> Node -> String

Unmarshal Pair

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Pair a)

Eq a => Eq (Pair a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (Pair a)

Defined in TreeSitter.Python.AST

Methods

compare :: Pair a -> Pair a -> Ordering

(<) :: Pair a -> Pair a -> Bool

(<=) :: Pair a -> Pair a -> Bool

(>) :: Pair a -> Pair a -> Bool

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

max :: Pair a -> Pair a -> Pair a

min :: Pair a -> Pair a -> Pair a

Show a => Show (Pair a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> Pair a -> ShowS

show :: Pair a -> String

showList :: [Pair a] -> ShowS

Generic (Pair a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (Pair a) :: Type -> Type

Methods

from :: Pair a -> Rep (Pair a) x

to :: Rep (Pair a) x -> Pair a

Generic1 Pair

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 Pair :: k -> Type

Methods

from1 :: Pair a -> Rep1 Pair a

to1 :: Rep1 Pair a -> Pair a

type Rep (Pair a)

Defined in TreeSitter.Python.AST

type Rep (Pair a) = D1 (MetaData "Pair" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "Pair" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: (S1 (MetaSel (Just "value") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Expression a)) :*: S1 (MetaSel (Just "key") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Expression a)))))

type Rep1 Pair

Defined in TreeSitter.Python.AST

type Rep1 Pair = D1 (MetaData "Pair" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "Pair" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: (S1 (MetaSel (Just "value") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 Expression) :*: S1 (MetaSel (Just "key") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 Expression))))

data Dictionary a

Constructors

Dictionary

Fields

• ann :: a
• extraChildren :: ([] ((:+:) DictionarySplat Pair a))

Instances

Functor Dictionary

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable Dictionary

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => Dictionary m -> m

foldMap :: Monoid m => (a -> m) -> Dictionary a -> m

foldr :: (a -> b -> b) -> b -> Dictionary a -> b

foldr' :: (a -> b -> b) -> b -> Dictionary a -> b

foldl :: (b -> a -> b) -> b -> Dictionary a -> b

foldl' :: (b -> a -> b) -> b -> Dictionary a -> b

foldr1 :: (a -> a -> a) -> Dictionary a -> a

foldl1 :: (a -> a -> a) -> Dictionary a -> a

toList :: Dictionary a -> [a]

null :: Dictionary a -> Bool

length :: Dictionary a -> Int

elem :: Eq a => a -> Dictionary a -> Bool

maximum :: Ord a => Dictionary a -> a

minimum :: Ord a => Dictionary a -> a

sum :: Num a => Dictionary a -> a

product :: Num a => Dictionary a -> a

Traversable Dictionary

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> Dictionary a -> f (Dictionary b)

sequenceA :: Applicative f => Dictionary (f a) -> f (Dictionary a)

mapM :: Monad m => (a -> m b) -> Dictionary a -> m (Dictionary b)

sequence :: Monad m => Dictionary (m a) -> m (Dictionary a)

SymbolMatching Dictionary

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy Dictionary -> Node -> Bool

showFailure :: Proxy Dictionary -> Node -> String

Unmarshal Dictionary

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Dictionary a)

Eq a => Eq (Dictionary a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (Dictionary a)

Defined in TreeSitter.Python.AST

Methods

compare :: Dictionary a -> Dictionary a -> Ordering

(<) :: Dictionary a -> Dictionary a -> Bool

(<=) :: Dictionary a -> Dictionary a -> Bool

(>) :: Dictionary a -> Dictionary a -> Bool

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

max :: Dictionary a -> Dictionary a -> Dictionary a

min :: Dictionary a -> Dictionary a -> Dictionary a

Show a => Show (Dictionary a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> Dictionary a -> ShowS

show :: Dictionary a -> String

showList :: [Dictionary a] -> ShowS

Generic (Dictionary a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (Dictionary a) :: Type -> Type

Methods

from :: Dictionary a -> Rep (Dictionary a) x

to :: Rep (Dictionary a) x -> Dictionary a

Generic1 Dictionary

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 Dictionary :: k -> Type

Methods

from1 :: Dictionary a -> Rep1 Dictionary a

to1 :: Rep1 Dictionary a -> Dictionary a

type Rep (Dictionary a)

Defined in TreeSitter.Python.AST

type Rep (Dictionary a) = D1 (MetaData "Dictionary" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "Dictionary" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [(DictionarySplat :+: Pair) a])))

type Rep1 Dictionary

Defined in TreeSitter.Python.AST

type Rep1 Dictionary = D1 (MetaData "Dictionary" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "Dictionary" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) ([] :.: Rec1 (DictionarySplat :+: Pair))))

data ConcatenatedString a

Constructors

ConcatenatedString

Fields

• ann :: a
• extraChildren :: (NonEmpty (String a))

Instances

Functor ConcatenatedString

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable ConcatenatedString

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => ConcatenatedString m -> m

foldMap :: Monoid m => (a -> m) -> ConcatenatedString a -> m

foldr :: (a -> b -> b) -> b -> ConcatenatedString a -> b

foldr' :: (a -> b -> b) -> b -> ConcatenatedString a -> b

foldl :: (b -> a -> b) -> b -> ConcatenatedString a -> b

foldl' :: (b -> a -> b) -> b -> ConcatenatedString a -> b

foldr1 :: (a -> a -> a) -> ConcatenatedString a -> a

foldl1 :: (a -> a -> a) -> ConcatenatedString a -> a

toList :: ConcatenatedString a -> [a]

null :: ConcatenatedString a -> Bool

length :: ConcatenatedString a -> Int

elem :: Eq a => a -> ConcatenatedString a -> Bool

maximum :: Ord a => ConcatenatedString a -> a

minimum :: Ord a => ConcatenatedString a -> a

sum :: Num a => ConcatenatedString a -> a

product :: Num a => ConcatenatedString a -> a

Traversable ConcatenatedString

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> ConcatenatedString a -> f (ConcatenatedString b)

sequenceA :: Applicative f => ConcatenatedString (f a) -> f (ConcatenatedString a)

mapM :: Monad m => (a -> m b) -> ConcatenatedString a -> m (ConcatenatedString b)

sequence :: Monad m => ConcatenatedString (m a) -> m (ConcatenatedString a)

SymbolMatching ConcatenatedString

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy ConcatenatedString -> Node -> Bool

showFailure :: Proxy ConcatenatedString -> Node -> String

Unmarshal ConcatenatedString

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (ConcatenatedString a)

Eq a => Eq (ConcatenatedString a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (ConcatenatedString a)

Defined in TreeSitter.Python.AST

Methods

compare :: ConcatenatedString a -> ConcatenatedString a -> Ordering

(<) :: ConcatenatedString a -> ConcatenatedString a -> Bool

(<=) :: ConcatenatedString a -> ConcatenatedString a -> Bool

(>) :: ConcatenatedString a -> ConcatenatedString a -> Bool

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

max :: ConcatenatedString a -> ConcatenatedString a -> ConcatenatedString a

min :: ConcatenatedString a -> ConcatenatedString a -> ConcatenatedString a

Show a => Show (ConcatenatedString a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> ConcatenatedString a -> ShowS

show :: ConcatenatedString a -> String

showList :: [ConcatenatedString a] -> ShowS

Generic (ConcatenatedString a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (ConcatenatedString a) :: Type -> Type

Methods

from :: ConcatenatedString a -> Rep (ConcatenatedString a) x

to :: Rep (ConcatenatedString a) x -> ConcatenatedString a

Generic1 ConcatenatedString

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 ConcatenatedString :: k -> Type

Methods

from1 :: ConcatenatedString a -> Rep1 ConcatenatedString a

to1 :: Rep1 ConcatenatedString a -> ConcatenatedString a

type Rep (ConcatenatedString a)

Defined in TreeSitter.Python.AST

type Rep (ConcatenatedString a) = D1 (MetaData "ConcatenatedString" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "ConcatenatedString" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (NonEmpty (String a)))))

type Rep1 ConcatenatedString

Defined in TreeSitter.Python.AST

type Rep1 ConcatenatedString = D1 (MetaData "ConcatenatedString" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "ConcatenatedString" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (NonEmpty :.: Rec1 String)))

data Call a

Constructors

Call

Fields

• ann :: a
• function :: (PrimaryExpression a)
• arguments :: ((:+:) ArgumentList GeneratorExpression a)

Instances

Functor Call

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable Call

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => Call m -> m

foldMap :: Monoid m => (a -> m) -> Call a -> m

foldr :: (a -> b -> b) -> b -> Call a -> b

foldr' :: (a -> b -> b) -> b -> Call a -> b

foldl :: (b -> a -> b) -> b -> Call a -> b

foldl' :: (b -> a -> b) -> b -> Call a -> b

foldr1 :: (a -> a -> a) -> Call a -> a

foldl1 :: (a -> a -> a) -> Call a -> a

toList :: Call a -> [a]

null :: Call a -> Bool

length :: Call a -> Int

elem :: Eq a => a -> Call a -> Bool

maximum :: Ord a => Call a -> a

minimum :: Ord a => Call a -> a

sum :: Num a => Call a -> a

product :: Num a => Call a -> a

Traversable Call

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> Call a -> f (Call b)

sequenceA :: Applicative f => Call (f a) -> f (Call a)

mapM :: Monad m => (a -> m b) -> Call a -> m (Call b)

sequence :: Monad m => Call (m a) -> m (Call a)

SymbolMatching Call

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy Call -> Node -> Bool

showFailure :: Proxy Call -> Node -> String

Unmarshal Call

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Call a)

Eq a => Eq (Call a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (Call a)

Defined in TreeSitter.Python.AST

Methods

compare :: Call a -> Call a -> Ordering

(<) :: Call a -> Call a -> Bool

(<=) :: Call a -> Call a -> Bool

(>) :: Call a -> Call a -> Bool

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

max :: Call a -> Call a -> Call a

min :: Call a -> Call a -> Call a

Show a => Show (Call a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> Call a -> ShowS

show :: Call a -> String

showList :: [Call a] -> ShowS

Generic (Call a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (Call a) :: Type -> Type

Methods

from :: Call a -> Rep (Call a) x

to :: Rep (Call a) x -> Call a

Generic1 Call

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 Call :: k -> Type

Methods

from1 :: Call a -> Rep1 Call a

to1 :: Rep1 Call a -> Call a

type Rep (Call a)

Defined in TreeSitter.Python.AST

type Rep (Call a) = D1 (MetaData "Call" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "Call" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: (S1 (MetaSel (Just "function") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (PrimaryExpression a)) :*: S1 (MetaSel (Just "arguments") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ((ArgumentList :+: GeneratorExpression) a)))))

type Rep1 Call

Defined in TreeSitter.Python.AST

type Rep1 Call = D1 (MetaData "Call" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "Call" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: (S1 (MetaSel (Just "function") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 PrimaryExpression) :*: S1 (MetaSel (Just "arguments") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 (ArgumentList :+: GeneratorExpression)))))

data ArgumentList a

Constructors

ArgumentList

Fields

• ann :: a
• extraChildren :: ([] ((:+:) Expression ((:+:) DictionarySplat ((:+:) KeywordArgument ListSplat)) a))

Instances

Functor ArgumentList

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable ArgumentList

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => ArgumentList m -> m

foldMap :: Monoid m => (a -> m) -> ArgumentList a -> m

foldr :: (a -> b -> b) -> b -> ArgumentList a -> b

foldr' :: (a -> b -> b) -> b -> ArgumentList a -> b

foldl :: (b -> a -> b) -> b -> ArgumentList a -> b

foldl' :: (b -> a -> b) -> b -> ArgumentList a -> b

foldr1 :: (a -> a -> a) -> ArgumentList a -> a

foldl1 :: (a -> a -> a) -> ArgumentList a -> a

toList :: ArgumentList a -> [a]

null :: ArgumentList a -> Bool

length :: ArgumentList a -> Int

elem :: Eq a => a -> ArgumentList a -> Bool

maximum :: Ord a => ArgumentList a -> a

minimum :: Ord a => ArgumentList a -> a

sum :: Num a => ArgumentList a -> a

product :: Num a => ArgumentList a -> a

Traversable ArgumentList

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> ArgumentList a -> f (ArgumentList b)

sequenceA :: Applicative f => ArgumentList (f a) -> f (ArgumentList a)

mapM :: Monad m => (a -> m b) -> ArgumentList a -> m (ArgumentList b)

sequence :: Monad m => ArgumentList (m a) -> m (ArgumentList a)

SymbolMatching ArgumentList

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy ArgumentList -> Node -> Bool

showFailure :: Proxy ArgumentList -> Node -> String

Unmarshal ArgumentList

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (ArgumentList a)

Eq a => Eq (ArgumentList a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (ArgumentList a)

Defined in TreeSitter.Python.AST

Methods

compare :: ArgumentList a -> ArgumentList a -> Ordering

(<) :: ArgumentList a -> ArgumentList a -> Bool

(<=) :: ArgumentList a -> ArgumentList a -> Bool

(>) :: ArgumentList a -> ArgumentList a -> Bool

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

max :: ArgumentList a -> ArgumentList a -> ArgumentList a

min :: ArgumentList a -> ArgumentList a -> ArgumentList a

Show a => Show (ArgumentList a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> ArgumentList a -> ShowS

show :: ArgumentList a -> String

showList :: [ArgumentList a] -> ShowS

Generic (ArgumentList a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (ArgumentList a) :: Type -> Type

Methods

from :: ArgumentList a -> Rep (ArgumentList a) x

to :: Rep (ArgumentList a) x -> ArgumentList a

Generic1 ArgumentList

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 ArgumentList :: k -> Type

Methods

from1 :: ArgumentList a -> Rep1 ArgumentList a

to1 :: Rep1 ArgumentList a -> ArgumentList a

type Rep (ArgumentList a)

Defined in TreeSitter.Python.AST

type Rep (ArgumentList a) = D1 (MetaData "ArgumentList" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "ArgumentList" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [(Expression :+: (DictionarySplat :+: (KeywordArgument :+: ListSplat))) a])))

type Rep1 ArgumentList

Defined in TreeSitter.Python.AST

type Rep1 ArgumentList = D1 (MetaData "ArgumentList" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "ArgumentList" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) ([] :.: Rec1 (Expression :+: (DictionarySplat :+: (KeywordArgument :+: ListSplat))))))

data KeywordArgument a

Constructors

KeywordArgument

Fields

• ann :: a
• value :: (Expression a)
• name :: (Identifier a)

Instances

Functor KeywordArgument

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable KeywordArgument

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => KeywordArgument m -> m

foldMap :: Monoid m => (a -> m) -> KeywordArgument a -> m

foldr :: (a -> b -> b) -> b -> KeywordArgument a -> b

foldr' :: (a -> b -> b) -> b -> KeywordArgument a -> b

foldl :: (b -> a -> b) -> b -> KeywordArgument a -> b

foldl' :: (b -> a -> b) -> b -> KeywordArgument a -> b

foldr1 :: (a -> a -> a) -> KeywordArgument a -> a

foldl1 :: (a -> a -> a) -> KeywordArgument a -> a

toList :: KeywordArgument a -> [a]

null :: KeywordArgument a -> Bool

length :: KeywordArgument a -> Int

elem :: Eq a => a -> KeywordArgument a -> Bool

maximum :: Ord a => KeywordArgument a -> a

minimum :: Ord a => KeywordArgument a -> a

sum :: Num a => KeywordArgument a -> a

product :: Num a => KeywordArgument a -> a

Traversable KeywordArgument

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> KeywordArgument a -> f (KeywordArgument b)

sequenceA :: Applicative f => KeywordArgument (f a) -> f (KeywordArgument a)

mapM :: Monad m => (a -> m b) -> KeywordArgument a -> m (KeywordArgument b)

sequence :: Monad m => KeywordArgument (m a) -> m (KeywordArgument a)

SymbolMatching KeywordArgument

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy KeywordArgument -> Node -> Bool

showFailure :: Proxy KeywordArgument -> Node -> String

Unmarshal KeywordArgument

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (KeywordArgument a)

Eq a => Eq (KeywordArgument a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (KeywordArgument a)

Defined in TreeSitter.Python.AST

Methods

compare :: KeywordArgument a -> KeywordArgument a -> Ordering

(<) :: KeywordArgument a -> KeywordArgument a -> Bool

(<=) :: KeywordArgument a -> KeywordArgument a -> Bool

(>) :: KeywordArgument a -> KeywordArgument a -> Bool

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

max :: KeywordArgument a -> KeywordArgument a -> KeywordArgument a

min :: KeywordArgument a -> KeywordArgument a -> KeywordArgument a

Show a => Show (KeywordArgument a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> KeywordArgument a -> ShowS

show :: KeywordArgument a -> String

showList :: [KeywordArgument a] -> ShowS

Generic (KeywordArgument a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (KeywordArgument a) :: Type -> Type

Methods

from :: KeywordArgument a -> Rep (KeywordArgument a) x

to :: Rep (KeywordArgument a) x -> KeywordArgument a

Generic1 KeywordArgument

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 KeywordArgument :: k -> Type

Methods

from1 :: KeywordArgument a -> Rep1 KeywordArgument a

to1 :: Rep1 KeywordArgument a -> KeywordArgument a

type Rep (KeywordArgument a)

Defined in TreeSitter.Python.AST

type Rep (KeywordArgument a) = D1 (MetaData "KeywordArgument" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "KeywordArgument" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: (S1 (MetaSel (Just "value") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Expression a)) :*: S1 (MetaSel (Just "name") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Identifier a)))))

type Rep1 KeywordArgument

Defined in TreeSitter.Python.AST

type Rep1 KeywordArgument = D1 (MetaData "KeywordArgument" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "KeywordArgument" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: (S1 (MetaSel (Just "value") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 Expression) :*: S1 (MetaSel (Just "name") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 Identifier))))

data BinaryOperator a

Constructors

BinaryOperator

Fields

• ann :: a
• operator :: ((:+:) AnonymousPercent ((:+:) AnonymousAmpersand ((:+:) AnonymousStar ((:+:) AnonymousStarStar ((:+:) AnonymousPlus ((:+:) AnonymousMinus ((:+:) AnonymousSlash ((:+:) AnonymousSlashSlash ((:+:) AnonymousLAngleLAngle ((:+:) AnonymousRAngleRAngle ((:+:) AnonymousAt ((:+:) AnonymousCaret AnonymousPipe))))))))))) a)
• left :: (PrimaryExpression a)
• right :: (PrimaryExpression a)

Instances

Functor BinaryOperator

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable BinaryOperator

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => BinaryOperator m -> m

foldMap :: Monoid m => (a -> m) -> BinaryOperator a -> m

foldr :: (a -> b -> b) -> b -> BinaryOperator a -> b

foldr' :: (a -> b -> b) -> b -> BinaryOperator a -> b

foldl :: (b -> a -> b) -> b -> BinaryOperator a -> b

foldl' :: (b -> a -> b) -> b -> BinaryOperator a -> b

foldr1 :: (a -> a -> a) -> BinaryOperator a -> a

foldl1 :: (a -> a -> a) -> BinaryOperator a -> a

toList :: BinaryOperator a -> [a]

null :: BinaryOperator a -> Bool

length :: BinaryOperator a -> Int

elem :: Eq a => a -> BinaryOperator a -> Bool

maximum :: Ord a => BinaryOperator a -> a

minimum :: Ord a => BinaryOperator a -> a

sum :: Num a => BinaryOperator a -> a

product :: Num a => BinaryOperator a -> a

Traversable BinaryOperator

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> BinaryOperator a -> f (BinaryOperator b)

sequenceA :: Applicative f => BinaryOperator (f a) -> f (BinaryOperator a)

mapM :: Monad m => (a -> m b) -> BinaryOperator a -> m (BinaryOperator b)

sequence :: Monad m => BinaryOperator (m a) -> m (BinaryOperator a)

SymbolMatching BinaryOperator

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy BinaryOperator -> Node -> Bool

showFailure :: Proxy BinaryOperator -> Node -> String

Unmarshal BinaryOperator

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (BinaryOperator a)

Eq a => Eq (BinaryOperator a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (BinaryOperator a)

Defined in TreeSitter.Python.AST

Methods

compare :: BinaryOperator a -> BinaryOperator a -> Ordering

(<) :: BinaryOperator a -> BinaryOperator a -> Bool

(<=) :: BinaryOperator a -> BinaryOperator a -> Bool

(>) :: BinaryOperator a -> BinaryOperator a -> Bool

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

max :: BinaryOperator a -> BinaryOperator a -> BinaryOperator a

min :: BinaryOperator a -> BinaryOperator a -> BinaryOperator a

Show a => Show (BinaryOperator a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> BinaryOperator a -> ShowS

show :: BinaryOperator a -> String

showList :: [BinaryOperator a] -> ShowS

Generic (BinaryOperator a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (BinaryOperator a) :: Type -> Type

Methods

from :: BinaryOperator a -> Rep (BinaryOperator a) x

to :: Rep (BinaryOperator a) x -> BinaryOperator a

Generic1 BinaryOperator

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 BinaryOperator :: k -> Type

Methods

from1 :: BinaryOperator a -> Rep1 BinaryOperator a

to1 :: Rep1 BinaryOperator a -> BinaryOperator a

type Rep (BinaryOperator a)

Defined in TreeSitter.Python.AST

type Rep (BinaryOperator a) = D1 (MetaData "BinaryOperator" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "BinaryOperator" PrefixI True) ((S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: S1 (MetaSel (Just "operator") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ((AnonymousPercent :+: (AnonymousAmpersand :+: (AnonymousStar :+: (AnonymousStarStar :+: (AnonymousPlus :+: (AnonymousMinus :+: (AnonymousSlash :+: (AnonymousSlashSlash :+: (AnonymousLAngleLAngle :+: (AnonymousRAngleRAngle :+: (AnonymousAt :+: (AnonymousCaret :+: AnonymousPipe)))))))))))) a))) :*: (S1 (MetaSel (Just "left") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (PrimaryExpression a)) :*: S1 (MetaSel (Just "right") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (PrimaryExpression a)))))

type Rep1 BinaryOperator

Defined in TreeSitter.Python.AST

type Rep1 BinaryOperator = D1 (MetaData "BinaryOperator" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "BinaryOperator" PrefixI True) ((S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: S1 (MetaSel (Just "operator") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 (AnonymousPercent :+: (AnonymousAmpersand :+: (AnonymousStar :+: (AnonymousStarStar :+: (AnonymousPlus :+: (AnonymousMinus :+: (AnonymousSlash :+: (AnonymousSlashSlash :+: (AnonymousLAngleLAngle :+: (AnonymousRAngleRAngle :+: (AnonymousAt :+: (AnonymousCaret :+: AnonymousPipe)))))))))))))) :*: (S1 (MetaSel (Just "left") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 PrimaryExpression) :*: S1 (MetaSel (Just "right") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 PrimaryExpression))))

data Attribute a

Constructors

Attribute

Fields

• ann :: a
• extraChildren :: (NonEmpty ((:+:) PrimaryExpression Identifier a))

Instances

Functor Attribute

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable Attribute

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => Attribute m -> m

foldMap :: Monoid m => (a -> m) -> Attribute a -> m

foldr :: (a -> b -> b) -> b -> Attribute a -> b

foldr' :: (a -> b -> b) -> b -> Attribute a -> b

foldl :: (b -> a -> b) -> b -> Attribute a -> b

foldl' :: (b -> a -> b) -> b -> Attribute a -> b

foldr1 :: (a -> a -> a) -> Attribute a -> a

foldl1 :: (a -> a -> a) -> Attribute a -> a

toList :: Attribute a -> [a]

null :: Attribute a -> Bool

length :: Attribute a -> Int

elem :: Eq a => a -> Attribute a -> Bool

maximum :: Ord a => Attribute a -> a

minimum :: Ord a => Attribute a -> a

sum :: Num a => Attribute a -> a

product :: Num a => Attribute a -> a

Traversable Attribute

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> Attribute a -> f (Attribute b)

sequenceA :: Applicative f => Attribute (f a) -> f (Attribute a)

mapM :: Monad m => (a -> m b) -> Attribute a -> m (Attribute b)

sequence :: Monad m => Attribute (m a) -> m (Attribute a)

SymbolMatching Attribute

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy Attribute -> Node -> Bool

showFailure :: Proxy Attribute -> Node -> String

Unmarshal Attribute

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Attribute a)

Eq a => Eq (Attribute a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (Attribute a)

Defined in TreeSitter.Python.AST

Methods

compare :: Attribute a -> Attribute a -> Ordering

(<) :: Attribute a -> Attribute a -> Bool

(<=) :: Attribute a -> Attribute a -> Bool

(>) :: Attribute a -> Attribute a -> Bool

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

max :: Attribute a -> Attribute a -> Attribute a

min :: Attribute a -> Attribute a -> Attribute a

Show a => Show (Attribute a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> Attribute a -> ShowS

show :: Attribute a -> String

showList :: [Attribute a] -> ShowS

Generic (Attribute a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (Attribute a) :: Type -> Type

Methods

from :: Attribute a -> Rep (Attribute a) x

to :: Rep (Attribute a) x -> Attribute a

Generic1 Attribute

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 Attribute :: k -> Type

Methods

from1 :: Attribute a -> Rep1 Attribute a

to1 :: Rep1 Attribute a -> Attribute a

type Rep (Attribute a)

Defined in TreeSitter.Python.AST

type Rep (Attribute a) = D1 (MetaData "Attribute" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "Attribute" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (NonEmpty ((PrimaryExpression :+: Identifier) a)))))

type Rep1 Attribute

Defined in TreeSitter.Python.AST

type Rep1 Attribute = D1 (MetaData "Attribute" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "Attribute" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (NonEmpty :.: Rec1 (PrimaryExpression :+: Identifier))))

data WithItem a

Constructors

WithItem

Fields

• ann :: a
• value :: (Expression a)
• alias :: (Maybe (Expression a))

Instances

Functor WithItem

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable WithItem

Defined in TreeSitter.Python.AST

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 TreeSitter.Python.AST

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)

SymbolMatching WithItem

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy WithItem -> Node -> Bool

showFailure :: Proxy WithItem -> Node -> String

Unmarshal WithItem

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (WithItem a)

Eq a => Eq (WithItem a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (WithItem a)

Defined in TreeSitter.Python.AST

Methods

compare :: WithItem a -> WithItem a -> Ordering

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

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

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

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

max :: WithItem a -> WithItem a -> WithItem a

min :: WithItem a -> WithItem a -> WithItem a

Show a => Show (WithItem a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> WithItem a -> ShowS

show :: WithItem a -> String

showList :: [WithItem a] -> ShowS

Generic (WithItem a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (WithItem a) :: Type -> Type

Methods

from :: WithItem a -> Rep (WithItem a) x

to :: Rep (WithItem a) x -> WithItem a

Generic1 WithItem

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 WithItem :: k -> Type

Methods

from1 :: WithItem a -> Rep1 WithItem a

to1 :: Rep1 WithItem a -> WithItem a

type Rep (WithItem a)

Defined in TreeSitter.Python.AST

type Rep (WithItem a) = D1 (MetaData "WithItem" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "WithItem" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: (S1 (MetaSel (Just "value") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Expression a)) :*: S1 (MetaSel (Just "alias") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Expression a))))))

type Rep1 WithItem

Defined in TreeSitter.Python.AST

type Rep1 WithItem = D1 (MetaData "WithItem" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "WithItem" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: (S1 (MetaSel (Just "value") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 Expression) :*: S1 (MetaSel (Just "alias") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Maybe :.: Rec1 Expression))))

data ReturnStatement a

Constructors

ReturnStatement

Fields

• ann :: a
• extraChildren :: (Maybe (ExpressionList a))

Instances

Functor ReturnStatement

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable ReturnStatement

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => ReturnStatement m -> m

foldMap :: Monoid m => (a -> m) -> ReturnStatement a -> m

foldr :: (a -> b -> b) -> b -> ReturnStatement a -> b

foldr' :: (a -> b -> b) -> b -> ReturnStatement a -> b

foldl :: (b -> a -> b) -> b -> ReturnStatement a -> b

foldl' :: (b -> a -> b) -> b -> ReturnStatement a -> b

foldr1 :: (a -> a -> a) -> ReturnStatement a -> a

foldl1 :: (a -> a -> a) -> ReturnStatement a -> a

toList :: ReturnStatement a -> [a]

null :: ReturnStatement a -> Bool

length :: ReturnStatement a -> Int

elem :: Eq a => a -> ReturnStatement a -> Bool

maximum :: Ord a => ReturnStatement a -> a

minimum :: Ord a => ReturnStatement a -> a

sum :: Num a => ReturnStatement a -> a

product :: Num a => ReturnStatement a -> a

Traversable ReturnStatement

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> ReturnStatement a -> f (ReturnStatement b)

sequenceA :: Applicative f => ReturnStatement (f a) -> f (ReturnStatement a)

mapM :: Monad m => (a -> m b) -> ReturnStatement a -> m (ReturnStatement b)

sequence :: Monad m => ReturnStatement (m a) -> m (ReturnStatement a)

SymbolMatching ReturnStatement

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy ReturnStatement -> Node -> Bool

showFailure :: Proxy ReturnStatement -> Node -> String

Unmarshal ReturnStatement

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (ReturnStatement a)

Eq a => Eq (ReturnStatement a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (ReturnStatement a)

Defined in TreeSitter.Python.AST

Methods

compare :: ReturnStatement a -> ReturnStatement a -> Ordering

(<) :: ReturnStatement a -> ReturnStatement a -> Bool

(<=) :: ReturnStatement a -> ReturnStatement a -> Bool

(>) :: ReturnStatement a -> ReturnStatement a -> Bool

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

max :: ReturnStatement a -> ReturnStatement a -> ReturnStatement a

min :: ReturnStatement a -> ReturnStatement a -> ReturnStatement a

Show a => Show (ReturnStatement a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> ReturnStatement a -> ShowS

show :: ReturnStatement a -> String

showList :: [ReturnStatement a] -> ShowS

Generic (ReturnStatement a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (ReturnStatement a) :: Type -> Type

Methods

from :: ReturnStatement a -> Rep (ReturnStatement a) x

to :: Rep (ReturnStatement a) x -> ReturnStatement a

Generic1 ReturnStatement

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 ReturnStatement :: k -> Type

Methods

from1 :: ReturnStatement a -> Rep1 ReturnStatement a

to1 :: Rep1 ReturnStatement a -> ReturnStatement a

type Rep (ReturnStatement a)

Defined in TreeSitter.Python.AST

type Rep (ReturnStatement a) = D1 (MetaData "ReturnStatement" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "ReturnStatement" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (ExpressionList a)))))

type Rep1 ReturnStatement

Defined in TreeSitter.Python.AST

type Rep1 ReturnStatement = D1 (MetaData "ReturnStatement" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "ReturnStatement" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Maybe :.: Rec1 ExpressionList)))

data RaiseStatement a

Constructors

RaiseStatement

Fields

• ann :: a
• cause :: (Maybe (Expression a))
• extraChildren :: (Maybe (ExpressionList a))

Instances

Functor RaiseStatement

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable RaiseStatement

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => RaiseStatement m -> m

foldMap :: Monoid m => (a -> m) -> RaiseStatement a -> m

foldr :: (a -> b -> b) -> b -> RaiseStatement a -> b

foldr' :: (a -> b -> b) -> b -> RaiseStatement a -> b

foldl :: (b -> a -> b) -> b -> RaiseStatement a -> b

foldl' :: (b -> a -> b) -> b -> RaiseStatement a -> b

foldr1 :: (a -> a -> a) -> RaiseStatement a -> a

foldl1 :: (a -> a -> a) -> RaiseStatement a -> a

toList :: RaiseStatement a -> [a]

null :: RaiseStatement a -> Bool

length :: RaiseStatement a -> Int

elem :: Eq a => a -> RaiseStatement a -> Bool

maximum :: Ord a => RaiseStatement a -> a

minimum :: Ord a => RaiseStatement a -> a

sum :: Num a => RaiseStatement a -> a

product :: Num a => RaiseStatement a -> a

Traversable RaiseStatement

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> RaiseStatement a -> f (RaiseStatement b)

sequenceA :: Applicative f => RaiseStatement (f a) -> f (RaiseStatement a)

mapM :: Monad m => (a -> m b) -> RaiseStatement a -> m (RaiseStatement b)

sequence :: Monad m => RaiseStatement (m a) -> m (RaiseStatement a)

SymbolMatching RaiseStatement

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy RaiseStatement -> Node -> Bool

showFailure :: Proxy RaiseStatement -> Node -> String

Unmarshal RaiseStatement

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (RaiseStatement a)

Eq a => Eq (RaiseStatement a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (RaiseStatement a)

Defined in TreeSitter.Python.AST

Methods

compare :: RaiseStatement a -> RaiseStatement a -> Ordering

(<) :: RaiseStatement a -> RaiseStatement a -> Bool

(<=) :: RaiseStatement a -> RaiseStatement a -> Bool

(>) :: RaiseStatement a -> RaiseStatement a -> Bool

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

max :: RaiseStatement a -> RaiseStatement a -> RaiseStatement a

min :: RaiseStatement a -> RaiseStatement a -> RaiseStatement a

Show a => Show (RaiseStatement a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> RaiseStatement a -> ShowS

show :: RaiseStatement a -> String

showList :: [RaiseStatement a] -> ShowS

Generic (RaiseStatement a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (RaiseStatement a) :: Type -> Type

Methods

from :: RaiseStatement a -> Rep (RaiseStatement a) x

to :: Rep (RaiseStatement a) x -> RaiseStatement a

Generic1 RaiseStatement

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 RaiseStatement :: k -> Type

Methods

from1 :: RaiseStatement a -> Rep1 RaiseStatement a

to1 :: Rep1 RaiseStatement a -> RaiseStatement a

type Rep (RaiseStatement a)

Defined in TreeSitter.Python.AST

type Rep (RaiseStatement a) = D1 (MetaData "RaiseStatement" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "RaiseStatement" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: (S1 (MetaSel (Just "cause") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Expression a))) :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (ExpressionList a))))))

type Rep1 RaiseStatement

Defined in TreeSitter.Python.AST

type Rep1 RaiseStatement = D1 (MetaData "RaiseStatement" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "RaiseStatement" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: (S1 (MetaSel (Just "cause") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Maybe :.: Rec1 Expression) :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Maybe :.: Rec1 ExpressionList))))

data DeleteStatement a

Constructors

DeleteStatement

Fields

• ann :: a
• extraChildren :: (ExpressionList a)

Instances

Functor DeleteStatement

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable DeleteStatement

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => DeleteStatement m -> m

foldMap :: Monoid m => (a -> m) -> DeleteStatement a -> m

foldr :: (a -> b -> b) -> b -> DeleteStatement a -> b

foldr' :: (a -> b -> b) -> b -> DeleteStatement a -> b

foldl :: (b -> a -> b) -> b -> DeleteStatement a -> b

foldl' :: (b -> a -> b) -> b -> DeleteStatement a -> b

foldr1 :: (a -> a -> a) -> DeleteStatement a -> a

foldl1 :: (a -> a -> a) -> DeleteStatement a -> a

toList :: DeleteStatement a -> [a]

null :: DeleteStatement a -> Bool

length :: DeleteStatement a -> Int

elem :: Eq a => a -> DeleteStatement a -> Bool

maximum :: Ord a => DeleteStatement a -> a

minimum :: Ord a => DeleteStatement a -> a

sum :: Num a => DeleteStatement a -> a

product :: Num a => DeleteStatement a -> a

Traversable DeleteStatement

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> DeleteStatement a -> f (DeleteStatement b)

sequenceA :: Applicative f => DeleteStatement (f a) -> f (DeleteStatement a)

mapM :: Monad m => (a -> m b) -> DeleteStatement a -> m (DeleteStatement b)

sequence :: Monad m => DeleteStatement (m a) -> m (DeleteStatement a)

SymbolMatching DeleteStatement

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy DeleteStatement -> Node -> Bool

showFailure :: Proxy DeleteStatement -> Node -> String

Unmarshal DeleteStatement

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (DeleteStatement a)

Eq a => Eq (DeleteStatement a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (DeleteStatement a)

Defined in TreeSitter.Python.AST

Methods

compare :: DeleteStatement a -> DeleteStatement a -> Ordering

(<) :: DeleteStatement a -> DeleteStatement a -> Bool

(<=) :: DeleteStatement a -> DeleteStatement a -> Bool

(>) :: DeleteStatement a -> DeleteStatement a -> Bool

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

max :: DeleteStatement a -> DeleteStatement a -> DeleteStatement a

min :: DeleteStatement a -> DeleteStatement a -> DeleteStatement a

Show a => Show (DeleteStatement a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> DeleteStatement a -> ShowS

show :: DeleteStatement a -> String

showList :: [DeleteStatement a] -> ShowS

Generic (DeleteStatement a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (DeleteStatement a) :: Type -> Type

Methods

from :: DeleteStatement a -> Rep (DeleteStatement a) x

to :: Rep (DeleteStatement a) x -> DeleteStatement a

Generic1 DeleteStatement

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 DeleteStatement :: k -> Type

Methods

from1 :: DeleteStatement a -> Rep1 DeleteStatement a

to1 :: Rep1 DeleteStatement a -> DeleteStatement a

type Rep (DeleteStatement a)

Defined in TreeSitter.Python.AST

type Rep (DeleteStatement a) = D1 (MetaData "DeleteStatement" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "DeleteStatement" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (ExpressionList a))))

type Rep1 DeleteStatement

Defined in TreeSitter.Python.AST

type Rep1 DeleteStatement = D1 (MetaData "DeleteStatement" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "DeleteStatement" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 ExpressionList)))

data Assignment a

Constructors

Assignment

Fields

• ann :: a
• left :: (ExpressionList a)
• right :: (Maybe ((:+:) Assignment ((:+:) AugmentedAssignment ((:+:) ExpressionList Yield)) a))
• type' :: (Maybe (Type a))

Instances

Functor Assignment

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable Assignment

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => Assignment m -> m

foldMap :: Monoid m => (a -> m) -> Assignment a -> m

foldr :: (a -> b -> b) -> b -> Assignment a -> b

foldr' :: (a -> b -> b) -> b -> Assignment a -> b

foldl :: (b -> a -> b) -> b -> Assignment a -> b

foldl' :: (b -> a -> b) -> b -> Assignment a -> b

foldr1 :: (a -> a -> a) -> Assignment a -> a

foldl1 :: (a -> a -> a) -> Assignment a -> a

toList :: Assignment a -> [a]

null :: Assignment a -> Bool

length :: Assignment a -> Int

elem :: Eq a => a -> Assignment a -> Bool

maximum :: Ord a => Assignment a -> a

minimum :: Ord a => Assignment a -> a

sum :: Num a => Assignment a -> a

product :: Num a => Assignment a -> a

Traversable Assignment

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> Assignment a -> f (Assignment b)

sequenceA :: Applicative f => Assignment (f a) -> f (Assignment a)

mapM :: Monad m => (a -> m b) -> Assignment a -> m (Assignment b)

sequence :: Monad m => Assignment (m a) -> m (Assignment a)

SymbolMatching Assignment

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy Assignment -> Node -> Bool

showFailure :: Proxy Assignment -> Node -> String

Unmarshal Assignment

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Assignment a)

Eq a => Eq (Assignment a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (Assignment a)

Defined in TreeSitter.Python.AST

Methods

compare :: Assignment a -> Assignment a -> Ordering

(<) :: Assignment a -> Assignment a -> Bool

(<=) :: Assignment a -> Assignment a -> Bool

(>) :: Assignment a -> Assignment a -> Bool

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

max :: Assignment a -> Assignment a -> Assignment a

min :: Assignment a -> Assignment a -> Assignment a

Show a => Show (Assignment a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> Assignment a -> ShowS

show :: Assignment a -> String

showList :: [Assignment a] -> ShowS

Generic (Assignment a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (Assignment a) :: Type -> Type

Methods

from :: Assignment a -> Rep (Assignment a) x

to :: Rep (Assignment a) x -> Assignment a

Generic1 Assignment

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 Assignment :: k -> Type

Methods

from1 :: Assignment a -> Rep1 Assignment a

to1 :: Rep1 Assignment a -> Assignment a

type Rep (Assignment a)

Defined in TreeSitter.Python.AST

type Rep (Assignment a) = D1 (MetaData "Assignment" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "Assignment" PrefixI True) ((S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: S1 (MetaSel (Just "left") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (ExpressionList a))) :*: (S1 (MetaSel (Just "right") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe ((Assignment :+: (AugmentedAssignment :+: (ExpressionList :+: Yield))) a))) :*: S1 (MetaSel (Just "type'") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Type a))))))

type Rep1 Assignment

Defined in TreeSitter.Python.AST

type Rep1 Assignment = D1 (MetaData "Assignment" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "Assignment" PrefixI True) ((S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: S1 (MetaSel (Just "left") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 ExpressionList)) :*: (S1 (MetaSel (Just "right") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Maybe :.: Rec1 (Assignment :+: (AugmentedAssignment :+: (ExpressionList :+: Yield)))) :*: S1 (MetaSel (Just "type'") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Maybe :.: Rec1 Type))))

data AugmentedAssignment a

Constructors

AugmentedAssignment

Fields

• ann :: a
• left :: (ExpressionList a)
• right :: ((:+:) Assignment ((:+:) AugmentedAssignment ((:+:) ExpressionList Yield)) a)

Instances

Functor AugmentedAssignment

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AugmentedAssignment

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AugmentedAssignment m -> m

foldMap :: Monoid m => (a -> m) -> AugmentedAssignment a -> m

foldr :: (a -> b -> b) -> b -> AugmentedAssignment a -> b

foldr' :: (a -> b -> b) -> b -> AugmentedAssignment a -> b

foldl :: (b -> a -> b) -> b -> AugmentedAssignment a -> b

foldl' :: (b -> a -> b) -> b -> AugmentedAssignment a -> b

foldr1 :: (a -> a -> a) -> AugmentedAssignment a -> a

foldl1 :: (a -> a -> a) -> AugmentedAssignment a -> a

toList :: AugmentedAssignment a -> [a]

null :: AugmentedAssignment a -> Bool

length :: AugmentedAssignment a -> Int

elem :: Eq a => a -> AugmentedAssignment a -> Bool

maximum :: Ord a => AugmentedAssignment a -> a

minimum :: Ord a => AugmentedAssignment a -> a

sum :: Num a => AugmentedAssignment a -> a

product :: Num a => AugmentedAssignment a -> a

Traversable AugmentedAssignment

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AugmentedAssignment a -> f (AugmentedAssignment b)

sequenceA :: Applicative f => AugmentedAssignment (f a) -> f (AugmentedAssignment a)

mapM :: Monad m => (a -> m b) -> AugmentedAssignment a -> m (AugmentedAssignment b)

sequence :: Monad m => AugmentedAssignment (m a) -> m (AugmentedAssignment a)

SymbolMatching AugmentedAssignment

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AugmentedAssignment -> Node -> Bool

showFailure :: Proxy AugmentedAssignment -> Node -> String

Unmarshal AugmentedAssignment

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AugmentedAssignment a)

Eq a => Eq (AugmentedAssignment a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AugmentedAssignment a)

Defined in TreeSitter.Python.AST

Methods

compare :: AugmentedAssignment a -> AugmentedAssignment a -> Ordering

(<) :: AugmentedAssignment a -> AugmentedAssignment a -> Bool

(<=) :: AugmentedAssignment a -> AugmentedAssignment a -> Bool

(>) :: AugmentedAssignment a -> AugmentedAssignment a -> Bool

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

max :: AugmentedAssignment a -> AugmentedAssignment a -> AugmentedAssignment a

min :: AugmentedAssignment a -> AugmentedAssignment a -> AugmentedAssignment a

Show a => Show (AugmentedAssignment a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AugmentedAssignment a -> ShowS

show :: AugmentedAssignment a -> String

showList :: [AugmentedAssignment a] -> ShowS

Generic (AugmentedAssignment a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AugmentedAssignment a) :: Type -> Type

Methods

from :: AugmentedAssignment a -> Rep (AugmentedAssignment a) x

to :: Rep (AugmentedAssignment a) x -> AugmentedAssignment a

Generic1 AugmentedAssignment

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AugmentedAssignment :: k -> Type

Methods

from1 :: AugmentedAssignment a -> Rep1 AugmentedAssignment a

to1 :: Rep1 AugmentedAssignment a -> AugmentedAssignment a

type Rep (AugmentedAssignment a)

Defined in TreeSitter.Python.AST

type Rep (AugmentedAssignment a) = D1 (MetaData "AugmentedAssignment" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "AugmentedAssignment" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: (S1 (MetaSel (Just "left") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (ExpressionList a)) :*: S1 (MetaSel (Just "right") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ((Assignment :+: (AugmentedAssignment :+: (ExpressionList :+: Yield))) a)))))

type Rep1 AugmentedAssignment

Defined in TreeSitter.Python.AST

type Rep1 AugmentedAssignment = D1 (MetaData "AugmentedAssignment" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "AugmentedAssignment" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: (S1 (MetaSel (Just "left") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 ExpressionList) :*: S1 (MetaSel (Just "right") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 (Assignment :+: (AugmentedAssignment :+: (ExpressionList :+: Yield)))))))

data ExpressionStatement a

Constructors

ExpressionStatement

Fields

• ann :: a
• extraChildren :: (NonEmpty ((:+:) Expression ((:+:) Assignment ((:+:) AugmentedAssignment Yield)) a))

Instances

Functor ExpressionStatement

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable ExpressionStatement

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => ExpressionStatement m -> m

foldMap :: Monoid m => (a -> m) -> ExpressionStatement a -> m

foldr :: (a -> b -> b) -> b -> ExpressionStatement a -> b

foldr' :: (a -> b -> b) -> b -> ExpressionStatement a -> b

foldl :: (b -> a -> b) -> b -> ExpressionStatement a -> b

foldl' :: (b -> a -> b) -> b -> ExpressionStatement a -> b

foldr1 :: (a -> a -> a) -> ExpressionStatement a -> a

foldl1 :: (a -> a -> a) -> ExpressionStatement a -> a

toList :: ExpressionStatement a -> [a]

null :: ExpressionStatement a -> Bool

length :: ExpressionStatement a -> Int

elem :: Eq a => a -> ExpressionStatement a -> Bool

maximum :: Ord a => ExpressionStatement a -> a

minimum :: Ord a => ExpressionStatement a -> a

sum :: Num a => ExpressionStatement a -> a

product :: Num a => ExpressionStatement a -> a

Traversable ExpressionStatement

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> ExpressionStatement a -> f (ExpressionStatement b)

sequenceA :: Applicative f => ExpressionStatement (f a) -> f (ExpressionStatement a)

mapM :: Monad m => (a -> m b) -> ExpressionStatement a -> m (ExpressionStatement b)

sequence :: Monad m => ExpressionStatement (m a) -> m (ExpressionStatement a)

SymbolMatching ExpressionStatement

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy ExpressionStatement -> Node -> Bool

showFailure :: Proxy ExpressionStatement -> Node -> String

Unmarshal ExpressionStatement

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (ExpressionStatement a)

Eq a => Eq (ExpressionStatement a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (ExpressionStatement a)

Defined in TreeSitter.Python.AST

Methods

compare :: ExpressionStatement a -> ExpressionStatement a -> Ordering

(<) :: ExpressionStatement a -> ExpressionStatement a -> Bool

(<=) :: ExpressionStatement a -> ExpressionStatement a -> Bool

(>) :: ExpressionStatement a -> ExpressionStatement a -> Bool

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

max :: ExpressionStatement a -> ExpressionStatement a -> ExpressionStatement a

min :: ExpressionStatement a -> ExpressionStatement a -> ExpressionStatement a

Show a => Show (ExpressionStatement a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> ExpressionStatement a -> ShowS

show :: ExpressionStatement a -> String

showList :: [ExpressionStatement a] -> ShowS

Generic (ExpressionStatement a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (ExpressionStatement a) :: Type -> Type

Methods

from :: ExpressionStatement a -> Rep (ExpressionStatement a) x

to :: Rep (ExpressionStatement a) x -> ExpressionStatement a

Generic1 ExpressionStatement

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 ExpressionStatement :: k -> Type

Methods

from1 :: ExpressionStatement a -> Rep1 ExpressionStatement a

to1 :: Rep1 ExpressionStatement a -> ExpressionStatement a

type Rep (ExpressionStatement a)

Defined in TreeSitter.Python.AST

type Rep (ExpressionStatement a) = D1 (MetaData "ExpressionStatement" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "ExpressionStatement" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (NonEmpty ((Expression :+: (Assignment :+: (AugmentedAssignment :+: Yield))) a)))))

type Rep1 ExpressionStatement

Defined in TreeSitter.Python.AST

type Rep1 ExpressionStatement = D1 (MetaData "ExpressionStatement" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "ExpressionStatement" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (NonEmpty :.: Rec1 (Expression :+: (Assignment :+: (AugmentedAssignment :+: Yield))))))

data ExecStatement a

Constructors

ExecStatement

Fields

• ann :: a
• code :: (String a)
• extraChildren :: ([] (Expression a))

Instances

Functor ExecStatement

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable ExecStatement

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => ExecStatement m -> m

foldMap :: Monoid m => (a -> m) -> ExecStatement a -> m

foldr :: (a -> b -> b) -> b -> ExecStatement a -> b

foldr' :: (a -> b -> b) -> b -> ExecStatement a -> b

foldl :: (b -> a -> b) -> b -> ExecStatement a -> b

foldl' :: (b -> a -> b) -> b -> ExecStatement a -> b

foldr1 :: (a -> a -> a) -> ExecStatement a -> a

foldl1 :: (a -> a -> a) -> ExecStatement a -> a

toList :: ExecStatement a -> [a]

null :: ExecStatement a -> Bool

length :: ExecStatement a -> Int

elem :: Eq a => a -> ExecStatement a -> Bool

maximum :: Ord a => ExecStatement a -> a

minimum :: Ord a => ExecStatement a -> a

sum :: Num a => ExecStatement a -> a

product :: Num a => ExecStatement a -> a

Traversable ExecStatement

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> ExecStatement a -> f (ExecStatement b)

sequenceA :: Applicative f => ExecStatement (f a) -> f (ExecStatement a)

mapM :: Monad m => (a -> m b) -> ExecStatement a -> m (ExecStatement b)

sequence :: Monad m => ExecStatement (m a) -> m (ExecStatement a)

SymbolMatching ExecStatement

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy ExecStatement -> Node -> Bool

showFailure :: Proxy ExecStatement -> Node -> String

Unmarshal ExecStatement

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (ExecStatement a)

Eq a => Eq (ExecStatement a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (ExecStatement a)

Defined in TreeSitter.Python.AST

Methods

compare :: ExecStatement a -> ExecStatement a -> Ordering

(<) :: ExecStatement a -> ExecStatement a -> Bool

(<=) :: ExecStatement a -> ExecStatement a -> Bool

(>) :: ExecStatement a -> ExecStatement a -> Bool

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

max :: ExecStatement a -> ExecStatement a -> ExecStatement a

min :: ExecStatement a -> ExecStatement a -> ExecStatement a

Show a => Show (ExecStatement a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> ExecStatement a -> ShowS

show :: ExecStatement a -> String

showList :: [ExecStatement a] -> ShowS

Generic (ExecStatement a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (ExecStatement a) :: Type -> Type

Methods

from :: ExecStatement a -> Rep (ExecStatement a) x

to :: Rep (ExecStatement a) x -> ExecStatement a

Generic1 ExecStatement

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 ExecStatement :: k -> Type

Methods

from1 :: ExecStatement a -> Rep1 ExecStatement a

to1 :: Rep1 ExecStatement a -> ExecStatement a

type Rep (ExecStatement a)

Defined in TreeSitter.Python.AST

type Rep (ExecStatement a) = D1 (MetaData "ExecStatement" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "ExecStatement" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: (S1 (MetaSel (Just "code") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (String a)) :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Expression a]))))

type Rep1 ExecStatement

Defined in TreeSitter.Python.AST

type Rep1 ExecStatement = D1 (MetaData "ExecStatement" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "ExecStatement" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: (S1 (MetaSel (Just "code") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 String) :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) ([] :.: Rec1 Expression))))

data Parameters a

Constructors

Parameters

Fields

• ann :: a
• extraChildren :: ([] (Parameter a))

Instances

Functor Parameters

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable Parameters

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => Parameters m -> m

foldMap :: Monoid m => (a -> m) -> Parameters a -> m

foldr :: (a -> b -> b) -> b -> Parameters a -> b

foldr' :: (a -> b -> b) -> b -> Parameters a -> b

foldl :: (b -> a -> b) -> b -> Parameters a -> b

foldl' :: (b -> a -> b) -> b -> Parameters a -> b

foldr1 :: (a -> a -> a) -> Parameters a -> a

foldl1 :: (a -> a -> a) -> Parameters a -> a

toList :: Parameters a -> [a]

null :: Parameters a -> Bool

length :: Parameters a -> Int

elem :: Eq a => a -> Parameters a -> Bool

maximum :: Ord a => Parameters a -> a

minimum :: Ord a => Parameters a -> a

sum :: Num a => Parameters a -> a

product :: Num a => Parameters a -> a

Traversable Parameters

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> Parameters a -> f (Parameters b)

sequenceA :: Applicative f => Parameters (f a) -> f (Parameters a)

mapM :: Monad m => (a -> m b) -> Parameters a -> m (Parameters b)

sequence :: Monad m => Parameters (m a) -> m (Parameters a)

SymbolMatching Parameters

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy Parameters -> Node -> Bool

showFailure :: Proxy Parameters -> Node -> String

Unmarshal Parameters

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Parameters a)

Eq a => Eq (Parameters a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (Parameters a)

Defined in TreeSitter.Python.AST

Methods

compare :: Parameters a -> Parameters a -> Ordering

(<) :: Parameters a -> Parameters a -> Bool

(<=) :: Parameters a -> Parameters a -> Bool

(>) :: Parameters a -> Parameters a -> Bool

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

max :: Parameters a -> Parameters a -> Parameters a

min :: Parameters a -> Parameters a -> Parameters a

Show a => Show (Parameters a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> Parameters a -> ShowS

show :: Parameters a -> String

showList :: [Parameters a] -> ShowS

Generic (Parameters a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (Parameters a) :: Type -> Type

Methods

from :: Parameters a -> Rep (Parameters a) x

to :: Rep (Parameters a) x -> Parameters a

Generic1 Parameters

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 Parameters :: k -> Type

Methods

from1 :: Parameters a -> Rep1 Parameters a

to1 :: Rep1 Parameters a -> Parameters a

type Rep (Parameters a)

Defined in TreeSitter.Python.AST

type Rep (Parameters a) = D1 (MetaData "Parameters" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "Parameters" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Parameter a])))

type Rep1 Parameters

Defined in TreeSitter.Python.AST

type Rep1 Parameters = D1 (MetaData "Parameters" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "Parameters" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) ([] :.: Rec1 Parameter)))

data Chevron a

Constructors

Chevron

Fields

• ann :: a
• extraChildren :: (Expression a)

Instances

Functor Chevron

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable Chevron

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => Chevron m -> m

foldMap :: Monoid m => (a -> m) -> Chevron a -> m

foldr :: (a -> b -> b) -> b -> Chevron a -> b

foldr' :: (a -> b -> b) -> b -> Chevron a -> b

foldl :: (b -> a -> b) -> b -> Chevron a -> b

foldl' :: (b -> a -> b) -> b -> Chevron a -> b

foldr1 :: (a -> a -> a) -> Chevron a -> a

foldl1 :: (a -> a -> a) -> Chevron a -> a

toList :: Chevron a -> [a]

null :: Chevron a -> Bool

length :: Chevron a -> Int

elem :: Eq a => a -> Chevron a -> Bool

maximum :: Ord a => Chevron a -> a

minimum :: Ord a => Chevron a -> a

sum :: Num a => Chevron a -> a

product :: Num a => Chevron a -> a

Traversable Chevron

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> Chevron a -> f (Chevron b)

sequenceA :: Applicative f => Chevron (f a) -> f (Chevron a)

mapM :: Monad m => (a -> m b) -> Chevron a -> m (Chevron b)

sequence :: Monad m => Chevron (m a) -> m (Chevron a)

SymbolMatching Chevron

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy Chevron -> Node -> Bool

showFailure :: Proxy Chevron -> Node -> String

Unmarshal Chevron

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Chevron a)

Eq a => Eq (Chevron a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (Chevron a)

Defined in TreeSitter.Python.AST

Methods

compare :: Chevron a -> Chevron a -> Ordering

(<) :: Chevron a -> Chevron a -> Bool

(<=) :: Chevron a -> Chevron a -> Bool

(>) :: Chevron a -> Chevron a -> Bool

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

max :: Chevron a -> Chevron a -> Chevron a

min :: Chevron a -> Chevron a -> Chevron a

Show a => Show (Chevron a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> Chevron a -> ShowS

show :: Chevron a -> String

showList :: [Chevron a] -> ShowS

Generic (Chevron a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (Chevron a) :: Type -> Type

Methods

from :: Chevron a -> Rep (Chevron a) x

to :: Rep (Chevron a) x -> Chevron a

Generic1 Chevron

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 Chevron :: k -> Type

Methods

from1 :: Chevron a -> Rep1 Chevron a

to1 :: Rep1 Chevron a -> Chevron a

type Rep (Chevron a)

Defined in TreeSitter.Python.AST

type Rep (Chevron a) = D1 (MetaData "Chevron" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "Chevron" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Expression a))))

type Rep1 Chevron

Defined in TreeSitter.Python.AST

type Rep1 Chevron = D1 (MetaData "Chevron" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "Chevron" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 Expression)))

data PrintStatement a

Constructors

PrintStatement

Fields

• ann :: a
• argument :: ([] (Expression a))
• extraChildren :: ([] (Chevron a))

Instances

Functor PrintStatement

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable PrintStatement

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => PrintStatement m -> m

foldMap :: Monoid m => (a -> m) -> PrintStatement a -> m

foldr :: (a -> b -> b) -> b -> PrintStatement a -> b

foldr' :: (a -> b -> b) -> b -> PrintStatement a -> b

foldl :: (b -> a -> b) -> b -> PrintStatement a -> b

foldl' :: (b -> a -> b) -> b -> PrintStatement a -> b

foldr1 :: (a -> a -> a) -> PrintStatement a -> a

foldl1 :: (a -> a -> a) -> PrintStatement a -> a

toList :: PrintStatement a -> [a]

null :: PrintStatement a -> Bool

length :: PrintStatement a -> Int

elem :: Eq a => a -> PrintStatement a -> Bool

maximum :: Ord a => PrintStatement a -> a

minimum :: Ord a => PrintStatement a -> a

sum :: Num a => PrintStatement a -> a

product :: Num a => PrintStatement a -> a

Traversable PrintStatement

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> PrintStatement a -> f (PrintStatement b)

sequenceA :: Applicative f => PrintStatement (f a) -> f (PrintStatement a)

mapM :: Monad m => (a -> m b) -> PrintStatement a -> m (PrintStatement b)

sequence :: Monad m => PrintStatement (m a) -> m (PrintStatement a)

SymbolMatching PrintStatement

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy PrintStatement -> Node -> Bool

showFailure :: Proxy PrintStatement -> Node -> String

Unmarshal PrintStatement

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (PrintStatement a)

Eq a => Eq (PrintStatement a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (PrintStatement a)

Defined in TreeSitter.Python.AST

Methods

compare :: PrintStatement a -> PrintStatement a -> Ordering

(<) :: PrintStatement a -> PrintStatement a -> Bool

(<=) :: PrintStatement a -> PrintStatement a -> Bool

(>) :: PrintStatement a -> PrintStatement a -> Bool

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

max :: PrintStatement a -> PrintStatement a -> PrintStatement a

min :: PrintStatement a -> PrintStatement a -> PrintStatement a

Show a => Show (PrintStatement a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> PrintStatement a -> ShowS

show :: PrintStatement a -> String

showList :: [PrintStatement a] -> ShowS

Generic (PrintStatement a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (PrintStatement a) :: Type -> Type

Methods

from :: PrintStatement a -> Rep (PrintStatement a) x

to :: Rep (PrintStatement a) x -> PrintStatement a

Generic1 PrintStatement

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 PrintStatement :: k -> Type

Methods

from1 :: PrintStatement a -> Rep1 PrintStatement a

to1 :: Rep1 PrintStatement a -> PrintStatement a

type Rep (PrintStatement a)

Defined in TreeSitter.Python.AST

type Rep (PrintStatement a) = D1 (MetaData "PrintStatement" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "PrintStatement" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: (S1 (MetaSel (Just "argument") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Expression a]) :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Chevron a]))))

type Rep1 PrintStatement

Defined in TreeSitter.Python.AST

type Rep1 PrintStatement = D1 (MetaData "PrintStatement" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "PrintStatement" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: (S1 (MetaSel (Just "argument") NoSourceUnpackedness NoSourceStrictness DecidedLazy) ([] :.: Rec1 Expression) :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) ([] :.: Rec1 Chevron))))

data AssertStatement a

Constructors

AssertStatement

Fields

• ann :: a
• extraChildren :: (NonEmpty (Expression a))

Instances

Functor AssertStatement

Defined in TreeSitter.Python.AST

Methods

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

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

Foldable AssertStatement

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AssertStatement m -> m

foldMap :: Monoid m => (a -> m) -> AssertStatement a -> m

foldr :: (a -> b -> b) -> b -> AssertStatement a -> b

foldr' :: (a -> b -> b) -> b -> AssertStatement a -> b

foldl :: (b -> a -> b) -> b -> AssertStatement a -> b

foldl' :: (b -> a -> b) -> b -> AssertStatement a -> b

foldr1 :: (a -> a -> a) -> AssertStatement a -> a

foldl1 :: (a -> a -> a) -> AssertStatement a -> a

toList :: AssertStatement a -> [a]

null :: AssertStatement a -> Bool

length :: AssertStatement a -> Int

elem :: Eq a => a -> AssertStatement a -> Bool

maximum :: Ord a => AssertStatement a -> a

minimum :: Ord a => AssertStatement a -> a

sum :: Num a => AssertStatement a -> a

product :: Num a => AssertStatement a -> a

Traversable AssertStatement

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AssertStatement a -> f (AssertStatement b)

sequenceA :: Applicative f => AssertStatement (f a) -> f (AssertStatement a)

mapM :: Monad m => (a -> m b) -> AssertStatement a -> m (AssertStatement b)

sequence :: Monad m => AssertStatement (m a) -> m (AssertStatement a)

SymbolMatching AssertStatement

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AssertStatement -> Node -> Bool

showFailure :: Proxy AssertStatement -> Node -> String

Unmarshal AssertStatement

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AssertStatement a)

Eq a => Eq (AssertStatement a)

Defined in TreeSitter.Python.AST

Methods

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

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

Ord a => Ord (AssertStatement a)

Defined in TreeSitter.Python.AST

Methods

compare :: AssertStatement a -> AssertStatement a -> Ordering

(<) :: AssertStatement a -> AssertStatement a -> Bool

(<=) :: AssertStatement a -> AssertStatement a -> Bool

(>) :: AssertStatement a -> AssertStatement a -> Bool

(>=) :: AssertStatement a -> AssertStatement a -> Bool

max :: AssertStatement a -> AssertStatement a -> AssertStatement a

min :: AssertStatement a -> AssertStatement a -> AssertStatement a

Show a => Show (AssertStatement a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AssertStatement a -> ShowS

show :: AssertStatement a -> String

showList :: [AssertStatement a] -> ShowS

Generic (AssertStatement a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AssertStatement a) :: Type -> Type

Methods

from :: AssertStatement a -> Rep (AssertStatement a) x

to :: Rep (AssertStatement a) x -> AssertStatement a

Generic1 AssertStatement

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AssertStatement :: k -> Type

Methods

from1 :: AssertStatement a -> Rep1 AssertStatement a

to1 :: Rep1 AssertStatement a -> AssertStatement a

type Rep (AssertStatement a)

Defined in TreeSitter.Python.AST

type Rep (AssertStatement a) = D1 (MetaData "AssertStatement" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "AssertStatement" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (NonEmpty (Expression a)))))

type Rep1 AssertStatement

Defined in TreeSitter.Python.AST

type Rep1 AssertStatement = D1 (MetaData "AssertStatement" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "AssertStatement" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (NonEmpty :.: Rec1 Expression)))

data SimpleStatement a

Constructors

AssertStatementSimpleStatement (AssertStatement a)

BreakStatementSimpleStatement (BreakStatement a)

ContinueStatementSimpleStatement (ContinueStatement a)

DeleteStatementSimpleStatement (DeleteStatement a)

ExecStatementSimpleStatement (ExecStatement a)

ExpressionStatementSimpleStatement (ExpressionStatement a)

FutureImportStatementSimpleStatement (FutureImportStatement a)

GlobalStatementSimpleStatement (GlobalStatement a)

ImportFromStatementSimpleStatement (ImportFromStatement a)

ImportStatementSimpleStatement (ImportStatement a)

NonlocalStatementSimpleStatement (NonlocalStatement a)

PassStatementSimpleStatement (PassStatement a)

PrintStatementSimpleStatement (PrintStatement a)

RaiseStatementSimpleStatement (RaiseStatement a)

ReturnStatementSimpleStatement (ReturnStatement a)

Instances

Functor SimpleStatement

Defined in TreeSitter.Python.AST

Methods

fmap :: (a -> b) -> SimpleStatement a -> SimpleStatement b

(<$) :: a -> SimpleStatement b -> SimpleStatement a

Foldable SimpleStatement

Defined in TreeSitter.Python.AST

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 TreeSitter.Python.AST

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)

SymbolMatching SimpleStatement

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy SimpleStatement -> Node -> Bool

showFailure :: Proxy SimpleStatement -> Node -> String

Unmarshal SimpleStatement

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (SimpleStatement a)

Eq a => Eq (SimpleStatement a)

Defined in TreeSitter.Python.AST

Methods

(==) :: SimpleStatement a -> SimpleStatement a -> Bool

(/=) :: SimpleStatement a -> SimpleStatement a -> Bool

Ord a => Ord (SimpleStatement a)

Defined in TreeSitter.Python.AST

Methods

compare :: SimpleStatement a -> SimpleStatement a -> Ordering

(<) :: SimpleStatement a -> SimpleStatement a -> Bool

(<=) :: SimpleStatement a -> SimpleStatement a -> Bool

(>) :: SimpleStatement a -> SimpleStatement a -> Bool

(>=) :: SimpleStatement a -> SimpleStatement a -> Bool

max :: SimpleStatement a -> SimpleStatement a -> SimpleStatement a

min :: SimpleStatement a -> SimpleStatement a -> SimpleStatement a

Show a => Show (SimpleStatement a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> SimpleStatement a -> ShowS

show :: SimpleStatement a -> String

showList :: [SimpleStatement a] -> ShowS

Generic (SimpleStatement a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (SimpleStatement a) :: Type -> Type

Methods

from :: SimpleStatement a -> Rep (SimpleStatement a) x

to :: Rep (SimpleStatement a) x -> SimpleStatement a

Generic1 SimpleStatement

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 SimpleStatement :: k -> Type

Methods

from1 :: SimpleStatement a -> Rep1 SimpleStatement a

to1 :: Rep1 SimpleStatement a -> SimpleStatement a

type Rep (SimpleStatement a)

Defined in TreeSitter.Python.AST

type Rep (SimpleStatement a) = D1 (MetaData "SimpleStatement" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (((C1 (MetaCons "AssertStatementSimpleStatement" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AssertStatement a))) :+: (C1 (MetaCons "BreakStatementSimpleStatement" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (BreakStatement a))) :+: C1 (MetaCons "ContinueStatementSimpleStatement" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (ContinueStatement a))))) :+: ((C1 (MetaCons "DeleteStatementSimpleStatement" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (DeleteStatement a))) :+: C1 (MetaCons "ExecStatementSimpleStatement" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (ExecStatement a)))) :+: (C1 (MetaCons "ExpressionStatementSimpleStatement" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (ExpressionStatement a))) :+: C1 (MetaCons "FutureImportStatementSimpleStatement" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (FutureImportStatement a)))))) :+: (((C1 (MetaCons "GlobalStatementSimpleStatement" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (GlobalStatement a))) :+: C1 (MetaCons "ImportFromStatementSimpleStatement" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (ImportFromStatement a)))) :+: (C1 (MetaCons "ImportStatementSimpleStatement" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (ImportStatement a))) :+: C1 (MetaCons "NonlocalStatementSimpleStatement" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (NonlocalStatement a))))) :+: ((C1 (MetaCons "PassStatementSimpleStatement" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (PassStatement a))) :+: C1 (MetaCons "PrintStatementSimpleStatement" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (PrintStatement a)))) :+: (C1 (MetaCons "RaiseStatementSimpleStatement" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (RaiseStatement a))) :+: C1 (MetaCons "ReturnStatementSimpleStatement" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (ReturnStatement a)))))))

type Rep1 SimpleStatement

Defined in TreeSitter.Python.AST

type Rep1 SimpleStatement = D1 (MetaData "SimpleStatement" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (((C1 (MetaCons "AssertStatementSimpleStatement" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 AssertStatement)) :+: (C1 (MetaCons "BreakStatementSimpleStatement" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 BreakStatement)) :+: C1 (MetaCons "ContinueStatementSimpleStatement" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 ContinueStatement)))) :+: ((C1 (MetaCons "DeleteStatementSimpleStatement" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 DeleteStatement)) :+: C1 (MetaCons "ExecStatementSimpleStatement" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 ExecStatement))) :+: (C1 (MetaCons "ExpressionStatementSimpleStatement" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 ExpressionStatement)) :+: C1 (MetaCons "FutureImportStatementSimpleStatement" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 FutureImportStatement))))) :+: (((C1 (MetaCons "GlobalStatementSimpleStatement" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 GlobalStatement)) :+: C1 (MetaCons "ImportFromStatementSimpleStatement" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 ImportFromStatement))) :+: (C1 (MetaCons "ImportStatementSimpleStatement" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 ImportStatement)) :+: C1 (MetaCons "NonlocalStatementSimpleStatement" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 NonlocalStatement)))) :+: ((C1 (MetaCons "PassStatementSimpleStatement" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 PassStatement)) :+: C1 (MetaCons "PrintStatementSimpleStatement" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 PrintStatement))) :+: (C1 (MetaCons "RaiseStatementSimpleStatement" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 RaiseStatement)) :+: C1 (MetaCons "ReturnStatementSimpleStatement" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 ReturnStatement))))))

data Decorator a

Constructors

Decorator

Fields

• ann :: a
• arguments :: (Maybe (ArgumentList a))
• extraChildren :: (DottedName a)

Instances

Functor Decorator

Defined in TreeSitter.Python.AST

Methods

fmap :: (a -> b) -> Decorator a -> Decorator b

(<$) :: a -> Decorator b -> Decorator a

Foldable Decorator

Defined in TreeSitter.Python.AST

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 TreeSitter.Python.AST

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)

SymbolMatching Decorator

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy Decorator -> Node -> Bool

showFailure :: Proxy Decorator -> Node -> String

Unmarshal Decorator

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Decorator a)

Eq a => Eq (Decorator a)

Defined in TreeSitter.Python.AST

Methods

(==) :: Decorator a -> Decorator a -> Bool

(/=) :: Decorator a -> Decorator a -> Bool

Ord a => Ord (Decorator a)

Defined in TreeSitter.Python.AST

Methods

compare :: Decorator a -> Decorator a -> Ordering

(<) :: Decorator a -> Decorator a -> Bool

(<=) :: Decorator a -> Decorator a -> Bool

(>) :: Decorator a -> Decorator a -> Bool

(>=) :: Decorator a -> Decorator a -> Bool

max :: Decorator a -> Decorator a -> Decorator a

min :: Decorator a -> Decorator a -> Decorator a

Show a => Show (Decorator a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> Decorator a -> ShowS

show :: Decorator a -> String

showList :: [Decorator a] -> ShowS

Generic (Decorator a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (Decorator a) :: Type -> Type

Methods

from :: Decorator a -> Rep (Decorator a) x

to :: Rep (Decorator a) x -> Decorator a

Generic1 Decorator

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 Decorator :: k -> Type

Methods

from1 :: Decorator a -> Rep1 Decorator a

to1 :: Rep1 Decorator a -> Decorator a

type Rep (Decorator a)

Defined in TreeSitter.Python.AST

type Rep (Decorator a) = D1 (MetaData "Decorator" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "Decorator" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: (S1 (MetaSel (Just "arguments") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (ArgumentList a))) :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (DottedName a)))))

type Rep1 Decorator

Defined in TreeSitter.Python.AST

type Rep1 Decorator = D1 (MetaData "Decorator" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "Decorator" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: (S1 (MetaSel (Just "arguments") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Maybe :.: Rec1 ArgumentList) :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 DottedName))))

data ClassDefinition a

Constructors

ClassDefinition

Fields

• ann :: a
• body :: (Block a)
• superclasses :: (Maybe (ArgumentList a))
• name :: (Identifier a)

Instances

Functor ClassDefinition

Defined in TreeSitter.Python.AST

Methods

fmap :: (a -> b) -> ClassDefinition a -> ClassDefinition b

(<$) :: a -> ClassDefinition b -> ClassDefinition a

Foldable ClassDefinition

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => ClassDefinition m -> m

foldMap :: Monoid m => (a -> m) -> ClassDefinition a -> m

foldr :: (a -> b -> b) -> b -> ClassDefinition a -> b

foldr' :: (a -> b -> b) -> b -> ClassDefinition a -> b

foldl :: (b -> a -> b) -> b -> ClassDefinition a -> b

foldl' :: (b -> a -> b) -> b -> ClassDefinition a -> b

foldr1 :: (a -> a -> a) -> ClassDefinition a -> a

foldl1 :: (a -> a -> a) -> ClassDefinition a -> a

toList :: ClassDefinition a -> [a]

null :: ClassDefinition a -> Bool

length :: ClassDefinition a -> Int

elem :: Eq a => a -> ClassDefinition a -> Bool

maximum :: Ord a => ClassDefinition a -> a

minimum :: Ord a => ClassDefinition a -> a

sum :: Num a => ClassDefinition a -> a

product :: Num a => ClassDefinition a -> a

Traversable ClassDefinition

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> ClassDefinition a -> f (ClassDefinition b)

sequenceA :: Applicative f => ClassDefinition (f a) -> f (ClassDefinition a)

mapM :: Monad m => (a -> m b) -> ClassDefinition a -> m (ClassDefinition b)

sequence :: Monad m => ClassDefinition (m a) -> m (ClassDefinition a)

SymbolMatching ClassDefinition

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy ClassDefinition -> Node -> Bool

showFailure :: Proxy ClassDefinition -> Node -> String

Unmarshal ClassDefinition

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (ClassDefinition a)

Eq a => Eq (ClassDefinition a)

Defined in TreeSitter.Python.AST

Methods

(==) :: ClassDefinition a -> ClassDefinition a -> Bool

(/=) :: ClassDefinition a -> ClassDefinition a -> Bool

Ord a => Ord (ClassDefinition a)

Defined in TreeSitter.Python.AST

Methods

compare :: ClassDefinition a -> ClassDefinition a -> Ordering

(<) :: ClassDefinition a -> ClassDefinition a -> Bool

(<=) :: ClassDefinition a -> ClassDefinition a -> Bool

(>) :: ClassDefinition a -> ClassDefinition a -> Bool

(>=) :: ClassDefinition a -> ClassDefinition a -> Bool

max :: ClassDefinition a -> ClassDefinition a -> ClassDefinition a

min :: ClassDefinition a -> ClassDefinition a -> ClassDefinition a

Show a => Show (ClassDefinition a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> ClassDefinition a -> ShowS

show :: ClassDefinition a -> String

showList :: [ClassDefinition a] -> ShowS

Generic (ClassDefinition a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (ClassDefinition a) :: Type -> Type

Methods

from :: ClassDefinition a -> Rep (ClassDefinition a) x

to :: Rep (ClassDefinition a) x -> ClassDefinition a

Generic1 ClassDefinition

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 ClassDefinition :: k -> Type

Methods

from1 :: ClassDefinition a -> Rep1 ClassDefinition a

to1 :: Rep1 ClassDefinition a -> ClassDefinition a

type Rep (ClassDefinition a)

Defined in TreeSitter.Python.AST

type Rep (ClassDefinition a) = D1 (MetaData "ClassDefinition" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "ClassDefinition" PrefixI True) ((S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: S1 (MetaSel (Just "body") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Block a))) :*: (S1 (MetaSel (Just "superclasses") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (ArgumentList a))) :*: S1 (MetaSel (Just "name") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Identifier a)))))

type Rep1 ClassDefinition

Defined in TreeSitter.Python.AST

type Rep1 ClassDefinition = D1 (MetaData "ClassDefinition" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "ClassDefinition" PrefixI True) ((S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: S1 (MetaSel (Just "body") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 Block)) :*: (S1 (MetaSel (Just "superclasses") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Maybe :.: Rec1 ArgumentList) :*: S1 (MetaSel (Just "name") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 Identifier))))

data Block a

Constructors

Block

Fields

• ann :: a
• extraChildren :: ([] ((:+:) CompoundStatement SimpleStatement a))

Instances

Functor Block

Defined in TreeSitter.Python.AST

Methods

fmap :: (a -> b) -> Block a -> Block b

(<$) :: a -> Block b -> Block a

Foldable Block

Defined in TreeSitter.Python.AST

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 TreeSitter.Python.AST

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)

SymbolMatching Block

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy Block -> Node -> Bool

showFailure :: Proxy Block -> Node -> String

Unmarshal Block

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Block a)

Eq a => Eq (Block a)

Defined in TreeSitter.Python.AST

Methods

(==) :: Block a -> Block a -> Bool

(/=) :: Block a -> Block a -> Bool

Ord a => Ord (Block a)

Defined in TreeSitter.Python.AST

Methods

compare :: Block a -> Block a -> Ordering

(<) :: Block a -> Block a -> Bool

(<=) :: Block a -> Block a -> Bool

(>) :: Block a -> Block a -> Bool

(>=) :: Block a -> Block a -> Bool

max :: Block a -> Block a -> Block a

min :: Block a -> Block a -> Block a

Show a => Show (Block a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> Block a -> ShowS

show :: Block a -> String

showList :: [Block a] -> ShowS

Generic (Block a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (Block a) :: Type -> Type

Methods

from :: Block a -> Rep (Block a) x

to :: Rep (Block a) x -> Block a

Generic1 Block

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 Block :: k -> Type

Methods

from1 :: Block a -> Rep1 Block a

to1 :: Rep1 Block a -> Block a

type Rep (Block a)

Defined in TreeSitter.Python.AST

type Rep (Block a) = D1 (MetaData "Block" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "Block" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [(CompoundStatement :+: SimpleStatement) a])))

type Rep1 Block

Defined in TreeSitter.Python.AST

type Rep1 Block = D1 (MetaData "Block" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "Block" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) ([] :.: Rec1 (CompoundStatement :+: SimpleStatement))))

data CompoundStatement a

Constructors

ClassDefinitionCompoundStatement (ClassDefinition a)

DecoratedDefinitionCompoundStatement (DecoratedDefinition a)

ForStatementCompoundStatement (ForStatement a)

FunctionDefinitionCompoundStatement (FunctionDefinition a)

IfStatementCompoundStatement (IfStatement a)

TryStatementCompoundStatement (TryStatement a)

WhileStatementCompoundStatement (WhileStatement a)

WithStatementCompoundStatement (WithStatement a)

Instances

Functor CompoundStatement

Defined in TreeSitter.Python.AST

Methods

fmap :: (a -> b) -> CompoundStatement a -> CompoundStatement b

(<$) :: a -> CompoundStatement b -> CompoundStatement a

Foldable CompoundStatement

Defined in TreeSitter.Python.AST

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 TreeSitter.Python.AST

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)

SymbolMatching CompoundStatement

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy CompoundStatement -> Node -> Bool

showFailure :: Proxy CompoundStatement -> Node -> String

Unmarshal CompoundStatement

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (CompoundStatement a)

Eq a => Eq (CompoundStatement a)

Defined in TreeSitter.Python.AST

Methods

(==) :: CompoundStatement a -> CompoundStatement a -> Bool

(/=) :: CompoundStatement a -> CompoundStatement a -> Bool

Ord a => Ord (CompoundStatement a)

Defined in TreeSitter.Python.AST

Methods

compare :: CompoundStatement a -> CompoundStatement a -> Ordering

(<) :: CompoundStatement a -> CompoundStatement a -> Bool

(<=) :: CompoundStatement a -> CompoundStatement a -> Bool

(>) :: CompoundStatement a -> CompoundStatement a -> Bool

(>=) :: CompoundStatement a -> CompoundStatement a -> Bool

max :: CompoundStatement a -> CompoundStatement a -> CompoundStatement a

min :: CompoundStatement a -> CompoundStatement a -> CompoundStatement a

Show a => Show (CompoundStatement a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> CompoundStatement a -> ShowS

show :: CompoundStatement a -> String

showList :: [CompoundStatement a] -> ShowS

Generic (CompoundStatement a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (CompoundStatement a) :: Type -> Type

Methods

from :: CompoundStatement a -> Rep (CompoundStatement a) x

to :: Rep (CompoundStatement a) x -> CompoundStatement a

Generic1 CompoundStatement

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 CompoundStatement :: k -> Type

Methods

from1 :: CompoundStatement a -> Rep1 CompoundStatement a

to1 :: Rep1 CompoundStatement a -> CompoundStatement a

type Rep (CompoundStatement a)

Defined in TreeSitter.Python.AST

type Rep (CompoundStatement a) = D1 (MetaData "CompoundStatement" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (((C1 (MetaCons "ClassDefinitionCompoundStatement" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (ClassDefinition a))) :+: C1 (MetaCons "DecoratedDefinitionCompoundStatement" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (DecoratedDefinition a)))) :+: (C1 (MetaCons "ForStatementCompoundStatement" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (ForStatement a))) :+: C1 (MetaCons "FunctionDefinitionCompoundStatement" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (FunctionDefinition a))))) :+: ((C1 (MetaCons "IfStatementCompoundStatement" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (IfStatement a))) :+: C1 (MetaCons "TryStatementCompoundStatement" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (TryStatement a)))) :+: (C1 (MetaCons "WhileStatementCompoundStatement" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (WhileStatement a))) :+: C1 (MetaCons "WithStatementCompoundStatement" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (WithStatement a))))))

type Rep1 CompoundStatement

Defined in TreeSitter.Python.AST

type Rep1 CompoundStatement = D1 (MetaData "CompoundStatement" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (((C1 (MetaCons "ClassDefinitionCompoundStatement" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 ClassDefinition)) :+: C1 (MetaCons "DecoratedDefinitionCompoundStatement" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 DecoratedDefinition))) :+: (C1 (MetaCons "ForStatementCompoundStatement" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 ForStatement)) :+: C1 (MetaCons "FunctionDefinitionCompoundStatement" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 FunctionDefinition)))) :+: ((C1 (MetaCons "IfStatementCompoundStatement" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 IfStatement)) :+: C1 (MetaCons "TryStatementCompoundStatement" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 TryStatement))) :+: (C1 (MetaCons "WhileStatementCompoundStatement" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 WhileStatement)) :+: C1 (MetaCons "WithStatementCompoundStatement" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 WithStatement)))))

data WithStatement a

Constructors

WithStatement

Fields

• ann :: a
• body :: (Block a)
• extraChildren :: (NonEmpty (WithItem a))

Instances

Functor WithStatement

Defined in TreeSitter.Python.AST

Methods

fmap :: (a -> b) -> WithStatement a -> WithStatement b

(<$) :: a -> WithStatement b -> WithStatement a

Foldable WithStatement

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => WithStatement m -> m

foldMap :: Monoid m => (a -> m) -> WithStatement a -> m

foldr :: (a -> b -> b) -> b -> WithStatement a -> b

foldr' :: (a -> b -> b) -> b -> WithStatement a -> b

foldl :: (b -> a -> b) -> b -> WithStatement a -> b

foldl' :: (b -> a -> b) -> b -> WithStatement a -> b

foldr1 :: (a -> a -> a) -> WithStatement a -> a

foldl1 :: (a -> a -> a) -> WithStatement a -> a

toList :: WithStatement a -> [a]

null :: WithStatement a -> Bool

length :: WithStatement a -> Int

elem :: Eq a => a -> WithStatement a -> Bool

maximum :: Ord a => WithStatement a -> a

minimum :: Ord a => WithStatement a -> a

sum :: Num a => WithStatement a -> a

product :: Num a => WithStatement a -> a

Traversable WithStatement

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> WithStatement a -> f (WithStatement b)

sequenceA :: Applicative f => WithStatement (f a) -> f (WithStatement a)

mapM :: Monad m => (a -> m b) -> WithStatement a -> m (WithStatement b)

sequence :: Monad m => WithStatement (m a) -> m (WithStatement a)

SymbolMatching WithStatement

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy WithStatement -> Node -> Bool

showFailure :: Proxy WithStatement -> Node -> String

Unmarshal WithStatement

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (WithStatement a)

Eq a => Eq (WithStatement a)

Defined in TreeSitter.Python.AST

Methods

(==) :: WithStatement a -> WithStatement a -> Bool

(/=) :: WithStatement a -> WithStatement a -> Bool

Ord a => Ord (WithStatement a)

Defined in TreeSitter.Python.AST

Methods

compare :: WithStatement a -> WithStatement a -> Ordering

(<) :: WithStatement a -> WithStatement a -> Bool

(<=) :: WithStatement a -> WithStatement a -> Bool

(>) :: WithStatement a -> WithStatement a -> Bool

(>=) :: WithStatement a -> WithStatement a -> Bool

max :: WithStatement a -> WithStatement a -> WithStatement a

min :: WithStatement a -> WithStatement a -> WithStatement a

Show a => Show (WithStatement a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> WithStatement a -> ShowS

show :: WithStatement a -> String

showList :: [WithStatement a] -> ShowS

Generic (WithStatement a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (WithStatement a) :: Type -> Type

Methods

from :: WithStatement a -> Rep (WithStatement a) x

to :: Rep (WithStatement a) x -> WithStatement a

Generic1 WithStatement

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 WithStatement :: k -> Type

Methods

from1 :: WithStatement a -> Rep1 WithStatement a

to1 :: Rep1 WithStatement a -> WithStatement a

type Rep (WithStatement a)

Defined in TreeSitter.Python.AST

type Rep (WithStatement a) = D1 (MetaData "WithStatement" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "WithStatement" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: (S1 (MetaSel (Just "body") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Block a)) :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (NonEmpty (WithItem a))))))

type Rep1 WithStatement

Defined in TreeSitter.Python.AST

type Rep1 WithStatement = D1 (MetaData "WithStatement" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "WithStatement" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: (S1 (MetaSel (Just "body") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 Block) :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (NonEmpty :.: Rec1 WithItem))))

data WhileStatement a

Constructors

WhileStatement

Fields

• ann :: a
• alternative :: (Maybe (ElseClause a))
• body :: (Block a)
• condition :: (Expression a)

Instances

Functor WhileStatement

Defined in TreeSitter.Python.AST

Methods

fmap :: (a -> b) -> WhileStatement a -> WhileStatement b

(<$) :: a -> WhileStatement b -> WhileStatement a

Foldable WhileStatement

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => WhileStatement m -> m

foldMap :: Monoid m => (a -> m) -> WhileStatement a -> m

foldr :: (a -> b -> b) -> b -> WhileStatement a -> b

foldr' :: (a -> b -> b) -> b -> WhileStatement a -> b

foldl :: (b -> a -> b) -> b -> WhileStatement a -> b

foldl' :: (b -> a -> b) -> b -> WhileStatement a -> b

foldr1 :: (a -> a -> a) -> WhileStatement a -> a

foldl1 :: (a -> a -> a) -> WhileStatement a -> a

toList :: WhileStatement a -> [a]

null :: WhileStatement a -> Bool

length :: WhileStatement a -> Int

elem :: Eq a => a -> WhileStatement a -> Bool

maximum :: Ord a => WhileStatement a -> a

minimum :: Ord a => WhileStatement a -> a

sum :: Num a => WhileStatement a -> a

product :: Num a => WhileStatement a -> a

Traversable WhileStatement

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> WhileStatement a -> f (WhileStatement b)

sequenceA :: Applicative f => WhileStatement (f a) -> f (WhileStatement a)

mapM :: Monad m => (a -> m b) -> WhileStatement a -> m (WhileStatement b)

sequence :: Monad m => WhileStatement (m a) -> m (WhileStatement a)

SymbolMatching WhileStatement

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy WhileStatement -> Node -> Bool

showFailure :: Proxy WhileStatement -> Node -> String

Unmarshal WhileStatement

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (WhileStatement a)

Eq a => Eq (WhileStatement a)

Defined in TreeSitter.Python.AST

Methods

(==) :: WhileStatement a -> WhileStatement a -> Bool

(/=) :: WhileStatement a -> WhileStatement a -> Bool

Ord a => Ord (WhileStatement a)

Defined in TreeSitter.Python.AST

Methods

compare :: WhileStatement a -> WhileStatement a -> Ordering

(<) :: WhileStatement a -> WhileStatement a -> Bool

(<=) :: WhileStatement a -> WhileStatement a -> Bool

(>) :: WhileStatement a -> WhileStatement a -> Bool

(>=) :: WhileStatement a -> WhileStatement a -> Bool

max :: WhileStatement a -> WhileStatement a -> WhileStatement a

min :: WhileStatement a -> WhileStatement a -> WhileStatement a

Show a => Show (WhileStatement a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> WhileStatement a -> ShowS

show :: WhileStatement a -> String

showList :: [WhileStatement a] -> ShowS

Generic (WhileStatement a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (WhileStatement a) :: Type -> Type

Methods

from :: WhileStatement a -> Rep (WhileStatement a) x

to :: Rep (WhileStatement a) x -> WhileStatement a

Generic1 WhileStatement

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 WhileStatement :: k -> Type

Methods

from1 :: WhileStatement a -> Rep1 WhileStatement a

to1 :: Rep1 WhileStatement a -> WhileStatement a

type Rep (WhileStatement a)

Defined in TreeSitter.Python.AST

type Rep (WhileStatement a) = D1 (MetaData "WhileStatement" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "WhileStatement" PrefixI True) ((S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: S1 (MetaSel (Just "alternative") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (ElseClause a)))) :*: (S1 (MetaSel (Just "body") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Block a)) :*: S1 (MetaSel (Just "condition") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Expression a)))))

type Rep1 WhileStatement

Defined in TreeSitter.Python.AST

type Rep1 WhileStatement = D1 (MetaData "WhileStatement" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "WhileStatement" PrefixI True) ((S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: S1 (MetaSel (Just "alternative") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Maybe :.: Rec1 ElseClause)) :*: (S1 (MetaSel (Just "body") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 Block) :*: S1 (MetaSel (Just "condition") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 Expression))))

data ElseClause a

Constructors

ElseClause

Fields

• ann :: a
• body :: (Block a)

Instances

Functor ElseClause

Defined in TreeSitter.Python.AST

Methods

fmap :: (a -> b) -> ElseClause a -> ElseClause b

(<$) :: a -> ElseClause b -> ElseClause a

Foldable ElseClause

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => ElseClause m -> m

foldMap :: Monoid m => (a -> m) -> ElseClause a -> m

foldr :: (a -> b -> b) -> b -> ElseClause a -> b

foldr' :: (a -> b -> b) -> b -> ElseClause a -> b

foldl :: (b -> a -> b) -> b -> ElseClause a -> b

foldl' :: (b -> a -> b) -> b -> ElseClause a -> b

foldr1 :: (a -> a -> a) -> ElseClause a -> a

foldl1 :: (a -> a -> a) -> ElseClause a -> a

toList :: ElseClause a -> [a]

null :: ElseClause a -> Bool

length :: ElseClause a -> Int

elem :: Eq a => a -> ElseClause a -> Bool

maximum :: Ord a => ElseClause a -> a

minimum :: Ord a => ElseClause a -> a

sum :: Num a => ElseClause a -> a

product :: Num a => ElseClause a -> a

Traversable ElseClause

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> ElseClause a -> f (ElseClause b)

sequenceA :: Applicative f => ElseClause (f a) -> f (ElseClause a)

mapM :: Monad m => (a -> m b) -> ElseClause a -> m (ElseClause b)

sequence :: Monad m => ElseClause (m a) -> m (ElseClause a)

SymbolMatching ElseClause

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy ElseClause -> Node -> Bool

showFailure :: Proxy ElseClause -> Node -> String

Unmarshal ElseClause

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (ElseClause a)

Eq a => Eq (ElseClause a)

Defined in TreeSitter.Python.AST

Methods

(==) :: ElseClause a -> ElseClause a -> Bool

(/=) :: ElseClause a -> ElseClause a -> Bool

Ord a => Ord (ElseClause a)

Defined in TreeSitter.Python.AST

Methods

compare :: ElseClause a -> ElseClause a -> Ordering

(<) :: ElseClause a -> ElseClause a -> Bool

(<=) :: ElseClause a -> ElseClause a -> Bool

(>) :: ElseClause a -> ElseClause a -> Bool

(>=) :: ElseClause a -> ElseClause a -> Bool

max :: ElseClause a -> ElseClause a -> ElseClause a

min :: ElseClause a -> ElseClause a -> ElseClause a

Show a => Show (ElseClause a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> ElseClause a -> ShowS

show :: ElseClause a -> String

showList :: [ElseClause a] -> ShowS

Generic (ElseClause a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (ElseClause a) :: Type -> Type

Methods

from :: ElseClause a -> Rep (ElseClause a) x

to :: Rep (ElseClause a) x -> ElseClause a

Generic1 ElseClause

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 ElseClause :: k -> Type

Methods

from1 :: ElseClause a -> Rep1 ElseClause a

to1 :: Rep1 ElseClause a -> ElseClause a

type Rep (ElseClause a)

Defined in TreeSitter.Python.AST

type Rep (ElseClause a) = D1 (MetaData "ElseClause" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "ElseClause" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: S1 (MetaSel (Just "body") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Block a))))

type Rep1 ElseClause

Defined in TreeSitter.Python.AST

type Rep1 ElseClause = D1 (MetaData "ElseClause" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "ElseClause" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: S1 (MetaSel (Just "body") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 Block)))

data TryStatement a

Constructors

TryStatement

Fields

• ann :: a
• body :: (Block a)
• extraChildren :: (NonEmpty ((:+:) ElseClause ((:+:) ExceptClause FinallyClause) a))

Instances

Functor TryStatement

Defined in TreeSitter.Python.AST

Methods

fmap :: (a -> b) -> TryStatement a -> TryStatement b

(<$) :: a -> TryStatement b -> TryStatement a

Foldable TryStatement

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => TryStatement m -> m

foldMap :: Monoid m => (a -> m) -> TryStatement a -> m

foldr :: (a -> b -> b) -> b -> TryStatement a -> b

foldr' :: (a -> b -> b) -> b -> TryStatement a -> b

foldl :: (b -> a -> b) -> b -> TryStatement a -> b

foldl' :: (b -> a -> b) -> b -> TryStatement a -> b

foldr1 :: (a -> a -> a) -> TryStatement a -> a

foldl1 :: (a -> a -> a) -> TryStatement a -> a

toList :: TryStatement a -> [a]

null :: TryStatement a -> Bool

length :: TryStatement a -> Int

elem :: Eq a => a -> TryStatement a -> Bool

maximum :: Ord a => TryStatement a -> a

minimum :: Ord a => TryStatement a -> a

sum :: Num a => TryStatement a -> a

product :: Num a => TryStatement a -> a

Traversable TryStatement

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> TryStatement a -> f (TryStatement b)

sequenceA :: Applicative f => TryStatement (f a) -> f (TryStatement a)

mapM :: Monad m => (a -> m b) -> TryStatement a -> m (TryStatement b)

sequence :: Monad m => TryStatement (m a) -> m (TryStatement a)

SymbolMatching TryStatement

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy TryStatement -> Node -> Bool

showFailure :: Proxy TryStatement -> Node -> String

Unmarshal TryStatement

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (TryStatement a)

Eq a => Eq (TryStatement a)

Defined in TreeSitter.Python.AST

Methods

(==) :: TryStatement a -> TryStatement a -> Bool

(/=) :: TryStatement a -> TryStatement a -> Bool

Ord a => Ord (TryStatement a)

Defined in TreeSitter.Python.AST

Methods

compare :: TryStatement a -> TryStatement a -> Ordering

(<) :: TryStatement a -> TryStatement a -> Bool

(<=) :: TryStatement a -> TryStatement a -> Bool

(>) :: TryStatement a -> TryStatement a -> Bool

(>=) :: TryStatement a -> TryStatement a -> Bool

max :: TryStatement a -> TryStatement a -> TryStatement a

min :: TryStatement a -> TryStatement a -> TryStatement a

Show a => Show (TryStatement a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> TryStatement a -> ShowS

show :: TryStatement a -> String

showList :: [TryStatement a] -> ShowS

Generic (TryStatement a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (TryStatement a) :: Type -> Type

Methods

from :: TryStatement a -> Rep (TryStatement a) x

to :: Rep (TryStatement a) x -> TryStatement a

Generic1 TryStatement

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 TryStatement :: k -> Type

Methods

from1 :: TryStatement a -> Rep1 TryStatement a

to1 :: Rep1 TryStatement a -> TryStatement a

type Rep (TryStatement a)

Defined in TreeSitter.Python.AST

type Rep (TryStatement a) = D1 (MetaData "TryStatement" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "TryStatement" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: (S1 (MetaSel (Just "body") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Block a)) :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (NonEmpty ((ElseClause :+: (ExceptClause :+: FinallyClause)) a))))))

type Rep1 TryStatement

Defined in TreeSitter.Python.AST

type Rep1 TryStatement = D1 (MetaData "TryStatement" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "TryStatement" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: (S1 (MetaSel (Just "body") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 Block) :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (NonEmpty :.: Rec1 (ElseClause :+: (ExceptClause :+: FinallyClause))))))

data FinallyClause a

Constructors

FinallyClause

Fields

• ann :: a
• extraChildren :: (Block a)

Instances

Functor FinallyClause

Defined in TreeSitter.Python.AST

Methods

fmap :: (a -> b) -> FinallyClause a -> FinallyClause b

(<$) :: a -> FinallyClause b -> FinallyClause a

Foldable FinallyClause

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => FinallyClause m -> m

foldMap :: Monoid m => (a -> m) -> FinallyClause a -> m

foldr :: (a -> b -> b) -> b -> FinallyClause a -> b

foldr' :: (a -> b -> b) -> b -> FinallyClause a -> b

foldl :: (b -> a -> b) -> b -> FinallyClause a -> b

foldl' :: (b -> a -> b) -> b -> FinallyClause a -> b

foldr1 :: (a -> a -> a) -> FinallyClause a -> a

foldl1 :: (a -> a -> a) -> FinallyClause a -> a

toList :: FinallyClause a -> [a]

null :: FinallyClause a -> Bool

length :: FinallyClause a -> Int

elem :: Eq a => a -> FinallyClause a -> Bool

maximum :: Ord a => FinallyClause a -> a

minimum :: Ord a => FinallyClause a -> a

sum :: Num a => FinallyClause a -> a

product :: Num a => FinallyClause a -> a

Traversable FinallyClause

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> FinallyClause a -> f (FinallyClause b)

sequenceA :: Applicative f => FinallyClause (f a) -> f (FinallyClause a)

mapM :: Monad m => (a -> m b) -> FinallyClause a -> m (FinallyClause b)

sequence :: Monad m => FinallyClause (m a) -> m (FinallyClause a)

SymbolMatching FinallyClause

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy FinallyClause -> Node -> Bool

showFailure :: Proxy FinallyClause -> Node -> String

Unmarshal FinallyClause

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (FinallyClause a)

Eq a => Eq (FinallyClause a)

Defined in TreeSitter.Python.AST

Methods

(==) :: FinallyClause a -> FinallyClause a -> Bool

(/=) :: FinallyClause a -> FinallyClause a -> Bool

Ord a => Ord (FinallyClause a)

Defined in TreeSitter.Python.AST

Methods

compare :: FinallyClause a -> FinallyClause a -> Ordering

(<) :: FinallyClause a -> FinallyClause a -> Bool

(<=) :: FinallyClause a -> FinallyClause a -> Bool

(>) :: FinallyClause a -> FinallyClause a -> Bool

(>=) :: FinallyClause a -> FinallyClause a -> Bool

max :: FinallyClause a -> FinallyClause a -> FinallyClause a

min :: FinallyClause a -> FinallyClause a -> FinallyClause a

Show a => Show (FinallyClause a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> FinallyClause a -> ShowS

show :: FinallyClause a -> String

showList :: [FinallyClause a] -> ShowS

Generic (FinallyClause a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (FinallyClause a) :: Type -> Type

Methods

from :: FinallyClause a -> Rep (FinallyClause a) x

to :: Rep (FinallyClause a) x -> FinallyClause a

Generic1 FinallyClause

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 FinallyClause :: k -> Type

Methods

from1 :: FinallyClause a -> Rep1 FinallyClause a

to1 :: Rep1 FinallyClause a -> FinallyClause a

type Rep (FinallyClause a)

Defined in TreeSitter.Python.AST

type Rep (FinallyClause a) = D1 (MetaData "FinallyClause" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "FinallyClause" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Block a))))

type Rep1 FinallyClause

Defined in TreeSitter.Python.AST

type Rep1 FinallyClause = D1 (MetaData "FinallyClause" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "FinallyClause" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 Block)))

data ExceptClause a

Constructors

ExceptClause

Fields

• ann :: a
• extraChildren :: (NonEmpty ((:+:) Expression Block a))

Instances

Functor ExceptClause

Defined in TreeSitter.Python.AST

Methods

fmap :: (a -> b) -> ExceptClause a -> ExceptClause b

(<$) :: a -> ExceptClause b -> ExceptClause a

Foldable ExceptClause

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => ExceptClause m -> m

foldMap :: Monoid m => (a -> m) -> ExceptClause a -> m

foldr :: (a -> b -> b) -> b -> ExceptClause a -> b

foldr' :: (a -> b -> b) -> b -> ExceptClause a -> b

foldl :: (b -> a -> b) -> b -> ExceptClause a -> b

foldl' :: (b -> a -> b) -> b -> ExceptClause a -> b

foldr1 :: (a -> a -> a) -> ExceptClause a -> a

foldl1 :: (a -> a -> a) -> ExceptClause a -> a

toList :: ExceptClause a -> [a]

null :: ExceptClause a -> Bool

length :: ExceptClause a -> Int

elem :: Eq a => a -> ExceptClause a -> Bool

maximum :: Ord a => ExceptClause a -> a

minimum :: Ord a => ExceptClause a -> a

sum :: Num a => ExceptClause a -> a

product :: Num a => ExceptClause a -> a

Traversable ExceptClause

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> ExceptClause a -> f (ExceptClause b)

sequenceA :: Applicative f => ExceptClause (f a) -> f (ExceptClause a)

mapM :: Monad m => (a -> m b) -> ExceptClause a -> m (ExceptClause b)

sequence :: Monad m => ExceptClause (m a) -> m (ExceptClause a)

SymbolMatching ExceptClause

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy ExceptClause -> Node -> Bool

showFailure :: Proxy ExceptClause -> Node -> String

Unmarshal ExceptClause

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (ExceptClause a)

Eq a => Eq (ExceptClause a)

Defined in TreeSitter.Python.AST

Methods

(==) :: ExceptClause a -> ExceptClause a -> Bool

(/=) :: ExceptClause a -> ExceptClause a -> Bool

Ord a => Ord (ExceptClause a)

Defined in TreeSitter.Python.AST

Methods

compare :: ExceptClause a -> ExceptClause a -> Ordering

(<) :: ExceptClause a -> ExceptClause a -> Bool

(<=) :: ExceptClause a -> ExceptClause a -> Bool

(>) :: ExceptClause a -> ExceptClause a -> Bool

(>=) :: ExceptClause a -> ExceptClause a -> Bool

max :: ExceptClause a -> ExceptClause a -> ExceptClause a

min :: ExceptClause a -> ExceptClause a -> ExceptClause a

Show a => Show (ExceptClause a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> ExceptClause a -> ShowS

show :: ExceptClause a -> String

showList :: [ExceptClause a] -> ShowS

Generic (ExceptClause a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (ExceptClause a) :: Type -> Type

Methods

from :: ExceptClause a -> Rep (ExceptClause a) x

to :: Rep (ExceptClause a) x -> ExceptClause a

Generic1 ExceptClause

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 ExceptClause :: k -> Type

Methods

from1 :: ExceptClause a -> Rep1 ExceptClause a

to1 :: Rep1 ExceptClause a -> ExceptClause a

type Rep (ExceptClause a)

Defined in TreeSitter.Python.AST

type Rep (ExceptClause a) = D1 (MetaData "ExceptClause" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "ExceptClause" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (NonEmpty ((Expression :+: Block) a)))))

type Rep1 ExceptClause

Defined in TreeSitter.Python.AST

type Rep1 ExceptClause = D1 (MetaData "ExceptClause" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "ExceptClause" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (NonEmpty :.: Rec1 (Expression :+: Block))))

data IfStatement a

Constructors

IfStatement

Fields

• ann :: a
• alternative :: ([] ((:+:) ElifClause ElseClause a))
• consequence :: (Block a)
• condition :: (Expression a)

Instances

Functor IfStatement

Defined in TreeSitter.Python.AST

Methods

fmap :: (a -> b) -> IfStatement a -> IfStatement b

(<$) :: a -> IfStatement b -> IfStatement a

Foldable IfStatement

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => IfStatement m -> m

foldMap :: Monoid m => (a -> m) -> IfStatement a -> m

foldr :: (a -> b -> b) -> b -> IfStatement a -> b

foldr' :: (a -> b -> b) -> b -> IfStatement a -> b

foldl :: (b -> a -> b) -> b -> IfStatement a -> b

foldl' :: (b -> a -> b) -> b -> IfStatement a -> b

foldr1 :: (a -> a -> a) -> IfStatement a -> a

foldl1 :: (a -> a -> a) -> IfStatement a -> a

toList :: IfStatement a -> [a]

null :: IfStatement a -> Bool

length :: IfStatement a -> Int

elem :: Eq a => a -> IfStatement a -> Bool

maximum :: Ord a => IfStatement a -> a

minimum :: Ord a => IfStatement a -> a

sum :: Num a => IfStatement a -> a

product :: Num a => IfStatement a -> a

Traversable IfStatement

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> IfStatement a -> f (IfStatement b)

sequenceA :: Applicative f => IfStatement (f a) -> f (IfStatement a)

mapM :: Monad m => (a -> m b) -> IfStatement a -> m (IfStatement b)

sequence :: Monad m => IfStatement (m a) -> m (IfStatement a)

SymbolMatching IfStatement

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy IfStatement -> Node -> Bool

showFailure :: Proxy IfStatement -> Node -> String

Unmarshal IfStatement

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (IfStatement a)

Eq a => Eq (IfStatement a)

Defined in TreeSitter.Python.AST

Methods

(==) :: IfStatement a -> IfStatement a -> Bool

(/=) :: IfStatement a -> IfStatement a -> Bool

Ord a => Ord (IfStatement a)

Defined in TreeSitter.Python.AST

Methods

compare :: IfStatement a -> IfStatement a -> Ordering

(<) :: IfStatement a -> IfStatement a -> Bool

(<=) :: IfStatement a -> IfStatement a -> Bool

(>) :: IfStatement a -> IfStatement a -> Bool

(>=) :: IfStatement a -> IfStatement a -> Bool

max :: IfStatement a -> IfStatement a -> IfStatement a

min :: IfStatement a -> IfStatement a -> IfStatement a

Show a => Show (IfStatement a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> IfStatement a -> ShowS

show :: IfStatement a -> String

showList :: [IfStatement a] -> ShowS

Generic (IfStatement a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (IfStatement a) :: Type -> Type

Methods

from :: IfStatement a -> Rep (IfStatement a) x

to :: Rep (IfStatement a) x -> IfStatement a

Generic1 IfStatement

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 IfStatement :: k -> Type

Methods

from1 :: IfStatement a -> Rep1 IfStatement a

to1 :: Rep1 IfStatement a -> IfStatement a

type Rep (IfStatement a)

Defined in TreeSitter.Python.AST

type Rep (IfStatement a) = D1 (MetaData "IfStatement" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "IfStatement" PrefixI True) ((S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: S1 (MetaSel (Just "alternative") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [(ElifClause :+: ElseClause) a])) :*: (S1 (MetaSel (Just "consequence") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Block a)) :*: S1 (MetaSel (Just "condition") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Expression a)))))

type Rep1 IfStatement

Defined in TreeSitter.Python.AST

type Rep1 IfStatement = D1 (MetaData "IfStatement" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "IfStatement" PrefixI True) ((S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: S1 (MetaSel (Just "alternative") NoSourceUnpackedness NoSourceStrictness DecidedLazy) ([] :.: Rec1 (ElifClause :+: ElseClause))) :*: (S1 (MetaSel (Just "consequence") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 Block) :*: S1 (MetaSel (Just "condition") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 Expression))))

data ElifClause a

Constructors

ElifClause

Fields

• ann :: a
• consequence :: (Block a)
• condition :: (Expression a)

Instances

Functor ElifClause

Defined in TreeSitter.Python.AST

Methods

fmap :: (a -> b) -> ElifClause a -> ElifClause b

(<$) :: a -> ElifClause b -> ElifClause a

Foldable ElifClause

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => ElifClause m -> m

foldMap :: Monoid m => (a -> m) -> ElifClause a -> m

foldr :: (a -> b -> b) -> b -> ElifClause a -> b

foldr' :: (a -> b -> b) -> b -> ElifClause a -> b

foldl :: (b -> a -> b) -> b -> ElifClause a -> b

foldl' :: (b -> a -> b) -> b -> ElifClause a -> b

foldr1 :: (a -> a -> a) -> ElifClause a -> a

foldl1 :: (a -> a -> a) -> ElifClause a -> a

toList :: ElifClause a -> [a]

null :: ElifClause a -> Bool

length :: ElifClause a -> Int

elem :: Eq a => a -> ElifClause a -> Bool

maximum :: Ord a => ElifClause a -> a

minimum :: Ord a => ElifClause a -> a

sum :: Num a => ElifClause a -> a

product :: Num a => ElifClause a -> a

Traversable ElifClause

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> ElifClause a -> f (ElifClause b)

sequenceA :: Applicative f => ElifClause (f a) -> f (ElifClause a)

mapM :: Monad m => (a -> m b) -> ElifClause a -> m (ElifClause b)

sequence :: Monad m => ElifClause (m a) -> m (ElifClause a)

SymbolMatching ElifClause

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy ElifClause -> Node -> Bool

showFailure :: Proxy ElifClause -> Node -> String

Unmarshal ElifClause

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (ElifClause a)

Eq a => Eq (ElifClause a)

Defined in TreeSitter.Python.AST

Methods

(==) :: ElifClause a -> ElifClause a -> Bool

(/=) :: ElifClause a -> ElifClause a -> Bool

Ord a => Ord (ElifClause a)

Defined in TreeSitter.Python.AST

Methods

compare :: ElifClause a -> ElifClause a -> Ordering

(<) :: ElifClause a -> ElifClause a -> Bool

(<=) :: ElifClause a -> ElifClause a -> Bool

(>) :: ElifClause a -> ElifClause a -> Bool

(>=) :: ElifClause a -> ElifClause a -> Bool

max :: ElifClause a -> ElifClause a -> ElifClause a

min :: ElifClause a -> ElifClause a -> ElifClause a

Show a => Show (ElifClause a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> ElifClause a -> ShowS

show :: ElifClause a -> String

showList :: [ElifClause a] -> ShowS

Generic (ElifClause a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (ElifClause a) :: Type -> Type

Methods

from :: ElifClause a -> Rep (ElifClause a) x

to :: Rep (ElifClause a) x -> ElifClause a

Generic1 ElifClause

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 ElifClause :: k -> Type

Methods

from1 :: ElifClause a -> Rep1 ElifClause a

to1 :: Rep1 ElifClause a -> ElifClause a

type Rep (ElifClause a)

Defined in TreeSitter.Python.AST

type Rep (ElifClause a) = D1 (MetaData "ElifClause" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "ElifClause" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: (S1 (MetaSel (Just "consequence") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Block a)) :*: S1 (MetaSel (Just "condition") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Expression a)))))

type Rep1 ElifClause

Defined in TreeSitter.Python.AST

type Rep1 ElifClause = D1 (MetaData "ElifClause" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "ElifClause" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: (S1 (MetaSel (Just "consequence") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 Block) :*: S1 (MetaSel (Just "condition") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 Expression))))

data FunctionDefinition a

Constructors

FunctionDefinition

Fields

• ann :: a
• returnType :: (Maybe (Type a))
• body :: (Block a)
• name :: (Identifier a)
• parameters :: (Parameters a)

Instances

Functor FunctionDefinition

Defined in TreeSitter.Python.AST

Methods

fmap :: (a -> b) -> FunctionDefinition a -> FunctionDefinition b

(<$) :: a -> FunctionDefinition b -> FunctionDefinition a

Foldable FunctionDefinition

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => FunctionDefinition m -> m

foldMap :: Monoid m => (a -> m) -> FunctionDefinition a -> m

foldr :: (a -> b -> b) -> b -> FunctionDefinition a -> b

foldr' :: (a -> b -> b) -> b -> FunctionDefinition a -> b

foldl :: (b -> a -> b) -> b -> FunctionDefinition a -> b

foldl' :: (b -> a -> b) -> b -> FunctionDefinition a -> b

foldr1 :: (a -> a -> a) -> FunctionDefinition a -> a

foldl1 :: (a -> a -> a) -> FunctionDefinition a -> a

toList :: FunctionDefinition a -> [a]

null :: FunctionDefinition a -> Bool

length :: FunctionDefinition a -> Int

elem :: Eq a => a -> FunctionDefinition a -> Bool

maximum :: Ord a => FunctionDefinition a -> a

minimum :: Ord a => FunctionDefinition a -> a

sum :: Num a => FunctionDefinition a -> a

product :: Num a => FunctionDefinition a -> a

Traversable FunctionDefinition

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> FunctionDefinition a -> f (FunctionDefinition b)

sequenceA :: Applicative f => FunctionDefinition (f a) -> f (FunctionDefinition a)

mapM :: Monad m => (a -> m b) -> FunctionDefinition a -> m (FunctionDefinition b)

sequence :: Monad m => FunctionDefinition (m a) -> m (FunctionDefinition a)

SymbolMatching FunctionDefinition

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy FunctionDefinition -> Node -> Bool

showFailure :: Proxy FunctionDefinition -> Node -> String

Unmarshal FunctionDefinition

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (FunctionDefinition a)

Eq a => Eq (FunctionDefinition a)

Defined in TreeSitter.Python.AST

Methods

(==) :: FunctionDefinition a -> FunctionDefinition a -> Bool

(/=) :: FunctionDefinition a -> FunctionDefinition a -> Bool

Ord a => Ord (FunctionDefinition a)

Defined in TreeSitter.Python.AST

Methods

compare :: FunctionDefinition a -> FunctionDefinition a -> Ordering

(<) :: FunctionDefinition a -> FunctionDefinition a -> Bool

(<=) :: FunctionDefinition a -> FunctionDefinition a -> Bool

(>) :: FunctionDefinition a -> FunctionDefinition a -> Bool

(>=) :: FunctionDefinition a -> FunctionDefinition a -> Bool

max :: FunctionDefinition a -> FunctionDefinition a -> FunctionDefinition a

min :: FunctionDefinition a -> FunctionDefinition a -> FunctionDefinition a

Show a => Show (FunctionDefinition a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> FunctionDefinition a -> ShowS

show :: FunctionDefinition a -> String

showList :: [FunctionDefinition a] -> ShowS

Generic (FunctionDefinition a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (FunctionDefinition a) :: Type -> Type

Methods

from :: FunctionDefinition a -> Rep (FunctionDefinition a) x

to :: Rep (FunctionDefinition a) x -> FunctionDefinition a

Generic1 FunctionDefinition

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 FunctionDefinition :: k -> Type

Methods

from1 :: FunctionDefinition a -> Rep1 FunctionDefinition a

to1 :: Rep1 FunctionDefinition a -> FunctionDefinition a

type Rep (FunctionDefinition a)

Defined in TreeSitter.Python.AST

type Rep (FunctionDefinition a) = D1 (MetaData "FunctionDefinition" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "FunctionDefinition" PrefixI True) ((S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: S1 (MetaSel (Just "returnType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Type a)))) :*: (S1 (MetaSel (Just "body") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Block a)) :*: (S1 (MetaSel (Just "name") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Identifier a)) :*: S1 (MetaSel (Just "parameters") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Parameters a))))))

type Rep1 FunctionDefinition

Defined in TreeSitter.Python.AST

type Rep1 FunctionDefinition = D1 (MetaData "FunctionDefinition" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "FunctionDefinition" PrefixI True) ((S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: S1 (MetaSel (Just "returnType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Maybe :.: Rec1 Type)) :*: (S1 (MetaSel (Just "body") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 Block) :*: (S1 (MetaSel (Just "name") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 Identifier) :*: S1 (MetaSel (Just "parameters") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 Parameters)))))

data ForStatement a

Constructors

ForStatement

Fields

• ann :: a
• alternative :: (Maybe (ElseClause a))
• body :: (Block a)
• left :: (Variables a)
• right :: (ExpressionList a)

Instances

Functor ForStatement

Defined in TreeSitter.Python.AST

Methods

fmap :: (a -> b) -> ForStatement a -> ForStatement b

(<$) :: a -> ForStatement b -> ForStatement a

Foldable ForStatement

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => ForStatement m -> m

foldMap :: Monoid m => (a -> m) -> ForStatement a -> m

foldr :: (a -> b -> b) -> b -> ForStatement a -> b

foldr' :: (a -> b -> b) -> b -> ForStatement a -> b

foldl :: (b -> a -> b) -> b -> ForStatement a -> b

foldl' :: (b -> a -> b) -> b -> ForStatement a -> b

foldr1 :: (a -> a -> a) -> ForStatement a -> a

foldl1 :: (a -> a -> a) -> ForStatement a -> a

toList :: ForStatement a -> [a]

null :: ForStatement a -> Bool

length :: ForStatement a -> Int

elem :: Eq a => a -> ForStatement a -> Bool

maximum :: Ord a => ForStatement a -> a

minimum :: Ord a => ForStatement a -> a

sum :: Num a => ForStatement a -> a

product :: Num a => ForStatement a -> a

Traversable ForStatement

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> ForStatement a -> f (ForStatement b)

sequenceA :: Applicative f => ForStatement (f a) -> f (ForStatement a)

mapM :: Monad m => (a -> m b) -> ForStatement a -> m (ForStatement b)

sequence :: Monad m => ForStatement (m a) -> m (ForStatement a)

SymbolMatching ForStatement

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy ForStatement -> Node -> Bool

showFailure :: Proxy ForStatement -> Node -> String

Unmarshal ForStatement

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (ForStatement a)

Eq a => Eq (ForStatement a)

Defined in TreeSitter.Python.AST

Methods

(==) :: ForStatement a -> ForStatement a -> Bool

(/=) :: ForStatement a -> ForStatement a -> Bool

Ord a => Ord (ForStatement a)

Defined in TreeSitter.Python.AST

Methods

compare :: ForStatement a -> ForStatement a -> Ordering

(<) :: ForStatement a -> ForStatement a -> Bool

(<=) :: ForStatement a -> ForStatement a -> Bool

(>) :: ForStatement a -> ForStatement a -> Bool

(>=) :: ForStatement a -> ForStatement a -> Bool

max :: ForStatement a -> ForStatement a -> ForStatement a

min :: ForStatement a -> ForStatement a -> ForStatement a

Show a => Show (ForStatement a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> ForStatement a -> ShowS

show :: ForStatement a -> String

showList :: [ForStatement a] -> ShowS

Generic (ForStatement a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (ForStatement a) :: Type -> Type

Methods

from :: ForStatement a -> Rep (ForStatement a) x

to :: Rep (ForStatement a) x -> ForStatement a

Generic1 ForStatement

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 ForStatement :: k -> Type

Methods

from1 :: ForStatement a -> Rep1 ForStatement a

to1 :: Rep1 ForStatement a -> ForStatement a

type Rep (ForStatement a)

Defined in TreeSitter.Python.AST

type Rep (ForStatement a) = D1 (MetaData "ForStatement" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "ForStatement" PrefixI True) ((S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: S1 (MetaSel (Just "alternative") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (ElseClause a)))) :*: (S1 (MetaSel (Just "body") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Block a)) :*: (S1 (MetaSel (Just "left") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Variables a)) :*: S1 (MetaSel (Just "right") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (ExpressionList a))))))

type Rep1 ForStatement

Defined in TreeSitter.Python.AST

type Rep1 ForStatement = D1 (MetaData "ForStatement" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "ForStatement" PrefixI True) ((S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: S1 (MetaSel (Just "alternative") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Maybe :.: Rec1 ElseClause)) :*: (S1 (MetaSel (Just "body") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 Block) :*: (S1 (MetaSel (Just "left") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 Variables) :*: S1 (MetaSel (Just "right") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 ExpressionList)))))

data DecoratedDefinition a

Constructors

DecoratedDefinition

Fields

• ann :: a
• definition :: ((:+:) ClassDefinition FunctionDefinition a)
• extraChildren :: (NonEmpty (Decorator a))

Instances

Functor DecoratedDefinition

Defined in TreeSitter.Python.AST

Methods

fmap :: (a -> b) -> DecoratedDefinition a -> DecoratedDefinition b

(<$) :: a -> DecoratedDefinition b -> DecoratedDefinition a

Foldable DecoratedDefinition

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => DecoratedDefinition m -> m

foldMap :: Monoid m => (a -> m) -> DecoratedDefinition a -> m

foldr :: (a -> b -> b) -> b -> DecoratedDefinition a -> b

foldr' :: (a -> b -> b) -> b -> DecoratedDefinition a -> b

foldl :: (b -> a -> b) -> b -> DecoratedDefinition a -> b

foldl' :: (b -> a -> b) -> b -> DecoratedDefinition a -> b

foldr1 :: (a -> a -> a) -> DecoratedDefinition a -> a

foldl1 :: (a -> a -> a) -> DecoratedDefinition a -> a

toList :: DecoratedDefinition a -> [a]

null :: DecoratedDefinition a -> Bool

length :: DecoratedDefinition a -> Int

elem :: Eq a => a -> DecoratedDefinition a -> Bool

maximum :: Ord a => DecoratedDefinition a -> a

minimum :: Ord a => DecoratedDefinition a -> a

sum :: Num a => DecoratedDefinition a -> a

product :: Num a => DecoratedDefinition a -> a

Traversable DecoratedDefinition

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> DecoratedDefinition a -> f (DecoratedDefinition b)

sequenceA :: Applicative f => DecoratedDefinition (f a) -> f (DecoratedDefinition a)

mapM :: Monad m => (a -> m b) -> DecoratedDefinition a -> m (DecoratedDefinition b)

sequence :: Monad m => DecoratedDefinition (m a) -> m (DecoratedDefinition a)

SymbolMatching DecoratedDefinition

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy DecoratedDefinition -> Node -> Bool

showFailure :: Proxy DecoratedDefinition -> Node -> String

Unmarshal DecoratedDefinition

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (DecoratedDefinition a)

Eq a => Eq (DecoratedDefinition a)

Defined in TreeSitter.Python.AST

Methods

(==) :: DecoratedDefinition a -> DecoratedDefinition a -> Bool

(/=) :: DecoratedDefinition a -> DecoratedDefinition a -> Bool

Ord a => Ord (DecoratedDefinition a)

Defined in TreeSitter.Python.AST

Methods

compare :: DecoratedDefinition a -> DecoratedDefinition a -> Ordering

(<) :: DecoratedDefinition a -> DecoratedDefinition a -> Bool

(<=) :: DecoratedDefinition a -> DecoratedDefinition a -> Bool

(>) :: DecoratedDefinition a -> DecoratedDefinition a -> Bool

(>=) :: DecoratedDefinition a -> DecoratedDefinition a -> Bool

max :: DecoratedDefinition a -> DecoratedDefinition a -> DecoratedDefinition a

min :: DecoratedDefinition a -> DecoratedDefinition a -> DecoratedDefinition a

Show a => Show (DecoratedDefinition a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> DecoratedDefinition a -> ShowS

show :: DecoratedDefinition a -> String

showList :: [DecoratedDefinition a] -> ShowS

Generic (DecoratedDefinition a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (DecoratedDefinition a) :: Type -> Type

Methods

from :: DecoratedDefinition a -> Rep (DecoratedDefinition a) x

to :: Rep (DecoratedDefinition a) x -> DecoratedDefinition a

Generic1 DecoratedDefinition

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 DecoratedDefinition :: k -> Type

Methods

from1 :: DecoratedDefinition a -> Rep1 DecoratedDefinition a

to1 :: Rep1 DecoratedDefinition a -> DecoratedDefinition a

type Rep (DecoratedDefinition a)

Defined in TreeSitter.Python.AST

type Rep (DecoratedDefinition a) = D1 (MetaData "DecoratedDefinition" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "DecoratedDefinition" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: (S1 (MetaSel (Just "definition") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ((ClassDefinition :+: FunctionDefinition) a)) :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (NonEmpty (Decorator a))))))

type Rep1 DecoratedDefinition

Defined in TreeSitter.Python.AST

type Rep1 DecoratedDefinition = D1 (MetaData "DecoratedDefinition" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "DecoratedDefinition" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: (S1 (MetaSel (Just "definition") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 (ClassDefinition :+: FunctionDefinition)) :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (NonEmpty :.: Rec1 Decorator))))

data Module a

Constructors

Module

Fields

• ann :: a
• extraChildren :: ([] ((:+:) CompoundStatement SimpleStatement a))

Instances

Functor Module

Defined in TreeSitter.Python.AST

Methods

fmap :: (a -> b) -> Module a -> Module b

(<$) :: a -> Module b -> Module a

Foldable Module

Defined in TreeSitter.Python.AST

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 TreeSitter.Python.AST

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)

SymbolMatching Module

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy Module -> Node -> Bool

showFailure :: Proxy Module -> Node -> String

Unmarshal Module

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Module a)

Eq a => Eq (Module a)

Defined in TreeSitter.Python.AST

Methods

(==) :: Module a -> Module a -> Bool

(/=) :: Module a -> Module a -> Bool

Ord a => Ord (Module a)

Defined in TreeSitter.Python.AST

Methods

compare :: Module a -> Module a -> Ordering

(<) :: Module a -> Module a -> Bool

(<=) :: Module a -> Module a -> Bool

(>) :: Module a -> Module a -> Bool

(>=) :: Module a -> Module a -> Bool

max :: Module a -> Module a -> Module a

min :: Module a -> Module a -> Module a

Show a => Show (Module a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> Module a -> ShowS

show :: Module a -> String

showList :: [Module a] -> ShowS

Generic (Module a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (Module a) :: Type -> Type

Methods

from :: Module a -> Rep (Module a) x

to :: Rep (Module a) x -> Module a

Generic1 Module

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 Module :: k -> Type

Methods

from1 :: Module a -> Rep1 Module a

to1 :: Rep1 Module a -> Module a

type Rep (Module a)

Defined in TreeSitter.Python.AST

type Rep (Module a) = D1 (MetaData "Module" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "Module" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [(CompoundStatement :+: SimpleStatement) a])))

type Rep1 Module

Defined in TreeSitter.Python.AST

type Rep1 Module = D1 (MetaData "Module" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "Module" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: S1 (MetaSel (Just "extraChildren") NoSourceUnpackedness NoSourceStrictness DecidedLazy) ([] :.: Rec1 (CompoundStatement :+: SimpleStatement))))

newtype AnonymousAwait a

Constructors

AnonymousAwait

Fields

• ann :: a

Instances

Functor AnonymousAwait

Defined in TreeSitter.Python.AST

Methods

fmap :: (a -> b) -> AnonymousAwait a -> AnonymousAwait b

(<$) :: a -> AnonymousAwait b -> AnonymousAwait a

Foldable AnonymousAwait

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => AnonymousAwait m -> m

foldMap :: Monoid m => (a -> m) -> AnonymousAwait a -> m

foldr :: (a -> b -> b) -> b -> AnonymousAwait a -> b

foldr' :: (a -> b -> b) -> b -> AnonymousAwait a -> b

foldl :: (b -> a -> b) -> b -> AnonymousAwait a -> b

foldl' :: (b -> a -> b) -> b -> AnonymousAwait a -> b

foldr1 :: (a -> a -> a) -> AnonymousAwait a -> a

foldl1 :: (a -> a -> a) -> AnonymousAwait a -> a

toList :: AnonymousAwait a -> [a]

null :: AnonymousAwait a -> Bool

length :: AnonymousAwait a -> Int

elem :: Eq a => a -> AnonymousAwait a -> Bool

maximum :: Ord a => AnonymousAwait a -> a

minimum :: Ord a => AnonymousAwait a -> a

sum :: Num a => AnonymousAwait a -> a

product :: Num a => AnonymousAwait a -> a

Traversable AnonymousAwait

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> AnonymousAwait a -> f (AnonymousAwait b)

sequenceA :: Applicative f => AnonymousAwait (f a) -> f (AnonymousAwait a)

mapM :: Monad m => (a -> m b) -> AnonymousAwait a -> m (AnonymousAwait b)

sequence :: Monad m => AnonymousAwait (m a) -> m (AnonymousAwait a)

SymbolMatching AnonymousAwait

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy AnonymousAwait -> Node -> Bool

showFailure :: Proxy AnonymousAwait -> Node -> String

Unmarshal AnonymousAwait

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (AnonymousAwait a)

Eq a => Eq (AnonymousAwait a)

Defined in TreeSitter.Python.AST

Methods

(==) :: AnonymousAwait a -> AnonymousAwait a -> Bool

(/=) :: AnonymousAwait a -> AnonymousAwait a -> Bool

Ord a => Ord (AnonymousAwait a)

Defined in TreeSitter.Python.AST

Methods

compare :: AnonymousAwait a -> AnonymousAwait a -> Ordering

(<) :: AnonymousAwait a -> AnonymousAwait a -> Bool

(<=) :: AnonymousAwait a -> AnonymousAwait a -> Bool

(>) :: AnonymousAwait a -> AnonymousAwait a -> Bool

(>=) :: AnonymousAwait a -> AnonymousAwait a -> Bool

max :: AnonymousAwait a -> AnonymousAwait a -> AnonymousAwait a

min :: AnonymousAwait a -> AnonymousAwait a -> AnonymousAwait a

Show a => Show (AnonymousAwait a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> AnonymousAwait a -> ShowS

show :: AnonymousAwait a -> String

showList :: [AnonymousAwait a] -> ShowS

Generic (AnonymousAwait a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (AnonymousAwait a) :: Type -> Type

Methods

from :: AnonymousAwait a -> Rep (AnonymousAwait a) x

to :: Rep (AnonymousAwait a) x -> AnonymousAwait a

Generic1 AnonymousAwait

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 AnonymousAwait :: k -> Type

Methods

from1 :: AnonymousAwait a -> Rep1 AnonymousAwait a

to1 :: Rep1 AnonymousAwait a -> AnonymousAwait a

type Rep (AnonymousAwait a)

Defined in TreeSitter.Python.AST

type Rep (AnonymousAwait a) = D1 (MetaData "AnonymousAwait" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousAwait" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 AnonymousAwait

Defined in TreeSitter.Python.AST

type Rep1 AnonymousAwait = D1 (MetaData "AnonymousAwait" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" True) (C1 (MetaCons "AnonymousAwait" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

data Comment a

Constructors

Comment

Fields

• ann :: a
• bytes :: Text

Instances

Functor Comment

Defined in TreeSitter.Python.AST

Methods

fmap :: (a -> b) -> Comment a -> Comment b

(<$) :: a -> Comment b -> Comment a

Foldable Comment

Defined in TreeSitter.Python.AST

Methods

fold :: Monoid m => Comment m -> m

foldMap :: Monoid m => (a -> m) -> Comment a -> m

foldr :: (a -> b -> b) -> b -> Comment a -> b

foldr' :: (a -> b -> b) -> b -> Comment a -> b

foldl :: (b -> a -> b) -> b -> Comment a -> b

foldl' :: (b -> a -> b) -> b -> Comment a -> b

foldr1 :: (a -> a -> a) -> Comment a -> a

foldl1 :: (a -> a -> a) -> Comment a -> a

toList :: Comment a -> [a]

null :: Comment a -> Bool

length :: Comment a -> Int

elem :: Eq a => a -> Comment a -> Bool

maximum :: Ord a => Comment a -> a

minimum :: Ord a => Comment a -> a

sum :: Num a => Comment a -> a

product :: Num a => Comment a -> a

Traversable Comment

Defined in TreeSitter.Python.AST

Methods

traverse :: Applicative f => (a -> f b) -> Comment a -> f (Comment b)

sequenceA :: Applicative f => Comment (f a) -> f (Comment a)

mapM :: Monad m => (a -> m b) -> Comment a -> m (Comment b)

sequence :: Monad m => Comment (m a) -> m (Comment a)

SymbolMatching Comment

Defined in TreeSitter.Python.AST

Methods

symbolMatch :: Proxy Comment -> Node -> Bool

showFailure :: Proxy Comment -> Node -> String

Unmarshal Comment

Defined in TreeSitter.Python.AST

Methods

unmarshalNode :: (Carrier sig m, Member (Reader ByteString) sig, Member (Reader (Ptr Cursor)) sig, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Comment a)

Eq a => Eq (Comment a)

Defined in TreeSitter.Python.AST

Methods

(==) :: Comment a -> Comment a -> Bool

(/=) :: Comment a -> Comment a -> Bool

Ord a => Ord (Comment a)

Defined in TreeSitter.Python.AST

Methods

compare :: Comment a -> Comment a -> Ordering

(<) :: Comment a -> Comment a -> Bool

(<=) :: Comment a -> Comment a -> Bool

(>) :: Comment a -> Comment a -> Bool

(>=) :: Comment a -> Comment a -> Bool

max :: Comment a -> Comment a -> Comment a

min :: Comment a -> Comment a -> Comment a

Show a => Show (Comment a)

Defined in TreeSitter.Python.AST

Methods

showsPrec :: Int -> Comment a -> ShowS

show :: Comment a -> String

showList :: [Comment a] -> ShowS

Generic (Comment a)

Defined in TreeSitter.Python.AST

Associated Types

type Rep (Comment a) :: Type -> Type

Methods

from :: Comment a -> Rep (Comment a) x

to :: Rep (Comment a) x -> Comment a

Generic1 Comment

Defined in TreeSitter.Python.AST

Associated Types

type Rep1 Comment :: k -> Type

Methods

from1 :: Comment a -> Rep1 Comment a

to1 :: Rep1 Comment a -> Comment a

type Rep (Comment a)

Defined in TreeSitter.Python.AST

type Rep (Comment a) = D1 (MetaData "Comment" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "Comment" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: S1 (MetaSel (Just "bytes") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Text)))

type Rep1 Comment

Defined in TreeSitter.Python.AST

type Rep1 Comment = D1 (MetaData "Comment" "TreeSitter.Python.AST" "tree-sitter-python-0.5.0.0-inplace" False) (C1 (MetaCons "Comment" PrefixI True) (S1 (MetaSel (Just "ann") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1 :*: S1 (MetaSel (Just "bytes") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Text)))