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

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

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

implicit val BooleanRW: Writer[Boolean] with Reader[Boolean]

implicit val ByteRW: Writer[Byte] with Reader[Byte]

implicit val CharRW: Writer[Char] with Reader[Char]

implicit val DoubleRW: Writer[Double] with Reader[Double]

implicit val DurationR: 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: Reader[FiniteDuration]

implicit val FiniteW: Writer[FiniteDuration]

implicit val FloatRW: Writer[Float] with Reader[Float]

implicit val InfiniteR: Reader[Infinite]

implicit val InfiniteW: Writer[Infinite]

implicit val IntRW: Writer[Int] with Reader[Int]

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 def ListR[T](implicit arg0: R[T]): R[List[T]]

implicit def ListW[T](implicit arg0: W[T]): W[List[T]]

implicit val LongRW: Writer[Long] with Reader[Long]

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

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

implicit def NoneR: R[None.type]

implicit def NoneW: W[None.type]

implicit val NothingR: Reader[Nothing]

implicit val NothingW: Writer[Nothing]

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

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

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 SeqR[T](implicit arg0: R[T]): R[Seq[T]]

implicit def SeqW[T](implicit arg0: W[T]): W[Seq[T]]

implicit def SetR[T](implicit arg0: R[T]): R[Set[T]]

implicit def SetW[T](implicit arg0: W[T]): W[Set[T]]

implicit val ShortRW: Writer[Short] with Reader[Short]

implicit def SomeR[T](implicit arg0: R[T]): Reader[Some[T]]

implicit def SomeW[T](implicit arg0: W[T]): Writer[Some[T]]

implicit def SortedSetR[T](implicit arg0: R[T], arg1: Ordering[T]): R[SortedSet[T]]

implicit def SortedSetW[T](implicit arg0: W[T]): W[SortedSet[T]]

implicit val StringRW: Writer[String] with Reader[String]

implicit def VectorR[T](implicit arg0: R[T]): R[Vector[T]]

implicit def VectorW[T](implicit arg0: W[T]): W[Vector[T]]

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

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def read[T](expr: String)(implicit arg0: Reader[T]): T

Deserialize a String object of type T

def readJs[T](expr: Value)(implicit arg0: Reader[T]): T

Deserialize a Js.Value object of type T

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

def toString(): String

def validate[T](name: String)(pf: PartialFunction[Value, T]): PartialFunction[Value, T]

def validateReader[T](name: String)(r: Reader[T]): Reader[T]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def write[T](expr: T)(implicit arg0: Writer[T]): String

Serialize an object of type T to a String

def writeJs[T](expr: T)(implicit arg0: Writer[T]): Value

Serialize an object of type T to a Js.Value