Implicits

implicit abstract def Tuple2R[T1, T2](implicit arg0: R[T1], arg1: R[T2]): R[(T1, T2)]

implicit abstract def Tuple2W[T1, T2](implicit arg0: W[T1], arg1: W[T2]): W[(T1, T2)]

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

object Aliases

Handy shorthands for Reader and Writer

implicit def ArrayR[T](implicit arg0: R[T], arg1: ClassTag[T]): R[Array[T]]

implicit def ArrayW[T](implicit arg0: W[T]): W[Array[T]]

implicit val BooleanRW: (Implicits.this)#Writer[Boolean] with (Implicits.this)#Reader[Boolean]

implicit val ByteRW: RW[Byte]

def Case0R[T](t: () ⇒ T): (Implicits.this)#Reader[T]

def Case0W[T](f: (T) ⇒ Boolean): (Implicits.this)#Writer[T]

def CaseR[T, V](f: (T) ⇒ V, names: Array[String], defaults: Array[Value])(implicit arg0: R[T]): (Implicits.this)#Reader[V]

def CaseW[T, V](f: (V) ⇒ Option[T], names: Array[String], defaults: Array[Value])(implicit arg0: W[T]): (Implicits.this)#Writer[V]

implicit val CharRW: (Implicits.this)#Writer[Char] with (Implicits.this)#Reader[Char]

implicit val DoubleRW: RW[Double]

implicit val DurationR: (Implicits.this)#Reader[Duration]

implicit val DurationW: W[Duration]

implicit def EitherR[A, B](implicit arg0: R[A], arg1: R[B]): R[Either[A, B]]

implicit def EitherW[A, B](implicit arg0: W[A], arg1: W[B]): W[Either[A, B]]

implicit val FiniteR: (Implicits.this)#Reader[FiniteDuration]

implicit val FiniteW: (Implicits.this)#Writer[FiniteDuration]

implicit val FloatRW: RW[Float]

implicit val InfiniteR: (Implicits.this)#Reader[Infinite]

implicit val InfiniteW: (Implicits.this)#Writer[Infinite]

implicit val IntRW: RW[Int]

object Internal

APIs that need to be exposed to the outside world to support Macros which depend on them, but probably should not get used directly.

object Knot

Classes that provides a mutable version of ReadWriter, used to allow serialization and deserialization of recursive data structure

implicit def LeftR[A, B](implicit arg0: R[A], arg1: R[B]): R[Left[A, B]]

implicit def LeftW[A, B](implicit arg0: W[A], arg1: W[B]): W[Left[A, B]]

implicit val LongRW: (Implicits.this)#Writer[Long] with (Implicits.this)#Reader[Long]

implicit def MapR[K, V](implicit arg0: R[K], arg1: R[V]): R[Map[K, V]]

implicit def MapW[K, V](implicit arg0: W[K], arg1: W[V]): W[Map[K, V]]

implicit def NoneR: R[None.type]

implicit def NoneW: W[None.type]

implicit def OptionR[T](implicit arg0: R[T]): R[Option[T]]

implicit def OptionW[T](implicit arg0: W[T]): W[Option[T]]

object ReadWriter

Helper object that makes it convenient to create instances of bother Reader and Writer at the same time.

object Reader

implicit def RightR[A, B](implicit arg0: R[A], arg1: R[B]): R[Right[A, B]]

implicit def RightW[A, B](implicit arg0: W[A], arg1: W[B]): W[Right[A, B]]

implicit def SeqishR[V[_], T](implicit arg0: R[T], cbf: CanBuildFrom[Nothing, T, V[T]]): R[V[T]]

implicit def SeqishW[T, V[_] <: Iterable[_]](implicit arg0: W[T]): W[V[T]]

implicit val ShortRW: RW[Short]

def SingletonR[T](t: T): (Implicits.this)#Reader[T]

def SingletonW[T](f: T): (Implicits.this)#Writer[T]

implicit def SomeR[T](implicit arg0: R[T]): (Implicits.this)#Reader[Some[T]]

implicit def SomeW[T](implicit arg0: W[T]): (Implicits.this)#Writer[Some[T]]

implicit val StringRW: (Implicits.this)#Writer[String] with (Implicits.this)#Reader[String]

implicit val SymbolRW: (Implicits.this)#Writer[Symbol] with (Implicits.this)#Reader[Symbol]

implicit val UnitRW: (Implicits.this)#Writer[Unit] with (Implicits.this)#Reader[Unit]

implicit def UuidR: R[UUID]

implicit def UuidW: W[UUID]

object Writer

final def asInstanceOf[T0]: T0

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def makeReader[T](pf: PartialFunction[Value, T]): (Implicits.this)#Reader[T]

def makeWriter[T](f: (T) ⇒ Value): (Implicits.this)#Writer[T]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def read[T](expr: String)(implicit arg0: (Implicits.this)#Reader[T]): T

Deserialize a String object of type T

def readJs[T](expr: Value)(implicit arg0: (Implicits.this)#Reader[T]): T

Deserialize a Js.Value object of type T

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

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def write[T](expr: T, indent: Int = 0)(implicit arg0: (Implicits.this)#Writer[T]): String

Serialize an object of type T to a String

def writeJs[T](expr: T)(implicit arg0: (Implicits.this)#Writer[T]): Value

Serialize an object of type T to a Js.Value