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: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

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: RW[Byte]

def CT[T](implicit arg0: ClassTag[T]): ClassTag[T]

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

implicit val DoubleRW: RW[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: RW[Float]

implicit val InfiniteR: Reader[Infinite]

implicit val InfiniteW: Writer[Infinite]

implicit val IntRW: RW[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 val LongRW: Writer[Long] with Reader[Long]

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

implicit def MapW[K, V](implicit arg0: W[K], arg1: ClassTag[K], arg2: W[V]): W[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 SeqishR[T, V[_]](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]

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

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

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

implicit val UnitRW: Writer[Unit] with Reader[Unit]

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

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