hydra.scala.syntax module

A Scala syntax model for Hydra, anchored on Scalameta (https://scalameta.org). Departs from Scalameta where Hydra’s needs differ: Term is renamed to Data, the FunctionType/FunctionData wrappers are flattened, and arms Hydra never emits (xml literals, quasiquote/macro forms) are omitted.

class hydra.scala.syntax.AlternativePat(lhs: 'Pat', rhs: 'Pat')

Bases: object

class Builder(_lhs: 'Pat' = None, _rhs: 'Pat' = None)

Bases: object

build()

lhs(lhs)

rhs(rhs)

LHS = Name(value='lhs')

RHS = Name(value='rhs')

TYPE_ = Name(value='hydra.scala.syntax.AlternativePat')

static builder()

lhs: Pat

rhs: Pat

with_lhs(lhs)

with_rhs(rhs)

class hydra.scala.syntax.AndType(lhs: 'Type', rhs: 'Type')

Bases: object

class Builder(_lhs: 'Type' = None, _rhs: 'Type' = None)

Bases: object

build()

lhs(lhs)

rhs(rhs)

LHS = Name(value='lhs')

RHS = Name(value='rhs')

TYPE_ = Name(value='hydra.scala.syntax.AndType')

static builder()

lhs: Type

rhs: Type

with_lhs(lhs)

with_rhs(rhs)

class hydra.scala.syntax.AnnotMod(init: 'Init')

Bases: object

class Builder(_init: 'Init' = None)

Bases: object

build()

init(init)

INIT = Name(value='init')

TYPE_ = Name(value='hydra.scala.syntax.AnnotMod')

static builder()

init: Init

with_init(init)

class hydra.scala.syntax.AnnotateData(expr: 'Data', annots: 'Sequence[AnnotMod]')

Bases: object

ANNOTS = Name(value='annots')

class Builder(_expr: 'Data' = None, _annots: 'Sequence[AnnotMod]' = None)

Bases: object

annots(annots)

build()

expr(expr)

EXPR = Name(value='expr')

TYPE_ = Name(value='hydra.scala.syntax.AnnotateData')

annots: Sequence[AnnotMod]

static builder()

expr: Data

with_annots(annots)

with_expr(expr)

class hydra.scala.syntax.AnnotateType(tpe: 'Type', annots: 'Sequence[AnnotMod]')

Bases: object

ANNOTS = Name(value='annots')

class Builder(_tpe: 'Type' = None, _annots: 'Sequence[AnnotMod]' = None)

Bases: object

annots(annots)

build()

tpe(tpe)

TPE = Name(value='tpe')

TYPE_ = Name(value='hydra.scala.syntax.AnnotateType')

annots: Sequence[AnnotMod]

static builder()

tpe: Type

with_annots(annots)

with_tpe(tpe)

class hydra.scala.syntax.AnonymousData(value: T)

Bases: Node[None]

TYPE_ = Name(value='hydra.scala.syntax.AnonymousData')

class hydra.scala.syntax.AnonymousNameType(value: T)

Bases: Node[None]

TYPE_ = Name(value='hydra.scala.syntax.AnonymousNameType')

class hydra.scala.syntax.ApplyData(fun: 'Data', args: 'Sequence[Data]')

Bases: object

ARGS = Name(value='args')

class Builder(_fun: 'Data' = None, _args: 'Sequence[Data]' = None)

Bases: object

args(args)

build()

fun(fun)

FUN = Name(value='fun')

TYPE_ = Name(value='hydra.scala.syntax.ApplyData')

args: Sequence[Data]

static builder()

fun: Data

with_args(args)

with_fun(fun)

class hydra.scala.syntax.ApplyInfixData(lhs: 'Data', op: 'NameData', targs: 'Sequence[Type]', args: 'Sequence[Data]')

Bases: object

ARGS = Name(value='args')

class Builder(_lhs: 'Data' = None, _op: 'NameData' = None, _targs: 'Sequence[Type]' = None, _args: 'Sequence[Data]' = None)

Bases: object

args(args)

build()

lhs(lhs)

op(op)

targs(targs)

LHS = Name(value='lhs')

OP = Name(value='op')

TARGS = Name(value='targs')

TYPE_ = Name(value='hydra.scala.syntax.ApplyInfixData')

args: Sequence[Data]

static builder()

lhs: Data

op: NameData

targs: Sequence[Type]

with_args(args)

with_lhs(lhs)

with_op(op)

with_targs(targs)

class hydra.scala.syntax.ApplyInfixType(lhs: 'Type', op: 'NameType', rhs: 'Type')

Bases: object

class Builder(_lhs: 'Type' = None, _op: 'NameType' = None, _rhs: 'Type' = None)

Bases: object

build()

lhs(lhs)

op(op)

rhs(rhs)

LHS = Name(value='lhs')

OP = Name(value='op')

RHS = Name(value='rhs')

TYPE_ = Name(value='hydra.scala.syntax.ApplyInfixType')

static builder()

lhs: Type

op: NameType

rhs: Type

with_lhs(lhs)

with_op(op)

with_rhs(rhs)

class hydra.scala.syntax.ApplyType(tpe: 'Type', args: 'Sequence[Type]')

Bases: object

ARGS = Name(value='args')

class Builder(_tpe: 'Type' = None, _args: 'Sequence[Type]' = None)

Bases: object

args(args)

build()

tpe(tpe)

TPE = Name(value='tpe')

TYPE_ = Name(value='hydra.scala.syntax.ApplyType')

args: Sequence[Type]

static builder()

tpe: Type

with_args(args)

with_tpe(tpe)

class hydra.scala.syntax.ApplyTypeData(lhs: 'Data', op: 'NameData', targs: 'Sequence[Type]', args: 'Sequence[Data]')

Bases: object

ARGS = Name(value='args')

class Builder(_lhs: 'Data' = None, _op: 'NameData' = None, _targs: 'Sequence[Type]' = None, _args: 'Sequence[Data]' = None)

Bases: object

args(args)

build()

lhs(lhs)

op(op)

targs(targs)

LHS = Name(value='lhs')

OP = Name(value='op')

TARGS = Name(value='targs')

TYPE_ = Name(value='hydra.scala.syntax.ApplyTypeData')

args: Sequence[Data]

static builder()

lhs: Data

op: NameData

targs: Sequence[Type]

with_args(args)

with_lhs(lhs)

with_op(op)

with_targs(targs)

class hydra.scala.syntax.ApplyUnaryData(op: 'NameData', arg: 'Data')

Bases: object

ARG = Name(value='arg')

class Builder(_op: 'NameData' = None, _arg: 'Data' = None)

Bases: object

arg(arg)

build()

op(op)

OP = Name(value='op')

TYPE_ = Name(value='hydra.scala.syntax.ApplyUnaryData')

arg: Data

static builder()

op: NameData

with_arg(arg)

with_op(op)

class hydra.scala.syntax.ApplyUsingData(fun: 'Data', targs: 'Sequence[Data]')

Bases: object

class Builder(_fun: 'Data' = None, _targs: 'Sequence[Data]' = None)

Bases: object

build()

fun(fun)

targs(targs)

FUN = Name(value='fun')

TARGS = Name(value='targs')

TYPE_ = Name(value='hydra.scala.syntax.ApplyUsingData')

static builder()

fun: Data

targs: Sequence[Data]

with_fun(fun)

with_targs(targs)

class hydra.scala.syntax.AscribeData(expr: 'Data', tpe: 'Type')

Bases: object

class Builder(_expr: 'Data' = None, _tpe: 'Type' = None)

Bases: object

build()

expr(expr)

tpe(tpe)

EXPR = Name(value='expr')

TPE = Name(value='tpe')

TYPE_ = Name(value='hydra.scala.syntax.AscribeData')

static builder()

expr: Data

tpe: Type

with_expr(expr)

with_tpe(tpe)

class hydra.scala.syntax.AssignData(lhs: 'Data', rhs: 'Data')

Bases: object

class Builder(_lhs: 'Data' = None, _rhs: 'Data' = None)

Bases: object

build()

lhs(lhs)

rhs(rhs)

LHS = Name(value='lhs')

RHS = Name(value='rhs')

TYPE_ = Name(value='hydra.scala.syntax.AssignData')

static builder()

lhs: Data

rhs: Data

with_lhs(lhs)

with_rhs(rhs)

class hydra.scala.syntax.BindPat(lhs: 'Pat', rhs: 'Pat')

Bases: object

class Builder(_lhs: 'Pat' = None, _rhs: 'Pat' = None)

Bases: object

build()

lhs(lhs)

rhs(rhs)

LHS = Name(value='lhs')

RHS = Name(value='rhs')

TYPE_ = Name(value='hydra.scala.syntax.BindPat')

static builder()

lhs: Pat

rhs: Pat

with_lhs(lhs)

with_rhs(rhs)

class hydra.scala.syntax.BlockData(stats: 'Sequence[Stat]')

Bases: object

class Builder(_stats: 'Sequence[Stat]' = None)

Bases: object

build()

stats(stats)

STATS = Name(value='stats')

TYPE_ = Name(value='hydra.scala.syntax.BlockData')

static builder()

stats: Sequence[Stat]

with_stats(stats)

class hydra.scala.syntax.ByNameType(tpe: 'Type')

Bases: object

class Builder(_tpe: 'Type' = None)

Bases: object

build()

tpe(tpe)

TPE = Name(value='tpe')

TYPE_ = Name(value='hydra.scala.syntax.ByNameType')

static builder()

tpe: Type

with_tpe(tpe)

class hydra.scala.syntax.Case(pat: 'Pat', cond: 'Optional[Data]', body: 'Data')

Bases: object

BODY = Name(value='body')

class Builder(_pat: 'Pat' = None, _cond: 'Optional[Data]' = None, _body: 'Data' = None)

Bases: object

body(body)

build()

cond(cond)

pat(pat)

COND = Name(value='cond')

PAT = Name(value='pat')

TYPE_ = Name(value='hydra.scala.syntax.Case')

body: Data

static builder()

cond: object

pat: Pat

with_body(body)

with_cond(cond)

with_pat(pat)

class hydra.scala.syntax.CaseGeneratorEnumerator(pat: 'Pat', rhs: 'Data')

Bases: object

class Builder(_pat: 'Pat' = None, _rhs: 'Data' = None)

Bases: object

build()

pat(pat)

rhs(rhs)

PAT = Name(value='pat')

RHS = Name(value='rhs')

TYPE_ = Name(value='hydra.scala.syntax.CaseGeneratorEnumerator')

static builder()

pat: Pat

rhs: Data

with_pat(pat)

with_rhs(rhs)

class hydra.scala.syntax.CaseTree

Bases: object

CaseTreeCase | CaseTreeTypeCase

CASE = Name(value='case')

TYPE_ = Name(value='hydra.scala.syntax.CaseTree')

TYPE_CASE = Name(value='typeCase')

class hydra.scala.syntax.CaseTreeCase(value: T)

Bases: Node[Case]

class hydra.scala.syntax.CaseTreeTypeCase(value: T)

Bases: Node[TypeCase]

class hydra.scala.syntax.ClassDefn(mods: 'Sequence[Mod]', name: 'NameType', tparams: 'Sequence[ParamType]', ctor: 'PrimaryCtor', template: 'Template')

Bases: object

class Builder(_mods: 'Sequence[Mod]' = None, _name: 'NameType' = None, _tparams: 'Sequence[ParamType]' = None, _ctor: 'PrimaryCtor' = None, _template: 'Template' = None)

Bases: object

build()

ctor(ctor)

mods(mods)

name(name)

template(template)

tparams(tparams)

CTOR = Name(value='ctor')

MODS = Name(value='mods')

NAME = Name(value='name')

TEMPLATE = Name(value='template')

TPARAMS = Name(value='tparams')

TYPE_ = Name(value='hydra.scala.syntax.ClassDefn')

static builder()

ctor: PrimaryCtor

mods: Sequence[Mod]

name: NameType

template: Template

tparams: Sequence[ParamType]

with_ctor(ctor)

with_mods(mods)

with_name(name)

with_template(template)

with_tparams(tparams)

class hydra.scala.syntax.ContextFunctionData(params: 'Sequence[ParamData]', body: 'Data')

Bases: object

BODY = Name(value='body')

class Builder(_params: 'Sequence[ParamData]' = None, _body: 'Data' = None)

Bases: object

body(body)

build()

params(params)

PARAMS = Name(value='params')

TYPE_ = Name(value='hydra.scala.syntax.ContextFunctionData')

body: Data

static builder()

params: Sequence[ParamData]

with_body(body)

with_params(params)

class hydra.scala.syntax.ContextFunctionType(params: 'Sequence[Type]', res: 'Type')

Bases: object

class Builder(_params: 'Sequence[Type]' = None, _res: 'Type' = None)

Bases: object

build()

params(params)

res(res)

PARAMS = Name(value='params')

RES = Name(value='res')

TYPE_ = Name(value='hydra.scala.syntax.ContextFunctionType')

static builder()

params: Sequence[Type]

res: Type

with_params(params)

with_res(res)

class hydra.scala.syntax.Ctor

Bases: object

CtorPrimary | CtorSecondary

PRIMARY = Name(value='primary')

SECONDARY = Name(value='secondary')

TYPE_ = Name(value='hydra.scala.syntax.Ctor')

class hydra.scala.syntax.CtorPrimary(value: T)

Bases: Node[PrimaryCtor]

class hydra.scala.syntax.CtorSecondary(value: T)

Bases: Node[SecondaryCtor]

class hydra.scala.syntax.Data

Bases: object

DataLit | DataRef | DataInterpolate | DataApply | DataApplyUsing | DataApplyType | DataAssign | DataReturn | DataThrow | DataAscribe | DataAnnotate | DataTuple | DataBlock | DataEndMarker | DataIf | DataMatch | DataTry | DataTryWithHandler | DataFunction | DataContextFunction | DataPolyFunction | DataPartialFunction | DataWhile | DataDo | DataFor | DataForYield | DataNew | DataNewAnonymous | DataPlaceholder | DataEta | DataRepeated | DataParam

ANNOTATE = Name(value='annotate')

APPLY = Name(value='apply')

APPLY_TYPE = Name(value='applyType')

APPLY_USING = Name(value='applyUsing')

ASCRIBE = Name(value='ascribe')

ASSIGN = Name(value='assign')

BLOCK = Name(value='block')

CONTEXT_FUNCTION = Name(value='contextFunction')

DO = Name(value='do')

END_MARKER = Name(value='endMarker')

ETA = Name(value='eta')

FOR = Name(value='for')

FOR_YIELD = Name(value='forYield')

FUNCTION = Name(value='function')

IF = Name(value='if')

INTERPOLATE = Name(value='interpolate')

LIT = Name(value='lit')

MATCH = Name(value='match')

NEW = Name(value='new')

NEW_ANONYMOUS = Name(value='newAnonymous')

PARAM = Name(value='param')

PARTIAL_FUNCTION = Name(value='partialFunction')

PLACEHOLDER = Name(value='placeholder')

POLY_FUNCTION = Name(value='polyFunction')

REF = Name(value='ref')

REPEATED = Name(value='repeated')

RETURN = Name(value='return')

THROW = Name(value='throw')

TRY = Name(value='try')

TRY_WITH_HANDLER = Name(value='tryWithHandler')

TUPLE = Name(value='tuple')

TYPE_ = Name(value='hydra.scala.syntax.Data')

WHILE = Name(value='while')

class hydra.scala.syntax.DataAnnotate(value: T)

Bases: Node[AnnotateData]

class hydra.scala.syntax.DataApply(value: T)

Bases: Node[ApplyData]

class hydra.scala.syntax.DataApplyType(value: T)

Bases: Node[ApplyTypeData]

class hydra.scala.syntax.DataApplyUsing(value: T)

Bases: Node[ApplyUsingData]

class hydra.scala.syntax.DataAscribe(value: T)

Bases: Node[AscribeData]

class hydra.scala.syntax.DataAssign(value: T)

Bases: Node[AssignData]

class hydra.scala.syntax.DataBlock(value: T)

Bases: Node[BlockData]

class hydra.scala.syntax.DataContextFunction(value: T)

Bases: Node[ContextFunctionData]

class hydra.scala.syntax.DataDo(value: T)

Bases: Node[DoData]

class hydra.scala.syntax.DataEndMarker(value: T)

Bases: Node[EndMarkerData]

class hydra.scala.syntax.DataEta(value: T)

Bases: Node[EtaData]

class hydra.scala.syntax.DataFor(value: T)

Bases: Node[ForData]

class hydra.scala.syntax.DataForYield(value: T)

Bases: Node[ForYieldData]

class hydra.scala.syntax.DataFunction(value: T)

Bases: Node[FunctionData]

class hydra.scala.syntax.DataIf(value: T)

Bases: Node[IfData]

class hydra.scala.syntax.DataInterpolate(value: T)

Bases: Node[InterpolateData]

class hydra.scala.syntax.DataLit(value: T)

Bases: Node[Lit]

class hydra.scala.syntax.DataMatch(value: T)

Bases: Node[MatchData]

class hydra.scala.syntax.DataMember

Bases: object

DataMemberPkg | DataMemberObject

OBJECT = Name(value='object')

PKG = Name(value='pkg')

TYPE_ = Name(value='hydra.scala.syntax.DataMember')

class hydra.scala.syntax.DataMemberObject(value: T)

Bases: Node[ObjectPkg]

class hydra.scala.syntax.DataMemberPkg(value: T)

Bases: Node[Pkg]

class hydra.scala.syntax.DataNew(value: T)

Bases: Node[NewData]

class hydra.scala.syntax.DataNewAnonymous(value: T)

Bases: Node[NewAnonymousData]

class hydra.scala.syntax.DataParam(value: T)

Bases: Node[ParamData]

class hydra.scala.syntax.DataPartialFunction(value: T)

Bases: Node[PartialFunctionData]

class hydra.scala.syntax.DataPlaceholder

Bases: object

class hydra.scala.syntax.DataPolyFunction(value: T)

Bases: Node[PolyFunctionData]

class hydra.scala.syntax.DataRef(value: T)

Bases: Node[RefData]

class hydra.scala.syntax.DataRepeated(value: T)

Bases: Node[RepeatedData]

class hydra.scala.syntax.DataReturn(value: T)

Bases: Node[ReturnData]

class hydra.scala.syntax.DataThrow(value: T)

Bases: Node[ThrowData]

class hydra.scala.syntax.DataTry(value: T)

Bases: Node[TryData]

class hydra.scala.syntax.DataTryWithHandler(value: T)

Bases: Node[TryWithHandlerData]

class hydra.scala.syntax.DataTuple(value: T)

Bases: Node[TupleData]

class hydra.scala.syntax.DataWhile(value: T)

Bases: Node[WhileData]

class hydra.scala.syntax.Decl

Bases: object

DeclVal | DeclVar | DeclDef | DeclType | DeclGiven

DEF = Name(value='def')

GIVEN = Name(value='given')

TYPE = Name(value='type')

TYPE_ = Name(value='hydra.scala.syntax.Decl')

VAL = Name(value='val')

VAR = Name(value='var')

class hydra.scala.syntax.DeclDef(value: T)

Bases: Node[DefDecl]

class hydra.scala.syntax.DeclGiven(value: T)

Bases: Node[GivenDecl]

class hydra.scala.syntax.DeclType(value: T)

Bases: Node[TypeDecl]

class hydra.scala.syntax.DeclVal(value: T)

Bases: Node[ValDecl]

class hydra.scala.syntax.DeclVar(value: T)

Bases: Node[VarDecl]

class hydra.scala.syntax.DefDecl(mods: 'Sequence[Mod]', name: 'NameData', tparams: 'Sequence[ParamType]', paramss: 'Sequence[Sequence[ParamData]]', decltpe: 'Type')

Bases: object

class Builder(_mods: 'Sequence[Mod]' = None, _name: 'NameData' = None, _tparams: 'Sequence[ParamType]' = None, _paramss: 'Sequence[Sequence[ParamData]]' = None, _decltpe: 'Type' = None)

Bases: object

build()

decltpe(decltpe)

mods(mods)

name(name)

paramss(paramss)

tparams(tparams)

DECLTPE = Name(value='decltpe')

MODS = Name(value='mods')

NAME = Name(value='name')

PARAMSS = Name(value='paramss')

TPARAMS = Name(value='tparams')

TYPE_ = Name(value='hydra.scala.syntax.DefDecl')

static builder()

decltpe: Type

mods: Sequence[Mod]

name: NameData

paramss: Sequence[Sequence[ParamData]]

tparams: Sequence[ParamType]

with_decltpe(decltpe)

with_mods(mods)

with_name(name)

with_paramss(paramss)

with_tparams(tparams)

class hydra.scala.syntax.DefDefn(mods: 'Sequence[Mod]', name: 'NameData', tparams: 'Sequence[ParamType]', paramss: 'Sequence[Sequence[ParamData]]', decltpe: 'Optional[Type]', body: 'Data')

Bases: object

BODY = Name(value='body')

class Builder(_mods: 'Sequence[Mod]' = None, _name: 'NameData' = None, _tparams: 'Sequence[ParamType]' = None, _paramss: 'Sequence[Sequence[ParamData]]' = None, _decltpe: 'Optional[Type]' = None, _body: 'Data' = None)

Bases: object

body(body)

build()

decltpe(decltpe)

mods(mods)

name(name)

paramss(paramss)

tparams(tparams)

DECLTPE = Name(value='decltpe')

MODS = Name(value='mods')

NAME = Name(value='name')

PARAMSS = Name(value='paramss')

TPARAMS = Name(value='tparams')

TYPE_ = Name(value='hydra.scala.syntax.DefDefn')

body: Data

static builder()

decltpe: object

mods: Sequence[Mod]

name: NameData

paramss: Sequence[Sequence[ParamData]]

tparams: Sequence[ParamType]

with_body(body)

with_decltpe(decltpe)

with_mods(mods)

with_name(name)

with_paramss(paramss)

with_tparams(tparams)

class hydra.scala.syntax.Defn

Bases: object

DefnVal | DefnVar | DefnGiven | DefnEnum | DefnEnumCase | DefnRepeatedEnumCase | DefnGivenAlias | DefnExtensionGroup | DefnDef | DefnType | DefnClass | DefnTrait | DefnObject

CLASS = Name(value='class')

DEF = Name(value='def')

ENUM = Name(value='enum')

ENUM_CASE = Name(value='enumCase')

EXTENSION_GROUP = Name(value='extensionGroup')

GIVEN = Name(value='given')

GIVEN_ALIAS = Name(value='givenAlias')

OBJECT = Name(value='object')

REPEATED_ENUM_CASE = Name(value='repeatedEnumCase')

TRAIT = Name(value='trait')

TYPE = Name(value='type')

TYPE_ = Name(value='hydra.scala.syntax.Defn')

VAL = Name(value='val')

VAR = Name(value='var')

class hydra.scala.syntax.DefnClass(value: T)

Bases: Node[ClassDefn]

class hydra.scala.syntax.DefnDef(value: T)

Bases: Node[DefDefn]

class hydra.scala.syntax.DefnEnum(value: T)

Bases: Node[EnumDefn]

class hydra.scala.syntax.DefnEnumCase(value: T)

Bases: Node[EnumCaseDefn]

class hydra.scala.syntax.DefnExtensionGroup(value: T)

Bases: Node[ExtensionGroupDefn]

class hydra.scala.syntax.DefnGiven(value: T)

Bases: Node[GivenDefn]

class hydra.scala.syntax.DefnGivenAlias(value: T)

Bases: Node[GivenAliasDefn]

class hydra.scala.syntax.DefnObject(value: T)

Bases: Node[ObjectDefn]

class hydra.scala.syntax.DefnRepeatedEnumCase(value: T)

Bases: Node[RepeatedEnumCaseDefn]

class hydra.scala.syntax.DefnTrait(value: T)

Bases: Node[TraitDefn]

class hydra.scala.syntax.DefnType(value: T)

Bases: Node[TypeDefn]

class hydra.scala.syntax.DefnVal(value: T)

Bases: Node[ValDefn]

class hydra.scala.syntax.DefnVar(value: T)

Bases: Node[VarDefn]

class hydra.scala.syntax.DoData(body: 'Data', expr: 'Data')

Bases: object

BODY = Name(value='body')

class Builder(_body: 'Data' = None, _expr: 'Data' = None)

Bases: object

body(body)

build()

expr(expr)

EXPR = Name(value='expr')

TYPE_ = Name(value='hydra.scala.syntax.DoData')

body: Data

static builder()

expr: Data

with_body(body)

with_expr(expr)

class hydra.scala.syntax.EndMarkerData(name: 'NameData')

Bases: object

class Builder(_name: 'NameData' = None)

Bases: object

build()

name(name)

NAME = Name(value='name')

TYPE_ = Name(value='hydra.scala.syntax.EndMarkerData')

static builder()

name: NameData

with_name(name)

class hydra.scala.syntax.EnumCaseDefn(mods: 'Sequence[Mod]', name: 'NameData', tparams: 'Sequence[ParamType]', ctor: 'PrimaryCtor', inits: 'Sequence[Init]')

Bases: object

class Builder(_mods: 'Sequence[Mod]' = None, _name: 'NameData' = None, _tparams: 'Sequence[ParamType]' = None, _ctor: 'PrimaryCtor' = None, _inits: 'Sequence[Init]' = None)

Bases: object

build()

ctor(ctor)

inits(inits)

mods(mods)

name(name)

tparams(tparams)

CTOR = Name(value='ctor')

INITS = Name(value='inits')

MODS = Name(value='mods')

NAME = Name(value='name')

TPARAMS = Name(value='tparams')

TYPE_ = Name(value='hydra.scala.syntax.EnumCaseDefn')

static builder()

ctor: PrimaryCtor

inits: Sequence[Init]

mods: Sequence[Mod]

name: NameData

tparams: Sequence[ParamType]

with_ctor(ctor)

with_inits(inits)

with_mods(mods)

with_name(name)

with_tparams(tparams)

class hydra.scala.syntax.EnumDefn(mods: 'Sequence[Mod]', name: 'NameType', tparams: 'Sequence[ParamType]', ctor: 'PrimaryCtor', template: 'Template')

Bases: object

class Builder(_mods: 'Sequence[Mod]' = None, _name: 'NameType' = None, _tparams: 'Sequence[ParamType]' = None, _ctor: 'PrimaryCtor' = None, _template: 'Template' = None)

Bases: object

build()

ctor(ctor)

mods(mods)

name(name)

template(template)

tparams(tparams)

CTOR = Name(value='ctor')

MODS = Name(value='mods')

NAME = Name(value='name')

TEMPLATE = Name(value='template')

TPARAMS = Name(value='tparams')

TYPE_ = Name(value='hydra.scala.syntax.EnumDefn')

static builder()

ctor: PrimaryCtor

mods: Sequence[Mod]

name: NameType

template: Template

tparams: Sequence[ParamType]

with_ctor(ctor)

with_mods(mods)

with_name(name)

with_template(template)

with_tparams(tparams)

class hydra.scala.syntax.Enumerator

Bases: object

EnumeratorGenerator | EnumeratorCaseGenerator | EnumeratorVal | EnumeratorGuard

CASE_GENERATOR = Name(value='caseGenerator')

GENERATOR = Name(value='generator')

GUARD = Name(value='guard')

TYPE_ = Name(value='hydra.scala.syntax.Enumerator')

VAL = Name(value='val')

class hydra.scala.syntax.EnumeratorCaseGenerator(value: T)

Bases: Node[CaseGeneratorEnumerator]

class hydra.scala.syntax.EnumeratorGenerator(value: T)

Bases: Node[GeneratorEnumerator]

class hydra.scala.syntax.EnumeratorGuard(value: T)

Bases: Node[GuardEnumerator]

class hydra.scala.syntax.EnumeratorVal(value: T)

Bases: Node[ValEnumerator]

class hydra.scala.syntax.EtaData(expr: 'Data')

Bases: object

class Builder(_expr: 'Data' = None)

Bases: object

build()

expr(expr)

EXPR = Name(value='expr')

TYPE_ = Name(value='hydra.scala.syntax.EtaData')

static builder()

expr: Data

with_expr(expr)

class hydra.scala.syntax.ExistentialType(tpe: 'Type', stats: 'Sequence[Stat]')

Bases: object

class Builder(_tpe: 'Type' = None, _stats: 'Sequence[Stat]' = None)

Bases: object

build()

stats(stats)

tpe(tpe)

STATS = Name(value='stats')

TPE = Name(value='tpe')

TYPE_ = Name(value='hydra.scala.syntax.ExistentialType')

static builder()

stats: Sequence[Stat]

tpe: Type

with_stats(stats)

with_tpe(tpe)

class hydra.scala.syntax.Export(importers: 'Sequence[Importer]')

Bases: object

class Builder(_importers: 'Sequence[Importer]' = None)

Bases: object

build()

importers(importers)

IMPORTERS = Name(value='importers')

TYPE_ = Name(value='hydra.scala.syntax.Export')

static builder()

importers: Sequence[Importer]

with_importers(importers)

class hydra.scala.syntax.ExtensionGroupDefn(tparams: 'Sequence[ParamType]', parmss: 'Sequence[Sequence[ParamData]]', body: 'Stat')

Bases: object

BODY = Name(value='body')

class Builder(_tparams: 'Sequence[ParamType]' = None, _parmss: 'Sequence[Sequence[ParamData]]' = None, _body: 'Stat' = None)

Bases: object

body(body)

build()

parmss(parmss)

tparams(tparams)

PARMSS = Name(value='parmss')

TPARAMS = Name(value='tparams')

TYPE_ = Name(value='hydra.scala.syntax.ExtensionGroupDefn')

body: Stat

static builder()

parmss: Sequence[Sequence[ParamData]]

tparams: Sequence[ParamType]

with_body(body)

with_parmss(parmss)

with_tparams(tparams)

class hydra.scala.syntax.ExtractInfixPat(lhs: 'Pat', op: 'NameData', rhs: 'Sequence[Pat]')

Bases: object

class Builder(_lhs: 'Pat' = None, _op: 'NameData' = None, _rhs: 'Sequence[Pat]' = None)

Bases: object

build()

lhs(lhs)

op(op)

rhs(rhs)

LHS = Name(value='lhs')

OP = Name(value='op')

RHS = Name(value='rhs')

TYPE_ = Name(value='hydra.scala.syntax.ExtractInfixPat')

static builder()

lhs: Pat

op: NameData

rhs: Sequence[Pat]

with_lhs(lhs)

with_op(op)

with_rhs(rhs)

class hydra.scala.syntax.ExtractPat(fun: 'Data', args: 'Sequence[Pat]')

Bases: object

ARGS = Name(value='args')

class Builder(_fun: 'Data' = None, _args: 'Sequence[Pat]' = None)

Bases: object

args(args)

build()

fun(fun)

FUN = Name(value='fun')

TYPE_ = Name(value='hydra.scala.syntax.ExtractPat')

args: Sequence[Pat]

static builder()

fun: Data

with_args(args)

with_fun(fun)

class hydra.scala.syntax.ForData(enums: 'Sequence[Enumerator]')

Bases: object

class Builder(_enums: 'Sequence[Enumerator]' = None)

Bases: object

build()

enums(enums)

ENUMS = Name(value='enums')

TYPE_ = Name(value='hydra.scala.syntax.ForData')

static builder()

enums: Sequence[Enumerator]

with_enums(enums)

class hydra.scala.syntax.ForYieldData(enums: 'Sequence[Enumerator]')

Bases: object

class Builder(_enums: 'Sequence[Enumerator]' = None)

Bases: object

build()

enums(enums)

ENUMS = Name(value='enums')

TYPE_ = Name(value='hydra.scala.syntax.ForYieldData')

static builder()

enums: Sequence[Enumerator]

with_enums(enums)

class hydra.scala.syntax.FunctionData(params: 'Sequence[ParamData]', body: 'Data')

Bases: object

BODY = Name(value='body')

class Builder(_params: 'Sequence[ParamData]' = None, _body: 'Data' = None)

Bases: object

body(body)

build()

params(params)

PARAMS = Name(value='params')

TYPE_ = Name(value='hydra.scala.syntax.FunctionData')

body: Data

static builder()

params: Sequence[ParamData]

with_body(body)

with_params(params)

class hydra.scala.syntax.FunctionType(params: 'Sequence[Type]', res: 'Type')

Bases: object

class Builder(_params: 'Sequence[Type]' = None, _res: 'Type' = None)

Bases: object

build()

params(params)

res(res)

PARAMS = Name(value='params')

RES = Name(value='res')

TYPE_ = Name(value='hydra.scala.syntax.FunctionType')

static builder()

params: Sequence[Type]

res: Type

with_params(params)

with_res(res)

class hydra.scala.syntax.GeneratorEnumerator(pat: 'Pat', rhs: 'Data')

Bases: object

class Builder(_pat: 'Pat' = None, _rhs: 'Data' = None)

Bases: object

build()

pat(pat)

rhs(rhs)

PAT = Name(value='pat')

RHS = Name(value='rhs')

TYPE_ = Name(value='hydra.scala.syntax.GeneratorEnumerator')

static builder()

pat: Pat

rhs: Data

with_pat(pat)

with_rhs(rhs)

class hydra.scala.syntax.GivenAliasDefn(mods: 'Sequence[Mod]', name: 'Name', tparams: 'Sequence[Sequence[ParamType]]', sparams: 'Sequence[Sequence[ParamData]]', decltpe: 'Type', body: 'Data')

Bases: object

BODY = Name(value='body')

class Builder(_mods: 'Sequence[Mod]' = None, _name: 'Name' = None, _tparams: 'Sequence[Sequence[ParamType]]' = None, _sparams: 'Sequence[Sequence[ParamData]]' = None, _decltpe: 'Type' = None, _body: 'Data' = None)

Bases: object

body(body)

build()

decltpe(decltpe)

mods(mods)

name(name)

sparams(sparams)

tparams(tparams)

DECLTPE = Name(value='decltpe')

MODS = Name(value='mods')

NAME = Name(value='name')

SPARAMS = Name(value='sparams')

TPARAMS = Name(value='tparams')

TYPE_ = Name(value='hydra.scala.syntax.GivenAliasDefn')

body: Data

static builder()

decltpe: Type

mods: Sequence[Mod]

name: Name

sparams: Sequence[Sequence[ParamData]]

tparams: Sequence[Sequence[ParamType]]

with_body(body)

with_decltpe(decltpe)

with_mods(mods)

with_name(name)

with_sparams(sparams)

with_tparams(tparams)

class hydra.scala.syntax.GivenDecl(mods: 'Sequence[Mod]', name: 'NameData', tparams: 'Sequence[ParamType]', sparams: 'Sequence[Sequence[ParamData]]', decltpe: 'Type')

Bases: object

class Builder(_mods: 'Sequence[Mod]' = None, _name: 'NameData' = None, _tparams: 'Sequence[ParamType]' = None, _sparams: 'Sequence[Sequence[ParamData]]' = None, _decltpe: 'Type' = None)

Bases: object

build()

decltpe(decltpe)

mods(mods)

name(name)

sparams(sparams)

tparams(tparams)

DECLTPE = Name(value='decltpe')

MODS = Name(value='mods')

NAME = Name(value='name')

SPARAMS = Name(value='sparams')

TPARAMS = Name(value='tparams')

TYPE_ = Name(value='hydra.scala.syntax.GivenDecl')

static builder()

decltpe: Type

mods: Sequence[Mod]

name: NameData

sparams: Sequence[Sequence[ParamData]]

tparams: Sequence[ParamType]

with_decltpe(decltpe)

with_mods(mods)

with_name(name)

with_sparams(sparams)

with_tparams(tparams)

class hydra.scala.syntax.GivenDefn(mods: 'Sequence[Mod]', name: 'Name', tparams: 'Sequence[Sequence[ParamType]]', sparams: 'Sequence[Sequence[ParamData]]', templ: 'Template')

Bases: object

class Builder(_mods: 'Sequence[Mod]' = None, _name: 'Name' = None, _tparams: 'Sequence[Sequence[ParamType]]' = None, _sparams: 'Sequence[Sequence[ParamData]]' = None, _templ: 'Template' = None)

Bases: object

build()

mods(mods)

name(name)

sparams(sparams)

templ(templ)

tparams(tparams)

MODS = Name(value='mods')

NAME = Name(value='name')

SPARAMS = Name(value='sparams')

TEMPL = Name(value='templ')

TPARAMS = Name(value='tparams')

TYPE_ = Name(value='hydra.scala.syntax.GivenDefn')

static builder()

mods: Sequence[Mod]

name: Name

sparams: Sequence[Sequence[ParamData]]

templ: Template

tparams: Sequence[Sequence[ParamType]]

with_mods(mods)

with_name(name)

with_sparams(sparams)

with_templ(templ)

with_tparams(tparams)

class hydra.scala.syntax.GivenImportee(tpe: 'Type')

Bases: object

class Builder(_tpe: 'Type' = None)

Bases: object

build()

tpe(tpe)

TPE = Name(value='tpe')

TYPE_ = Name(value='hydra.scala.syntax.GivenImportee')

static builder()

tpe: Type

with_tpe(tpe)

class hydra.scala.syntax.GivenPat(tpe: 'Type')

Bases: object

class Builder(_tpe: 'Type' = None)

Bases: object

build()

tpe(tpe)

TPE = Name(value='tpe')

TYPE_ = Name(value='hydra.scala.syntax.GivenPat')

static builder()

tpe: Type

with_tpe(tpe)

class hydra.scala.syntax.GuardEnumerator(cond: 'Data')

Bases: object

class Builder(_cond: 'Data' = None)

Bases: object

build()

cond(cond)

COND = Name(value='cond')

TYPE_ = Name(value='hydra.scala.syntax.GuardEnumerator')

static builder()

cond: Data

with_cond(cond)

class hydra.scala.syntax.IfData(cond: 'Data', thenp: 'Data', elsep: 'Data')

Bases: object

class Builder(_cond: 'Data' = None, _thenp: 'Data' = None, _elsep: 'Data' = None)

Bases: object

build()

cond(cond)

elsep(elsep)

thenp(thenp)

COND = Name(value='cond')

ELSEP = Name(value='elsep')

THENP = Name(value='thenp')

TYPE_ = Name(value='hydra.scala.syntax.IfData')

static builder()

cond: Data

elsep: Data

thenp: Data

with_cond(cond)

with_elsep(elsep)

with_thenp(thenp)

class hydra.scala.syntax.ImplicitFunctionType(params: 'Sequence[Type]', res: 'Type')

Bases: object

class Builder(_params: 'Sequence[Type]' = None, _res: 'Type' = None)

Bases: object

build()

params(params)

res(res)

PARAMS = Name(value='params')

RES = Name(value='res')

TYPE_ = Name(value='hydra.scala.syntax.ImplicitFunctionType')

static builder()

params: Sequence[Type]

res: Type

with_params(params)

with_res(res)

class hydra.scala.syntax.Import(importers: 'Sequence[Importer]')

Bases: object

class Builder(_importers: 'Sequence[Importer]' = None)

Bases: object

build()

importers(importers)

IMPORTERS = Name(value='importers')

TYPE_ = Name(value='hydra.scala.syntax.Import')

static builder()

importers: Sequence[Importer]

with_importers(importers)

class hydra.scala.syntax.ImportExportStat

Bases: object

ImportExportStatImport | ImportExportStatExport

EXPORT = Name(value='export')

IMPORT = Name(value='import')

TYPE_ = Name(value='hydra.scala.syntax.ImportExportStat')

class hydra.scala.syntax.ImportExportStatExport(value: T)

Bases: Node[Export]

class hydra.scala.syntax.ImportExportStatImport(value: T)

Bases: Node[Import]

class hydra.scala.syntax.Importee

Bases: object

ImporteeWildcard | ImporteeGiven | ImporteeGivenAll | ImporteeName | ImporteeRename | ImporteeUnimport

GIVEN = Name(value='given')

GIVEN_ALL = Name(value='givenAll')

NAME = Name(value='name')

RENAME = Name(value='rename')

TYPE_ = Name(value='hydra.scala.syntax.Importee')

UNIMPORT = Name(value='unimport')

WILDCARD = Name(value='wildcard')

class hydra.scala.syntax.ImporteeGiven(value: T)

Bases: Node[GivenImportee]

class hydra.scala.syntax.ImporteeGivenAll

Bases: object

class hydra.scala.syntax.ImporteeName(value: T)

Bases: Node[NameImportee]

class hydra.scala.syntax.ImporteeRename(value: T)

Bases: Node[RenameImportee]

class hydra.scala.syntax.ImporteeUnimport(value: T)

Bases: Node[UnimportImportee]

class hydra.scala.syntax.ImporteeWildcard

Bases: object

class hydra.scala.syntax.Importer(ref: 'RefData', importees: 'Sequence[Importee]')

Bases: object

class Builder(_ref: 'RefData' = None, _importees: 'Sequence[Importee]' = None)

Bases: object

build()

importees(importees)

ref(ref)

IMPORTEES = Name(value='importees')

REF = Name(value='ref')

TYPE_ = Name(value='hydra.scala.syntax.Importer')

static builder()

importees: Sequence[Importee]

ref: RefData

with_importees(importees)

with_ref(ref)

class hydra.scala.syntax.Init(tpe: 'Type', name: 'Name', argss: 'Sequence[Sequence[Data]]')

Bases: object

ARGSS = Name(value='argss')

class Builder(_tpe: 'Type' = None, _name: 'Name' = None, _argss: 'Sequence[Sequence[Data]]' = None)

Bases: object

argss(argss)

build()

name(name)

tpe(tpe)

NAME = Name(value='name')

TPE = Name(value='tpe')

TYPE_ = Name(value='hydra.scala.syntax.Init')

argss: Sequence[Sequence[Data]]

static builder()

name: Name

tpe: Type

with_argss(argss)

with_name(name)

with_tpe(tpe)

class hydra.scala.syntax.InterpolateData(prefix: 'NameData', parts: 'Sequence[Lit]', args: 'Sequence[Data]')

Bases: object

ARGS = Name(value='args')

class Builder(_prefix: 'NameData' = None, _parts: 'Sequence[Lit]' = None, _args: 'Sequence[Data]' = None)

Bases: object

args(args)

build()

parts(parts)

prefix(prefix)

PARTS = Name(value='parts')

PREFIX = Name(value='prefix')

TYPE_ = Name(value='hydra.scala.syntax.InterpolateData')

args: Sequence[Data]

static builder()

parts: Sequence[Lit]

prefix: NameData

with_args(args)

with_parts(parts)

with_prefix(prefix)

class hydra.scala.syntax.InterpolatePat(prefix: 'NameData', parts: 'Sequence[Lit]')

Bases: object

class Builder(_prefix: 'NameData' = None, _parts: 'Sequence[Lit]' = None)

Bases: object

build()

parts(parts)

prefix(prefix)

PARTS = Name(value='parts')

PREFIX = Name(value='prefix')

TYPE_ = Name(value='hydra.scala.syntax.InterpolatePat')

static builder()

parts: Sequence[Lit]

prefix: NameData

with_parts(parts)

with_prefix(prefix)

class hydra.scala.syntax.LambdaType(tparams: 'Sequence[ParamType]', tpe: 'Type')

Bases: object

class Builder(_tparams: 'Sequence[ParamType]' = None, _tpe: 'Type' = None)

Bases: object

build()

tparams(tparams)

tpe(tpe)

TPARAMS = Name(value='tparams')

TPE = Name(value='tpe')

TYPE_ = Name(value='hydra.scala.syntax.LambdaType')

static builder()

tparams: Sequence[ParamType]

tpe: Type

with_tparams(tparams)

with_tpe(tpe)

class hydra.scala.syntax.Lit

Bases: object

LitNull | LitInt | LitDouble | LitFloat | LitByte | LitShort | LitChar | LitLong | LitBoolean | LitUnit | LitString | LitBytes | LitSymbol

BOOLEAN = Name(value='boolean')

BYTE = Name(value='byte')

BYTES = Name(value='bytes')

CHAR = Name(value='char')

DOUBLE = Name(value='double')

FLOAT = Name(value='float')

INT = Name(value='int')

LONG = Name(value='long')

NULL = Name(value='null')

SHORT = Name(value='short')

STRING = Name(value='string')

SYMBOL = Name(value='symbol')

TYPE_ = Name(value='hydra.scala.syntax.Lit')

UNIT = Name(value='unit')

class hydra.scala.syntax.LitBoolean(value: T)

Bases: Node[bool]

class hydra.scala.syntax.LitByte(value: T)

Bases: Node[int]

class hydra.scala.syntax.LitBytes(value: T)

Bases: Node[Sequence[int]]

class hydra.scala.syntax.LitChar(value: T)

Bases: Node[int]

class hydra.scala.syntax.LitDouble(value: T)

Bases: Node[float]

class hydra.scala.syntax.LitFloat(value: T)

Bases: Node[float]

class hydra.scala.syntax.LitInt(value: T)

Bases: Node[int]

class hydra.scala.syntax.LitLong(value: T)

Bases: Node[int]

class hydra.scala.syntax.LitNull

Bases: object

class hydra.scala.syntax.LitShort(value: T)

Bases: Node[int]

class hydra.scala.syntax.LitString(value: T)

Bases: Node[str]

class hydra.scala.syntax.LitSymbol(value: T)

Bases: Node[ScalaSymbol]

class hydra.scala.syntax.LitUnit

Bases: object

class hydra.scala.syntax.MatchData(expr: 'Data', cases: 'Sequence[Case]')

Bases: object

class Builder(_expr: 'Data' = None, _cases: 'Sequence[Case]' = None)

Bases: object

build()

cases(cases)

expr(expr)

CASES = Name(value='cases')

EXPR = Name(value='expr')

TYPE_ = Name(value='hydra.scala.syntax.MatchData')

static builder()

cases: Sequence[Case]

expr: Data

with_cases(cases)

with_expr(expr)

class hydra.scala.syntax.MatchType(tpe: 'Type', cases: 'Sequence[TypeCase]')

Bases: object

class Builder(_tpe: 'Type' = None, _cases: 'Sequence[TypeCase]' = None)

Bases: object

build()

cases(cases)

tpe(tpe)

CASES = Name(value='cases')

TPE = Name(value='tpe')

TYPE_ = Name(value='hydra.scala.syntax.MatchType')

static builder()

cases: Sequence[TypeCase]

tpe: Type

with_cases(cases)

with_tpe(tpe)

class hydra.scala.syntax.Member

Bases: object

MemberTerm | MemberType | MemberTermParam | MemberTypeParam | MemberSelf

SELF = Name(value='self')

TERM = Name(value='term')

TERM_PARAM = Name(value='termParam')

TYPE = Name(value='type')

TYPE_ = Name(value='hydra.scala.syntax.Member')

TYPE_PARAM = Name(value='typeParam')

class hydra.scala.syntax.MemberSelf(value: T)

Bases: Node[Self]

class hydra.scala.syntax.MemberTerm(value: T)

Bases: Node[DataMember]

class hydra.scala.syntax.MemberTermParam(value: T)

Bases: Node[ParamData]

class hydra.scala.syntax.MemberType(value: T)

Bases: Node[TypeMember]

class hydra.scala.syntax.MemberTypeParam(value: T)

Bases: Node[ParamType]

class hydra.scala.syntax.MethodType(paramss: 'Sequence[Sequence[ParamData]]', tpe: 'Type')

Bases: object

class Builder(_paramss: 'Sequence[Sequence[ParamData]]' = None, _tpe: 'Type' = None)

Bases: object

build()

paramss(paramss)

tpe(tpe)

PARAMSS = Name(value='paramss')

TPE = Name(value='tpe')

TYPE_ = Name(value='hydra.scala.syntax.MethodType')

static builder()

paramss: Sequence[Sequence[ParamData]]

tpe: Type

with_paramss(paramss)

with_tpe(tpe)

class hydra.scala.syntax.Mod

Bases: object

ModAnnot | ModPrivate | ModProtected | ModImplicit | ModFinal | ModSealed | ModOpen | ModSuper | ModOverride | ModCase | ModAbstract | ModCovariant | ModContravariant | ModLazy | ModValParam | ModVarParam | ModInfix | ModInline | ModUsing | ModOpaque | ModTransparent

ABSTRACT = Name(value='abstract')

ANNOT = Name(value='annot')

CASE = Name(value='case')

CONTRAVARIANT = Name(value='contravariant')

COVARIANT = Name(value='covariant')

FINAL = Name(value='final')

IMPLICIT = Name(value='implicit')

INFIX = Name(value='infix')

INLINE = Name(value='inline')

LAZY = Name(value='lazy')

OPAQUE = Name(value='opaque')

OPEN = Name(value='open')

OVERRIDE = Name(value='override')

PRIVATE = Name(value='private')

PROTECTED = Name(value='protected')

SEALED = Name(value='sealed')

SUPER = Name(value='super')

TRANSPARENT = Name(value='transparent')

TYPE_ = Name(value='hydra.scala.syntax.Mod')

USING = Name(value='using')

VAL_PARAM = Name(value='valParam')

VAR_PARAM = Name(value='varParam')

class hydra.scala.syntax.ModAbstract

Bases: object

class hydra.scala.syntax.ModAnnot(value: T)

Bases: Node[AnnotMod]

class hydra.scala.syntax.ModCase

Bases: object

class hydra.scala.syntax.ModContravariant

Bases: object

class hydra.scala.syntax.ModCovariant

Bases: object

class hydra.scala.syntax.ModFinal

Bases: object

class hydra.scala.syntax.ModImplicit

Bases: object

class hydra.scala.syntax.ModInfix

Bases: object

class hydra.scala.syntax.ModInline

Bases: object

class hydra.scala.syntax.ModLazy

Bases: object

class hydra.scala.syntax.ModOpaque

Bases: object

class hydra.scala.syntax.ModOpen

Bases: object

class hydra.scala.syntax.ModOverride

Bases: object

class hydra.scala.syntax.ModPrivate(value: T)

Bases: Node[PrivateMod]

class hydra.scala.syntax.ModProtected(value: T)

Bases: Node[ProtectedMod]

class hydra.scala.syntax.ModSealed

Bases: object

class hydra.scala.syntax.ModSuper

Bases: object

class hydra.scala.syntax.ModTransparent

Bases: object

class hydra.scala.syntax.ModUsing

Bases: object

class hydra.scala.syntax.ModValParam

Bases: object

class hydra.scala.syntax.ModVarParam

Bases: object

class hydra.scala.syntax.Name

Bases: object

NameValue | NameAnonymous | NameIndeterminate

ANONYMOUS = Name(value='anonymous')

INDETERMINATE = Name(value='indeterminate')

TYPE_ = Name(value='hydra.scala.syntax.Name')

VALUE = Name(value='value')

class hydra.scala.syntax.NameAnonymous

Bases: object

class hydra.scala.syntax.NameData(value: 'PredefString')

Bases: object

class Builder(_value: 'PredefString' = None)

Bases: object

build()

value(value)

TYPE_ = Name(value='hydra.scala.syntax.NameData')

VALUE = Name(value='value')

static builder()

value: PredefString

with_value(value)

class hydra.scala.syntax.NameImportee(name: 'Name')

Bases: object

class Builder(_name: 'Name' = None)

Bases: object

build()

name(name)

NAME = Name(value='name')

TYPE_ = Name(value='hydra.scala.syntax.NameImportee')

static builder()

name: Name

with_name(name)

class hydra.scala.syntax.NameIndeterminate(value: T)

Bases: Node[PredefString]

class hydra.scala.syntax.NameType(value: 'str')

Bases: object

class Builder(_value: 'str' = None)

Bases: object

build()

value(value)

TYPE_ = Name(value='hydra.scala.syntax.NameType')

VALUE = Name(value='value')

static builder()

value: str

with_value(value)

class hydra.scala.syntax.NameValue(value: T)

Bases: Node[str]

class hydra.scala.syntax.NewAnonymousData(templ: 'Template')

Bases: object

class Builder(_templ: 'Template' = None)

Bases: object

build()

templ(templ)

TEMPL = Name(value='templ')

TYPE_ = Name(value='hydra.scala.syntax.NewAnonymousData')

static builder()

templ: Template

with_templ(templ)

class hydra.scala.syntax.NewData(init: 'Init')

Bases: object

class Builder(_init: 'Init' = None)

Bases: object

build()

init(init)

INIT = Name(value='init')

TYPE_ = Name(value='hydra.scala.syntax.NewData')

static builder()

init: Init

with_init(init)

class hydra.scala.syntax.ObjectDefn(name: 'NameData')

Bases: object

class Builder(_name: 'NameData' = None)

Bases: object

build()

name(name)

NAME = Name(value='name')

TYPE_ = Name(value='hydra.scala.syntax.ObjectDefn')

static builder()

name: NameData

with_name(name)

class hydra.scala.syntax.ObjectPkg(mods: 'Sequence[Mod]', name: 'NameData', template: 'Template')

Bases: object

class Builder(_mods: 'Sequence[Mod]' = None, _name: 'NameData' = None, _template: 'Template' = None)

Bases: object

build()

mods(mods)

name(name)

template(template)

MODS = Name(value='mods')

NAME = Name(value='name')

TEMPLATE = Name(value='template')

TYPE_ = Name(value='hydra.scala.syntax.ObjectPkg')

static builder()

mods: Sequence[Mod]

name: NameData

template: Template

with_mods(mods)

with_name(name)

with_template(template)

class hydra.scala.syntax.OrType(lhs: 'Type', rhs: 'Type')

Bases: object

class Builder(_lhs: 'Type' = None, _rhs: 'Type' = None)

Bases: object

build()

lhs(lhs)

rhs(rhs)

LHS = Name(value='lhs')

RHS = Name(value='rhs')

TYPE_ = Name(value='hydra.scala.syntax.OrType')

static builder()

lhs: Type

rhs: Type

with_lhs(lhs)

with_rhs(rhs)

class hydra.scala.syntax.ParamData(mods: 'Sequence[Mod]', name: 'Name', decltpe: 'Optional[Type]', default: 'Optional[Data]')

Bases: object

class Builder(_mods: 'Sequence[Mod]' = None, _name: 'Name' = None, _decltpe: 'Optional[Type]' = None, _default: 'Optional[Data]' = None)

Bases: object

build()

decltpe(decltpe)

default(default)

mods(mods)

name(name)

DECLTPE = Name(value='decltpe')

DEFAULT = Name(value='default')

MODS = Name(value='mods')

NAME = Name(value='name')

TYPE_ = Name(value='hydra.scala.syntax.ParamData')

static builder()

decltpe: object

default: object

mods: Sequence[Mod]

name: Name

with_decltpe(decltpe)

with_default(default)

with_mods(mods)

with_name(name)

class hydra.scala.syntax.ParamType(mods: 'Sequence[Mod]', name: 'Name', tparams: 'Sequence[ParamType]', tbounds: 'Sequence[TypeBounds]', vbounds: 'Sequence[Type]', cbounds: 'Sequence[Type]')

Bases: object

class Builder(_mods: 'Sequence[Mod]' = None, _name: 'Name' = None, _tparams: 'Sequence[ParamType]' = None, _tbounds: 'Sequence[TypeBounds]' = None, _vbounds: 'Sequence[Type]' = None, _cbounds: 'Sequence[Type]' = None)

Bases: object

build()

cbounds(cbounds)

mods(mods)

name(name)

tbounds(tbounds)

tparams(tparams)

vbounds(vbounds)

CBOUNDS = Name(value='cbounds')

MODS = Name(value='mods')

NAME = Name(value='name')

TBOUNDS = Name(value='tbounds')

TPARAMS = Name(value='tparams')

TYPE_ = Name(value='hydra.scala.syntax.ParamType')

VBOUNDS = Name(value='vbounds')

static builder()

cbounds: Sequence[Type]

mods: Sequence[Mod]

name: Name

tbounds: Sequence[TypeBounds]

tparams: Sequence[ParamType]

vbounds: Sequence[Type]

with_cbounds(cbounds)

with_mods(mods)

with_name(name)

with_tbounds(tbounds)

with_tparams(tparams)

with_vbounds(vbounds)

class hydra.scala.syntax.PartialFunctionData(cases: 'Sequence[Case]')

Bases: object

class Builder(_cases: 'Sequence[Case]' = None)

Bases: object

build()

cases(cases)

CASES = Name(value='cases')

TYPE_ = Name(value='hydra.scala.syntax.PartialFunctionData')

static builder()

cases: Sequence[Case]

with_cases(cases)

class hydra.scala.syntax.Pat

Bases: object

PatVar | PatWildcard | PatSeqWildcard | PatBind | PatAlternative | PatTuple | PatRepeated | PatExtract | PatExtractInfix | PatInterpolate | PatTyped | PatGiven

ALTERNATIVE = Name(value='alternative')

BIND = Name(value='bind')

EXTRACT = Name(value='extract')

EXTRACT_INFIX = Name(value='extractInfix')

GIVEN = Name(value='given')

INTERPOLATE = Name(value='interpolate')

REPEATED = Name(value='repeated')

SEQ_WILDCARD = Name(value='seqWildcard')

TUPLE = Name(value='tuple')

TYPED = Name(value='typed')

TYPE_ = Name(value='hydra.scala.syntax.Pat')

VAR = Name(value='var')

WILDCARD = Name(value='wildcard')

class hydra.scala.syntax.PatAlternative(value: T)

Bases: Node[AlternativePat]

class hydra.scala.syntax.PatBind(value: T)

Bases: Node[BindPat]

class hydra.scala.syntax.PatExtract(value: T)

Bases: Node[ExtractPat]

class hydra.scala.syntax.PatExtractInfix(value: T)

Bases: Node[ExtractInfixPat]

class hydra.scala.syntax.PatGiven(value: T)

Bases: Node[GivenPat]

class hydra.scala.syntax.PatInterpolate(value: T)

Bases: Node[InterpolatePat]

class hydra.scala.syntax.PatRepeated(value: T)

Bases: Node[RepeatedPat]

class hydra.scala.syntax.PatSeqWildcard

Bases: object

class hydra.scala.syntax.PatTuple(value: T)

Bases: Node[TuplePat]

class hydra.scala.syntax.PatTyped(value: T)

Bases: Node[TypedPat]

class hydra.scala.syntax.PatVar(value: T)

Bases: Node[VarPat]

class hydra.scala.syntax.PatWildcard

Bases: object

class hydra.scala.syntax.Pkg(name: 'NameData', ref: 'RefData', stats: 'Sequence[Stat]')

Bases: object

class Builder(_name: 'NameData' = None, _ref: 'RefData' = None, _stats: 'Sequence[Stat]' = None)

Bases: object

build()

name(name)

ref(ref)

stats(stats)

NAME = Name(value='name')

REF = Name(value='ref')

STATS = Name(value='stats')

TYPE_ = Name(value='hydra.scala.syntax.Pkg')

static builder()

name: NameData

ref: RefData

stats: Sequence[Stat]

with_name(name)

with_ref(ref)

with_stats(stats)

class hydra.scala.syntax.PlaceholderType(bounds: 'TypeBounds')

Bases: object

BOUNDS = Name(value='bounds')

class Builder(_bounds: 'TypeBounds' = None)

Bases: object

bounds(bounds)

build()

TYPE_ = Name(value='hydra.scala.syntax.PlaceholderType')

bounds: TypeBounds

static builder()

with_bounds(bounds)

class hydra.scala.syntax.PolyFunctionData(tparams: 'Sequence[ParamType]', body: 'Data')

Bases: object

BODY = Name(value='body')

class Builder(_tparams: 'Sequence[ParamType]' = None, _body: 'Data' = None)

Bases: object

body(body)

build()

tparams(tparams)

TPARAMS = Name(value='tparams')

TYPE_ = Name(value='hydra.scala.syntax.PolyFunctionData')

body: Data

static builder()

tparams: Sequence[ParamType]

with_body(body)

with_tparams(tparams)

class hydra.scala.syntax.PolyFunctionType(tparams: 'Sequence[ParamType]', tpe: 'Type')

Bases: object

class Builder(_tparams: 'Sequence[ParamType]' = None, _tpe: 'Type' = None)

Bases: object

build()

tparams(tparams)

tpe(tpe)

TPARAMS = Name(value='tparams')

TPE = Name(value='tpe')

TYPE_ = Name(value='hydra.scala.syntax.PolyFunctionType')

static builder()

tparams: Sequence[ParamType]

tpe: Type

with_tparams(tparams)

with_tpe(tpe)

class hydra.scala.syntax.PredefString(value: T)

Bases: Node[str]

A wrapper for strings used in scala.Predef contexts.

TYPE_ = Name(value='hydra.scala.syntax.PredefString')

class hydra.scala.syntax.PrimaryCtor(mods: 'Sequence[Mod]', name: 'Name', paramss: 'Sequence[Sequence[ParamData]]')

Bases: object

class Builder(_mods: 'Sequence[Mod]' = None, _name: 'Name' = None, _paramss: 'Sequence[Sequence[ParamData]]' = None)

Bases: object

build()

mods(mods)

name(name)

paramss(paramss)

MODS = Name(value='mods')

NAME = Name(value='name')

PARAMSS = Name(value='paramss')

TYPE_ = Name(value='hydra.scala.syntax.PrimaryCtor')

static builder()

mods: Sequence[Mod]

name: Name

paramss: Sequence[Sequence[ParamData]]

with_mods(mods)

with_name(name)

with_paramss(paramss)

class hydra.scala.syntax.PrivateMod(within: 'Ref')

Bases: object

class Builder(_within: 'Ref' = None)

Bases: object

build()

within(within)

TYPE_ = Name(value='hydra.scala.syntax.PrivateMod')

WITHIN = Name(value='within')

static builder()

with_within(within)

within: Ref

class hydra.scala.syntax.ProjectType(qual: 'Type', name: 'NameType')

Bases: object

class Builder(_qual: 'Type' = None, _name: 'NameType' = None)

Bases: object

build()

name(name)

qual(qual)

NAME = Name(value='name')

QUAL = Name(value='qual')

TYPE_ = Name(value='hydra.scala.syntax.ProjectType')

static builder()

name: NameType

qual: Type

with_name(name)

with_qual(qual)

class hydra.scala.syntax.ProtectedMod(within: 'Ref')

Bases: object

class Builder(_within: 'Ref' = None)

Bases: object

build()

within(within)

TYPE_ = Name(value='hydra.scala.syntax.ProtectedMod')

WITHIN = Name(value='within')

static builder()

with_within(within)

within: Ref

class hydra.scala.syntax.Ref

Bases: object

RefName | RefInit

INIT = Name(value='init')

NAME = Name(value='name')

TYPE_ = Name(value='hydra.scala.syntax.Ref')

class hydra.scala.syntax.RefData

Bases: object

RefDataThis | RefDataSuper | RefDataName | RefDataAnonymous | RefDataSelect | RefDataApplyUnary

ANONYMOUS = Name(value='anonymous')

APPLY_UNARY = Name(value='applyUnary')

NAME = Name(value='name')

SELECT = Name(value='select')

SUPER = Name(value='super')

THIS = Name(value='this')

TYPE_ = Name(value='hydra.scala.syntax.RefData')

class hydra.scala.syntax.RefDataAnonymous(value: T)

Bases: Node[AnonymousData]

class hydra.scala.syntax.RefDataApplyUnary(value: T)

Bases: Node[ApplyUnaryData]

class hydra.scala.syntax.RefDataName(value: T)

Bases: Node[NameData]

class hydra.scala.syntax.RefDataSelect(value: T)

Bases: Node[SelectData]

class hydra.scala.syntax.RefDataSuper(value: T)

Bases: Node[SuperData]

class hydra.scala.syntax.RefDataThis(value: T)

Bases: Node[ThisData]

class hydra.scala.syntax.RefInit(value: T)

Bases: Node[Init]

class hydra.scala.syntax.RefName(value: T)

Bases: Node[Name]

class hydra.scala.syntax.RefType

Bases: object

RefTypeName | RefTypeSelect | RefTypeProject | RefTypeSingleton

NAME = Name(value='name')

PROJECT = Name(value='project')

SELECT = Name(value='select')

SINGLETON = Name(value='singleton')

TYPE_ = Name(value='hydra.scala.syntax.RefType')

class hydra.scala.syntax.RefTypeName(value: T)

Bases: Node[NameType]

class hydra.scala.syntax.RefTypeProject(value: T)

Bases: Node[ProjectType]

class hydra.scala.syntax.RefTypeSelect(value: T)

Bases: Node[SelectType]

class hydra.scala.syntax.RefTypeSingleton(value: T)

Bases: Node[SingletonType]

class hydra.scala.syntax.RefineType(tpe: 'Optional[Type]', stats: 'Sequence[Stat]')

Bases: object

class Builder(_tpe: 'Optional[Type]' = None, _stats: 'Sequence[Stat]' = None)

Bases: object

build()

stats(stats)

tpe(tpe)

STATS = Name(value='stats')

TPE = Name(value='tpe')

TYPE_ = Name(value='hydra.scala.syntax.RefineType')

static builder()

stats: Sequence[Stat]

tpe: object

with_stats(stats)

with_tpe(tpe)

class hydra.scala.syntax.RenameImportee(name: 'Name', rename: 'Name')

Bases: object

class Builder(_name: 'Name' = None, _rename: 'Name' = None)

Bases: object

build()

name(name)

rename(rename)

NAME = Name(value='name')

RENAME = Name(value='rename')

TYPE_ = Name(value='hydra.scala.syntax.RenameImportee')

static builder()

name: Name

rename: Name

with_name(name)

with_rename(rename)

class hydra.scala.syntax.RepeatedData(expr: 'Data')

Bases: object

class Builder(_expr: 'Data' = None)

Bases: object

build()

expr(expr)

EXPR = Name(value='expr')

TYPE_ = Name(value='hydra.scala.syntax.RepeatedData')

static builder()

expr: Data

with_expr(expr)

class hydra.scala.syntax.RepeatedEnumCaseDefn(mods: 'Sequence[Mod]', cases: 'Sequence[NameData]')

Bases: object

class Builder(_mods: 'Sequence[Mod]' = None, _cases: 'Sequence[NameData]' = None)

Bases: object

build()

cases(cases)

mods(mods)

CASES = Name(value='cases')

MODS = Name(value='mods')

TYPE_ = Name(value='hydra.scala.syntax.RepeatedEnumCaseDefn')

static builder()

cases: Sequence[NameData]

mods: Sequence[Mod]

with_cases(cases)

with_mods(mods)

class hydra.scala.syntax.RepeatedPat(name: 'NameData')

Bases: object

class Builder(_name: 'NameData' = None)

Bases: object

build()

name(name)

NAME = Name(value='name')

TYPE_ = Name(value='hydra.scala.syntax.RepeatedPat')

static builder()

name: NameData

with_name(name)

class hydra.scala.syntax.RepeatedType(tpe: 'Type')

Bases: object

class Builder(_tpe: 'Type' = None)

Bases: object

build()

tpe(tpe)

TPE = Name(value='tpe')

TYPE_ = Name(value='hydra.scala.syntax.RepeatedType')

static builder()

tpe: Type

with_tpe(tpe)

class hydra.scala.syntax.ReturnData(expr: 'Data')

Bases: object

class Builder(_expr: 'Data' = None)

Bases: object

build()

expr(expr)

EXPR = Name(value='expr')

TYPE_ = Name(value='hydra.scala.syntax.ReturnData')

static builder()

expr: Data

with_expr(expr)

class hydra.scala.syntax.ScalaSymbol(name: str)

Bases: object

A Scala 2 symbol literal (corresponds to scala.Symbol).

class Builder(_name: 'str' = None)

Bases: object

build()

name(name)

NAME = Name(value='name')

TYPE_ = Name(value='hydra.scala.syntax.ScalaSymbol')

static builder()

name: str

with_name(name)

class hydra.scala.syntax.SecondaryCtor(mods: 'Sequence[Mod]', name: 'Name', paramss: 'Sequence[Sequence[ParamData]]', init: 'Init', stats: 'Sequence[Stat]')

Bases: object

class Builder(_mods: 'Sequence[Mod]' = None, _name: 'Name' = None, _paramss: 'Sequence[Sequence[ParamData]]' = None, _init: 'Init' = None, _stats: 'Sequence[Stat]' = None)

Bases: object

build()

init(init)

mods(mods)

name(name)

paramss(paramss)

stats(stats)

INIT = Name(value='init')

MODS = Name(value='mods')

NAME = Name(value='name')

PARAMSS = Name(value='paramss')

STATS = Name(value='stats')

TYPE_ = Name(value='hydra.scala.syntax.SecondaryCtor')

static builder()

init: Init

mods: Sequence[Mod]

name: Name

paramss: Sequence[Sequence[ParamData]]

stats: Sequence[Stat]

with_init(init)

with_mods(mods)

with_name(name)

with_paramss(paramss)

with_stats(stats)

class hydra.scala.syntax.SelectData(qual: 'Data', name: 'NameData')

Bases: object

class Builder(_qual: 'Data' = None, _name: 'NameData' = None)

Bases: object

build()

name(name)

qual(qual)

NAME = Name(value='name')

QUAL = Name(value='qual')

TYPE_ = Name(value='hydra.scala.syntax.SelectData')

static builder()

name: NameData

qual: Data

with_name(name)

with_qual(qual)

class hydra.scala.syntax.SelectType(qual: 'RefData', name: 'NameType')

Bases: object

class Builder(_qual: 'RefData' = None, _name: 'NameType' = None)

Bases: object

build()

name(name)

qual(qual)

NAME = Name(value='name')

QUAL = Name(value='qual')

TYPE_ = Name(value='hydra.scala.syntax.SelectType')

static builder()

name: NameType

qual: RefData

with_name(name)

with_qual(qual)

class hydra.scala.syntax.Self(value: T)

Bases: Node[None]

TYPE_ = Name(value='hydra.scala.syntax.Self')

class hydra.scala.syntax.SingletonType(ref: 'RefData')

Bases: object

class Builder(_ref: 'RefData' = None)

Bases: object

build()

ref(ref)

REF = Name(value='ref')

TYPE_ = Name(value='hydra.scala.syntax.SingletonType')

static builder()

ref: RefData

with_ref(ref)

class hydra.scala.syntax.Source(stats: 'Sequence[Stat]')

Bases: object

class Builder(_stats: 'Sequence[Stat]' = None)

Bases: object

build()

stats(stats)

STATS = Name(value='stats')

TYPE_ = Name(value='hydra.scala.syntax.Source')

static builder()

stats: Sequence[Stat]

with_stats(stats)

class hydra.scala.syntax.Stat

Bases: object

StatTerm | StatDecl | StatDefn | StatImportExport

DECL = Name(value='decl')

DEFN = Name(value='defn')

IMPORT_EXPORT = Name(value='importExport')

TERM = Name(value='term')

TYPE_ = Name(value='hydra.scala.syntax.Stat')

class hydra.scala.syntax.StatDecl(value: T)

Bases: Node[Decl]

class hydra.scala.syntax.StatDefn(value: T)

Bases: Node[Defn]

class hydra.scala.syntax.StatImportExport(value: T)

Bases: Node[ImportExportStat]

class hydra.scala.syntax.StatTerm(value: T)

Bases: Node[Data]

class hydra.scala.syntax.SuperData(thisp: 'Name', superp: 'Name')

Bases: object

class Builder(_thisp: 'Name' = None, _superp: 'Name' = None)

Bases: object

build()

superp(superp)

thisp(thisp)

SUPERP = Name(value='superp')

THISP = Name(value='thisp')

TYPE_ = Name(value='hydra.scala.syntax.SuperData')

static builder()

superp: Name

thisp: Name

with_superp(superp)

with_thisp(thisp)

class hydra.scala.syntax.Template(early: 'Sequence[Stat]', inits: 'Sequence[Init]', self: 'Self', stats: 'Sequence[Stat]')

Bases: object

class Builder(_early: 'Sequence[Stat]' = None, _inits: 'Sequence[Init]' = None, _self: 'Self' = None, _stats: 'Sequence[Stat]' = None)

Bases: object

build()

early(early)

inits(inits)

self_(self_)

stats(stats)

EARLY = Name(value='early')

INITS = Name(value='inits')

SELF = Name(value='self')

STATS = Name(value='stats')

TYPE_ = Name(value='hydra.scala.syntax.Template')

static builder()

early: Sequence[Stat]

inits: Sequence[Init]

self: Self

stats: Sequence[Stat]

with_early(early)

with_inits(inits)

with_self(_self)

with_stats(stats)

class hydra.scala.syntax.ThisData(value: T)

Bases: Node[None]

TYPE_ = Name(value='hydra.scala.syntax.ThisData')

class hydra.scala.syntax.ThrowData(expr: 'Data')

Bases: object

class Builder(_expr: 'Data' = None)

Bases: object

build()

expr(expr)

EXPR = Name(value='expr')

TYPE_ = Name(value='hydra.scala.syntax.ThrowData')

static builder()

expr: Data

with_expr(expr)

class hydra.scala.syntax.TraitDefn(mods: 'Sequence[Mod]', name: 'NameType', tparams: 'Sequence[ParamType]', ctor: 'PrimaryCtor', template: 'Template')

Bases: object

class Builder(_mods: 'Sequence[Mod]' = None, _name: 'NameType' = None, _tparams: 'Sequence[ParamType]' = None, _ctor: 'PrimaryCtor' = None, _template: 'Template' = None)

Bases: object

build()

ctor(ctor)

mods(mods)

name(name)

template(template)

tparams(tparams)

CTOR = Name(value='ctor')

MODS = Name(value='mods')

NAME = Name(value='name')

TEMPLATE = Name(value='template')

TPARAMS = Name(value='tparams')

TYPE_ = Name(value='hydra.scala.syntax.TraitDefn')

static builder()

ctor: PrimaryCtor

mods: Sequence[Mod]

name: NameType

template: Template

tparams: Sequence[ParamType]

with_ctor(ctor)

with_mods(mods)

with_name(name)

with_template(template)

with_tparams(tparams)

class hydra.scala.syntax.Tree

Bases: object

TreeRef | TreeStat | TreeType | TreeBounds | TreePat | TreeMember | TreeCtor | TreeTemplate | TreeMod | TreeEnumerator | TreeImporter | TreeImportee | TreeCaseTree | TreeSource

BOUNDS = Name(value='bounds')

CASE_TREE = Name(value='caseTree')

CTOR = Name(value='ctor')

ENUMERATOR = Name(value='enumerator')

IMPORTEE = Name(value='importee')

IMPORTER = Name(value='importer')

MEMBER = Name(value='member')

MOD = Name(value='mod')

PAT = Name(value='pat')

REF = Name(value='ref')

SOURCE = Name(value='source')

STAT = Name(value='stat')

TEMPLATE = Name(value='template')

TYPE = Name(value='type')

TYPE_ = Name(value='hydra.scala.syntax.Tree')

class hydra.scala.syntax.TreeBounds(value: T)

Bases: Node[TypeBounds]

class hydra.scala.syntax.TreeCaseTree(value: T)

Bases: Node[CaseTree]

class hydra.scala.syntax.TreeCtor(value: T)

Bases: Node[Ctor]

class hydra.scala.syntax.TreeEnumerator(value: T)

Bases: Node[Enumerator]

class hydra.scala.syntax.TreeImportee(value: T)

Bases: Node[Importee]

class hydra.scala.syntax.TreeImporter(value: T)

Bases: Node[Importer]

class hydra.scala.syntax.TreeMember(value: T)

Bases: Node[Member]

class hydra.scala.syntax.TreeMod(value: T)

Bases: Node[Mod]

class hydra.scala.syntax.TreePat(value: T)

Bases: Node[Pat]

class hydra.scala.syntax.TreeRef(value: T)

Bases: Node[Ref]

class hydra.scala.syntax.TreeSource(value: T)

Bases: Node[Source]

class hydra.scala.syntax.TreeStat(value: T)

Bases: Node[Stat]

class hydra.scala.syntax.TreeTemplate(value: T)

Bases: Node[Template]

class hydra.scala.syntax.TreeType(value: T)

Bases: Node[Type]

class hydra.scala.syntax.TryData(expr: 'Data', catchp: 'Sequence[Case]', finallyp: 'Optional[Data]')

Bases: object

class Builder(_expr: 'Data' = None, _catchp: 'Sequence[Case]' = None, _finallyp: 'Optional[Data]' = None)

Bases: object

build()

catchp(catchp)

expr(expr)

finallyp(finallyp)

CATCHP = Name(value='catchp')

EXPR = Name(value='expr')

FINALLYP = Name(value='finallyp')

TYPE_ = Name(value='hydra.scala.syntax.TryData')

static builder()

catchp: Sequence[Case]

expr: Data

finallyp: object

with_catchp(catchp)

with_expr(expr)

with_finallyp(finallyp)

class hydra.scala.syntax.TryWithHandlerData(expr: 'Data', catchp: 'Data', finallyp: 'Optional[Data]')

Bases: object

class Builder(_expr: 'Data' = None, _catchp: 'Data' = None, _finallyp: 'Optional[Data]' = None)

Bases: object

build()

catchp(catchp)

expr(expr)

finallyp(finallyp)

CATCHP = Name(value='catchp')

EXPR = Name(value='expr')

FINALLYP = Name(value='finallyp')

TYPE_ = Name(value='hydra.scala.syntax.TryWithHandlerData')

static builder()

catchp: Data

expr: Data

finallyp: object

with_catchp(catchp)

with_expr(expr)

with_finallyp(finallyp)

class hydra.scala.syntax.TupleData(args: 'Sequence[Data]')

Bases: object

ARGS = Name(value='args')

class Builder(_args: 'Sequence[Data]' = None)

Bases: object

args(args)

build()

TYPE_ = Name(value='hydra.scala.syntax.TupleData')

args: Sequence[Data]

static builder()

with_args(args)

class hydra.scala.syntax.TuplePat(args: 'Sequence[Pat]')

Bases: object

ARGS = Name(value='args')

class Builder(_args: 'Sequence[Pat]' = None)

Bases: object

args(args)

build()

TYPE_ = Name(value='hydra.scala.syntax.TuplePat')

args: Sequence[Pat]

static builder()

with_args(args)

class hydra.scala.syntax.TupleType(args: 'Sequence[Type]')

Bases: object

ARGS = Name(value='args')

class Builder(_args: 'Sequence[Type]' = None)

Bases: object

args(args)

build()

TYPE_ = Name(value='hydra.scala.syntax.TupleType')

args: Sequence[Type]

static builder()

with_args(args)

class hydra.scala.syntax.Type

Bases: object

TypeRef | TypeAnonymousName | TypeApply | TypeApplyInfix | TypeFunction | TypeContextFunction | TypePolyFunction | TypeImplicitFunction | TypeTuple | TypeWith | TypeAnd | TypeOr | TypeRefine | TypeExistential | TypeAnnotate | TypeLambda | TypeMethod | TypePlaceholder | TypeByName | TypeRepeated | TypeVar | TypeTypedParam | TypeMatch

AND = Name(value='and')

ANNOTATE = Name(value='annotate')

ANONYMOUS_NAME = Name(value='anonymousName')

APPLY = Name(value='apply')

APPLY_INFIX = Name(value='applyInfix')

BY_NAME = Name(value='byName')

CONTEXT_FUNCTION = Name(value='contextFunction')

EXISTENTIAL = Name(value='existential')

FUNCTION = Name(value='function')

IMPLICIT_FUNCTION = Name(value='implicitFunction')

LAMBDA = Name(value='lambda')

MATCH = Name(value='match')

METHOD = Name(value='method')

OR = Name(value='or')

PLACEHOLDER = Name(value='placeholder')

POLY_FUNCTION = Name(value='polyFunction')

REF = Name(value='ref')

REFINE = Name(value='refine')

REPEATED = Name(value='repeated')

TUPLE = Name(value='tuple')

TYPED_PARAM = Name(value='typedParam')

TYPE_ = Name(value='hydra.scala.syntax.Type')

VAR = Name(value='var')

WITH = Name(value='with')

class hydra.scala.syntax.TypeAnd(value: T)

Bases: Node[AndType]

class hydra.scala.syntax.TypeAnnotate(value: T)

Bases: Node[AnnotateType]

class hydra.scala.syntax.TypeAnonymousName(value: T)

Bases: Node[AnonymousNameType]

class hydra.scala.syntax.TypeApply(value: T)

Bases: Node[ApplyType]

class hydra.scala.syntax.TypeApplyInfix(value: T)

Bases: Node[ApplyInfixType]

class hydra.scala.syntax.TypeBounds(lo: 'Optional[Type]', hi: 'Optional[Type]')

Bases: object

class Builder(_lo: 'Optional[Type]' = None, _hi: 'Optional[Type]' = None)

Bases: object

build()

hi(hi)

lo(lo)

HI = Name(value='hi')

LO = Name(value='lo')

TYPE_ = Name(value='hydra.scala.syntax.TypeBounds')

static builder()

hi: object

lo: object

with_hi(hi)

with_lo(lo)

class hydra.scala.syntax.TypeByName(value: T)

Bases: Node[ByNameType]

class hydra.scala.syntax.TypeCase(pat: 'Type', body: 'Type')

Bases: object

BODY = Name(value='body')

class Builder(_pat: 'Type' = None, _body: 'Type' = None)

Bases: object

body(body)

build()

pat(pat)

PAT = Name(value='pat')

TYPE_ = Name(value='hydra.scala.syntax.TypeCase')

body: Type

static builder()

pat: Type

with_body(body)

with_pat(pat)

class hydra.scala.syntax.TypeContextFunction(value: T)

Bases: Node[ContextFunctionType]

class hydra.scala.syntax.TypeDecl(mods: 'Sequence[Mod]', name: 'NameType', tparams: 'Sequence[ParamType]', bounds: 'TypeBounds')

Bases: object

BOUNDS = Name(value='bounds')

class Builder(_mods: 'Sequence[Mod]' = None, _name: 'NameType' = None, _tparams: 'Sequence[ParamType]' = None, _bounds: 'TypeBounds' = None)

Bases: object

bounds(bounds)

build()

mods(mods)

name(name)

tparams(tparams)

MODS = Name(value='mods')

NAME = Name(value='name')

TPARAMS = Name(value='tparams')

TYPE_ = Name(value='hydra.scala.syntax.TypeDecl')

bounds: TypeBounds

static builder()

mods: Sequence[Mod]

name: NameType

tparams: Sequence[ParamType]

with_bounds(bounds)

with_mods(mods)

with_name(name)

with_tparams(tparams)

class hydra.scala.syntax.TypeDefn(mods: 'Sequence[Mod]', name: 'NameType', tparams: 'Sequence[ParamType]', body: 'Type')

Bases: object

BODY = Name(value='body')

class Builder(_mods: 'Sequence[Mod]' = None, _name: 'NameType' = None, _tparams: 'Sequence[ParamType]' = None, _body: 'Type' = None)

Bases: object

body(body)

build()

mods(mods)

name(name)

tparams(tparams)

MODS = Name(value='mods')

NAME = Name(value='name')

TPARAMS = Name(value='tparams')

TYPE_ = Name(value='hydra.scala.syntax.TypeDefn')

body: Type

static builder()

mods: Sequence[Mod]

name: NameType

tparams: Sequence[ParamType]

with_body(body)

with_mods(mods)

with_name(name)

with_tparams(tparams)

class hydra.scala.syntax.TypeExistential(value: T)

Bases: Node[ExistentialType]

class hydra.scala.syntax.TypeFunction(value: T)

Bases: Node[FunctionType]

class hydra.scala.syntax.TypeImplicitFunction(value: T)

Bases: Node[ImplicitFunctionType]

class hydra.scala.syntax.TypeLambda(value: T)

Bases: Node[LambdaType]

class hydra.scala.syntax.TypeMatch(value: T)

Bases: Node[MatchType]

class hydra.scala.syntax.TypeMember(name: 'NameType')

Bases: object

class Builder(_name: 'NameType' = None)

Bases: object

build()

name(name)

NAME = Name(value='name')

TYPE_ = Name(value='hydra.scala.syntax.TypeMember')

static builder()

name: NameType

with_name(name)

class hydra.scala.syntax.TypeMethod(value: T)

Bases: Node[MethodType]

class hydra.scala.syntax.TypeOr(value: T)

Bases: Node[OrType]

class hydra.scala.syntax.TypePlaceholder(value: T)

Bases: Node[PlaceholderType]

class hydra.scala.syntax.TypePolyFunction(value: T)

Bases: Node[PolyFunctionType]

class hydra.scala.syntax.TypeRef(value: T)

Bases: Node[RefType]

class hydra.scala.syntax.TypeRefine(value: T)

Bases: Node[RefineType]

class hydra.scala.syntax.TypeRepeated(value: T)

Bases: Node[RepeatedType]

class hydra.scala.syntax.TypeTuple(value: T)

Bases: Node[TupleType]

class hydra.scala.syntax.TypeTypedParam(value: T)

Bases: Node[TypedParamType]

class hydra.scala.syntax.TypeVar(value: T)

Bases: Node[VarType]

class hydra.scala.syntax.TypeWith(value: T)

Bases: Node[WithType]

class hydra.scala.syntax.TypedParamType(name: 'Name', typ: 'Type')

Bases: object

class Builder(_name: 'Name' = None, _typ: 'Type' = None)

Bases: object

build()

name(name)

typ(typ)

NAME = Name(value='name')

TYP = Name(value='typ')

TYPE_ = Name(value='hydra.scala.syntax.TypedParamType')

static builder()

name: Name

typ: Type

with_name(name)

with_typ(typ)

class hydra.scala.syntax.TypedPat(lhs: 'Pat', rhs: 'Type')

Bases: object

class Builder(_lhs: 'Pat' = None, _rhs: 'Type' = None)

Bases: object

build()

lhs(lhs)

rhs(rhs)

LHS = Name(value='lhs')

RHS = Name(value='rhs')

TYPE_ = Name(value='hydra.scala.syntax.TypedPat')

static builder()

lhs: Pat

rhs: Type

with_lhs(lhs)

with_rhs(rhs)

class hydra.scala.syntax.UnimportImportee(name: 'Name')

Bases: object

class Builder(_name: 'Name' = None)

Bases: object

build()

name(name)

NAME = Name(value='name')

TYPE_ = Name(value='hydra.scala.syntax.UnimportImportee')

static builder()

name: Name

with_name(name)

class hydra.scala.syntax.ValDecl(mods: 'Sequence[Mod]', pats: 'Sequence[Pat]', decltpe: 'Type')

Bases: object

class Builder(_mods: 'Sequence[Mod]' = None, _pats: 'Sequence[Pat]' = None, _decltpe: 'Type' = None)

Bases: object

build()

decltpe(decltpe)

mods(mods)

pats(pats)

DECLTPE = Name(value='decltpe')

MODS = Name(value='mods')

PATS = Name(value='pats')

TYPE_ = Name(value='hydra.scala.syntax.ValDecl')

static builder()

decltpe: Type

mods: Sequence[Mod]

pats: Sequence[Pat]

with_decltpe(decltpe)

with_mods(mods)

with_pats(pats)

class hydra.scala.syntax.ValDefn(mods: 'Sequence[Mod]', pats: 'Sequence[Pat]', decltpe: 'Optional[Type]', rhs: 'Data')

Bases: object

class Builder(_mods: 'Sequence[Mod]' = None, _pats: 'Sequence[Pat]' = None, _decltpe: 'Optional[Type]' = None, _rhs: 'Data' = None)

Bases: object

build()

decltpe(decltpe)

mods(mods)

pats(pats)

rhs(rhs)

DECLTPE = Name(value='decltpe')

MODS = Name(value='mods')

PATS = Name(value='pats')

RHS = Name(value='rhs')

TYPE_ = Name(value='hydra.scala.syntax.ValDefn')

static builder()

decltpe: object

mods: Sequence[Mod]

pats: Sequence[Pat]

rhs: Data

with_decltpe(decltpe)

with_mods(mods)

with_pats(pats)

with_rhs(rhs)

class hydra.scala.syntax.ValEnumerator(pat: 'Pat', rhs: 'Data')

Bases: object

class Builder(_pat: 'Pat' = None, _rhs: 'Data' = None)

Bases: object

build()

pat(pat)

rhs(rhs)

PAT = Name(value='pat')

RHS = Name(value='rhs')

TYPE_ = Name(value='hydra.scala.syntax.ValEnumerator')

static builder()

pat: Pat

rhs: Data

with_pat(pat)

with_rhs(rhs)

class hydra.scala.syntax.VarDecl(mods: 'Sequence[Mod]', pats: 'Sequence[Pat]', decltpe: 'Type')

Bases: object

class Builder(_mods: 'Sequence[Mod]' = None, _pats: 'Sequence[Pat]' = None, _decltpe: 'Type' = None)

Bases: object

build()

decltpe(decltpe)

mods(mods)

pats(pats)

DECLTPE = Name(value='decltpe')

MODS = Name(value='mods')

PATS = Name(value='pats')

TYPE_ = Name(value='hydra.scala.syntax.VarDecl')

static builder()

decltpe: Type

mods: Sequence[Mod]

pats: Sequence[Pat]

with_decltpe(decltpe)

with_mods(mods)

with_pats(pats)

class hydra.scala.syntax.VarDefn(mods: 'Sequence[Mod]', pats: 'Sequence[Pat]', decltpe: 'Type', rhs: 'Optional[Data]')

Bases: object

class Builder(_mods: 'Sequence[Mod]' = None, _pats: 'Sequence[Pat]' = None, _decltpe: 'Type' = None, _rhs: 'Optional[Data]' = None)

Bases: object

build()

decltpe(decltpe)

mods(mods)

pats(pats)

rhs(rhs)

DECLTPE = Name(value='decltpe')

MODS = Name(value='mods')

PATS = Name(value='pats')

RHS = Name(value='rhs')

TYPE_ = Name(value='hydra.scala.syntax.VarDefn')

static builder()

decltpe: Type

mods: Sequence[Mod]

pats: Sequence[Pat]

rhs: object

with_decltpe(decltpe)

with_mods(mods)

with_pats(pats)

with_rhs(rhs)

class hydra.scala.syntax.VarPat(name: 'NameData')

Bases: object

class Builder(_name: 'NameData' = None)

Bases: object

build()

name(name)

NAME = Name(value='name')

TYPE_ = Name(value='hydra.scala.syntax.VarPat')

static builder()

name: NameData

with_name(name)

class hydra.scala.syntax.VarType(name: 'NameType')

Bases: object

class Builder(_name: 'NameType' = None)

Bases: object

build()

name(name)

NAME = Name(value='name')

TYPE_ = Name(value='hydra.scala.syntax.VarType')

static builder()

name: NameType

with_name(name)

class hydra.scala.syntax.WhileData(expr: 'Data', body: 'Data')

Bases: object

BODY = Name(value='body')

class Builder(_expr: 'Data' = None, _body: 'Data' = None)

Bases: object

body(body)

build()

expr(expr)

EXPR = Name(value='expr')

TYPE_ = Name(value='hydra.scala.syntax.WhileData')

body: Data

static builder()

expr: Data

with_body(body)

with_expr(expr)

class hydra.scala.syntax.WithType(lhs: 'Type', rhs: 'Type')

Bases: object

class Builder(_lhs: 'Type' = None, _rhs: 'Type' = None)

Bases: object

build()

lhs(lhs)

rhs(rhs)

LHS = Name(value='lhs')

RHS = Name(value='rhs')

TYPE_ = Name(value='hydra.scala.syntax.WithType')

static builder()

lhs: Type

rhs: Type

with_lhs(lhs)

with_rhs(rhs)