SetEncoder

abstract val sourceProgram: Program

final def !=(arg0: Any): Boolean

final def ##(): Int

def <<(that: ProgramEncoder { val sourceProgram: inox.ast.ProgramEncoder.<refinement>.type }): ProgramEncoder { ... /* 2 definitions in type refinement */ }

final def ==(arg0: Any): Boolean

def >>(that: ProgramEncoder { val t: SetEncoder.this.s.type }): ProgramEncoder { ... /* 2 definitions in type refinement */ }

val Add: ast.Trees.FunDef

val AddID: ast.Identifier

val Contains: ast.Trees.FunDef

val ContainsID: ast.Identifier

val Difference: ast.Trees.FunDef

val DifferenceID: ast.Identifier

val Elem: (dsl)#IdToADTType

val ElemID: ast.Identifier

val EqualsID: ast.Identifier

val Intersect: ast.Trees.FunDef

val IntersectID: ast.Identifier

val Leaf: (dsl)#IdToADTType

val LeafID: ast.Identifier

val Remove: ast.Trees.FunDef

val RemoveID: ast.Identifier

val Set: (dsl)#IdToADTType

val SetEquals: ast.Trees.FunDef

val SetID: ast.Identifier

val Sum: (dsl)#IdToADTType

val SumID: ast.Identifier

val Union: ast.Trees.FunDef

val UnionID: ast.Identifier

def andThen(that: ProgramTransformer { val sourceProgram: inox.ast.ProgramEncoder.<refinement>.type }): ProgramTransformer { ... /* 2 definitions in type refinement */ }

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def compose(that: ProgramTransformer { val targetProgram: SetEncoder.this.sourceProgram.type }): ProgramTransformer { ... /* 2 definitions in type refinement */ }

def decode(tpe: ast.Trees.Type): ast.Trees.Type

def decode(e: ast.Trees.Expr): ast.Trees.Expr

def decode(v: ast.Trees.Variable): ast.Trees.Variable

def decode(vd: ast.Trees.ValDef): ast.Trees.ValDef

object decoder extends ast.Trees.SelfTreeTransformer

val elemADT: ast.Trees.ADTConstructor

def encode(tpe: ast.Trees.Type): ast.Trees.Type

def encode(e: ast.Trees.Expr): ast.Trees.Expr

def encode(v: ast.Trees.Variable): ast.Trees.Variable

def encode(vd: ast.Trees.ValDef): ast.Trees.ValDef

def encodedProgram: Program { val trees: SetEncoder.this.t.type }

Override point for more complex program transformations

object encoder extends ast.Trees.SelfTreeTransformer

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

val extraADTs: Seq[ast.Trees.ADTDefinition]

val extraFunctions: Seq[ast.Trees.FunDef]

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

val leafADT: ast.Trees.ADTConstructor

val left: ast.Identifier

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def reverse: ProgramTransformer { ... /* 2 definitions in type refinement */ }

val right: ast.Identifier

final lazy val s: Program.trees.type

val setADT: ast.Trees.ADTDefinition

val sumADT: ast.Trees.ADTConstructor

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

val t: Program.trees.type

final lazy val targetProgram: Program { val trees: SetEncoder.this.t.type }

def toString(): String

lazy val trees: Program.trees.type

val value: ast.Identifier

final def wait(): Unit

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

final def wait(arg0: Long): Unit