SigmaParser

final def !=(arg0: Any): Boolean

val #: fastparse.all.Parser[Unit]

final def ##(): Int

val *: fastparse.all.Parser[Unit]

val :: fastparse.all.Parser[Unit]

val <:: fastparse.all.Parser[Unit]

val =: fastparse.all.Parser[Unit]

final def ==(arg0: Any): Boolean

val =>: Parser[Unit, Char, String]

val >:: fastparse.all.Parser[Unit]

val @: fastparse.all.Parser[Unit]

val Annot: fastparse.noApi.P0

val AnnotType: fastparse.noApi.Parser[SType]

val AnonTmpl: Parser[Unit, Char, String]

val ArgList: fastparse.noApi.Parser[Value[SType]]

val BacktickId: fastparse.noApi.Parser[Unit]

def BaseBlock(end: fastparse.noApi.P0)(implicit name: Name): fastparse.noApi.P[Value[SType]]

val BindPattern: fastparse.noApi.Parser[Any]

val Block: fastparse.noApi.P[Value[SType]]

val BlockChunk: fastparse.noApi.Parser[(Seq[Seq[(String, SType)]], Seq[Value[SType]])]

val BlockDef: fastparse.noApi.Parser[Value[SType]]

val BlockExpr: fastparse.noApi.Parser[Value[SType]]

val BlockLambda: fastparse.noApi.Parser[Seq[(String, SType)]]

val BlockLambdaHead: Parser[Seq[(String, SType)], Char, String]

val CaseBlock: fastparse.noApi.P[Value[SType]]

val CaseClauses: fastparse.noApi.P0

val CompoundType: Parser[SType, Char, String]

val Constr: fastparse.noApi.Parser[(SType, Seq[Value[SType]])]

val Constrs: fastparse.noApi.Parser[Seq[(SType, Seq[Value[SType]])]]

val Dcl: fastparse.noApi.Parser[Value[SType]]

val DefTmpl: fastparse.noApi.Parser[Any]

val DottyExtMethodSubj: fastparse.noApi.Parser[(String, SType)]

val EarlyDefTmpl: fastparse.noApi.Parser[(Option[Seq[(String, SType)]], Seq[Value[SType]], Seq[(SType, Seq[Value[SType]])], Option[(Option[Seq[(String, SType)]], Seq[Value[SType]])])]

object ExprCtx extends WsCtx

val ExprLiteral: fastparse.noApi.Parser[Constant[SMonoType with SProduct with Serializable { type WrappedType >: Long with Int with Boolean with String }]]

val Exprs: fastparse.noApi.Parser[Seq[Value[SType]]]

object FreeCtx extends WsCtx

val FunDef: Parser[Val, Char, String]

val FunSig: fastparse.noApi.Parser[Seq[Seq[(String, SType)]]]

val Id: fastparse.noApi.Parser[Unit]

val Ids: fastparse.noApi.Parser[Unit]

val InfixType: Parser[SType, Char, String]

object Literals

val NLAnnot: fastparse.noApi.Parser[Unit]

val NamedTmpl: fastparse.noApi.Parser[(Seq[(SType, Seq[Value[SType]])], Option[(Option[Seq[(String, SType)]], Seq[Value[SType]])])]

val Newline: fastparse.all.Parser[Unit]

val NotNewline: fastparse.all.P0

val OneNLMax: fastparse.all.P0

val ParenArgList: Parser[Value[SType], Char, String]

val PatLiteral: fastparse.noApi.Parser[Constant[SMonoType with SProduct with Serializable { type WrappedType >: Long with Int with Boolean with String }]]

val Pattern: fastparse.noApi.P0

val Patterns: fastparse.noApi.P0

val PostDotCheck: fastparse.noApi.P0

Sketchy way to whitelist a few suffixes that come after a .

val PostfixType: Parser[SType, Char, String]

val QualId: fastparse.noApi.Parser[Unit]

val Semi: fastparse.all.Parser[Unit]

val Semis: fastparse.all.Parser[Unit]

val SimplePattern: fastparse.noApi.Parser[Any]

val SimpleType: Parser[SType, Char, String]

val StableId: fastparse.noApi.Parser[SValue]

object StatCtx extends WsCtx

val TmplBody: fastparse.noApi.Parser[(Option[Seq[(String, SType)]], Seq[Value[SType]])]

