ExprTypeImplA

abstract def readValue(in: DataInput): A

abstract def typeID: Int

abstract def writeValue(value: A, out: DataOutput): Unit

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def addExtension(exts: Array[Extension1[[$tilde]Expr[~, A]]], ext: Extension1[[$tilde]Expr[~, A]]): Array[Extension1[[$tilde]Expr[~, A]]]

final def asInstanceOf[T0]: T0

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

final val extTag: ClassTag[Extension1[[$tilde]Expr[~, A]]]

def finalize(): Unit

final def findExt(exts: Array[Extension1[[$tilde]Expr[~, A]]], op: Int): Extension1[[$tilde]Expr[~, A]]

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def newConst[S <: Sys[S]](value: A): Const[S, A]

final def newVar[S <: Sys[S]](init: Ex[S])(implicit tx: ExprTypeImpl.newVar.S.Tx): ExV[S]

final def notify(): Unit

final def notifyAll(): Unit

final def read[S <: Sys[S]](in: DataInput, access: ExprTypeImpl.read.S.Acc)(implicit tx: ExprTypeImpl.read.S.Tx): Ex[S]

final def readConst[S <: Sys[S]](in: DataInput): Const[S, A]

final def readExtension[S <: Sys[S]](arity: Int, op: Int, in: DataInput, access: TypeImpl1A.readExtension.S.Acc, targets: Targets[S])(implicit tx: TypeImpl1A.readExtension.S.Tx): Expr[S, A] with Node[S]

def readNode[S <: Sys[S]](cookie: Int, in: DataInput, access: readNode.S.Acc, targets: Targets[S])(implicit tx: readNode.S.Tx): Ex[S] with Node[S]

The default implementation reads a type Int requiring to match typeID, followed by an operator id Int which will be resolved using readOpExtension.

final def readVar[S <: Sys[S]](in: DataInput, access: ExprTypeImpl.readVar.S.Acc, targets: Targets[S])(implicit tx: ExprTypeImpl.readVar.S.Tx): ExV[S]

final def readVar[S <: Sys[S]](in: DataInput, access: ExprTypeImpl.readVar.S.Acc)(implicit tx: ExprTypeImpl.readVar.S.Tx): ExV[S]

final def registerExtension(arity: Int, ext: Ext): Unit

This method is not thread-safe.

implicit final def serializer[S <: Sys[S]]: Serializer[S, Ex[S]]

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

def toString(): String

implicit final def varSerializer[S <: Sys[S]]: Serializer[S, ExV[S]]

final def wait(): Unit

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

final def wait(arg0: Long): Unit