hydra-go
  • hydra
    • hydra namespace
      • Subpackages
        • hydra.go namespace
          • Submodules
            • hydra.go.language module
              • go_language()
              • go_reserved_words()
            • hydra.go.syntax module
              • AddOp
                • AddOp.ADD
                • AddOp.BITWISE_OR
                • AddOp.BITWISE_XOR
                • AddOp.SUBTRACT
                • AddOp.TYPE_
              • AliasDecl
                • AliasDecl.Builder
                  • AliasDecl.Builder.build()
                  • AliasDecl.Builder.name()
                  • AliasDecl.Builder.type()
                • AliasDecl.NAME
                • AliasDecl.TYPE
                • AliasDecl.TYPE_
                • AliasDecl.builder()
                • AliasDecl.name
                • AliasDecl.type
                • AliasDecl.with_name()
                • AliasDecl.with_type()
              • AnnotatedDeclaration
                • AnnotatedDeclaration.Builder
                  • AnnotatedDeclaration.Builder.build()
                  • AnnotatedDeclaration.Builder.comment()
                  • AnnotatedDeclaration.Builder.declaration()
                • AnnotatedDeclaration.COMMENT
                • AnnotatedDeclaration.DECLARATION
                • AnnotatedDeclaration.TYPE_
                • AnnotatedDeclaration.builder()
                • AnnotatedDeclaration.comment
                • AnnotatedDeclaration.declaration
                • AnnotatedDeclaration.with_comment()
                • AnnotatedDeclaration.with_declaration()
              • Arguments
                • Arguments.Builder
                  • Arguments.Builder.build()
                  • Arguments.Builder.ellipsis()
                  • Arguments.Builder.expressions()
                  • Arguments.Builder.type_arg()
                • Arguments.ELLIPSIS
                • Arguments.EXPRESSIONS
                • Arguments.TYPE_
                • Arguments.TYPE_ARG
                • Arguments.builder()
                • Arguments.ellipsis
                • Arguments.expressions
                • Arguments.type_arg
                • Arguments.with_ellipsis()
                • Arguments.with_expressions()
                • Arguments.with_type_arg()
              • ArrayType
                • ArrayType.Builder
                  • ArrayType.Builder.build()
                  • ArrayType.Builder.element()
                  • ArrayType.Builder.length()
                • ArrayType.ELEMENT
                • ArrayType.LENGTH
                • ArrayType.TYPE_
                • ArrayType.builder()
                • ArrayType.element
                • ArrayType.length
                • ArrayType.with_element()
                • ArrayType.with_length()
              • AssignOp
                • AssignOp.ADD
                • AssignOp.MUL
                • AssignOp.SIMPLE
                • AssignOp.TYPE_
              • AssignOpAdd
              • AssignOpMul
              • AssignOpSimple
              • Assignment
                • Assignment.Builder
                  • Assignment.Builder.build()
                  • Assignment.Builder.lhs()
                  • Assignment.Builder.op()
                  • Assignment.Builder.rhs()
                • Assignment.LHS
                • Assignment.OP
                • Assignment.RHS
                • Assignment.TYPE_
                • Assignment.builder()
                • Assignment.lhs
                • Assignment.op
                • Assignment.rhs
                • Assignment.with_lhs()
                • Assignment.with_op()
                • Assignment.with_rhs()
              • BasicLit
                • BasicLit.FLOAT
                • BasicLit.IMAGINARY
                • BasicLit.INT
                • BasicLit.RUNE
                • BasicLit.STRING
                • BasicLit.TYPE_
              • BasicLitFloat
              • BasicLitImaginary
              • BasicLitInt
              • BasicLitRune
              • BasicLitString
              • BinaryExpr
                • BinaryExpr.Builder
                  • BinaryExpr.Builder.build()
                  • BinaryExpr.Builder.left()
                  • BinaryExpr.Builder.op()
                  • BinaryExpr.Builder.right()
                • BinaryExpr.LEFT
                • BinaryExpr.OP
                • BinaryExpr.RIGHT
                • BinaryExpr.TYPE_
                • BinaryExpr.builder()
                • BinaryExpr.left
                • BinaryExpr.op
                • BinaryExpr.right
                • BinaryExpr.with_left()
                • BinaryExpr.with_op()
                • BinaryExpr.with_right()
              • BinaryOp
                • BinaryOp.ADD
                • BinaryOp.AND
                • BinaryOp.BITWISE_AND
                • BinaryOp.BITWISE_OR
                • BinaryOp.BITWISE_XOR
                • BinaryOp.BIT_CLEAR
                • BinaryOp.DIVIDE
                • BinaryOp.EQUAL
                • BinaryOp.GREATER
                • BinaryOp.GREATER_EQUAL
                • BinaryOp.LEFT_SHIFT
                • BinaryOp.LESS
                • BinaryOp.LESS_EQUAL
                • BinaryOp.MULTIPLY
                • BinaryOp.NOT_EQUAL
                • BinaryOp.OR
                • BinaryOp.REMAINDER
                • BinaryOp.RIGHT_SHIFT
                • BinaryOp.SUBTRACT
                • BinaryOp.TYPE_
              • Block
                • Block.TYPE_
              • BreakStmt
                • BreakStmt.TYPE_
              • CallExpr
                • CallExpr.ARGUMENTS
                • CallExpr.Builder
                  • CallExpr.Builder.arguments()
                  • CallExpr.Builder.build()
                  • CallExpr.Builder.function()
                • CallExpr.FUNCTION
                • CallExpr.TYPE_
                • CallExpr.arguments
                • CallExpr.builder()
                • CallExpr.function
                • CallExpr.with_arguments()
                • CallExpr.with_function()
              • ChannelDirection
                • ChannelDirection.BIDIRECTIONAL
                • ChannelDirection.RECEIVE
                • ChannelDirection.SEND
                • ChannelDirection.TYPE_
              • ChannelType
                • ChannelType.Builder
                  • ChannelType.Builder.build()
                  • ChannelType.Builder.direction()
                  • ChannelType.Builder.element()
                • ChannelType.DIRECTION
                • ChannelType.ELEMENT
                • ChannelType.TYPE_
                • ChannelType.builder()
                • ChannelType.direction
                • ChannelType.element
                • ChannelType.with_direction()
                • ChannelType.with_element()
              • CommCase
                • CommCase.DEFAULT
                • CommCase.RECEIVE
                • CommCase.SEND
                • CommCase.TYPE_
              • CommCaseDefault
              • CommCaseReceive
              • CommCaseSend
              • CommClause
                • CommClause.Builder
                  • CommClause.Builder.build()
                  • CommClause.Builder.case()
                  • CommClause.Builder.statements()
                • CommClause.CASE
                • CommClause.STATEMENTS
                • CommClause.TYPE_
                • CommClause.builder()
                • CommClause.case
                • CommClause.statements
                • CommClause.with_case()
                • CommClause.with_statements()
              • CompositeLit
                • CompositeLit.Builder
                  • CompositeLit.Builder.build()
                  • CompositeLit.Builder.type()
                  • CompositeLit.Builder.value()
                • CompositeLit.TYPE
                • CompositeLit.TYPE_
                • CompositeLit.VALUE
                • CompositeLit.builder()
                • CompositeLit.type
                • CompositeLit.value
                • CompositeLit.with_type()
                • CompositeLit.with_value()
              • ConstDecl
                • ConstDecl.TYPE_
              • ConstSpec
                • ConstSpec.Builder
                  • ConstSpec.Builder.build()
                  • ConstSpec.Builder.names()
                  • ConstSpec.Builder.type()
                  • ConstSpec.Builder.values()
                • ConstSpec.NAMES
                • ConstSpec.TYPE
                • ConstSpec.TYPE_
                • ConstSpec.VALUES
                • ConstSpec.builder()
                • ConstSpec.names
                • ConstSpec.type
                • ConstSpec.values
                • ConstSpec.with_names()
                • ConstSpec.with_type()
                • ConstSpec.with_values()
              • ContinueStmt
                • ContinueStmt.TYPE_
              • Conversion
                • Conversion.Builder
                  • Conversion.Builder.build()
                  • Conversion.Builder.expression()
                  • Conversion.Builder.type()
                • Conversion.EXPRESSION
                • Conversion.TYPE
                • Conversion.TYPE_
                • Conversion.builder()
                • Conversion.expression
                • Conversion.type
                • Conversion.with_expression()
                • Conversion.with_type()
              • Declaration
                • Declaration.CONST
                • Declaration.TYPE
                • Declaration.TYPE_
                • Declaration.VAR
              • DeclarationConst
              • DeclarationType
              • DeclarationVar
              • DeferStmt
                • DeferStmt.TYPE_
              • Element
                • Element.EXPRESSION
                • Element.LITERAL
                • Element.TYPE_
              • ElementExpression
              • ElementList
                • ElementList.TYPE_
              • ElementLiteral
              • ElseClause
                • ElseClause.BLOCK
                • ElseClause.IF
                • ElseClause.TYPE_
              • ElseClauseBlock
              • ElseClauseIf
              • EmbeddedField
                • EmbeddedField.Builder
                  • EmbeddedField.Builder.build()
                  • EmbeddedField.Builder.pointer()
                  • EmbeddedField.Builder.tag()
                  • EmbeddedField.Builder.type()
                • EmbeddedField.POINTER
                • EmbeddedField.TAG
                • EmbeddedField.TYPE
                • EmbeddedField.TYPE_
                • EmbeddedField.builder()
                • EmbeddedField.pointer
                • EmbeddedField.tag
                • EmbeddedField.type
                • EmbeddedField.with_pointer()
                • EmbeddedField.with_tag()
                • EmbeddedField.with_type()
              • EmptyStmt
                • EmptyStmt.TYPE_
              • ExprCaseClause
                • ExprCaseClause.Builder
                  • ExprCaseClause.Builder.build()
                  • ExprCaseClause.Builder.case()
                  • ExprCaseClause.Builder.statements()
                • ExprCaseClause.CASE
                • ExprCaseClause.STATEMENTS
                • ExprCaseClause.TYPE_
                • ExprCaseClause.builder()
                • ExprCaseClause.case
                • ExprCaseClause.statements
                • ExprCaseClause.with_case()
                • ExprCaseClause.with_statements()
              • ExprSwitchStmt
                • ExprSwitchStmt.Builder
                  • ExprSwitchStmt.Builder.build()
                  • ExprSwitchStmt.Builder.cases()
                  • ExprSwitchStmt.Builder.expression()
                  • ExprSwitchStmt.Builder.init()
                • ExprSwitchStmt.CASES
                • ExprSwitchStmt.EXPRESSION
                • ExprSwitchStmt.INIT
                • ExprSwitchStmt.TYPE_
                • ExprSwitchStmt.builder()
                • ExprSwitchStmt.cases
                • ExprSwitchStmt.expression
                • ExprSwitchStmt.init
                • ExprSwitchStmt.with_cases()
                • ExprSwitchStmt.with_expression()
                • ExprSwitchStmt.with_init()
              • Expression
                • Expression.BINARY
                • Expression.TYPE_
                • Expression.UNARY
              • ExpressionBinary
              • ExpressionStmt
                • ExpressionStmt.TYPE_
              • ExpressionUnary
              • FallthroughStmt
                • FallthroughStmt.TYPE_
              • FieldDecl
                • FieldDecl.EMBEDDED
                • FieldDecl.NAMED
                • FieldDecl.TYPE_
              • FieldDeclEmbedded
              • FieldDeclNamed
              • FloatLit
                • FloatLit.TYPE_
              • ForClause
                • ForClause.Builder
                  • ForClause.Builder.build()
                  • ForClause.Builder.condition()
                  • ForClause.Builder.init()
                  • ForClause.Builder.post()
                • ForClause.CONDITION
                • ForClause.INIT
                • ForClause.POST
                • ForClause.TYPE_
                • ForClause.builder()
                • ForClause.condition
                • ForClause.init
                • ForClause.post
                • ForClause.with_condition()
                • ForClause.with_init()
                • ForClause.with_post()
              • ForClauseOrRange
                • ForClauseOrRange.CLAUSE
                • ForClauseOrRange.CONDITION
                • ForClauseOrRange.RANGE
                • ForClauseOrRange.TYPE_
              • ForClauseOrRangeClause
              • ForClauseOrRangeCondition
              • ForClauseOrRangeRange
              • ForStmt
                • ForStmt.BODY
                • ForStmt.Builder
                  • ForStmt.Builder.body()
                  • ForStmt.Builder.build()
                  • ForStmt.Builder.clause()
                • ForStmt.CLAUSE
                • ForStmt.TYPE_
                • ForStmt.body
                • ForStmt.builder()
                • ForStmt.clause
                • ForStmt.with_body()
                • ForStmt.with_clause()
              • FullSlice
                • FullSlice.Builder
                  • FullSlice.Builder.build()
                  • FullSlice.Builder.high()
                  • FullSlice.Builder.low()
                  • FullSlice.Builder.max()
                • FullSlice.HIGH
                • FullSlice.LOW
                • FullSlice.MAX
                • FullSlice.TYPE_
                • FullSlice.builder()
                • FullSlice.high
                • FullSlice.low
                • FullSlice.max
                • FullSlice.with_high()
                • FullSlice.with_low()
                • FullSlice.with_max()
              • FunctionBody
                • FunctionBody.TYPE_
              • FunctionDecl
                • FunctionDecl.BODY
                • FunctionDecl.Builder
                  • FunctionDecl.Builder.body()
                  • FunctionDecl.Builder.build()
                  • FunctionDecl.Builder.name()
                  • FunctionDecl.Builder.signature()
                  • FunctionDecl.Builder.type_params()
                • FunctionDecl.NAME
                • FunctionDecl.SIGNATURE
                • FunctionDecl.TYPE_
                • FunctionDecl.TYPE_PARAMS
                • FunctionDecl.body
                • FunctionDecl.builder()
                • FunctionDecl.name
                • FunctionDecl.signature
                • FunctionDecl.type_params
                • FunctionDecl.with_body()
                • FunctionDecl.with_name()
                • FunctionDecl.with_signature()
                • FunctionDecl.with_type_params()
              • FunctionLit
                • FunctionLit.BODY
                • FunctionLit.Builder
                  • FunctionLit.Builder.body()
                  • FunctionLit.Builder.build()
                  • FunctionLit.Builder.signature()
                • FunctionLit.SIGNATURE
                • FunctionLit.TYPE_
                • FunctionLit.body
                • FunctionLit.builder()
                • FunctionLit.signature
                • FunctionLit.with_body()
                • FunctionLit.with_signature()
              • FunctionType
                • FunctionType.TYPE_
              • GoStmt
                • GoStmt.TYPE_
              • GotoStmt
                • GotoStmt.TYPE_
              • Identifier
                • Identifier.TYPE_
              • IfStmt
                • IfStmt.Builder
                  • IfStmt.Builder.build()
                  • IfStmt.Builder.condition()
                  • IfStmt.Builder.else_()
                  • IfStmt.Builder.init()
                  • IfStmt.Builder.then()
                • IfStmt.CONDITION
                • IfStmt.ELSE
                • IfStmt.INIT
                • IfStmt.THEN
                • IfStmt.TYPE_
                • IfStmt.builder()
                • IfStmt.condition
                • IfStmt.else_
                • IfStmt.init
                • IfStmt.then
                • IfStmt.with_condition()
                • IfStmt.with_else_()
                • IfStmt.with_init()
                • IfStmt.with_then()
              • ImaginaryLit
                • ImaginaryLit.TYPE_
              • ImportAlias
                • ImportAlias.DOT
                • ImportAlias.NAME
                • ImportAlias.TYPE_
              • ImportAliasDot
              • ImportAliasName
              • ImportDecl
                • ImportDecl.TYPE_
              • ImportPath
                • ImportPath.TYPE_
              • ImportSpec
                • ImportSpec.ALIAS
                • ImportSpec.Builder
                  • ImportSpec.Builder.alias()
                  • ImportSpec.Builder.build()
                  • ImportSpec.Builder.path()
                • ImportSpec.PATH
                • ImportSpec.TYPE_
                • ImportSpec.alias
                • ImportSpec.builder()
                • ImportSpec.path
                • ImportSpec.with_alias()
                • ImportSpec.with_path()
              • IncDecStmt
                • IncDecStmt.Builder
                  • IncDecStmt.Builder.build()
                  • IncDecStmt.Builder.expression()
                  • IncDecStmt.Builder.increment()
                • IncDecStmt.EXPRESSION
                • IncDecStmt.INCREMENT
                • IncDecStmt.TYPE_
                • IncDecStmt.builder()
                • IncDecStmt.expression
                • IncDecStmt.increment
                • IncDecStmt.with_expression()
                • IncDecStmt.with_increment()
              • Index
                • Index.TYPE_
              • IndexExpr
                • IndexExpr.Builder
                  • IndexExpr.Builder.build()
                  • IndexExpr.Builder.expr()
                  • IndexExpr.Builder.index()
                • IndexExpr.EXPR
                • IndexExpr.INDEX
                • IndexExpr.TYPE_
                • IndexExpr.builder()
                • IndexExpr.expr
                • IndexExpr.index
                • IndexExpr.with_expr()
                • IndexExpr.with_index()
              • IntLit
                • IntLit.TYPE_
              • InterfaceElem
                • InterfaceElem.METHOD
                • InterfaceElem.TYPE
                • InterfaceElem.TYPE_
              • InterfaceElemMethod
              • InterfaceElemType
              • InterfaceType
                • InterfaceType.TYPE_
              • InterpretedStringLit
                • InterpretedStringLit.TYPE_
              • Key
                • Key.EXPRESSION
                • Key.FIELD
                • Key.LITERAL
                • Key.TYPE_
              • KeyExpression
              • KeyField
              • KeyLiteral
              • KeyedElement
                • KeyedElement.Builder
                  • KeyedElement.Builder.build()
                  • KeyedElement.Builder.element()
                  • KeyedElement.Builder.key()
                • KeyedElement.ELEMENT
                • KeyedElement.KEY
                • KeyedElement.TYPE_
                • KeyedElement.builder()
                • KeyedElement.element
                • KeyedElement.key
                • KeyedElement.with_element()
                • KeyedElement.with_key()
              • LabeledStmt
                • LabeledStmt.Builder
                  • LabeledStmt.Builder.build()
                  • LabeledStmt.Builder.label()
                  • LabeledStmt.Builder.statement()
                • LabeledStmt.LABEL
                • LabeledStmt.STATEMENT
                • LabeledStmt.TYPE_
                • LabeledStmt.builder()
                • LabeledStmt.label
                • LabeledStmt.statement
                • LabeledStmt.with_label()
                • LabeledStmt.with_statement()
              • Literal
                • Literal.BASIC
                • Literal.COMPOSITE
                • Literal.FUNCTION
                • Literal.TYPE_
              • LiteralBasic
              • LiteralComposite
              • LiteralFunction
              • LiteralType
                • LiteralType.ARRAY
                • LiteralType.INFERRED_ARRAY
                • LiteralType.MAP
                • LiteralType.NAME
                • LiteralType.SLICE
                • LiteralType.STRUCT
                • LiteralType.TYPE_
              • LiteralTypeArray
              • LiteralTypeInferredArray
              • LiteralTypeMap
              • LiteralTypeName
              • LiteralTypeSlice
              • LiteralTypeStruct
              • LiteralValue
                • LiteralValue.TYPE_
              • MapType
                • MapType.Builder
                  • MapType.Builder.build()
                  • MapType.Builder.key()
                  • MapType.Builder.value()
                • MapType.KEY
                • MapType.TYPE_
                • MapType.VALUE
                • MapType.builder()
                • MapType.key
                • MapType.value
                • MapType.with_key()
                • MapType.with_value()
              • MethodDecl
                • MethodDecl.BODY
                • MethodDecl.Builder
                  • MethodDecl.Builder.body()
                  • MethodDecl.Builder.build()
                  • MethodDecl.Builder.name()
                  • MethodDecl.Builder.receiver()
                  • MethodDecl.Builder.signature()
                • MethodDecl.NAME
                • MethodDecl.RECEIVER
                • MethodDecl.SIGNATURE
                • MethodDecl.TYPE_
                • MethodDecl.body
                • MethodDecl.builder()
                • MethodDecl.name
                • MethodDecl.receiver
                • MethodDecl.signature
                • MethodDecl.with_body()
                • MethodDecl.with_name()
                • MethodDecl.with_receiver()
                • MethodDecl.with_signature()
              • MethodElem
                • MethodElem.Builder
                  • MethodElem.Builder.build()
                  • MethodElem.Builder.name()
                  • MethodElem.Builder.signature()
                • MethodElem.NAME
                • MethodElem.SIGNATURE
                • MethodElem.TYPE_
                • MethodElem.builder()
                • MethodElem.name
                • MethodElem.signature
                • MethodElem.with_name()
                • MethodElem.with_signature()
              • MethodExpr
                • MethodExpr.Builder
                  • MethodExpr.Builder.build()
                  • MethodExpr.Builder.method()
                  • MethodExpr.Builder.receiver()
                • MethodExpr.METHOD
                • MethodExpr.RECEIVER
                • MethodExpr.TYPE_
                • MethodExpr.builder()
                • MethodExpr.method
                • MethodExpr.receiver
                • MethodExpr.with_method()
                • MethodExpr.with_receiver()
              • Module
                • Module.Builder
                  • Module.Builder.build()
                  • Module.Builder.declarations()
                  • Module.Builder.imports()
                  • Module.Builder.package()
                • Module.DECLARATIONS
                • Module.IMPORTS
                • Module.PACKAGE
                • Module.TYPE_
                • Module.builder()
                • Module.declarations
                • Module.imports
                • Module.package
                • Module.with_declarations()
                • Module.with_imports()
                • Module.with_package()
              • MulOp
                • MulOp.BITWISE_AND
                • MulOp.BIT_CLEAR
                • MulOp.DIVIDE
                • MulOp.LEFT_SHIFT
                • MulOp.MULTIPLY
                • MulOp.REMAINDER
                • MulOp.RIGHT_SHIFT
                • MulOp.TYPE_
              • NamedField
                • NamedField.Builder
                  • NamedField.Builder.build()
                  • NamedField.Builder.names()
                  • NamedField.Builder.tag()
                  • NamedField.Builder.type()
                • NamedField.NAMES
                • NamedField.TAG
                • NamedField.TYPE
                • NamedField.TYPE_
                • NamedField.builder()
                • NamedField.names
                • NamedField.tag
                • NamedField.type
                • NamedField.with_names()
                • NamedField.with_tag()
                • NamedField.with_type()
              • Operand
                • Operand.LITERAL
                • Operand.NAMED
                • Operand.PAREN
                • Operand.TYPE_
              • OperandLiteral
              • OperandName
                • OperandName.Builder
                  • OperandName.Builder.build()
                  • OperandName.Builder.name()
                  • OperandName.Builder.type_args()
                • OperandName.NAME
                • OperandName.TYPE_
                • OperandName.TYPE_ARGS
                • OperandName.builder()
                • OperandName.name
                • OperandName.type_args
                • OperandName.with_name()
                • OperandName.with_type_args()
              • OperandNamed
              • OperandParen
              • PackageClause
                • PackageClause.TYPE_
              • ParameterDecl
                • ParameterDecl.Builder
                  • ParameterDecl.Builder.build()
                  • ParameterDecl.Builder.names()
                  • ParameterDecl.Builder.type()
                  • ParameterDecl.Builder.variadic()
                • ParameterDecl.NAMES
                • ParameterDecl.TYPE
                • ParameterDecl.TYPE_
                • ParameterDecl.VARIADIC
                • ParameterDecl.builder()
                • ParameterDecl.names
                • ParameterDecl.type
                • ParameterDecl.variadic
                • ParameterDecl.with_names()
                • ParameterDecl.with_type()
                • ParameterDecl.with_variadic()
              • Parameters
                • Parameters.TYPE_
              • PointerType
                • PointerType.TYPE_
              • PrimaryExpr
                • PrimaryExpr.CALL
                • PrimaryExpr.CONVERSION
                • PrimaryExpr.INDEX
                • PrimaryExpr.METHOD_EXPR
                • PrimaryExpr.OPERAND
                • PrimaryExpr.SELECTOR
                • PrimaryExpr.SLICE
                • PrimaryExpr.TYPE_
                • PrimaryExpr.TYPE_ASSERTION
              • PrimaryExprCall
              • PrimaryExprConversion
              • PrimaryExprIndex
              • PrimaryExprMethodExpr
              • PrimaryExprOperand
              • PrimaryExprSelector
              • PrimaryExprSlice
              • PrimaryExprTypeAssertion
              • QualifiedIdent
                • QualifiedIdent.Builder
                  • QualifiedIdent.Builder.build()
                  • QualifiedIdent.Builder.name()
                  • QualifiedIdent.Builder.package()
                • QualifiedIdent.NAME
                • QualifiedIdent.PACKAGE
                • QualifiedIdent.TYPE_
                • QualifiedIdent.builder()
                • QualifiedIdent.name
                • QualifiedIdent.package
                • QualifiedIdent.with_name()
                • QualifiedIdent.with_package()
              • RangeClause
                • RangeClause.Builder
                  • RangeClause.Builder.build()
                  • RangeClause.Builder.expression()
                  • RangeClause.Builder.vars()
                • RangeClause.EXPRESSION
                • RangeClause.TYPE_
                • RangeClause.VARS
                • RangeClause.builder()
                • RangeClause.expression
                • RangeClause.vars
                • RangeClause.with_expression()
                • RangeClause.with_vars()
              • RangeVars
                • RangeVars.ASSIGN
                • RangeVars.DECLARE
                • RangeVars.TYPE_
              • RangeVarsAssign
              • RangeVarsDeclare
              • RawStringLit
                • RawStringLit.TYPE_
              • ReceiveCase
                • ReceiveCase.Builder
                  • ReceiveCase.Builder.build()
                  • ReceiveCase.Builder.expression()
                  • ReceiveCase.Builder.vars()
                • ReceiveCase.EXPRESSION
                • ReceiveCase.TYPE_
                • ReceiveCase.VARS
                • ReceiveCase.builder()
                • ReceiveCase.expression
                • ReceiveCase.vars
                • ReceiveCase.with_expression()
                • ReceiveCase.with_vars()
              • Receiver
                • Receiver.Builder
                  • Receiver.Builder.build()
                  • Receiver.Builder.name()
                  • Receiver.Builder.type()
                • Receiver.NAME
                • Receiver.TYPE
                • Receiver.TYPE_
                • Receiver.builder()
                • Receiver.name
                • Receiver.type
                • Receiver.with_name()
                • Receiver.with_type()
              • RelOp
                • RelOp.EQUAL
                • RelOp.GREATER
                • RelOp.GREATER_EQUAL
                • RelOp.LESS
                • RelOp.LESS_EQUAL
                • RelOp.NOT_EQUAL
                • RelOp.TYPE_
              • Result
                • Result.PARAMETERS
                • Result.TYPE
                • Result.TYPE_
              • ResultParameters
              • ResultType
              • ReturnStmt
                • ReturnStmt.TYPE_
              • RuneLit
                • RuneLit.TYPE_
              • SelectStmt
                • SelectStmt.TYPE_
              • Selector
                • Selector.TYPE_
              • SelectorExpr
                • SelectorExpr.Builder
                  • SelectorExpr.Builder.build()
                  • SelectorExpr.Builder.expr()
                  • SelectorExpr.Builder.selector()
                • SelectorExpr.EXPR
                • SelectorExpr.SELECTOR
                • SelectorExpr.TYPE_
                • SelectorExpr.builder()
                • SelectorExpr.expr
                • SelectorExpr.selector
                • SelectorExpr.with_expr()
                • SelectorExpr.with_selector()
              • SendStmt
                • SendStmt.Builder
                  • SendStmt.Builder.build()
                  • SendStmt.Builder.channel()
                  • SendStmt.Builder.value()
                • SendStmt.CHANNEL
                • SendStmt.TYPE_
                • SendStmt.VALUE
                • SendStmt.builder()
                • SendStmt.channel
                • SendStmt.value
                • SendStmt.with_channel()
                • SendStmt.with_value()
              • ShortVarDecl
                • ShortVarDecl.Builder
                  • ShortVarDecl.Builder.build()
                  • ShortVarDecl.Builder.names()
                  • ShortVarDecl.Builder.values()
                • ShortVarDecl.NAMES
                • ShortVarDecl.TYPE_
                • ShortVarDecl.VALUES
                • ShortVarDecl.builder()
                • ShortVarDecl.names
                • ShortVarDecl.values
                • ShortVarDecl.with_names()
                • ShortVarDecl.with_values()
              • Signature
                • Signature.Builder
                  • Signature.Builder.build()
                  • Signature.Builder.parameters()
                  • Signature.Builder.result()
                • Signature.PARAMETERS
                • Signature.RESULT
                • Signature.TYPE_
                • Signature.builder()
                • Signature.parameters
                • Signature.result
                • Signature.with_parameters()
                • Signature.with_result()
              • SimpleSlice
                • SimpleSlice.Builder
                  • SimpleSlice.Builder.build()
                  • SimpleSlice.Builder.high()
                  • SimpleSlice.Builder.low()
                • SimpleSlice.HIGH
                • SimpleSlice.LOW
                • SimpleSlice.TYPE_
                • SimpleSlice.builder()
                • SimpleSlice.high
                • SimpleSlice.low
                • SimpleSlice.with_high()
                • SimpleSlice.with_low()
              • SimpleStmt
                • SimpleStmt.ASSIGNMENT
                • SimpleStmt.EMPTY
                • SimpleStmt.EXPRESSION
                • SimpleStmt.INC_DEC
                • SimpleStmt.SEND
                • SimpleStmt.SHORT_VAR_DECL
                • SimpleStmt.TYPE_
              • SimpleStmtAssignment
              • SimpleStmtEmpty
              • SimpleStmtExpression
              • SimpleStmtIncDec
              • SimpleStmtSend
              • SimpleStmtShortVarDecl
              • Slice
                • Slice.FULL
                • Slice.SIMPLE
                • Slice.TYPE_
              • SliceExpr
                • SliceExpr.Builder
                  • SliceExpr.Builder.build()
                  • SliceExpr.Builder.expr()
                  • SliceExpr.Builder.slice()
                • SliceExpr.EXPR
                • SliceExpr.SLICE
                • SliceExpr.TYPE_
                • SliceExpr.builder()
                • SliceExpr.expr
                • SliceExpr.slice
                • SliceExpr.with_expr()
                • SliceExpr.with_slice()
              • SliceFull
              • SliceSimple
              • SliceType
                • SliceType.TYPE_
              • SourceFile
                • SourceFile.Builder
                  • SourceFile.Builder.build()
                  • SourceFile.Builder.declarations()
                  • SourceFile.Builder.imports()
                  • SourceFile.Builder.package()
                • SourceFile.DECLARATIONS
                • SourceFile.IMPORTS
                • SourceFile.PACKAGE
                • SourceFile.TYPE_
                • SourceFile.builder()
                • SourceFile.declarations
                • SourceFile.imports
                • SourceFile.package
                • SourceFile.with_declarations()
                • SourceFile.with_imports()
                • SourceFile.with_package()
              • Statement
                • Statement.BLOCK
                • Statement.BREAK
                • Statement.CONTINUE
                • Statement.DECLARATION
                • Statement.DEFER
                • Statement.FALLTHROUGH
                • Statement.FOR
                • Statement.GO
                • Statement.GOTO
                • Statement.IF
                • Statement.LABELED
                • Statement.RETURN
                • Statement.SELECT
                • Statement.SIMPLE
                • Statement.SWITCH
                • Statement.TYPE_
              • StatementBlock
              • StatementBreak
              • StatementContinue
              • StatementDeclaration
              • StatementDefer
              • StatementFallthrough
              • StatementFor
              • StatementGo
              • StatementGoto
              • StatementIf
              • StatementLabeled
              • StatementReturn
              • StatementSelect
              • StatementSimple
              • StatementSwitch
              • StringLit
                • StringLit.INTERPRETED
                • StringLit.RAW
                • StringLit.TYPE_
              • StringLitInterpreted
              • StringLitRaw
              • StructType
                • StructType.TYPE_
              • SwitchStmt
                • SwitchStmt.EXPRESSION
                • SwitchStmt.TYPE
                • SwitchStmt.TYPE_
              • SwitchStmtExpression
              • SwitchStmtType
              • Tag
                • Tag.TYPE_
              • TopLevelDecl
                • TopLevelDecl.DECLARATION
                • TopLevelDecl.FUNCTION
                • TopLevelDecl.METHOD
                • TopLevelDecl.TYPE_
              • TopLevelDeclDeclaration
              • TopLevelDeclFunction
              • TopLevelDeclMethod
              • Type
                • Type.LITERAL
                • Type.NAMED
                • Type.PAREN
                • Type.TYPE_
              • TypeAssertion
                • TypeAssertion.TYPE_
              • TypeAssertionExpr
                • TypeAssertionExpr.Builder
                  • TypeAssertionExpr.Builder.build()
                  • TypeAssertionExpr.Builder.expr()
                  • TypeAssertionExpr.Builder.type()
                • TypeAssertionExpr.EXPR
                • TypeAssertionExpr.TYPE
                • TypeAssertionExpr.TYPE_
                • TypeAssertionExpr.builder()
                • TypeAssertionExpr.expr
                • TypeAssertionExpr.type
                • TypeAssertionExpr.with_expr()
                • TypeAssertionExpr.with_type()
              • TypeCaseClause
                • TypeCaseClause.Builder
                  • TypeCaseClause.Builder.build()
                  • TypeCaseClause.Builder.case()
                  • TypeCaseClause.Builder.statements()
                • TypeCaseClause.CASE
                • TypeCaseClause.STATEMENTS
                • TypeCaseClause.TYPE_
                • TypeCaseClause.builder()
                • TypeCaseClause.case
                • TypeCaseClause.statements
                • TypeCaseClause.with_case()
                • TypeCaseClause.with_statements()
              • TypeConstraint
                • TypeConstraint.TYPE_
              • TypeDecl
                • TypeDecl.TYPE_
              • TypeDef
                • TypeDef.Builder
                  • TypeDef.Builder.build()
                  • TypeDef.Builder.name()
                  • TypeDef.Builder.type()
                  • TypeDef.Builder.type_params()
                • TypeDef.NAME
                • TypeDef.TYPE
                • TypeDef.TYPE_
                • TypeDef.TYPE_PARAMS
                • TypeDef.builder()
                • TypeDef.name
                • TypeDef.type
                • TypeDef.type_params
                • TypeDef.with_name()
                • TypeDef.with_type()
                • TypeDef.with_type_params()
              • TypeElem
                • TypeElem.TYPE_
              • TypeLit
                • TypeLit.ARRAY
                • TypeLit.CHANNEL
                • TypeLit.FUNCTION
                • TypeLit.INTERFACE
                • TypeLit.MAP
                • TypeLit.POINTER
                • TypeLit.SLICE
                • TypeLit.STRUCT
                • TypeLit.TYPE_
              • TypeLitArray
              • TypeLitChannel
              • TypeLitFunction
              • TypeLitInterface
              • TypeLitMap
              • TypeLitPointer
              • TypeLitSlice
              • TypeLitStruct
              • TypeLiteral
              • TypeName
                • TypeName.Builder
                  • TypeName.Builder.build()
                  • TypeName.Builder.name()
                  • TypeName.Builder.type_args()
                • TypeName.NAME
                • TypeName.TYPE_
                • TypeName.TYPE_ARGS
                • TypeName.builder()
                • TypeName.name
                • TypeName.type_args
                • TypeName.with_name()
                • TypeName.with_type_args()
              • TypeNamed
              • TypeParamDecl
                • TypeParamDecl.Builder
                  • TypeParamDecl.Builder.build()
                  • TypeParamDecl.Builder.constraint()
                  • TypeParamDecl.Builder.names()
                • TypeParamDecl.CONSTRAINT
                • TypeParamDecl.NAMES
                • TypeParamDecl.TYPE_
                • TypeParamDecl.builder()
                • TypeParamDecl.constraint
                • TypeParamDecl.names
                • TypeParamDecl.with_constraint()
                • TypeParamDecl.with_names()
              • TypeParameters
                • TypeParameters.TYPE_
              • TypeParen
              • TypeSpec
                • TypeSpec.ALIAS
                • TypeSpec.DEFINITION
                • TypeSpec.TYPE_
              • TypeSpecAlias
              • TypeSpecDefinition
              • TypeSwitchGuard
                • TypeSwitchGuard.Builder
                  • TypeSwitchGuard.Builder.build()
                  • TypeSwitchGuard.Builder.expression()
                  • TypeSwitchGuard.Builder.name()
                • TypeSwitchGuard.EXPRESSION
                • TypeSwitchGuard.NAME
                • TypeSwitchGuard.TYPE_
                • TypeSwitchGuard.builder()
                • TypeSwitchGuard.expression
                • TypeSwitchGuard.name
                • TypeSwitchGuard.with_expression()
                • TypeSwitchGuard.with_name()
              • TypeSwitchStmt
                • TypeSwitchStmt.Builder
                  • TypeSwitchStmt.Builder.build()
                  • TypeSwitchStmt.Builder.cases()
                  • TypeSwitchStmt.Builder.guard()
                  • TypeSwitchStmt.Builder.init()
                • TypeSwitchStmt.CASES
                • TypeSwitchStmt.GUARD
                • TypeSwitchStmt.INIT
                • TypeSwitchStmt.TYPE_
                • TypeSwitchStmt.builder()
                • TypeSwitchStmt.cases
                • TypeSwitchStmt.guard
                • TypeSwitchStmt.init
                • TypeSwitchStmt.with_cases()
                • TypeSwitchStmt.with_guard()
                • TypeSwitchStmt.with_init()
              • TypeTerm
                • TypeTerm.Builder
                  • TypeTerm.Builder.build()
                  • TypeTerm.Builder.type()
                  • TypeTerm.Builder.underlying()
                • TypeTerm.TYPE
                • TypeTerm.TYPE_
                • TypeTerm.UNDERLYING
                • TypeTerm.builder()
                • TypeTerm.type
                • TypeTerm.underlying
                • TypeTerm.with_type()
                • TypeTerm.with_underlying()
              • UnaryExpr
                • UnaryExpr.OP
                • UnaryExpr.PRIMARY
                • UnaryExpr.TYPE_
              • UnaryExprOp
              • UnaryExprPrimary
              • UnaryOp
                • UnaryOp.ADDRESS_OF
                • UnaryOp.DEREF
                • UnaryOp.MINUS
                • UnaryOp.NOT
                • UnaryOp.PLUS
                • UnaryOp.RECEIVE
                • UnaryOp.TYPE_
                • UnaryOp.XOR
              • UnaryOperation
                • UnaryOperation.Builder
                  • UnaryOperation.Builder.build()
                  • UnaryOperation.Builder.op()
                  • UnaryOperation.Builder.operand()
                • UnaryOperation.OP
                • UnaryOperation.OPERAND
                • UnaryOperation.TYPE_
                • UnaryOperation.builder()
                • UnaryOperation.op
                • UnaryOperation.operand
                • UnaryOperation.with_op()
                • UnaryOperation.with_operand()
              • VarDecl
                • VarDecl.TYPE_
              • VarSpec
                • VarSpec.Builder
                  • VarSpec.Builder.build()
                  • VarSpec.Builder.names()
                  • VarSpec.Builder.type()
                  • VarSpec.Builder.values()
                • VarSpec.NAMES
                • VarSpec.TYPE
                • VarSpec.TYPE_
                • VarSpec.VALUES
                • VarSpec.builder()
                • VarSpec.names
                • VarSpec.type
                • VarSpec.values
                • VarSpec.with_names()
                • VarSpec.with_type()
                • VarSpec.with_values()
hydra-go
  • hydra
  • View page source

hydra

  • hydra namespace
    • Subpackages
      • hydra.go namespace
        • Submodules
Previous Next

© Copyright 2026, Hydra.

Built with Sphinx using a theme provided by Read the Docs.