Comprehensive built-in readers and writers for primitive types, collections, and common Scala types. These are automatically available when importing upickle.default._.
Built-in readers for all Scala primitive types with automatic type conversion support.
implicit val UnitReader: Reader[Unit]
implicit val BooleanReader: Reader[Boolean]
implicit val StringReader: Reader[String]
implicit val CharReader: Reader[Char]
implicit val IntReader: Reader[Int]
implicit val LongReader: Reader[Long]
implicit val FloatReader: Reader[Float]
implicit val DoubleReader: Reader[Double]
implicit val ShortReader: Reader[Short]
implicit val ByteReader: Reader[Byte]Usage Examples:
import upickle.default._
// Automatic conversion from various JSON types
val str = read[String]("\"hello\"") // From string
val strFromNum = read[String]("42") // From number
val int = read[Int]("42") // From number
val intFromStr = read[Int]("\"42\"") // From string
val bool = read[Boolean]("true") // From boolean
val boolFromStr = read[Boolean]("\"true\"") // From stringBuilt-in writers for all Scala primitive types with JSON dictionary key support.
implicit val UnitWriter: Writer[Unit]
implicit val BooleanWriter: Writer[Boolean]
implicit val StringWriter: Writer[String]
implicit val CharWriter: Writer[Char]
implicit val IntWriter: Writer[Int]
implicit val LongWriter: Writer[Long]
implicit val FloatWriter: Writer[Float]
implicit val DoubleWriter: Writer[Double]
implicit val ShortWriter: Writer[Short]
implicit val ByteWriter: Writer[Byte]Usage Examples:
import upickle.default._
// All primitive writers support JSON dict keys
val intMap = Map(1 -> "one", 2 -> "two")
val json = write(intMap)
// Result: {"1": "one", "2": "two"}
val stringMap = Map("key" -> "value")
val stringJson = write(stringMap)
// Result: {"key": "value"}Readers for common extended types like UUID, BigInt, and Symbol.
implicit val UUIDReader: Reader[UUID]
implicit val BigIntReader: Reader[BigInt]
implicit val BigDecimalReader: Reader[BigDecimal]
implicit val SymbolReader: Reader[Symbol]Usage Examples:
import upickle.default._
import java.util.UUID
// UUID from string
val uuid = read[UUID]("\"550e8400-e29b-41d4-a716-446655440000\"")
// BigInt from string
val bigInt = read[BigInt]("\"12345678901234567890\"")
// BigDecimal from string
val bigDec = read[BigDecimal]("\"123.456789012345678901234567890\"")
// Symbol from string
val sym = read[Symbol]("\"mySymbol\"")Writers for extended types with string-based JSON representation.
implicit val UUIDWriter: Writer[UUID]
implicit val BigIntWriter: Writer[BigInt]
implicit val BigDecimalWriter: Writer[BigDecimal]
implicit val SymbolWriter: Writer[Symbol]Readers for arrays with special optimization for byte arrays.
/**
* Reader for arrays with ClassTag for type erasure handling
* Special case: byte arrays can be read from binary data
*/
implicit def ArrayReader[T: Reader: ClassTag]: Reader[Array[T]]Usage Examples:
import upickle.default._
// Regular arrays
val intArray = read[Array[Int]]("[1,2,3,4,5]")
val stringArray = read[Array[String]]("""["a","b","c"]""")
// Byte arrays from JSON array
val byteArray = read[Array[Byte]]("[65,66,67]") // "ABC"
// Byte arrays from binary data (MessagePack)
val binaryData: Array[Byte] = Array(1, 2, 3)
val fromBinary = readBinary[Array[Byte]](binaryData)Writers for arrays with binary optimization for byte arrays.
/**
* Writer for arrays
* Special case: byte arrays are written as binary data in MessagePack
*/
implicit def ArrayWriter[T](implicit r: Writer[T]): Writer[Array[T]]Usage Examples:
import upickle.default._
val intArray = Array(1, 2, 3, 4, 5)
val json = write(intArray)
// Result: [1,2,3,4,5]
// Byte arrays optimize to binary in MessagePack
val byteArray = Array[Byte](65, 66, 67)
val binary = writeBinary(byteArray) // Efficient binary representation
val jsonFromBytes = write(byteArray) // JSON: [65,66,67]Generic readers for all Scala collection types using Factory pattern.
/**
* Generic reader for sequence-like collections
*/
implicit def SeqLikeReader[C[_], T](implicit r: Reader[T], factory: Factory[T, C[T]]): Reader[C[T]]
/**
* Readers for specific collection types
*/
implicit def MapReader1[K: Reader, V: Reader]: Reader[collection.Map[K, V]]
implicit def MapReader2[K: Reader, V: Reader]: Reader[collection.immutable.Map[K, V]]
implicit def MapReader3[K: Reader, V: Reader]: Reader[collection.mutable.Map[K, V]]
implicit def MapReader4[K: Reader, V: Reader]: Reader[collection.mutable.LinkedHashMap[K, V]]
implicit def SortedMapReader[K: Reader: Ordering, V: Reader]: Reader[collection.mutable.SortedMap[K, V]]
implicit def MapReader6[K: Reader: Ordering, V: Reader]: Reader[collection.immutable.SortedMap[K, V]]Usage Examples:
import upickle.default._
import scala.collection.mutable
// Lists and sequences
val list = read[List[Int]]("[1,2,3,4,5]")
val vector = read[Vector[String]]("""["a","b","c"]""")
val set = read[Set[Int]]("[1,2,3,2,1]") // Deduplicates to Set(1,2,3)
// Maps - can be from objects or arrays
val map1 = read[Map[String, Int]]("""{"a":1,"b":2}""")
val map2 = read[Map[String, Int]]("""[["a",1],["b",2]]""")
// Mutable collections
val mutableMap = read[mutable.Map[String, Int]]("""{"x":10,"y":20}""")
val linkedMap = read[mutable.LinkedHashMap[String, Int]]("""{"first":1,"second":2}""")Generic writers for all Scala collection types.
/**
* Writer for sequence-like collections
*/
implicit def SeqLikeWriter[C[_] <: Iterable[_], T](implicit r: Writer[T]): Writer[C[T]]
/**
* Writers for map types with key serialization support
*/
implicit def MapWriter1[K: Writer, V: Writer]: Writer[collection.Map[K, V]]
implicit def MapWriter2[K: Writer, V: Writer]: Writer[collection.immutable.Map[K, V]]
implicit def MapWriter3[K: Writer, V: Writer]: Writer[collection.mutable.Map[K, V]]Usage Examples:
import upickle.default._
// Sequences serialize to JSON arrays
val list = List(1, 2, 3, 4, 5)
val listJson = write(list) // [1,2,3,4,5]
// Maps serialize to objects when keys are string-compatible
val stringMap = Map("key1" -> "value1", "key2" -> "value2")
val mapJson = write(stringMap) // {"key1":"value1","key2":"value2"}
// Maps with non-string keys serialize to arrays
val intMap = Map(1 -> "one", 2 -> "two")
val intMapJson = write(intMap) // [[1,"one"],[2,"two"]]Support for Option types with configurable null handling.
/**
* Readers for Option types
* Behavior depends on optionsAsNulls configuration
*/
implicit def OptionReader[T: Reader]: Reader[Option[T]]
implicit def SomeReader[T: Reader]: Reader[Some[T]]
implicit def NoneReader: Reader[None.type]
/**
* Writers for Option types
*/
implicit def OptionWriter[T: Writer]: Writer[Option[T]]
implicit def SomeWriter[T: Writer]: Writer[Some[T]]
implicit def NoneWriter: Writer[None.type]Usage Examples:
import upickle.default._
// Options as arrays (default behavior)
val some = read[Option[Int]]("[42]") // Some(42)
val none = read[Option[Int]]("[]") // None
// Options as nulls (when configured)
// val someAsNull = read[Option[Int]]("42") // Some(42)
// val noneAsNull = read[Option[Int]]("null") // None
// Writing options
val someValue: Option[Int] = Some(42)
val noneValue: Option[Int] = None
val someJson = write(someValue) // [42]
val noneJson = write(noneValue) // []Support for Either types with tuple-based serialization.
/**
* Readers for Either types - serialized as [tag, value] tuples
*/
implicit def EitherReader[T1: Reader, T2: Reader]: SimpleReader[Either[T1, T2]]
implicit def RightReader[T1: Reader, T2: Reader]: Reader[Right[T1, T2]]
implicit def LeftReader[T1: Reader, T2: Reader]: Reader[Left[T1, T2]]
/**
* Writers for Either types
*/
implicit def EitherWriter[T1: Writer, T2: Writer]: Writer[Either[T1, T2]]
implicit def RightWriter[T1: Writer, T2: Writer]: Writer[Right[T1, T2]]
implicit def LeftWriter[T1: Writer, T2: Writer]: Writer[Left[T1, T2]]Usage Examples:
import upickle.default._
// Either serialization format: [tag, value]
val left: Either[String, Int] = Left("error")
val right: Either[String, Int] = Right(42)
val leftJson = write(left) // [0, "error"]
val rightJson = write(right) // [1, 42]
// Reading Either values
val parsedLeft = read[Either[String, Int]]("[0, \"error\"]") // Left("error")
val parsedRight = read[Either[String, Int]]("[1, 42]") // Right(42)Support for Scala Duration types with string-based serialization.
implicit val DurationReader: Reader[Duration]
implicit val InfiniteDurationReader: Reader[Duration.Infinite]
implicit val FiniteDurationReader: Reader[FiniteDuration]
implicit val DurationWriter: Writer[Duration]
implicit val InfiniteDurationWriter: Writer[Duration.Infinite]
implicit val FiniteDurationWriter: Writer[FiniteDuration]Usage Examples:
import upickle.default._
import scala.concurrent.duration._
// Duration serialization
val duration = 5.seconds
val infinite = Duration.Inf
val minusInf = Duration.MinusInf
val undefined = Duration.Undefined
val durJson = write(duration) // "5000000000" (nanoseconds)
val infJson = write(infinite) // "inf"
val minusJson = write(minusInf) // "-inf"
val undefJson = write(undefined) // "undef"
// Reading durations
val parsedDur = read[Duration]("\"5000000000\"") // 5.seconds
val parsedInf = read[Duration]("\"inf\"") // Duration.InfReaders and writers for Java boxed primitive types.
implicit val JavaBooleanReader: Reader[java.lang.Boolean]
implicit val JavaByteReader: Reader[java.lang.Byte]
implicit val JavaCharReader: Reader[java.lang.Character]
implicit val JavaShortReader: Reader[java.lang.Short]
implicit val JavaIntReader: Reader[java.lang.Integer]
implicit val JavaLongReader: Reader[java.lang.Long]
implicit val JavaFloatReader: Reader[java.lang.Float]
implicit val JavaDoubleReader: Reader[java.lang.Double]
implicit val JavaBooleanWriter: Writer[java.lang.Boolean]
implicit val JavaByteWriter: Writer[java.lang.Byte]
implicit val JavaCharWriter: Writer[java.lang.Character]
implicit val JavaShortWriter: Writer[java.lang.Short]
implicit val JavaIntWriter: Writer[java.lang.Integer]
implicit val JavaLongWriter: Writer[java.lang.Long]
implicit val JavaFloatWriter: Writer[java.lang.Float]
implicit val JavaDoubleWriter: Writer[java.lang.Double]Usage Examples:
import upickle.default._
// Java boxed types work seamlessly
val javaInt: java.lang.Integer = 42
val javaStr = write(javaInt) // "42"
val parsed: java.lang.Integer = read[java.lang.Integer]("42")trait SimpleStringReader[T] extends SimpleReader[T] {
def readString(s: CharSequence): T
}
trait SimpleMapKeyWriter[T] extends Writer[T] {
override def isJsonDictKey: Boolean = true
def writeString(v: T): String
}
trait OptionReader[T] extends Reader[Option[T]]
trait OptionWriter[T] extends Writer[Option[T]]
protected trait NumericReader[T] extends SimpleReader[T]