Functor Uninterpreted Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> Uninterpreted a -> Uninterpreted b # (<$) :: a -> Uninterpreted b -> Uninterpreted a #
Foldable Uninterpreted Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => Uninterpreted m -> m # foldMap :: Monoid m => (a -> m) -> Uninterpreted a -> m # foldMap' :: Monoid m => (a -> m) -> Uninterpreted a -> m # foldr :: (a -> b -> b) -> b -> Uninterpreted a -> b # foldr' :: (a -> b -> b) -> b -> Uninterpreted a -> b # foldl :: (b -> a -> b) -> b -> Uninterpreted a -> b # foldl' :: (b -> a -> b) -> b -> Uninterpreted a -> b # foldr1 :: (a -> a -> a) -> Uninterpreted a -> a # foldl1 :: (a -> a -> a) -> Uninterpreted a -> a # toList :: Uninterpreted a -> [a] # null :: Uninterpreted a -> Bool # length :: Uninterpreted a -> Int # elem :: Eq a => a -> Uninterpreted a -> Bool # maximum :: Ord a => Uninterpreted a -> a # minimum :: Ord a => Uninterpreted a -> a # sum :: Num a => Uninterpreted a -> a # product :: Num a => Uninterpreted a -> a #
Traversable Uninterpreted Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> Uninterpreted a -> f (Uninterpreted b) # sequenceA :: Applicative f => Uninterpreted (f a) -> f (Uninterpreted a) # mapM :: Monad m => (a -> m b) -> Uninterpreted a -> m (Uninterpreted b) # sequence :: Monad m => Uninterpreted (m a) -> m (Uninterpreted a) #
SymbolMatching Uninterpreted Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy Uninterpreted -> [Int] showFailure :: Proxy Uninterpreted -> Node -> String
Unmarshal Uninterpreted Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match Uninterpreted) matchers :: B (Int, Match Uninterpreted)
Eq a => Eq (Uninterpreted a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: Uninterpreted a -> Uninterpreted a -> Bool # (/=) :: Uninterpreted a -> Uninterpreted a -> Bool #
Ord a => Ord (Uninterpreted a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: Uninterpreted a -> Uninterpreted a -> Ordering # (<) :: Uninterpreted a -> Uninterpreted a -> Bool # (<=) :: Uninterpreted a -> Uninterpreted a -> Bool # (>) :: Uninterpreted a -> Uninterpreted a -> Bool # (>=) :: Uninterpreted a -> Uninterpreted a -> Bool # max :: Uninterpreted a -> Uninterpreted a -> Uninterpreted a # min :: Uninterpreted a -> Uninterpreted a -> Uninterpreted a #
Show a => Show (Uninterpreted a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> Uninterpreted a -> ShowS # show :: Uninterpreted a -> String # showList :: [Uninterpreted a] -> ShowS #
Generic (Uninterpreted a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (Uninterpreted a) :: Type -> Type # Methods from :: Uninterpreted a -> Rep (Uninterpreted a) x # to :: Rep (Uninterpreted a) x -> Uninterpreted a #
Generic1 Uninterpreted Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 Uninterpreted :: k -> Type # Methods from1 :: forall (a :: k). Uninterpreted a -> Rep1 Uninterpreted a # to1 :: forall (a :: k). Rep1 Uninterpreted a -> Uninterpreted a #
type Rep (Uninterpreted a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (Uninterpreted a) = D1 ('MetaData "Uninterpreted" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Uninterpreted" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "text") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Text)))
type Rep1 Uninterpreted Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 Uninterpreted = D1 ('MetaData "Uninterpreted" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Uninterpreted" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Just "text") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Text)))

type AnonymousUndef = Token "undef" 98 Source #

data True a Source #

Constructors

True
Fields ann :: a text :: Text

Instances

Instances details

Functor True Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> True a -> True b # (<$) :: a -> True b -> True a #
Foldable True Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => True m -> m # foldMap :: Monoid m => (a -> m) -> True a -> 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 Source #
Instance details Defined in TreeSitter.Ruby.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 Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy True -> [Int] showFailure :: Proxy True -> Node -> String
Unmarshal True Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match True) matchers :: B (Int, Match True)
Eq a => Eq (True a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: True a -> True a -> Bool # (/=) :: True a -> True a -> Bool #
Ord a => Ord (True a) Source #
Instance details Defined in TreeSitter.Ruby.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) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> True a -> ShowS # show :: True a -> String # showList :: [True a] -> ShowS #
Generic (True a) Source #
Instance details Defined in TreeSitter.Ruby.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 Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 True :: k -> Type # Methods from1 :: forall (a :: k). True a -> Rep1 True a # to1 :: forall (a :: k). Rep1 True a -> True a #
type Rep (True a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (True a) = D1 ('MetaData "True" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "True" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "text") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Text)))
type Rep1 True Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 True = D1 ('MetaData "True" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "True" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Just "text") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Text)))

type AnonymousThen = Token "then" 43 Source #

data Super a Source #

Constructors

Super
Fields ann :: a text :: Text

Instances

Instances details

Functor Super Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> Super a -> Super b # (<$) :: a -> Super b -> Super a #
Foldable Super Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => Super m -> m # foldMap :: Monoid m => (a -> m) -> Super a -> m # foldMap' :: Monoid m => (a -> m) -> Super a -> m # foldr :: (a -> b -> b) -> b -> Super a -> b # foldr' :: (a -> b -> b) -> b -> Super a -> b # foldl :: (b -> a -> b) -> b -> Super a -> b # foldl' :: (b -> a -> b) -> b -> Super a -> b # foldr1 :: (a -> a -> a) -> Super a -> a # foldl1 :: (a -> a -> a) -> Super a -> a # toList :: Super a -> [a] # null :: Super a -> Bool # length :: Super a -> Int # elem :: Eq a => a -> Super a -> Bool # maximum :: Ord a => Super a -> a # minimum :: Ord a => Super a -> a # sum :: Num a => Super a -> a # product :: Num a => Super a -> a #
Traversable Super Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> Super a -> f (Super b) # sequenceA :: Applicative f => Super (f a) -> f (Super a) # mapM :: Monad m => (a -> m b) -> Super a -> m (Super b) # sequence :: Monad m => Super (m a) -> m (Super a) #
SymbolMatching Super Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy Super -> [Int] showFailure :: Proxy Super -> Node -> String
Unmarshal Super Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match Super) matchers :: B (Int, Match Super)
Eq a => Eq (Super a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: Super a -> Super a -> Bool # (/=) :: Super a -> Super a -> Bool #
Ord a => Ord (Super a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: Super a -> Super a -> Ordering # (<) :: Super a -> Super a -> Bool # (<=) :: Super a -> Super a -> Bool # (>) :: Super a -> Super a -> Bool # (>=) :: Super a -> Super a -> Bool # max :: Super a -> Super a -> Super a # min :: Super a -> Super a -> Super a #
Show a => Show (Super a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> Super a -> ShowS # show :: Super a -> String # showList :: [Super a] -> ShowS #
Generic (Super a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (Super a) :: Type -> Type # Methods from :: Super a -> Rep (Super a) x # to :: Rep (Super a) x -> Super a #
Generic1 Super Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 Super :: k -> Type # Methods from1 :: forall (a :: k). Super a -> Rep1 Super a # to1 :: forall (a :: k). Rep1 Super a -> Super a #
type Rep (Super a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (Super a) = D1 ('MetaData "Super" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Super" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "text") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Text)))
type Rep1 Super Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 Super = D1 ('MetaData "Super" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Super" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Just "text") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Text)))

data Self a Source #

Constructors

Self
Fields ann :: a text :: Text

Instances

Instances details

Functor Self Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> Self a -> Self b # (<$) :: a -> Self b -> Self a #
Foldable Self Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => Self m -> m # foldMap :: Monoid m => (a -> m) -> Self a -> m # foldMap' :: Monoid m => (a -> m) -> Self a -> m # foldr :: (a -> b -> b) -> b -> Self a -> b # foldr' :: (a -> b -> b) -> b -> Self a -> b # foldl :: (b -> a -> b) -> b -> Self a -> b # foldl' :: (b -> a -> b) -> b -> Self a -> b # foldr1 :: (a -> a -> a) -> Self a -> a # foldl1 :: (a -> a -> a) -> Self a -> a # toList :: Self a -> [a] # null :: Self a -> Bool # length :: Self a -> Int # elem :: Eq a => a -> Self a -> Bool # maximum :: Ord a => Self a -> a # minimum :: Ord a => Self a -> a # sum :: Num a => Self a -> a # product :: Num a => Self a -> a #
Traversable Self Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> Self a -> f (Self b) # sequenceA :: Applicative f => Self (f a) -> f (Self a) # mapM :: Monad m => (a -> m b) -> Self a -> m (Self b) # sequence :: Monad m => Self (m a) -> m (Self a) #
SymbolMatching Self Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy Self -> [Int] showFailure :: Proxy Self -> Node -> String
Unmarshal Self Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match Self) matchers :: B (Int, Match Self)
Eq a => Eq (Self a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: Self a -> Self a -> Bool # (/=) :: Self a -> Self a -> Bool #
Ord a => Ord (Self a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: Self a -> Self a -> Ordering # (<) :: Self a -> Self a -> Bool # (<=) :: Self a -> Self a -> Bool # (>) :: Self a -> Self a -> Bool # (>=) :: Self a -> Self a -> Bool # max :: Self a -> Self a -> Self a # min :: Self a -> Self a -> Self a #
Show a => Show (Self a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> Self a -> ShowS # show :: Self a -> String # showList :: [Self a] -> ShowS #
Generic (Self a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (Self a) :: Type -> Type # Methods from :: Self a -> Rep (Self a) x # to :: Rep (Self a) x -> Self a #
Generic1 Self Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 Self :: k -> Type # Methods from1 :: forall (a :: k). Self a -> Rep1 Self a # to1 :: forall (a :: k). Rep1 Self a -> Self a #
type Rep (Self a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (Self a) = D1 ('MetaData "Self" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Self" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "text") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Text)))
type Rep1 Self Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 Self = D1 ('MetaData "Self" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Self" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Just "text") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Text)))

type AnonymousReturn = Token "return" 25 Source #

type AnonymousRetry = Token "retry" 30 Source #

type AnonymousRescue = Token "rescue" 35 Source #

type AnonymousRedo = Token "redo" 29 Source #

type AnonymousR = Token "r" 104 Source #

type AnonymousOr = Token "or" 70 Source #

type AnonymousNot = Token "not" 89 Source #

data Nil a Source #

Constructors

Nil
Fields ann :: a text :: Text

Instances

Instances details

Functor Nil Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> Nil a -> Nil b # (<$) :: a -> Nil b -> Nil a #
Foldable Nil Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => Nil m -> m # foldMap :: Monoid m => (a -> m) -> Nil a -> m # foldMap' :: Monoid m => (a -> m) -> Nil a -> m # foldr :: (a -> b -> b) -> b -> Nil a -> b # foldr' :: (a -> b -> b) -> b -> Nil a -> b # foldl :: (b -> a -> b) -> b -> Nil a -> b # foldl' :: (b -> a -> b) -> b -> Nil a -> b # foldr1 :: (a -> a -> a) -> Nil a -> a # foldl1 :: (a -> a -> a) -> Nil a -> a # toList :: Nil a -> [a] # null :: Nil a -> Bool # length :: Nil a -> Int # elem :: Eq a => a -> Nil a -> Bool # maximum :: Ord a => Nil a -> a # minimum :: Ord a => Nil a -> a # sum :: Num a => Nil a -> a # product :: Num a => Nil a -> a #
Traversable Nil Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> Nil a -> f (Nil b) # sequenceA :: Applicative f => Nil (f a) -> f (Nil a) # mapM :: Monad m => (a -> m b) -> Nil a -> m (Nil b) # sequence :: Monad m => Nil (m a) -> m (Nil a) #
SymbolMatching Nil Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy Nil -> [Int] showFailure :: Proxy Nil -> Node -> String
Unmarshal Nil Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match Nil) matchers :: B (Int, Match Nil)
Eq a => Eq (Nil a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: Nil a -> Nil a -> Bool # (/=) :: Nil a -> Nil a -> Bool #
Ord a => Ord (Nil a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: Nil a -> Nil a -> Ordering # (<) :: Nil a -> Nil a -> Bool # (<=) :: Nil a -> Nil a -> Bool # (>) :: Nil a -> Nil a -> Bool # (>=) :: Nil a -> Nil a -> Bool # max :: Nil a -> Nil a -> Nil a # min :: Nil a -> Nil a -> Nil a #
Show a => Show (Nil a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> Nil a -> ShowS # show :: Nil a -> String # showList :: [Nil a] -> ShowS #
Generic (Nil a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (Nil a) :: Type -> Type # Methods from :: Nil a -> Rep (Nil a) x # to :: Rep (Nil a) x -> Nil a #
Generic1 Nil Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 Nil :: k -> Type # Methods from1 :: forall (a :: k). Nil a -> Rep1 Nil a # to1 :: forall (a :: k). Rep1 Nil a -> Nil a #
type Rep (Nil a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (Nil a) = D1 ('MetaData "Nil" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Nil" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "text") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Text)))
type Rep1 Nil Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 Nil = D1 ('MetaData "Nil" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Nil" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Just "text") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Text)))

type AnonymousNext = Token "next" 28 Source #

type AnonymousModule = Token "module" 23 Source #

data Integer a Source #

Constructors

Integer
Fields ann :: a text :: Text

Instances

Instances details

Functor Integer Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> Integer a -> Integer b # (<$) :: a -> Integer b -> Integer a #
Foldable Integer Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => Integer m -> m # foldMap :: Monoid m => (a -> m) -> Integer a -> 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 Source #
Instance details Defined in TreeSitter.Ruby.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 Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy Integer -> [Int] showFailure :: Proxy Integer -> Node -> String
Unmarshal Integer Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match Integer) matchers :: B (Int, Match Integer)
Eq a => Eq (Integer a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: Integer a -> Integer a -> Bool # (/=) :: Integer a -> Integer a -> Bool #
Ord a => Ord (Integer a) Source #
Instance details Defined in TreeSitter.Ruby.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) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> Integer a -> ShowS # show :: Integer a -> String # showList :: [Integer a] -> ShowS #
Generic (Integer a) Source #
Instance details Defined in TreeSitter.Ruby.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 Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 Integer :: k -> Type # Methods from1 :: forall (a :: k). Integer a -> Rep1 Integer a # to1 :: forall (a :: k). Rep1 Integer a -> Integer a #
type Rep (Integer a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (Integer a) = D1 ('MetaData "Integer" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Integer" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "text") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Text)))
type Rep1 Integer Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 Integer = D1 ('MetaData "Integer" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Integer" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Just "text") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Text)))

data InstanceVariable a Source #

Constructors

InstanceVariable
Fields ann :: a text :: Text

Instances

Instances details

Functor InstanceVariable Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> InstanceVariable a -> InstanceVariable b # (<$) :: a -> InstanceVariable b -> InstanceVariable a #
Foldable InstanceVariable Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => InstanceVariable m -> m # foldMap :: Monoid m => (a -> m) -> InstanceVariable a -> m # foldMap' :: Monoid m => (a -> m) -> InstanceVariable a -> m # foldr :: (a -> b -> b) -> b -> InstanceVariable a -> b # foldr' :: (a -> b -> b) -> b -> InstanceVariable a -> b # foldl :: (b -> a -> b) -> b -> InstanceVariable a -> b # foldl' :: (b -> a -> b) -> b -> InstanceVariable a -> b # foldr1 :: (a -> a -> a) -> InstanceVariable a -> a # foldl1 :: (a -> a -> a) -> InstanceVariable a -> a # toList :: InstanceVariable a -> [a] # null :: InstanceVariable a -> Bool # length :: InstanceVariable a -> Int # elem :: Eq a => a -> InstanceVariable a -> Bool # maximum :: Ord a => InstanceVariable a -> a # minimum :: Ord a => InstanceVariable a -> a # sum :: Num a => InstanceVariable a -> a # product :: Num a => InstanceVariable a -> a #
Traversable InstanceVariable Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> InstanceVariable a -> f (InstanceVariable b) # sequenceA :: Applicative f => InstanceVariable (f a) -> f (InstanceVariable a) # mapM :: Monad m => (a -> m b) -> InstanceVariable a -> m (InstanceVariable b) # sequence :: Monad m => InstanceVariable (m a) -> m (InstanceVariable a) #
SymbolMatching InstanceVariable Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy InstanceVariable -> [Int] showFailure :: Proxy InstanceVariable -> Node -> String
Unmarshal InstanceVariable Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match InstanceVariable) matchers :: B (Int, Match InstanceVariable)
Eq a => Eq (InstanceVariable a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: InstanceVariable a -> InstanceVariable a -> Bool # (/=) :: InstanceVariable a -> InstanceVariable a -> Bool #
Ord a => Ord (InstanceVariable a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: InstanceVariable a -> InstanceVariable a -> Ordering # (<) :: InstanceVariable a -> InstanceVariable a -> Bool # (<=) :: InstanceVariable a -> InstanceVariable a -> Bool # (>) :: InstanceVariable a -> InstanceVariable a -> Bool # (>=) :: InstanceVariable a -> InstanceVariable a -> Bool # max :: InstanceVariable a -> InstanceVariable a -> InstanceVariable a # min :: InstanceVariable a -> InstanceVariable a -> InstanceVariable a #
Show a => Show (InstanceVariable a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> InstanceVariable a -> ShowS # show :: InstanceVariable a -> String # showList :: [InstanceVariable a] -> ShowS #
Generic (InstanceVariable a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (InstanceVariable a) :: Type -> Type # Methods from :: InstanceVariable a -> Rep (InstanceVariable a) x # to :: Rep (InstanceVariable a) x -> InstanceVariable a #
Generic1 InstanceVariable Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 InstanceVariable :: k -> Type # Methods from1 :: forall (a :: k). InstanceVariable a -> Rep1 InstanceVariable a # to1 :: forall (a :: k). Rep1 InstanceVariable a -> InstanceVariable a #
type Rep (InstanceVariable a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (InstanceVariable a) = D1 ('MetaData "InstanceVariable" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "InstanceVariable" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "text") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Text)))
type Rep1 InstanceVariable Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 InstanceVariable = D1 ('MetaData "InstanceVariable" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "InstanceVariable" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Just "text") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Text)))

type AnonymousIn = Token "in" 37 Source #

type AnonymousIf = Token "if" 31 Source #

data Identifier a Source #

Constructors

Identifier
Fields ann :: a text :: Text

Instances

Instances details

Functor Identifier Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> Identifier a -> Identifier b # (<$) :: a -> Identifier b -> Identifier a #
Foldable Identifier Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => Identifier m -> m # foldMap :: Monoid m => (a -> m) -> Identifier a -> 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 Source #
Instance details Defined in TreeSitter.Ruby.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 Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy Identifier -> [Int] showFailure :: Proxy Identifier -> Node -> String
Unmarshal Identifier Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match Identifier) matchers :: B (Int, Match Identifier)
Eq a => Eq (Identifier a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: Identifier a -> Identifier a -> Bool # (/=) :: Identifier a -> Identifier a -> Bool #
Ord a => Ord (Identifier a) Source #
Instance details Defined in TreeSitter.Ruby.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) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> Identifier a -> ShowS # show :: Identifier a -> String # showList :: [Identifier a] -> ShowS #
Generic (Identifier a) Source #
Instance details Defined in TreeSitter.Ruby.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 Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 Identifier :: k -> Type # Methods from1 :: forall (a :: k). Identifier a -> Rep1 Identifier a # to1 :: forall (a :: k). Rep1 Identifier a -> Identifier a #
type Rep (Identifier a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (Identifier a) = D1 ('MetaData "Identifier" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Identifier" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "text") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Text)))
type Rep1 Identifier Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 Identifier = D1 ('MetaData "Identifier" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Identifier" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Just "text") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Text)))

data HeredocEnd a Source #

Constructors

HeredocEnd
Fields ann :: a text :: Text

Instances

Instances details

Functor HeredocEnd Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> HeredocEnd a -> HeredocEnd b # (<$) :: a -> HeredocEnd b -> HeredocEnd a #
Foldable HeredocEnd Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => HeredocEnd m -> m # foldMap :: Monoid m => (a -> m) -> HeredocEnd a -> m # foldMap' :: Monoid m => (a -> m) -> HeredocEnd a -> m # foldr :: (a -> b -> b) -> b -> HeredocEnd a -> b # foldr' :: (a -> b -> b) -> b -> HeredocEnd a -> b # foldl :: (b -> a -> b) -> b -> HeredocEnd a -> b # foldl' :: (b -> a -> b) -> b -> HeredocEnd a -> b # foldr1 :: (a -> a -> a) -> HeredocEnd a -> a # foldl1 :: (a -> a -> a) -> HeredocEnd a -> a # toList :: HeredocEnd a -> [a] # null :: HeredocEnd a -> Bool # length :: HeredocEnd a -> Int # elem :: Eq a => a -> HeredocEnd a -> Bool # maximum :: Ord a => HeredocEnd a -> a # minimum :: Ord a => HeredocEnd a -> a # sum :: Num a => HeredocEnd a -> a # product :: Num a => HeredocEnd a -> a #
Traversable HeredocEnd Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> HeredocEnd a -> f (HeredocEnd b) # sequenceA :: Applicative f => HeredocEnd (f a) -> f (HeredocEnd a) # mapM :: Monad m => (a -> m b) -> HeredocEnd a -> m (HeredocEnd b) # sequence :: Monad m => HeredocEnd (m a) -> m (HeredocEnd a) #
SymbolMatching HeredocEnd Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy HeredocEnd -> [Int] showFailure :: Proxy HeredocEnd -> Node -> String
Unmarshal HeredocEnd Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match HeredocEnd) matchers :: B (Int, Match HeredocEnd)
Eq a => Eq (HeredocEnd a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: HeredocEnd a -> HeredocEnd a -> Bool # (/=) :: HeredocEnd a -> HeredocEnd a -> Bool #
Ord a => Ord (HeredocEnd a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: HeredocEnd a -> HeredocEnd a -> Ordering # (<) :: HeredocEnd a -> HeredocEnd a -> Bool # (<=) :: HeredocEnd a -> HeredocEnd a -> Bool # (>) :: HeredocEnd a -> HeredocEnd a -> Bool # (>=) :: HeredocEnd a -> HeredocEnd a -> Bool # max :: HeredocEnd a -> HeredocEnd a -> HeredocEnd a # min :: HeredocEnd a -> HeredocEnd a -> HeredocEnd a #
Show a => Show (HeredocEnd a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> HeredocEnd a -> ShowS # show :: HeredocEnd a -> String # showList :: [HeredocEnd a] -> ShowS #
Generic (HeredocEnd a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (HeredocEnd a) :: Type -> Type # Methods from :: HeredocEnd a -> Rep (HeredocEnd a) x # to :: Rep (HeredocEnd a) x -> HeredocEnd a #
Generic1 HeredocEnd Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 HeredocEnd :: k -> Type # Methods from1 :: forall (a :: k). HeredocEnd a -> Rep1 HeredocEnd a # to1 :: forall (a :: k). Rep1 HeredocEnd a -> HeredocEnd a #
type Rep (HeredocEnd a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (HeredocEnd a) = D1 ('MetaData "HeredocEnd" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "HeredocEnd" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "text") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Text)))
type Rep1 HeredocEnd Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 HeredocEnd = D1 ('MetaData "HeredocEnd" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "HeredocEnd" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Just "text") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Text)))

data HeredocBeginning a Source #

Constructors

HeredocBeginning
Fields ann :: a text :: Text

Instances

Instances details

Functor HeredocBeginning Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> HeredocBeginning a -> HeredocBeginning b # (<$) :: a -> HeredocBeginning b -> HeredocBeginning a #
Foldable HeredocBeginning Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => HeredocBeginning m -> m # foldMap :: Monoid m => (a -> m) -> HeredocBeginning a -> m # foldMap' :: Monoid m => (a -> m) -> HeredocBeginning a -> m # foldr :: (a -> b -> b) -> b -> HeredocBeginning a -> b # foldr' :: (a -> b -> b) -> b -> HeredocBeginning a -> b # foldl :: (b -> a -> b) -> b -> HeredocBeginning a -> b # foldl' :: (b -> a -> b) -> b -> HeredocBeginning a -> b # foldr1 :: (a -> a -> a) -> HeredocBeginning a -> a # foldl1 :: (a -> a -> a) -> HeredocBeginning a -> a # toList :: HeredocBeginning a -> [a] # null :: HeredocBeginning a -> Bool # length :: HeredocBeginning a -> Int # elem :: Eq a => a -> HeredocBeginning a -> Bool # maximum :: Ord a => HeredocBeginning a -> a # minimum :: Ord a => HeredocBeginning a -> a # sum :: Num a => HeredocBeginning a -> a # product :: Num a => HeredocBeginning a -> a #
Traversable HeredocBeginning Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> HeredocBeginning a -> f (HeredocBeginning b) # sequenceA :: Applicative f => HeredocBeginning (f a) -> f (HeredocBeginning a) # mapM :: Monad m => (a -> m b) -> HeredocBeginning a -> m (HeredocBeginning b) # sequence :: Monad m => HeredocBeginning (m a) -> m (HeredocBeginning a) #
SymbolMatching HeredocBeginning Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy HeredocBeginning -> [Int] showFailure :: Proxy HeredocBeginning -> Node -> String
Unmarshal HeredocBeginning Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match HeredocBeginning) matchers :: B (Int, Match HeredocBeginning)
Eq a => Eq (HeredocBeginning a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: HeredocBeginning a -> HeredocBeginning a -> Bool # (/=) :: HeredocBeginning a -> HeredocBeginning a -> Bool #
Ord a => Ord (HeredocBeginning a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: HeredocBeginning a -> HeredocBeginning a -> Ordering # (<) :: HeredocBeginning a -> HeredocBeginning a -> Bool # (<=) :: HeredocBeginning a -> HeredocBeginning a -> Bool # (>) :: HeredocBeginning a -> HeredocBeginning a -> Bool # (>=) :: HeredocBeginning a -> HeredocBeginning a -> Bool # max :: HeredocBeginning a -> HeredocBeginning a -> HeredocBeginning a # min :: HeredocBeginning a -> HeredocBeginning a -> HeredocBeginning a #
Show a => Show (HeredocBeginning a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> HeredocBeginning a -> ShowS # show :: HeredocBeginning a -> String # showList :: [HeredocBeginning a] -> ShowS #
Generic (HeredocBeginning a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (HeredocBeginning a) :: Type -> Type # Methods from :: HeredocBeginning a -> Rep (HeredocBeginning a) x # to :: Rep (HeredocBeginning a) x -> HeredocBeginning a #
Generic1 HeredocBeginning Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 HeredocBeginning :: k -> Type # Methods from1 :: forall (a :: k). HeredocBeginning a -> Rep1 HeredocBeginning a # to1 :: forall (a :: k). Rep1 HeredocBeginning a -> HeredocBeginning a #
type Rep (HeredocBeginning a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (HeredocBeginning a) = D1 ('MetaData "HeredocBeginning" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "HeredocBeginning" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "text") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Text)))
type Rep1 HeredocBeginning Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 HeredocBeginning = D1 ('MetaData "HeredocBeginning" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "HeredocBeginning" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Just "text") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Text)))

data GlobalVariable a Source #

Constructors

GlobalVariable
Fields ann :: a text :: Text

Instances

Instances details

Functor GlobalVariable Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> GlobalVariable a -> GlobalVariable b # (<$) :: a -> GlobalVariable b -> GlobalVariable a #
Foldable GlobalVariable Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => GlobalVariable m -> m # foldMap :: Monoid m => (a -> m) -> GlobalVariable a -> m # foldMap' :: Monoid m => (a -> m) -> GlobalVariable a -> m # foldr :: (a -> b -> b) -> b -> GlobalVariable a -> b # foldr' :: (a -> b -> b) -> b -> GlobalVariable a -> b # foldl :: (b -> a -> b) -> b -> GlobalVariable a -> b # foldl' :: (b -> a -> b) -> b -> GlobalVariable a -> b # foldr1 :: (a -> a -> a) -> GlobalVariable a -> a # foldl1 :: (a -> a -> a) -> GlobalVariable a -> a # toList :: GlobalVariable a -> [a] # null :: GlobalVariable a -> Bool # length :: GlobalVariable a -> Int # elem :: Eq a => a -> GlobalVariable a -> Bool # maximum :: Ord a => GlobalVariable a -> a # minimum :: Ord a => GlobalVariable a -> a # sum :: Num a => GlobalVariable a -> a # product :: Num a => GlobalVariable a -> a #
Traversable GlobalVariable Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> GlobalVariable a -> f (GlobalVariable b) # sequenceA :: Applicative f => GlobalVariable (f a) -> f (GlobalVariable a) # mapM :: Monad m => (a -> m b) -> GlobalVariable a -> m (GlobalVariable b) # sequence :: Monad m => GlobalVariable (m a) -> m (GlobalVariable a) #
SymbolMatching GlobalVariable Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy GlobalVariable -> [Int] showFailure :: Proxy GlobalVariable -> Node -> String
Unmarshal GlobalVariable Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match GlobalVariable) matchers :: B (Int, Match GlobalVariable)
Eq a => Eq (GlobalVariable a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: GlobalVariable a -> GlobalVariable a -> Bool # (/=) :: GlobalVariable a -> GlobalVariable a -> Bool #
Ord a => Ord (GlobalVariable a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: GlobalVariable a -> GlobalVariable a -> Ordering # (<) :: GlobalVariable a -> GlobalVariable a -> Bool # (<=) :: GlobalVariable a -> GlobalVariable a -> Bool # (>) :: GlobalVariable a -> GlobalVariable a -> Bool # (>=) :: GlobalVariable a -> GlobalVariable a -> Bool # max :: GlobalVariable a -> GlobalVariable a -> GlobalVariable a # min :: GlobalVariable a -> GlobalVariable a -> GlobalVariable a #
Show a => Show (GlobalVariable a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> GlobalVariable a -> ShowS # show :: GlobalVariable a -> String # showList :: [GlobalVariable a] -> ShowS #
Generic (GlobalVariable a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (GlobalVariable a) :: Type -> Type # Methods from :: GlobalVariable a -> Rep (GlobalVariable a) x # to :: Rep (GlobalVariable a) x -> GlobalVariable a #
Generic1 GlobalVariable Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 GlobalVariable :: k -> Type # Methods from1 :: forall (a :: k). GlobalVariable a -> Rep1 GlobalVariable a # to1 :: forall (a :: k). Rep1 GlobalVariable a -> GlobalVariable a #
type Rep (GlobalVariable a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (GlobalVariable a) = D1 ('MetaData "GlobalVariable" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "GlobalVariable" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "text") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Text)))
type Rep1 GlobalVariable Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 GlobalVariable = D1 ('MetaData "GlobalVariable" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "GlobalVariable" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Just "text") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Text)))

type AnonymousFor = Token "for" 36 Source #

data Float a Source #

Constructors

Float
Fields ann :: a text :: Text

Instances

Instances details

Functor Float Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> Float a -> Float b # (<$) :: a -> Float b -> Float a #
Foldable Float Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => Float m -> m # foldMap :: Monoid m => (a -> m) -> Float a -> 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 Source #
Instance details Defined in TreeSitter.Ruby.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 Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy Float -> [Int] showFailure :: Proxy Float -> Node -> String
Unmarshal Float Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match Float) matchers :: B (Int, Match Float)
Eq a => Eq (Float a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: Float a -> Float a -> Bool # (/=) :: Float a -> Float a -> Bool #
Ord a => Ord (Float a) Source #
Instance details Defined in TreeSitter.Ruby.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) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> Float a -> ShowS # show :: Float a -> String # showList :: [Float a] -> ShowS #
Generic (Float a) Source #
Instance details Defined in TreeSitter.Ruby.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 Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 Float :: k -> Type # Methods from1 :: forall (a :: k). Float a -> Rep1 Float a # to1 :: forall (a :: k). Rep1 Float a -> Float a #
type Rep (Float a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (Float a) = D1 ('MetaData "Float" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Float" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "text") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Text)))
type Rep1 Float Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 Float = D1 ('MetaData "Float" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Float" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Just "text") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Text)))

data False a Source #

Constructors

False
Fields ann :: a text :: Text

Instances

Instances details

Functor False Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> False a -> False b # (<$) :: a -> False b -> False a #
Foldable False Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => False m -> m # foldMap :: Monoid m => (a -> m) -> False a -> 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 Source #
Instance details Defined in TreeSitter.Ruby.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 Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy False -> [Int] showFailure :: Proxy False -> Node -> String
Unmarshal False Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match False) matchers :: B (Int, Match False)
Eq a => Eq (False a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: False a -> False a -> Bool # (/=) :: False a -> False a -> Bool #
Ord a => Ord (False a) Source #
Instance details Defined in TreeSitter.Ruby.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) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> False a -> ShowS # show :: False a -> String # showList :: [False a] -> ShowS #
Generic (False a) Source #
Instance details Defined in TreeSitter.Ruby.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 Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 False :: k -> Type # Methods from1 :: forall (a :: k). False a -> Rep1 False a # to1 :: forall (a :: k). Rep1 False a -> False a #
type Rep (False a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (False a) = D1 ('MetaData "False" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "False" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "text") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Text)))
type Rep1 False Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 False = D1 ('MetaData "False" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "False" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Just "text") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Text)))

data EscapeSequence a Source #

Constructors

EscapeSequence
Fields ann :: a text :: Text

Instances

Instances details

Functor EscapeSequence Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> EscapeSequence a -> EscapeSequence b # (<$) :: a -> EscapeSequence b -> EscapeSequence a #
Foldable EscapeSequence Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => EscapeSequence m -> m # foldMap :: Monoid m => (a -> m) -> EscapeSequence a -> 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 Source #
Instance details Defined in TreeSitter.Ruby.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 Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy EscapeSequence -> [Int] showFailure :: Proxy EscapeSequence -> Node -> String
Unmarshal EscapeSequence Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match EscapeSequence) matchers :: B (Int, Match EscapeSequence)
Eq a => Eq (EscapeSequence a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: EscapeSequence a -> EscapeSequence a -> Bool # (/=) :: EscapeSequence a -> EscapeSequence a -> Bool #
Ord a => Ord (EscapeSequence a) Source #
Instance details Defined in TreeSitter.Ruby.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) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> EscapeSequence a -> ShowS # show :: EscapeSequence a -> String # showList :: [EscapeSequence a] -> ShowS #
Generic (EscapeSequence a) Source #
Instance details Defined in TreeSitter.Ruby.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 Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 EscapeSequence :: k -> Type # Methods from1 :: forall (a :: k). EscapeSequence a -> Rep1 EscapeSequence a # to1 :: forall (a :: k). Rep1 EscapeSequence a -> EscapeSequence a #
type Rep (EscapeSequence a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (EscapeSequence a) = D1 ('MetaData "EscapeSequence" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "EscapeSequence" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "text") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Text)))
type Rep1 EscapeSequence Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 EscapeSequence = D1 ('MetaData "EscapeSequence" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "EscapeSequence" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Just "text") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Text)))

type AnonymousEnsure = Token "ensure" 45 Source #

type AnonymousEnd = Token "end" 24 Source #

type AnonymousElsif = Token "elsif" 41 Source #

type AnonymousElse = Token "else" 42 Source #

type AnonymousDo = Token "do" 38 Source #

type AnonymousDefinedQuestion = Token "defined?" 88 Source #

type AnonymousDef = Token "def" 8 Source #

data Constant a Source #

Constructors

Constant
Fields ann :: a text :: Text

Instances

Instances details

Functor Constant Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> Constant a -> Constant b # (<$) :: a -> Constant b -> Constant a #
Foldable Constant Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => Constant m -> m # foldMap :: Monoid m => (a -> m) -> Constant a -> m # foldMap' :: Monoid m => (a -> m) -> Constant a -> m # foldr :: (a -> b -> b) -> b -> Constant a -> b # foldr' :: (a -> b -> b) -> b -> Constant a -> b # foldl :: (b -> a -> b) -> b -> Constant a -> b # foldl' :: (b -> a -> b) -> b -> Constant a -> b # foldr1 :: (a -> a -> a) -> Constant a -> a # foldl1 :: (a -> a -> a) -> Constant a -> a # toList :: Constant a -> [a] # null :: Constant a -> Bool # length :: Constant a -> Int # elem :: Eq a => a -> Constant a -> Bool # maximum :: Ord a => Constant a -> a # minimum :: Ord a => Constant a -> a # sum :: Num a => Constant a -> a # product :: Num a => Constant a -> a #
Traversable Constant Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> Constant a -> f (Constant b) # sequenceA :: Applicative f => Constant (f a) -> f (Constant a) # mapM :: Monad m => (a -> m b) -> Constant a -> m (Constant b) # sequence :: Monad m => Constant (m a) -> m (Constant a) #
SymbolMatching Constant Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy Constant -> [Int] showFailure :: Proxy Constant -> Node -> String
Unmarshal Constant Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match Constant) matchers :: B (Int, Match Constant)
Eq a => Eq (Constant a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: Constant a -> Constant a -> Bool # (/=) :: Constant a -> Constant a -> Bool #
Ord a => Ord (Constant a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: Constant a -> Constant a -> Ordering # (<) :: Constant a -> Constant a -> Bool # (<=) :: Constant a -> Constant a -> Bool # (>) :: Constant a -> Constant a -> Bool # (>=) :: Constant a -> Constant a -> Bool # max :: Constant a -> Constant a -> Constant a # min :: Constant a -> Constant a -> Constant a #
Show a => Show (Constant a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> Constant a -> ShowS # show :: Constant a -> String # showList :: [Constant a] -> ShowS #
Generic (Constant a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (Constant a) :: Type -> Type # Methods from :: Constant a -> Rep (Constant a) x # to :: Rep (Constant a) x -> Constant a #
Generic1 Constant Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 Constant :: k -> Type # Methods from1 :: forall (a :: k). Constant a -> Rep1 Constant a # to1 :: forall (a :: k). Rep1 Constant a -> Constant a #
type Rep (Constant a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (Constant a) = D1 ('MetaData "Constant" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Constant" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "text") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Text)))
type Rep1 Constant Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 Constant = D1 ('MetaData "Constant" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Constant" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Just "text") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Text)))

data Complex a Source #

Constructors

Complex
Fields ann :: a text :: Text

Instances

Instances details

Functor Complex Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> Complex a -> Complex b # (<$) :: a -> Complex b -> Complex a #
Foldable Complex Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => Complex m -> m # foldMap :: Monoid m => (a -> m) -> Complex a -> m # foldMap' :: Monoid m => (a -> m) -> Complex a -> m # foldr :: (a -> b -> b) -> b -> Complex a -> b # foldr' :: (a -> b -> b) -> b -> Complex a -> b # foldl :: (b -> a -> b) -> b -> Complex a -> b # foldl' :: (b -> a -> b) -> b -> Complex a -> b # foldr1 :: (a -> a -> a) -> Complex a -> a # foldl1 :: (a -> a -> a) -> Complex a -> a # toList :: Complex a -> [a] # null :: Complex a -> Bool # length :: Complex a -> Int # elem :: Eq a => a -> Complex a -> Bool # maximum :: Ord a => Complex a -> a # minimum :: Ord a => Complex a -> a # sum :: Num a => Complex a -> a # product :: Num a => Complex a -> a #
Traversable Complex Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> Complex a -> f (Complex b) # sequenceA :: Applicative f => Complex (f a) -> f (Complex a) # mapM :: Monad m => (a -> m b) -> Complex a -> m (Complex b) # sequence :: Monad m => Complex (m a) -> m (Complex a) #
SymbolMatching Complex Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy Complex -> [Int] showFailure :: Proxy Complex -> Node -> String
Unmarshal Complex Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match Complex) matchers :: B (Int, Match Complex)
Eq a => Eq (Complex a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: Complex a -> Complex a -> Bool # (/=) :: Complex a -> Complex a -> Bool #
Ord a => Ord (Complex a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: Complex a -> Complex a -> Ordering # (<) :: Complex a -> Complex a -> Bool # (<=) :: Complex a -> Complex a -> Bool # (>) :: Complex a -> Complex a -> Bool # (>=) :: Complex a -> Complex a -> Bool # max :: Complex a -> Complex a -> Complex a # min :: Complex a -> Complex a -> Complex a #
Show a => Show (Complex a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> Complex a -> ShowS # show :: Complex a -> String # showList :: [Complex a] -> ShowS #
Generic (Complex a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (Complex a) :: Type -> Type # Methods from :: Complex a -> Rep (Complex a) x # to :: Rep (Complex a) x -> Complex a #
Generic1 Complex Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 Complex :: k -> Type # Methods from1 :: forall (a :: k). Complex a -> Rep1 Complex a # to1 :: forall (a :: k). Rep1 Complex a -> Complex a #
type Rep (Complex a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (Complex a) = D1 ('MetaData "Complex" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Complex" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "text") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Text)))
type Rep1 Complex Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 Complex = D1 ('MetaData "Complex" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Complex" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Just "text") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Text)))

data ClassVariable a Source #

Constructors

ClassVariable
Fields ann :: a text :: Text

Instances

Instances details

Functor ClassVariable Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> ClassVariable a -> ClassVariable b # (<$) :: a -> ClassVariable b -> ClassVariable a #
Foldable ClassVariable Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => ClassVariable m -> m # foldMap :: Monoid m => (a -> m) -> ClassVariable a -> m # foldMap' :: Monoid m => (a -> m) -> ClassVariable a -> m # foldr :: (a -> b -> b) -> b -> ClassVariable a -> b # foldr' :: (a -> b -> b) -> b -> ClassVariable a -> b # foldl :: (b -> a -> b) -> b -> ClassVariable a -> b # foldl' :: (b -> a -> b) -> b -> ClassVariable a -> b # foldr1 :: (a -> a -> a) -> ClassVariable a -> a # foldl1 :: (a -> a -> a) -> ClassVariable a -> a # toList :: ClassVariable a -> [a] # null :: ClassVariable a -> Bool # length :: ClassVariable a -> Int # elem :: Eq a => a -> ClassVariable a -> Bool # maximum :: Ord a => ClassVariable a -> a # minimum :: Ord a => ClassVariable a -> a # sum :: Num a => ClassVariable a -> a # product :: Num a => ClassVariable a -> a #
Traversable ClassVariable Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> ClassVariable a -> f (ClassVariable b) # sequenceA :: Applicative f => ClassVariable (f a) -> f (ClassVariable a) # mapM :: Monad m => (a -> m b) -> ClassVariable a -> m (ClassVariable b) # sequence :: Monad m => ClassVariable (m a) -> m (ClassVariable a) #
SymbolMatching ClassVariable Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy ClassVariable -> [Int] showFailure :: Proxy ClassVariable -> Node -> String
Unmarshal ClassVariable Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match ClassVariable) matchers :: B (Int, Match ClassVariable)
Eq a => Eq (ClassVariable a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: ClassVariable a -> ClassVariable a -> Bool # (/=) :: ClassVariable a -> ClassVariable a -> Bool #
Ord a => Ord (ClassVariable a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: ClassVariable a -> ClassVariable a -> Ordering # (<) :: ClassVariable a -> ClassVariable a -> Bool # (<=) :: ClassVariable a -> ClassVariable a -> Bool # (>) :: ClassVariable a -> ClassVariable a -> Bool # (>=) :: ClassVariable a -> ClassVariable a -> Bool # max :: ClassVariable a -> ClassVariable a -> ClassVariable a # min :: ClassVariable a -> ClassVariable a -> ClassVariable a #
Show a => Show (ClassVariable a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> ClassVariable a -> ShowS # show :: ClassVariable a -> String # showList :: [ClassVariable a] -> ShowS #
Generic (ClassVariable a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (ClassVariable a) :: Type -> Type # Methods from :: ClassVariable a -> Rep (ClassVariable a) x # to :: Rep (ClassVariable a) x -> ClassVariable a #
Generic1 ClassVariable Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 ClassVariable :: k -> Type # Methods from1 :: forall (a :: k). ClassVariable a -> Rep1 ClassVariable a # to1 :: forall (a :: k). Rep1 ClassVariable a -> ClassVariable a #
type Rep (ClassVariable a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (ClassVariable a) = D1 ('MetaData "ClassVariable" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "ClassVariable" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "text") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Text)))
type Rep1 ClassVariable Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 ClassVariable = D1 ('MetaData "ClassVariable" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "ClassVariable" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Just "text") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Text)))

type AnonymousClass = Token "class" 21 Source #

data Character a Source #

Constructors

Character
Fields ann :: a text :: Text

Instances

Instances details

Functor Character Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> Character a -> Character b # (<$) :: a -> Character b -> Character a #
Foldable Character Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => Character m -> m # foldMap :: Monoid m => (a -> m) -> Character a -> m # foldMap' :: Monoid m => (a -> m) -> Character a -> m # foldr :: (a -> b -> b) -> b -> Character a -> b # foldr' :: (a -> b -> b) -> b -> Character a -> b # foldl :: (b -> a -> b) -> b -> Character a -> b # foldl' :: (b -> a -> b) -> b -> Character a -> b # foldr1 :: (a -> a -> a) -> Character a -> a # foldl1 :: (a -> a -> a) -> Character a -> a # toList :: Character a -> [a] # null :: Character a -> Bool # length :: Character a -> Int # elem :: Eq a => a -> Character a -> Bool # maximum :: Ord a => Character a -> a # minimum :: Ord a => Character a -> a # sum :: Num a => Character a -> a # product :: Num a => Character a -> a #
Traversable Character Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> Character a -> f (Character b) # sequenceA :: Applicative f => Character (f a) -> f (Character a) # mapM :: Monad m => (a -> m b) -> Character a -> m (Character b) # sequence :: Monad m => Character (m a) -> m (Character a) #
SymbolMatching Character Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy Character -> [Int] showFailure :: Proxy Character -> Node -> String
Unmarshal Character Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match Character) matchers :: B (Int, Match Character)
Eq a => Eq (Character a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: Character a -> Character a -> Bool # (/=) :: Character a -> Character a -> Bool #
Ord a => Ord (Character a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: Character a -> Character a -> Ordering # (<) :: Character a -> Character a -> Bool # (<=) :: Character a -> Character a -> Bool # (>) :: Character a -> Character a -> Bool # (>=) :: Character a -> Character a -> Bool # max :: Character a -> Character a -> Character a # min :: Character a -> Character a -> Character a #
Show a => Show (Character a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> Character a -> ShowS # show :: Character a -> String # showList :: [Character a] -> ShowS #
Generic (Character a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (Character a) :: Type -> Type # Methods from :: Character a -> Rep (Character a) x # to :: Rep (Character a) x -> Character a #
Generic1 Character Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 Character :: k -> Type # Methods from1 :: forall (a :: k). Character a -> Rep1 Character a # to1 :: forall (a :: k). Rep1 Character a -> Character a #
type Rep (Character a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (Character a) = D1 ('MetaData "Character" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Character" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "text") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Text)))
type Rep1 Character Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 Character = D1 ('MetaData "Character" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Character" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Just "text") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Text)))

type AnonymousCase = Token "case" 39 Source #

type AnonymousBreak = Token "break" 27 Source #

type AnonymousBegin = Token "begin" 44 Source #

type AnonymousAnd = Token "and" 69 Source #

type AnonymousAlias = Token "alias" 99 Source #

type AnonymousBacktick = Token "`" 97 Source #

type AnonymousUnderscoreENDUnderscore = Token "__END__" 2 Source #

type AnonymousCaretEqual = Token "^=" 64 Source #

type AnonymousCaret = Token "^" 78 Source #

type AnonymousRBracket = Token "]" 48 Source #

type AnonymousLBracketRBracketEqual = Token "[]=" 96 Source #

type AnonymousLBracketRBracket = Token "[]" 95 Source #

type AnonymousLBracket = Token "[" 47 Source #

type AnonymousEND = Token "END" 7 Source #

type AnonymousBEGIN = Token "BEGIN" 4 Source #

type AnonymousQuestion = Token "?" 65 Source #

type AnonymousRAngleRAngleEqual = Token ">>=" 62 Source #

type AnonymousRAngleRAngle = Token ">>" 74 Source #

type AnonymousRAngleEqual = Token ">=" 77 Source #

type AnonymousRAngle = Token ">" 76 Source #

type AnonymousEqualTilde = Token "=~" 86 Source #

type AnonymousEqualRAngle = Token "=>" 46 Source #

type AnonymousEqualEqualEqual = Token "===" 84 Source #

type AnonymousEqualEqual = Token "==" 82 Source #

type AnonymousEqual = Token "=" 20 Source #

type AnonymousLAngleEqualRAngle = Token "<=>" 85 Source #

type AnonymousLAngleEqual = Token "<=" 75 Source #

type AnonymousLAngleLAngleEqual = Token "<<=" 63 Source #

type AnonymousLAngleLAngle = Token "<<" 73 Source #

type AnonymousLAngle = Token "<" 22 Source #

type AnonymousSemicolon = Token ";" 15 Source #

type AnonymousColonColon = Token "::" 12 Source #

type AnonymousColonDQuote = Token ":\"" 123 Source #

type AnonymousColon = Token ":" 19 Source #

type AnonymousSlashEqual = Token "/=" 56 Source #

type AnonymousSlash = Token "/" 80 Source #

type AnonymousDotDotDot = Token "..." 68 Source #

type AnonymousDotDot = Token ".." 67 Source #

type AnonymousDot = Token "." 11 Source #

type AnonymousMinusAt = Token "-@" 94 Source #

type AnonymousMinusRAngle = Token "->" 119 Source #

type AnonymousMinusEqual = Token "-=" 53 Source #

type AnonymousMinus = Token "-" 92 Source #

type AnonymousComma = Token "," 13 Source #

type AnonymousPlusAt = Token "+@" 93 Source #

type AnonymousPlusEqual = Token "+=" 52 Source #

type AnonymousPlus = Token "+" 79 Source #

type AnonymousStarEqual = Token "*=" 54 Source #

type AnonymousStarStarEqual = Token "**=" 55 Source #

type AnonymousStarStar = Token "**" 17 Source #

type AnonymousStar = Token "*" 16 Source #

type AnonymousRParen = Token ")" 10 Source #

type AnonymousLParen = Token "(" 9 Source #

type AnonymousAmpersandEqual = Token "&=" 60 Source #

type AnonymousAmpersandDot = Token "&." 50 Source #

type AnonymousAmpersandAmpersandEqual = Token "&&=" 59 Source #

type AnonymousAmpersandAmpersand = Token "&&" 72 Source #

type AnonymousAmpersand = Token "&" 18 Source #

type AnonymousPercentwLParen = Token "%w(" 126 Source #

type AnonymousPercentiLParen = Token "%i(" 127 Source #

type AnonymousPercentEqual = Token "%=" 61 Source #

type AnonymousPercent = Token "%" 81 Source #

type AnonymousHashLBrace = Token "#{" 115 Source #

type AnonymousDQuote = Token "\"" 122 Source #

type AnonymousBangTilde = Token "!~" 87 Source #

type AnonymousBangEqual = Token "!=" 83 Source #

type AnonymousBang = Token "!" 90 Source #

data Yield a Source #

Constructors

Yield
Fields ann :: a extraChildren :: (Maybe (ArgumentList a))

Instances

Instances details

Functor Yield Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> Yield a -> Yield b # (<$) :: a -> Yield b -> Yield a #
Foldable Yield Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => Yield m -> m # foldMap :: Monoid m => (a -> m) -> Yield a -> 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 Source #
Instance details Defined in TreeSitter.Ruby.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 Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy Yield -> [Int] showFailure :: Proxy Yield -> Node -> String
Unmarshal Yield Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match Yield) matchers :: B (Int, Match Yield)
Eq a => Eq (Yield a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: Yield a -> Yield a -> Bool # (/=) :: Yield a -> Yield a -> Bool #
Ord a => Ord (Yield a) Source #
Instance details Defined in TreeSitter.Ruby.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) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> Yield a -> ShowS # show :: Yield a -> String # showList :: [Yield a] -> ShowS #
Generic (Yield a) Source #
Instance details Defined in TreeSitter.Ruby.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 Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 Yield :: k -> Type # Methods from1 :: forall (a :: k). Yield a -> Rep1 Yield a # to1 :: forall (a :: k). Rep1 Yield a -> Yield a #
type Rep (Yield a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (Yield a) = D1 ('MetaData "Yield" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.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 (ArgumentList a)))))
type Rep1 Yield Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 Yield = D1 ('MetaData "Yield" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.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 ArgumentList)))

data WhileModifier a Source #

Constructors

WhileModifier
Fields ann :: a body :: (Statement a) condition :: ((:+:) ((:+:) Arg ((:+:) Break MethodCall)) ((:+:) Next ((:+:) Return Yield)) a)

Instances

Instances details

Functor WhileModifier Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> WhileModifier a -> WhileModifier b # (<$) :: a -> WhileModifier b -> WhileModifier a #
Foldable WhileModifier Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => WhileModifier m -> m # foldMap :: Monoid m => (a -> m) -> WhileModifier a -> m # foldMap' :: Monoid m => (a -> m) -> WhileModifier a -> m # foldr :: (a -> b -> b) -> b -> WhileModifier a -> b # foldr' :: (a -> b -> b) -> b -> WhileModifier a -> b # foldl :: (b -> a -> b) -> b -> WhileModifier a -> b # foldl' :: (b -> a -> b) -> b -> WhileModifier a -> b # foldr1 :: (a -> a -> a) -> WhileModifier a -> a # foldl1 :: (a -> a -> a) -> WhileModifier a -> a # toList :: WhileModifier a -> [a] # null :: WhileModifier a -> Bool # length :: WhileModifier a -> Int # elem :: Eq a => a -> WhileModifier a -> Bool # maximum :: Ord a => WhileModifier a -> a # minimum :: Ord a => WhileModifier a -> a # sum :: Num a => WhileModifier a -> a # product :: Num a => WhileModifier a -> a #
Traversable WhileModifier Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> WhileModifier a -> f (WhileModifier b) # sequenceA :: Applicative f => WhileModifier (f a) -> f (WhileModifier a) # mapM :: Monad m => (a -> m b) -> WhileModifier a -> m (WhileModifier b) # sequence :: Monad m => WhileModifier (m a) -> m (WhileModifier a) #
SymbolMatching WhileModifier Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy WhileModifier -> [Int] showFailure :: Proxy WhileModifier -> Node -> String
Unmarshal WhileModifier Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match WhileModifier) matchers :: B (Int, Match WhileModifier)
Eq a => Eq (WhileModifier a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: WhileModifier a -> WhileModifier a -> Bool # (/=) :: WhileModifier a -> WhileModifier a -> Bool #
Ord a => Ord (WhileModifier a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: WhileModifier a -> WhileModifier a -> Ordering # (<) :: WhileModifier a -> WhileModifier a -> Bool # (<=) :: WhileModifier a -> WhileModifier a -> Bool # (>) :: WhileModifier a -> WhileModifier a -> Bool # (>=) :: WhileModifier a -> WhileModifier a -> Bool # max :: WhileModifier a -> WhileModifier a -> WhileModifier a # min :: WhileModifier a -> WhileModifier a -> WhileModifier a #
Show a => Show (WhileModifier a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> WhileModifier a -> ShowS # show :: WhileModifier a -> String # showList :: [WhileModifier a] -> ShowS #
Generic (WhileModifier a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (WhileModifier a) :: Type -> Type # Methods from :: WhileModifier a -> Rep (WhileModifier a) x # to :: Rep (WhileModifier a) x -> WhileModifier a #
Generic1 WhileModifier Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 WhileModifier :: k -> Type # Methods from1 :: forall (a :: k). WhileModifier a -> Rep1 WhileModifier a # to1 :: forall (a :: k). Rep1 WhileModifier a -> WhileModifier a #
type Rep (WhileModifier a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (WhileModifier a) = D1 ('MetaData "WhileModifier" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "WhileModifier" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :: (S1 ('MetaSel ('Just "body") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Statement a)) :: S1 ('MetaSel ('Just "condition") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (((Arg :+: (Break :+: MethodCall)) :+: (Next :+: (Return :+: Yield))) a)))))
type Rep1 WhileModifier Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 WhileModifier = D1 ('MetaData "WhileModifier" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "WhileModifier" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :: (S1 ('MetaSel ('Just "body") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 Statement) :: S1 ('MetaSel ('Just "condition") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 ((Arg :+: (Break :+: MethodCall)) :+: (Next :+: (Return :+: Yield)))))))

data While a Source #

Constructors

While
Fields ann :: a body :: (Do a) condition :: (Arg a)

Instances

Instances details

Functor While Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> While a -> While b # (<$) :: a -> While b -> While a #
Foldable While Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => While m -> m # foldMap :: Monoid m => (a -> m) -> While a -> m # foldMap' :: Monoid m => (a -> m) -> While a -> m # foldr :: (a -> b -> b) -> b -> While a -> b # foldr' :: (a -> b -> b) -> b -> While a -> b # foldl :: (b -> a -> b) -> b -> While a -> b # foldl' :: (b -> a -> b) -> b -> While a -> b # foldr1 :: (a -> a -> a) -> While a -> a # foldl1 :: (a -> a -> a) -> While a -> a # toList :: While a -> [a] # null :: While a -> Bool # length :: While a -> Int # elem :: Eq a => a -> While a -> Bool # maximum :: Ord a => While a -> a # minimum :: Ord a => While a -> a # sum :: Num a => While a -> a # product :: Num a => While a -> a #
Traversable While Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> While a -> f (While b) # sequenceA :: Applicative f => While (f a) -> f (While a) # mapM :: Monad m => (a -> m b) -> While a -> m (While b) # sequence :: Monad m => While (m a) -> m (While a) #
SymbolMatching While Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy While -> [Int] showFailure :: Proxy While -> Node -> String
Unmarshal While Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match While) matchers :: B (Int, Match While)
Eq a => Eq (While a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: While a -> While a -> Bool # (/=) :: While a -> While a -> Bool #
Ord a => Ord (While a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: While a -> While a -> Ordering # (<) :: While a -> While a -> Bool # (<=) :: While a -> While a -> Bool # (>) :: While a -> While a -> Bool # (>=) :: While a -> While a -> Bool # max :: While a -> While a -> While a # min :: While a -> While a -> While a #
Show a => Show (While a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> While a -> ShowS # show :: While a -> String # showList :: [While a] -> ShowS #
Generic (While a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (While a) :: Type -> Type # Methods from :: While a -> Rep (While a) x # to :: Rep (While a) x -> While a #
Generic1 While Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 While :: k -> Type # Methods from1 :: forall (a :: k). While a -> Rep1 While a # to1 :: forall (a :: k). Rep1 While a -> While a #
type Rep (While a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (While a) = D1 ('MetaData "While" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "While" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :: (S1 ('MetaSel ('Just "body") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Do a)) :: S1 ('MetaSel ('Just "condition") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Arg a)))))
type Rep1 While Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 While = D1 ('MetaData "While" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "While" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :: (S1 ('MetaSel ('Just "body") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 Do) :: S1 ('MetaSel ('Just "condition") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 Arg))))

data When a Source #

Constructors

When
Fields ann :: a pattern :: (NonEmpty ((:+:) AnonymousComma Pattern a)) body :: (Maybe (Then a))

Instances

Instances details

Functor When Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> When a -> When b # (<$) :: a -> When b -> When a #
Foldable When Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => When m -> m # foldMap :: Monoid m => (a -> m) -> When a -> m # foldMap' :: Monoid m => (a -> m) -> When a -> m # foldr :: (a -> b -> b) -> b -> When a -> b # foldr' :: (a -> b -> b) -> b -> When a -> b # foldl :: (b -> a -> b) -> b -> When a -> b # foldl' :: (b -> a -> b) -> b -> When a -> b # foldr1 :: (a -> a -> a) -> When a -> a # foldl1 :: (a -> a -> a) -> When a -> a # toList :: When a -> [a] # null :: When a -> Bool # length :: When a -> Int # elem :: Eq a => a -> When a -> Bool # maximum :: Ord a => When a -> a # minimum :: Ord a => When a -> a # sum :: Num a => When a -> a # product :: Num a => When a -> a #
Traversable When Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> When a -> f (When b) # sequenceA :: Applicative f => When (f a) -> f (When a) # mapM :: Monad m => (a -> m b) -> When a -> m (When b) # sequence :: Monad m => When (m a) -> m (When a) #
SymbolMatching When Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy When -> [Int] showFailure :: Proxy When -> Node -> String
Unmarshal When Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match When) matchers :: B (Int, Match When)
Eq a => Eq (When a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: When a -> When a -> Bool # (/=) :: When a -> When a -> Bool #
Ord a => Ord (When a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: When a -> When a -> Ordering # (<) :: When a -> When a -> Bool # (<=) :: When a -> When a -> Bool # (>) :: When a -> When a -> Bool # (>=) :: When a -> When a -> Bool # max :: When a -> When a -> When a # min :: When a -> When a -> When a #
Show a => Show (When a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> When a -> ShowS # show :: When a -> String # showList :: [When a] -> ShowS #
Generic (When a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (When a) :: Type -> Type # Methods from :: When a -> Rep (When a) x # to :: Rep (When a) x -> When a #
Generic1 When Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 When :: k -> Type # Methods from1 :: forall (a :: k). When a -> Rep1 When a # to1 :: forall (a :: k). Rep1 When a -> When a #
type Rep (When a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (When a) = D1 ('MetaData "When" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "When" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :: (S1 ('MetaSel ('Just "pattern") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (NonEmpty ((AnonymousComma :+: Pattern) a))) :: S1 ('MetaSel ('Just "body") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe (Then a))))))
type Rep1 When Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 When = D1 ('MetaData "When" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "When" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :: (S1 ('MetaSel ('Just "pattern") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (NonEmpty :.: Rec1 (AnonymousComma :+: Pattern)) :: S1 ('MetaSel ('Just "body") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Maybe :.: Rec1 Then))))

data UntilModifier a Source #

Constructors

UntilModifier
Fields ann :: a body :: (Statement a) condition :: ((:+:) ((:+:) Arg ((:+:) Break MethodCall)) ((:+:) Next ((:+:) Return Yield)) a)

Instances

Instances details

Functor UntilModifier Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> UntilModifier a -> UntilModifier b # (<$) :: a -> UntilModifier b -> UntilModifier a #
Foldable UntilModifier Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => UntilModifier m -> m # foldMap :: Monoid m => (a -> m) -> UntilModifier a -> m # foldMap' :: Monoid m => (a -> m) -> UntilModifier a -> m # foldr :: (a -> b -> b) -> b -> UntilModifier a -> b # foldr' :: (a -> b -> b) -> b -> UntilModifier a -> b # foldl :: (b -> a -> b) -> b -> UntilModifier a -> b # foldl' :: (b -> a -> b) -> b -> UntilModifier a -> b # foldr1 :: (a -> a -> a) -> UntilModifier a -> a # foldl1 :: (a -> a -> a) -> UntilModifier a -> a # toList :: UntilModifier a -> [a] # null :: UntilModifier a -> Bool # length :: UntilModifier a -> Int # elem :: Eq a => a -> UntilModifier a -> Bool # maximum :: Ord a => UntilModifier a -> a # minimum :: Ord a => UntilModifier a -> a # sum :: Num a => UntilModifier a -> a # product :: Num a => UntilModifier a -> a #
Traversable UntilModifier Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> UntilModifier a -> f (UntilModifier b) # sequenceA :: Applicative f => UntilModifier (f a) -> f (UntilModifier a) # mapM :: Monad m => (a -> m b) -> UntilModifier a -> m (UntilModifier b) # sequence :: Monad m => UntilModifier (m a) -> m (UntilModifier a) #
SymbolMatching UntilModifier Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy UntilModifier -> [Int] showFailure :: Proxy UntilModifier -> Node -> String
Unmarshal UntilModifier Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match UntilModifier) matchers :: B (Int, Match UntilModifier)
Eq a => Eq (UntilModifier a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: UntilModifier a -> UntilModifier a -> Bool # (/=) :: UntilModifier a -> UntilModifier a -> Bool #
Ord a => Ord (UntilModifier a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: UntilModifier a -> UntilModifier a -> Ordering # (<) :: UntilModifier a -> UntilModifier a -> Bool # (<=) :: UntilModifier a -> UntilModifier a -> Bool # (>) :: UntilModifier a -> UntilModifier a -> Bool # (>=) :: UntilModifier a -> UntilModifier a -> Bool # max :: UntilModifier a -> UntilModifier a -> UntilModifier a # min :: UntilModifier a -> UntilModifier a -> UntilModifier a #
Show a => Show (UntilModifier a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> UntilModifier a -> ShowS # show :: UntilModifier a -> String # showList :: [UntilModifier a] -> ShowS #
Generic (UntilModifier a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (UntilModifier a) :: Type -> Type # Methods from :: UntilModifier a -> Rep (UntilModifier a) x # to :: Rep (UntilModifier a) x -> UntilModifier a #
Generic1 UntilModifier Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 UntilModifier :: k -> Type # Methods from1 :: forall (a :: k). UntilModifier a -> Rep1 UntilModifier a # to1 :: forall (a :: k). Rep1 UntilModifier a -> UntilModifier a #
type Rep (UntilModifier a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (UntilModifier a) = D1 ('MetaData "UntilModifier" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "UntilModifier" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :: (S1 ('MetaSel ('Just "body") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Statement a)) :: S1 ('MetaSel ('Just "condition") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (((Arg :+: (Break :+: MethodCall)) :+: (Next :+: (Return :+: Yield))) a)))))
type Rep1 UntilModifier Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 UntilModifier = D1 ('MetaData "UntilModifier" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "UntilModifier" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :: (S1 ('MetaSel ('Just "body") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 Statement) :: S1 ('MetaSel ('Just "condition") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 ((Arg :+: (Break :+: MethodCall)) :+: (Next :+: (Return :+: Yield)))))))

data Until a Source #

Constructors

Until
Fields ann :: a body :: (Do a) condition :: (Arg a)

Instances

Instances details

Functor Until Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> Until a -> Until b # (<$) :: a -> Until b -> Until a #
Foldable Until Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => Until m -> m # foldMap :: Monoid m => (a -> m) -> Until a -> m # foldMap' :: Monoid m => (a -> m) -> Until a -> m # foldr :: (a -> b -> b) -> b -> Until a -> b # foldr' :: (a -> b -> b) -> b -> Until a -> b # foldl :: (b -> a -> b) -> b -> Until a -> b # foldl' :: (b -> a -> b) -> b -> Until a -> b # foldr1 :: (a -> a -> a) -> Until a -> a # foldl1 :: (a -> a -> a) -> Until a -> a # toList :: Until a -> [a] # null :: Until a -> Bool # length :: Until a -> Int # elem :: Eq a => a -> Until a -> Bool # maximum :: Ord a => Until a -> a # minimum :: Ord a => Until a -> a # sum :: Num a => Until a -> a # product :: Num a => Until a -> a #
Traversable Until Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> Until a -> f (Until b) # sequenceA :: Applicative f => Until (f a) -> f (Until a) # mapM :: Monad m => (a -> m b) -> Until a -> m (Until b) # sequence :: Monad m => Until (m a) -> m (Until a) #
SymbolMatching Until Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy Until -> [Int] showFailure :: Proxy Until -> Node -> String
Unmarshal Until Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match Until) matchers :: B (Int, Match Until)
Eq a => Eq (Until a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: Until a -> Until a -> Bool # (/=) :: Until a -> Until a -> Bool #
Ord a => Ord (Until a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: Until a -> Until a -> Ordering # (<) :: Until a -> Until a -> Bool # (<=) :: Until a -> Until a -> Bool # (>) :: Until a -> Until a -> Bool # (>=) :: Until a -> Until a -> Bool # max :: Until a -> Until a -> Until a # min :: Until a -> Until a -> Until a #
Show a => Show (Until a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> Until a -> ShowS # show :: Until a -> String # showList :: [Until a] -> ShowS #
Generic (Until a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (Until a) :: Type -> Type # Methods from :: Until a -> Rep (Until a) x # to :: Rep (Until a) x -> Until a #
Generic1 Until Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 Until :: k -> Type # Methods from1 :: forall (a :: k). Until a -> Rep1 Until a # to1 :: forall (a :: k). Rep1 Until a -> Until a #
type Rep (Until a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (Until a) = D1 ('MetaData "Until" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Until" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :: (S1 ('MetaSel ('Just "body") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Do a)) :: S1 ('MetaSel ('Just "condition") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Arg a)))))
type Rep1 Until Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 Until = D1 ('MetaData "Until" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Until" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :: (S1 ('MetaSel ('Just "body") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 Do) :: S1 ('MetaSel ('Just "condition") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 Arg))))

data UnlessModifier a Source #

Constructors

UnlessModifier
Fields ann :: a body :: (Statement a) condition :: ((:+:) ((:+:) Arg ((:+:) Break MethodCall)) ((:+:) Next ((:+:) Return Yield)) a)

Instances

Instances details

Functor UnlessModifier Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> UnlessModifier a -> UnlessModifier b # (<$) :: a -> UnlessModifier b -> UnlessModifier a #
Foldable UnlessModifier Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => UnlessModifier m -> m # foldMap :: Monoid m => (a -> m) -> UnlessModifier a -> m # foldMap' :: Monoid m => (a -> m) -> UnlessModifier a -> m # foldr :: (a -> b -> b) -> b -> UnlessModifier a -> b # foldr' :: (a -> b -> b) -> b -> UnlessModifier a -> b # foldl :: (b -> a -> b) -> b -> UnlessModifier a -> b # foldl' :: (b -> a -> b) -> b -> UnlessModifier a -> b # foldr1 :: (a -> a -> a) -> UnlessModifier a -> a # foldl1 :: (a -> a -> a) -> UnlessModifier a -> a # toList :: UnlessModifier a -> [a] # null :: UnlessModifier a -> Bool # length :: UnlessModifier a -> Int # elem :: Eq a => a -> UnlessModifier a -> Bool # maximum :: Ord a => UnlessModifier a -> a # minimum :: Ord a => UnlessModifier a -> a # sum :: Num a => UnlessModifier a -> a # product :: Num a => UnlessModifier a -> a #
Traversable UnlessModifier Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> UnlessModifier a -> f (UnlessModifier b) # sequenceA :: Applicative f => UnlessModifier (f a) -> f (UnlessModifier a) # mapM :: Monad m => (a -> m b) -> UnlessModifier a -> m (UnlessModifier b) # sequence :: Monad m => UnlessModifier (m a) -> m (UnlessModifier a) #
SymbolMatching UnlessModifier Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy UnlessModifier -> [Int] showFailure :: Proxy UnlessModifier -> Node -> String
Unmarshal UnlessModifier Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match UnlessModifier) matchers :: B (Int, Match UnlessModifier)
Eq a => Eq (UnlessModifier a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: UnlessModifier a -> UnlessModifier a -> Bool # (/=) :: UnlessModifier a -> UnlessModifier a -> Bool #
Ord a => Ord (UnlessModifier a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: UnlessModifier a -> UnlessModifier a -> Ordering # (<) :: UnlessModifier a -> UnlessModifier a -> Bool # (<=) :: UnlessModifier a -> UnlessModifier a -> Bool # (>) :: UnlessModifier a -> UnlessModifier a -> Bool # (>=) :: UnlessModifier a -> UnlessModifier a -> Bool # max :: UnlessModifier a -> UnlessModifier a -> UnlessModifier a # min :: UnlessModifier a -> UnlessModifier a -> UnlessModifier a #
Show a => Show (UnlessModifier a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> UnlessModifier a -> ShowS # show :: UnlessModifier a -> String # showList :: [UnlessModifier a] -> ShowS #
Generic (UnlessModifier a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (UnlessModifier a) :: Type -> Type # Methods from :: UnlessModifier a -> Rep (UnlessModifier a) x # to :: Rep (UnlessModifier a) x -> UnlessModifier a #
Generic1 UnlessModifier Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 UnlessModifier :: k -> Type # Methods from1 :: forall (a :: k). UnlessModifier a -> Rep1 UnlessModifier a # to1 :: forall (a :: k). Rep1 UnlessModifier a -> UnlessModifier a #
type Rep (UnlessModifier a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (UnlessModifier a) = D1 ('MetaData "UnlessModifier" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "UnlessModifier" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :: (S1 ('MetaSel ('Just "body") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Statement a)) :: S1 ('MetaSel ('Just "condition") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (((Arg :+: (Break :+: MethodCall)) :+: (Next :+: (Return :+: Yield))) a)))))
type Rep1 UnlessModifier Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 UnlessModifier = D1 ('MetaData "UnlessModifier" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "UnlessModifier" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :: (S1 ('MetaSel ('Just "body") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 Statement) :: S1 ('MetaSel ('Just "condition") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 ((Arg :+: (Break :+: MethodCall)) :+: (Next :+: (Return :+: Yield)))))))

data Unless a Source #

Constructors

Unless
Fields ann :: a alternative :: (Maybe ((:+:) Else Elsif a)) consequence :: (Maybe (Then a)) condition :: (Statement a)

Instances

Instances details

Functor Unless Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> Unless a -> Unless b # (<$) :: a -> Unless b -> Unless a #
Foldable Unless Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => Unless m -> m # foldMap :: Monoid m => (a -> m) -> Unless a -> m # foldMap' :: Monoid m => (a -> m) -> Unless a -> m # foldr :: (a -> b -> b) -> b -> Unless a -> b # foldr' :: (a -> b -> b) -> b -> Unless a -> b # foldl :: (b -> a -> b) -> b -> Unless a -> b # foldl' :: (b -> a -> b) -> b -> Unless a -> b # foldr1 :: (a -> a -> a) -> Unless a -> a # foldl1 :: (a -> a -> a) -> Unless a -> a # toList :: Unless a -> [a] # null :: Unless a -> Bool # length :: Unless a -> Int # elem :: Eq a => a -> Unless a -> Bool # maximum :: Ord a => Unless a -> a # minimum :: Ord a => Unless a -> a # sum :: Num a => Unless a -> a # product :: Num a => Unless a -> a #
Traversable Unless Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> Unless a -> f (Unless b) # sequenceA :: Applicative f => Unless (f a) -> f (Unless a) # mapM :: Monad m => (a -> m b) -> Unless a -> m (Unless b) # sequence :: Monad m => Unless (m a) -> m (Unless a) #
SymbolMatching Unless Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy Unless -> [Int] showFailure :: Proxy Unless -> Node -> String
Unmarshal Unless Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match Unless) matchers :: B (Int, Match Unless)
Eq a => Eq (Unless a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: Unless a -> Unless a -> Bool # (/=) :: Unless a -> Unless a -> Bool #
Ord a => Ord (Unless a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: Unless a -> Unless a -> Ordering # (<) :: Unless a -> Unless a -> Bool # (<=) :: Unless a -> Unless a -> Bool # (>) :: Unless a -> Unless a -> Bool # (>=) :: Unless a -> Unless a -> Bool # max :: Unless a -> Unless a -> Unless a # min :: Unless a -> Unless a -> Unless a #
Show a => Show (Unless a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> Unless a -> ShowS # show :: Unless a -> String # showList :: [Unless a] -> ShowS #
Generic (Unless a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (Unless a) :: Type -> Type # Methods from :: Unless a -> Rep (Unless a) x # to :: Rep (Unless a) x -> Unless a #
Generic1 Unless Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 Unless :: k -> Type # Methods from1 :: forall (a :: k). Unless a -> Rep1 Unless a # to1 :: forall (a :: k). Rep1 Unless a -> Unless a #
type Rep (Unless a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (Unless a) = D1 ('MetaData "Unless" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Unless" 'PrefixI 'True) ((S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :: S1 ('MetaSel ('Just "alternative") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe ((Else :+: Elsif) a)))) :: (S1 ('MetaSel ('Just "consequence") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe (Then a))) :*: S1 ('MetaSel ('Just "condition") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Statement a)))))
type Rep1 Unless Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 Unless = D1 ('MetaData "Unless" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Unless" 'PrefixI 'True) ((S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :: S1 ('MetaSel ('Just "alternative") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Maybe :.: Rec1 (Else :+: Elsif))) :: (S1 ('MetaSel ('Just "consequence") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Maybe :.: Rec1 Then) :*: S1 ('MetaSel ('Just "condition") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 Statement))))

data Undef a Source #

Constructors

Undef
Fields ann :: a extraChildren :: (NonEmpty (MethodName a))

Instances

Instances details

Functor Undef Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> Undef a -> Undef b # (<$) :: a -> Undef b -> Undef a #
Foldable Undef Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => Undef m -> m # foldMap :: Monoid m => (a -> m) -> Undef a -> m # foldMap' :: Monoid m => (a -> m) -> Undef a -> m # foldr :: (a -> b -> b) -> b -> Undef a -> b # foldr' :: (a -> b -> b) -> b -> Undef a -> b # foldl :: (b -> a -> b) -> b -> Undef a -> b # foldl' :: (b -> a -> b) -> b -> Undef a -> b # foldr1 :: (a -> a -> a) -> Undef a -> a # foldl1 :: (a -> a -> a) -> Undef a -> a # toList :: Undef a -> [a] # null :: Undef a -> Bool # length :: Undef a -> Int # elem :: Eq a => a -> Undef a -> Bool # maximum :: Ord a => Undef a -> a # minimum :: Ord a => Undef a -> a # sum :: Num a => Undef a -> a # product :: Num a => Undef a -> a #
Traversable Undef Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> Undef a -> f (Undef b) # sequenceA :: Applicative f => Undef (f a) -> f (Undef a) # mapM :: Monad m => (a -> m b) -> Undef a -> m (Undef b) # sequence :: Monad m => Undef (m a) -> m (Undef a) #
SymbolMatching Undef Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy Undef -> [Int] showFailure :: Proxy Undef -> Node -> String
Unmarshal Undef Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match Undef) matchers :: B (Int, Match Undef)
Eq a => Eq (Undef a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: Undef a -> Undef a -> Bool # (/=) :: Undef a -> Undef a -> Bool #
Ord a => Ord (Undef a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: Undef a -> Undef a -> Ordering # (<) :: Undef a -> Undef a -> Bool # (<=) :: Undef a -> Undef a -> Bool # (>) :: Undef a -> Undef a -> Bool # (>=) :: Undef a -> Undef a -> Bool # max :: Undef a -> Undef a -> Undef a # min :: Undef a -> Undef a -> Undef a #
Show a => Show (Undef a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> Undef a -> ShowS # show :: Undef a -> String # showList :: [Undef a] -> ShowS #
Generic (Undef a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (Undef a) :: Type -> Type # Methods from :: Undef a -> Rep (Undef a) x # to :: Rep (Undef a) x -> Undef a #
Generic1 Undef Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 Undef :: k -> Type # Methods from1 :: forall (a :: k). Undef a -> Rep1 Undef a # to1 :: forall (a :: k). Rep1 Undef a -> Undef a #
type Rep (Undef a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (Undef a) = D1 ('MetaData "Undef" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Undef" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (NonEmpty (MethodName a)))))
type Rep1 Undef Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 Undef = D1 ('MetaData "Undef" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Undef" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (NonEmpty :.: Rec1 MethodName)))

data Unary a Source #

Constructors

Unary
Fields ann :: a extraChildren :: ((:+:) ((:+:) Arg Float) ((:+:) Integer ParenthesizedStatements) a)

Instances

Instances details

Functor Unary Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> Unary a -> Unary b # (<$) :: a -> Unary b -> Unary a #
Foldable Unary Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => Unary m -> m # foldMap :: Monoid m => (a -> m) -> Unary a -> m # foldMap' :: Monoid m => (a -> m) -> Unary a -> m # foldr :: (a -> b -> b) -> b -> Unary a -> b # foldr' :: (a -> b -> b) -> b -> Unary a -> b # foldl :: (b -> a -> b) -> b -> Unary a -> b # foldl' :: (b -> a -> b) -> b -> Unary a -> b # foldr1 :: (a -> a -> a) -> Unary a -> a # foldl1 :: (a -> a -> a) -> Unary a -> a # toList :: Unary a -> [a] # null :: Unary a -> Bool # length :: Unary a -> Int # elem :: Eq a => a -> Unary a -> Bool # maximum :: Ord a => Unary a -> a # minimum :: Ord a => Unary a -> a # sum :: Num a => Unary a -> a # product :: Num a => Unary a -> a #
Traversable Unary Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> Unary a -> f (Unary b) # sequenceA :: Applicative f => Unary (f a) -> f (Unary a) # mapM :: Monad m => (a -> m b) -> Unary a -> m (Unary b) # sequence :: Monad m => Unary (m a) -> m (Unary a) #
SymbolMatching Unary Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy Unary -> [Int] showFailure :: Proxy Unary -> Node -> String
Unmarshal Unary Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match Unary) matchers :: B (Int, Match Unary)
Eq a => Eq (Unary a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: Unary a -> Unary a -> Bool # (/=) :: Unary a -> Unary a -> Bool #
Ord a => Ord (Unary a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: Unary a -> Unary a -> Ordering # (<) :: Unary a -> Unary a -> Bool # (<=) :: Unary a -> Unary a -> Bool # (>) :: Unary a -> Unary a -> Bool # (>=) :: Unary a -> Unary a -> Bool # max :: Unary a -> Unary a -> Unary a # min :: Unary a -> Unary a -> Unary a #
Show a => Show (Unary a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> Unary a -> ShowS # show :: Unary a -> String # showList :: [Unary a] -> ShowS #
Generic (Unary a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (Unary a) :: Type -> Type # Methods from :: Unary a -> Rep (Unary a) x # to :: Rep (Unary a) x -> Unary a #
Generic1 Unary Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 Unary :: k -> Type # Methods from1 :: forall (a :: k). Unary a -> Rep1 Unary a # to1 :: forall (a :: k). Rep1 Unary a -> Unary a #
type Rep (Unary a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (Unary a) = D1 ('MetaData "Unary" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Unary" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (((Arg :+: Float) :+: (Integer :+: ParenthesizedStatements)) a))))
type Rep1 Unary Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 Unary = D1 ('MetaData "Unary" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Unary" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 ((Arg :+: Float) :+: (Integer :+: ParenthesizedStatements)))))

data Then a Source #

Constructors

Then
Fields ann :: a extraChildren :: ([] ((:+:) Statement EmptyStatement a))

Instances

Instances details

Functor Then Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> Then a -> Then b # (<$) :: a -> Then b -> Then a #
Foldable Then Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => Then m -> m # foldMap :: Monoid m => (a -> m) -> Then a -> m # foldMap' :: Monoid m => (a -> m) -> Then a -> m # foldr :: (a -> b -> b) -> b -> Then a -> b # foldr' :: (a -> b -> b) -> b -> Then a -> b # foldl :: (b -> a -> b) -> b -> Then a -> b # foldl' :: (b -> a -> b) -> b -> Then a -> b # foldr1 :: (a -> a -> a) -> Then a -> a # foldl1 :: (a -> a -> a) -> Then a -> a # toList :: Then a -> [a] # null :: Then a -> Bool # length :: Then a -> Int # elem :: Eq a => a -> Then a -> Bool # maximum :: Ord a => Then a -> a # minimum :: Ord a => Then a -> a # sum :: Num a => Then a -> a # product :: Num a => Then a -> a #
Traversable Then Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> Then a -> f (Then b) # sequenceA :: Applicative f => Then (f a) -> f (Then a) # mapM :: Monad m => (a -> m b) -> Then a -> m (Then b) # sequence :: Monad m => Then (m a) -> m (Then a) #
SymbolMatching Then Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy Then -> [Int] showFailure :: Proxy Then -> Node -> String
Unmarshal Then Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match Then) matchers :: B (Int, Match Then)
Eq a => Eq (Then a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: Then a -> Then a -> Bool # (/=) :: Then a -> Then a -> Bool #
Ord a => Ord (Then a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: Then a -> Then a -> Ordering # (<) :: Then a -> Then a -> Bool # (<=) :: Then a -> Then a -> Bool # (>) :: Then a -> Then a -> Bool # (>=) :: Then a -> Then a -> Bool # max :: Then a -> Then a -> Then a # min :: Then a -> Then a -> Then a #
Show a => Show (Then a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> Then a -> ShowS # show :: Then a -> String # showList :: [Then a] -> ShowS #
Generic (Then a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (Then a) :: Type -> Type # Methods from :: Then a -> Rep (Then a) x # to :: Rep (Then a) x -> Then a #
Generic1 Then Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 Then :: k -> Type # Methods from1 :: forall (a :: k). Then a -> Rep1 Then a # to1 :: forall (a :: k). Rep1 Then a -> Then a #
type Rep (Then a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (Then a) = D1 ('MetaData "Then" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Then" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [(Statement :+: EmptyStatement) a])))
type Rep1 Then Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 Then = D1 ('MetaData "Then" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Then" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) ([] :.: Rec1 (Statement :+: EmptyStatement))))

data SymbolArray a Source #

Constructors

SymbolArray
Fields ann :: a extraChildren :: ([] (BareSymbol a))

Instances

Instances details

Functor SymbolArray Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> SymbolArray a -> SymbolArray b # (<$) :: a -> SymbolArray b -> SymbolArray a #
Foldable SymbolArray Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => SymbolArray m -> m # foldMap :: Monoid m => (a -> m) -> SymbolArray a -> m # foldMap' :: Monoid m => (a -> m) -> SymbolArray a -> m # foldr :: (a -> b -> b) -> b -> SymbolArray a -> b # foldr' :: (a -> b -> b) -> b -> SymbolArray a -> b # foldl :: (b -> a -> b) -> b -> SymbolArray a -> b # foldl' :: (b -> a -> b) -> b -> SymbolArray a -> b # foldr1 :: (a -> a -> a) -> SymbolArray a -> a # foldl1 :: (a -> a -> a) -> SymbolArray a -> a # toList :: SymbolArray a -> [a] # null :: SymbolArray a -> Bool # length :: SymbolArray a -> Int # elem :: Eq a => a -> SymbolArray a -> Bool # maximum :: Ord a => SymbolArray a -> a # minimum :: Ord a => SymbolArray a -> a # sum :: Num a => SymbolArray a -> a # product :: Num a => SymbolArray a -> a #
Traversable SymbolArray Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> SymbolArray a -> f (SymbolArray b) # sequenceA :: Applicative f => SymbolArray (f a) -> f (SymbolArray a) # mapM :: Monad m => (a -> m b) -> SymbolArray a -> m (SymbolArray b) # sequence :: Monad m => SymbolArray (m a) -> m (SymbolArray a) #
SymbolMatching SymbolArray Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy SymbolArray -> [Int] showFailure :: Proxy SymbolArray -> Node -> String
Unmarshal SymbolArray Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match SymbolArray) matchers :: B (Int, Match SymbolArray)
Eq a => Eq (SymbolArray a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: SymbolArray a -> SymbolArray a -> Bool # (/=) :: SymbolArray a -> SymbolArray a -> Bool #
Ord a => Ord (SymbolArray a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: SymbolArray a -> SymbolArray a -> Ordering # (<) :: SymbolArray a -> SymbolArray a -> Bool # (<=) :: SymbolArray a -> SymbolArray a -> Bool # (>) :: SymbolArray a -> SymbolArray a -> Bool # (>=) :: SymbolArray a -> SymbolArray a -> Bool # max :: SymbolArray a -> SymbolArray a -> SymbolArray a # min :: SymbolArray a -> SymbolArray a -> SymbolArray a #
Show a => Show (SymbolArray a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> SymbolArray a -> ShowS # show :: SymbolArray a -> String # showList :: [SymbolArray a] -> ShowS #
Generic (SymbolArray a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (SymbolArray a) :: Type -> Type # Methods from :: SymbolArray a -> Rep (SymbolArray a) x # to :: Rep (SymbolArray a) x -> SymbolArray a #
Generic1 SymbolArray Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 SymbolArray :: k -> Type # Methods from1 :: forall (a :: k). SymbolArray a -> Rep1 SymbolArray a # to1 :: forall (a :: k). Rep1 SymbolArray a -> SymbolArray a #
type Rep (SymbolArray a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (SymbolArray a) = D1 ('MetaData "SymbolArray" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "SymbolArray" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [BareSymbol a])))
type Rep1 SymbolArray Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 SymbolArray = D1 ('MetaData "SymbolArray" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "SymbolArray" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) ([] :.: Rec1 BareSymbol)))

data Symbol a Source #

Constructors

Symbol
Fields ann :: a extraChildren :: ([] ((:+:) EscapeSequence Interpolation a))

Instances

Instances details

Functor Symbol Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> Symbol a -> Symbol b # (<$) :: a -> Symbol b -> Symbol a #
Foldable Symbol Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => Symbol m -> m # foldMap :: Monoid m => (a -> m) -> Symbol a -> m # foldMap' :: Monoid m => (a -> m) -> Symbol a -> m # foldr :: (a -> b -> b) -> b -> Symbol a -> b # foldr' :: (a -> b -> b) -> b -> Symbol a -> b # foldl :: (b -> a -> b) -> b -> Symbol a -> b # foldl' :: (b -> a -> b) -> b -> Symbol a -> b # foldr1 :: (a -> a -> a) -> Symbol a -> a # foldl1 :: (a -> a -> a) -> Symbol a -> a # toList :: Symbol a -> [a] # null :: Symbol a -> Bool # length :: Symbol a -> Int # elem :: Eq a => a -> Symbol a -> Bool # maximum :: Ord a => Symbol a -> a # minimum :: Ord a => Symbol a -> a # sum :: Num a => Symbol a -> a # product :: Num a => Symbol a -> a #
Traversable Symbol Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> Symbol a -> f (Symbol b) # sequenceA :: Applicative f => Symbol (f a) -> f (Symbol a) # mapM :: Monad m => (a -> m b) -> Symbol a -> m (Symbol b) # sequence :: Monad m => Symbol (m a) -> m (Symbol a) #
SymbolMatching Symbol Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy Symbol -> [Int] showFailure :: Proxy Symbol -> Node -> String
Unmarshal Symbol Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match Symbol) matchers :: B (Int, Match Symbol)
Eq a => Eq (Symbol a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: Symbol a -> Symbol a -> Bool # (/=) :: Symbol a -> Symbol a -> Bool #
Ord a => Ord (Symbol a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: Symbol a -> Symbol a -> Ordering # (<) :: Symbol a -> Symbol a -> Bool # (<=) :: Symbol a -> Symbol a -> Bool # (>) :: Symbol a -> Symbol a -> Bool # (>=) :: Symbol a -> Symbol a -> Bool # max :: Symbol a -> Symbol a -> Symbol a # min :: Symbol a -> Symbol a -> Symbol a #
Show a => Show (Symbol a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> Symbol a -> ShowS # show :: Symbol a -> String # showList :: [Symbol a] -> ShowS #
Generic (Symbol a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (Symbol a) :: Type -> Type # Methods from :: Symbol a -> Rep (Symbol a) x # to :: Rep (Symbol a) x -> Symbol a #
Generic1 Symbol Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 Symbol :: k -> Type # Methods from1 :: forall (a :: k). Symbol a -> Rep1 Symbol a # to1 :: forall (a :: k). Rep1 Symbol a -> Symbol a #
type Rep (Symbol a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (Symbol a) = D1 ('MetaData "Symbol" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Symbol" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [(EscapeSequence :+: Interpolation) a])))
type Rep1 Symbol Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 Symbol = D1 ('MetaData "Symbol" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Symbol" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) ([] :.: Rec1 (EscapeSequence :+: Interpolation))))

data Superclass a Source #

Constructors

Superclass
Fields ann :: a extraChildren :: (Arg a)

Instances

Instances details

Functor Superclass Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> Superclass a -> Superclass b # (<$) :: a -> Superclass b -> Superclass a #
Foldable Superclass Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => Superclass m -> m # foldMap :: Monoid m => (a -> m) -> Superclass a -> m # foldMap' :: Monoid m => (a -> m) -> Superclass a -> m # foldr :: (a -> b -> b) -> b -> Superclass a -> b # foldr' :: (a -> b -> b) -> b -> Superclass a -> b # foldl :: (b -> a -> b) -> b -> Superclass a -> b # foldl' :: (b -> a -> b) -> b -> Superclass a -> b # foldr1 :: (a -> a -> a) -> Superclass a -> a # foldl1 :: (a -> a -> a) -> Superclass a -> a # toList :: Superclass a -> [a] # null :: Superclass a -> Bool # length :: Superclass a -> Int # elem :: Eq a => a -> Superclass a -> Bool # maximum :: Ord a => Superclass a -> a # minimum :: Ord a => Superclass a -> a # sum :: Num a => Superclass a -> a # product :: Num a => Superclass a -> a #
Traversable Superclass Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> Superclass a -> f (Superclass b) # sequenceA :: Applicative f => Superclass (f a) -> f (Superclass a) # mapM :: Monad m => (a -> m b) -> Superclass a -> m (Superclass b) # sequence :: Monad m => Superclass (m a) -> m (Superclass a) #
SymbolMatching Superclass Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy Superclass -> [Int] showFailure :: Proxy Superclass -> Node -> String
Unmarshal Superclass Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match Superclass) matchers :: B (Int, Match Superclass)
Eq a => Eq (Superclass a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: Superclass a -> Superclass a -> Bool # (/=) :: Superclass a -> Superclass a -> Bool #
Ord a => Ord (Superclass a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: Superclass a -> Superclass a -> Ordering # (<) :: Superclass a -> Superclass a -> Bool # (<=) :: Superclass a -> Superclass a -> Bool # (>) :: Superclass a -> Superclass a -> Bool # (>=) :: Superclass a -> Superclass a -> Bool # max :: Superclass a -> Superclass a -> Superclass a # min :: Superclass a -> Superclass a -> Superclass a #
Show a => Show (Superclass a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> Superclass a -> ShowS # show :: Superclass a -> String # showList :: [Superclass a] -> ShowS #
Generic (Superclass a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (Superclass a) :: Type -> Type # Methods from :: Superclass a -> Rep (Superclass a) x # to :: Rep (Superclass a) x -> Superclass a #
Generic1 Superclass Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 Superclass :: k -> Type # Methods from1 :: forall (a :: k). Superclass a -> Rep1 Superclass a # to1 :: forall (a :: k). Rep1 Superclass a -> Superclass a #
type Rep (Superclass a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (Superclass a) = D1 ('MetaData "Superclass" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Superclass" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Arg a))))
type Rep1 Superclass Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 Superclass = D1 ('MetaData "Superclass" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Superclass" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 Arg)))

data Subshell a Source #

Constructors

Subshell
Fields ann :: a extraChildren :: ([] ((:+:) EscapeSequence Interpolation a))

Instances

Instances details

Functor Subshell Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> Subshell a -> Subshell b # (<$) :: a -> Subshell b -> Subshell a #
Foldable Subshell Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => Subshell m -> m # foldMap :: Monoid m => (a -> m) -> Subshell a -> m # foldMap' :: Monoid m => (a -> m) -> Subshell a -> m # foldr :: (a -> b -> b) -> b -> Subshell a -> b # foldr' :: (a -> b -> b) -> b -> Subshell a -> b # foldl :: (b -> a -> b) -> b -> Subshell a -> b # foldl' :: (b -> a -> b) -> b -> Subshell a -> b # foldr1 :: (a -> a -> a) -> Subshell a -> a # foldl1 :: (a -> a -> a) -> Subshell a -> a # toList :: Subshell a -> [a] # null :: Subshell a -> Bool # length :: Subshell a -> Int # elem :: Eq a => a -> Subshell a -> Bool # maximum :: Ord a => Subshell a -> a # minimum :: Ord a => Subshell a -> a # sum :: Num a => Subshell a -> a # product :: Num a => Subshell a -> a #
Traversable Subshell Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> Subshell a -> f (Subshell b) # sequenceA :: Applicative f => Subshell (f a) -> f (Subshell a) # mapM :: Monad m => (a -> m b) -> Subshell a -> m (Subshell b) # sequence :: Monad m => Subshell (m a) -> m (Subshell a) #
SymbolMatching Subshell Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy Subshell -> [Int] showFailure :: Proxy Subshell -> Node -> String
Unmarshal Subshell Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match Subshell) matchers :: B (Int, Match Subshell)
Eq a => Eq (Subshell a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: Subshell a -> Subshell a -> Bool # (/=) :: Subshell a -> Subshell a -> Bool #
Ord a => Ord (Subshell a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: Subshell a -> Subshell a -> Ordering # (<) :: Subshell a -> Subshell a -> Bool # (<=) :: Subshell a -> Subshell a -> Bool # (>) :: Subshell a -> Subshell a -> Bool # (>=) :: Subshell a -> Subshell a -> Bool # max :: Subshell a -> Subshell a -> Subshell a # min :: Subshell a -> Subshell a -> Subshell a #
Show a => Show (Subshell a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> Subshell a -> ShowS # show :: Subshell a -> String # showList :: [Subshell a] -> ShowS #
Generic (Subshell a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (Subshell a) :: Type -> Type # Methods from :: Subshell a -> Rep (Subshell a) x # to :: Rep (Subshell a) x -> Subshell a #
Generic1 Subshell Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 Subshell :: k -> Type # Methods from1 :: forall (a :: k). Subshell a -> Rep1 Subshell a # to1 :: forall (a :: k). Rep1 Subshell a -> Subshell a #
type Rep (Subshell a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (Subshell a) = D1 ('MetaData "Subshell" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Subshell" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [(EscapeSequence :+: Interpolation) a])))
type Rep1 Subshell Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 Subshell = D1 ('MetaData "Subshell" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Subshell" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) ([] :.: Rec1 (EscapeSequence :+: Interpolation))))

data StringArray a Source #

Constructors

StringArray
Fields ann :: a extraChildren :: ([] (BareString a))

Instances

Instances details

Functor StringArray Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> StringArray a -> StringArray b # (<$) :: a -> StringArray b -> StringArray a #
Foldable StringArray Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => StringArray m -> m # foldMap :: Monoid m => (a -> m) -> StringArray a -> m # foldMap' :: Monoid m => (a -> m) -> StringArray a -> m # foldr :: (a -> b -> b) -> b -> StringArray a -> b # foldr' :: (a -> b -> b) -> b -> StringArray a -> b # foldl :: (b -> a -> b) -> b -> StringArray a -> b # foldl' :: (b -> a -> b) -> b -> StringArray a -> b # foldr1 :: (a -> a -> a) -> StringArray a -> a # foldl1 :: (a -> a -> a) -> StringArray a -> a # toList :: StringArray a -> [a] # null :: StringArray a -> Bool # length :: StringArray a -> Int # elem :: Eq a => a -> StringArray a -> Bool # maximum :: Ord a => StringArray a -> a # minimum :: Ord a => StringArray a -> a # sum :: Num a => StringArray a -> a # product :: Num a => StringArray a -> a #
Traversable StringArray Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> StringArray a -> f (StringArray b) # sequenceA :: Applicative f => StringArray (f a) -> f (StringArray a) # mapM :: Monad m => (a -> m b) -> StringArray a -> m (StringArray b) # sequence :: Monad m => StringArray (m a) -> m (StringArray a) #
SymbolMatching StringArray Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy StringArray -> [Int] showFailure :: Proxy StringArray -> Node -> String
Unmarshal StringArray Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match StringArray) matchers :: B (Int, Match StringArray)
Eq a => Eq (StringArray a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: StringArray a -> StringArray a -> Bool # (/=) :: StringArray a -> StringArray a -> Bool #
Ord a => Ord (StringArray a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: StringArray a -> StringArray a -> Ordering # (<) :: StringArray a -> StringArray a -> Bool # (<=) :: StringArray a -> StringArray a -> Bool # (>) :: StringArray a -> StringArray a -> Bool # (>=) :: StringArray a -> StringArray a -> Bool # max :: StringArray a -> StringArray a -> StringArray a # min :: StringArray a -> StringArray a -> StringArray a #
Show a => Show (StringArray a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> StringArray a -> ShowS # show :: StringArray a -> String # showList :: [StringArray a] -> ShowS #
Generic (StringArray a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (StringArray a) :: Type -> Type # Methods from :: StringArray a -> Rep (StringArray a) x # to :: Rep (StringArray a) x -> StringArray a #
Generic1 StringArray Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 StringArray :: k -> Type # Methods from1 :: forall (a :: k). StringArray a -> Rep1 StringArray a # to1 :: forall (a :: k). Rep1 StringArray a -> StringArray a #
type Rep (StringArray a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (StringArray a) = D1 ('MetaData "StringArray" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "StringArray" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [BareString a])))
type Rep1 StringArray Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 StringArray = D1 ('MetaData "StringArray" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "StringArray" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) ([] :.: Rec1 BareString)))

data String a Source #

Constructors

String
Fields ann :: a extraChildren :: ([] ((:+:) EscapeSequence Interpolation a))

Instances

Instances details

Functor String Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> String a -> String b # (<$) :: a -> String b -> String a #
Foldable String Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => String m -> m # foldMap :: Monoid m => (a -> m) -> String a -> 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 Source #
Instance details Defined in TreeSitter.Ruby.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 Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy String -> [Int] showFailure :: Proxy String -> Node -> String0
Unmarshal String Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match String) matchers :: B (Int, Match String)
Eq a => Eq (String a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: String a -> String a -> Bool # (/=) :: String a -> String a -> Bool #
Ord a => Ord (String a) Source #
Instance details Defined in TreeSitter.Ruby.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) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> String a -> ShowS # show :: String a -> String0 # showList :: [String a] -> ShowS #
Generic (String a) Source #
Instance details Defined in TreeSitter.Ruby.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 Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 String :: k -> Type # Methods from1 :: forall (a :: k). String a -> Rep1 String a # to1 :: forall (a :: k). Rep1 String a -> String a #
type Rep (String a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (String a) = D1 ('MetaData "String" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.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 Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 String = D1 ('MetaData "String" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.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 SplatParameter a Source #

Constructors

SplatParameter
Fields ann :: a name :: (Maybe (Identifier a))

Instances

Instances details

Functor SplatParameter Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> SplatParameter a -> SplatParameter b # (<$) :: a -> SplatParameter b -> SplatParameter a #
Foldable SplatParameter Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => SplatParameter m -> m # foldMap :: Monoid m => (a -> m) -> SplatParameter a -> m # foldMap' :: Monoid m => (a -> m) -> SplatParameter a -> m # foldr :: (a -> b -> b) -> b -> SplatParameter a -> b # foldr' :: (a -> b -> b) -> b -> SplatParameter a -> b # foldl :: (b -> a -> b) -> b -> SplatParameter a -> b # foldl' :: (b -> a -> b) -> b -> SplatParameter a -> b # foldr1 :: (a -> a -> a) -> SplatParameter a -> a # foldl1 :: (a -> a -> a) -> SplatParameter a -> a # toList :: SplatParameter a -> [a] # null :: SplatParameter a -> Bool # length :: SplatParameter a -> Int # elem :: Eq a => a -> SplatParameter a -> Bool # maximum :: Ord a => SplatParameter a -> a # minimum :: Ord a => SplatParameter a -> a # sum :: Num a => SplatParameter a -> a # product :: Num a => SplatParameter a -> a #
Traversable SplatParameter Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> SplatParameter a -> f (SplatParameter b) # sequenceA :: Applicative f => SplatParameter (f a) -> f (SplatParameter a) # mapM :: Monad m => (a -> m b) -> SplatParameter a -> m (SplatParameter b) # sequence :: Monad m => SplatParameter (m a) -> m (SplatParameter a) #
SymbolMatching SplatParameter Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy SplatParameter -> [Int] showFailure :: Proxy SplatParameter -> Node -> String
Unmarshal SplatParameter Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match SplatParameter) matchers :: B (Int, Match SplatParameter)
Eq a => Eq (SplatParameter a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: SplatParameter a -> SplatParameter a -> Bool # (/=) :: SplatParameter a -> SplatParameter a -> Bool #
Ord a => Ord (SplatParameter a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: SplatParameter a -> SplatParameter a -> Ordering # (<) :: SplatParameter a -> SplatParameter a -> Bool # (<=) :: SplatParameter a -> SplatParameter a -> Bool # (>) :: SplatParameter a -> SplatParameter a -> Bool # (>=) :: SplatParameter a -> SplatParameter a -> Bool # max :: SplatParameter a -> SplatParameter a -> SplatParameter a # min :: SplatParameter a -> SplatParameter a -> SplatParameter a #
Show a => Show (SplatParameter a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> SplatParameter a -> ShowS # show :: SplatParameter a -> String # showList :: [SplatParameter a] -> ShowS #
Generic (SplatParameter a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (SplatParameter a) :: Type -> Type # Methods from :: SplatParameter a -> Rep (SplatParameter a) x # to :: Rep (SplatParameter a) x -> SplatParameter a #
Generic1 SplatParameter Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 SplatParameter :: k -> Type # Methods from1 :: forall (a :: k). SplatParameter a -> Rep1 SplatParameter a # to1 :: forall (a :: k). Rep1 SplatParameter a -> SplatParameter a #
type Rep (SplatParameter a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (SplatParameter a) = D1 ('MetaData "SplatParameter" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "SplatParameter" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "name") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe (Identifier a)))))
type Rep1 SplatParameter Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 SplatParameter = D1 ('MetaData "SplatParameter" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "SplatParameter" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Just "name") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Maybe :.: Rec1 Identifier)))

data SplatArgument a Source #

Constructors

SplatArgument
Fields ann :: a extraChildren :: (Arg a)

Instances

Instances details

Functor SplatArgument Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> SplatArgument a -> SplatArgument b # (<$) :: a -> SplatArgument b -> SplatArgument a #
Foldable SplatArgument Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => SplatArgument m -> m # foldMap :: Monoid m => (a -> m) -> SplatArgument a -> m # foldMap' :: Monoid m => (a -> m) -> SplatArgument a -> m # foldr :: (a -> b -> b) -> b -> SplatArgument a -> b # foldr' :: (a -> b -> b) -> b -> SplatArgument a -> b # foldl :: (b -> a -> b) -> b -> SplatArgument a -> b # foldl' :: (b -> a -> b) -> b -> SplatArgument a -> b # foldr1 :: (a -> a -> a) -> SplatArgument a -> a # foldl1 :: (a -> a -> a) -> SplatArgument a -> a # toList :: SplatArgument a -> [a] # null :: SplatArgument a -> Bool # length :: SplatArgument a -> Int # elem :: Eq a => a -> SplatArgument a -> Bool # maximum :: Ord a => SplatArgument a -> a # minimum :: Ord a => SplatArgument a -> a # sum :: Num a => SplatArgument a -> a # product :: Num a => SplatArgument a -> a #
Traversable SplatArgument Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> SplatArgument a -> f (SplatArgument b) # sequenceA :: Applicative f => SplatArgument (f a) -> f (SplatArgument a) # mapM :: Monad m => (a -> m b) -> SplatArgument a -> m (SplatArgument b) # sequence :: Monad m => SplatArgument (m a) -> m (SplatArgument a) #
SymbolMatching SplatArgument Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy SplatArgument -> [Int] showFailure :: Proxy SplatArgument -> Node -> String
Unmarshal SplatArgument Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match SplatArgument) matchers :: B (Int, Match SplatArgument)
Eq a => Eq (SplatArgument a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: SplatArgument a -> SplatArgument a -> Bool # (/=) :: SplatArgument a -> SplatArgument a -> Bool #
Ord a => Ord (SplatArgument a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: SplatArgument a -> SplatArgument a -> Ordering # (<) :: SplatArgument a -> SplatArgument a -> Bool # (<=) :: SplatArgument a -> SplatArgument a -> Bool # (>) :: SplatArgument a -> SplatArgument a -> Bool # (>=) :: SplatArgument a -> SplatArgument a -> Bool # max :: SplatArgument a -> SplatArgument a -> SplatArgument a # min :: SplatArgument a -> SplatArgument a -> SplatArgument a #
Show a => Show (SplatArgument a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> SplatArgument a -> ShowS # show :: SplatArgument a -> String # showList :: [SplatArgument a] -> ShowS #
Generic (SplatArgument a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (SplatArgument a) :: Type -> Type # Methods from :: SplatArgument a -> Rep (SplatArgument a) x # to :: Rep (SplatArgument a) x -> SplatArgument a #
Generic1 SplatArgument Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 SplatArgument :: k -> Type # Methods from1 :: forall (a :: k). SplatArgument a -> Rep1 SplatArgument a # to1 :: forall (a :: k). Rep1 SplatArgument a -> SplatArgument a #
type Rep (SplatArgument a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (SplatArgument a) = D1 ('MetaData "SplatArgument" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "SplatArgument" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Arg a))))
type Rep1 SplatArgument Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 SplatArgument = D1 ('MetaData "SplatArgument" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "SplatArgument" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 Arg)))

data SingletonMethod a Source #

Constructors

SingletonMethod
Fields ann :: a name :: (MethodName a) parameters :: (Maybe (MethodParameters a)) object :: ((:+:) Arg Variable a) extraChildren :: ([] ((:+:) ((:+:) Statement Else) ((:+:) EmptyStatement ((:+:) Ensure Rescue)) a))

Instances

Instances details

Functor SingletonMethod Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> SingletonMethod a -> SingletonMethod b # (<$) :: a -> SingletonMethod b -> SingletonMethod a #
Foldable SingletonMethod Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => SingletonMethod m -> m # foldMap :: Monoid m => (a -> m) -> SingletonMethod a -> m # foldMap' :: Monoid m => (a -> m) -> SingletonMethod a -> m # foldr :: (a -> b -> b) -> b -> SingletonMethod a -> b # foldr' :: (a -> b -> b) -> b -> SingletonMethod a -> b # foldl :: (b -> a -> b) -> b -> SingletonMethod a -> b # foldl' :: (b -> a -> b) -> b -> SingletonMethod a -> b # foldr1 :: (a -> a -> a) -> SingletonMethod a -> a # foldl1 :: (a -> a -> a) -> SingletonMethod a -> a # toList :: SingletonMethod a -> [a] # null :: SingletonMethod a -> Bool # length :: SingletonMethod a -> Int # elem :: Eq a => a -> SingletonMethod a -> Bool # maximum :: Ord a => SingletonMethod a -> a # minimum :: Ord a => SingletonMethod a -> a # sum :: Num a => SingletonMethod a -> a # product :: Num a => SingletonMethod a -> a #
Traversable SingletonMethod Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> SingletonMethod a -> f (SingletonMethod b) # sequenceA :: Applicative f => SingletonMethod (f a) -> f (SingletonMethod a) # mapM :: Monad m => (a -> m b) -> SingletonMethod a -> m (SingletonMethod b) # sequence :: Monad m => SingletonMethod (m a) -> m (SingletonMethod a) #
SymbolMatching SingletonMethod Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy SingletonMethod -> [Int] showFailure :: Proxy SingletonMethod -> Node -> String
Unmarshal SingletonMethod Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match SingletonMethod) matchers :: B (Int, Match SingletonMethod)
Eq a => Eq (SingletonMethod a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: SingletonMethod a -> SingletonMethod a -> Bool # (/=) :: SingletonMethod a -> SingletonMethod a -> Bool #
Ord a => Ord (SingletonMethod a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: SingletonMethod a -> SingletonMethod a -> Ordering # (<) :: SingletonMethod a -> SingletonMethod a -> Bool # (<=) :: SingletonMethod a -> SingletonMethod a -> Bool # (>) :: SingletonMethod a -> SingletonMethod a -> Bool # (>=) :: SingletonMethod a -> SingletonMethod a -> Bool # max :: SingletonMethod a -> SingletonMethod a -> SingletonMethod a # min :: SingletonMethod a -> SingletonMethod a -> SingletonMethod a #
Show a => Show (SingletonMethod a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> SingletonMethod a -> ShowS # show :: SingletonMethod a -> String # showList :: [SingletonMethod a] -> ShowS #
Generic (SingletonMethod a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (SingletonMethod a) :: Type -> Type # Methods from :: SingletonMethod a -> Rep (SingletonMethod a) x # to :: Rep (SingletonMethod a) x -> SingletonMethod a #
Generic1 SingletonMethod Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 SingletonMethod :: k -> Type # Methods from1 :: forall (a :: k). SingletonMethod a -> Rep1 SingletonMethod a # to1 :: forall (a :: k). Rep1 SingletonMethod a -> SingletonMethod a #
type Rep (SingletonMethod a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (SingletonMethod a) = D1 ('MetaData "SingletonMethod" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "SingletonMethod" 'PrefixI 'True) ((S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :: S1 ('MetaSel ('Just "name") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (MethodName a))) :: (S1 ('MetaSel ('Just "parameters") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe (MethodParameters a))) :: (S1 ('MetaSel ('Just "object") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ((Arg :+: Variable) a)) :: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [((Statement :+: Else) :+: (EmptyStatement :+: (Ensure :+: Rescue))) a])))))
type Rep1 SingletonMethod Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 SingletonMethod = D1 ('MetaData "SingletonMethod" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "SingletonMethod" 'PrefixI 'True) ((S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :: S1 ('MetaSel ('Just "name") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 MethodName)) :: (S1 ('MetaSel ('Just "parameters") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Maybe :.: Rec1 MethodParameters) :: (S1 ('MetaSel ('Just "object") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 (Arg :+: Variable)) :: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) ([] :.: Rec1 ((Statement :+: Else) :+: (EmptyStatement :+: (Ensure :+: Rescue))))))))

data SingletonClass a Source #

Constructors

SingletonClass
Fields ann :: a value :: (Arg a) extraChildren :: ([] ((:+:) ((:+:) Statement Else) ((:+:) EmptyStatement ((:+:) Ensure Rescue)) a))

Instances

Instances details

Functor SingletonClass Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> SingletonClass a -> SingletonClass b # (<$) :: a -> SingletonClass b -> SingletonClass a #
Foldable SingletonClass Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => SingletonClass m -> m # foldMap :: Monoid m => (a -> m) -> SingletonClass a -> m # foldMap' :: Monoid m => (a -> m) -> SingletonClass a -> m # foldr :: (a -> b -> b) -> b -> SingletonClass a -> b # foldr' :: (a -> b -> b) -> b -> SingletonClass a -> b # foldl :: (b -> a -> b) -> b -> SingletonClass a -> b # foldl' :: (b -> a -> b) -> b -> SingletonClass a -> b # foldr1 :: (a -> a -> a) -> SingletonClass a -> a # foldl1 :: (a -> a -> a) -> SingletonClass a -> a # toList :: SingletonClass a -> [a] # null :: SingletonClass a -> Bool # length :: SingletonClass a -> Int # elem :: Eq a => a -> SingletonClass a -> Bool # maximum :: Ord a => SingletonClass a -> a # minimum :: Ord a => SingletonClass a -> a # sum :: Num a => SingletonClass a -> a # product :: Num a => SingletonClass a -> a #
Traversable SingletonClass Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> SingletonClass a -> f (SingletonClass b) # sequenceA :: Applicative f => SingletonClass (f a) -> f (SingletonClass a) # mapM :: Monad m => (a -> m b) -> SingletonClass a -> m (SingletonClass b) # sequence :: Monad m => SingletonClass (m a) -> m (SingletonClass a) #
SymbolMatching SingletonClass Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy SingletonClass -> [Int] showFailure :: Proxy SingletonClass -> Node -> String
Unmarshal SingletonClass Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match SingletonClass) matchers :: B (Int, Match SingletonClass)
Eq a => Eq (SingletonClass a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: SingletonClass a -> SingletonClass a -> Bool # (/=) :: SingletonClass a -> SingletonClass a -> Bool #
Ord a => Ord (SingletonClass a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: SingletonClass a -> SingletonClass a -> Ordering # (<) :: SingletonClass a -> SingletonClass a -> Bool # (<=) :: SingletonClass a -> SingletonClass a -> Bool # (>) :: SingletonClass a -> SingletonClass a -> Bool # (>=) :: SingletonClass a -> SingletonClass a -> Bool # max :: SingletonClass a -> SingletonClass a -> SingletonClass a # min :: SingletonClass a -> SingletonClass a -> SingletonClass a #
Show a => Show (SingletonClass a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> SingletonClass a -> ShowS # show :: SingletonClass a -> String # showList :: [SingletonClass a] -> ShowS #
Generic (SingletonClass a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (SingletonClass a) :: Type -> Type # Methods from :: SingletonClass a -> Rep (SingletonClass a) x # to :: Rep (SingletonClass a) x -> SingletonClass a #
Generic1 SingletonClass Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 SingletonClass :: k -> Type # Methods from1 :: forall (a :: k). SingletonClass a -> Rep1 SingletonClass a # to1 :: forall (a :: k). Rep1 SingletonClass a -> SingletonClass a #
type Rep (SingletonClass a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (SingletonClass a) = D1 ('MetaData "SingletonClass" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "SingletonClass" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :: (S1 ('MetaSel ('Just "value") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Arg a)) :: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [((Statement :+: Else) :+: (EmptyStatement :+: (Ensure :+: Rescue))) a]))))
type Rep1 SingletonClass Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 SingletonClass = D1 ('MetaData "SingletonClass" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "SingletonClass" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :: (S1 ('MetaSel ('Just "value") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 Arg) :: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) ([] :.: Rec1 ((Statement :+: Else) :+: (EmptyStatement :+: (Ensure :+: Rescue)))))))

data Setter a Source #

Constructors

Setter
Fields ann :: a extraChildren :: (Identifier a)

Instances

Instances details

Functor Setter Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> Setter a -> Setter b # (<$) :: a -> Setter b -> Setter a #
Foldable Setter Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => Setter m -> m # foldMap :: Monoid m => (a -> m) -> Setter a -> m # foldMap' :: Monoid m => (a -> m) -> Setter a -> m # foldr :: (a -> b -> b) -> b -> Setter a -> b # foldr' :: (a -> b -> b) -> b -> Setter a -> b # foldl :: (b -> a -> b) -> b -> Setter a -> b # foldl' :: (b -> a -> b) -> b -> Setter a -> b # foldr1 :: (a -> a -> a) -> Setter a -> a # foldl1 :: (a -> a -> a) -> Setter a -> a # toList :: Setter a -> [a] # null :: Setter a -> Bool # length :: Setter a -> Int # elem :: Eq a => a -> Setter a -> Bool # maximum :: Ord a => Setter a -> a # minimum :: Ord a => Setter a -> a # sum :: Num a => Setter a -> a # product :: Num a => Setter a -> a #
Traversable Setter Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> Setter a -> f (Setter b) # sequenceA :: Applicative f => Setter (f a) -> f (Setter a) # mapM :: Monad m => (a -> m b) -> Setter a -> m (Setter b) # sequence :: Monad m => Setter (m a) -> m (Setter a) #
SymbolMatching Setter Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy Setter -> [Int] showFailure :: Proxy Setter -> Node -> String
Unmarshal Setter Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match Setter) matchers :: B (Int, Match Setter)
Eq a => Eq (Setter a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: Setter a -> Setter a -> Bool # (/=) :: Setter a -> Setter a -> Bool #
Ord a => Ord (Setter a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: Setter a -> Setter a -> Ordering # (<) :: Setter a -> Setter a -> Bool # (<=) :: Setter a -> Setter a -> Bool # (>) :: Setter a -> Setter a -> Bool # (>=) :: Setter a -> Setter a -> Bool # max :: Setter a -> Setter a -> Setter a # min :: Setter a -> Setter a -> Setter a #
Show a => Show (Setter a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> Setter a -> ShowS # show :: Setter a -> String # showList :: [Setter a] -> ShowS #
Generic (Setter a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (Setter a) :: Type -> Type # Methods from :: Setter a -> Rep (Setter a) x # to :: Rep (Setter a) x -> Setter a #
Generic1 Setter Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 Setter :: k -> Type # Methods from1 :: forall (a :: k). Setter a -> Rep1 Setter a # to1 :: forall (a :: k). Rep1 Setter a -> Setter a #
type Rep (Setter a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (Setter a) = D1 ('MetaData "Setter" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Setter" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Identifier a))))
type Rep1 Setter Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 Setter = D1 ('MetaData "Setter" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Setter" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 Identifier)))

data ScopeResolution a Source #

Constructors

ScopeResolution
Fields ann :: a name :: ((:+:) Constant Identifier a) scope :: (Maybe (Primary a))

Instances

Instances details

Functor ScopeResolution Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> ScopeResolution a -> ScopeResolution b # (<$) :: a -> ScopeResolution b -> ScopeResolution a #
Foldable ScopeResolution Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => ScopeResolution m -> m # foldMap :: Monoid m => (a -> m) -> ScopeResolution a -> m # foldMap' :: Monoid m => (a -> m) -> ScopeResolution a -> m # foldr :: (a -> b -> b) -> b -> ScopeResolution a -> b # foldr' :: (a -> b -> b) -> b -> ScopeResolution a -> b # foldl :: (b -> a -> b) -> b -> ScopeResolution a -> b # foldl' :: (b -> a -> b) -> b -> ScopeResolution a -> b # foldr1 :: (a -> a -> a) -> ScopeResolution a -> a # foldl1 :: (a -> a -> a) -> ScopeResolution a -> a # toList :: ScopeResolution a -> [a] # null :: ScopeResolution a -> Bool # length :: ScopeResolution a -> Int # elem :: Eq a => a -> ScopeResolution a -> Bool # maximum :: Ord a => ScopeResolution a -> a # minimum :: Ord a => ScopeResolution a -> a # sum :: Num a => ScopeResolution a -> a # product :: Num a => ScopeResolution a -> a #
Traversable ScopeResolution Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> ScopeResolution a -> f (ScopeResolution b) # sequenceA :: Applicative f => ScopeResolution (f a) -> f (ScopeResolution a) # mapM :: Monad m => (a -> m b) -> ScopeResolution a -> m (ScopeResolution b) # sequence :: Monad m => ScopeResolution (m a) -> m (ScopeResolution a) #
SymbolMatching ScopeResolution Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy ScopeResolution -> [Int] showFailure :: Proxy ScopeResolution -> Node -> String
Unmarshal ScopeResolution Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match ScopeResolution) matchers :: B (Int, Match ScopeResolution)
Eq a => Eq (ScopeResolution a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: ScopeResolution a -> ScopeResolution a -> Bool # (/=) :: ScopeResolution a -> ScopeResolution a -> Bool #
Ord a => Ord (ScopeResolution a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: ScopeResolution a -> ScopeResolution a -> Ordering # (<) :: ScopeResolution a -> ScopeResolution a -> Bool # (<=) :: ScopeResolution a -> ScopeResolution a -> Bool # (>) :: ScopeResolution a -> ScopeResolution a -> Bool # (>=) :: ScopeResolution a -> ScopeResolution a -> Bool # max :: ScopeResolution a -> ScopeResolution a -> ScopeResolution a # min :: ScopeResolution a -> ScopeResolution a -> ScopeResolution a #
Show a => Show (ScopeResolution a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> ScopeResolution a -> ShowS # show :: ScopeResolution a -> String # showList :: [ScopeResolution a] -> ShowS #
Generic (ScopeResolution a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (ScopeResolution a) :: Type -> Type # Methods from :: ScopeResolution a -> Rep (ScopeResolution a) x # to :: Rep (ScopeResolution a) x -> ScopeResolution a #
Generic1 ScopeResolution Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 ScopeResolution :: k -> Type # Methods from1 :: forall (a :: k). ScopeResolution a -> Rep1 ScopeResolution a # to1 :: forall (a :: k). Rep1 ScopeResolution a -> ScopeResolution a #
type Rep (ScopeResolution a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (ScopeResolution a) = D1 ('MetaData "ScopeResolution" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "ScopeResolution" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :: (S1 ('MetaSel ('Just "name") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ((Constant :+: Identifier) a)) :: S1 ('MetaSel ('Just "scope") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe (Primary a))))))
type Rep1 ScopeResolution Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 ScopeResolution = D1 ('MetaData "ScopeResolution" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "ScopeResolution" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :: (S1 ('MetaSel ('Just "name") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 (Constant :+: Identifier)) :: S1 ('MetaSel ('Just "scope") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Maybe :.: Rec1 Primary))))

data RightAssignmentList a Source #

Constructors

RightAssignmentList
Fields ann :: a extraChildren :: (NonEmpty ((:+:) Arg SplatArgument a))

Instances

Instances details

Functor RightAssignmentList Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> RightAssignmentList a -> RightAssignmentList b # (<$) :: a -> RightAssignmentList b -> RightAssignmentList a #
Foldable RightAssignmentList Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => RightAssignmentList m -> m # foldMap :: Monoid m => (a -> m) -> RightAssignmentList a -> m # foldMap' :: Monoid m => (a -> m) -> RightAssignmentList a -> m # foldr :: (a -> b -> b) -> b -> RightAssignmentList a -> b # foldr' :: (a -> b -> b) -> b -> RightAssignmentList a -> b # foldl :: (b -> a -> b) -> b -> RightAssignmentList a -> b # foldl' :: (b -> a -> b) -> b -> RightAssignmentList a -> b # foldr1 :: (a -> a -> a) -> RightAssignmentList a -> a # foldl1 :: (a -> a -> a) -> RightAssignmentList a -> a # toList :: RightAssignmentList a -> [a] # null :: RightAssignmentList a -> Bool # length :: RightAssignmentList a -> Int # elem :: Eq a => a -> RightAssignmentList a -> Bool # maximum :: Ord a => RightAssignmentList a -> a # minimum :: Ord a => RightAssignmentList a -> a # sum :: Num a => RightAssignmentList a -> a # product :: Num a => RightAssignmentList a -> a #
Traversable RightAssignmentList Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> RightAssignmentList a -> f (RightAssignmentList b) # sequenceA :: Applicative f => RightAssignmentList (f a) -> f (RightAssignmentList a) # mapM :: Monad m => (a -> m b) -> RightAssignmentList a -> m (RightAssignmentList b) # sequence :: Monad m => RightAssignmentList (m a) -> m (RightAssignmentList a) #
SymbolMatching RightAssignmentList Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy RightAssignmentList -> [Int] showFailure :: Proxy RightAssignmentList -> Node -> String
Unmarshal RightAssignmentList Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match RightAssignmentList) matchers :: B (Int, Match RightAssignmentList)
Eq a => Eq (RightAssignmentList a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: RightAssignmentList a -> RightAssignmentList a -> Bool # (/=) :: RightAssignmentList a -> RightAssignmentList a -> Bool #
Ord a => Ord (RightAssignmentList a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: RightAssignmentList a -> RightAssignmentList a -> Ordering # (<) :: RightAssignmentList a -> RightAssignmentList a -> Bool # (<=) :: RightAssignmentList a -> RightAssignmentList a -> Bool # (>) :: RightAssignmentList a -> RightAssignmentList a -> Bool # (>=) :: RightAssignmentList a -> RightAssignmentList a -> Bool # max :: RightAssignmentList a -> RightAssignmentList a -> RightAssignmentList a # min :: RightAssignmentList a -> RightAssignmentList a -> RightAssignmentList a #
Show a => Show (RightAssignmentList a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> RightAssignmentList a -> ShowS # show :: RightAssignmentList a -> String # showList :: [RightAssignmentList a] -> ShowS #
Generic (RightAssignmentList a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (RightAssignmentList a) :: Type -> Type # Methods from :: RightAssignmentList a -> Rep (RightAssignmentList a) x # to :: Rep (RightAssignmentList a) x -> RightAssignmentList a #
Generic1 RightAssignmentList Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 RightAssignmentList :: k -> Type # Methods from1 :: forall (a :: k). RightAssignmentList a -> Rep1 RightAssignmentList a # to1 :: forall (a :: k). Rep1 RightAssignmentList a -> RightAssignmentList a #
type Rep (RightAssignmentList a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (RightAssignmentList a) = D1 ('MetaData "RightAssignmentList" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "RightAssignmentList" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (NonEmpty ((Arg :+: SplatArgument) a)))))
type Rep1 RightAssignmentList Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 RightAssignmentList = D1 ('MetaData "RightAssignmentList" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "RightAssignmentList" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (NonEmpty :.: Rec1 (Arg :+: SplatArgument))))

data Return a Source #

Constructors

Return
Fields ann :: a extraChildren :: (Maybe (ArgumentList a))

Instances

Instances details

Functor Return Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> Return a -> Return b # (<$) :: a -> Return b -> Return a #
Foldable Return Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => Return m -> m # foldMap :: Monoid m => (a -> m) -> Return a -> m # foldMap' :: Monoid m => (a -> m) -> Return a -> m # foldr :: (a -> b -> b) -> b -> Return a -> b # foldr' :: (a -> b -> b) -> b -> Return a -> b # foldl :: (b -> a -> b) -> b -> Return a -> b # foldl' :: (b -> a -> b) -> b -> Return a -> b # foldr1 :: (a -> a -> a) -> Return a -> a # foldl1 :: (a -> a -> a) -> Return a -> a # toList :: Return a -> [a] # null :: Return a -> Bool # length :: Return a -> Int # elem :: Eq a => a -> Return a -> Bool # maximum :: Ord a => Return a -> a # minimum :: Ord a => Return a -> a # sum :: Num a => Return a -> a # product :: Num a => Return a -> a #
Traversable Return Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> Return a -> f (Return b) # sequenceA :: Applicative f => Return (f a) -> f (Return a) # mapM :: Monad m => (a -> m b) -> Return a -> m (Return b) # sequence :: Monad m => Return (m a) -> m (Return a) #
SymbolMatching Return Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy Return -> [Int] showFailure :: Proxy Return -> Node -> String
Unmarshal Return Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match Return) matchers :: B (Int, Match Return)
Eq a => Eq (Return a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: Return a -> Return a -> Bool # (/=) :: Return a -> Return a -> Bool #
Ord a => Ord (Return a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: Return a -> Return a -> Ordering # (<) :: Return a -> Return a -> Bool # (<=) :: Return a -> Return a -> Bool # (>) :: Return a -> Return a -> Bool # (>=) :: Return a -> Return a -> Bool # max :: Return a -> Return a -> Return a # min :: Return a -> Return a -> Return a #
Show a => Show (Return a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> Return a -> ShowS # show :: Return a -> String # showList :: [Return a] -> ShowS #
Generic (Return a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (Return a) :: Type -> Type # Methods from :: Return a -> Rep (Return a) x # to :: Rep (Return a) x -> Return a #
Generic1 Return Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 Return :: k -> Type # Methods from1 :: forall (a :: k). Return a -> Rep1 Return a # to1 :: forall (a :: k). Rep1 Return a -> Return a #
type Rep (Return a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (Return a) = D1 ('MetaData "Return" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Return" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe (ArgumentList a)))))
type Rep1 Return Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 Return = D1 ('MetaData "Return" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Return" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Maybe :.: Rec1 ArgumentList)))

data Retry a Source #

Constructors

Retry
Fields ann :: a extraChildren :: (Maybe (ArgumentList a))

Instances

Instances details

Functor Retry Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> Retry a -> Retry b # (<$) :: a -> Retry b -> Retry a #
Foldable Retry Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => Retry m -> m # foldMap :: Monoid m => (a -> m) -> Retry a -> m # foldMap' :: Monoid m => (a -> m) -> Retry a -> m # foldr :: (a -> b -> b) -> b -> Retry a -> b # foldr' :: (a -> b -> b) -> b -> Retry a -> b # foldl :: (b -> a -> b) -> b -> Retry a -> b # foldl' :: (b -> a -> b) -> b -> Retry a -> b # foldr1 :: (a -> a -> a) -> Retry a -> a # foldl1 :: (a -> a -> a) -> Retry a -> a # toList :: Retry a -> [a] # null :: Retry a -> Bool # length :: Retry a -> Int # elem :: Eq a => a -> Retry a -> Bool # maximum :: Ord a => Retry a -> a # minimum :: Ord a => Retry a -> a # sum :: Num a => Retry a -> a # product :: Num a => Retry a -> a #
Traversable Retry Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> Retry a -> f (Retry b) # sequenceA :: Applicative f => Retry (f a) -> f (Retry a) # mapM :: Monad m => (a -> m b) -> Retry a -> m (Retry b) # sequence :: Monad m => Retry (m a) -> m (Retry a) #
SymbolMatching Retry Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy Retry -> [Int] showFailure :: Proxy Retry -> Node -> String
Unmarshal Retry Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match Retry) matchers :: B (Int, Match Retry)
Eq a => Eq (Retry a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: Retry a -> Retry a -> Bool # (/=) :: Retry a -> Retry a -> Bool #
Ord a => Ord (Retry a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: Retry a -> Retry a -> Ordering # (<) :: Retry a -> Retry a -> Bool # (<=) :: Retry a -> Retry a -> Bool # (>) :: Retry a -> Retry a -> Bool # (>=) :: Retry a -> Retry a -> Bool # max :: Retry a -> Retry a -> Retry a # min :: Retry a -> Retry a -> Retry a #
Show a => Show (Retry a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> Retry a -> ShowS # show :: Retry a -> String # showList :: [Retry a] -> ShowS #
Generic (Retry a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (Retry a) :: Type -> Type # Methods from :: Retry a -> Rep (Retry a) x # to :: Rep (Retry a) x -> Retry a #
Generic1 Retry Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 Retry :: k -> Type # Methods from1 :: forall (a :: k). Retry a -> Rep1 Retry a # to1 :: forall (a :: k). Rep1 Retry a -> Retry a #
type Rep (Retry a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (Retry a) = D1 ('MetaData "Retry" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Retry" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe (ArgumentList a)))))
type Rep1 Retry Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 Retry = D1 ('MetaData "Retry" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Retry" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Maybe :.: Rec1 ArgumentList)))

data RestAssignment a Source #

Constructors

RestAssignment
Fields ann :: a extraChildren :: (Maybe (Lhs a))

Instances

Instances details

Functor RestAssignment Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> RestAssignment a -> RestAssignment b # (<$) :: a -> RestAssignment b -> RestAssignment a #
Foldable RestAssignment Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => RestAssignment m -> m # foldMap :: Monoid m => (a -> m) -> RestAssignment a -> m # foldMap' :: Monoid m => (a -> m) -> RestAssignment a -> m # foldr :: (a -> b -> b) -> b -> RestAssignment a -> b # foldr' :: (a -> b -> b) -> b -> RestAssignment a -> b # foldl :: (b -> a -> b) -> b -> RestAssignment a -> b # foldl' :: (b -> a -> b) -> b -> RestAssignment a -> b # foldr1 :: (a -> a -> a) -> RestAssignment a -> a # foldl1 :: (a -> a -> a) -> RestAssignment a -> a # toList :: RestAssignment a -> [a] # null :: RestAssignment a -> Bool # length :: RestAssignment a -> Int # elem :: Eq a => a -> RestAssignment a -> Bool # maximum :: Ord a => RestAssignment a -> a # minimum :: Ord a => RestAssignment a -> a # sum :: Num a => RestAssignment a -> a # product :: Num a => RestAssignment a -> a #
Traversable RestAssignment Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> RestAssignment a -> f (RestAssignment b) # sequenceA :: Applicative f => RestAssignment (f a) -> f (RestAssignment a) # mapM :: Monad m => (a -> m b) -> RestAssignment a -> m (RestAssignment b) # sequence :: Monad m => RestAssignment (m a) -> m (RestAssignment a) #
SymbolMatching RestAssignment Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy RestAssignment -> [Int] showFailure :: Proxy RestAssignment -> Node -> String
Unmarshal RestAssignment Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match RestAssignment) matchers :: B (Int, Match RestAssignment)
Eq a => Eq (RestAssignment a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: RestAssignment a -> RestAssignment a -> Bool # (/=) :: RestAssignment a -> RestAssignment a -> Bool #
Ord a => Ord (RestAssignment a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: RestAssignment a -> RestAssignment a -> Ordering # (<) :: RestAssignment a -> RestAssignment a -> Bool # (<=) :: RestAssignment a -> RestAssignment a -> Bool # (>) :: RestAssignment a -> RestAssignment a -> Bool # (>=) :: RestAssignment a -> RestAssignment a -> Bool # max :: RestAssignment a -> RestAssignment a -> RestAssignment a # min :: RestAssignment a -> RestAssignment a -> RestAssignment a #
Show a => Show (RestAssignment a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> RestAssignment a -> ShowS # show :: RestAssignment a -> String # showList :: [RestAssignment a] -> ShowS #
Generic (RestAssignment a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (RestAssignment a) :: Type -> Type # Methods from :: RestAssignment a -> Rep (RestAssignment a) x # to :: Rep (RestAssignment a) x -> RestAssignment a #
Generic1 RestAssignment Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 RestAssignment :: k -> Type # Methods from1 :: forall (a :: k). RestAssignment a -> Rep1 RestAssignment a # to1 :: forall (a :: k). Rep1 RestAssignment a -> RestAssignment a #
type Rep (RestAssignment a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (RestAssignment a) = D1 ('MetaData "RestAssignment" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "RestAssignment" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe (Lhs a)))))
type Rep1 RestAssignment Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 RestAssignment = D1 ('MetaData "RestAssignment" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "RestAssignment" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Maybe :.: Rec1 Lhs)))

data RescueModifier a Source #

Constructors

RescueModifier
Fields ann :: a body :: (Statement a) handler :: ((:+:) ((:+:) Arg ((:+:) Break MethodCall)) ((:+:) Next ((:+:) Return Yield)) a)

Instances

Instances details

Functor RescueModifier Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> RescueModifier a -> RescueModifier b # (<$) :: a -> RescueModifier b -> RescueModifier a #
Foldable RescueModifier Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => RescueModifier m -> m # foldMap :: Monoid m => (a -> m) -> RescueModifier a -> m # foldMap' :: Monoid m => (a -> m) -> RescueModifier a -> m # foldr :: (a -> b -> b) -> b -> RescueModifier a -> b # foldr' :: (a -> b -> b) -> b -> RescueModifier a -> b # foldl :: (b -> a -> b) -> b -> RescueModifier a -> b # foldl' :: (b -> a -> b) -> b -> RescueModifier a -> b # foldr1 :: (a -> a -> a) -> RescueModifier a -> a # foldl1 :: (a -> a -> a) -> RescueModifier a -> a # toList :: RescueModifier a -> [a] # null :: RescueModifier a -> Bool # length :: RescueModifier a -> Int # elem :: Eq a => a -> RescueModifier a -> Bool # maximum :: Ord a => RescueModifier a -> a # minimum :: Ord a => RescueModifier a -> a # sum :: Num a => RescueModifier a -> a # product :: Num a => RescueModifier a -> a #
Traversable RescueModifier Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> RescueModifier a -> f (RescueModifier b) # sequenceA :: Applicative f => RescueModifier (f a) -> f (RescueModifier a) # mapM :: Monad m => (a -> m b) -> RescueModifier a -> m (RescueModifier b) # sequence :: Monad m => RescueModifier (m a) -> m (RescueModifier a) #
SymbolMatching RescueModifier Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy RescueModifier -> [Int] showFailure :: Proxy RescueModifier -> Node -> String
Unmarshal RescueModifier Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match RescueModifier) matchers :: B (Int, Match RescueModifier)
Eq a => Eq (RescueModifier a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: RescueModifier a -> RescueModifier a -> Bool # (/=) :: RescueModifier a -> RescueModifier a -> Bool #
Ord a => Ord (RescueModifier a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: RescueModifier a -> RescueModifier a -> Ordering # (<) :: RescueModifier a -> RescueModifier a -> Bool # (<=) :: RescueModifier a -> RescueModifier a -> Bool # (>) :: RescueModifier a -> RescueModifier a -> Bool # (>=) :: RescueModifier a -> RescueModifier a -> Bool # max :: RescueModifier a -> RescueModifier a -> RescueModifier a # min :: RescueModifier a -> RescueModifier a -> RescueModifier a #
Show a => Show (RescueModifier a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> RescueModifier a -> ShowS # show :: RescueModifier a -> String # showList :: [RescueModifier a] -> ShowS #
Generic (RescueModifier a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (RescueModifier a) :: Type -> Type # Methods from :: RescueModifier a -> Rep (RescueModifier a) x # to :: Rep (RescueModifier a) x -> RescueModifier a #
Generic1 RescueModifier Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 RescueModifier :: k -> Type # Methods from1 :: forall (a :: k). RescueModifier a -> Rep1 RescueModifier a # to1 :: forall (a :: k). Rep1 RescueModifier a -> RescueModifier a #
type Rep (RescueModifier a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (RescueModifier a) = D1 ('MetaData "RescueModifier" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "RescueModifier" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :: (S1 ('MetaSel ('Just "body") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Statement a)) :: S1 ('MetaSel ('Just "handler") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (((Arg :+: (Break :+: MethodCall)) :+: (Next :+: (Return :+: Yield))) a)))))
type Rep1 RescueModifier Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 RescueModifier = D1 ('MetaData "RescueModifier" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "RescueModifier" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :: (S1 ('MetaSel ('Just "body") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 Statement) :: S1 ('MetaSel ('Just "handler") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 ((Arg :+: (Break :+: MethodCall)) :+: (Next :+: (Return :+: Yield)))))))

data Rescue a Source #

Constructors

Rescue
Fields ann :: a exceptions :: (Maybe (Exceptions a)) body :: (Maybe (Then a)) variable :: (Maybe (ExceptionVariable a))

Instances

Instances details

Functor Rescue Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> Rescue a -> Rescue b # (<$) :: a -> Rescue b -> Rescue a #
Foldable Rescue Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => Rescue m -> m # foldMap :: Monoid m => (a -> m) -> Rescue a -> m # foldMap' :: Monoid m => (a -> m) -> Rescue a -> m # foldr :: (a -> b -> b) -> b -> Rescue a -> b # foldr' :: (a -> b -> b) -> b -> Rescue a -> b # foldl :: (b -> a -> b) -> b -> Rescue a -> b # foldl' :: (b -> a -> b) -> b -> Rescue a -> b # foldr1 :: (a -> a -> a) -> Rescue a -> a # foldl1 :: (a -> a -> a) -> Rescue a -> a # toList :: Rescue a -> [a] # null :: Rescue a -> Bool # length :: Rescue a -> Int # elem :: Eq a => a -> Rescue a -> Bool # maximum :: Ord a => Rescue a -> a # minimum :: Ord a => Rescue a -> a # sum :: Num a => Rescue a -> a # product :: Num a => Rescue a -> a #
Traversable Rescue Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> Rescue a -> f (Rescue b) # sequenceA :: Applicative f => Rescue (f a) -> f (Rescue a) # mapM :: Monad m => (a -> m b) -> Rescue a -> m (Rescue b) # sequence :: Monad m => Rescue (m a) -> m (Rescue a) #
SymbolMatching Rescue Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy Rescue -> [Int] showFailure :: Proxy Rescue -> Node -> String
Unmarshal Rescue Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match Rescue) matchers :: B (Int, Match Rescue)
Eq a => Eq (Rescue a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: Rescue a -> Rescue a -> Bool # (/=) :: Rescue a -> Rescue a -> Bool #
Ord a => Ord (Rescue a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: Rescue a -> Rescue a -> Ordering # (<) :: Rescue a -> Rescue a -> Bool # (<=) :: Rescue a -> Rescue a -> Bool # (>) :: Rescue a -> Rescue a -> Bool # (>=) :: Rescue a -> Rescue a -> Bool # max :: Rescue a -> Rescue a -> Rescue a # min :: Rescue a -> Rescue a -> Rescue a #
Show a => Show (Rescue a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> Rescue a -> ShowS # show :: Rescue a -> String # showList :: [Rescue a] -> ShowS #
Generic (Rescue a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (Rescue a) :: Type -> Type # Methods from :: Rescue a -> Rep (Rescue a) x # to :: Rep (Rescue a) x -> Rescue a #
Generic1 Rescue Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 Rescue :: k -> Type # Methods from1 :: forall (a :: k). Rescue a -> Rep1 Rescue a # to1 :: forall (a :: k). Rep1 Rescue a -> Rescue a #
type Rep (Rescue a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (Rescue a) = D1 ('MetaData "Rescue" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Rescue" 'PrefixI 'True) ((S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :: S1 ('MetaSel ('Just "exceptions") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe (Exceptions a)))) :: (S1 ('MetaSel ('Just "body") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe (Then a))) :*: S1 ('MetaSel ('Just "variable") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe (ExceptionVariable a))))))
type Rep1 Rescue Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 Rescue = D1 ('MetaData "Rescue" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Rescue" 'PrefixI 'True) ((S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :: S1 ('MetaSel ('Just "exceptions") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Maybe :.: Rec1 Exceptions)) :: (S1 ('MetaSel ('Just "body") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Maybe :.: Rec1 Then) :*: S1 ('MetaSel ('Just "variable") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Maybe :.: Rec1 ExceptionVariable))))

data Regex a Source #

Constructors

Regex
Fields ann :: a extraChildren :: ([] ((:+:) EscapeSequence Interpolation a))

Instances

Instances details

Functor Regex Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> Regex a -> Regex b # (<$) :: a -> Regex b -> Regex a #
Foldable Regex Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => Regex m -> m # foldMap :: Monoid m => (a -> m) -> Regex a -> m # foldMap' :: Monoid m => (a -> m) -> Regex a -> m # foldr :: (a -> b -> b) -> b -> Regex a -> b # foldr' :: (a -> b -> b) -> b -> Regex a -> b # foldl :: (b -> a -> b) -> b -> Regex a -> b # foldl' :: (b -> a -> b) -> b -> Regex a -> b # foldr1 :: (a -> a -> a) -> Regex a -> a # foldl1 :: (a -> a -> a) -> Regex a -> a # toList :: Regex a -> [a] # null :: Regex a -> Bool # length :: Regex a -> Int # elem :: Eq a => a -> Regex a -> Bool # maximum :: Ord a => Regex a -> a # minimum :: Ord a => Regex a -> a # sum :: Num a => Regex a -> a # product :: Num a => Regex a -> a #
Traversable Regex Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> Regex a -> f (Regex b) # sequenceA :: Applicative f => Regex (f a) -> f (Regex a) # mapM :: Monad m => (a -> m b) -> Regex a -> m (Regex b) # sequence :: Monad m => Regex (m a) -> m (Regex a) #
SymbolMatching Regex Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy Regex -> [Int] showFailure :: Proxy Regex -> Node -> String
Unmarshal Regex Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match Regex) matchers :: B (Int, Match Regex)
Eq a => Eq (Regex a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: Regex a -> Regex a -> Bool # (/=) :: Regex a -> Regex a -> Bool #
Ord a => Ord (Regex a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: Regex a -> Regex a -> Ordering # (<) :: Regex a -> Regex a -> Bool # (<=) :: Regex a -> Regex a -> Bool # (>) :: Regex a -> Regex a -> Bool # (>=) :: Regex a -> Regex a -> Bool # max :: Regex a -> Regex a -> Regex a # min :: Regex a -> Regex a -> Regex a #
Show a => Show (Regex a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> Regex a -> ShowS # show :: Regex a -> String # showList :: [Regex a] -> ShowS #
Generic (Regex a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (Regex a) :: Type -> Type # Methods from :: Regex a -> Rep (Regex a) x # to :: Rep (Regex a) x -> Regex a #
Generic1 Regex Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 Regex :: k -> Type # Methods from1 :: forall (a :: k). Regex a -> Rep1 Regex a # to1 :: forall (a :: k). Rep1 Regex a -> Regex a #
type Rep (Regex a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (Regex a) = D1 ('MetaData "Regex" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Regex" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [(EscapeSequence :+: Interpolation) a])))
type Rep1 Regex Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 Regex = D1 ('MetaData "Regex" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Regex" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) ([] :.: Rec1 (EscapeSequence :+: Interpolation))))

data Redo a Source #

Constructors

Redo
Fields ann :: a extraChildren :: (Maybe (ArgumentList a))

Instances

Instances details

Functor Redo Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> Redo a -> Redo b # (<$) :: a -> Redo b -> Redo a #
Foldable Redo Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => Redo m -> m # foldMap :: Monoid m => (a -> m) -> Redo a -> m # foldMap' :: Monoid m => (a -> m) -> Redo a -> m # foldr :: (a -> b -> b) -> b -> Redo a -> b # foldr' :: (a -> b -> b) -> b -> Redo a -> b # foldl :: (b -> a -> b) -> b -> Redo a -> b # foldl' :: (b -> a -> b) -> b -> Redo a -> b # foldr1 :: (a -> a -> a) -> Redo a -> a # foldl1 :: (a -> a -> a) -> Redo a -> a # toList :: Redo a -> [a] # null :: Redo a -> Bool # length :: Redo a -> Int # elem :: Eq a => a -> Redo a -> Bool # maximum :: Ord a => Redo a -> a # minimum :: Ord a => Redo a -> a # sum :: Num a => Redo a -> a # product :: Num a => Redo a -> a #
Traversable Redo Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> Redo a -> f (Redo b) # sequenceA :: Applicative f => Redo (f a) -> f (Redo a) # mapM :: Monad m => (a -> m b) -> Redo a -> m (Redo b) # sequence :: Monad m => Redo (m a) -> m (Redo a) #
SymbolMatching Redo Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy Redo -> [Int] showFailure :: Proxy Redo -> Node -> String
Unmarshal Redo Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match Redo) matchers :: B (Int, Match Redo)
Eq a => Eq (Redo a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: Redo a -> Redo a -> Bool # (/=) :: Redo a -> Redo a -> Bool #
Ord a => Ord (Redo a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: Redo a -> Redo a -> Ordering # (<) :: Redo a -> Redo a -> Bool # (<=) :: Redo a -> Redo a -> Bool # (>) :: Redo a -> Redo a -> Bool # (>=) :: Redo a -> Redo a -> Bool # max :: Redo a -> Redo a -> Redo a # min :: Redo a -> Redo a -> Redo a #
Show a => Show (Redo a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> Redo a -> ShowS # show :: Redo a -> String # showList :: [Redo a] -> ShowS #
Generic (Redo a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (Redo a) :: Type -> Type # Methods from :: Redo a -> Rep (Redo a) x # to :: Rep (Redo a) x -> Redo a #
Generic1 Redo Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 Redo :: k -> Type # Methods from1 :: forall (a :: k). Redo a -> Rep1 Redo a # to1 :: forall (a :: k). Rep1 Redo a -> Redo a #
type Rep (Redo a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (Redo a) = D1 ('MetaData "Redo" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Redo" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe (ArgumentList a)))))
type Rep1 Redo Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 Redo = D1 ('MetaData "Redo" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Redo" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Maybe :.: Rec1 ArgumentList)))

data Rational a Source #

Constructors

Rational
Fields ann :: a extraChildren :: (Integer a)

Instances

Instances details

Functor Rational Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> Rational a -> Rational b # (<$) :: a -> Rational b -> Rational a #
Foldable Rational Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => Rational m -> m # foldMap :: Monoid m => (a -> m) -> Rational a -> m # foldMap' :: Monoid m => (a -> m) -> Rational a -> m # foldr :: (a -> b -> b) -> b -> Rational a -> b # foldr' :: (a -> b -> b) -> b -> Rational a -> b # foldl :: (b -> a -> b) -> b -> Rational a -> b # foldl' :: (b -> a -> b) -> b -> Rational a -> b # foldr1 :: (a -> a -> a) -> Rational a -> a # foldl1 :: (a -> a -> a) -> Rational a -> a # toList :: Rational a -> [a] # null :: Rational a -> Bool # length :: Rational a -> Int # elem :: Eq a => a -> Rational a -> Bool # maximum :: Ord a => Rational a -> a # minimum :: Ord a => Rational a -> a # sum :: Num a => Rational a -> a # product :: Num a => Rational a -> a #
Traversable Rational Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> Rational a -> f (Rational b) # sequenceA :: Applicative f => Rational (f a) -> f (Rational a) # mapM :: Monad m => (a -> m b) -> Rational a -> m (Rational b) # sequence :: Monad m => Rational (m a) -> m (Rational a) #
SymbolMatching Rational Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy Rational -> [Int] showFailure :: Proxy Rational -> Node -> String
Unmarshal Rational Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match Rational) matchers :: B (Int, Match Rational)
Eq a => Eq (Rational a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: Rational a -> Rational a -> Bool # (/=) :: Rational a -> Rational a -> Bool #
Ord a => Ord (Rational a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: Rational a -> Rational a -> Ordering # (<) :: Rational a -> Rational a -> Bool # (<=) :: Rational a -> Rational a -> Bool # (>) :: Rational a -> Rational a -> Bool # (>=) :: Rational a -> Rational a -> Bool # max :: Rational a -> Rational a -> Rational a # min :: Rational a -> Rational a -> Rational a #
Show a => Show (Rational a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> Rational a -> ShowS # show :: Rational a -> String # showList :: [Rational a] -> ShowS #
Generic (Rational a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (Rational a) :: Type -> Type # Methods from :: Rational a -> Rep (Rational a) x # to :: Rep (Rational a) x -> Rational a #
Generic1 Rational Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 Rational :: k -> Type # Methods from1 :: forall (a :: k). Rational a -> Rep1 Rational a # to1 :: forall (a :: k). Rep1 Rational a -> Rational a #
type Rep (Rational a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (Rational a) = D1 ('MetaData "Rational" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Rational" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Integer a))))
type Rep1 Rational Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 Rational = D1 ('MetaData "Rational" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Rational" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 Integer)))

data Range a Source #

Constructors

Range
Fields ann :: a extraChildren :: (NonEmpty (Arg a))

Instances

Instances details

Functor Range Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> Range a -> Range b # (<$) :: a -> Range b -> Range a #
Foldable Range Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => Range m -> m # foldMap :: Monoid m => (a -> m) -> Range a -> m # foldMap' :: Monoid m => (a -> m) -> Range a -> m # foldr :: (a -> b -> b) -> b -> Range a -> b # foldr' :: (a -> b -> b) -> b -> Range a -> b # foldl :: (b -> a -> b) -> b -> Range a -> b # foldl' :: (b -> a -> b) -> b -> Range a -> b # foldr1 :: (a -> a -> a) -> Range a -> a # foldl1 :: (a -> a -> a) -> Range a -> a # toList :: Range a -> [a] # null :: Range a -> Bool # length :: Range a -> Int # elem :: Eq a => a -> Range a -> Bool # maximum :: Ord a => Range a -> a # minimum :: Ord a => Range a -> a # sum :: Num a => Range a -> a # product :: Num a => Range a -> a #
Traversable Range Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> Range a -> f (Range b) # sequenceA :: Applicative f => Range (f a) -> f (Range a) # mapM :: Monad m => (a -> m b) -> Range a -> m (Range b) # sequence :: Monad m => Range (m a) -> m (Range a) #
SymbolMatching Range Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy Range -> [Int] showFailure :: Proxy Range -> Node -> String
Unmarshal Range Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match Range) matchers :: B (Int, Match Range)
Eq a => Eq (Range a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: Range a -> Range a -> Bool # (/=) :: Range a -> Range a -> Bool #
Ord a => Ord (Range a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: Range a -> Range a -> Ordering # (<) :: Range a -> Range a -> Bool # (<=) :: Range a -> Range a -> Bool # (>) :: Range a -> Range a -> Bool # (>=) :: Range a -> Range a -> Bool # max :: Range a -> Range a -> Range a # min :: Range a -> Range a -> Range a #
Show a => Show (Range a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> Range a -> ShowS # show :: Range a -> String # showList :: [Range a] -> ShowS #
Generic (Range a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (Range a) :: Type -> Type # Methods from :: Range a -> Rep (Range a) x # to :: Rep (Range a) x -> Range a #
Generic1 Range Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 Range :: k -> Type # Methods from1 :: forall (a :: k). Range a -> Rep1 Range a # to1 :: forall (a :: k). Rep1 Range a -> Range a #
type Rep (Range a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (Range a) = D1 ('MetaData "Range" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Range" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (NonEmpty (Arg a)))))
type Rep1 Range Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 Range = D1 ('MetaData "Range" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Range" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (NonEmpty :.: Rec1 Arg)))

data Program a Source #

Constructors

Program
Fields ann :: a extraChildren :: ([] ((:+:) Statement ((:+:) EmptyStatement Uninterpreted) a))

Instances

Instances details

Functor Program Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> Program a -> Program b # (<$) :: a -> Program b -> Program a #
Foldable Program Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => Program m -> m # foldMap :: Monoid m => (a -> m) -> Program a -> m # foldMap' :: Monoid m => (a -> m) -> Program a -> m # foldr :: (a -> b -> b) -> b -> Program a -> b # foldr' :: (a -> b -> b) -> b -> Program a -> b # foldl :: (b -> a -> b) -> b -> Program a -> b # foldl' :: (b -> a -> b) -> b -> Program a -> b # foldr1 :: (a -> a -> a) -> Program a -> a # foldl1 :: (a -> a -> a) -> Program a -> a # toList :: Program a -> [a] # null :: Program a -> Bool # length :: Program a -> Int # elem :: Eq a => a -> Program a -> Bool # maximum :: Ord a => Program a -> a # minimum :: Ord a => Program a -> a # sum :: Num a => Program a -> a # product :: Num a => Program a -> a #
Traversable Program Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> Program a -> f (Program b) # sequenceA :: Applicative f => Program (f a) -> f (Program a) # mapM :: Monad m => (a -> m b) -> Program a -> m (Program b) # sequence :: Monad m => Program (m a) -> m (Program a) #
SymbolMatching Program Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy Program -> [Int] showFailure :: Proxy Program -> Node -> String
Unmarshal Program Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match Program) matchers :: B (Int, Match Program)
Eq a => Eq (Program a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: Program a -> Program a -> Bool # (/=) :: Program a -> Program a -> Bool #
Ord a => Ord (Program a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: Program a -> Program a -> Ordering # (<) :: Program a -> Program a -> Bool # (<=) :: Program a -> Program a -> Bool # (>) :: Program a -> Program a -> Bool # (>=) :: Program a -> Program a -> Bool # max :: Program a -> Program a -> Program a # min :: Program a -> Program a -> Program a #
Show a => Show (Program a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> Program a -> ShowS # show :: Program a -> String # showList :: [Program a] -> ShowS #
Generic (Program a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (Program a) :: Type -> Type # Methods from :: Program a -> Rep (Program a) x # to :: Rep (Program a) x -> Program a #
Generic1 Program Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 Program :: k -> Type # Methods from1 :: forall (a :: k). Program a -> Rep1 Program a # to1 :: forall (a :: k). Rep1 Program a -> Program a #
type Rep (Program a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (Program a) = D1 ('MetaData "Program" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Program" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [(Statement :+: (EmptyStatement :+: Uninterpreted)) a])))
type Rep1 Program Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 Program = D1 ('MetaData "Program" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Program" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) ([] :.: Rec1 (Statement :+: (EmptyStatement :+: Uninterpreted)))))

data Pattern a Source #

Constructors

Pattern
Fields ann :: a extraChildren :: ((:+:) Arg SplatArgument a)

Instances

Instances details

Functor Pattern Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> Pattern a -> Pattern b # (<$) :: a -> Pattern b -> Pattern a #
Foldable Pattern Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => Pattern m -> m # foldMap :: Monoid m => (a -> m) -> Pattern a -> m # foldMap' :: Monoid m => (a -> m) -> Pattern a -> m # foldr :: (a -> b -> b) -> b -> Pattern a -> b # foldr' :: (a -> b -> b) -> b -> Pattern a -> b # foldl :: (b -> a -> b) -> b -> Pattern a -> b # foldl' :: (b -> a -> b) -> b -> Pattern a -> b # foldr1 :: (a -> a -> a) -> Pattern a -> a # foldl1 :: (a -> a -> a) -> Pattern a -> a # toList :: Pattern a -> [a] # null :: Pattern a -> Bool # length :: Pattern a -> Int # elem :: Eq a => a -> Pattern a -> Bool # maximum :: Ord a => Pattern a -> a # minimum :: Ord a => Pattern a -> a # sum :: Num a => Pattern a -> a # product :: Num a => Pattern a -> a #
Traversable Pattern Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> Pattern a -> f (Pattern b) # sequenceA :: Applicative f => Pattern (f a) -> f (Pattern a) # mapM :: Monad m => (a -> m b) -> Pattern a -> m (Pattern b) # sequence :: Monad m => Pattern (m a) -> m (Pattern a) #
SymbolMatching Pattern Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy Pattern -> [Int] showFailure :: Proxy Pattern -> Node -> String
Unmarshal Pattern Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match Pattern) matchers :: B (Int, Match Pattern)
Eq a => Eq (Pattern a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: Pattern a -> Pattern a -> Bool # (/=) :: Pattern a -> Pattern a -> Bool #
Ord a => Ord (Pattern a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: Pattern a -> Pattern a -> Ordering # (<) :: Pattern a -> Pattern a -> Bool # (<=) :: Pattern a -> Pattern a -> Bool # (>) :: Pattern a -> Pattern a -> Bool # (>=) :: Pattern a -> Pattern a -> Bool # max :: Pattern a -> Pattern a -> Pattern a # min :: Pattern a -> Pattern a -> Pattern a #
Show a => Show (Pattern a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> Pattern a -> ShowS # show :: Pattern a -> String # showList :: [Pattern a] -> ShowS #
Generic (Pattern a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (Pattern a) :: Type -> Type # Methods from :: Pattern a -> Rep (Pattern a) x # to :: Rep (Pattern a) x -> Pattern a #
Generic1 Pattern Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 Pattern :: k -> Type # Methods from1 :: forall (a :: k). Pattern a -> Rep1 Pattern a # to1 :: forall (a :: k). Rep1 Pattern a -> Pattern a #
type Rep (Pattern a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (Pattern a) = D1 ('MetaData "Pattern" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Pattern" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ((Arg :+: SplatArgument) a))))
type Rep1 Pattern Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 Pattern = D1 ('MetaData "Pattern" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Pattern" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 (Arg :+: SplatArgument))))

data ParenthesizedStatements a Source #

Constructors

ParenthesizedStatements
Fields ann :: a extraChildren :: ([] ((:+:) Statement EmptyStatement a))

Instances

Instances details

Functor ParenthesizedStatements Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> ParenthesizedStatements a -> ParenthesizedStatements b # (<$) :: a -> ParenthesizedStatements b -> ParenthesizedStatements a #
Foldable ParenthesizedStatements Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => ParenthesizedStatements m -> m # foldMap :: Monoid m => (a -> m) -> ParenthesizedStatements a -> m # foldMap' :: Monoid m => (a -> m) -> ParenthesizedStatements a -> m # foldr :: (a -> b -> b) -> b -> ParenthesizedStatements a -> b # foldr' :: (a -> b -> b) -> b -> ParenthesizedStatements a -> b # foldl :: (b -> a -> b) -> b -> ParenthesizedStatements a -> b # foldl' :: (b -> a -> b) -> b -> ParenthesizedStatements a -> b # foldr1 :: (a -> a -> a) -> ParenthesizedStatements a -> a # foldl1 :: (a -> a -> a) -> ParenthesizedStatements a -> a # toList :: ParenthesizedStatements a -> [a] # null :: ParenthesizedStatements a -> Bool # length :: ParenthesizedStatements a -> Int # elem :: Eq a => a -> ParenthesizedStatements a -> Bool # maximum :: Ord a => ParenthesizedStatements a -> a # minimum :: Ord a => ParenthesizedStatements a -> a # sum :: Num a => ParenthesizedStatements a -> a # product :: Num a => ParenthesizedStatements a -> a #
Traversable ParenthesizedStatements Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> ParenthesizedStatements a -> f (ParenthesizedStatements b) # sequenceA :: Applicative f => ParenthesizedStatements (f a) -> f (ParenthesizedStatements a) # mapM :: Monad m => (a -> m b) -> ParenthesizedStatements a -> m (ParenthesizedStatements b) # sequence :: Monad m => ParenthesizedStatements (m a) -> m (ParenthesizedStatements a) #
SymbolMatching ParenthesizedStatements Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy ParenthesizedStatements -> [Int] showFailure :: Proxy ParenthesizedStatements -> Node -> String
Unmarshal ParenthesizedStatements Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match ParenthesizedStatements) matchers :: B (Int, Match ParenthesizedStatements)
Eq a => Eq (ParenthesizedStatements a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: ParenthesizedStatements a -> ParenthesizedStatements a -> Bool # (/=) :: ParenthesizedStatements a -> ParenthesizedStatements a -> Bool #
Ord a => Ord (ParenthesizedStatements a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: ParenthesizedStatements a -> ParenthesizedStatements a -> Ordering # (<) :: ParenthesizedStatements a -> ParenthesizedStatements a -> Bool # (<=) :: ParenthesizedStatements a -> ParenthesizedStatements a -> Bool # (>) :: ParenthesizedStatements a -> ParenthesizedStatements a -> Bool # (>=) :: ParenthesizedStatements a -> ParenthesizedStatements a -> Bool # max :: ParenthesizedStatements a -> ParenthesizedStatements a -> ParenthesizedStatements a # min :: ParenthesizedStatements a -> ParenthesizedStatements a -> ParenthesizedStatements a #
Show a => Show (ParenthesizedStatements a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> ParenthesizedStatements a -> ShowS # show :: ParenthesizedStatements a -> String # showList :: [ParenthesizedStatements a] -> ShowS #
Generic (ParenthesizedStatements a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (ParenthesizedStatements a) :: Type -> Type # Methods from :: ParenthesizedStatements a -> Rep (ParenthesizedStatements a) x # to :: Rep (ParenthesizedStatements a) x -> ParenthesizedStatements a #
Generic1 ParenthesizedStatements Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 ParenthesizedStatements :: k -> Type # Methods from1 :: forall (a :: k). ParenthesizedStatements a -> Rep1 ParenthesizedStatements a # to1 :: forall (a :: k). Rep1 ParenthesizedStatements a -> ParenthesizedStatements a #
type Rep (ParenthesizedStatements a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (ParenthesizedStatements a) = D1 ('MetaData "ParenthesizedStatements" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "ParenthesizedStatements" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [(Statement :+: EmptyStatement) a])))
type Rep1 ParenthesizedStatements Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 ParenthesizedStatements = D1 ('MetaData "ParenthesizedStatements" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "ParenthesizedStatements" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) ([] :.: Rec1 (Statement :+: EmptyStatement))))

data Pair a Source #

Constructors

Pair
Fields ann :: a value :: (Arg a) key :: ((:+:) Arg ((:+:) String Symbol) a)

Instances

Instances details

Functor Pair Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> Pair a -> Pair b # (<$) :: a -> Pair b -> Pair a #
Foldable Pair Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => Pair m -> m # foldMap :: Monoid m => (a -> m) -> Pair a -> 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 Source #
Instance details Defined in TreeSitter.Ruby.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 Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy Pair -> [Int] showFailure :: Proxy Pair -> Node -> String
Unmarshal Pair Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match Pair) matchers :: B (Int, Match Pair)
Eq a => Eq (Pair a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: Pair a -> Pair a -> Bool # (/=) :: Pair a -> Pair a -> Bool #
Ord a => Ord (Pair a) Source #
Instance details Defined in TreeSitter.Ruby.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) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> Pair a -> ShowS # show :: Pair a -> String # showList :: [Pair a] -> ShowS #
Generic (Pair a) Source #
Instance details Defined in TreeSitter.Ruby.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 Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 Pair :: k -> Type # Methods from1 :: forall (a :: k). Pair a -> Rep1 Pair a # to1 :: forall (a :: k). Rep1 Pair a -> Pair a #
type Rep (Pair a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (Pair a) = D1 ('MetaData "Pair" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.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 (Arg a)) :: S1 ('MetaSel ('Just "key") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ((Arg :+: (String :+: Symbol)) a)))))
type Rep1 Pair Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 Pair = D1 ('MetaData "Pair" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Pair" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :: (S1 ('MetaSel ('Just "value") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 Arg) :: S1 ('MetaSel ('Just "key") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 (Arg :+: (String :+: Symbol))))))

data OptionalParameter a Source #

Constructors

OptionalParameter
Fields ann :: a value :: (Arg a) name :: (Identifier a)

Instances

Instances details

Functor OptionalParameter Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> OptionalParameter a -> OptionalParameter b # (<$) :: a -> OptionalParameter b -> OptionalParameter a #
Foldable OptionalParameter Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => OptionalParameter m -> m # foldMap :: Monoid m => (a -> m) -> OptionalParameter a -> m # foldMap' :: Monoid m => (a -> m) -> OptionalParameter a -> m # foldr :: (a -> b -> b) -> b -> OptionalParameter a -> b # foldr' :: (a -> b -> b) -> b -> OptionalParameter a -> b # foldl :: (b -> a -> b) -> b -> OptionalParameter a -> b # foldl' :: (b -> a -> b) -> b -> OptionalParameter a -> b # foldr1 :: (a -> a -> a) -> OptionalParameter a -> a # foldl1 :: (a -> a -> a) -> OptionalParameter a -> a # toList :: OptionalParameter a -> [a] # null :: OptionalParameter a -> Bool # length :: OptionalParameter a -> Int # elem :: Eq a => a -> OptionalParameter a -> Bool # maximum :: Ord a => OptionalParameter a -> a # minimum :: Ord a => OptionalParameter a -> a # sum :: Num a => OptionalParameter a -> a # product :: Num a => OptionalParameter a -> a #
Traversable OptionalParameter Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> OptionalParameter a -> f (OptionalParameter b) # sequenceA :: Applicative f => OptionalParameter (f a) -> f (OptionalParameter a) # mapM :: Monad m => (a -> m b) -> OptionalParameter a -> m (OptionalParameter b) # sequence :: Monad m => OptionalParameter (m a) -> m (OptionalParameter a) #
SymbolMatching OptionalParameter Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy OptionalParameter -> [Int] showFailure :: Proxy OptionalParameter -> Node -> String
Unmarshal OptionalParameter Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match OptionalParameter) matchers :: B (Int, Match OptionalParameter)
Eq a => Eq (OptionalParameter a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: OptionalParameter a -> OptionalParameter a -> Bool # (/=) :: OptionalParameter a -> OptionalParameter a -> Bool #
Ord a => Ord (OptionalParameter a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: OptionalParameter a -> OptionalParameter a -> Ordering # (<) :: OptionalParameter a -> OptionalParameter a -> Bool # (<=) :: OptionalParameter a -> OptionalParameter a -> Bool # (>) :: OptionalParameter a -> OptionalParameter a -> Bool # (>=) :: OptionalParameter a -> OptionalParameter a -> Bool # max :: OptionalParameter a -> OptionalParameter a -> OptionalParameter a # min :: OptionalParameter a -> OptionalParameter a -> OptionalParameter a #
Show a => Show (OptionalParameter a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> OptionalParameter a -> ShowS # show :: OptionalParameter a -> String # showList :: [OptionalParameter a] -> ShowS #
Generic (OptionalParameter a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (OptionalParameter a) :: Type -> Type # Methods from :: OptionalParameter a -> Rep (OptionalParameter a) x # to :: Rep (OptionalParameter a) x -> OptionalParameter a #
Generic1 OptionalParameter Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 OptionalParameter :: k -> Type # Methods from1 :: forall (a :: k). OptionalParameter a -> Rep1 OptionalParameter a # to1 :: forall (a :: k). Rep1 OptionalParameter a -> OptionalParameter a #
type Rep (OptionalParameter a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (OptionalParameter a) = D1 ('MetaData "OptionalParameter" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "OptionalParameter" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :: (S1 ('MetaSel ('Just "value") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Arg a)) :: S1 ('MetaSel ('Just "name") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Identifier a)))))
type Rep1 OptionalParameter Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 OptionalParameter = D1 ('MetaData "OptionalParameter" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "OptionalParameter" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :: (S1 ('MetaSel ('Just "value") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 Arg) :: S1 ('MetaSel ('Just "name") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 Identifier))))

data OperatorAssignment a Source #

Constructors

OperatorAssignment
Fields ann :: a left :: (Lhs a) right :: ((:+:) ((:+:) Arg ((:+:) Break MethodCall)) ((:+:) Next ((:+:) Return Yield)) a)

Instances

Instances details

Functor OperatorAssignment Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> OperatorAssignment a -> OperatorAssignment b # (<$) :: a -> OperatorAssignment b -> OperatorAssignment a #
Foldable OperatorAssignment Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => OperatorAssignment m -> m # foldMap :: Monoid m => (a -> m) -> OperatorAssignment a -> m # foldMap' :: Monoid m => (a -> m) -> OperatorAssignment a -> m # foldr :: (a -> b -> b) -> b -> OperatorAssignment a -> b # foldr' :: (a -> b -> b) -> b -> OperatorAssignment a -> b # foldl :: (b -> a -> b) -> b -> OperatorAssignment a -> b # foldl' :: (b -> a -> b) -> b -> OperatorAssignment a -> b # foldr1 :: (a -> a -> a) -> OperatorAssignment a -> a # foldl1 :: (a -> a -> a) -> OperatorAssignment a -> a # toList :: OperatorAssignment a -> [a] # null :: OperatorAssignment a -> Bool # length :: OperatorAssignment a -> Int # elem :: Eq a => a -> OperatorAssignment a -> Bool # maximum :: Ord a => OperatorAssignment a -> a # minimum :: Ord a => OperatorAssignment a -> a # sum :: Num a => OperatorAssignment a -> a # product :: Num a => OperatorAssignment a -> a #
Traversable OperatorAssignment Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> OperatorAssignment a -> f (OperatorAssignment b) # sequenceA :: Applicative f => OperatorAssignment (f a) -> f (OperatorAssignment a) # mapM :: Monad m => (a -> m b) -> OperatorAssignment a -> m (OperatorAssignment b) # sequence :: Monad m => OperatorAssignment (m a) -> m (OperatorAssignment a) #
SymbolMatching OperatorAssignment Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy OperatorAssignment -> [Int] showFailure :: Proxy OperatorAssignment -> Node -> String
Unmarshal OperatorAssignment Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match OperatorAssignment) matchers :: B (Int, Match OperatorAssignment)
Eq a => Eq (OperatorAssignment a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: OperatorAssignment a -> OperatorAssignment a -> Bool # (/=) :: OperatorAssignment a -> OperatorAssignment a -> Bool #
Ord a => Ord (OperatorAssignment a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: OperatorAssignment a -> OperatorAssignment a -> Ordering # (<) :: OperatorAssignment a -> OperatorAssignment a -> Bool # (<=) :: OperatorAssignment a -> OperatorAssignment a -> Bool # (>) :: OperatorAssignment a -> OperatorAssignment a -> Bool # (>=) :: OperatorAssignment a -> OperatorAssignment a -> Bool # max :: OperatorAssignment a -> OperatorAssignment a -> OperatorAssignment a # min :: OperatorAssignment a -> OperatorAssignment a -> OperatorAssignment a #
Show a => Show (OperatorAssignment a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> OperatorAssignment a -> ShowS # show :: OperatorAssignment a -> String # showList :: [OperatorAssignment a] -> ShowS #
Generic (OperatorAssignment a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (OperatorAssignment a) :: Type -> Type # Methods from :: OperatorAssignment a -> Rep (OperatorAssignment a) x # to :: Rep (OperatorAssignment a) x -> OperatorAssignment a #
Generic1 OperatorAssignment Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 OperatorAssignment :: k -> Type # Methods from1 :: forall (a :: k). OperatorAssignment a -> Rep1 OperatorAssignment a # to1 :: forall (a :: k). Rep1 OperatorAssignment a -> OperatorAssignment a #
type Rep (OperatorAssignment a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (OperatorAssignment a) = D1 ('MetaData "OperatorAssignment" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "OperatorAssignment" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :: (S1 ('MetaSel ('Just "left") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Lhs a)) :: S1 ('MetaSel ('Just "right") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (((Arg :+: (Break :+: MethodCall)) :+: (Next :+: (Return :+: Yield))) a)))))
type Rep1 OperatorAssignment Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 OperatorAssignment = D1 ('MetaData "OperatorAssignment" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "OperatorAssignment" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :: (S1 ('MetaSel ('Just "left") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 Lhs) :: S1 ('MetaSel ('Just "right") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 ((Arg :+: (Break :+: MethodCall)) :+: (Next :+: (Return :+: Yield)))))))

data Operator a Source #

Constructors

Operator
Fields ann :: a text :: Text

Instances

Instances details

Functor Operator Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> Operator a -> Operator b # (<$) :: a -> Operator b -> Operator a #
Foldable Operator Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => Operator m -> m # foldMap :: Monoid m => (a -> m) -> Operator a -> m # foldMap' :: Monoid m => (a -> m) -> Operator a -> m # foldr :: (a -> b -> b) -> b -> Operator a -> b # foldr' :: (a -> b -> b) -> b -> Operator a -> b # foldl :: (b -> a -> b) -> b -> Operator a -> b # foldl' :: (b -> a -> b) -> b -> Operator a -> b # foldr1 :: (a -> a -> a) -> Operator a -> a # foldl1 :: (a -> a -> a) -> Operator a -> a # toList :: Operator a -> [a] # null :: Operator a -> Bool # length :: Operator a -> Int # elem :: Eq a => a -> Operator a -> Bool # maximum :: Ord a => Operator a -> a # minimum :: Ord a => Operator a -> a # sum :: Num a => Operator a -> a # product :: Num a => Operator a -> a #
Traversable Operator Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> Operator a -> f (Operator b) # sequenceA :: Applicative f => Operator (f a) -> f (Operator a) # mapM :: Monad m => (a -> m b) -> Operator a -> m (Operator b) # sequence :: Monad m => Operator (m a) -> m (Operator a) #
SymbolMatching Operator Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy Operator -> [Int] showFailure :: Proxy Operator -> Node -> String
Unmarshal Operator Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match Operator) matchers :: B (Int, Match Operator)
Eq a => Eq (Operator a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: Operator a -> Operator a -> Bool # (/=) :: Operator a -> Operator a -> Bool #
Ord a => Ord (Operator a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: Operator a -> Operator a -> Ordering # (<) :: Operator a -> Operator a -> Bool # (<=) :: Operator a -> Operator a -> Bool # (>) :: Operator a -> Operator a -> Bool # (>=) :: Operator a -> Operator a -> Bool # max :: Operator a -> Operator a -> Operator a # min :: Operator a -> Operator a -> Operator a #
Show a => Show (Operator a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> Operator a -> ShowS # show :: Operator a -> String # showList :: [Operator a] -> ShowS #
Generic (Operator a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (Operator a) :: Type -> Type # Methods from :: Operator a -> Rep (Operator a) x # to :: Rep (Operator a) x -> Operator a #
Generic1 Operator Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 Operator :: k -> Type # Methods from1 :: forall (a :: k). Operator a -> Rep1 Operator a # to1 :: forall (a :: k). Rep1 Operator a -> Operator a #
type Rep (Operator a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (Operator a) = D1 ('MetaData "Operator" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Operator" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "text") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Text)))
type Rep1 Operator Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 Operator = D1 ('MetaData "Operator" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Operator" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Just "text") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Text)))

data Next a Source #

Constructors

Next
Fields ann :: a extraChildren :: (Maybe (ArgumentList a))

Instances

Instances details

Functor Next Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> Next a -> Next b # (<$) :: a -> Next b -> Next a #
Foldable Next Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => Next m -> m # foldMap :: Monoid m => (a -> m) -> Next a -> m # foldMap' :: Monoid m => (a -> m) -> Next a -> m # foldr :: (a -> b -> b) -> b -> Next a -> b # foldr' :: (a -> b -> b) -> b -> Next a -> b # foldl :: (b -> a -> b) -> b -> Next a -> b # foldl' :: (b -> a -> b) -> b -> Next a -> b # foldr1 :: (a -> a -> a) -> Next a -> a # foldl1 :: (a -> a -> a) -> Next a -> a # toList :: Next a -> [a] # null :: Next a -> Bool # length :: Next a -> Int # elem :: Eq a => a -> Next a -> Bool # maximum :: Ord a => Next a -> a # minimum :: Ord a => Next a -> a # sum :: Num a => Next a -> a # product :: Num a => Next a -> a #
Traversable Next Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> Next a -> f (Next b) # sequenceA :: Applicative f => Next (f a) -> f (Next a) # mapM :: Monad m => (a -> m b) -> Next a -> m (Next b) # sequence :: Monad m => Next (m a) -> m (Next a) #
SymbolMatching Next Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy Next -> [Int] showFailure :: Proxy Next -> Node -> String
Unmarshal Next Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match Next) matchers :: B (Int, Match Next)
Eq a => Eq (Next a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: Next a -> Next a -> Bool # (/=) :: Next a -> Next a -> Bool #
Ord a => Ord (Next a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: Next a -> Next a -> Ordering # (<) :: Next a -> Next a -> Bool # (<=) :: Next a -> Next a -> Bool # (>) :: Next a -> Next a -> Bool # (>=) :: Next a -> Next a -> Bool # max :: Next a -> Next a -> Next a # min :: Next a -> Next a -> Next a #
Show a => Show (Next a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> Next a -> ShowS # show :: Next a -> String # showList :: [Next a] -> ShowS #
Generic (Next a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (Next a) :: Type -> Type # Methods from :: Next a -> Rep (Next a) x # to :: Rep (Next a) x -> Next a #
Generic1 Next Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 Next :: k -> Type # Methods from1 :: forall (a :: k). Next a -> Rep1 Next a # to1 :: forall (a :: k). Rep1 Next a -> Next a #
type Rep (Next a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (Next a) = D1 ('MetaData "Next" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Next" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe (ArgumentList a)))))
type Rep1 Next Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 Next = D1 ('MetaData "Next" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Next" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Maybe :.: Rec1 ArgumentList)))

data Module a Source #

Constructors

Module
Fields ann :: a name :: ((:+:) Constant ScopeResolution a) extraChildren :: ([] ((:+:) ((:+:) Statement Else) ((:+:) EmptyStatement ((:+:) Ensure Rescue)) a))

Instances

Instances details

Functor Module Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> Module a -> Module b # (<$) :: a -> Module b -> Module a #
Foldable Module Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => Module m -> m # foldMap :: Monoid m => (a -> m) -> Module a -> m # foldMap' :: Monoid m => (a -> m) -> Module a -> m # foldr :: (a -> b -> b) -> b -> Module a -> b # foldr' :: (a -> b -> b) -> b -> Module a -> b # foldl :: (b -> a -> b) -> b -> Module a -> b # foldl' :: (b -> a -> b) -> b -> Module a -> b # foldr1 :: (a -> a -> a) -> Module a -> a # foldl1 :: (a -> a -> a) -> Module a -> a # toList :: Module a -> [a] # null :: Module a -> Bool # length :: Module a -> Int # elem :: Eq a => a -> Module a -> Bool # maximum :: Ord a => Module a -> a # minimum :: Ord a => Module a -> a # sum :: Num a => Module a -> a # product :: Num a => Module a -> a #
Traversable Module Source #
Instance details Defined in TreeSitter.Ruby.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 Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy Module -> [Int] showFailure :: Proxy Module -> Node -> String
Unmarshal Module Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match Module) matchers :: B (Int, Match Module)
Eq a => Eq (Module a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: Module a -> Module a -> Bool # (/=) :: Module a -> Module a -> Bool #
Ord a => Ord (Module a) Source #
Instance details Defined in TreeSitter.Ruby.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) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> Module a -> ShowS # show :: Module a -> String # showList :: [Module a] -> ShowS #
Generic (Module a) Source #
Instance details Defined in TreeSitter.Ruby.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 Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 Module :: k -> Type # Methods from1 :: forall (a :: k). Module a -> Rep1 Module a # to1 :: forall (a :: k). Rep1 Module a -> Module a #
type Rep (Module a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (Module a) = D1 ('MetaData "Module" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Module" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :: (S1 ('MetaSel ('Just "name") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ((Constant :+: ScopeResolution) a)) :: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [((Statement :+: Else) :+: (EmptyStatement :+: (Ensure :+: Rescue))) a]))))
type Rep1 Module Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 Module = D1 ('MetaData "Module" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Module" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :: (S1 ('MetaSel ('Just "name") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 (Constant :+: ScopeResolution)) :: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) ([] :.: Rec1 ((Statement :+: Else) :+: (EmptyStatement :+: (Ensure :+: Rescue)))))))

data MethodParameters a Source #

Constructors

MethodParameters
Fields ann :: a extraChildren :: ([] ((:+:) ((:+:) BlockParameter ((:+:) DestructuredParameter HashSplatParameter)) ((:+:) ((:+:) Identifier KeywordParameter) ((:+:) OptionalParameter SplatParameter)) a))

Instances

Instances details

Functor MethodParameters Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> MethodParameters a -> MethodParameters b # (<$) :: a -> MethodParameters b -> MethodParameters a #
Foldable MethodParameters Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => MethodParameters m -> m # foldMap :: Monoid m => (a -> m) -> MethodParameters a -> m # foldMap' :: Monoid m => (a -> m) -> MethodParameters a -> m # foldr :: (a -> b -> b) -> b -> MethodParameters a -> b # foldr' :: (a -> b -> b) -> b -> MethodParameters a -> b # foldl :: (b -> a -> b) -> b -> MethodParameters a -> b # foldl' :: (b -> a -> b) -> b -> MethodParameters a -> b # foldr1 :: (a -> a -> a) -> MethodParameters a -> a # foldl1 :: (a -> a -> a) -> MethodParameters a -> a # toList :: MethodParameters a -> [a] # null :: MethodParameters a -> Bool # length :: MethodParameters a -> Int # elem :: Eq a => a -> MethodParameters a -> Bool # maximum :: Ord a => MethodParameters a -> a # minimum :: Ord a => MethodParameters a -> a # sum :: Num a => MethodParameters a -> a # product :: Num a => MethodParameters a -> a #
Traversable MethodParameters Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> MethodParameters a -> f (MethodParameters b) # sequenceA :: Applicative f => MethodParameters (f a) -> f (MethodParameters a) # mapM :: Monad m => (a -> m b) -> MethodParameters a -> m (MethodParameters b) # sequence :: Monad m => MethodParameters (m a) -> m (MethodParameters a) #
SymbolMatching MethodParameters Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy MethodParameters -> [Int] showFailure :: Proxy MethodParameters -> Node -> String
Unmarshal MethodParameters Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match MethodParameters) matchers :: B (Int, Match MethodParameters)
Eq a => Eq (MethodParameters a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: MethodParameters a -> MethodParameters a -> Bool # (/=) :: MethodParameters a -> MethodParameters a -> Bool #
Ord a => Ord (MethodParameters a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: MethodParameters a -> MethodParameters a -> Ordering # (<) :: MethodParameters a -> MethodParameters a -> Bool # (<=) :: MethodParameters a -> MethodParameters a -> Bool # (>) :: MethodParameters a -> MethodParameters a -> Bool # (>=) :: MethodParameters a -> MethodParameters a -> Bool # max :: MethodParameters a -> MethodParameters a -> MethodParameters a # min :: MethodParameters a -> MethodParameters a -> MethodParameters a #
Show a => Show (MethodParameters a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> MethodParameters a -> ShowS # show :: MethodParameters a -> String # showList :: [MethodParameters a] -> ShowS #
Generic (MethodParameters a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (MethodParameters a) :: Type -> Type # Methods from :: MethodParameters a -> Rep (MethodParameters a) x # to :: Rep (MethodParameters a) x -> MethodParameters a #
Generic1 MethodParameters Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 MethodParameters :: k -> Type # Methods from1 :: forall (a :: k). MethodParameters a -> Rep1 MethodParameters a # to1 :: forall (a :: k). Rep1 MethodParameters a -> MethodParameters a #
type Rep (MethodParameters a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (MethodParameters a) = D1 ('MetaData "MethodParameters" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "MethodParameters" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [((BlockParameter :+: (DestructuredParameter :+: HashSplatParameter)) :+: ((Identifier :+: KeywordParameter) :+: (OptionalParameter :+: SplatParameter))) a])))
type Rep1 MethodParameters Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 MethodParameters = D1 ('MetaData "MethodParameters" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "MethodParameters" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) ([] :.: Rec1 ((BlockParameter :+: (DestructuredParameter :+: HashSplatParameter)) :+: ((Identifier :+: KeywordParameter) :+: (OptionalParameter :+: SplatParameter))))))

data MethodCall a Source #

Constructors

MethodCall
Fields ann :: a arguments :: (Maybe (ArgumentList a)) block :: (Maybe ((:+:) Block DoBlock a)) method :: ((:+:) Variable ((:+:) Call ScopeResolution) a)

Instances

Instances details

Functor MethodCall Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> MethodCall a -> MethodCall b # (<$) :: a -> MethodCall b -> MethodCall a #
Foldable MethodCall Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => MethodCall m -> m # foldMap :: Monoid m => (a -> m) -> MethodCall a -> m # foldMap' :: Monoid m => (a -> m) -> MethodCall a -> m # foldr :: (a -> b -> b) -> b -> MethodCall a -> b # foldr' :: (a -> b -> b) -> b -> MethodCall a -> b # foldl :: (b -> a -> b) -> b -> MethodCall a -> b # foldl' :: (b -> a -> b) -> b -> MethodCall a -> b # foldr1 :: (a -> a -> a) -> MethodCall a -> a # foldl1 :: (a -> a -> a) -> MethodCall a -> a # toList :: MethodCall a -> [a] # null :: MethodCall a -> Bool # length :: MethodCall a -> Int # elem :: Eq a => a -> MethodCall a -> Bool # maximum :: Ord a => MethodCall a -> a # minimum :: Ord a => MethodCall a -> a # sum :: Num a => MethodCall a -> a # product :: Num a => MethodCall a -> a #
Traversable MethodCall Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> MethodCall a -> f (MethodCall b) # sequenceA :: Applicative f => MethodCall (f a) -> f (MethodCall a) # mapM :: Monad m => (a -> m b) -> MethodCall a -> m (MethodCall b) # sequence :: Monad m => MethodCall (m a) -> m (MethodCall a) #
SymbolMatching MethodCall Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy MethodCall -> [Int] showFailure :: Proxy MethodCall -> Node -> String
Unmarshal MethodCall Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match MethodCall) matchers :: B (Int, Match MethodCall)
Eq a => Eq (MethodCall a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: MethodCall a -> MethodCall a -> Bool # (/=) :: MethodCall a -> MethodCall a -> Bool #
Ord a => Ord (MethodCall a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: MethodCall a -> MethodCall a -> Ordering # (<) :: MethodCall a -> MethodCall a -> Bool # (<=) :: MethodCall a -> MethodCall a -> Bool # (>) :: MethodCall a -> MethodCall a -> Bool # (>=) :: MethodCall a -> MethodCall a -> Bool # max :: MethodCall a -> MethodCall a -> MethodCall a # min :: MethodCall a -> MethodCall a -> MethodCall a #
Show a => Show (MethodCall a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> MethodCall a -> ShowS # show :: MethodCall a -> String # showList :: [MethodCall a] -> ShowS #
Generic (MethodCall a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (MethodCall a) :: Type -> Type # Methods from :: MethodCall a -> Rep (MethodCall a) x # to :: Rep (MethodCall a) x -> MethodCall a #
Generic1 MethodCall Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 MethodCall :: k -> Type # Methods from1 :: forall (a :: k). MethodCall a -> Rep1 MethodCall a # to1 :: forall (a :: k). Rep1 MethodCall a -> MethodCall a #
type Rep (MethodCall a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (MethodCall a) = D1 ('MetaData "MethodCall" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "MethodCall" '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 "block") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe ((Block :+: DoBlock) a))) :*: S1 ('MetaSel ('Just "method") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ((Variable :+: (Call :+: ScopeResolution)) a)))))
type Rep1 MethodCall Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 MethodCall = D1 ('MetaData "MethodCall" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "MethodCall" 'PrefixI 'True) ((S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :: S1 ('MetaSel ('Just "arguments") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Maybe :.: Rec1 ArgumentList)) :: (S1 ('MetaSel ('Just "block") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Maybe :.: Rec1 (Block :+: DoBlock)) :*: S1 ('MetaSel ('Just "method") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 (Variable :+: (Call :+: ScopeResolution))))))

data Method a Source #

Constructors

Method
Fields ann :: a name :: (MethodName a) parameters :: (Maybe (MethodParameters a)) extraChildren :: ([] ((:+:) ((:+:) Statement Else) ((:+:) EmptyStatement ((:+:) Ensure Rescue)) a))

Instances

Instances details

Functor Method Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> Method a -> Method b # (<$) :: a -> Method b -> Method a #
Foldable Method Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => Method m -> m # foldMap :: Monoid m => (a -> m) -> Method a -> m # foldMap' :: Monoid m => (a -> m) -> Method a -> m # foldr :: (a -> b -> b) -> b -> Method a -> b # foldr' :: (a -> b -> b) -> b -> Method a -> b # foldl :: (b -> a -> b) -> b -> Method a -> b # foldl' :: (b -> a -> b) -> b -> Method a -> b # foldr1 :: (a -> a -> a) -> Method a -> a # foldl1 :: (a -> a -> a) -> Method a -> a # toList :: Method a -> [a] # null :: Method a -> Bool # length :: Method a -> Int # elem :: Eq a => a -> Method a -> Bool # maximum :: Ord a => Method a -> a # minimum :: Ord a => Method a -> a # sum :: Num a => Method a -> a # product :: Num a => Method a -> a #
Traversable Method Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> Method a -> f (Method b) # sequenceA :: Applicative f => Method (f a) -> f (Method a) # mapM :: Monad m => (a -> m b) -> Method a -> m (Method b) # sequence :: Monad m => Method (m a) -> m (Method a) #
SymbolMatching Method Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy Method -> [Int] showFailure :: Proxy Method -> Node -> String
Unmarshal Method Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match Method) matchers :: B (Int, Match Method)
Eq a => Eq (Method a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: Method a -> Method a -> Bool # (/=) :: Method a -> Method a -> Bool #
Ord a => Ord (Method a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: Method a -> Method a -> Ordering # (<) :: Method a -> Method a -> Bool # (<=) :: Method a -> Method a -> Bool # (>) :: Method a -> Method a -> Bool # (>=) :: Method a -> Method a -> Bool # max :: Method a -> Method a -> Method a # min :: Method a -> Method a -> Method a #
Show a => Show (Method a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> Method a -> ShowS # show :: Method a -> String # showList :: [Method a] -> ShowS #
Generic (Method a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (Method a) :: Type -> Type # Methods from :: Method a -> Rep (Method a) x # to :: Rep (Method a) x -> Method a #
Generic1 Method Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 Method :: k -> Type # Methods from1 :: forall (a :: k). Method a -> Rep1 Method a # to1 :: forall (a :: k). Rep1 Method a -> Method a #
type Rep (Method a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (Method a) = D1 ('MetaData "Method" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Method" 'PrefixI 'True) ((S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :: S1 ('MetaSel ('Just "name") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (MethodName a))) :: (S1 ('MetaSel ('Just "parameters") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe (MethodParameters a))) :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [((Statement :+: Else) :+: (EmptyStatement :+: (Ensure :+: Rescue))) a]))))
type Rep1 Method Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 Method = D1 ('MetaData "Method" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Method" 'PrefixI 'True) ((S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :: S1 ('MetaSel ('Just "name") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 MethodName)) :: (S1 ('MetaSel ('Just "parameters") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Maybe :.: Rec1 MethodParameters) :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) ([] :.: Rec1 ((Statement :+: Else) :+: (EmptyStatement :+: (Ensure :+: Rescue)))))))

data LeftAssignmentList a Source #

Constructors

LeftAssignmentList
Fields ann :: a extraChildren :: (NonEmpty ((:+:) Lhs ((:+:) DestructuredLeftAssignment RestAssignment) a))

Instances

Instances details

Functor LeftAssignmentList Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> LeftAssignmentList a -> LeftAssignmentList b # (<$) :: a -> LeftAssignmentList b -> LeftAssignmentList a #
Foldable LeftAssignmentList Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => LeftAssignmentList m -> m # foldMap :: Monoid m => (a -> m) -> LeftAssignmentList a -> m # foldMap' :: Monoid m => (a -> m) -> LeftAssignmentList a -> m # foldr :: (a -> b -> b) -> b -> LeftAssignmentList a -> b # foldr' :: (a -> b -> b) -> b -> LeftAssignmentList a -> b # foldl :: (b -> a -> b) -> b -> LeftAssignmentList a -> b # foldl' :: (b -> a -> b) -> b -> LeftAssignmentList a -> b # foldr1 :: (a -> a -> a) -> LeftAssignmentList a -> a # foldl1 :: (a -> a -> a) -> LeftAssignmentList a -> a # toList :: LeftAssignmentList a -> [a] # null :: LeftAssignmentList a -> Bool # length :: LeftAssignmentList a -> Int # elem :: Eq a => a -> LeftAssignmentList a -> Bool # maximum :: Ord a => LeftAssignmentList a -> a # minimum :: Ord a => LeftAssignmentList a -> a # sum :: Num a => LeftAssignmentList a -> a # product :: Num a => LeftAssignmentList a -> a #
Traversable LeftAssignmentList Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> LeftAssignmentList a -> f (LeftAssignmentList b) # sequenceA :: Applicative f => LeftAssignmentList (f a) -> f (LeftAssignmentList a) # mapM :: Monad m => (a -> m b) -> LeftAssignmentList a -> m (LeftAssignmentList b) # sequence :: Monad m => LeftAssignmentList (m a) -> m (LeftAssignmentList a) #
SymbolMatching LeftAssignmentList Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy LeftAssignmentList -> [Int] showFailure :: Proxy LeftAssignmentList -> Node -> String
Unmarshal LeftAssignmentList Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match LeftAssignmentList) matchers :: B (Int, Match LeftAssignmentList)
Eq a => Eq (LeftAssignmentList a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: LeftAssignmentList a -> LeftAssignmentList a -> Bool # (/=) :: LeftAssignmentList a -> LeftAssignmentList a -> Bool #
Ord a => Ord (LeftAssignmentList a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: LeftAssignmentList a -> LeftAssignmentList a -> Ordering # (<) :: LeftAssignmentList a -> LeftAssignmentList a -> Bool # (<=) :: LeftAssignmentList a -> LeftAssignmentList a -> Bool # (>) :: LeftAssignmentList a -> LeftAssignmentList a -> Bool # (>=) :: LeftAssignmentList a -> LeftAssignmentList a -> Bool # max :: LeftAssignmentList a -> LeftAssignmentList a -> LeftAssignmentList a # min :: LeftAssignmentList a -> LeftAssignmentList a -> LeftAssignmentList a #
Show a => Show (LeftAssignmentList a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> LeftAssignmentList a -> ShowS # show :: LeftAssignmentList a -> String # showList :: [LeftAssignmentList a] -> ShowS #
Generic (LeftAssignmentList a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (LeftAssignmentList a) :: Type -> Type # Methods from :: LeftAssignmentList a -> Rep (LeftAssignmentList a) x # to :: Rep (LeftAssignmentList a) x -> LeftAssignmentList a #
Generic1 LeftAssignmentList Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 LeftAssignmentList :: k -> Type # Methods from1 :: forall (a :: k). LeftAssignmentList a -> Rep1 LeftAssignmentList a # to1 :: forall (a :: k). Rep1 LeftAssignmentList a -> LeftAssignmentList a #
type Rep (LeftAssignmentList a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (LeftAssignmentList a) = D1 ('MetaData "LeftAssignmentList" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "LeftAssignmentList" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (NonEmpty ((Lhs :+: (DestructuredLeftAssignment :+: RestAssignment)) a)))))
type Rep1 LeftAssignmentList Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 LeftAssignmentList = D1 ('MetaData "LeftAssignmentList" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "LeftAssignmentList" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (NonEmpty :.: Rec1 (Lhs :+: (DestructuredLeftAssignment :+: RestAssignment)))))

data LambdaParameters a Source #

Constructors

LambdaParameters
Fields ann :: a extraChildren :: ([] ((:+:) ((:+:) BlockParameter ((:+:) DestructuredParameter HashSplatParameter)) ((:+:) ((:+:) Identifier KeywordParameter) ((:+:) OptionalParameter SplatParameter)) a))

Instances

Instances details

Functor LambdaParameters Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> LambdaParameters a -> LambdaParameters b # (<$) :: a -> LambdaParameters b -> LambdaParameters a #
Foldable LambdaParameters Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => LambdaParameters m -> m # foldMap :: Monoid m => (a -> m) -> LambdaParameters a -> 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 Source #
Instance details Defined in TreeSitter.Ruby.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 Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy LambdaParameters -> [Int] showFailure :: Proxy LambdaParameters -> Node -> String
Unmarshal LambdaParameters Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match LambdaParameters) matchers :: B (Int, Match LambdaParameters)
Eq a => Eq (LambdaParameters a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: LambdaParameters a -> LambdaParameters a -> Bool # (/=) :: LambdaParameters a -> LambdaParameters a -> Bool #
Ord a => Ord (LambdaParameters a) Source #
Instance details Defined in TreeSitter.Ruby.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) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> LambdaParameters a -> ShowS # show :: LambdaParameters a -> String # showList :: [LambdaParameters a] -> ShowS #
Generic (LambdaParameters a) Source #
Instance details Defined in TreeSitter.Ruby.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 Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 LambdaParameters :: k -> Type # Methods from1 :: forall (a :: k). LambdaParameters a -> Rep1 LambdaParameters a # to1 :: forall (a :: k). Rep1 LambdaParameters a -> LambdaParameters a #
type Rep (LambdaParameters a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (LambdaParameters a) = D1 ('MetaData "LambdaParameters" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.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 [((BlockParameter :+: (DestructuredParameter :+: HashSplatParameter)) :+: ((Identifier :+: KeywordParameter) :+: (OptionalParameter :+: SplatParameter))) a])))
type Rep1 LambdaParameters Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 LambdaParameters = D1 ('MetaData "LambdaParameters" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "LambdaParameters" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) ([] :.: Rec1 ((BlockParameter :+: (DestructuredParameter :+: HashSplatParameter)) :+: ((Identifier :+: KeywordParameter) :+: (OptionalParameter :+: SplatParameter))))))

data Lambda a Source #

Constructors

Lambda
Fields ann :: a body :: ((:+:) Block DoBlock a) parameters :: (Maybe (LambdaParameters a))

Instances

Instances details

Functor Lambda Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> Lambda a -> Lambda b # (<$) :: a -> Lambda b -> Lambda a #
Foldable Lambda Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => Lambda m -> m # foldMap :: Monoid m => (a -> m) -> Lambda a -> 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 Source #
Instance details Defined in TreeSitter.Ruby.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 Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy Lambda -> [Int] showFailure :: Proxy Lambda -> Node -> String
Unmarshal Lambda Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match Lambda) matchers :: B (Int, Match Lambda)
Eq a => Eq (Lambda a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: Lambda a -> Lambda a -> Bool # (/=) :: Lambda a -> Lambda a -> Bool #
Ord a => Ord (Lambda a) Source #
Instance details Defined in TreeSitter.Ruby.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) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> Lambda a -> ShowS # show :: Lambda a -> String # showList :: [Lambda a] -> ShowS #
Generic (Lambda a) Source #
Instance details Defined in TreeSitter.Ruby.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 Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 Lambda :: k -> Type # Methods from1 :: forall (a :: k). Lambda a -> Rep1 Lambda a # to1 :: forall (a :: k). Rep1 Lambda a -> Lambda a #
type Rep (Lambda a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (Lambda a) = D1 ('MetaData "Lambda" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.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 ((Block :+: DoBlock) a)) :: S1 ('MetaSel ('Just "parameters") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe (LambdaParameters a))))))
type Rep1 Lambda Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 Lambda = D1 ('MetaData "Lambda" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Lambda" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :: (S1 ('MetaSel ('Just "body") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 (Block :+: DoBlock)) :: S1 ('MetaSel ('Just "parameters") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Maybe :.: Rec1 LambdaParameters))))

data KeywordParameter a Source #

Constructors

KeywordParameter
Fields ann :: a value :: (Maybe (Arg a)) name :: (Identifier a)

Instances

Instances details

Functor KeywordParameter Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> KeywordParameter a -> KeywordParameter b # (<$) :: a -> KeywordParameter b -> KeywordParameter a #
Foldable KeywordParameter Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => KeywordParameter m -> m # foldMap :: Monoid m => (a -> m) -> KeywordParameter a -> m # foldMap' :: Monoid m => (a -> m) -> KeywordParameter a -> m # foldr :: (a -> b -> b) -> b -> KeywordParameter a -> b # foldr' :: (a -> b -> b) -> b -> KeywordParameter a -> b # foldl :: (b -> a -> b) -> b -> KeywordParameter a -> b # foldl' :: (b -> a -> b) -> b -> KeywordParameter a -> b # foldr1 :: (a -> a -> a) -> KeywordParameter a -> a # foldl1 :: (a -> a -> a) -> KeywordParameter a -> a # toList :: KeywordParameter a -> [a] # null :: KeywordParameter a -> Bool # length :: KeywordParameter a -> Int # elem :: Eq a => a -> KeywordParameter a -> Bool # maximum :: Ord a => KeywordParameter a -> a # minimum :: Ord a => KeywordParameter a -> a # sum :: Num a => KeywordParameter a -> a # product :: Num a => KeywordParameter a -> a #
Traversable KeywordParameter Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> KeywordParameter a -> f (KeywordParameter b) # sequenceA :: Applicative f => KeywordParameter (f a) -> f (KeywordParameter a) # mapM :: Monad m => (a -> m b) -> KeywordParameter a -> m (KeywordParameter b) # sequence :: Monad m => KeywordParameter (m a) -> m (KeywordParameter a) #
SymbolMatching KeywordParameter Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy KeywordParameter -> [Int] showFailure :: Proxy KeywordParameter -> Node -> String
Unmarshal KeywordParameter Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match KeywordParameter) matchers :: B (Int, Match KeywordParameter)
Eq a => Eq (KeywordParameter a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: KeywordParameter a -> KeywordParameter a -> Bool # (/=) :: KeywordParameter a -> KeywordParameter a -> Bool #
Ord a => Ord (KeywordParameter a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: KeywordParameter a -> KeywordParameter a -> Ordering # (<) :: KeywordParameter a -> KeywordParameter a -> Bool # (<=) :: KeywordParameter a -> KeywordParameter a -> Bool # (>) :: KeywordParameter a -> KeywordParameter a -> Bool # (>=) :: KeywordParameter a -> KeywordParameter a -> Bool # max :: KeywordParameter a -> KeywordParameter a -> KeywordParameter a # min :: KeywordParameter a -> KeywordParameter a -> KeywordParameter a #
Show a => Show (KeywordParameter a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> KeywordParameter a -> ShowS # show :: KeywordParameter a -> String # showList :: [KeywordParameter a] -> ShowS #
Generic (KeywordParameter a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (KeywordParameter a) :: Type -> Type # Methods from :: KeywordParameter a -> Rep (KeywordParameter a) x # to :: Rep (KeywordParameter a) x -> KeywordParameter a #
Generic1 KeywordParameter Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 KeywordParameter :: k -> Type # Methods from1 :: forall (a :: k). KeywordParameter a -> Rep1 KeywordParameter a # to1 :: forall (a :: k). Rep1 KeywordParameter a -> KeywordParameter a #
type Rep (KeywordParameter a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (KeywordParameter a) = D1 ('MetaData "KeywordParameter" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "KeywordParameter" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :: (S1 ('MetaSel ('Just "value") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe (Arg a))) :: S1 ('MetaSel ('Just "name") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Identifier a)))))
type Rep1 KeywordParameter Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 KeywordParameter = D1 ('MetaData "KeywordParameter" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "KeywordParameter" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :: (S1 ('MetaSel ('Just "value") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Maybe :.: Rec1 Arg) :: S1 ('MetaSel ('Just "name") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 Identifier))))

data Interpolation a Source #

Constructors

Interpolation
Fields ann :: a extraChildren :: (Statement a)

Instances

Instances details

Functor Interpolation Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> Interpolation a -> Interpolation b # (<$) :: a -> Interpolation b -> Interpolation a #
Foldable Interpolation Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => Interpolation m -> m # foldMap :: Monoid m => (a -> m) -> Interpolation a -> 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 Source #
Instance details Defined in TreeSitter.Ruby.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 Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy Interpolation -> [Int] showFailure :: Proxy Interpolation -> Node -> String
Unmarshal Interpolation Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match Interpolation) matchers :: B (Int, Match Interpolation)
Eq a => Eq (Interpolation a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: Interpolation a -> Interpolation a -> Bool # (/=) :: Interpolation a -> Interpolation a -> Bool #
Ord a => Ord (Interpolation a) Source #
Instance details Defined in TreeSitter.Ruby.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) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> Interpolation a -> ShowS # show :: Interpolation a -> String # showList :: [Interpolation a] -> ShowS #
Generic (Interpolation a) Source #
Instance details Defined in TreeSitter.Ruby.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 Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 Interpolation :: k -> Type # Methods from1 :: forall (a :: k). Interpolation a -> Rep1 Interpolation a # to1 :: forall (a :: k). Rep1 Interpolation a -> Interpolation a #
type Rep (Interpolation a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (Interpolation a) = D1 ('MetaData "Interpolation" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.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 (Statement a))))
type Rep1 Interpolation Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 Interpolation = D1 ('MetaData "Interpolation" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Interpolation" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 Statement)))

data In a Source #

Constructors

In
Fields ann :: a extraChildren :: (Arg a)

Instances

Instances details

Functor In Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> In a -> In b # (<$) :: a -> In b -> In a #
Foldable In Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => In m -> m # foldMap :: Monoid m => (a -> m) -> In a -> m # foldMap' :: Monoid m => (a -> m) -> In a -> m # foldr :: (a -> b -> b) -> b -> In a -> b # foldr' :: (a -> b -> b) -> b -> In a -> b # foldl :: (b -> a -> b) -> b -> In a -> b # foldl' :: (b -> a -> b) -> b -> In a -> b # foldr1 :: (a -> a -> a) -> In a -> a # foldl1 :: (a -> a -> a) -> In a -> a # toList :: In a -> [a] # null :: In a -> Bool # length :: In a -> Int # elem :: Eq a => a -> In a -> Bool # maximum :: Ord a => In a -> a # minimum :: Ord a => In a -> a # sum :: Num a => In a -> a # product :: Num a => In a -> a #
Traversable In Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> In a -> f (In b) # sequenceA :: Applicative f => In (f a) -> f (In a) # mapM :: Monad m => (a -> m b) -> In a -> m (In b) # sequence :: Monad m => In (m a) -> m (In a) #
SymbolMatching In Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy In -> [Int] showFailure :: Proxy In -> Node -> String
Unmarshal In Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match In) matchers :: B (Int, Match In)
Eq a => Eq (In a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: In a -> In a -> Bool # (/=) :: In a -> In a -> Bool #
Ord a => Ord (In a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: In a -> In a -> Ordering # (<) :: In a -> In a -> Bool # (<=) :: In a -> In a -> Bool # (>) :: In a -> In a -> Bool # (>=) :: In a -> In a -> Bool # max :: In a -> In a -> In a # min :: In a -> In a -> In a #
Show a => Show (In a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> In a -> ShowS # show :: In a -> String # showList :: [In a] -> ShowS #
Generic (In a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (In a) :: Type -> Type # Methods from :: In a -> Rep (In a) x # to :: Rep (In a) x -> In a #
Generic1 In Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 In :: k -> Type # Methods from1 :: forall (a :: k). In a -> Rep1 In a # to1 :: forall (a :: k). Rep1 In a -> In a #
type Rep (In a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (In a) = D1 ('MetaData "In" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "In" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Arg a))))
type Rep1 In Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 In = D1 ('MetaData "In" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "In" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 Arg)))

data IfModifier a Source #

Constructors

IfModifier
Fields ann :: a body :: (Statement a) condition :: ((:+:) ((:+:) Arg ((:+:) Break MethodCall)) ((:+:) Next ((:+:) Return Yield)) a)

Instances

Instances details

Functor IfModifier Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> IfModifier a -> IfModifier b # (<$) :: a -> IfModifier b -> IfModifier a #
Foldable IfModifier Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => IfModifier m -> m # foldMap :: Monoid m => (a -> m) -> IfModifier a -> m # foldMap' :: Monoid m => (a -> m) -> IfModifier a -> m # foldr :: (a -> b -> b) -> b -> IfModifier a -> b # foldr' :: (a -> b -> b) -> b -> IfModifier a -> b # foldl :: (b -> a -> b) -> b -> IfModifier a -> b # foldl' :: (b -> a -> b) -> b -> IfModifier a -> b # foldr1 :: (a -> a -> a) -> IfModifier a -> a # foldl1 :: (a -> a -> a) -> IfModifier a -> a # toList :: IfModifier a -> [a] # null :: IfModifier a -> Bool # length :: IfModifier a -> Int # elem :: Eq a => a -> IfModifier a -> Bool # maximum :: Ord a => IfModifier a -> a # minimum :: Ord a => IfModifier a -> a # sum :: Num a => IfModifier a -> a # product :: Num a => IfModifier a -> a #
Traversable IfModifier Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> IfModifier a -> f (IfModifier b) # sequenceA :: Applicative f => IfModifier (f a) -> f (IfModifier a) # mapM :: Monad m => (a -> m b) -> IfModifier a -> m (IfModifier b) # sequence :: Monad m => IfModifier (m a) -> m (IfModifier a) #
SymbolMatching IfModifier Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy IfModifier -> [Int] showFailure :: Proxy IfModifier -> Node -> String
Unmarshal IfModifier Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match IfModifier) matchers :: B (Int, Match IfModifier)
Eq a => Eq (IfModifier a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: IfModifier a -> IfModifier a -> Bool # (/=) :: IfModifier a -> IfModifier a -> Bool #
Ord a => Ord (IfModifier a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: IfModifier a -> IfModifier a -> Ordering # (<) :: IfModifier a -> IfModifier a -> Bool # (<=) :: IfModifier a -> IfModifier a -> Bool # (>) :: IfModifier a -> IfModifier a -> Bool # (>=) :: IfModifier a -> IfModifier a -> Bool # max :: IfModifier a -> IfModifier a -> IfModifier a # min :: IfModifier a -> IfModifier a -> IfModifier a #
Show a => Show (IfModifier a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> IfModifier a -> ShowS # show :: IfModifier a -> String # showList :: [IfModifier a] -> ShowS #
Generic (IfModifier a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (IfModifier a) :: Type -> Type # Methods from :: IfModifier a -> Rep (IfModifier a) x # to :: Rep (IfModifier a) x -> IfModifier a #
Generic1 IfModifier Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 IfModifier :: k -> Type # Methods from1 :: forall (a :: k). IfModifier a -> Rep1 IfModifier a # to1 :: forall (a :: k). Rep1 IfModifier a -> IfModifier a #
type Rep (IfModifier a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (IfModifier a) = D1 ('MetaData "IfModifier" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "IfModifier" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :: (S1 ('MetaSel ('Just "body") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Statement a)) :: S1 ('MetaSel ('Just "condition") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (((Arg :+: (Break :+: MethodCall)) :+: (Next :+: (Return :+: Yield))) a)))))
type Rep1 IfModifier Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 IfModifier = D1 ('MetaData "IfModifier" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "IfModifier" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :: (S1 ('MetaSel ('Just "body") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 Statement) :: S1 ('MetaSel ('Just "condition") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 ((Arg :+: (Break :+: MethodCall)) :+: (Next :+: (Return :+: Yield)))))))

data If a Source #

Constructors

If
Fields ann :: a alternative :: (Maybe ((:+:) Else Elsif a)) consequence :: (Maybe (Then a)) condition :: (Statement a)

Instances

Instances details

Functor If Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> If a -> If b # (<$) :: a -> If b -> If a #
Foldable If Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => If m -> m # foldMap :: Monoid m => (a -> m) -> If a -> m # foldMap' :: Monoid m => (a -> m) -> If a -> m # foldr :: (a -> b -> b) -> b -> If a -> b # foldr' :: (a -> b -> b) -> b -> If a -> b # foldl :: (b -> a -> b) -> b -> If a -> b # foldl' :: (b -> a -> b) -> b -> If a -> b # foldr1 :: (a -> a -> a) -> If a -> a # foldl1 :: (a -> a -> a) -> If a -> a # toList :: If a -> [a] # null :: If a -> Bool # length :: If a -> Int # elem :: Eq a => a -> If a -> Bool # maximum :: Ord a => If a -> a # minimum :: Ord a => If a -> a # sum :: Num a => If a -> a # product :: Num a => If a -> a #
Traversable If Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> If a -> f (If b) # sequenceA :: Applicative f => If (f a) -> f (If a) # mapM :: Monad m => (a -> m b) -> If a -> m (If b) # sequence :: Monad m => If (m a) -> m (If a) #
SymbolMatching If Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy If -> [Int] showFailure :: Proxy If -> Node -> String
Unmarshal If Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match If) matchers :: B (Int, Match If)
Eq a => Eq (If a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: If a -> If a -> Bool # (/=) :: If a -> If a -> Bool #
Ord a => Ord (If a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: If a -> If a -> Ordering # (<) :: If a -> If a -> Bool # (<=) :: If a -> If a -> Bool # (>) :: If a -> If a -> Bool # (>=) :: If a -> If a -> Bool # max :: If a -> If a -> If a # min :: If a -> If a -> If a #
Show a => Show (If a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> If a -> ShowS # show :: If a -> String # showList :: [If a] -> ShowS #
Generic (If a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (If a) :: Type -> Type # Methods from :: If a -> Rep (If a) x # to :: Rep (If a) x -> If a #
Generic1 If Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 If :: k -> Type # Methods from1 :: forall (a :: k). If a -> Rep1 If a # to1 :: forall (a :: k). Rep1 If a -> If a #
type Rep (If a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (If a) = D1 ('MetaData "If" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "If" 'PrefixI 'True) ((S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :: S1 ('MetaSel ('Just "alternative") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe ((Else :+: Elsif) a)))) :: (S1 ('MetaSel ('Just "consequence") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe (Then a))) :*: S1 ('MetaSel ('Just "condition") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Statement a)))))
type Rep1 If Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 If = D1 ('MetaData "If" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "If" 'PrefixI 'True) ((S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :: S1 ('MetaSel ('Just "alternative") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Maybe :.: Rec1 (Else :+: Elsif))) :: (S1 ('MetaSel ('Just "consequence") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Maybe :.: Rec1 Then) :*: S1 ('MetaSel ('Just "condition") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 Statement))))

data HashSplatParameter a Source #

Constructors

HashSplatParameter
Fields ann :: a name :: (Maybe (Identifier a))

Instances

Instances details

Functor HashSplatParameter Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> HashSplatParameter a -> HashSplatParameter b # (<$) :: a -> HashSplatParameter b -> HashSplatParameter a #
Foldable HashSplatParameter Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => HashSplatParameter m -> m # foldMap :: Monoid m => (a -> m) -> HashSplatParameter a -> m # foldMap' :: Monoid m => (a -> m) -> HashSplatParameter a -> m # foldr :: (a -> b -> b) -> b -> HashSplatParameter a -> b # foldr' :: (a -> b -> b) -> b -> HashSplatParameter a -> b # foldl :: (b -> a -> b) -> b -> HashSplatParameter a -> b # foldl' :: (b -> a -> b) -> b -> HashSplatParameter a -> b # foldr1 :: (a -> a -> a) -> HashSplatParameter a -> a # foldl1 :: (a -> a -> a) -> HashSplatParameter a -> a # toList :: HashSplatParameter a -> [a] # null :: HashSplatParameter a -> Bool # length :: HashSplatParameter a -> Int # elem :: Eq a => a -> HashSplatParameter a -> Bool # maximum :: Ord a => HashSplatParameter a -> a # minimum :: Ord a => HashSplatParameter a -> a # sum :: Num a => HashSplatParameter a -> a # product :: Num a => HashSplatParameter a -> a #
Traversable HashSplatParameter Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> HashSplatParameter a -> f (HashSplatParameter b) # sequenceA :: Applicative f => HashSplatParameter (f a) -> f (HashSplatParameter a) # mapM :: Monad m => (a -> m b) -> HashSplatParameter a -> m (HashSplatParameter b) # sequence :: Monad m => HashSplatParameter (m a) -> m (HashSplatParameter a) #
SymbolMatching HashSplatParameter Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy HashSplatParameter -> [Int] showFailure :: Proxy HashSplatParameter -> Node -> String
Unmarshal HashSplatParameter Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match HashSplatParameter) matchers :: B (Int, Match HashSplatParameter)
Eq a => Eq (HashSplatParameter a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: HashSplatParameter a -> HashSplatParameter a -> Bool # (/=) :: HashSplatParameter a -> HashSplatParameter a -> Bool #
Ord a => Ord (HashSplatParameter a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: HashSplatParameter a -> HashSplatParameter a -> Ordering # (<) :: HashSplatParameter a -> HashSplatParameter a -> Bool # (<=) :: HashSplatParameter a -> HashSplatParameter a -> Bool # (>) :: HashSplatParameter a -> HashSplatParameter a -> Bool # (>=) :: HashSplatParameter a -> HashSplatParameter a -> Bool # max :: HashSplatParameter a -> HashSplatParameter a -> HashSplatParameter a # min :: HashSplatParameter a -> HashSplatParameter a -> HashSplatParameter a #
Show a => Show (HashSplatParameter a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> HashSplatParameter a -> ShowS # show :: HashSplatParameter a -> String # showList :: [HashSplatParameter a] -> ShowS #
Generic (HashSplatParameter a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (HashSplatParameter a) :: Type -> Type # Methods from :: HashSplatParameter a -> Rep (HashSplatParameter a) x # to :: Rep (HashSplatParameter a) x -> HashSplatParameter a #
Generic1 HashSplatParameter Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 HashSplatParameter :: k -> Type # Methods from1 :: forall (a :: k). HashSplatParameter a -> Rep1 HashSplatParameter a # to1 :: forall (a :: k). Rep1 HashSplatParameter a -> HashSplatParameter a #
type Rep (HashSplatParameter a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (HashSplatParameter a) = D1 ('MetaData "HashSplatParameter" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "HashSplatParameter" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "name") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe (Identifier a)))))
type Rep1 HashSplatParameter Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 HashSplatParameter = D1 ('MetaData "HashSplatParameter" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "HashSplatParameter" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Just "name") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Maybe :.: Rec1 Identifier)))

data HashSplatArgument a Source #

Constructors

HashSplatArgument
Fields ann :: a extraChildren :: (Arg a)

Instances

Instances details

Functor HashSplatArgument Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> HashSplatArgument a -> HashSplatArgument b # (<$) :: a -> HashSplatArgument b -> HashSplatArgument a #
Foldable HashSplatArgument Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => HashSplatArgument m -> m # foldMap :: Monoid m => (a -> m) -> HashSplatArgument a -> m # foldMap' :: Monoid m => (a -> m) -> HashSplatArgument a -> m # foldr :: (a -> b -> b) -> b -> HashSplatArgument a -> b # foldr' :: (a -> b -> b) -> b -> HashSplatArgument a -> b # foldl :: (b -> a -> b) -> b -> HashSplatArgument a -> b # foldl' :: (b -> a -> b) -> b -> HashSplatArgument a -> b # foldr1 :: (a -> a -> a) -> HashSplatArgument a -> a # foldl1 :: (a -> a -> a) -> HashSplatArgument a -> a # toList :: HashSplatArgument a -> [a] # null :: HashSplatArgument a -> Bool # length :: HashSplatArgument a -> Int # elem :: Eq a => a -> HashSplatArgument a -> Bool # maximum :: Ord a => HashSplatArgument a -> a # minimum :: Ord a => HashSplatArgument a -> a # sum :: Num a => HashSplatArgument a -> a # product :: Num a => HashSplatArgument a -> a #
Traversable HashSplatArgument Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> HashSplatArgument a -> f (HashSplatArgument b) # sequenceA :: Applicative f => HashSplatArgument (f a) -> f (HashSplatArgument a) # mapM :: Monad m => (a -> m b) -> HashSplatArgument a -> m (HashSplatArgument b) # sequence :: Monad m => HashSplatArgument (m a) -> m (HashSplatArgument a) #
SymbolMatching HashSplatArgument Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy HashSplatArgument -> [Int] showFailure :: Proxy HashSplatArgument -> Node -> String
Unmarshal HashSplatArgument Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match HashSplatArgument) matchers :: B (Int, Match HashSplatArgument)
Eq a => Eq (HashSplatArgument a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: HashSplatArgument a -> HashSplatArgument a -> Bool # (/=) :: HashSplatArgument a -> HashSplatArgument a -> Bool #
Ord a => Ord (HashSplatArgument a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: HashSplatArgument a -> HashSplatArgument a -> Ordering # (<) :: HashSplatArgument a -> HashSplatArgument a -> Bool # (<=) :: HashSplatArgument a -> HashSplatArgument a -> Bool # (>) :: HashSplatArgument a -> HashSplatArgument a -> Bool # (>=) :: HashSplatArgument a -> HashSplatArgument a -> Bool # max :: HashSplatArgument a -> HashSplatArgument a -> HashSplatArgument a # min :: HashSplatArgument a -> HashSplatArgument a -> HashSplatArgument a #
Show a => Show (HashSplatArgument a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> HashSplatArgument a -> ShowS # show :: HashSplatArgument a -> String # showList :: [HashSplatArgument a] -> ShowS #
Generic (HashSplatArgument a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (HashSplatArgument a) :: Type -> Type # Methods from :: HashSplatArgument a -> Rep (HashSplatArgument a) x # to :: Rep (HashSplatArgument a) x -> HashSplatArgument a #
Generic1 HashSplatArgument Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 HashSplatArgument :: k -> Type # Methods from1 :: forall (a :: k). HashSplatArgument a -> Rep1 HashSplatArgument a # to1 :: forall (a :: k). Rep1 HashSplatArgument a -> HashSplatArgument a #
type Rep (HashSplatArgument a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (HashSplatArgument a) = D1 ('MetaData "HashSplatArgument" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "HashSplatArgument" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Arg a))))
type Rep1 HashSplatArgument Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 HashSplatArgument = D1 ('MetaData "HashSplatArgument" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "HashSplatArgument" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 Arg)))

data Hash a Source #

Constructors

Hash
Fields ann :: a extraChildren :: ([] ((:+:) HashSplatArgument Pair a))

Instances

Instances details

Functor Hash Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> Hash a -> Hash b # (<$) :: a -> Hash b -> Hash a #
Foldable Hash Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => Hash m -> m # foldMap :: Monoid m => (a -> m) -> Hash a -> m # foldMap' :: Monoid m => (a -> m) -> Hash a -> m # foldr :: (a -> b -> b) -> b -> Hash a -> b # foldr' :: (a -> b -> b) -> b -> Hash a -> b # foldl :: (b -> a -> b) -> b -> Hash a -> b # foldl' :: (b -> a -> b) -> b -> Hash a -> b # foldr1 :: (a -> a -> a) -> Hash a -> a # foldl1 :: (a -> a -> a) -> Hash a -> a # toList :: Hash a -> [a] # null :: Hash a -> Bool # length :: Hash a -> Int # elem :: Eq a => a -> Hash a -> Bool # maximum :: Ord a => Hash a -> a # minimum :: Ord a => Hash a -> a # sum :: Num a => Hash a -> a # product :: Num a => Hash a -> a #
Traversable Hash Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> Hash a -> f (Hash b) # sequenceA :: Applicative f => Hash (f a) -> f (Hash a) # mapM :: Monad m => (a -> m b) -> Hash a -> m (Hash b) # sequence :: Monad m => Hash (m a) -> m (Hash a) #
SymbolMatching Hash Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy Hash -> [Int] showFailure :: Proxy Hash -> Node -> String
Unmarshal Hash Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match Hash) matchers :: B (Int, Match Hash)
Eq a => Eq (Hash a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: Hash a -> Hash a -> Bool # (/=) :: Hash a -> Hash a -> Bool #
Ord a => Ord (Hash a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: Hash a -> Hash a -> Ordering # (<) :: Hash a -> Hash a -> Bool # (<=) :: Hash a -> Hash a -> Bool # (>) :: Hash a -> Hash a -> Bool # (>=) :: Hash a -> Hash a -> Bool # max :: Hash a -> Hash a -> Hash a # min :: Hash a -> Hash a -> Hash a #
Show a => Show (Hash a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> Hash a -> ShowS # show :: Hash a -> String # showList :: [Hash a] -> ShowS #
Generic (Hash a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (Hash a) :: Type -> Type # Methods from :: Hash a -> Rep (Hash a) x # to :: Rep (Hash a) x -> Hash a #
Generic1 Hash Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 Hash :: k -> Type # Methods from1 :: forall (a :: k). Hash a -> Rep1 Hash a # to1 :: forall (a :: k). Rep1 Hash a -> Hash a #
type Rep (Hash a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (Hash a) = D1 ('MetaData "Hash" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Hash" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [(HashSplatArgument :+: Pair) a])))
type Rep1 Hash Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 Hash = D1 ('MetaData "Hash" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Hash" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) ([] :.: Rec1 (HashSplatArgument :+: Pair))))

data For a Source #

Constructors

For
Fields ann :: a pattern :: (NonEmpty ((:+:) Lhs ((:+:) DestructuredLeftAssignment RestAssignment) a)) body :: (Do a) value :: (In a)

Instances

Instances details

Functor For Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> For a -> For b # (<$) :: a -> For b -> For a #
Foldable For Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => For m -> m # foldMap :: Monoid m => (a -> m) -> For a -> m # foldMap' :: Monoid m => (a -> m) -> For a -> m # foldr :: (a -> b -> b) -> b -> For a -> b # foldr' :: (a -> b -> b) -> b -> For a -> b # foldl :: (b -> a -> b) -> b -> For a -> b # foldl' :: (b -> a -> b) -> b -> For a -> b # foldr1 :: (a -> a -> a) -> For a -> a # foldl1 :: (a -> a -> a) -> For a -> a # toList :: For a -> [a] # null :: For a -> Bool # length :: For a -> Int # elem :: Eq a => a -> For a -> Bool # maximum :: Ord a => For a -> a # minimum :: Ord a => For a -> a # sum :: Num a => For a -> a # product :: Num a => For a -> a #
Traversable For Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> For a -> f (For b) # sequenceA :: Applicative f => For (f a) -> f (For a) # mapM :: Monad m => (a -> m b) -> For a -> m (For b) # sequence :: Monad m => For (m a) -> m (For a) #
SymbolMatching For Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy For -> [Int] showFailure :: Proxy For -> Node -> String
Unmarshal For Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match For) matchers :: B (Int, Match For)
Eq a => Eq (For a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: For a -> For a -> Bool # (/=) :: For a -> For a -> Bool #
Ord a => Ord (For a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: For a -> For a -> Ordering # (<) :: For a -> For a -> Bool # (<=) :: For a -> For a -> Bool # (>) :: For a -> For a -> Bool # (>=) :: For a -> For a -> Bool # max :: For a -> For a -> For a # min :: For a -> For a -> For a #
Show a => Show (For a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> For a -> ShowS # show :: For a -> String # showList :: [For a] -> ShowS #
Generic (For a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (For a) :: Type -> Type # Methods from :: For a -> Rep (For a) x # to :: Rep (For a) x -> For a #
Generic1 For Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 For :: k -> Type # Methods from1 :: forall (a :: k). For a -> Rep1 For a # to1 :: forall (a :: k). Rep1 For a -> For a #
type Rep (For a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (For a) = D1 ('MetaData "For" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "For" 'PrefixI 'True) ((S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :: S1 ('MetaSel ('Just "pattern") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (NonEmpty ((Lhs :+: (DestructuredLeftAssignment :+: RestAssignment)) a)))) :: (S1 ('MetaSel ('Just "body") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Do a)) :*: S1 ('MetaSel ('Just "value") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (In a)))))
type Rep1 For Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 For = D1 ('MetaData "For" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "For" 'PrefixI 'True) ((S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :: S1 ('MetaSel ('Just "pattern") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (NonEmpty :.: Rec1 (Lhs :+: (DestructuredLeftAssignment :+: RestAssignment)))) :: (S1 ('MetaSel ('Just "body") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 Do) :*: S1 ('MetaSel ('Just "value") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 In))))

data Exceptions a Source #

Constructors

Exceptions
Fields ann :: a extraChildren :: (NonEmpty ((:+:) Arg SplatArgument a))

Instances

Instances details

Functor Exceptions Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> Exceptions a -> Exceptions b # (<$) :: a -> Exceptions b -> Exceptions a #
Foldable Exceptions Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => Exceptions m -> m # foldMap :: Monoid m => (a -> m) -> Exceptions a -> m # foldMap' :: Monoid m => (a -> m) -> Exceptions a -> m # foldr :: (a -> b -> b) -> b -> Exceptions a -> b # foldr' :: (a -> b -> b) -> b -> Exceptions a -> b # foldl :: (b -> a -> b) -> b -> Exceptions a -> b # foldl' :: (b -> a -> b) -> b -> Exceptions a -> b # foldr1 :: (a -> a -> a) -> Exceptions a -> a # foldl1 :: (a -> a -> a) -> Exceptions a -> a # toList :: Exceptions a -> [a] # null :: Exceptions a -> Bool # length :: Exceptions a -> Int # elem :: Eq a => a -> Exceptions a -> Bool # maximum :: Ord a => Exceptions a -> a # minimum :: Ord a => Exceptions a -> a # sum :: Num a => Exceptions a -> a # product :: Num a => Exceptions a -> a #
Traversable Exceptions Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> Exceptions a -> f (Exceptions b) # sequenceA :: Applicative f => Exceptions (f a) -> f (Exceptions a) # mapM :: Monad m => (a -> m b) -> Exceptions a -> m (Exceptions b) # sequence :: Monad m => Exceptions (m a) -> m (Exceptions a) #
SymbolMatching Exceptions Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy Exceptions -> [Int] showFailure :: Proxy Exceptions -> Node -> String
Unmarshal Exceptions Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match Exceptions) matchers :: B (Int, Match Exceptions)
Eq a => Eq (Exceptions a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: Exceptions a -> Exceptions a -> Bool # (/=) :: Exceptions a -> Exceptions a -> Bool #
Ord a => Ord (Exceptions a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: Exceptions a -> Exceptions a -> Ordering # (<) :: Exceptions a -> Exceptions a -> Bool # (<=) :: Exceptions a -> Exceptions a -> Bool # (>) :: Exceptions a -> Exceptions a -> Bool # (>=) :: Exceptions a -> Exceptions a -> Bool # max :: Exceptions a -> Exceptions a -> Exceptions a # min :: Exceptions a -> Exceptions a -> Exceptions a #
Show a => Show (Exceptions a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> Exceptions a -> ShowS # show :: Exceptions a -> String # showList :: [Exceptions a] -> ShowS #
Generic (Exceptions a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (Exceptions a) :: Type -> Type # Methods from :: Exceptions a -> Rep (Exceptions a) x # to :: Rep (Exceptions a) x -> Exceptions a #
Generic1 Exceptions Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 Exceptions :: k -> Type # Methods from1 :: forall (a :: k). Exceptions a -> Rep1 Exceptions a # to1 :: forall (a :: k). Rep1 Exceptions a -> Exceptions a #
type Rep (Exceptions a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (Exceptions a) = D1 ('MetaData "Exceptions" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Exceptions" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (NonEmpty ((Arg :+: SplatArgument) a)))))
type Rep1 Exceptions Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 Exceptions = D1 ('MetaData "Exceptions" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Exceptions" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (NonEmpty :.: Rec1 (Arg :+: SplatArgument))))

data ExceptionVariable a Source #

Constructors

ExceptionVariable
Fields ann :: a extraChildren :: (Lhs a)

Instances

Instances details

Functor ExceptionVariable Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> ExceptionVariable a -> ExceptionVariable b # (<$) :: a -> ExceptionVariable b -> ExceptionVariable a #
Foldable ExceptionVariable Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => ExceptionVariable m -> m # foldMap :: Monoid m => (a -> m) -> ExceptionVariable a -> m # foldMap' :: Monoid m => (a -> m) -> ExceptionVariable a -> m # foldr :: (a -> b -> b) -> b -> ExceptionVariable a -> b # foldr' :: (a -> b -> b) -> b -> ExceptionVariable a -> b # foldl :: (b -> a -> b) -> b -> ExceptionVariable a -> b # foldl' :: (b -> a -> b) -> b -> ExceptionVariable a -> b # foldr1 :: (a -> a -> a) -> ExceptionVariable a -> a # foldl1 :: (a -> a -> a) -> ExceptionVariable a -> a # toList :: ExceptionVariable a -> [a] # null :: ExceptionVariable a -> Bool # length :: ExceptionVariable a -> Int # elem :: Eq a => a -> ExceptionVariable a -> Bool # maximum :: Ord a => ExceptionVariable a -> a # minimum :: Ord a => ExceptionVariable a -> a # sum :: Num a => ExceptionVariable a -> a # product :: Num a => ExceptionVariable a -> a #
Traversable ExceptionVariable Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> ExceptionVariable a -> f (ExceptionVariable b) # sequenceA :: Applicative f => ExceptionVariable (f a) -> f (ExceptionVariable a) # mapM :: Monad m => (a -> m b) -> ExceptionVariable a -> m (ExceptionVariable b) # sequence :: Monad m => ExceptionVariable (m a) -> m (ExceptionVariable a) #
SymbolMatching ExceptionVariable Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy ExceptionVariable -> [Int] showFailure :: Proxy ExceptionVariable -> Node -> String
Unmarshal ExceptionVariable Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match ExceptionVariable) matchers :: B (Int, Match ExceptionVariable)
Eq a => Eq (ExceptionVariable a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: ExceptionVariable a -> ExceptionVariable a -> Bool # (/=) :: ExceptionVariable a -> ExceptionVariable a -> Bool #
Ord a => Ord (ExceptionVariable a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: ExceptionVariable a -> ExceptionVariable a -> Ordering # (<) :: ExceptionVariable a -> ExceptionVariable a -> Bool # (<=) :: ExceptionVariable a -> ExceptionVariable a -> Bool # (>) :: ExceptionVariable a -> ExceptionVariable a -> Bool # (>=) :: ExceptionVariable a -> ExceptionVariable a -> Bool # max :: ExceptionVariable a -> ExceptionVariable a -> ExceptionVariable a # min :: ExceptionVariable a -> ExceptionVariable a -> ExceptionVariable a #
Show a => Show (ExceptionVariable a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> ExceptionVariable a -> ShowS # show :: ExceptionVariable a -> String # showList :: [ExceptionVariable a] -> ShowS #
Generic (ExceptionVariable a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (ExceptionVariable a) :: Type -> Type # Methods from :: ExceptionVariable a -> Rep (ExceptionVariable a) x # to :: Rep (ExceptionVariable a) x -> ExceptionVariable a #
Generic1 ExceptionVariable Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 ExceptionVariable :: k -> Type # Methods from1 :: forall (a :: k). ExceptionVariable a -> Rep1 ExceptionVariable a # to1 :: forall (a :: k). Rep1 ExceptionVariable a -> ExceptionVariable a #
type Rep (ExceptionVariable a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (ExceptionVariable a) = D1 ('MetaData "ExceptionVariable" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "ExceptionVariable" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Lhs a))))
type Rep1 ExceptionVariable Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 ExceptionVariable = D1 ('MetaData "ExceptionVariable" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "ExceptionVariable" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 Lhs)))

data Ensure a Source #

Constructors

Ensure
Fields ann :: a extraChildren :: ([] ((:+:) Statement EmptyStatement a))

Instances

Instances details

Functor Ensure Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> Ensure a -> Ensure b # (<$) :: a -> Ensure b -> Ensure a #
Foldable Ensure Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => Ensure m -> m # foldMap :: Monoid m => (a -> m) -> Ensure a -> m # foldMap' :: Monoid m => (a -> m) -> Ensure a -> m # foldr :: (a -> b -> b) -> b -> Ensure a -> b # foldr' :: (a -> b -> b) -> b -> Ensure a -> b # foldl :: (b -> a -> b) -> b -> Ensure a -> b # foldl' :: (b -> a -> b) -> b -> Ensure a -> b # foldr1 :: (a -> a -> a) -> Ensure a -> a # foldl1 :: (a -> a -> a) -> Ensure a -> a # toList :: Ensure a -> [a] # null :: Ensure a -> Bool # length :: Ensure a -> Int # elem :: Eq a => a -> Ensure a -> Bool # maximum :: Ord a => Ensure a -> a # minimum :: Ord a => Ensure a -> a # sum :: Num a => Ensure a -> a # product :: Num a => Ensure a -> a #
Traversable Ensure Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> Ensure a -> f (Ensure b) # sequenceA :: Applicative f => Ensure (f a) -> f (Ensure a) # mapM :: Monad m => (a -> m b) -> Ensure a -> m (Ensure b) # sequence :: Monad m => Ensure (m a) -> m (Ensure a) #
SymbolMatching Ensure Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy Ensure -> [Int] showFailure :: Proxy Ensure -> Node -> String
Unmarshal Ensure Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match Ensure) matchers :: B (Int, Match Ensure)
Eq a => Eq (Ensure a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: Ensure a -> Ensure a -> Bool # (/=) :: Ensure a -> Ensure a -> Bool #
Ord a => Ord (Ensure a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: Ensure a -> Ensure a -> Ordering # (<) :: Ensure a -> Ensure a -> Bool # (<=) :: Ensure a -> Ensure a -> Bool # (>) :: Ensure a -> Ensure a -> Bool # (>=) :: Ensure a -> Ensure a -> Bool # max :: Ensure a -> Ensure a -> Ensure a # min :: Ensure a -> Ensure a -> Ensure a #
Show a => Show (Ensure a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> Ensure a -> ShowS # show :: Ensure a -> String # showList :: [Ensure a] -> ShowS #
Generic (Ensure a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (Ensure a) :: Type -> Type # Methods from :: Ensure a -> Rep (Ensure a) x # to :: Rep (Ensure a) x -> Ensure a #
Generic1 Ensure Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 Ensure :: k -> Type # Methods from1 :: forall (a :: k). Ensure a -> Rep1 Ensure a # to1 :: forall (a :: k). Rep1 Ensure a -> Ensure a #
type Rep (Ensure a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (Ensure a) = D1 ('MetaData "Ensure" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Ensure" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [(Statement :+: EmptyStatement) a])))
type Rep1 Ensure Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 Ensure = D1 ('MetaData "Ensure" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Ensure" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) ([] :.: Rec1 (Statement :+: EmptyStatement))))

data EndBlock a Source #

Constructors

EndBlock
Fields ann :: a extraChildren :: ([] ((:+:) Statement EmptyStatement a))

Instances

Instances details

Functor EndBlock Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> EndBlock a -> EndBlock b # (<$) :: a -> EndBlock b -> EndBlock a #
Foldable EndBlock Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => EndBlock m -> m # foldMap :: Monoid m => (a -> m) -> EndBlock a -> m # foldMap' :: Monoid m => (a -> m) -> EndBlock a -> m # foldr :: (a -> b -> b) -> b -> EndBlock a -> b # foldr' :: (a -> b -> b) -> b -> EndBlock a -> b # foldl :: (b -> a -> b) -> b -> EndBlock a -> b # foldl' :: (b -> a -> b) -> b -> EndBlock a -> b # foldr1 :: (a -> a -> a) -> EndBlock a -> a # foldl1 :: (a -> a -> a) -> EndBlock a -> a # toList :: EndBlock a -> [a] # null :: EndBlock a -> Bool # length :: EndBlock a -> Int # elem :: Eq a => a -> EndBlock a -> Bool # maximum :: Ord a => EndBlock a -> a # minimum :: Ord a => EndBlock a -> a # sum :: Num a => EndBlock a -> a # product :: Num a => EndBlock a -> a #
Traversable EndBlock Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> EndBlock a -> f (EndBlock b) # sequenceA :: Applicative f => EndBlock (f a) -> f (EndBlock a) # mapM :: Monad m => (a -> m b) -> EndBlock a -> m (EndBlock b) # sequence :: Monad m => EndBlock (m a) -> m (EndBlock a) #
SymbolMatching EndBlock Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy EndBlock -> [Int] showFailure :: Proxy EndBlock -> Node -> String
Unmarshal EndBlock Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match EndBlock) matchers :: B (Int, Match EndBlock)
Eq a => Eq (EndBlock a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: EndBlock a -> EndBlock a -> Bool # (/=) :: EndBlock a -> EndBlock a -> Bool #
Ord a => Ord (EndBlock a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: EndBlock a -> EndBlock a -> Ordering # (<) :: EndBlock a -> EndBlock a -> Bool # (<=) :: EndBlock a -> EndBlock a -> Bool # (>) :: EndBlock a -> EndBlock a -> Bool # (>=) :: EndBlock a -> EndBlock a -> Bool # max :: EndBlock a -> EndBlock a -> EndBlock a # min :: EndBlock a -> EndBlock a -> EndBlock a #
Show a => Show (EndBlock a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> EndBlock a -> ShowS # show :: EndBlock a -> String # showList :: [EndBlock a] -> ShowS #
Generic (EndBlock a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (EndBlock a) :: Type -> Type # Methods from :: EndBlock a -> Rep (EndBlock a) x # to :: Rep (EndBlock a) x -> EndBlock a #
Generic1 EndBlock Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 EndBlock :: k -> Type # Methods from1 :: forall (a :: k). EndBlock a -> Rep1 EndBlock a # to1 :: forall (a :: k). Rep1 EndBlock a -> EndBlock a #
type Rep (EndBlock a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (EndBlock a) = D1 ('MetaData "EndBlock" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "EndBlock" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [(Statement :+: EmptyStatement) a])))
type Rep1 EndBlock Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 EndBlock = D1 ('MetaData "EndBlock" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "EndBlock" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) ([] :.: Rec1 (Statement :+: EmptyStatement))))

data EmptyStatement a Source #

Constructors

EmptyStatement
Fields ann :: a text :: Text

Instances

Instances details

Functor EmptyStatement Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> EmptyStatement a -> EmptyStatement b # (<$) :: a -> EmptyStatement b -> EmptyStatement a #
Foldable EmptyStatement Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => EmptyStatement m -> m # foldMap :: Monoid m => (a -> m) -> EmptyStatement a -> m # foldMap' :: Monoid m => (a -> m) -> EmptyStatement a -> m # foldr :: (a -> b -> b) -> b -> EmptyStatement a -> b # foldr' :: (a -> b -> b) -> b -> EmptyStatement a -> b # foldl :: (b -> a -> b) -> b -> EmptyStatement a -> b # foldl' :: (b -> a -> b) -> b -> EmptyStatement a -> b # foldr1 :: (a -> a -> a) -> EmptyStatement a -> a # foldl1 :: (a -> a -> a) -> EmptyStatement a -> a # toList :: EmptyStatement a -> [a] # null :: EmptyStatement a -> Bool # length :: EmptyStatement a -> Int # elem :: Eq a => a -> EmptyStatement a -> Bool # maximum :: Ord a => EmptyStatement a -> a # minimum :: Ord a => EmptyStatement a -> a # sum :: Num a => EmptyStatement a -> a # product :: Num a => EmptyStatement a -> a #
Traversable EmptyStatement Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> EmptyStatement a -> f (EmptyStatement b) # sequenceA :: Applicative f => EmptyStatement (f a) -> f (EmptyStatement a) # mapM :: Monad m => (a -> m b) -> EmptyStatement a -> m (EmptyStatement b) # sequence :: Monad m => EmptyStatement (m a) -> m (EmptyStatement a) #
SymbolMatching EmptyStatement Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy EmptyStatement -> [Int] showFailure :: Proxy EmptyStatement -> Node -> String
Unmarshal EmptyStatement Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match EmptyStatement) matchers :: B (Int, Match EmptyStatement)
Eq a => Eq (EmptyStatement a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: EmptyStatement a -> EmptyStatement a -> Bool # (/=) :: EmptyStatement a -> EmptyStatement a -> Bool #
Ord a => Ord (EmptyStatement a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: EmptyStatement a -> EmptyStatement a -> Ordering # (<) :: EmptyStatement a -> EmptyStatement a -> Bool # (<=) :: EmptyStatement a -> EmptyStatement a -> Bool # (>) :: EmptyStatement a -> EmptyStatement a -> Bool # (>=) :: EmptyStatement a -> EmptyStatement a -> Bool # max :: EmptyStatement a -> EmptyStatement a -> EmptyStatement a # min :: EmptyStatement a -> EmptyStatement a -> EmptyStatement a #
Show a => Show (EmptyStatement a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> EmptyStatement a -> ShowS # show :: EmptyStatement a -> String # showList :: [EmptyStatement a] -> ShowS #
Generic (EmptyStatement a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (EmptyStatement a) :: Type -> Type # Methods from :: EmptyStatement a -> Rep (EmptyStatement a) x # to :: Rep (EmptyStatement a) x -> EmptyStatement a #
Generic1 EmptyStatement Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 EmptyStatement :: k -> Type # Methods from1 :: forall (a :: k). EmptyStatement a -> Rep1 EmptyStatement a # to1 :: forall (a :: k). Rep1 EmptyStatement a -> EmptyStatement a #
type Rep (EmptyStatement a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (EmptyStatement a) = D1 ('MetaData "EmptyStatement" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "EmptyStatement" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "text") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Text)))
type Rep1 EmptyStatement Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 EmptyStatement = D1 ('MetaData "EmptyStatement" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "EmptyStatement" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Just "text") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Text)))

data Elsif a Source #

Constructors

Elsif
Fields ann :: a alternative :: (Maybe ((:+:) Else Elsif a)) consequence :: (Maybe (Then a)) condition :: (Statement a)

Instances

Instances details

Functor Elsif Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> Elsif a -> Elsif b # (<$) :: a -> Elsif b -> Elsif a #
Foldable Elsif Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => Elsif m -> m # foldMap :: Monoid m => (a -> m) -> Elsif a -> m # foldMap' :: Monoid m => (a -> m) -> Elsif a -> m # foldr :: (a -> b -> b) -> b -> Elsif a -> b # foldr' :: (a -> b -> b) -> b -> Elsif a -> b # foldl :: (b -> a -> b) -> b -> Elsif a -> b # foldl' :: (b -> a -> b) -> b -> Elsif a -> b # foldr1 :: (a -> a -> a) -> Elsif a -> a # foldl1 :: (a -> a -> a) -> Elsif a -> a # toList :: Elsif a -> [a] # null :: Elsif a -> Bool # length :: Elsif a -> Int # elem :: Eq a => a -> Elsif a -> Bool # maximum :: Ord a => Elsif a -> a # minimum :: Ord a => Elsif a -> a # sum :: Num a => Elsif a -> a # product :: Num a => Elsif a -> a #
Traversable Elsif Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> Elsif a -> f (Elsif b) # sequenceA :: Applicative f => Elsif (f a) -> f (Elsif a) # mapM :: Monad m => (a -> m b) -> Elsif a -> m (Elsif b) # sequence :: Monad m => Elsif (m a) -> m (Elsif a) #
SymbolMatching Elsif Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy Elsif -> [Int] showFailure :: Proxy Elsif -> Node -> String
Unmarshal Elsif Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match Elsif) matchers :: B (Int, Match Elsif)
Eq a => Eq (Elsif a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: Elsif a -> Elsif a -> Bool # (/=) :: Elsif a -> Elsif a -> Bool #
Ord a => Ord (Elsif a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: Elsif a -> Elsif a -> Ordering # (<) :: Elsif a -> Elsif a -> Bool # (<=) :: Elsif a -> Elsif a -> Bool # (>) :: Elsif a -> Elsif a -> Bool # (>=) :: Elsif a -> Elsif a -> Bool # max :: Elsif a -> Elsif a -> Elsif a # min :: Elsif a -> Elsif a -> Elsif a #
Show a => Show (Elsif a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> Elsif a -> ShowS # show :: Elsif a -> String # showList :: [Elsif a] -> ShowS #
Generic (Elsif a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (Elsif a) :: Type -> Type # Methods from :: Elsif a -> Rep (Elsif a) x # to :: Rep (Elsif a) x -> Elsif a #
Generic1 Elsif Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 Elsif :: k -> Type # Methods from1 :: forall (a :: k). Elsif a -> Rep1 Elsif a # to1 :: forall (a :: k). Rep1 Elsif a -> Elsif a #
type Rep (Elsif a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (Elsif a) = D1 ('MetaData "Elsif" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Elsif" 'PrefixI 'True) ((S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :: S1 ('MetaSel ('Just "alternative") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe ((Else :+: Elsif) a)))) :: (S1 ('MetaSel ('Just "consequence") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe (Then a))) :*: S1 ('MetaSel ('Just "condition") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Statement a)))))
type Rep1 Elsif Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 Elsif = D1 ('MetaData "Elsif" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Elsif" 'PrefixI 'True) ((S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :: S1 ('MetaSel ('Just "alternative") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Maybe :.: Rec1 (Else :+: Elsif))) :: (S1 ('MetaSel ('Just "consequence") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Maybe :.: Rec1 Then) :*: S1 ('MetaSel ('Just "condition") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 Statement))))

data Else a Source #

Constructors

Else
Fields ann :: a condition :: (Maybe (AnonymousSemicolon a)) extraChildren :: ([] ((:+:) Statement EmptyStatement a))

Instances

Instances details

Functor Else Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> Else a -> Else b # (<$) :: a -> Else b -> Else a #
Foldable Else Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => Else m -> m # foldMap :: Monoid m => (a -> m) -> Else a -> m # foldMap' :: Monoid m => (a -> m) -> Else a -> m # foldr :: (a -> b -> b) -> b -> Else a -> b # foldr' :: (a -> b -> b) -> b -> Else a -> b # foldl :: (b -> a -> b) -> b -> Else a -> b # foldl' :: (b -> a -> b) -> b -> Else a -> b # foldr1 :: (a -> a -> a) -> Else a -> a # foldl1 :: (a -> a -> a) -> Else a -> a # toList :: Else a -> [a] # null :: Else a -> Bool # length :: Else a -> Int # elem :: Eq a => a -> Else a -> Bool # maximum :: Ord a => Else a -> a # minimum :: Ord a => Else a -> a # sum :: Num a => Else a -> a # product :: Num a => Else a -> a #
Traversable Else Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> Else a -> f (Else b) # sequenceA :: Applicative f => Else (f a) -> f (Else a) # mapM :: Monad m => (a -> m b) -> Else a -> m (Else b) # sequence :: Monad m => Else (m a) -> m (Else a) #
SymbolMatching Else Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy Else -> [Int] showFailure :: Proxy Else -> Node -> String
Unmarshal Else Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match Else) matchers :: B (Int, Match Else)
Eq a => Eq (Else a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: Else a -> Else a -> Bool # (/=) :: Else a -> Else a -> Bool #
Ord a => Ord (Else a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: Else a -> Else a -> Ordering # (<) :: Else a -> Else a -> Bool # (<=) :: Else a -> Else a -> Bool # (>) :: Else a -> Else a -> Bool # (>=) :: Else a -> Else a -> Bool # max :: Else a -> Else a -> Else a # min :: Else a -> Else a -> Else a #
Show a => Show (Else a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> Else a -> ShowS # show :: Else a -> String # showList :: [Else a] -> ShowS #
Generic (Else a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (Else a) :: Type -> Type # Methods from :: Else a -> Rep (Else a) x # to :: Rep (Else a) x -> Else a #
Generic1 Else Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 Else :: k -> Type # Methods from1 :: forall (a :: k). Else a -> Rep1 Else a # to1 :: forall (a :: k). Rep1 Else a -> Else a #
type Rep (Else a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (Else a) = D1 ('MetaData "Else" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Else" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :: (S1 ('MetaSel ('Just "condition") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe (AnonymousSemicolon a))) :: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [(Statement :+: EmptyStatement) a]))))
type Rep1 Else Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 Else = D1 ('MetaData "Else" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Else" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :: (S1 ('MetaSel ('Just "condition") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Maybe :.: Rec1 (Token ";" 15)) :: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) ([] :.: Rec1 (Statement :+: EmptyStatement)))))

data ElementReference a Source #

Constructors

ElementReference
Fields ann :: a object :: (Primary a) extraChildren :: ([] ((:+:) ((:+:) Arg BlockArgument) ((:+:) HashSplatArgument ((:+:) Pair SplatArgument)) a))

Instances

Instances details

Functor ElementReference Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> ElementReference a -> ElementReference b # (<$) :: a -> ElementReference b -> ElementReference a #
Foldable ElementReference Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => ElementReference m -> m # foldMap :: Monoid m => (a -> m) -> ElementReference a -> m # foldMap' :: Monoid m => (a -> m) -> ElementReference a -> m # foldr :: (a -> b -> b) -> b -> ElementReference a -> b # foldr' :: (a -> b -> b) -> b -> ElementReference a -> b # foldl :: (b -> a -> b) -> b -> ElementReference a -> b # foldl' :: (b -> a -> b) -> b -> ElementReference a -> b # foldr1 :: (a -> a -> a) -> ElementReference a -> a # foldl1 :: (a -> a -> a) -> ElementReference a -> a # toList :: ElementReference a -> [a] # null :: ElementReference a -> Bool # length :: ElementReference a -> Int # elem :: Eq a => a -> ElementReference a -> Bool # maximum :: Ord a => ElementReference a -> a # minimum :: Ord a => ElementReference a -> a # sum :: Num a => ElementReference a -> a # product :: Num a => ElementReference a -> a #
Traversable ElementReference Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> ElementReference a -> f (ElementReference b) # sequenceA :: Applicative f => ElementReference (f a) -> f (ElementReference a) # mapM :: Monad m => (a -> m b) -> ElementReference a -> m (ElementReference b) # sequence :: Monad m => ElementReference (m a) -> m (ElementReference a) #
SymbolMatching ElementReference Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy ElementReference -> [Int] showFailure :: Proxy ElementReference -> Node -> String
Unmarshal ElementReference Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match ElementReference) matchers :: B (Int, Match ElementReference)
Eq a => Eq (ElementReference a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: ElementReference a -> ElementReference a -> Bool # (/=) :: ElementReference a -> ElementReference a -> Bool #
Ord a => Ord (ElementReference a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: ElementReference a -> ElementReference a -> Ordering # (<) :: ElementReference a -> ElementReference a -> Bool # (<=) :: ElementReference a -> ElementReference a -> Bool # (>) :: ElementReference a -> ElementReference a -> Bool # (>=) :: ElementReference a -> ElementReference a -> Bool # max :: ElementReference a -> ElementReference a -> ElementReference a # min :: ElementReference a -> ElementReference a -> ElementReference a #
Show a => Show (ElementReference a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> ElementReference a -> ShowS # show :: ElementReference a -> String # showList :: [ElementReference a] -> ShowS #
Generic (ElementReference a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (ElementReference a) :: Type -> Type # Methods from :: ElementReference a -> Rep (ElementReference a) x # to :: Rep (ElementReference a) x -> ElementReference a #
Generic1 ElementReference Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 ElementReference :: k -> Type # Methods from1 :: forall (a :: k). ElementReference a -> Rep1 ElementReference a # to1 :: forall (a :: k). Rep1 ElementReference a -> ElementReference a #
type Rep (ElementReference a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (ElementReference a) = D1 ('MetaData "ElementReference" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "ElementReference" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :: (S1 ('MetaSel ('Just "object") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Primary a)) :: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [((Arg :+: BlockArgument) :+: (HashSplatArgument :+: (Pair :+: SplatArgument))) a]))))
type Rep1 ElementReference Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 ElementReference = D1 ('MetaData "ElementReference" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "ElementReference" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :: (S1 ('MetaSel ('Just "object") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 Primary) :: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) ([] :.: Rec1 ((Arg :+: BlockArgument) :+: (HashSplatArgument :+: (Pair :+: SplatArgument)))))))

data DoBlock a Source #

Constructors

DoBlock
Fields ann :: a extraChildren :: ([] ((:+:) ((:+:) Statement ((:+:) BlockParameters Else)) ((:+:) EmptyStatement ((:+:) Ensure Rescue)) a))

Instances

Instances details

Functor DoBlock Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> DoBlock a -> DoBlock b # (<$) :: a -> DoBlock b -> DoBlock a #
Foldable DoBlock Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => DoBlock m -> m # foldMap :: Monoid m => (a -> m) -> DoBlock a -> m # foldMap' :: Monoid m => (a -> m) -> DoBlock a -> m # foldr :: (a -> b -> b) -> b -> DoBlock a -> b # foldr' :: (a -> b -> b) -> b -> DoBlock a -> b # foldl :: (b -> a -> b) -> b -> DoBlock a -> b # foldl' :: (b -> a -> b) -> b -> DoBlock a -> b # foldr1 :: (a -> a -> a) -> DoBlock a -> a # foldl1 :: (a -> a -> a) -> DoBlock a -> a # toList :: DoBlock a -> [a] # null :: DoBlock a -> Bool # length :: DoBlock a -> Int # elem :: Eq a => a -> DoBlock a -> Bool # maximum :: Ord a => DoBlock a -> a # minimum :: Ord a => DoBlock a -> a # sum :: Num a => DoBlock a -> a # product :: Num a => DoBlock a -> a #
Traversable DoBlock Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> DoBlock a -> f (DoBlock b) # sequenceA :: Applicative f => DoBlock (f a) -> f (DoBlock a) # mapM :: Monad m => (a -> m b) -> DoBlock a -> m (DoBlock b) # sequence :: Monad m => DoBlock (m a) -> m (DoBlock a) #
SymbolMatching DoBlock Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy DoBlock -> [Int] showFailure :: Proxy DoBlock -> Node -> String
Unmarshal DoBlock Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match DoBlock) matchers :: B (Int, Match DoBlock)
Eq a => Eq (DoBlock a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: DoBlock a -> DoBlock a -> Bool # (/=) :: DoBlock a -> DoBlock a -> Bool #
Ord a => Ord (DoBlock a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: DoBlock a -> DoBlock a -> Ordering # (<) :: DoBlock a -> DoBlock a -> Bool # (<=) :: DoBlock a -> DoBlock a -> Bool # (>) :: DoBlock a -> DoBlock a -> Bool # (>=) :: DoBlock a -> DoBlock a -> Bool # max :: DoBlock a -> DoBlock a -> DoBlock a # min :: DoBlock a -> DoBlock a -> DoBlock a #
Show a => Show (DoBlock a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> DoBlock a -> ShowS # show :: DoBlock a -> String # showList :: [DoBlock a] -> ShowS #
Generic (DoBlock a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (DoBlock a) :: Type -> Type # Methods from :: DoBlock a -> Rep (DoBlock a) x # to :: Rep (DoBlock a) x -> DoBlock a #
Generic1 DoBlock Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 DoBlock :: k -> Type # Methods from1 :: forall (a :: k). DoBlock a -> Rep1 DoBlock a # to1 :: forall (a :: k). Rep1 DoBlock a -> DoBlock a #
type Rep (DoBlock a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (DoBlock a) = D1 ('MetaData "DoBlock" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "DoBlock" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [((Statement :+: (BlockParameters :+: Else)) :+: (EmptyStatement :+: (Ensure :+: Rescue))) a])))
type Rep1 DoBlock Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 DoBlock = D1 ('MetaData "DoBlock" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "DoBlock" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) ([] :.: Rec1 ((Statement :+: (BlockParameters :+: Else)) :+: (EmptyStatement :+: (Ensure :+: Rescue))))))

data Do a Source #

Constructors

Do
Fields ann :: a extraChildren :: ([] ((:+:) Statement EmptyStatement a))

Instances

Instances details

Functor Do Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> Do a -> Do b # (<$) :: a -> Do b -> Do a #
Foldable Do Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => Do m -> m # foldMap :: Monoid m => (a -> m) -> Do a -> m # foldMap' :: Monoid m => (a -> m) -> Do a -> m # foldr :: (a -> b -> b) -> b -> Do a -> b # foldr' :: (a -> b -> b) -> b -> Do a -> b # foldl :: (b -> a -> b) -> b -> Do a -> b # foldl' :: (b -> a -> b) -> b -> Do a -> b # foldr1 :: (a -> a -> a) -> Do a -> a # foldl1 :: (a -> a -> a) -> Do a -> a # toList :: Do a -> [a] # null :: Do a -> Bool # length :: Do a -> Int # elem :: Eq a => a -> Do a -> Bool # maximum :: Ord a => Do a -> a # minimum :: Ord a => Do a -> a # sum :: Num a => Do a -> a # product :: Num a => Do a -> a #
Traversable Do Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> Do a -> f (Do b) # sequenceA :: Applicative f => Do (f a) -> f (Do a) # mapM :: Monad m => (a -> m b) -> Do a -> m (Do b) # sequence :: Monad m => Do (m a) -> m (Do a) #
SymbolMatching Do Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy Do -> [Int] showFailure :: Proxy Do -> Node -> String
Unmarshal Do Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match Do) matchers :: B (Int, Match Do)
Eq a => Eq (Do a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: Do a -> Do a -> Bool # (/=) :: Do a -> Do a -> Bool #
Ord a => Ord (Do a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: Do a -> Do a -> Ordering # (<) :: Do a -> Do a -> Bool # (<=) :: Do a -> Do a -> Bool # (>) :: Do a -> Do a -> Bool # (>=) :: Do a -> Do a -> Bool # max :: Do a -> Do a -> Do a # min :: Do a -> Do a -> Do a #
Show a => Show (Do a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> Do a -> ShowS # show :: Do a -> String # showList :: [Do a] -> ShowS #
Generic (Do a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (Do a) :: Type -> Type # Methods from :: Do a -> Rep (Do a) x # to :: Rep (Do a) x -> Do a #
Generic1 Do Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 Do :: k -> Type # Methods from1 :: forall (a :: k). Do a -> Rep1 Do a # to1 :: forall (a :: k). Rep1 Do a -> Do a #
type Rep (Do a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (Do a) = D1 ('MetaData "Do" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Do" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [(Statement :+: EmptyStatement) a])))
type Rep1 Do Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 Do = D1 ('MetaData "Do" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Do" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) ([] :.: Rec1 (Statement :+: EmptyStatement))))

data DestructuredParameter a Source #

Constructors

DestructuredParameter
Fields ann :: a extraChildren :: ([] ((:+:) ((:+:) BlockParameter ((:+:) DestructuredParameter HashSplatParameter)) ((:+:) ((:+:) Identifier KeywordParameter) ((:+:) OptionalParameter SplatParameter)) a))

Instances

Instances details

Functor DestructuredParameter Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> DestructuredParameter a -> DestructuredParameter b # (<$) :: a -> DestructuredParameter b -> DestructuredParameter a #
Foldable DestructuredParameter Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => DestructuredParameter m -> m # foldMap :: Monoid m => (a -> m) -> DestructuredParameter a -> m # foldMap' :: Monoid m => (a -> m) -> DestructuredParameter a -> m # foldr :: (a -> b -> b) -> b -> DestructuredParameter a -> b # foldr' :: (a -> b -> b) -> b -> DestructuredParameter a -> b # foldl :: (b -> a -> b) -> b -> DestructuredParameter a -> b # foldl' :: (b -> a -> b) -> b -> DestructuredParameter a -> b # foldr1 :: (a -> a -> a) -> DestructuredParameter a -> a # foldl1 :: (a -> a -> a) -> DestructuredParameter a -> a # toList :: DestructuredParameter a -> [a] # null :: DestructuredParameter a -> Bool # length :: DestructuredParameter a -> Int # elem :: Eq a => a -> DestructuredParameter a -> Bool # maximum :: Ord a => DestructuredParameter a -> a # minimum :: Ord a => DestructuredParameter a -> a # sum :: Num a => DestructuredParameter a -> a # product :: Num a => DestructuredParameter a -> a #
Traversable DestructuredParameter Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> DestructuredParameter a -> f (DestructuredParameter b) # sequenceA :: Applicative f => DestructuredParameter (f a) -> f (DestructuredParameter a) # mapM :: Monad m => (a -> m b) -> DestructuredParameter a -> m (DestructuredParameter b) # sequence :: Monad m => DestructuredParameter (m a) -> m (DestructuredParameter a) #
SymbolMatching DestructuredParameter Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy DestructuredParameter -> [Int] showFailure :: Proxy DestructuredParameter -> Node -> String
Unmarshal DestructuredParameter Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match DestructuredParameter) matchers :: B (Int, Match DestructuredParameter)
Eq a => Eq (DestructuredParameter a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: DestructuredParameter a -> DestructuredParameter a -> Bool # (/=) :: DestructuredParameter a -> DestructuredParameter a -> Bool #
Ord a => Ord (DestructuredParameter a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: DestructuredParameter a -> DestructuredParameter a -> Ordering # (<) :: DestructuredParameter a -> DestructuredParameter a -> Bool # (<=) :: DestructuredParameter a -> DestructuredParameter a -> Bool # (>) :: DestructuredParameter a -> DestructuredParameter a -> Bool # (>=) :: DestructuredParameter a -> DestructuredParameter a -> Bool # max :: DestructuredParameter a -> DestructuredParameter a -> DestructuredParameter a # min :: DestructuredParameter a -> DestructuredParameter a -> DestructuredParameter a #
Show a => Show (DestructuredParameter a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> DestructuredParameter a -> ShowS # show :: DestructuredParameter a -> String # showList :: [DestructuredParameter a] -> ShowS #
Generic (DestructuredParameter a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (DestructuredParameter a) :: Type -> Type # Methods from :: DestructuredParameter a -> Rep (DestructuredParameter a) x # to :: Rep (DestructuredParameter a) x -> DestructuredParameter a #
Generic1 DestructuredParameter Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 DestructuredParameter :: k -> Type # Methods from1 :: forall (a :: k). DestructuredParameter a -> Rep1 DestructuredParameter a # to1 :: forall (a :: k). Rep1 DestructuredParameter a -> DestructuredParameter a #
type Rep (DestructuredParameter a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (DestructuredParameter a) = D1 ('MetaData "DestructuredParameter" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "DestructuredParameter" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [((BlockParameter :+: (DestructuredParameter :+: HashSplatParameter)) :+: ((Identifier :+: KeywordParameter) :+: (OptionalParameter :+: SplatParameter))) a])))
type Rep1 DestructuredParameter Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 DestructuredParameter = D1 ('MetaData "DestructuredParameter" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "DestructuredParameter" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) ([] :.: Rec1 ((BlockParameter :+: (DestructuredParameter :+: HashSplatParameter)) :+: ((Identifier :+: KeywordParameter) :+: (OptionalParameter :+: SplatParameter))))))

data DestructuredLeftAssignment a Source #

Constructors

DestructuredLeftAssignment
Fields ann :: a extraChildren :: (NonEmpty ((:+:) Lhs ((:+:) DestructuredLeftAssignment RestAssignment) a))

Instances

Instances details

Functor DestructuredLeftAssignment Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> DestructuredLeftAssignment a -> DestructuredLeftAssignment b # (<$) :: a -> DestructuredLeftAssignment b -> DestructuredLeftAssignment a #
Foldable DestructuredLeftAssignment Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => DestructuredLeftAssignment m -> m # foldMap :: Monoid m => (a -> m) -> DestructuredLeftAssignment a -> m # foldMap' :: Monoid m => (a -> m) -> DestructuredLeftAssignment a -> m # foldr :: (a -> b -> b) -> b -> DestructuredLeftAssignment a -> b # foldr' :: (a -> b -> b) -> b -> DestructuredLeftAssignment a -> b # foldl :: (b -> a -> b) -> b -> DestructuredLeftAssignment a -> b # foldl' :: (b -> a -> b) -> b -> DestructuredLeftAssignment a -> b # foldr1 :: (a -> a -> a) -> DestructuredLeftAssignment a -> a # foldl1 :: (a -> a -> a) -> DestructuredLeftAssignment a -> a # toList :: DestructuredLeftAssignment a -> [a] # null :: DestructuredLeftAssignment a -> Bool # length :: DestructuredLeftAssignment a -> Int # elem :: Eq a => a -> DestructuredLeftAssignment a -> Bool # maximum :: Ord a => DestructuredLeftAssignment a -> a # minimum :: Ord a => DestructuredLeftAssignment a -> a # sum :: Num a => DestructuredLeftAssignment a -> a # product :: Num a => DestructuredLeftAssignment a -> a #
Traversable DestructuredLeftAssignment Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> DestructuredLeftAssignment a -> f (DestructuredLeftAssignment b) # sequenceA :: Applicative f => DestructuredLeftAssignment (f a) -> f (DestructuredLeftAssignment a) # mapM :: Monad m => (a -> m b) -> DestructuredLeftAssignment a -> m (DestructuredLeftAssignment b) # sequence :: Monad m => DestructuredLeftAssignment (m a) -> m (DestructuredLeftAssignment a) #
SymbolMatching DestructuredLeftAssignment Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy DestructuredLeftAssignment -> [Int] showFailure :: Proxy DestructuredLeftAssignment -> Node -> String
Unmarshal DestructuredLeftAssignment Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match DestructuredLeftAssignment) matchers :: B (Int, Match DestructuredLeftAssignment)
Eq a => Eq (DestructuredLeftAssignment a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: DestructuredLeftAssignment a -> DestructuredLeftAssignment a -> Bool # (/=) :: DestructuredLeftAssignment a -> DestructuredLeftAssignment a -> Bool #
Ord a => Ord (DestructuredLeftAssignment a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: DestructuredLeftAssignment a -> DestructuredLeftAssignment a -> Ordering # (<) :: DestructuredLeftAssignment a -> DestructuredLeftAssignment a -> Bool # (<=) :: DestructuredLeftAssignment a -> DestructuredLeftAssignment a -> Bool # (>) :: DestructuredLeftAssignment a -> DestructuredLeftAssignment a -> Bool # (>=) :: DestructuredLeftAssignment a -> DestructuredLeftAssignment a -> Bool # max :: DestructuredLeftAssignment a -> DestructuredLeftAssignment a -> DestructuredLeftAssignment a # min :: DestructuredLeftAssignment a -> DestructuredLeftAssignment a -> DestructuredLeftAssignment a #
Show a => Show (DestructuredLeftAssignment a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> DestructuredLeftAssignment a -> ShowS # show :: DestructuredLeftAssignment a -> String # showList :: [DestructuredLeftAssignment a] -> ShowS #
Generic (DestructuredLeftAssignment a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (DestructuredLeftAssignment a) :: Type -> Type # Methods from :: DestructuredLeftAssignment a -> Rep (DestructuredLeftAssignment a) x # to :: Rep (DestructuredLeftAssignment a) x -> DestructuredLeftAssignment a #
Generic1 DestructuredLeftAssignment Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 DestructuredLeftAssignment :: k -> Type # Methods from1 :: forall (a :: k). DestructuredLeftAssignment a -> Rep1 DestructuredLeftAssignment a # to1 :: forall (a :: k). Rep1 DestructuredLeftAssignment a -> DestructuredLeftAssignment a #
type Rep (DestructuredLeftAssignment a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (DestructuredLeftAssignment a) = D1 ('MetaData "DestructuredLeftAssignment" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "DestructuredLeftAssignment" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (NonEmpty ((Lhs :+: (DestructuredLeftAssignment :+: RestAssignment)) a)))))
type Rep1 DestructuredLeftAssignment Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 DestructuredLeftAssignment = D1 ('MetaData "DestructuredLeftAssignment" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "DestructuredLeftAssignment" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (NonEmpty :.: Rec1 (Lhs :+: (DestructuredLeftAssignment :+: RestAssignment)))))

data Conditional a Source #

Constructors

Conditional
Fields ann :: a alternative :: (Arg a) consequence :: (Arg a) condition :: (Arg a)

Instances

Instances details

Functor Conditional Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> Conditional a -> Conditional b # (<$) :: a -> Conditional b -> Conditional a #
Foldable Conditional Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => Conditional m -> m # foldMap :: Monoid m => (a -> m) -> Conditional a -> m # foldMap' :: Monoid m => (a -> m) -> Conditional a -> m # foldr :: (a -> b -> b) -> b -> Conditional a -> b # foldr' :: (a -> b -> b) -> b -> Conditional a -> b # foldl :: (b -> a -> b) -> b -> Conditional a -> b # foldl' :: (b -> a -> b) -> b -> Conditional a -> b # foldr1 :: (a -> a -> a) -> Conditional a -> a # foldl1 :: (a -> a -> a) -> Conditional a -> a # toList :: Conditional a -> [a] # null :: Conditional a -> Bool # length :: Conditional a -> Int # elem :: Eq a => a -> Conditional a -> Bool # maximum :: Ord a => Conditional a -> a # minimum :: Ord a => Conditional a -> a # sum :: Num a => Conditional a -> a # product :: Num a => Conditional a -> a #
Traversable Conditional Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> Conditional a -> f (Conditional b) # sequenceA :: Applicative f => Conditional (f a) -> f (Conditional a) # mapM :: Monad m => (a -> m b) -> Conditional a -> m (Conditional b) # sequence :: Monad m => Conditional (m a) -> m (Conditional a) #
SymbolMatching Conditional Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy Conditional -> [Int] showFailure :: Proxy Conditional -> Node -> String
Unmarshal Conditional Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match Conditional) matchers :: B (Int, Match Conditional)
Eq a => Eq (Conditional a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: Conditional a -> Conditional a -> Bool # (/=) :: Conditional a -> Conditional a -> Bool #
Ord a => Ord (Conditional a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: Conditional a -> Conditional a -> Ordering # (<) :: Conditional a -> Conditional a -> Bool # (<=) :: Conditional a -> Conditional a -> Bool # (>) :: Conditional a -> Conditional a -> Bool # (>=) :: Conditional a -> Conditional a -> Bool # max :: Conditional a -> Conditional a -> Conditional a # min :: Conditional a -> Conditional a -> Conditional a #
Show a => Show (Conditional a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> Conditional a -> ShowS # show :: Conditional a -> String # showList :: [Conditional a] -> ShowS #
Generic (Conditional a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (Conditional a) :: Type -> Type # Methods from :: Conditional a -> Rep (Conditional a) x # to :: Rep (Conditional a) x -> Conditional a #
Generic1 Conditional Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 Conditional :: k -> Type # Methods from1 :: forall (a :: k). Conditional a -> Rep1 Conditional a # to1 :: forall (a :: k). Rep1 Conditional a -> Conditional a #
type Rep (Conditional a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (Conditional a) = D1 ('MetaData "Conditional" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Conditional" 'PrefixI 'True) ((S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :: S1 ('MetaSel ('Just "alternative") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Arg a))) :: (S1 ('MetaSel ('Just "consequence") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Arg a)) :*: S1 ('MetaSel ('Just "condition") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Arg a)))))
type Rep1 Conditional Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 Conditional = D1 ('MetaData "Conditional" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Conditional" 'PrefixI 'True) ((S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :: S1 ('MetaSel ('Just "alternative") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 Arg)) :: (S1 ('MetaSel ('Just "consequence") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 Arg) :*: S1 ('MetaSel ('Just "condition") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 Arg))))

data Class a Source #

Constructors

Class
Fields ann :: a name :: ((:+:) Constant ScopeResolution a) extraChildren :: ([] ((:+:) ((:+:) Statement ((:+:) Else EmptyStatement)) ((:+:) Ensure ((:+:) Rescue Superclass)) a))

Instances

Instances details

Functor Class Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> Class a -> Class b # (<$) :: a -> Class b -> Class a #
Foldable Class Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => Class m -> m # foldMap :: Monoid m => (a -> m) -> Class a -> m # foldMap' :: Monoid m => (a -> m) -> Class a -> m # foldr :: (a -> b -> b) -> b -> Class a -> b # foldr' :: (a -> b -> b) -> b -> Class a -> b # foldl :: (b -> a -> b) -> b -> Class a -> b # foldl' :: (b -> a -> b) -> b -> Class a -> b # foldr1 :: (a -> a -> a) -> Class a -> a # foldl1 :: (a -> a -> a) -> Class a -> a # toList :: Class a -> [a] # null :: Class a -> Bool # length :: Class a -> Int # elem :: Eq a => a -> Class a -> Bool # maximum :: Ord a => Class a -> a # minimum :: Ord a => Class a -> a # sum :: Num a => Class a -> a # product :: Num a => Class a -> a #
Traversable Class Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> Class a -> f (Class b) # sequenceA :: Applicative f => Class (f a) -> f (Class a) # mapM :: Monad m => (a -> m b) -> Class a -> m (Class b) # sequence :: Monad m => Class (m a) -> m (Class a) #
SymbolMatching Class Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy Class -> [Int] showFailure :: Proxy Class -> Node -> String
Unmarshal Class Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match Class) matchers :: B (Int, Match Class)
Eq a => Eq (Class a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: Class a -> Class a -> Bool # (/=) :: Class a -> Class a -> Bool #
Ord a => Ord (Class a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: Class a -> Class a -> Ordering # (<) :: Class a -> Class a -> Bool # (<=) :: Class a -> Class a -> Bool # (>) :: Class a -> Class a -> Bool # (>=) :: Class a -> Class a -> Bool # max :: Class a -> Class a -> Class a # min :: Class a -> Class a -> Class a #
Show a => Show (Class a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> Class a -> ShowS # show :: Class a -> String # showList :: [Class a] -> ShowS #
Generic (Class a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (Class a) :: Type -> Type # Methods from :: Class a -> Rep (Class a) x # to :: Rep (Class a) x -> Class a #
Generic1 Class Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 Class :: k -> Type # Methods from1 :: forall (a :: k). Class a -> Rep1 Class a # to1 :: forall (a :: k). Rep1 Class a -> Class a #
type Rep (Class a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (Class a) = D1 ('MetaData "Class" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Class" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :: (S1 ('MetaSel ('Just "name") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ((Constant :+: ScopeResolution) a)) :: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [((Statement :+: (Else :+: EmptyStatement)) :+: (Ensure :+: (Rescue :+: Superclass))) a]))))
type Rep1 Class Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 Class = D1 ('MetaData "Class" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Class" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :: (S1 ('MetaSel ('Just "name") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 (Constant :+: ScopeResolution)) :: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) ([] :.: Rec1 ((Statement :+: (Else :+: EmptyStatement)) :+: (Ensure :+: (Rescue :+: Superclass)))))))

data ChainedString a Source #

Constructors

ChainedString
Fields ann :: a extraChildren :: (NonEmpty (String a))

Instances

Instances details

Functor ChainedString Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> ChainedString a -> ChainedString b # (<$) :: a -> ChainedString b -> ChainedString a #
Foldable ChainedString Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => ChainedString m -> m # foldMap :: Monoid m => (a -> m) -> ChainedString a -> m # foldMap' :: Monoid m => (a -> m) -> ChainedString a -> m # foldr :: (a -> b -> b) -> b -> ChainedString a -> b # foldr' :: (a -> b -> b) -> b -> ChainedString a -> b # foldl :: (b -> a -> b) -> b -> ChainedString a -> b # foldl' :: (b -> a -> b) -> b -> ChainedString a -> b # foldr1 :: (a -> a -> a) -> ChainedString a -> a # foldl1 :: (a -> a -> a) -> ChainedString a -> a # toList :: ChainedString a -> [a] # null :: ChainedString a -> Bool # length :: ChainedString a -> Int # elem :: Eq a => a -> ChainedString a -> Bool # maximum :: Ord a => ChainedString a -> a # minimum :: Ord a => ChainedString a -> a # sum :: Num a => ChainedString a -> a # product :: Num a => ChainedString a -> a #
Traversable ChainedString Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> ChainedString a -> f (ChainedString b) # sequenceA :: Applicative f => ChainedString (f a) -> f (ChainedString a) # mapM :: Monad m => (a -> m b) -> ChainedString a -> m (ChainedString b) # sequence :: Monad m => ChainedString (m a) -> m (ChainedString a) #
SymbolMatching ChainedString Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy ChainedString -> [Int] showFailure :: Proxy ChainedString -> Node -> String
Unmarshal ChainedString Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match ChainedString) matchers :: B (Int, Match ChainedString)
Eq a => Eq (ChainedString a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: ChainedString a -> ChainedString a -> Bool # (/=) :: ChainedString a -> ChainedString a -> Bool #
Ord a => Ord (ChainedString a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: ChainedString a -> ChainedString a -> Ordering # (<) :: ChainedString a -> ChainedString a -> Bool # (<=) :: ChainedString a -> ChainedString a -> Bool # (>) :: ChainedString a -> ChainedString a -> Bool # (>=) :: ChainedString a -> ChainedString a -> Bool # max :: ChainedString a -> ChainedString a -> ChainedString a # min :: ChainedString a -> ChainedString a -> ChainedString a #
Show a => Show (ChainedString a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> ChainedString a -> ShowS # show :: ChainedString a -> String # showList :: [ChainedString a] -> ShowS #
Generic (ChainedString a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (ChainedString a) :: Type -> Type # Methods from :: ChainedString a -> Rep (ChainedString a) x # to :: Rep (ChainedString a) x -> ChainedString a #
Generic1 ChainedString Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 ChainedString :: k -> Type # Methods from1 :: forall (a :: k). ChainedString a -> Rep1 ChainedString a # to1 :: forall (a :: k). Rep1 ChainedString a -> ChainedString a #
type Rep (ChainedString a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (ChainedString a) = D1 ('MetaData "ChainedString" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "ChainedString" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (NonEmpty (String a)))))
type Rep1 ChainedString Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 ChainedString = D1 ('MetaData "ChainedString" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "ChainedString" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (NonEmpty :.: Rec1 String)))

data Case a Source #

Constructors

Case
Fields ann :: a value :: (Maybe (Arg a)) extraChildren :: ([] ((:+:) Else When a))

Instances

Instances details

Functor Case Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> Case a -> Case b # (<$) :: a -> Case b -> Case a #
Foldable Case Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => Case m -> m # foldMap :: Monoid m => (a -> m) -> Case a -> m # foldMap' :: Monoid m => (a -> m) -> Case a -> m # foldr :: (a -> b -> b) -> b -> Case a -> b # foldr' :: (a -> b -> b) -> b -> Case a -> b # foldl :: (b -> a -> b) -> b -> Case a -> b # foldl' :: (b -> a -> b) -> b -> Case a -> b # foldr1 :: (a -> a -> a) -> Case a -> a # foldl1 :: (a -> a -> a) -> Case a -> a # toList :: Case a -> [a] # null :: Case a -> Bool # length :: Case a -> Int # elem :: Eq a => a -> Case a -> Bool # maximum :: Ord a => Case a -> a # minimum :: Ord a => Case a -> a # sum :: Num a => Case a -> a # product :: Num a => Case a -> a #
Traversable Case Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> Case a -> f (Case b) # sequenceA :: Applicative f => Case (f a) -> f (Case a) # mapM :: Monad m => (a -> m b) -> Case a -> m (Case b) # sequence :: Monad m => Case (m a) -> m (Case a) #
SymbolMatching Case Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy Case -> [Int] showFailure :: Proxy Case -> Node -> String
Unmarshal Case Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match Case) matchers :: B (Int, Match Case)
Eq a => Eq (Case a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: Case a -> Case a -> Bool # (/=) :: Case a -> Case a -> Bool #
Ord a => Ord (Case a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: Case a -> Case a -> Ordering # (<) :: Case a -> Case a -> Bool # (<=) :: Case a -> Case a -> Bool # (>) :: Case a -> Case a -> Bool # (>=) :: Case a -> Case a -> Bool # max :: Case a -> Case a -> Case a # min :: Case a -> Case a -> Case a #
Show a => Show (Case a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> Case a -> ShowS # show :: Case a -> String # showList :: [Case a] -> ShowS #
Generic (Case a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (Case a) :: Type -> Type # Methods from :: Case a -> Rep (Case a) x # to :: Rep (Case a) x -> Case a #
Generic1 Case Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 Case :: k -> Type # Methods from1 :: forall (a :: k). Case a -> Rep1 Case a # to1 :: forall (a :: k). Rep1 Case a -> Case a #
type Rep (Case a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (Case a) = D1 ('MetaData "Case" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Case" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :: (S1 ('MetaSel ('Just "value") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe (Arg a))) :: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [(Else :+: When) a]))))
type Rep1 Case Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 Case = D1 ('MetaData "Case" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Case" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :: (S1 ('MetaSel ('Just "value") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Maybe :.: Rec1 Arg) :: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) ([] :.: Rec1 (Else :+: When)))))

data Call a Source #

Constructors

Call
Fields ann :: a receiver :: (Primary a) method :: ((:+:) ((:+:) ArgumentList Constant) ((:+:) Identifier Operator) a)

Instances

Instances details

Functor Call Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> Call a -> Call b # (<$) :: a -> Call b -> Call a #
Foldable Call Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => Call m -> m # foldMap :: Monoid m => (a -> m) -> Call a -> 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 Source #
Instance details Defined in TreeSitter.Ruby.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 Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy Call -> [Int] showFailure :: Proxy Call -> Node -> String
Unmarshal Call Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match Call) matchers :: B (Int, Match Call)
Eq a => Eq (Call a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: Call a -> Call a -> Bool # (/=) :: Call a -> Call a -> Bool #
Ord a => Ord (Call a) Source #
Instance details Defined in TreeSitter.Ruby.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) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> Call a -> ShowS # show :: Call a -> String # showList :: [Call a] -> ShowS #
Generic (Call a) Source #
Instance details Defined in TreeSitter.Ruby.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 Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 Call :: k -> Type # Methods from1 :: forall (a :: k). Call a -> Rep1 Call a # to1 :: forall (a :: k). Rep1 Call a -> Call a #
type Rep (Call a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (Call a) = D1 ('MetaData "Call" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Call" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :: (S1 ('MetaSel ('Just "receiver") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Primary a)) :: S1 ('MetaSel ('Just "method") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (((ArgumentList :+: Constant) :+: (Identifier :+: Operator)) a)))))
type Rep1 Call Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 Call = D1 ('MetaData "Call" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Call" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :: (S1 ('MetaSel ('Just "receiver") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 Primary) :: S1 ('MetaSel ('Just "method") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 ((ArgumentList :+: Constant) :+: (Identifier :+: Operator))))))

data Break a Source #

Constructors

Break
Fields ann :: a extraChildren :: (Maybe (ArgumentList a))

Instances

Instances details

Functor Break Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> Break a -> Break b # (<$) :: a -> Break b -> Break a #
Foldable Break Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => Break m -> m # foldMap :: Monoid m => (a -> m) -> Break a -> m # foldMap' :: Monoid m => (a -> m) -> Break a -> m # foldr :: (a -> b -> b) -> b -> Break a -> b # foldr' :: (a -> b -> b) -> b -> Break a -> b # foldl :: (b -> a -> b) -> b -> Break a -> b # foldl' :: (b -> a -> b) -> b -> Break a -> b # foldr1 :: (a -> a -> a) -> Break a -> a # foldl1 :: (a -> a -> a) -> Break a -> a # toList :: Break a -> [a] # null :: Break a -> Bool # length :: Break a -> Int # elem :: Eq a => a -> Break a -> Bool # maximum :: Ord a => Break a -> a # minimum :: Ord a => Break a -> a # sum :: Num a => Break a -> a # product :: Num a => Break a -> a #
Traversable Break Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> Break a -> f (Break b) # sequenceA :: Applicative f => Break (f a) -> f (Break a) # mapM :: Monad m => (a -> m b) -> Break a -> m (Break b) # sequence :: Monad m => Break (m a) -> m (Break a) #
SymbolMatching Break Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy Break -> [Int] showFailure :: Proxy Break -> Node -> String
Unmarshal Break Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match Break) matchers :: B (Int, Match Break)
Eq a => Eq (Break a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: Break a -> Break a -> Bool # (/=) :: Break a -> Break a -> Bool #
Ord a => Ord (Break a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: Break a -> Break a -> Ordering # (<) :: Break a -> Break a -> Bool # (<=) :: Break a -> Break a -> Bool # (>) :: Break a -> Break a -> Bool # (>=) :: Break a -> Break a -> Bool # max :: Break a -> Break a -> Break a # min :: Break a -> Break a -> Break a #
Show a => Show (Break a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> Break a -> ShowS # show :: Break a -> String # showList :: [Break a] -> ShowS #
Generic (Break a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (Break a) :: Type -> Type # Methods from :: Break a -> Rep (Break a) x # to :: Rep (Break a) x -> Break a #
Generic1 Break Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 Break :: k -> Type # Methods from1 :: forall (a :: k). Break a -> Rep1 Break a # to1 :: forall (a :: k). Rep1 Break a -> Break a #
type Rep (Break a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (Break a) = D1 ('MetaData "Break" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Break" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe (ArgumentList a)))))
type Rep1 Break Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 Break = D1 ('MetaData "Break" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Break" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Maybe :.: Rec1 ArgumentList)))

data BlockParameters a Source #

Constructors

BlockParameters
Fields ann :: a extraChildren :: ([] ((:+:) ((:+:) BlockParameter ((:+:) DestructuredParameter HashSplatParameter)) ((:+:) ((:+:) Identifier KeywordParameter) ((:+:) OptionalParameter SplatParameter)) a))

Instances

Instances details

Functor BlockParameters Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> BlockParameters a -> BlockParameters b # (<$) :: a -> BlockParameters b -> BlockParameters a #
Foldable BlockParameters Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => BlockParameters m -> m # foldMap :: Monoid m => (a -> m) -> BlockParameters a -> m # foldMap' :: Monoid m => (a -> m) -> BlockParameters a -> m # foldr :: (a -> b -> b) -> b -> BlockParameters a -> b # foldr' :: (a -> b -> b) -> b -> BlockParameters a -> b # foldl :: (b -> a -> b) -> b -> BlockParameters a -> b # foldl' :: (b -> a -> b) -> b -> BlockParameters a -> b # foldr1 :: (a -> a -> a) -> BlockParameters a -> a # foldl1 :: (a -> a -> a) -> BlockParameters a -> a # toList :: BlockParameters a -> [a] # null :: BlockParameters a -> Bool # length :: BlockParameters a -> Int # elem :: Eq a => a -> BlockParameters a -> Bool # maximum :: Ord a => BlockParameters a -> a # minimum :: Ord a => BlockParameters a -> a # sum :: Num a => BlockParameters a -> a # product :: Num a => BlockParameters a -> a #
Traversable BlockParameters Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> BlockParameters a -> f (BlockParameters b) # sequenceA :: Applicative f => BlockParameters (f a) -> f (BlockParameters a) # mapM :: Monad m => (a -> m b) -> BlockParameters a -> m (BlockParameters b) # sequence :: Monad m => BlockParameters (m a) -> m (BlockParameters a) #
SymbolMatching BlockParameters Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy BlockParameters -> [Int] showFailure :: Proxy BlockParameters -> Node -> String
Unmarshal BlockParameters Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match BlockParameters) matchers :: B (Int, Match BlockParameters)
Eq a => Eq (BlockParameters a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: BlockParameters a -> BlockParameters a -> Bool # (/=) :: BlockParameters a -> BlockParameters a -> Bool #
Ord a => Ord (BlockParameters a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: BlockParameters a -> BlockParameters a -> Ordering # (<) :: BlockParameters a -> BlockParameters a -> Bool # (<=) :: BlockParameters a -> BlockParameters a -> Bool # (>) :: BlockParameters a -> BlockParameters a -> Bool # (>=) :: BlockParameters a -> BlockParameters a -> Bool # max :: BlockParameters a -> BlockParameters a -> BlockParameters a # min :: BlockParameters a -> BlockParameters a -> BlockParameters a #
Show a => Show (BlockParameters a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> BlockParameters a -> ShowS # show :: BlockParameters a -> String # showList :: [BlockParameters a] -> ShowS #
Generic (BlockParameters a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (BlockParameters a) :: Type -> Type # Methods from :: BlockParameters a -> Rep (BlockParameters a) x # to :: Rep (BlockParameters a) x -> BlockParameters a #
Generic1 BlockParameters Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 BlockParameters :: k -> Type # Methods from1 :: forall (a :: k). BlockParameters a -> Rep1 BlockParameters a # to1 :: forall (a :: k). Rep1 BlockParameters a -> BlockParameters a #
type Rep (BlockParameters a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (BlockParameters a) = D1 ('MetaData "BlockParameters" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "BlockParameters" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [((BlockParameter :+: (DestructuredParameter :+: HashSplatParameter)) :+: ((Identifier :+: KeywordParameter) :+: (OptionalParameter :+: SplatParameter))) a])))
type Rep1 BlockParameters Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 BlockParameters = D1 ('MetaData "BlockParameters" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "BlockParameters" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) ([] :.: Rec1 ((BlockParameter :+: (DestructuredParameter :+: HashSplatParameter)) :+: ((Identifier :+: KeywordParameter) :+: (OptionalParameter :+: SplatParameter))))))

data BlockParameter a Source #

Constructors

BlockParameter
Fields ann :: a name :: (Identifier a)

Instances

Instances details

Functor BlockParameter Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> BlockParameter a -> BlockParameter b # (<$) :: a -> BlockParameter b -> BlockParameter a #
Foldable BlockParameter Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => BlockParameter m -> m # foldMap :: Monoid m => (a -> m) -> BlockParameter a -> m # foldMap' :: Monoid m => (a -> m) -> BlockParameter a -> m # foldr :: (a -> b -> b) -> b -> BlockParameter a -> b # foldr' :: (a -> b -> b) -> b -> BlockParameter a -> b # foldl :: (b -> a -> b) -> b -> BlockParameter a -> b # foldl' :: (b -> a -> b) -> b -> BlockParameter a -> b # foldr1 :: (a -> a -> a) -> BlockParameter a -> a # foldl1 :: (a -> a -> a) -> BlockParameter a -> a # toList :: BlockParameter a -> [a] # null :: BlockParameter a -> Bool # length :: BlockParameter a -> Int # elem :: Eq a => a -> BlockParameter a -> Bool # maximum :: Ord a => BlockParameter a -> a # minimum :: Ord a => BlockParameter a -> a # sum :: Num a => BlockParameter a -> a # product :: Num a => BlockParameter a -> a #
Traversable BlockParameter Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> BlockParameter a -> f (BlockParameter b) # sequenceA :: Applicative f => BlockParameter (f a) -> f (BlockParameter a) # mapM :: Monad m => (a -> m b) -> BlockParameter a -> m (BlockParameter b) # sequence :: Monad m => BlockParameter (m a) -> m (BlockParameter a) #
SymbolMatching BlockParameter Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy BlockParameter -> [Int] showFailure :: Proxy BlockParameter -> Node -> String
Unmarshal BlockParameter Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match BlockParameter) matchers :: B (Int, Match BlockParameter)
Eq a => Eq (BlockParameter a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: BlockParameter a -> BlockParameter a -> Bool # (/=) :: BlockParameter a -> BlockParameter a -> Bool #
Ord a => Ord (BlockParameter a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: BlockParameter a -> BlockParameter a -> Ordering # (<) :: BlockParameter a -> BlockParameter a -> Bool # (<=) :: BlockParameter a -> BlockParameter a -> Bool # (>) :: BlockParameter a -> BlockParameter a -> Bool # (>=) :: BlockParameter a -> BlockParameter a -> Bool # max :: BlockParameter a -> BlockParameter a -> BlockParameter a # min :: BlockParameter a -> BlockParameter a -> BlockParameter a #
Show a => Show (BlockParameter a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> BlockParameter a -> ShowS # show :: BlockParameter a -> String # showList :: [BlockParameter a] -> ShowS #
Generic (BlockParameter a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (BlockParameter a) :: Type -> Type # Methods from :: BlockParameter a -> Rep (BlockParameter a) x # to :: Rep (BlockParameter a) x -> BlockParameter a #
Generic1 BlockParameter Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 BlockParameter :: k -> Type # Methods from1 :: forall (a :: k). BlockParameter a -> Rep1 BlockParameter a # to1 :: forall (a :: k). Rep1 BlockParameter a -> BlockParameter a #
type Rep (BlockParameter a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (BlockParameter a) = D1 ('MetaData "BlockParameter" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "BlockParameter" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "name") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Identifier a))))
type Rep1 BlockParameter Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 BlockParameter = D1 ('MetaData "BlockParameter" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "BlockParameter" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Just "name") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 Identifier)))

data BlockArgument a Source #

Constructors

BlockArgument
Fields ann :: a extraChildren :: (Arg a)

Instances

Instances details

Functor BlockArgument Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> BlockArgument a -> BlockArgument b # (<$) :: a -> BlockArgument b -> BlockArgument a #
Foldable BlockArgument Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => BlockArgument m -> m # foldMap :: Monoid m => (a -> m) -> BlockArgument a -> m # foldMap' :: Monoid m => (a -> m) -> BlockArgument a -> m # foldr :: (a -> b -> b) -> b -> BlockArgument a -> b # foldr' :: (a -> b -> b) -> b -> BlockArgument a -> b # foldl :: (b -> a -> b) -> b -> BlockArgument a -> b # foldl' :: (b -> a -> b) -> b -> BlockArgument a -> b # foldr1 :: (a -> a -> a) -> BlockArgument a -> a # foldl1 :: (a -> a -> a) -> BlockArgument a -> a # toList :: BlockArgument a -> [a] # null :: BlockArgument a -> Bool # length :: BlockArgument a -> Int # elem :: Eq a => a -> BlockArgument a -> Bool # maximum :: Ord a => BlockArgument a -> a # minimum :: Ord a => BlockArgument a -> a # sum :: Num a => BlockArgument a -> a # product :: Num a => BlockArgument a -> a #
Traversable BlockArgument Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> BlockArgument a -> f (BlockArgument b) # sequenceA :: Applicative f => BlockArgument (f a) -> f (BlockArgument a) # mapM :: Monad m => (a -> m b) -> BlockArgument a -> m (BlockArgument b) # sequence :: Monad m => BlockArgument (m a) -> m (BlockArgument a) #
SymbolMatching BlockArgument Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy BlockArgument -> [Int] showFailure :: Proxy BlockArgument -> Node -> String
Unmarshal BlockArgument Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match BlockArgument) matchers :: B (Int, Match BlockArgument)
Eq a => Eq (BlockArgument a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: BlockArgument a -> BlockArgument a -> Bool # (/=) :: BlockArgument a -> BlockArgument a -> Bool #
Ord a => Ord (BlockArgument a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: BlockArgument a -> BlockArgument a -> Ordering # (<) :: BlockArgument a -> BlockArgument a -> Bool # (<=) :: BlockArgument a -> BlockArgument a -> Bool # (>) :: BlockArgument a -> BlockArgument a -> Bool # (>=) :: BlockArgument a -> BlockArgument a -> Bool # max :: BlockArgument a -> BlockArgument a -> BlockArgument a # min :: BlockArgument a -> BlockArgument a -> BlockArgument a #
Show a => Show (BlockArgument a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> BlockArgument a -> ShowS # show :: BlockArgument a -> String # showList :: [BlockArgument a] -> ShowS #
Generic (BlockArgument a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (BlockArgument a) :: Type -> Type # Methods from :: BlockArgument a -> Rep (BlockArgument a) x # to :: Rep (BlockArgument a) x -> BlockArgument a #
Generic1 BlockArgument Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 BlockArgument :: k -> Type # Methods from1 :: forall (a :: k). BlockArgument a -> Rep1 BlockArgument a # to1 :: forall (a :: k). Rep1 BlockArgument a -> BlockArgument a #
type Rep (BlockArgument a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (BlockArgument a) = D1 ('MetaData "BlockArgument" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "BlockArgument" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Arg a))))
type Rep1 BlockArgument Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 BlockArgument = D1 ('MetaData "BlockArgument" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "BlockArgument" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 Arg)))

data Block a Source #

Constructors

Block
Fields ann :: a extraChildren :: ([] ((:+:) Statement ((:+:) BlockParameters EmptyStatement) a))

Instances

Instances details

Functor Block Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> Block a -> Block b # (<$) :: a -> Block b -> Block a #
Foldable Block Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => Block m -> m # foldMap :: Monoid m => (a -> m) -> Block a -> m # foldMap' :: Monoid m => (a -> m) -> Block a -> m # foldr :: (a -> b -> b) -> b -> Block a -> b # foldr' :: (a -> b -> b) -> b -> Block a -> b # foldl :: (b -> a -> b) -> b -> Block a -> b # foldl' :: (b -> a -> b) -> b -> Block a -> b # foldr1 :: (a -> a -> a) -> Block a -> a # foldl1 :: (a -> a -> a) -> Block a -> a # toList :: Block a -> [a] # null :: Block a -> Bool # length :: Block a -> Int # elem :: Eq a => a -> Block a -> Bool # maximum :: Ord a => Block a -> a # minimum :: Ord a => Block a -> a # sum :: Num a => Block a -> a # product :: Num a => Block a -> a #
Traversable Block Source #
Instance details Defined in TreeSitter.Ruby.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 Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy Block -> [Int] showFailure :: Proxy Block -> Node -> String
Unmarshal Block Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match Block) matchers :: B (Int, Match Block)
Eq a => Eq (Block a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: Block a -> Block a -> Bool # (/=) :: Block a -> Block a -> Bool #
Ord a => Ord (Block a) Source #
Instance details Defined in TreeSitter.Ruby.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) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> Block a -> ShowS # show :: Block a -> String # showList :: [Block a] -> ShowS #
Generic (Block a) Source #
Instance details Defined in TreeSitter.Ruby.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 Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 Block :: k -> Type # Methods from1 :: forall (a :: k). Block a -> Rep1 Block a # to1 :: forall (a :: k). Rep1 Block a -> Block a #
type Rep (Block a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (Block a) = D1 ('MetaData "Block" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.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 [(Statement :+: (BlockParameters :+: EmptyStatement)) a])))
type Rep1 Block Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 Block = D1 ('MetaData "Block" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Block" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) ([] :.: Rec1 (Statement :+: (BlockParameters :+: EmptyStatement)))))

data Binary a Source #

Constructors

Binary

Fields

ann :: a
operator :: ((:+:) ((:+:) ((:+:) ((:+:) AnonymousBangEqual ((:+:) AnonymousBangTilde AnonymousPercent)) ((:+:) AnonymousAmpersand ((:+:) AnonymousAmpersandAmpersand AnonymousStar))) ((:+:) ((:+:) AnonymousStarStar ((:+:) AnonymousPlus AnonymousMinus)) ((:+:) AnonymousSlash ((:+:) AnonymousLAngle AnonymousLAngleLAngle)))) ((:+:) ((:+:) ((:+:) AnonymousLAngleEqual ((:+:) AnonymousLAngleEqualRAngle AnonymousEqualEqual)) ((:+:) AnonymousEqualEqualEqual ((:+:) AnonymousEqualTilde AnonymousRAngle))) ((:+:) ((:+:) AnonymousRAngleEqual ((:+:) AnonymousRAngleRAngle AnonymousCaret)) ((:+:) ((:+:) AnonymousAnd AnonymousOr) ((:+:) AnonymousPipe AnonymousPipePipe)))) a)
left :: ((:+:) ((:+:) Arg ((:+:) Break MethodCall)) ((:+:) Next ((:+:) Return Yield)) a)
right :: ((:+:) ((:+:) Arg ((:+:) Break MethodCall)) ((:+:) Next ((:+:) Return Yield)) a)

Instances

Instances details

Functor Binary Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> Binary a -> Binary b # (<$) :: a -> Binary b -> Binary a #
Foldable Binary Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => Binary m -> m # foldMap :: Monoid m => (a -> m) -> Binary a -> m # foldMap' :: Monoid m => (a -> m) -> Binary a -> m # foldr :: (a -> b -> b) -> b -> Binary a -> b # foldr' :: (a -> b -> b) -> b -> Binary a -> b # foldl :: (b -> a -> b) -> b -> Binary a -> b # foldl' :: (b -> a -> b) -> b -> Binary a -> b # foldr1 :: (a -> a -> a) -> Binary a -> a # foldl1 :: (a -> a -> a) -> Binary a -> a # toList :: Binary a -> [a] # null :: Binary a -> Bool # length :: Binary a -> Int # elem :: Eq a => a -> Binary a -> Bool # maximum :: Ord a => Binary a -> a # minimum :: Ord a => Binary a -> a # sum :: Num a => Binary a -> a # product :: Num a => Binary a -> a #
Traversable Binary Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> Binary a -> f (Binary b) # sequenceA :: Applicative f => Binary (f a) -> f (Binary a) # mapM :: Monad m => (a -> m b) -> Binary a -> m (Binary b) # sequence :: Monad m => Binary (m a) -> m (Binary a) #
SymbolMatching Binary Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy Binary -> [Int] showFailure :: Proxy Binary -> Node -> String
Unmarshal Binary Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match Binary) matchers :: B (Int, Match Binary)
Eq a => Eq (Binary a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: Binary a -> Binary a -> Bool # (/=) :: Binary a -> Binary a -> Bool #
Ord a => Ord (Binary a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: Binary a -> Binary a -> Ordering # (<) :: Binary a -> Binary a -> Bool # (<=) :: Binary a -> Binary a -> Bool # (>) :: Binary a -> Binary a -> Bool # (>=) :: Binary a -> Binary a -> Bool # max :: Binary a -> Binary a -> Binary a # min :: Binary a -> Binary a -> Binary a #
Show a => Show (Binary a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> Binary a -> ShowS # show :: Binary a -> String # showList :: [Binary a] -> ShowS #
Generic (Binary a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (Binary a) :: Type -> Type # Methods from :: Binary a -> Rep (Binary a) x # to :: Rep (Binary a) x -> Binary a #
Generic1 Binary Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 Binary :: k -> Type # Methods from1 :: forall (a :: k). Binary a -> Rep1 Binary a # to1 :: forall (a :: k). Rep1 Binary a -> Binary a #
type Rep (Binary a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (Binary a) = D1 ('MetaData "Binary" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Binary" 'PrefixI 'True) ((S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :: S1 ('MetaSel ('Just "operator") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (((((AnonymousBangEqual :+: (AnonymousBangTilde :+: AnonymousPercent)) :+: (AnonymousAmpersand :+: (AnonymousAmpersandAmpersand :+: AnonymousStar))) :+: ((AnonymousStarStar :+: (AnonymousPlus :+: AnonymousMinus)) :+: (AnonymousSlash :+: (AnonymousLAngle :+: AnonymousLAngleLAngle)))) :+: (((AnonymousLAngleEqual :+: (AnonymousLAngleEqualRAngle :+: AnonymousEqualEqual)) :+: (AnonymousEqualEqualEqual :+: (AnonymousEqualTilde :+: AnonymousRAngle))) :+: ((AnonymousRAngleEqual :+: (AnonymousRAngleRAngle :+: AnonymousCaret)) :+: ((AnonymousAnd :+: AnonymousOr) :+: (AnonymousPipe :+: AnonymousPipePipe))))) a))) :: (S1 ('MetaSel ('Just "left") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (((Arg :+: (Break :+: MethodCall)) :+: (Next :+: (Return :+: Yield))) a)) :*: S1 ('MetaSel ('Just "right") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (((Arg :+: (Break :+: MethodCall)) :+: (Next :+: (Return :+: Yield))) a)))))
type Rep1 Binary Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 Binary = D1 ('MetaData "Binary" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Binary" 'PrefixI 'True) ((S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :: S1 ('MetaSel ('Just "operator") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 ((((AnonymousBangEqual :+: (AnonymousBangTilde :+: AnonymousPercent)) :+: (AnonymousAmpersand :+: (AnonymousAmpersandAmpersand :+: AnonymousStar))) :+: ((AnonymousStarStar :+: (AnonymousPlus :+: AnonymousMinus)) :+: (AnonymousSlash :+: (AnonymousLAngle :+: AnonymousLAngleLAngle)))) :+: (((AnonymousLAngleEqual :+: (AnonymousLAngleEqualRAngle :+: AnonymousEqualEqual)) :+: (AnonymousEqualEqualEqual :+: (AnonymousEqualTilde :+: AnonymousRAngle))) :+: ((AnonymousRAngleEqual :+: (AnonymousRAngleRAngle :+: AnonymousCaret)) :+: ((AnonymousAnd :+: AnonymousOr) :+: (AnonymousPipe :+: AnonymousPipePipe))))))) :: (S1 ('MetaSel ('Just "left") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 ((Arg :+: (Break :+: MethodCall)) :+: (Next :+: (Return :+: Yield)))) :*: S1 ('MetaSel ('Just "right") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 ((Arg :+: (Break :+: MethodCall)) :+: (Next :+: (Return :+: Yield)))))))

data BeginBlock a Source #

Constructors

BeginBlock
Fields ann :: a extraChildren :: ([] ((:+:) Statement EmptyStatement a))

Instances

Instances details

Functor BeginBlock Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> BeginBlock a -> BeginBlock b # (<$) :: a -> BeginBlock b -> BeginBlock a #
Foldable BeginBlock Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => BeginBlock m -> m # foldMap :: Monoid m => (a -> m) -> BeginBlock a -> m # foldMap' :: Monoid m => (a -> m) -> BeginBlock a -> m # foldr :: (a -> b -> b) -> b -> BeginBlock a -> b # foldr' :: (a -> b -> b) -> b -> BeginBlock a -> b # foldl :: (b -> a -> b) -> b -> BeginBlock a -> b # foldl' :: (b -> a -> b) -> b -> BeginBlock a -> b # foldr1 :: (a -> a -> a) -> BeginBlock a -> a # foldl1 :: (a -> a -> a) -> BeginBlock a -> a # toList :: BeginBlock a -> [a] # null :: BeginBlock a -> Bool # length :: BeginBlock a -> Int # elem :: Eq a => a -> BeginBlock a -> Bool # maximum :: Ord a => BeginBlock a -> a # minimum :: Ord a => BeginBlock a -> a # sum :: Num a => BeginBlock a -> a # product :: Num a => BeginBlock a -> a #
Traversable BeginBlock Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> BeginBlock a -> f (BeginBlock b) # sequenceA :: Applicative f => BeginBlock (f a) -> f (BeginBlock a) # mapM :: Monad m => (a -> m b) -> BeginBlock a -> m (BeginBlock b) # sequence :: Monad m => BeginBlock (m a) -> m (BeginBlock a) #
SymbolMatching BeginBlock Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy BeginBlock -> [Int] showFailure :: Proxy BeginBlock -> Node -> String
Unmarshal BeginBlock Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match BeginBlock) matchers :: B (Int, Match BeginBlock)
Eq a => Eq (BeginBlock a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: BeginBlock a -> BeginBlock a -> Bool # (/=) :: BeginBlock a -> BeginBlock a -> Bool #
Ord a => Ord (BeginBlock a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: BeginBlock a -> BeginBlock a -> Ordering # (<) :: BeginBlock a -> BeginBlock a -> Bool # (<=) :: BeginBlock a -> BeginBlock a -> Bool # (>) :: BeginBlock a -> BeginBlock a -> Bool # (>=) :: BeginBlock a -> BeginBlock a -> Bool # max :: BeginBlock a -> BeginBlock a -> BeginBlock a # min :: BeginBlock a -> BeginBlock a -> BeginBlock a #
Show a => Show (BeginBlock a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> BeginBlock a -> ShowS # show :: BeginBlock a -> String # showList :: [BeginBlock a] -> ShowS #
Generic (BeginBlock a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (BeginBlock a) :: Type -> Type # Methods from :: BeginBlock a -> Rep (BeginBlock a) x # to :: Rep (BeginBlock a) x -> BeginBlock a #
Generic1 BeginBlock Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 BeginBlock :: k -> Type # Methods from1 :: forall (a :: k). BeginBlock a -> Rep1 BeginBlock a # to1 :: forall (a :: k). Rep1 BeginBlock a -> BeginBlock a #
type Rep (BeginBlock a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (BeginBlock a) = D1 ('MetaData "BeginBlock" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "BeginBlock" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [(Statement :+: EmptyStatement) a])))
type Rep1 BeginBlock Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 BeginBlock = D1 ('MetaData "BeginBlock" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "BeginBlock" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) ([] :.: Rec1 (Statement :+: EmptyStatement))))

data Begin a Source #

Constructors

Begin
Fields ann :: a extraChildren :: ([] ((:+:) ((:+:) Statement Else) ((:+:) EmptyStatement ((:+:) Ensure Rescue)) a))

Instances

Instances details

Functor Begin Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> Begin a -> Begin b # (<$) :: a -> Begin b -> Begin a #
Foldable Begin Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => Begin m -> m # foldMap :: Monoid m => (a -> m) -> Begin a -> m # foldMap' :: Monoid m => (a -> m) -> Begin a -> m # foldr :: (a -> b -> b) -> b -> Begin a -> b # foldr' :: (a -> b -> b) -> b -> Begin a -> b # foldl :: (b -> a -> b) -> b -> Begin a -> b # foldl' :: (b -> a -> b) -> b -> Begin a -> b # foldr1 :: (a -> a -> a) -> Begin a -> a # foldl1 :: (a -> a -> a) -> Begin a -> a # toList :: Begin a -> [a] # null :: Begin a -> Bool # length :: Begin a -> Int # elem :: Eq a => a -> Begin a -> Bool # maximum :: Ord a => Begin a -> a # minimum :: Ord a => Begin a -> a # sum :: Num a => Begin a -> a # product :: Num a => Begin a -> a #
Traversable Begin Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> Begin a -> f (Begin b) # sequenceA :: Applicative f => Begin (f a) -> f (Begin a) # mapM :: Monad m => (a -> m b) -> Begin a -> m (Begin b) # sequence :: Monad m => Begin (m a) -> m (Begin a) #
SymbolMatching Begin Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy Begin -> [Int] showFailure :: Proxy Begin -> Node -> String
Unmarshal Begin Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match Begin) matchers :: B (Int, Match Begin)
Eq a => Eq (Begin a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: Begin a -> Begin a -> Bool # (/=) :: Begin a -> Begin a -> Bool #
Ord a => Ord (Begin a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: Begin a -> Begin a -> Ordering # (<) :: Begin a -> Begin a -> Bool # (<=) :: Begin a -> Begin a -> Bool # (>) :: Begin a -> Begin a -> Bool # (>=) :: Begin a -> Begin a -> Bool # max :: Begin a -> Begin a -> Begin a # min :: Begin a -> Begin a -> Begin a #
Show a => Show (Begin a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> Begin a -> ShowS # show :: Begin a -> String # showList :: [Begin a] -> ShowS #
Generic (Begin a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (Begin a) :: Type -> Type # Methods from :: Begin a -> Rep (Begin a) x # to :: Rep (Begin a) x -> Begin a #
Generic1 Begin Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 Begin :: k -> Type # Methods from1 :: forall (a :: k). Begin a -> Rep1 Begin a # to1 :: forall (a :: k). Rep1 Begin a -> Begin a #
type Rep (Begin a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (Begin a) = D1 ('MetaData "Begin" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Begin" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [((Statement :+: Else) :+: (EmptyStatement :+: (Ensure :+: Rescue))) a])))
type Rep1 Begin Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 Begin = D1 ('MetaData "Begin" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Begin" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) ([] :.: Rec1 ((Statement :+: Else) :+: (EmptyStatement :+: (Ensure :+: Rescue))))))

data BareSymbol a Source #

Constructors

BareSymbol
Fields ann :: a extraChildren :: ([] ((:+:) EscapeSequence Interpolation a))

Instances

Instances details

Functor BareSymbol Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> BareSymbol a -> BareSymbol b # (<$) :: a -> BareSymbol b -> BareSymbol a #
Foldable BareSymbol Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => BareSymbol m -> m # foldMap :: Monoid m => (a -> m) -> BareSymbol a -> m # foldMap' :: Monoid m => (a -> m) -> BareSymbol a -> m # foldr :: (a -> b -> b) -> b -> BareSymbol a -> b # foldr' :: (a -> b -> b) -> b -> BareSymbol a -> b # foldl :: (b -> a -> b) -> b -> BareSymbol a -> b # foldl' :: (b -> a -> b) -> b -> BareSymbol a -> b # foldr1 :: (a -> a -> a) -> BareSymbol a -> a # foldl1 :: (a -> a -> a) -> BareSymbol a -> a # toList :: BareSymbol a -> [a] # null :: BareSymbol a -> Bool # length :: BareSymbol a -> Int # elem :: Eq a => a -> BareSymbol a -> Bool # maximum :: Ord a => BareSymbol a -> a # minimum :: Ord a => BareSymbol a -> a # sum :: Num a => BareSymbol a -> a # product :: Num a => BareSymbol a -> a #
Traversable BareSymbol Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> BareSymbol a -> f (BareSymbol b) # sequenceA :: Applicative f => BareSymbol (f a) -> f (BareSymbol a) # mapM :: Monad m => (a -> m b) -> BareSymbol a -> m (BareSymbol b) # sequence :: Monad m => BareSymbol (m a) -> m (BareSymbol a) #
SymbolMatching BareSymbol Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy BareSymbol -> [Int] showFailure :: Proxy BareSymbol -> Node -> String
Unmarshal BareSymbol Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match BareSymbol) matchers :: B (Int, Match BareSymbol)
Eq a => Eq (BareSymbol a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: BareSymbol a -> BareSymbol a -> Bool # (/=) :: BareSymbol a -> BareSymbol a -> Bool #
Ord a => Ord (BareSymbol a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: BareSymbol a -> BareSymbol a -> Ordering # (<) :: BareSymbol a -> BareSymbol a -> Bool # (<=) :: BareSymbol a -> BareSymbol a -> Bool # (>) :: BareSymbol a -> BareSymbol a -> Bool # (>=) :: BareSymbol a -> BareSymbol a -> Bool # max :: BareSymbol a -> BareSymbol a -> BareSymbol a # min :: BareSymbol a -> BareSymbol a -> BareSymbol a #
Show a => Show (BareSymbol a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> BareSymbol a -> ShowS # show :: BareSymbol a -> String # showList :: [BareSymbol a] -> ShowS #
Generic (BareSymbol a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (BareSymbol a) :: Type -> Type # Methods from :: BareSymbol a -> Rep (BareSymbol a) x # to :: Rep (BareSymbol a) x -> BareSymbol a #
Generic1 BareSymbol Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 BareSymbol :: k -> Type # Methods from1 :: forall (a :: k). BareSymbol a -> Rep1 BareSymbol a # to1 :: forall (a :: k). Rep1 BareSymbol a -> BareSymbol a #
type Rep (BareSymbol a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (BareSymbol a) = D1 ('MetaData "BareSymbol" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "BareSymbol" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [(EscapeSequence :+: Interpolation) a])))
type Rep1 BareSymbol Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 BareSymbol = D1 ('MetaData "BareSymbol" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "BareSymbol" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) ([] :.: Rec1 (EscapeSequence :+: Interpolation))))

data BareString a Source #

Constructors

BareString
Fields ann :: a extraChildren :: ([] ((:+:) EscapeSequence Interpolation a))

Instances

Instances details

Functor BareString Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> BareString a -> BareString b # (<$) :: a -> BareString b -> BareString a #
Foldable BareString Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => BareString m -> m # foldMap :: Monoid m => (a -> m) -> BareString a -> m # foldMap' :: Monoid m => (a -> m) -> BareString a -> m # foldr :: (a -> b -> b) -> b -> BareString a -> b # foldr' :: (a -> b -> b) -> b -> BareString a -> b # foldl :: (b -> a -> b) -> b -> BareString a -> b # foldl' :: (b -> a -> b) -> b -> BareString a -> b # foldr1 :: (a -> a -> a) -> BareString a -> a # foldl1 :: (a -> a -> a) -> BareString a -> a # toList :: BareString a -> [a] # null :: BareString a -> Bool # length :: BareString a -> Int # elem :: Eq a => a -> BareString a -> Bool # maximum :: Ord a => BareString a -> a # minimum :: Ord a => BareString a -> a # sum :: Num a => BareString a -> a # product :: Num a => BareString a -> a #
Traversable BareString Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> BareString a -> f (BareString b) # sequenceA :: Applicative f => BareString (f a) -> f (BareString a) # mapM :: Monad m => (a -> m b) -> BareString a -> m (BareString b) # sequence :: Monad m => BareString (m a) -> m (BareString a) #
SymbolMatching BareString Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy BareString -> [Int] showFailure :: Proxy BareString -> Node -> String
Unmarshal BareString Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match BareString) matchers :: B (Int, Match BareString)
Eq a => Eq (BareString a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: BareString a -> BareString a -> Bool # (/=) :: BareString a -> BareString a -> Bool #
Ord a => Ord (BareString a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: BareString a -> BareString a -> Ordering # (<) :: BareString a -> BareString a -> Bool # (<=) :: BareString a -> BareString a -> Bool # (>) :: BareString a -> BareString a -> Bool # (>=) :: BareString a -> BareString a -> Bool # max :: BareString a -> BareString a -> BareString a # min :: BareString a -> BareString a -> BareString a #
Show a => Show (BareString a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> BareString a -> ShowS # show :: BareString a -> String # showList :: [BareString a] -> ShowS #
Generic (BareString a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (BareString a) :: Type -> Type # Methods from :: BareString a -> Rep (BareString a) x # to :: Rep (BareString a) x -> BareString a #
Generic1 BareString Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 BareString :: k -> Type # Methods from1 :: forall (a :: k). BareString a -> Rep1 BareString a # to1 :: forall (a :: k). Rep1 BareString a -> BareString a #
type Rep (BareString a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (BareString a) = D1 ('MetaData "BareString" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "BareString" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [(EscapeSequence :+: Interpolation) a])))
type Rep1 BareString Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 BareString = D1 ('MetaData "BareString" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "BareString" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) ([] :.: Rec1 (EscapeSequence :+: Interpolation))))

data Assignment a Source #

Constructors

Assignment
Fields ann :: a left :: ((:+:) Lhs LeftAssignmentList a) right :: ((:+:) ((:+:) ((:+:) Arg Break) ((:+:) MethodCall Next)) ((:+:) ((:+:) Return RightAssignmentList) ((:+:) SplatArgument Yield)) a)

Instances

Instances details

Functor Assignment Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> Assignment a -> Assignment b # (<$) :: a -> Assignment b -> Assignment a #
Foldable Assignment Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => Assignment m -> m # foldMap :: Monoid m => (a -> m) -> Assignment a -> 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 Source #
Instance details Defined in TreeSitter.Ruby.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 Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy Assignment -> [Int] showFailure :: Proxy Assignment -> Node -> String
Unmarshal Assignment Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match Assignment) matchers :: B (Int, Match Assignment)
Eq a => Eq (Assignment a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: Assignment a -> Assignment a -> Bool # (/=) :: Assignment a -> Assignment a -> Bool #
Ord a => Ord (Assignment a) Source #
Instance details Defined in TreeSitter.Ruby.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) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> Assignment a -> ShowS # show :: Assignment a -> String # showList :: [Assignment a] -> ShowS #
Generic (Assignment a) Source #
Instance details Defined in TreeSitter.Ruby.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 Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 Assignment :: k -> Type # Methods from1 :: forall (a :: k). Assignment a -> Rep1 Assignment a # to1 :: forall (a :: k). Rep1 Assignment a -> Assignment a #
type Rep (Assignment a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (Assignment a) = D1 ('MetaData "Assignment" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.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 ((Lhs :+: LeftAssignmentList) a)) :: S1 ('MetaSel ('Just "right") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ((((Arg :+: Break) :+: (MethodCall :+: Next)) :+: ((Return :+: RightAssignmentList) :+: (SplatArgument :+: Yield))) a)))))
type Rep1 Assignment Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 Assignment = D1 ('MetaData "Assignment" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Assignment" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :: (S1 ('MetaSel ('Just "left") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 (Lhs :+: LeftAssignmentList)) :: S1 ('MetaSel ('Just "right") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 (((Arg :+: Break) :+: (MethodCall :+: Next)) :+: ((Return :+: RightAssignmentList) :+: (SplatArgument :+: Yield)))))))

data Array a Source #

Constructors

Array
Fields ann :: a extraChildren :: ([] ((:+:) ((:+:) Arg BlockArgument) ((:+:) HashSplatArgument ((:+:) Pair SplatArgument)) a))

Instances

Instances details

Functor Array Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> Array a -> Array b # (<$) :: a -> Array b -> Array a #
Foldable Array Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => Array m -> m # foldMap :: Monoid m => (a -> m) -> Array a -> m # foldMap' :: Monoid m => (a -> m) -> Array a -> m # foldr :: (a -> b -> b) -> b -> Array a -> b # foldr' :: (a -> b -> b) -> b -> Array a -> b # foldl :: (b -> a -> b) -> b -> Array a -> b # foldl' :: (b -> a -> b) -> b -> Array a -> b # foldr1 :: (a -> a -> a) -> Array a -> a # foldl1 :: (a -> a -> a) -> Array a -> a # toList :: Array a -> [a] # null :: Array a -> Bool # length :: Array a -> Int # elem :: Eq a => a -> Array a -> Bool # maximum :: Ord a => Array a -> a # minimum :: Ord a => Array a -> a # sum :: Num a => Array a -> a # product :: Num a => Array a -> a #
Traversable Array Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> Array a -> f (Array b) # sequenceA :: Applicative f => Array (f a) -> f (Array a) # mapM :: Monad m => (a -> m b) -> Array a -> m (Array b) # sequence :: Monad m => Array (m a) -> m (Array a) #
SymbolMatching Array Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy Array -> [Int] showFailure :: Proxy Array -> Node -> String
Unmarshal Array Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match Array) matchers :: B (Int, Match Array)
Eq a => Eq (Array a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: Array a -> Array a -> Bool # (/=) :: Array a -> Array a -> Bool #
Ord a => Ord (Array a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: Array a -> Array a -> Ordering # (<) :: Array a -> Array a -> Bool # (<=) :: Array a -> Array a -> Bool # (>) :: Array a -> Array a -> Bool # (>=) :: Array a -> Array a -> Bool # max :: Array a -> Array a -> Array a # min :: Array a -> Array a -> Array a #
Show a => Show (Array a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> Array a -> ShowS # show :: Array a -> String # showList :: [Array a] -> ShowS #
Generic (Array a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (Array a) :: Type -> Type # Methods from :: Array a -> Rep (Array a) x # to :: Rep (Array a) x -> Array a #
Generic1 Array Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 Array :: k -> Type # Methods from1 :: forall (a :: k). Array a -> Rep1 Array a # to1 :: forall (a :: k). Rep1 Array a -> Array a #
type Rep (Array a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (Array a) = D1 ('MetaData "Array" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Array" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [((Arg :+: BlockArgument) :+: (HashSplatArgument :+: (Pair :+: SplatArgument))) a])))
type Rep1 Array Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 Array = D1 ('MetaData "Array" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Array" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) ([] :.: Rec1 ((Arg :+: BlockArgument) :+: (HashSplatArgument :+: (Pair :+: SplatArgument))))))

data ArgumentList a Source #

Constructors

ArgumentList
Fields ann :: a extraChildren :: ([] ((:+:) ((:+:) Arg ((:+:) BlockArgument HashSplatArgument)) ((:+:) MethodCall ((:+:) Pair SplatArgument)) a))

Instances

Instances details

Functor ArgumentList Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> ArgumentList a -> ArgumentList b # (<$) :: a -> ArgumentList b -> ArgumentList a #
Foldable ArgumentList Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => ArgumentList m -> m # foldMap :: Monoid m => (a -> m) -> ArgumentList a -> 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 Source #
Instance details Defined in TreeSitter.Ruby.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 Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy ArgumentList -> [Int] showFailure :: Proxy ArgumentList -> Node -> String
Unmarshal ArgumentList Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match ArgumentList) matchers :: B (Int, Match ArgumentList)
Eq a => Eq (ArgumentList a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: ArgumentList a -> ArgumentList a -> Bool # (/=) :: ArgumentList a -> ArgumentList a -> Bool #
Ord a => Ord (ArgumentList a) Source #
Instance details Defined in TreeSitter.Ruby.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) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> ArgumentList a -> ShowS # show :: ArgumentList a -> String # showList :: [ArgumentList a] -> ShowS #
Generic (ArgumentList a) Source #
Instance details Defined in TreeSitter.Ruby.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 Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 ArgumentList :: k -> Type # Methods from1 :: forall (a :: k). ArgumentList a -> Rep1 ArgumentList a # to1 :: forall (a :: k). Rep1 ArgumentList a -> ArgumentList a #
type Rep (ArgumentList a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (ArgumentList a) = D1 ('MetaData "ArgumentList" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.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 [((Arg :+: (BlockArgument :+: HashSplatArgument)) :+: (MethodCall :+: (Pair :+: SplatArgument))) a])))
type Rep1 ArgumentList Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 ArgumentList = D1 ('MetaData "ArgumentList" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "ArgumentList" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Just "extraChildren") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) ([] :.: Rec1 ((Arg :+: (BlockArgument :+: HashSplatArgument)) :+: (MethodCall :+: (Pair :+: SplatArgument))))))

data Alias a Source #

Constructors

Alias
Fields ann :: a alias :: (MethodName a) name :: (MethodName a)

Instances

Instances details

Functor Alias Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> Alias a -> Alias b # (<$) :: a -> Alias b -> Alias a #
Foldable Alias Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => Alias m -> m # foldMap :: Monoid m => (a -> m) -> Alias a -> m # foldMap' :: Monoid m => (a -> m) -> Alias a -> m # foldr :: (a -> b -> b) -> b -> Alias a -> b # foldr' :: (a -> b -> b) -> b -> Alias a -> b # foldl :: (b -> a -> b) -> b -> Alias a -> b # foldl' :: (b -> a -> b) -> b -> Alias a -> b # foldr1 :: (a -> a -> a) -> Alias a -> a # foldl1 :: (a -> a -> a) -> Alias a -> a # toList :: Alias a -> [a] # null :: Alias a -> Bool # length :: Alias a -> Int # elem :: Eq a => a -> Alias a -> Bool # maximum :: Ord a => Alias a -> a # minimum :: Ord a => Alias a -> a # sum :: Num a => Alias a -> a # product :: Num a => Alias a -> a #
Traversable Alias Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> Alias a -> f (Alias b) # sequenceA :: Applicative f => Alias (f a) -> f (Alias a) # mapM :: Monad m => (a -> m b) -> Alias a -> m (Alias b) # sequence :: Monad m => Alias (m a) -> m (Alias a) #
SymbolMatching Alias Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy Alias -> [Int] showFailure :: Proxy Alias -> Node -> String
Unmarshal Alias Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match Alias) matchers :: B (Int, Match Alias)
Eq a => Eq (Alias a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: Alias a -> Alias a -> Bool # (/=) :: Alias a -> Alias a -> Bool #
Ord a => Ord (Alias a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: Alias a -> Alias a -> Ordering # (<) :: Alias a -> Alias a -> Bool # (<=) :: Alias a -> Alias a -> Bool # (>) :: Alias a -> Alias a -> Bool # (>=) :: Alias a -> Alias a -> Bool # max :: Alias a -> Alias a -> Alias a # min :: Alias a -> Alias a -> Alias a #
Show a => Show (Alias a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> Alias a -> ShowS # show :: Alias a -> String # showList :: [Alias a] -> ShowS #
Generic (Alias a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (Alias a) :: Type -> Type # Methods from :: Alias a -> Rep (Alias a) x # to :: Rep (Alias a) x -> Alias a #
Generic1 Alias Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 Alias :: k -> Type # Methods from1 :: forall (a :: k). Alias a -> Rep1 Alias a # to1 :: forall (a :: k). Rep1 Alias a -> Alias a #
type Rep (Alias a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (Alias a) = D1 ('MetaData "Alias" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Alias" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :: (S1 ('MetaSel ('Just "alias") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (MethodName a)) :: S1 ('MetaSel ('Just "name") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (MethodName a)))))
type Rep1 Alias Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 Alias = D1 ('MetaData "Alias" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'False) (C1 ('MetaCons "Alias" 'PrefixI 'True) (S1 ('MetaSel ('Just "ann") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :: (S1 ('MetaSel ('Just "alias") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 MethodName) :: S1 ('MetaSel ('Just "name") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 MethodName))))

newtype Variable a Source #

Constructors

Variable
Fields getVariable :: ((:+:) ((:+:) ClassVariable ((:+:) Constant GlobalVariable)) ((:+:) ((:+:) Identifier InstanceVariable) ((:+:) Self Super)) a)

Instances

Instances details

Functor Variable Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> Variable a -> Variable b # (<$) :: a -> Variable b -> Variable a #
Foldable Variable Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => Variable m -> m # foldMap :: Monoid m => (a -> m) -> Variable a -> m # foldMap' :: Monoid m => (a -> m) -> Variable a -> m # foldr :: (a -> b -> b) -> b -> Variable a -> b # foldr' :: (a -> b -> b) -> b -> Variable a -> b # foldl :: (b -> a -> b) -> b -> Variable a -> b # foldl' :: (b -> a -> b) -> b -> Variable a -> b # foldr1 :: (a -> a -> a) -> Variable a -> a # foldl1 :: (a -> a -> a) -> Variable a -> a # toList :: Variable a -> [a] # null :: Variable a -> Bool # length :: Variable a -> Int # elem :: Eq a => a -> Variable a -> Bool # maximum :: Ord a => Variable a -> a # minimum :: Ord a => Variable a -> a # sum :: Num a => Variable a -> a # product :: Num a => Variable a -> a #
Traversable Variable Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> Variable a -> f (Variable b) # sequenceA :: Applicative f => Variable (f a) -> f (Variable a) # mapM :: Monad m => (a -> m b) -> Variable a -> m (Variable b) # sequence :: Monad m => Variable (m a) -> m (Variable a) #
SymbolMatching Variable Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy Variable -> [Int] showFailure :: Proxy Variable -> Node -> String
Unmarshal Variable Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match Variable) matchers :: B (Int, Match Variable)
HasField "ann" (Variable a) a Source #
Instance details Defined in TreeSitter.Ruby.AST Methods getField :: Variable a -> a #
Eq a => Eq (Variable a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: Variable a -> Variable a -> Bool # (/=) :: Variable a -> Variable a -> Bool #
Ord a => Ord (Variable a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: Variable a -> Variable a -> Ordering # (<) :: Variable a -> Variable a -> Bool # (<=) :: Variable a -> Variable a -> Bool # (>) :: Variable a -> Variable a -> Bool # (>=) :: Variable a -> Variable a -> Bool # max :: Variable a -> Variable a -> Variable a # min :: Variable a -> Variable a -> Variable a #
Show a => Show (Variable a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> Variable a -> ShowS # show :: Variable a -> String # showList :: [Variable a] -> ShowS #
Generic (Variable a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (Variable a) :: Type -> Type # Methods from :: Variable a -> Rep (Variable a) x # to :: Rep (Variable a) x -> Variable a #
Generic1 Variable Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 Variable :: k -> Type # Methods from1 :: forall (a :: k). Variable a -> Rep1 Variable a # to1 :: forall (a :: k). Rep1 Variable a -> Variable a #
type Rep (Variable a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (Variable a) = D1 ('MetaData "Variable" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'True) (C1 ('MetaCons "Variable" 'PrefixI 'True) (S1 ('MetaSel ('Just "getVariable") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (((ClassVariable :+: (Constant :+: GlobalVariable)) :+: ((Identifier :+: InstanceVariable) :+: (Self :+: Super))) a))))
type Rep1 Variable Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 Variable = D1 ('MetaData "Variable" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'True) (C1 ('MetaCons "Variable" 'PrefixI 'True) (S1 ('MetaSel ('Just "getVariable") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 ((ClassVariable :+: (Constant :+: GlobalVariable)) :+: ((Identifier :+: InstanceVariable) :+: (Self :+: Super))))))

newtype Statement a Source #

Constructors

Statement
Fields getStatement :: ((:+:) ((:+:) ((:+:) ((:+:) Arg Alias) ((:+:) Assignment BeginBlock)) ((:+:) ((:+:) Binary Break) ((:+:) EndBlock ((:+:) IfModifier MethodCall)))) ((:+:) ((:+:) ((:+:) Next OperatorAssignment) ((:+:) RescueModifier Return)) ((:+:) ((:+:) Undef UnlessModifier) ((:+:) UntilModifier ((:+:) WhileModifier Yield)))) a)

Instances

Instances details

Functor Statement Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> Statement a -> Statement b # (<$) :: a -> Statement b -> Statement a #
Foldable Statement Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => Statement m -> m # foldMap :: Monoid m => (a -> m) -> Statement a -> m # foldMap' :: Monoid m => (a -> m) -> Statement a -> m # foldr :: (a -> b -> b) -> b -> Statement a -> b # foldr' :: (a -> b -> b) -> b -> Statement a -> b # foldl :: (b -> a -> b) -> b -> Statement a -> b # foldl' :: (b -> a -> b) -> b -> Statement a -> b # foldr1 :: (a -> a -> a) -> Statement a -> a # foldl1 :: (a -> a -> a) -> Statement a -> a # toList :: Statement a -> [a] # null :: Statement a -> Bool # length :: Statement a -> Int # elem :: Eq a => a -> Statement a -> Bool # maximum :: Ord a => Statement a -> a # minimum :: Ord a => Statement a -> a # sum :: Num a => Statement a -> a # product :: Num a => Statement a -> a #
Traversable Statement Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> Statement a -> f (Statement b) # sequenceA :: Applicative f => Statement (f a) -> f (Statement a) # mapM :: Monad m => (a -> m b) -> Statement a -> m (Statement b) # sequence :: Monad m => Statement (m a) -> m (Statement a) #
SymbolMatching Statement Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy Statement -> [Int] showFailure :: Proxy Statement -> Node -> String
Unmarshal Statement Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match Statement) matchers :: B (Int, Match Statement)
HasField "ann" (Statement a) a Source #
Instance details Defined in TreeSitter.Ruby.AST Methods getField :: Statement a -> a #
Eq a => Eq (Statement a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: Statement a -> Statement a -> Bool # (/=) :: Statement a -> Statement a -> Bool #
Ord a => Ord (Statement a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: Statement a -> Statement a -> Ordering # (<) :: Statement a -> Statement a -> Bool # (<=) :: Statement a -> Statement a -> Bool # (>) :: Statement a -> Statement a -> Bool # (>=) :: Statement a -> Statement a -> Bool # max :: Statement a -> Statement a -> Statement a # min :: Statement a -> Statement a -> Statement a #
Show a => Show (Statement a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> Statement a -> ShowS # show :: Statement a -> String # showList :: [Statement a] -> ShowS #
Generic (Statement a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (Statement a) :: Type -> Type # Methods from :: Statement a -> Rep (Statement a) x # to :: Rep (Statement a) x -> Statement a #
Generic1 Statement Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 Statement :: k -> Type # Methods from1 :: forall (a :: k). Statement a -> Rep1 Statement a # to1 :: forall (a :: k). Rep1 Statement a -> Statement a #
type Rep (Statement a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (Statement a) = D1 ('MetaData "Statement" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'True) (C1 ('MetaCons "Statement" 'PrefixI 'True) (S1 ('MetaSel ('Just "getStatement") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (((((Arg :+: Alias) :+: (Assignment :+: BeginBlock)) :+: ((Binary :+: Break) :+: (EndBlock :+: (IfModifier :+: MethodCall)))) :+: (((Next :+: OperatorAssignment) :+: (RescueModifier :+: Return)) :+: ((Undef :+: UnlessModifier) :+: (UntilModifier :+: (WhileModifier :+: Yield))))) a))))
type Rep1 Statement Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 Statement = D1 ('MetaData "Statement" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'True) (C1 ('MetaCons "Statement" 'PrefixI 'True) (S1 ('MetaSel ('Just "getStatement") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 ((((Arg :+: Alias) :+: (Assignment :+: BeginBlock)) :+: ((Binary :+: Break) :+: (EndBlock :+: (IfModifier :+: MethodCall)))) :+: (((Next :+: OperatorAssignment) :+: (RescueModifier :+: Return)) :+: ((Undef :+: UnlessModifier) :+: (UntilModifier :+: (WhileModifier :+: Yield))))))))

newtype Primary a Source #

Constructors

Primary

Fields

getPrimary :: ((:+:) ((:+:) ((:+:) ((:+:) ((:+:) Lhs Array) ((:+:) Begin Break)) ((:+:) ((:+:) Case ChainedString) ((:+:) Character ((:+:) Class Complex)))) ((:+:) ((:+:) ((:+:) Float For) ((:+:) Hash HeredocBeginning)) ((:+:) ((:+:) If Integer) ((:+:) Lambda ((:+:) Method Module))))) ((:+:) ((:+:) ((:+:) ((:+:) Next ParenthesizedStatements) ((:+:) Rational Redo)) ((:+:) ((:+:) Regex Retry) ((:+:) Return ((:+:) SingletonClass SingletonMethod)))) ((:+:) ((:+:) ((:+:) String StringArray) ((:+:) Subshell ((:+:) Symbol SymbolArray))) ((:+:) ((:+:) Unary Unless) ((:+:) Until ((:+:) While Yield))))) a)

Instances

Instances details

Functor Primary Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> Primary a -> Primary b # (<$) :: a -> Primary b -> Primary a #
Foldable Primary Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => Primary m -> m # foldMap :: Monoid m => (a -> m) -> Primary a -> m # foldMap' :: Monoid m => (a -> m) -> Primary a -> m # foldr :: (a -> b -> b) -> b -> Primary a -> b # foldr' :: (a -> b -> b) -> b -> Primary a -> b # foldl :: (b -> a -> b) -> b -> Primary a -> b # foldl' :: (b -> a -> b) -> b -> Primary a -> b # foldr1 :: (a -> a -> a) -> Primary a -> a # foldl1 :: (a -> a -> a) -> Primary a -> a # toList :: Primary a -> [a] # null :: Primary a -> Bool # length :: Primary a -> Int # elem :: Eq a => a -> Primary a -> Bool # maximum :: Ord a => Primary a -> a # minimum :: Ord a => Primary a -> a # sum :: Num a => Primary a -> a # product :: Num a => Primary a -> a #
Traversable Primary Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> Primary a -> f (Primary b) # sequenceA :: Applicative f => Primary (f a) -> f (Primary a) # mapM :: Monad m => (a -> m b) -> Primary a -> m (Primary b) # sequence :: Monad m => Primary (m a) -> m (Primary a) #
SymbolMatching Primary Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy Primary -> [Int] showFailure :: Proxy Primary -> Node -> String
Unmarshal Primary Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match Primary) matchers :: B (Int, Match Primary)
HasField "ann" (Primary a) a Source #
Instance details Defined in TreeSitter.Ruby.AST Methods getField :: Primary a -> a #
Eq a => Eq (Primary a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: Primary a -> Primary a -> Bool # (/=) :: Primary a -> Primary a -> Bool #
Ord a => Ord (Primary a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: Primary a -> Primary a -> Ordering # (<) :: Primary a -> Primary a -> Bool # (<=) :: Primary a -> Primary a -> Bool # (>) :: Primary a -> Primary a -> Bool # (>=) :: Primary a -> Primary a -> Bool # max :: Primary a -> Primary a -> Primary a # min :: Primary a -> Primary a -> Primary a #
Show a => Show (Primary a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> Primary a -> ShowS # show :: Primary a -> String # showList :: [Primary a] -> ShowS #
Generic (Primary a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (Primary a) :: Type -> Type # Methods from :: Primary a -> Rep (Primary a) x # to :: Rep (Primary a) x -> Primary a #
Generic1 Primary Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 Primary :: k -> Type # Methods from1 :: forall (a :: k). Primary a -> Rep1 Primary a # to1 :: forall (a :: k). Rep1 Primary a -> Primary a #
type Rep (Primary a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (Primary a) = D1 ('MetaData "Primary" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'True) (C1 ('MetaCons "Primary" 'PrefixI 'True) (S1 ('MetaSel ('Just "getPrimary") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ((((((Lhs :+: Array) :+: (Begin :+: Break)) :+: ((Case :+: ChainedString) :+: (Character :+: (Class :+: Complex)))) :+: (((Float :+: For) :+: (Hash :+: HeredocBeginning)) :+: ((If :+: Integer) :+: (Lambda :+: (Method :+: Module))))) :+: ((((Next :+: ParenthesizedStatements) :+: (Rational :+: Redo)) :+: ((Regex :+: Retry) :+: (Return :+: (SingletonClass :+: SingletonMethod)))) :+: (((String :+: StringArray) :+: (Subshell :+: (Symbol :+: SymbolArray))) :+: ((Unary :+: Unless) :+: (Until :+: (While :+: Yield)))))) a))))
type Rep1 Primary Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 Primary = D1 ('MetaData "Primary" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'True) (C1 ('MetaCons "Primary" 'PrefixI 'True) (S1 ('MetaSel ('Just "getPrimary") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 (((((Lhs :+: Array) :+: (Begin :+: Break)) :+: ((Case :+: ChainedString) :+: (Character :+: (Class :+: Complex)))) :+: (((Float :+: For) :+: (Hash :+: HeredocBeginning)) :+: ((If :+: Integer) :+: (Lambda :+: (Method :+: Module))))) :+: ((((Next :+: ParenthesizedStatements) :+: (Rational :+: Redo)) :+: ((Regex :+: Retry) :+: (Return :+: (SingletonClass :+: SingletonMethod)))) :+: (((String :+: StringArray) :+: (Subshell :+: (Symbol :+: SymbolArray))) :+: ((Unary :+: Unless) :+: (Until :+: (While :+: Yield)))))))))

newtype MethodName a Source #

Constructors

MethodName
Fields getMethodName :: ((:+:) ((:+:) ((:+:) ClassVariable Constant) ((:+:) GlobalVariable Identifier)) ((:+:) ((:+:) InstanceVariable Operator) ((:+:) Setter Symbol)) a)

Instances

Instances details

Functor MethodName Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> MethodName a -> MethodName b # (<$) :: a -> MethodName b -> MethodName a #
Foldable MethodName Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => MethodName m -> m # foldMap :: Monoid m => (a -> m) -> MethodName a -> m # foldMap' :: Monoid m => (a -> m) -> MethodName a -> m # foldr :: (a -> b -> b) -> b -> MethodName a -> b # foldr' :: (a -> b -> b) -> b -> MethodName a -> b # foldl :: (b -> a -> b) -> b -> MethodName a -> b # foldl' :: (b -> a -> b) -> b -> MethodName a -> b # foldr1 :: (a -> a -> a) -> MethodName a -> a # foldl1 :: (a -> a -> a) -> MethodName a -> a # toList :: MethodName a -> [a] # null :: MethodName a -> Bool # length :: MethodName a -> Int # elem :: Eq a => a -> MethodName a -> Bool # maximum :: Ord a => MethodName a -> a # minimum :: Ord a => MethodName a -> a # sum :: Num a => MethodName a -> a # product :: Num a => MethodName a -> a #
Traversable MethodName Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> MethodName a -> f (MethodName b) # sequenceA :: Applicative f => MethodName (f a) -> f (MethodName a) # mapM :: Monad m => (a -> m b) -> MethodName a -> m (MethodName b) # sequence :: Monad m => MethodName (m a) -> m (MethodName a) #
SymbolMatching MethodName Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy MethodName -> [Int] showFailure :: Proxy MethodName -> Node -> String
Unmarshal MethodName Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match MethodName) matchers :: B (Int, Match MethodName)
HasField "ann" (MethodName a) a Source #
Instance details Defined in TreeSitter.Ruby.AST Methods getField :: MethodName a -> a #
Eq a => Eq (MethodName a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: MethodName a -> MethodName a -> Bool # (/=) :: MethodName a -> MethodName a -> Bool #
Ord a => Ord (MethodName a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: MethodName a -> MethodName a -> Ordering # (<) :: MethodName a -> MethodName a -> Bool # (<=) :: MethodName a -> MethodName a -> Bool # (>) :: MethodName a -> MethodName a -> Bool # (>=) :: MethodName a -> MethodName a -> Bool # max :: MethodName a -> MethodName a -> MethodName a # min :: MethodName a -> MethodName a -> MethodName a #
Show a => Show (MethodName a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> MethodName a -> ShowS # show :: MethodName a -> String # showList :: [MethodName a] -> ShowS #
Generic (MethodName a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (MethodName a) :: Type -> Type # Methods from :: MethodName a -> Rep (MethodName a) x # to :: Rep (MethodName a) x -> MethodName a #
Generic1 MethodName Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 MethodName :: k -> Type # Methods from1 :: forall (a :: k). MethodName a -> Rep1 MethodName a # to1 :: forall (a :: k). Rep1 MethodName a -> MethodName a #
type Rep (MethodName a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (MethodName a) = D1 ('MetaData "MethodName" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'True) (C1 ('MetaCons "MethodName" 'PrefixI 'True) (S1 ('MetaSel ('Just "getMethodName") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ((((ClassVariable :+: Constant) :+: (GlobalVariable :+: Identifier)) :+: ((InstanceVariable :+: Operator) :+: (Setter :+: Symbol))) a))))
type Rep1 MethodName Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 MethodName = D1 ('MetaData "MethodName" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'True) (C1 ('MetaCons "MethodName" 'PrefixI 'True) (S1 ('MetaSel ('Just "getMethodName") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 (((ClassVariable :+: Constant) :+: (GlobalVariable :+: Identifier)) :+: ((InstanceVariable :+: Operator) :+: (Setter :+: Symbol))))))

newtype Lhs a Source #

Constructors

Lhs
Fields getLhs :: ((:+:) ((:+:) ((:+:) Variable Call) ((:+:) ElementReference False)) ((:+:) ((:+:) MethodCall Nil) ((:+:) ScopeResolution True)) a)

Instances

Instances details

Functor Lhs Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> Lhs a -> Lhs b # (<$) :: a -> Lhs b -> Lhs a #
Foldable Lhs Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => Lhs m -> m # foldMap :: Monoid m => (a -> m) -> Lhs a -> m # foldMap' :: Monoid m => (a -> m) -> Lhs a -> m # foldr :: (a -> b -> b) -> b -> Lhs a -> b # foldr' :: (a -> b -> b) -> b -> Lhs a -> b # foldl :: (b -> a -> b) -> b -> Lhs a -> b # foldl' :: (b -> a -> b) -> b -> Lhs a -> b # foldr1 :: (a -> a -> a) -> Lhs a -> a # foldl1 :: (a -> a -> a) -> Lhs a -> a # toList :: Lhs a -> [a] # null :: Lhs a -> Bool # length :: Lhs a -> Int # elem :: Eq a => a -> Lhs a -> Bool # maximum :: Ord a => Lhs a -> a # minimum :: Ord a => Lhs a -> a # sum :: Num a => Lhs a -> a # product :: Num a => Lhs a -> a #
Traversable Lhs Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> Lhs a -> f (Lhs b) # sequenceA :: Applicative f => Lhs (f a) -> f (Lhs a) # mapM :: Monad m => (a -> m b) -> Lhs a -> m (Lhs b) # sequence :: Monad m => Lhs (m a) -> m (Lhs a) #
SymbolMatching Lhs Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy Lhs -> [Int] showFailure :: Proxy Lhs -> Node -> String
Unmarshal Lhs Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match Lhs) matchers :: B (Int, Match Lhs)
HasField "ann" (Lhs a) a Source #
Instance details Defined in TreeSitter.Ruby.AST Methods getField :: Lhs a -> a #
Eq a => Eq (Lhs a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: Lhs a -> Lhs a -> Bool # (/=) :: Lhs a -> Lhs a -> Bool #
Ord a => Ord (Lhs a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: Lhs a -> Lhs a -> Ordering # (<) :: Lhs a -> Lhs a -> Bool # (<=) :: Lhs a -> Lhs a -> Bool # (>) :: Lhs a -> Lhs a -> Bool # (>=) :: Lhs a -> Lhs a -> Bool # max :: Lhs a -> Lhs a -> Lhs a # min :: Lhs a -> Lhs a -> Lhs a #
Show a => Show (Lhs a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> Lhs a -> ShowS # show :: Lhs a -> String # showList :: [Lhs a] -> ShowS #
Generic (Lhs a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (Lhs a) :: Type -> Type # Methods from :: Lhs a -> Rep (Lhs a) x # to :: Rep (Lhs a) x -> Lhs a #
Generic1 Lhs Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 Lhs :: k -> Type # Methods from1 :: forall (a :: k). Lhs a -> Rep1 Lhs a # to1 :: forall (a :: k). Rep1 Lhs a -> Lhs a #
type Rep (Lhs a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (Lhs a) = D1 ('MetaData "Lhs" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'True) (C1 ('MetaCons "Lhs" 'PrefixI 'True) (S1 ('MetaSel ('Just "getLhs") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ((((Variable :+: Call) :+: (ElementReference :+: False)) :+: ((MethodCall :+: Nil) :+: (ScopeResolution :+: True))) a))))
type Rep1 Lhs Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 Lhs = D1 ('MetaData "Lhs" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'True) (C1 ('MetaCons "Lhs" 'PrefixI 'True) (S1 ('MetaSel ('Just "getLhs") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 (((Variable :+: Call) :+: (ElementReference :+: False)) :+: ((MethodCall :+: Nil) :+: (ScopeResolution :+: True))))))

newtype Arg a Source #

Constructors

Arg
Fields getArg :: ((:+:) ((:+:) Primary ((:+:) Assignment Binary)) ((:+:) ((:+:) Conditional OperatorAssignment) ((:+:) Range Unary)) a)

Instances

Instances details

Functor Arg Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fmap :: (a -> b) -> Arg a -> Arg b # (<$) :: a -> Arg b -> Arg a #
Foldable Arg Source #
Instance details Defined in TreeSitter.Ruby.AST Methods fold :: Monoid m => Arg m -> m # foldMap :: Monoid m => (a -> m) -> Arg a -> m # foldMap' :: Monoid m => (a -> m) -> Arg a -> m # foldr :: (a -> b -> b) -> b -> Arg a -> b # foldr' :: (a -> b -> b) -> b -> Arg a -> b # foldl :: (b -> a -> b) -> b -> Arg a -> b # foldl' :: (b -> a -> b) -> b -> Arg a -> b # foldr1 :: (a -> a -> a) -> Arg a -> a # foldl1 :: (a -> a -> a) -> Arg a -> a # toList :: Arg a -> [a] # null :: Arg a -> Bool # length :: Arg a -> Int # elem :: Eq a => a -> Arg a -> Bool # maximum :: Ord a => Arg a -> a # minimum :: Ord a => Arg a -> a # sum :: Num a => Arg a -> a # product :: Num a => Arg a -> a #
Traversable Arg Source #
Instance details Defined in TreeSitter.Ruby.AST Methods traverse :: Applicative f => (a -> f b) -> Arg a -> f (Arg b) # sequenceA :: Applicative f => Arg (f a) -> f (Arg a) # mapM :: Monad m => (a -> m b) -> Arg a -> m (Arg b) # sequence :: Monad m => Arg (m a) -> m (Arg a) #
SymbolMatching Arg Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchedSymbols :: Proxy Arg -> [Int] showFailure :: Proxy Arg -> Node -> String
Unmarshal Arg Source #
Instance details Defined in TreeSitter.Ruby.AST Methods matchers' :: IntMap (Match Arg) matchers :: B (Int, Match Arg)
HasField "ann" (Arg a) a Source #
Instance details Defined in TreeSitter.Ruby.AST Methods getField :: Arg a -> a #
Eq a => Eq (Arg a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods (==) :: Arg a -> Arg a -> Bool # (/=) :: Arg a -> Arg a -> Bool #
Ord a => Ord (Arg a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods compare :: Arg a -> Arg a -> Ordering # (<) :: Arg a -> Arg a -> Bool # (<=) :: Arg a -> Arg a -> Bool # (>) :: Arg a -> Arg a -> Bool # (>=) :: Arg a -> Arg a -> Bool # max :: Arg a -> Arg a -> Arg a # min :: Arg a -> Arg a -> Arg a #
Show a => Show (Arg a) Source #
Instance details Defined in TreeSitter.Ruby.AST Methods showsPrec :: Int -> Arg a -> ShowS # show :: Arg a -> String # showList :: [Arg a] -> ShowS #
Generic (Arg a) Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep (Arg a) :: Type -> Type # Methods from :: Arg a -> Rep (Arg a) x # to :: Rep (Arg a) x -> Arg a #
Generic1 Arg Source #
Instance details Defined in TreeSitter.Ruby.AST Associated Types type Rep1 Arg :: k -> Type # Methods from1 :: forall (a :: k). Arg a -> Rep1 Arg a # to1 :: forall (a :: k). Rep1 Arg a -> Arg a #
type Rep (Arg a) Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep (Arg a) = D1 ('MetaData "Arg" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'True) (C1 ('MetaCons "Arg" 'PrefixI 'True) (S1 ('MetaSel ('Just "getArg") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (((Primary :+: (Assignment :+: Binary)) :+: ((Conditional :+: OperatorAssignment) :+: (Range :+: Unary))) a))))
type Rep1 Arg Source #
Instance details Defined in TreeSitter.Ruby.AST type Rep1 Arg = D1 ('MetaData "Arg" "TreeSitter.Ruby.AST" "tree-sitter-ruby-0.4.1.0-inplace" 'True) (C1 ('MetaCons "Arg" 'PrefixI 'True) (S1 ('MetaSel ('Just "getArg") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 ((Primary :+: (Assignment :+: Binary)) :+: ((Conditional :+: OperatorAssignment) :+: (Range :+: Unary))))))