val TrailingComma: fastparse.all.P0

val Type: fastparse.noApi.P[SType]

val TypeArg: fastparse.noApi.P0

val TypeArgList: fastparse.noApi.P0

val TypeArgs: fastparse.noApi.Parser[Seq[SType]]

val TypeBounds: fastparse.noApi.P0

val TypeExpr: fastparse.noApi.P[Value[SType]]

val TypeId: Parser[SType, Char, String]

val TypeOrBindPattern: fastparse.noApi.P0

val TypePat: fastparse.noApi.Parser[SType]

val TypePattern: fastparse.noApi.Parser[SType]

val ValVarDef: Parser[Val, Char, String]

val VarId: fastparse.noApi.Parser[Unit]

val WL: fastparse.all.Parser[Unit]

val WL0: fastparse.all.Parser[Unit]

Parses whitespace, including newlines.

val WS: fastparse.all.Parser[Unit]

Parses all whitespace, excluding newlines.

val WhitespaceApi: Wrapper2

val _: fastparse.all.Parser[Unit]

val _*: fastparse.noApi.Parser[Unit]

def apply(script: String, sigmaBuilder: SigmaBuilder): Parsed[Value[_ <: SType], Char, String]

def applySuffix(f: Value[SType], args: Seq[SigmaNode]): Value[SType]

final def asInstanceOf[T0]: T0

def atSrcPos[A](parserIndex: Int)(thunk: ⇒ A): A

def block(stats: Seq[SValue]): SValue

val builder: SigmaBuilder

val case: fastparse.all.Parser[Unit]

def clone(): AnyRef

val currentInput: DynamicVariable[String]

val def: fastparse.all.Parser[Unit]

val else: fastparse.all.Parser[Unit]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

val extends: fastparse.all.Parser[Unit]

def extractBlockStats(stats: Seq[SValue]): (Seq[Val], SValue)

final def getClass(): Class[_]

def hashCode(): Int

val if: fastparse.all.Parser[Unit]

val implicit: fastparse.all.Parser[Unit]

final def isInstanceOf[T0]: Boolean

def lambda(args: Seq[Value[SType]], body: Value[SType]): Value[SType]

val lazy: fastparse.all.Parser[Unit]

val logged: Buffer[String]

implicit val logger: Logger

val match: fastparse.all.Parser[Unit]

def mkBinaryOp(l: Value[SType], opName: String, r: Value[SType]): Value[SType]

def mkInfixTree(lhs: SValue, rhss: Seq[(String, SValue)]): SValue

def mkUnaryOp(opName: String, arg: Value[SType]): Value[SType]

final def ne(arg0: AnyRef): Boolean

val new: fastparse.all.Parser[Unit]

final def notify(): Unit

final def notifyAll(): Unit

val parseAsMethods: Set[String]

def parseType(str: String): SType

def parsedType(str: String): Parsed[SType, Char, String]

def precedenceOf(op: String): Int

def precedenceOf(ch: Char): Int

val predefTypes: Map[String, SType { type WrappedType >: Unit with special.sigma.Box with String with special.sigma.PreHeader with special.sigma.Header with special.sigma.SigmaDslBuilder with special.sigma.SigmaProp with special.sigma.GroupElement with org.ergoplatform.ErgoLikeContext with special.sigma.AvlTree with special.collection.Coll[Byte] with special.sigma.BigInt with Long with Int with Short with Byte with Boolean }]

This map should be in sync with SType.allPredefTypes

val priorityList: Seq[Seq[Char]]

The precedence of an infix operator is determined by the operator's first character.

val priorityMap: Map[Char, Int]

val return: fastparse.all.Parser[Unit]

def srcCtx(parserIndex: Int): SourceContext

val super: fastparse.all.Parser[Unit]

final def synchronized[T0](arg0: ⇒ T0): T0

val then: fastparse.all.Parser[Unit]

val this: fastparse.all.Parser[Unit]

def toString(): String

val type: fastparse.all.Parser[Unit]

def typeFromName(tn: String): Option[SType]

val val: fastparse.all.Parser[Unit]

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

final def wait(): Unit

val with: fastparse.all.Parser[Unit]

val {: fastparse.noApi.Parser[Unit]

val }: fastparse.noApi.Parser[Unit]

def finalize(): Unit