tree-sitter-ruby-0.3.2.0: Tree-sitter grammar/parser for Ruby
Safe HaskellNone
LanguageHaskell2010

TreeSitter.Ruby.AST

Documentation

type AnonymousTilde = Token "~" 91 Source #

type AnonymousRBrace = Token "}" 6 Source #

type AnonymousPipePipeEqual = Token "||=" 57 Source #

type AnonymousPipePipe = Token "||" 71 Source #

type AnonymousPipeEqual = Token "|=" 58 Source #

type AnonymousPipe = Token "|" 14 Source #

type AnonymousLBrace = Token "{" 5 Source #

type AnonymousYield = Token "yield" 26 Source #

type AnonymousWhile = Token "while" 33 Source #

type AnonymousWhen = Token "when" 40 Source #

type AnonymousUntil = Token "until" 34 Source #

type AnonymousUnless = Token "unless" 32 Source #

data Uninterpreted a Source #

Constructors

Uninterpreted 

Fields

Instances

Instances details
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

Unmarshal Uninterpreted Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Uninterpreted a)

Eq a => Eq (Uninterpreted a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Ord a => Ord (Uninterpreted a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Show a => Show (Uninterpreted a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Generic (Uninterpreted a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Associated Types

type Rep (Uninterpreted a) :: Type -> Type #

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.3.2.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.3.2.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

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

symbolMatch :: Proxy True -> Node -> Bool

showFailure :: Proxy True -> Node -> String

Unmarshal True Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (True a)

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.3.2.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.3.2.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

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

symbolMatch :: Proxy Super -> Node -> Bool

showFailure :: Proxy Super -> Node -> String

Unmarshal Super Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Super a)

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.3.2.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.3.2.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

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

symbolMatch :: Proxy Self -> Node -> Bool

showFailure :: Proxy Self -> Node -> String

Unmarshal Self Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Self a)

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.3.2.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.3.2.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

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

symbolMatch :: Proxy Nil -> Node -> Bool

showFailure :: Proxy Nil -> Node -> String

Unmarshal Nil Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Nil a)

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.3.2.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.3.2.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

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

symbolMatch :: Proxy Integer -> Node -> Bool

showFailure :: Proxy Integer -> Node -> String

Unmarshal Integer Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Integer a)

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.3.2.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.3.2.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

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

Unmarshal InstanceVariable Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (InstanceVariable a)

Eq a => Eq (InstanceVariable a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Ord a => Ord (InstanceVariable a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Show a => Show (InstanceVariable a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Generic (InstanceVariable a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Associated Types

type Rep (InstanceVariable a) :: Type -> Type #

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.3.2.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.3.2.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

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

Unmarshal Identifier Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Identifier a)

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

Show a => Show (Identifier a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

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.3.2.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.3.2.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

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

Unmarshal HeredocEnd Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (HeredocEnd a)

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

Show a => Show (HeredocEnd a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

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.3.2.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.3.2.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

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

Unmarshal HeredocBeginning Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (HeredocBeginning a)

Eq a => Eq (HeredocBeginning a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Ord a => Ord (HeredocBeginning a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Show a => Show (HeredocBeginning a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Generic (HeredocBeginning a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Associated Types

type Rep (HeredocBeginning a) :: Type -> Type #

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.3.2.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.3.2.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

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

Unmarshal GlobalVariable Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (GlobalVariable a)

Eq a => Eq (GlobalVariable a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Ord a => Ord (GlobalVariable a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Show a => Show (GlobalVariable a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Generic (GlobalVariable a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Associated Types

type Rep (GlobalVariable a) :: Type -> Type #

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.3.2.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.3.2.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

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

symbolMatch :: Proxy Float -> Node -> Bool

showFailure :: Proxy Float -> Node -> String

Unmarshal Float Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Float a)

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.3.2.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.3.2.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

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

symbolMatch :: Proxy False -> Node -> Bool

showFailure :: Proxy False -> Node -> String

Unmarshal False Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (False a)

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.3.2.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.3.2.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

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

Unmarshal EscapeSequence Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (EscapeSequence a)

Eq a => Eq (EscapeSequence a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Ord a => Ord (EscapeSequence a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Show a => Show (EscapeSequence a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Generic (EscapeSequence a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Associated Types

type Rep (EscapeSequence a) :: Type -> Type #

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.3.2.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.3.2.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

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

symbolMatch :: Proxy Constant -> Node -> Bool

showFailure :: Proxy Constant -> Node -> String

Unmarshal Constant Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Constant a)

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.3.2.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.3.2.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

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

symbolMatch :: Proxy Complex -> Node -> Bool

showFailure :: Proxy Complex -> Node -> String

Unmarshal Complex Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Complex a)

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.3.2.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.3.2.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

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

Unmarshal ClassVariable Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (ClassVariable a)

Eq a => Eq (ClassVariable a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Ord a => Ord (ClassVariable a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Show a => Show (ClassVariable a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Generic (ClassVariable a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Associated Types

type Rep (ClassVariable a) :: Type -> Type #

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.3.2.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.3.2.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

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

symbolMatch :: Proxy Character -> Node -> Bool

showFailure :: Proxy Character -> Node -> String

Unmarshal Character Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Character a)

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

Show a => Show (Character a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

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.3.2.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.3.2.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 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 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

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

symbolMatch :: Proxy Yield -> Node -> Bool

showFailure :: Proxy Yield -> Node -> String

Unmarshal Yield Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Yield a)

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.3.2.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.3.2.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 

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

Unmarshal WhileModifier Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (WhileModifier a)

Eq a => Eq (WhileModifier a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Ord a => Ord (WhileModifier a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Show a => Show (WhileModifier a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Generic (WhileModifier a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Associated Types

type Rep (WhileModifier a) :: Type -> Type #

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.3.2.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.3.2.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

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

symbolMatch :: Proxy While -> Node -> Bool

showFailure :: Proxy While -> Node -> String

Unmarshal While Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (While a)

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.3.2.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.3.2.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

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

symbolMatch :: Proxy When -> Node -> Bool

showFailure :: Proxy When -> Node -> String

Unmarshal When Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (When a)

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.3.2.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

data UntilModifier a Source #

Constructors

UntilModifier 

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

Unmarshal UntilModifier Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (UntilModifier a)

Eq a => Eq (UntilModifier a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Ord a => Ord (UntilModifier a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Show a => Show (UntilModifier a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Generic (UntilModifier a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Associated Types

type Rep (UntilModifier a) :: Type -> Type #

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.3.2.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.3.2.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

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

symbolMatch :: Proxy Until -> Node -> Bool

showFailure :: Proxy Until -> Node -> String

Unmarshal Until Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Until a)

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.3.2.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.3.2.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 

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

Unmarshal UnlessModifier Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (UnlessModifier a)

Eq a => Eq (UnlessModifier a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Ord a => Ord (UnlessModifier a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Show a => Show (UnlessModifier a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Generic (UnlessModifier a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Associated Types

type Rep (UnlessModifier a) :: Type -> Type #

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.3.2.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.3.2.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

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

symbolMatch :: Proxy Unless -> Node -> Bool

showFailure :: Proxy Unless -> Node -> String

Unmarshal Unless Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Unless a)

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.3.2.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

data Undef a Source #

Constructors

Undef 

Fields

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

symbolMatch :: Proxy Undef -> Node -> Bool

showFailure :: Proxy Undef -> Node -> String

Unmarshal Undef Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Undef a)

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.3.2.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.3.2.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 #

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

symbolMatch :: Proxy Unary -> Node -> Bool

showFailure :: Proxy Unary -> Node -> String

Unmarshal Unary Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Unary a)

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.3.2.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.3.2.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

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

symbolMatch :: Proxy Then -> Node -> Bool

showFailure :: Proxy Then -> Node -> String

Unmarshal Then Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Then a)

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.3.2.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.3.2.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

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

Unmarshal SymbolArray Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (SymbolArray a)

Eq a => Eq (SymbolArray a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Ord a => Ord (SymbolArray a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Show a => Show (SymbolArray a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

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.3.2.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.3.2.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 

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

symbolMatch :: Proxy Symbol -> Node -> Bool

showFailure :: Proxy Symbol -> Node -> String

Unmarshal Symbol Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Symbol a)

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.3.2.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.3.2.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

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

Unmarshal Superclass Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Superclass a)

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

Show a => Show (Superclass a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

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.3.2.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.3.2.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 

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

symbolMatch :: Proxy Subshell -> Node -> Bool

showFailure :: Proxy Subshell -> Node -> String

Unmarshal Subshell Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Subshell a)

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.3.2.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.3.2.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

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

Unmarshal StringArray Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (StringArray a)

Eq a => Eq (StringArray a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Ord a => Ord (StringArray a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Show a => Show (StringArray a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

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.3.2.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.3.2.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 

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

symbolMatch :: Proxy String -> Node -> Bool

showFailure :: Proxy String -> Node -> String0

Unmarshal String Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (String a)

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.3.2.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.3.2.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

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

Unmarshal SplatParameter Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (SplatParameter a)

Eq a => Eq (SplatParameter a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Ord a => Ord (SplatParameter a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Show a => Show (SplatParameter a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Generic (SplatParameter a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Associated Types

type Rep (SplatParameter a) :: Type -> Type #

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.3.2.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.3.2.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

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

Unmarshal SplatArgument Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (SplatArgument a)

Eq a => Eq (SplatArgument a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Ord a => Ord (SplatArgument a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Show a => Show (SplatArgument a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Generic (SplatArgument a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Associated Types

type Rep (SplatArgument a) :: Type -> Type #

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.3.2.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.3.2.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 #

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

Unmarshal SingletonMethod Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (SingletonMethod a)

Eq a => Eq (SingletonMethod a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Ord a => Ord (SingletonMethod a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Show a => Show (SingletonMethod a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Generic (SingletonMethod a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Associated Types

type Rep (SingletonMethod a) :: Type -> Type #

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 Rep1 SingletonMethod Source # 
Instance details

Defined in TreeSitter.Ruby.AST

data SingletonClass a Source #

Constructors

SingletonClass 

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

Unmarshal SingletonClass Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (SingletonClass a)

Eq a => Eq (SingletonClass a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Ord a => Ord (SingletonClass a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Show a => Show (SingletonClass a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Generic (SingletonClass a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Associated Types

type Rep (SingletonClass a) :: Type -> Type #

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.3.2.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.3.2.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

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

symbolMatch :: Proxy Setter -> Node -> Bool

showFailure :: Proxy Setter -> Node -> String

Unmarshal Setter Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Setter a)

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.3.2.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.3.2.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

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

Unmarshal ScopeResolution Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (ScopeResolution a)

Eq a => Eq (ScopeResolution a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Ord a => Ord (ScopeResolution a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Show a => Show (ScopeResolution a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Generic (ScopeResolution a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Associated Types

type Rep (ScopeResolution a) :: Type -> Type #

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.3.2.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.3.2.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 #

Instances

Instances details
Functor RightAssignmentList Source # 
Instance details

Defined in TreeSitter.Ruby.AST

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

SymbolMatching RightAssignmentList Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Unmarshal RightAssignmentList Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (RightAssignmentList a)

Eq a => Eq (RightAssignmentList a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Ord a => Ord (RightAssignmentList a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Show a => Show (RightAssignmentList a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Generic (RightAssignmentList a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Associated Types

type Rep (RightAssignmentList a) :: Type -> Type #

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.3.2.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.3.2.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

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

symbolMatch :: Proxy Return -> Node -> Bool

showFailure :: Proxy Return -> Node -> String

Unmarshal Return Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Return a)

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.3.2.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.3.2.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

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

symbolMatch :: Proxy Retry -> Node -> Bool

showFailure :: Proxy Retry -> Node -> String

Unmarshal Retry Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Retry a)

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.3.2.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.3.2.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

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

Unmarshal RestAssignment Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (RestAssignment a)

Eq a => Eq (RestAssignment a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Ord a => Ord (RestAssignment a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Show a => Show (RestAssignment a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Generic (RestAssignment a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Associated Types

type Rep (RestAssignment a) :: Type -> Type #

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.3.2.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.3.2.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 

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

Unmarshal RescueModifier Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (RescueModifier a)

Eq a => Eq (RescueModifier a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Ord a => Ord (RescueModifier a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Show a => Show (RescueModifier a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Generic (RescueModifier a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Associated Types

type Rep (RescueModifier a) :: Type -> Type #

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.3.2.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.3.2.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

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

symbolMatch :: Proxy Rescue -> Node -> Bool

showFailure :: Proxy Rescue -> Node -> String

Unmarshal Rescue Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Rescue a)

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.3.2.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

data Regex a Source #

Constructors

Regex 

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

symbolMatch :: Proxy Regex -> Node -> Bool

showFailure :: Proxy Regex -> Node -> String

Unmarshal Regex Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Regex a)

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.3.2.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.3.2.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

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

symbolMatch :: Proxy Redo -> Node -> Bool

showFailure :: Proxy Redo -> Node -> String

Unmarshal Redo Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Redo a)

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.3.2.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.3.2.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

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

symbolMatch :: Proxy Rational -> Node -> Bool

showFailure :: Proxy Rational -> Node -> String

Unmarshal Rational Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Rational a)

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.3.2.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.3.2.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

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

symbolMatch :: Proxy Range -> Node -> Bool

showFailure :: Proxy Range -> Node -> String

Unmarshal Range Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Range a)

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.3.2.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.3.2.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 

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

symbolMatch :: Proxy Program -> Node -> Bool

showFailure :: Proxy Program -> Node -> String

Unmarshal Program Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Program a)

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.3.2.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.3.2.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

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

symbolMatch :: Proxy Pattern -> Node -> Bool

showFailure :: Proxy Pattern -> Node -> String

Unmarshal Pattern Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Pattern a)

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.3.2.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.3.2.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 #

Instances

Instances details
Functor ParenthesizedStatements Source # 
Instance details

Defined in TreeSitter.Ruby.AST

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

SymbolMatching ParenthesizedStatements Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Unmarshal ParenthesizedStatements Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (ParenthesizedStatements a)

Eq a => Eq (ParenthesizedStatements a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Ord a => Ord (ParenthesizedStatements a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Show a => Show (ParenthesizedStatements a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Generic (ParenthesizedStatements a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Associated Types

type Rep (ParenthesizedStatements a) :: Type -> Type #

Generic1 ParenthesizedStatements Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Associated Types

type Rep1 ParenthesizedStatements :: k -> Type #

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.3.2.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.3.2.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

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

symbolMatch :: Proxy Pair -> Node -> Bool

showFailure :: Proxy Pair -> Node -> String

Unmarshal Pair Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Pair a)

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.3.2.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.3.2.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

Instances

Instances details
Functor OptionalParameter Source # 
Instance details

Defined in TreeSitter.Ruby.AST

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

Unmarshal OptionalParameter Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (OptionalParameter a)

Eq a => Eq (OptionalParameter a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Ord a => Ord (OptionalParameter a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Show a => Show (OptionalParameter a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Generic (OptionalParameter a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Associated Types

type Rep (OptionalParameter a) :: Type -> Type #

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.3.2.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.3.2.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

Instances

Instances details
Functor OperatorAssignment Source # 
Instance details

Defined in TreeSitter.Ruby.AST

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

SymbolMatching OperatorAssignment Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Unmarshal OperatorAssignment Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (OperatorAssignment a)

Eq a => Eq (OperatorAssignment a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Ord a => Ord (OperatorAssignment a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Show a => Show (OperatorAssignment a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Generic (OperatorAssignment a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Associated Types

type Rep (OperatorAssignment a) :: Type -> Type #

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.3.2.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.3.2.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

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

symbolMatch :: Proxy Operator -> Node -> Bool

showFailure :: Proxy Operator -> Node -> String

Unmarshal Operator Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Operator a)

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.3.2.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.3.2.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

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

symbolMatch :: Proxy Next -> Node -> Bool

showFailure :: Proxy Next -> Node -> String

Unmarshal Next Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Next a)

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.3.2.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.3.2.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 #

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

symbolMatch :: Proxy Module -> Node -> Bool

showFailure :: Proxy Module -> Node -> String

Unmarshal Module Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Module a)

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.3.2.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

data MethodParameters a Source #

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

Unmarshal MethodParameters Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (MethodParameters a)

Eq a => Eq (MethodParameters a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Ord a => Ord (MethodParameters a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Show a => Show (MethodParameters a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Generic (MethodParameters a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Associated Types

type Rep (MethodParameters a) :: Type -> Type #

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.3.2.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

data MethodCall a Source #

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

Unmarshal MethodCall Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (MethodCall a)

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

Show a => Show (MethodCall a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

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.3.2.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

data Method a Source #

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

symbolMatch :: Proxy Method -> Node -> Bool

showFailure :: Proxy Method -> Node -> String

Unmarshal Method Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Method a)

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 Rep1 Method Source # 
Instance details

Defined in TreeSitter.Ruby.AST

data LeftAssignmentList a Source #

Instances

Instances details
Functor LeftAssignmentList Source # 
Instance details

Defined in TreeSitter.Ruby.AST

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

SymbolMatching LeftAssignmentList Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Unmarshal LeftAssignmentList Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (LeftAssignmentList a)

Eq a => Eq (LeftAssignmentList a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Ord a => Ord (LeftAssignmentList a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Show a => Show (LeftAssignmentList a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Generic (LeftAssignmentList a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Associated Types

type Rep (LeftAssignmentList a) :: Type -> Type #

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.3.2.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.3.2.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 #

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

Unmarshal LambdaParameters Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (LambdaParameters a)

Eq a => Eq (LambdaParameters a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Ord a => Ord (LambdaParameters a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Show a => Show (LambdaParameters a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Generic (LambdaParameters a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Associated Types

type Rep (LambdaParameters a) :: Type -> Type #

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.3.2.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

data Lambda a Source #

Constructors

Lambda 

Fields

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

symbolMatch :: Proxy Lambda -> Node -> Bool

showFailure :: Proxy Lambda -> Node -> String

Unmarshal Lambda Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Lambda a)

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.3.2.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.3.2.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

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

Unmarshal KeywordParameter Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (KeywordParameter a)

Eq a => Eq (KeywordParameter a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Ord a => Ord (KeywordParameter a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Show a => Show (KeywordParameter a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Generic (KeywordParameter a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Associated Types

type Rep (KeywordParameter a) :: Type -> Type #

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.3.2.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.3.2.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

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

Unmarshal Interpolation Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Interpolation a)

Eq a => Eq (Interpolation a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Ord a => Ord (Interpolation a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Show a => Show (Interpolation a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Generic (Interpolation a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Associated Types

type Rep (Interpolation a) :: Type -> Type #

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.3.2.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.3.2.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

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

symbolMatch :: Proxy In -> Node -> Bool

showFailure :: Proxy In -> Node -> String

Unmarshal In Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (In a)

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.3.2.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.3.2.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 

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

Unmarshal IfModifier Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (IfModifier a)

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

Show a => Show (IfModifier a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

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.3.2.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.3.2.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

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

symbolMatch :: Proxy If -> Node -> Bool

showFailure :: Proxy If -> Node -> String

Unmarshal If Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (If a)

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.3.2.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

data HashSplatParameter a Source #

Constructors

HashSplatParameter 

Fields

Instances

Instances details
Functor HashSplatParameter Source # 
Instance details

Defined in TreeSitter.Ruby.AST

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

SymbolMatching HashSplatParameter Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Unmarshal HashSplatParameter Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (HashSplatParameter a)

Eq a => Eq (HashSplatParameter a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Ord a => Ord (HashSplatParameter a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Show a => Show (HashSplatParameter a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Generic (HashSplatParameter a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Associated Types

type Rep (HashSplatParameter a) :: Type -> Type #

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.3.2.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.3.2.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

Instances

Instances details
Functor HashSplatArgument Source # 
Instance details

Defined in TreeSitter.Ruby.AST

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

Unmarshal HashSplatArgument Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (HashSplatArgument a)

Eq a => Eq (HashSplatArgument a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Ord a => Ord (HashSplatArgument a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Show a => Show (HashSplatArgument a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Generic (HashSplatArgument a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Associated Types

type Rep (HashSplatArgument a) :: Type -> Type #

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.3.2.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.3.2.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

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

symbolMatch :: Proxy Hash -> Node -> Bool

showFailure :: Proxy Hash -> Node -> String

Unmarshal Hash Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Hash a)

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.3.2.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.3.2.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 

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

symbolMatch :: Proxy For -> Node -> Bool

showFailure :: Proxy For -> Node -> String

Unmarshal For Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (For a)

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 Rep1 For Source # 
Instance details

Defined in TreeSitter.Ruby.AST

data Exceptions a Source #

Constructors

Exceptions 

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

Unmarshal Exceptions Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Exceptions a)

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

Show a => Show (Exceptions a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

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.3.2.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.3.2.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

Instances

Instances details
Functor ExceptionVariable Source # 
Instance details

Defined in TreeSitter.Ruby.AST

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

Unmarshal ExceptionVariable Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (ExceptionVariable a)

Eq a => Eq (ExceptionVariable a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Ord a => Ord (ExceptionVariable a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Show a => Show (ExceptionVariable a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Generic (ExceptionVariable a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Associated Types

type Rep (ExceptionVariable a) :: Type -> Type #

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.3.2.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.3.2.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

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

symbolMatch :: Proxy Ensure -> Node -> Bool

showFailure :: Proxy Ensure -> Node -> String

Unmarshal Ensure Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Ensure a)

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.3.2.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.3.2.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

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

symbolMatch :: Proxy EndBlock -> Node -> Bool

showFailure :: Proxy EndBlock -> Node -> String

Unmarshal EndBlock Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (EndBlock a)

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.3.2.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.3.2.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

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

Unmarshal EmptyStatement Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (EmptyStatement a)

Eq a => Eq (EmptyStatement a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Ord a => Ord (EmptyStatement a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Show a => Show (EmptyStatement a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Generic (EmptyStatement a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Associated Types

type Rep (EmptyStatement a) :: Type -> Type #

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.3.2.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.3.2.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

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

symbolMatch :: Proxy Elsif -> Node -> Bool

showFailure :: Proxy Elsif -> Node -> String

Unmarshal Elsif Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Elsif a)

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.3.2.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

data Else a Source #

Constructors

Else 

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

symbolMatch :: Proxy Else -> Node -> Bool

showFailure :: Proxy Else -> Node -> String

Unmarshal Else Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Else a)

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.3.2.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.3.2.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 #

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

Unmarshal ElementReference Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (ElementReference a)

Eq a => Eq (ElementReference a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Ord a => Ord (ElementReference a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Show a => Show (ElementReference a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Generic (ElementReference a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Associated Types

type Rep (ElementReference a) :: Type -> Type #

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.3.2.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.3.2.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 #

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

symbolMatch :: Proxy DoBlock -> Node -> Bool

showFailure :: Proxy DoBlock -> Node -> String

Unmarshal DoBlock Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (DoBlock a)

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.3.2.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.3.2.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

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

symbolMatch :: Proxy Do -> Node -> Bool

showFailure :: Proxy Do -> Node -> String

Unmarshal Do Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Do a)

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.3.2.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.3.2.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 #

Instances

Instances details
Functor DestructuredParameter Source # 
Instance details

Defined in TreeSitter.Ruby.AST

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

SymbolMatching DestructuredParameter Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Unmarshal DestructuredParameter Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (DestructuredParameter a)

Eq a => Eq (DestructuredParameter a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Ord a => Ord (DestructuredParameter a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Show a => Show (DestructuredParameter a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Generic (DestructuredParameter a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Associated Types

type Rep (DestructuredParameter a) :: Type -> Type #

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.3.2.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.3.2.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 #

Instances

Instances details
Functor DestructuredLeftAssignment Source # 
Instance details

Defined in TreeSitter.Ruby.AST

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

SymbolMatching DestructuredLeftAssignment Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Unmarshal DestructuredLeftAssignment Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (DestructuredLeftAssignment a)

Eq a => Eq (DestructuredLeftAssignment a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Ord a => Ord (DestructuredLeftAssignment a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Show a => Show (DestructuredLeftAssignment a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Generic (DestructuredLeftAssignment a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Associated Types

type Rep (DestructuredLeftAssignment a) :: Type -> Type #

Generic1 DestructuredLeftAssignment Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Associated Types

type Rep1 DestructuredLeftAssignment :: k -> Type #

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.3.2.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.3.2.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

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

Unmarshal Conditional Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Conditional a)

Eq a => Eq (Conditional a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Ord a => Ord (Conditional a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Show a => Show (Conditional a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

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.3.2.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.3.2.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 #

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

symbolMatch :: Proxy Class -> Node -> Bool

showFailure :: Proxy Class -> Node -> String

Unmarshal Class Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Class a)

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.3.2.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

data ChainedString a Source #

Constructors

ChainedString 

Fields

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

Unmarshal ChainedString Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (ChainedString a)

Eq a => Eq (ChainedString a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Ord a => Ord (ChainedString a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Show a => Show (ChainedString a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Generic (ChainedString a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Associated Types

type Rep (ChainedString a) :: Type -> Type #

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.3.2.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.3.2.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

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

symbolMatch :: Proxy Case -> Node -> Bool

showFailure :: Proxy Case -> Node -> String

Unmarshal Case Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Case a)

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.3.2.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.3.2.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 

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

symbolMatch :: Proxy Call -> Node -> Bool

showFailure :: Proxy Call -> Node -> String

Unmarshal Call Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Call a)

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.3.2.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

data Break a Source #

Constructors

Break 

Fields

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

symbolMatch :: Proxy Break -> Node -> Bool

showFailure :: Proxy Break -> Node -> String

Unmarshal Break Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Break a)

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.3.2.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.3.2.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 #

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

Unmarshal BlockParameters Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (BlockParameters a)

Eq a => Eq (BlockParameters a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Ord a => Ord (BlockParameters a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Show a => Show (BlockParameters a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Generic (BlockParameters a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Associated Types

type Rep (BlockParameters a) :: Type -> Type #

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.3.2.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

data BlockParameter a Source #

Constructors

BlockParameter 

Fields

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

Unmarshal BlockParameter Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (BlockParameter a)

Eq a => Eq (BlockParameter a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Ord a => Ord (BlockParameter a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Show a => Show (BlockParameter a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Generic (BlockParameter a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Associated Types

type Rep (BlockParameter a) :: Type -> Type #

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.3.2.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.3.2.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

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

Unmarshal BlockArgument Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (BlockArgument a)

Eq a => Eq (BlockArgument a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Ord a => Ord (BlockArgument a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Show a => Show (BlockArgument a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Generic (BlockArgument a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Associated Types

type Rep (BlockArgument a) :: Type -> Type #

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.3.2.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.3.2.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 

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

symbolMatch :: Proxy Block -> Node -> Bool

showFailure :: Proxy Block -> Node -> String

Unmarshal Block Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Block a)

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.3.2.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.3.2.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 #

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

symbolMatch :: Proxy Binary -> Node -> Bool

showFailure :: Proxy Binary -> Node -> String

Unmarshal Binary Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Binary a)

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 Rep1 Binary Source # 
Instance details

Defined in TreeSitter.Ruby.AST

data BeginBlock a Source #

Constructors

BeginBlock 

Fields

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

Unmarshal BeginBlock Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (BeginBlock a)

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

Show a => Show (BeginBlock a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

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.3.2.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.3.2.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 

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

symbolMatch :: Proxy Begin -> Node -> Bool

showFailure :: Proxy Begin -> Node -> String

Unmarshal Begin Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Begin a)

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.3.2.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.3.2.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 

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

Unmarshal BareSymbol Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (BareSymbol a)

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

Show a => Show (BareSymbol a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

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.3.2.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.3.2.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 

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

Unmarshal BareString Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (BareString a)

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

Show a => Show (BareString a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

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.3.2.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.3.2.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 #

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

Unmarshal Assignment Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Assignment a)

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

Show a => Show (Assignment a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

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 Rep1 Assignment Source # 
Instance details

Defined in TreeSitter.Ruby.AST

data Array a Source #

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

symbolMatch :: Proxy Array -> Node -> Bool

showFailure :: Proxy Array -> Node -> String

Unmarshal Array Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Array a)

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.3.2.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.3.2.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 #

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

Unmarshal ArgumentList Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (ArgumentList a)

Eq a => Eq (ArgumentList a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Ord a => Ord (ArgumentList a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Show a => Show (ArgumentList a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

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.3.2.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.3.2.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

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

symbolMatch :: Proxy Alias -> Node -> Bool

showFailure :: Proxy Alias -> Node -> String

Unmarshal Alias Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Alias a)

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.3.2.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.3.2.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 #

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

symbolMatch :: Proxy Variable -> Node -> Bool

showFailure :: Proxy Variable -> Node -> String

Unmarshal Variable Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Variable 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.3.2.0-inplace" 'True) (C1 ('MetaCons "Variable" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) '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.3.2.0-inplace" 'True) (C1 ('MetaCons "Variable" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 ((ClassVariable :+: (Constant :+: GlobalVariable)) :+: ((Identifier :+: InstanceVariable) :+: (Self :+: Super))))))

newtype Statement a Source #

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

symbolMatch :: Proxy Statement -> Node -> Bool

showFailure :: Proxy Statement -> Node -> String

Unmarshal Statement Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Statement 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

Show a => Show (Statement a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

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 Rep1 Statement Source # 
Instance details

Defined in TreeSitter.Ruby.AST

newtype Primary a Source #

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

symbolMatch :: Proxy Primary -> Node -> Bool

showFailure :: Proxy Primary -> Node -> String

Unmarshal Primary Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Primary 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 Rep1 Primary Source # 
Instance details

Defined in TreeSitter.Ruby.AST

newtype MethodName a Source #

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

Unmarshal MethodName Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (MethodName 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

Show a => Show (MethodName a) Source # 
Instance details

Defined in TreeSitter.Ruby.AST

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.3.2.0-inplace" 'True) (C1 ('MetaCons "MethodName" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) '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.3.2.0-inplace" 'True) (C1 ('MetaCons "MethodName" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 (((ClassVariable :+: Constant) :+: (GlobalVariable :+: Identifier)) :+: ((InstanceVariable :+: Operator) :+: (Setter :+: Symbol))))))

newtype Lhs a Source #

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

symbolMatch :: Proxy Lhs -> Node -> Bool

showFailure :: Proxy Lhs -> Node -> String

Unmarshal Lhs Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Lhs 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.3.2.0-inplace" 'True) (C1 ('MetaCons "Lhs" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) '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.3.2.0-inplace" 'True) (C1 ('MetaCons "Lhs" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 (((Variable :+: Call) :+: (ElementReference :+: False)) :+: ((MethodCall :+: Nil) :+: (ScopeResolution :+: True))))))

newtype Arg a Source #

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

symbolMatch :: Proxy Arg -> Node -> Bool

showFailure :: Proxy Arg -> Node -> String

Unmarshal Arg Source # 
Instance details

Defined in TreeSitter.Ruby.AST

Methods

unmarshalNode :: forall (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader ByteString) sig m, Has (Reader (Ptr Cursor)) sig m, MonadFail m, MonadIO m, UnmarshalAnn a) => Node -> m (Arg 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.3.2.0-inplace" 'True) (C1 ('MetaCons "Arg" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) '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.3.2.0-inplace" 'True) (C1 ('MetaCons "Arg" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 ((Primary :+: (Assignment :+: Binary)) :+: ((Conditional :+: OperatorAssignment) :+: (Range :+: Unary))))))