JsonDecoder

A JsonDecoder[A] instance has the ability to decode JSON to values of type A, potentially failing with an error if the JSON content does not encode a value of the given type.

Companion:
object
class Object
trait Matchable
class Any

Value members

Abstract methods

def unsafeDecode(trace: List[JsonError], in: RetractReader): A
Implicitly added by chunk

Low-level, unsafe method to decode a value or throw an exception. This method should not be called in application code, although it can be implemented for user-defined data structures.

Low-level, unsafe method to decode a value or throw an exception. This method should not be called in application code, although it can be implemented for user-defined data structures.

def unsafeDecode(trace: List[JsonError], in: RetractReader): A
Implicitly added by hashSet

Low-level, unsafe method to decode a value or throw an exception. This method should not be called in application code, although it can be implemented for user-defined data structures.

Low-level, unsafe method to decode a value or throw an exception. This method should not be called in application code, although it can be implemented for user-defined data structures.

def unsafeDecode(trace: List[JsonError], in: RetractReader): A
Implicitly added by indexedSeq

Low-level, unsafe method to decode a value or throw an exception. This method should not be called in application code, although it can be implemented for user-defined data structures.

Low-level, unsafe method to decode a value or throw an exception. This method should not be called in application code, although it can be implemented for user-defined data structures.

def unsafeDecode(trace: List[JsonError], in: RetractReader): A
Implicitly added by iterable

Low-level, unsafe method to decode a value or throw an exception. This method should not be called in application code, although it can be implemented for user-defined data structures.

Low-level, unsafe method to decode a value or throw an exception. This method should not be called in application code, although it can be implemented for user-defined data structures.

def unsafeDecode(trace: List[JsonError], in: RetractReader): A
Implicitly added by linearSeq

Low-level, unsafe method to decode a value or throw an exception. This method should not be called in application code, although it can be implemented for user-defined data structures.

Low-level, unsafe method to decode a value or throw an exception. This method should not be called in application code, although it can be implemented for user-defined data structures.

def unsafeDecode(trace: List[JsonError], in: RetractReader): A
Implicitly added by list

Low-level, unsafe method to decode a value or throw an exception. This method should not be called in application code, although it can be implemented for user-defined data structures.

Low-level, unsafe method to decode a value or throw an exception. This method should not be called in application code, although it can be implemented for user-defined data structures.

def unsafeDecode(trace: List[JsonError], in: RetractReader): A
Implicitly added by listSet

Low-level, unsafe method to decode a value or throw an exception. This method should not be called in application code, although it can be implemented for user-defined data structures.

Low-level, unsafe method to decode a value or throw an exception. This method should not be called in application code, although it can be implemented for user-defined data structures.

def unsafeDecode(trace: List[JsonError], in: RetractReader): A
Implicitly added by nonEmptyChunk

Low-level, unsafe method to decode a value or throw an exception. This method should not be called in application code, although it can be implemented for user-defined data structures.

Low-level, unsafe method to decode a value or throw an exception. This method should not be called in application code, although it can be implemented for user-defined data structures.

def unsafeDecode(trace: List[JsonError], in: RetractReader): A
Implicitly added by option

Low-level, unsafe method to decode a value or throw an exception. This method should not be called in application code, although it can be implemented for user-defined data structures.

Low-level, unsafe method to decode a value or throw an exception. This method should not be called in application code, although it can be implemented for user-defined data structures.

def unsafeDecode(trace: List[JsonError], in: RetractReader): A
Implicitly added by seq

Low-level, unsafe method to decode a value or throw an exception. This method should not be called in application code, although it can be implemented for user-defined data structures.

Low-level, unsafe method to decode a value or throw an exception. This method should not be called in application code, although it can be implemented for user-defined data structures.

def unsafeDecode(trace: List[JsonError], in: RetractReader): A
Implicitly added by set

Low-level, unsafe method to decode a value or throw an exception. This method should not be called in application code, although it can be implemented for user-defined data structures.

Low-level, unsafe method to decode a value or throw an exception. This method should not be called in application code, although it can be implemented for user-defined data structures.

def unsafeDecode(trace: List[JsonError], in: RetractReader): A
Implicitly added by tuple1

Low-level, unsafe method to decode a value or throw an exception. This method should not be called in application code, although it can be implemented for user-defined data structures.

Low-level, unsafe method to decode a value or throw an exception. This method should not be called in application code, although it can be implemented for user-defined data structures.

def unsafeDecode(trace: List[JsonError], in: RetractReader): A
Implicitly added by vector

Low-level, unsafe method to decode a value or throw an exception. This method should not be called in application code, although it can be implemented for user-defined data structures.

Low-level, unsafe method to decode a value or throw an exception. This method should not be called in application code, although it can be implemented for user-defined data structures.

def unsafeDecode(trace: List[JsonError], in: RetractReader): A

Low-level, unsafe method to decode a value or throw an exception. This method should not be called in application code, although it can be implemented for user-defined data structures.

Low-level, unsafe method to decode a value or throw an exception. This method should not be called in application code, although it can be implemented for user-defined data structures.

Concrete methods

final def *>[B](that: => JsonDecoder[B]): JsonDecoder[B]
Implicitly added by chunk

An alias for JsonDecoder#zipRight.

An alias for JsonDecoder#zipRight.

final def *>[B](that: => JsonDecoder[B]): JsonDecoder[B]
Implicitly added by hashSet

An alias for JsonDecoder#zipRight.

An alias for JsonDecoder#zipRight.

final def *>[B](that: => JsonDecoder[B]): JsonDecoder[B]
Implicitly added by indexedSeq

An alias for JsonDecoder#zipRight.

An alias for JsonDecoder#zipRight.

final def *>[B](that: => JsonDecoder[B]): JsonDecoder[B]
Implicitly added by iterable

An alias for JsonDecoder#zipRight.

An alias for JsonDecoder#zipRight.

final def *>[B](that: => JsonDecoder[B]): JsonDecoder[B]
Implicitly added by linearSeq

An alias for JsonDecoder#zipRight.

An alias for JsonDecoder#zipRight.

final def *>[B](that: => JsonDecoder[B]): JsonDecoder[B]
Implicitly added by list

An alias for JsonDecoder#zipRight.

An alias for JsonDecoder#zipRight.

final def *>[B](that: => JsonDecoder[B]): JsonDecoder[B]
Implicitly added by listSet

An alias for JsonDecoder#zipRight.

An alias for JsonDecoder#zipRight.

final def *>[B](that: => JsonDecoder[B]): JsonDecoder[B]
Implicitly added by nonEmptyChunk

An alias for JsonDecoder#zipRight.

An alias for JsonDecoder#zipRight.

final def *>[B](that: => JsonDecoder[B]): JsonDecoder[B]
Implicitly added by option

An alias for JsonDecoder#zipRight.

An alias for JsonDecoder#zipRight.

final def *>[B](that: => JsonDecoder[B]): JsonDecoder[B]
Implicitly added by seq

An alias for JsonDecoder#zipRight.

An alias for JsonDecoder#zipRight.

final def *>[B](that: => JsonDecoder[B]): JsonDecoder[B]
Implicitly added by set

An alias for JsonDecoder#zipRight.

An alias for JsonDecoder#zipRight.

final def *>[B](that: => JsonDecoder[B]): JsonDecoder[B]
Implicitly added by tuple1

An alias for JsonDecoder#zipRight.

An alias for JsonDecoder#zipRight.

final def *>[B](that: => JsonDecoder[B]): JsonDecoder[B]
Implicitly added by vector

An alias for JsonDecoder#zipRight.

An alias for JsonDecoder#zipRight.

final def *>[B](that: => JsonDecoder[B]): JsonDecoder[B]

An alias for JsonDecoder#zipRight.

An alias for JsonDecoder#zipRight.

final def <*[B](that: => JsonDecoder[B]): JsonDecoder[A]
Implicitly added by chunk

An alias for JsonDecoder#zipLeft.

An alias for JsonDecoder#zipLeft.

final def <*[B](that: => JsonDecoder[B]): JsonDecoder[A]
Implicitly added by hashSet

An alias for JsonDecoder#zipLeft.

An alias for JsonDecoder#zipLeft.

final def <*[B](that: => JsonDecoder[B]): JsonDecoder[A]
Implicitly added by indexedSeq

An alias for JsonDecoder#zipLeft.

An alias for JsonDecoder#zipLeft.

final def <*[B](that: => JsonDecoder[B]): JsonDecoder[A]
Implicitly added by iterable

An alias for JsonDecoder#zipLeft.

An alias for JsonDecoder#zipLeft.

final def <*[B](that: => JsonDecoder[B]): JsonDecoder[A]
Implicitly added by linearSeq

An alias for JsonDecoder#zipLeft.

An alias for JsonDecoder#zipLeft.

final def <*[B](that: => JsonDecoder[B]): JsonDecoder[A]
Implicitly added by list

An alias for JsonDecoder#zipLeft.

An alias for JsonDecoder#zipLeft.

final def <*[B](that: => JsonDecoder[B]): JsonDecoder[A]
Implicitly added by listSet

An alias for JsonDecoder#zipLeft.

An alias for JsonDecoder#zipLeft.

final def <*[B](that: => JsonDecoder[B]): JsonDecoder[A]
Implicitly added by nonEmptyChunk

An alias for JsonDecoder#zipLeft.

An alias for JsonDecoder#zipLeft.

final def <*[B](that: => JsonDecoder[B]): JsonDecoder[A]
Implicitly added by option

An alias for JsonDecoder#zipLeft.

An alias for JsonDecoder#zipLeft.

final def <*[B](that: => JsonDecoder[B]): JsonDecoder[A]
Implicitly added by seq

An alias for JsonDecoder#zipLeft.

An alias for JsonDecoder#zipLeft.

final def <*[B](that: => JsonDecoder[B]): JsonDecoder[A]
Implicitly added by set

An alias for JsonDecoder#zipLeft.

An alias for JsonDecoder#zipLeft.

final def <*[B](that: => JsonDecoder[B]): JsonDecoder[A]
Implicitly added by tuple1

An alias for JsonDecoder#zipLeft.

An alias for JsonDecoder#zipLeft.

final def <*[B](that: => JsonDecoder[B]): JsonDecoder[A]
Implicitly added by vector

An alias for JsonDecoder#zipLeft.

An alias for JsonDecoder#zipLeft.

final def <*[B](that: => JsonDecoder[B]): JsonDecoder[A]

An alias for JsonDecoder#zipLeft.

An alias for JsonDecoder#zipLeft.

final def <*>[B](that: => JsonDecoder[B]): JsonDecoder[(A, B)]
Implicitly added by chunk

An alias for JsonDecoder#zip.

An alias for JsonDecoder#zip.

final def <*>[B](that: => JsonDecoder[B]): JsonDecoder[(A, B)]
Implicitly added by hashSet

An alias for JsonDecoder#zip.

An alias for JsonDecoder#zip.

final def <*>[B](that: => JsonDecoder[B]): JsonDecoder[(A, B)]
Implicitly added by indexedSeq

An alias for JsonDecoder#zip.

An alias for JsonDecoder#zip.

final def <*>[B](that: => JsonDecoder[B]): JsonDecoder[(A, B)]
Implicitly added by iterable

An alias for JsonDecoder#zip.

An alias for JsonDecoder#zip.

final def <*>[B](that: => JsonDecoder[B]): JsonDecoder[(A, B)]
Implicitly added by linearSeq

An alias for JsonDecoder#zip.

An alias for JsonDecoder#zip.

final def <*>[B](that: => JsonDecoder[B]): JsonDecoder[(A, B)]
Implicitly added by list

An alias for JsonDecoder#zip.

An alias for JsonDecoder#zip.

final def <*>[B](that: => JsonDecoder[B]): JsonDecoder[(A, B)]
Implicitly added by listSet

An alias for JsonDecoder#zip.

An alias for JsonDecoder#zip.

final def <*>[B](that: => JsonDecoder[B]): JsonDecoder[(A, B)]
Implicitly added by nonEmptyChunk

An alias for JsonDecoder#zip.

An alias for JsonDecoder#zip.

final def <*>[B](that: => JsonDecoder[B]): JsonDecoder[(A, B)]
Implicitly added by option

An alias for JsonDecoder#zip.

An alias for JsonDecoder#zip.

final def <*>[B](that: => JsonDecoder[B]): JsonDecoder[(A, B)]
Implicitly added by seq

An alias for JsonDecoder#zip.

An alias for JsonDecoder#zip.

final def <*>[B](that: => JsonDecoder[B]): JsonDecoder[(A, B)]
Implicitly added by set

An alias for JsonDecoder#zip.

An alias for JsonDecoder#zip.

final def <*>[B](that: => JsonDecoder[B]): JsonDecoder[(A, B)]
Implicitly added by tuple1

An alias for JsonDecoder#zip.

An alias for JsonDecoder#zip.

final def <*>[B](that: => JsonDecoder[B]): JsonDecoder[(A, B)]
Implicitly added by vector

An alias for JsonDecoder#zip.

An alias for JsonDecoder#zip.

final def <*>[B](that: => JsonDecoder[B]): JsonDecoder[(A, B)]

An alias for JsonDecoder#zip.

An alias for JsonDecoder#zip.

final def <+>[B](that: => JsonDecoder[B]): JsonDecoder[Either[A, B]]
Implicitly added by chunk
final def <+>[B](that: => JsonDecoder[B]): JsonDecoder[Either[A, B]]
Implicitly added by hashSet
final def <+>[B](that: => JsonDecoder[B]): JsonDecoder[Either[A, B]]
Implicitly added by indexedSeq
final def <+>[B](that: => JsonDecoder[B]): JsonDecoder[Either[A, B]]
Implicitly added by iterable
final def <+>[B](that: => JsonDecoder[B]): JsonDecoder[Either[A, B]]
Implicitly added by linearSeq
final def <+>[B](that: => JsonDecoder[B]): JsonDecoder[Either[A, B]]
Implicitly added by list
final def <+>[B](that: => JsonDecoder[B]): JsonDecoder[Either[A, B]]
Implicitly added by listSet
final def <+>[B](that: => JsonDecoder[B]): JsonDecoder[Either[A, B]]
Implicitly added by nonEmptyChunk
final def <+>[B](that: => JsonDecoder[B]): JsonDecoder[Either[A, B]]
Implicitly added by option
final def <+>[B](that: => JsonDecoder[B]): JsonDecoder[Either[A, B]]
Implicitly added by seq
final def <+>[B](that: => JsonDecoder[B]): JsonDecoder[Either[A, B]]
Implicitly added by set
final def <+>[B](that: => JsonDecoder[B]): JsonDecoder[Either[A, B]]
Implicitly added by tuple1
final def <+>[B](that: => JsonDecoder[B]): JsonDecoder[Either[A, B]]
Implicitly added by vector
final def <+>[B](that: => JsonDecoder[B]): JsonDecoder[Either[A, B]]
final def <>[A1 >: A](that: => JsonDecoder[A1]): JsonDecoder[A1]
Implicitly added by chunk

An alias for JsonDecoder#orElse.

An alias for JsonDecoder#orElse.

final def <>[A1 >: A](that: => JsonDecoder[A1]): JsonDecoder[A1]
Implicitly added by hashSet

An alias for JsonDecoder#orElse.

An alias for JsonDecoder#orElse.

final def <>[A1 >: A](that: => JsonDecoder[A1]): JsonDecoder[A1]
Implicitly added by indexedSeq

An alias for JsonDecoder#orElse.

An alias for JsonDecoder#orElse.

final def <>[A1 >: A](that: => JsonDecoder[A1]): JsonDecoder[A1]
Implicitly added by iterable

An alias for JsonDecoder#orElse.

An alias for JsonDecoder#orElse.

final def <>[A1 >: A](that: => JsonDecoder[A1]): JsonDecoder[A1]
Implicitly added by linearSeq

An alias for JsonDecoder#orElse.

An alias for JsonDecoder#orElse.

final def <>[A1 >: A](that: => JsonDecoder[A1]): JsonDecoder[A1]
Implicitly added by list

An alias for JsonDecoder#orElse.

An alias for JsonDecoder#orElse.

final def <>[A1 >: A](that: => JsonDecoder[A1]): JsonDecoder[A1]
Implicitly added by listSet

An alias for JsonDecoder#orElse.

An alias for JsonDecoder#orElse.

final def <>[A1 >: A](that: => JsonDecoder[A1]): JsonDecoder[A1]
Implicitly added by nonEmptyChunk

An alias for JsonDecoder#orElse.

An alias for JsonDecoder#orElse.

final def <>[A1 >: A](that: => JsonDecoder[A1]): JsonDecoder[A1]
Implicitly added by option

An alias for JsonDecoder#orElse.

An alias for JsonDecoder#orElse.

final def <>[A1 >: A](that: => JsonDecoder[A1]): JsonDecoder[A1]
Implicitly added by seq

An alias for JsonDecoder#orElse.

An alias for JsonDecoder#orElse.

final def <>[A1 >: A](that: => JsonDecoder[A1]): JsonDecoder[A1]
Implicitly added by set

An alias for JsonDecoder#orElse.

An alias for JsonDecoder#orElse.

final def <>[A1 >: A](that: => JsonDecoder[A1]): JsonDecoder[A1]
Implicitly added by tuple1

An alias for JsonDecoder#orElse.

An alias for JsonDecoder#orElse.

final def <>[A1 >: A](that: => JsonDecoder[A1]): JsonDecoder[A1]
Implicitly added by vector

An alias for JsonDecoder#orElse.

An alias for JsonDecoder#orElse.

final def <>[A1 >: A](that: => JsonDecoder[A1]): JsonDecoder[A1]

An alias for JsonDecoder#orElse.

An alias for JsonDecoder#orElse.

final def decodeJson(str: CharSequence): Either[String, A]
Implicitly added by chunk

Attempts to decode a value of type A from the specified CharSequence, but may fail with a human-readable error message if the provided text does not encode a value of this type.

Attempts to decode a value of type A from the specified CharSequence, but may fail with a human-readable error message if the provided text does not encode a value of this type.

Note: This method may not entirely consume the specified character sequence.

final def decodeJson(str: CharSequence): Either[String, A]
Implicitly added by hashSet

Attempts to decode a value of type A from the specified CharSequence, but may fail with a human-readable error message if the provided text does not encode a value of this type.

Attempts to decode a value of type A from the specified CharSequence, but may fail with a human-readable error message if the provided text does not encode a value of this type.

Note: This method may not entirely consume the specified character sequence.

final def decodeJson(str: CharSequence): Either[String, A]
Implicitly added by indexedSeq

Attempts to decode a value of type A from the specified CharSequence, but may fail with a human-readable error message if the provided text does not encode a value of this type.

Attempts to decode a value of type A from the specified CharSequence, but may fail with a human-readable error message if the provided text does not encode a value of this type.

Note: This method may not entirely consume the specified character sequence.

final def decodeJson(str: CharSequence): Either[String, A]
Implicitly added by iterable

Attempts to decode a value of type A from the specified CharSequence, but may fail with a human-readable error message if the provided text does not encode a value of this type.

Attempts to decode a value of type A from the specified CharSequence, but may fail with a human-readable error message if the provided text does not encode a value of this type.

Note: This method may not entirely consume the specified character sequence.

final def decodeJson(str: CharSequence): Either[String, A]
Implicitly added by linearSeq

Attempts to decode a value of type A from the specified CharSequence, but may fail with a human-readable error message if the provided text does not encode a value of this type.

Attempts to decode a value of type A from the specified CharSequence, but may fail with a human-readable error message if the provided text does not encode a value of this type.

Note: This method may not entirely consume the specified character sequence.

final def decodeJson(str: CharSequence): Either[String, A]
Implicitly added by list

Attempts to decode a value of type A from the specified CharSequence, but may fail with a human-readable error message if the provided text does not encode a value of this type.

Attempts to decode a value of type A from the specified CharSequence, but may fail with a human-readable error message if the provided text does not encode a value of this type.

Note: This method may not entirely consume the specified character sequence.

final def decodeJson(str: CharSequence): Either[String, A]
Implicitly added by listSet

Attempts to decode a value of type A from the specified CharSequence, but may fail with a human-readable error message if the provided text does not encode a value of this type.

Attempts to decode a value of type A from the specified CharSequence, but may fail with a human-readable error message if the provided text does not encode a value of this type.

Note: This method may not entirely consume the specified character sequence.

final def decodeJson(str: CharSequence): Either[String, A]
Implicitly added by nonEmptyChunk

Attempts to decode a value of type A from the specified CharSequence, but may fail with a human-readable error message if the provided text does not encode a value of this type.

Attempts to decode a value of type A from the specified CharSequence, but may fail with a human-readable error message if the provided text does not encode a value of this type.

Note: This method may not entirely consume the specified character sequence.

final def decodeJson(str: CharSequence): Either[String, A]
Implicitly added by option

Attempts to decode a value of type A from the specified CharSequence, but may fail with a human-readable error message if the provided text does not encode a value of this type.

Attempts to decode a value of type A from the specified CharSequence, but may fail with a human-readable error message if the provided text does not encode a value of this type.

Note: This method may not entirely consume the specified character sequence.

final def decodeJson(str: CharSequence): Either[String, A]
Implicitly added by seq

Attempts to decode a value of type A from the specified CharSequence, but may fail with a human-readable error message if the provided text does not encode a value of this type.

Attempts to decode a value of type A from the specified CharSequence, but may fail with a human-readable error message if the provided text does not encode a value of this type.

Note: This method may not entirely consume the specified character sequence.

final def decodeJson(str: CharSequence): Either[String, A]
Implicitly added by set

Attempts to decode a value of type A from the specified CharSequence, but may fail with a human-readable error message if the provided text does not encode a value of this type.

Attempts to decode a value of type A from the specified CharSequence, but may fail with a human-readable error message if the provided text does not encode a value of this type.

Note: This method may not entirely consume the specified character sequence.

final def decodeJson(str: CharSequence): Either[String, A]
Implicitly added by tuple1

Attempts to decode a value of type A from the specified CharSequence, but may fail with a human-readable error message if the provided text does not encode a value of this type.

Attempts to decode a value of type A from the specified CharSequence, but may fail with a human-readable error message if the provided text does not encode a value of this type.

Note: This method may not entirely consume the specified character sequence.

final def decodeJson(str: CharSequence): Either[String, A]
Implicitly added by vector

Attempts to decode a value of type A from the specified CharSequence, but may fail with a human-readable error message if the provided text does not encode a value of this type.

Attempts to decode a value of type A from the specified CharSequence, but may fail with a human-readable error message if the provided text does not encode a value of this type.

Note: This method may not entirely consume the specified character sequence.

final def decodeJson(str: CharSequence): Either[String, A]

Attempts to decode a value of type A from the specified CharSequence, but may fail with a human-readable error message if the provided text does not encode a value of this type.

Attempts to decode a value of type A from the specified CharSequence, but may fail with a human-readable error message if the provided text does not encode a value of this type.

Note: This method may not entirely consume the specified character sequence.

final def fromJsonAST(json: Json): Either[String, A]
Implicitly added by chunk

Decode a value from an already parsed Json AST.

Decode a value from an already parsed Json AST.

The default implementation encodes the Json to a byte stream and uses decode to parse that. Override to provide a more performant implementation.

final def fromJsonAST(json: Json): Either[String, A]
Implicitly added by hashSet

Decode a value from an already parsed Json AST.

Decode a value from an already parsed Json AST.

The default implementation encodes the Json to a byte stream and uses decode to parse that. Override to provide a more performant implementation.

final def fromJsonAST(json: Json): Either[String, A]
Implicitly added by indexedSeq

Decode a value from an already parsed Json AST.

Decode a value from an already parsed Json AST.

The default implementation encodes the Json to a byte stream and uses decode to parse that. Override to provide a more performant implementation.

final def fromJsonAST(json: Json): Either[String, A]
Implicitly added by iterable

Decode a value from an already parsed Json AST.

Decode a value from an already parsed Json AST.

The default implementation encodes the Json to a byte stream and uses decode to parse that. Override to provide a more performant implementation.

final def fromJsonAST(json: Json): Either[String, A]
Implicitly added by linearSeq

Decode a value from an already parsed Json AST.

Decode a value from an already parsed Json AST.

The default implementation encodes the Json to a byte stream and uses decode to parse that. Override to provide a more performant implementation.

final def fromJsonAST(json: Json): Either[String, A]
Implicitly added by list

Decode a value from an already parsed Json AST.

Decode a value from an already parsed Json AST.

The default implementation encodes the Json to a byte stream and uses decode to parse that. Override to provide a more performant implementation.

final def fromJsonAST(json: Json): Either[String, A]
Implicitly added by listSet

Decode a value from an already parsed Json AST.

Decode a value from an already parsed Json AST.

The default implementation encodes the Json to a byte stream and uses decode to parse that. Override to provide a more performant implementation.

final def fromJsonAST(json: Json): Either[String, A]
Implicitly added by nonEmptyChunk

Decode a value from an already parsed Json AST.

Decode a value from an already parsed Json AST.

The default implementation encodes the Json to a byte stream and uses decode to parse that. Override to provide a more performant implementation.

final def fromJsonAST(json: Json): Either[String, A]
Implicitly added by option

Decode a value from an already parsed Json AST.

Decode a value from an already parsed Json AST.

The default implementation encodes the Json to a byte stream and uses decode to parse that. Override to provide a more performant implementation.

final def fromJsonAST(json: Json): Either[String, A]
Implicitly added by seq

Decode a value from an already parsed Json AST.

Decode a value from an already parsed Json AST.

The default implementation encodes the Json to a byte stream and uses decode to parse that. Override to provide a more performant implementation.

final def fromJsonAST(json: Json): Either[String, A]
Implicitly added by set

Decode a value from an already parsed Json AST.

Decode a value from an already parsed Json AST.

The default implementation encodes the Json to a byte stream and uses decode to parse that. Override to provide a more performant implementation.

final def fromJsonAST(json: Json): Either[String, A]
Implicitly added by tuple1

Decode a value from an already parsed Json AST.

Decode a value from an already parsed Json AST.

The default implementation encodes the Json to a byte stream and uses decode to parse that. Override to provide a more performant implementation.

final def fromJsonAST(json: Json): Either[String, A]
Implicitly added by vector

Decode a value from an already parsed Json AST.

Decode a value from an already parsed Json AST.

The default implementation encodes the Json to a byte stream and uses decode to parse that. Override to provide a more performant implementation.

final def fromJsonAST(json: Json): Either[String, A]

Decode a value from an already parsed Json AST.

Decode a value from an already parsed Json AST.

The default implementation encodes the Json to a byte stream and uses decode to parse that. Override to provide a more performant implementation.

final def map[B](f: A => B): JsonDecoder[B]
Implicitly added by chunk

Returns a new codec whose decoded values will be mapped by the specified function.

Returns a new codec whose decoded values will be mapped by the specified function.

final def map[B](f: A => B): JsonDecoder[B]
Implicitly added by hashSet

Returns a new codec whose decoded values will be mapped by the specified function.

Returns a new codec whose decoded values will be mapped by the specified function.

final def map[B](f: A => B): JsonDecoder[B]
Implicitly added by indexedSeq

Returns a new codec whose decoded values will be mapped by the specified function.

Returns a new codec whose decoded values will be mapped by the specified function.

final def map[B](f: A => B): JsonDecoder[B]
Implicitly added by iterable

Returns a new codec whose decoded values will be mapped by the specified function.

Returns a new codec whose decoded values will be mapped by the specified function.

final def map[B](f: A => B): JsonDecoder[B]
Implicitly added by linearSeq

Returns a new codec whose decoded values will be mapped by the specified function.

Returns a new codec whose decoded values will be mapped by the specified function.

final def map[B](f: A => B): JsonDecoder[B]
Implicitly added by list

Returns a new codec whose decoded values will be mapped by the specified function.

Returns a new codec whose decoded values will be mapped by the specified function.

final def map[B](f: A => B): JsonDecoder[B]
Implicitly added by listSet

Returns a new codec whose decoded values will be mapped by the specified function.

Returns a new codec whose decoded values will be mapped by the specified function.

final def map[B](f: A => B): JsonDecoder[B]
Implicitly added by nonEmptyChunk

Returns a new codec whose decoded values will be mapped by the specified function.

Returns a new codec whose decoded values will be mapped by the specified function.

final def map[B](f: A => B): JsonDecoder[B]
Implicitly added by option

Returns a new codec whose decoded values will be mapped by the specified function.

Returns a new codec whose decoded values will be mapped by the specified function.

final def map[B](f: A => B): JsonDecoder[B]
Implicitly added by seq

Returns a new codec whose decoded values will be mapped by the specified function.

Returns a new codec whose decoded values will be mapped by the specified function.

final def map[B](f: A => B): JsonDecoder[B]
Implicitly added by set

Returns a new codec whose decoded values will be mapped by the specified function.

Returns a new codec whose decoded values will be mapped by the specified function.

final def map[B](f: A => B): JsonDecoder[B]
Implicitly added by tuple1

Returns a new codec whose decoded values will be mapped by the specified function.

Returns a new codec whose decoded values will be mapped by the specified function.

final def map[B](f: A => B): JsonDecoder[B]
Implicitly added by vector

Returns a new codec whose decoded values will be mapped by the specified function.

Returns a new codec whose decoded values will be mapped by the specified function.

final def map[B](f: A => B): JsonDecoder[B]

Returns a new codec whose decoded values will be mapped by the specified function.

Returns a new codec whose decoded values will be mapped by the specified function.

final def mapOrFail[B](f: A => Either[String, B]): JsonDecoder[B]
Implicitly added by chunk

Returns a new codec whose decoded values will be mapped by the specified function, which may itself decide to fail with some type of error.

Returns a new codec whose decoded values will be mapped by the specified function, which may itself decide to fail with some type of error.

final def mapOrFail[B](f: A => Either[String, B]): JsonDecoder[B]
Implicitly added by hashSet

Returns a new codec whose decoded values will be mapped by the specified function, which may itself decide to fail with some type of error.

Returns a new codec whose decoded values will be mapped by the specified function, which may itself decide to fail with some type of error.

final def mapOrFail[B](f: A => Either[String, B]): JsonDecoder[B]
Implicitly added by indexedSeq

Returns a new codec whose decoded values will be mapped by the specified function, which may itself decide to fail with some type of error.

Returns a new codec whose decoded values will be mapped by the specified function, which may itself decide to fail with some type of error.

final def mapOrFail[B](f: A => Either[String, B]): JsonDecoder[B]
Implicitly added by iterable

Returns a new codec whose decoded values will be mapped by the specified function, which may itself decide to fail with some type of error.

Returns a new codec whose decoded values will be mapped by the specified function, which may itself decide to fail with some type of error.

final def mapOrFail[B](f: A => Either[String, B]): JsonDecoder[B]
Implicitly added by linearSeq

Returns a new codec whose decoded values will be mapped by the specified function, which may itself decide to fail with some type of error.

Returns a new codec whose decoded values will be mapped by the specified function, which may itself decide to fail with some type of error.

final def mapOrFail[B](f: A => Either[String, B]): JsonDecoder[B]
Implicitly added by list

Returns a new codec whose decoded values will be mapped by the specified function, which may itself decide to fail with some type of error.

Returns a new codec whose decoded values will be mapped by the specified function, which may itself decide to fail with some type of error.

final def mapOrFail[B](f: A => Either[String, B]): JsonDecoder[B]
Implicitly added by listSet

Returns a new codec whose decoded values will be mapped by the specified function, which may itself decide to fail with some type of error.

Returns a new codec whose decoded values will be mapped by the specified function, which may itself decide to fail with some type of error.

final def mapOrFail[B](f: A => Either[String, B]): JsonDecoder[B]
Implicitly added by nonEmptyChunk

Returns a new codec whose decoded values will be mapped by the specified function, which may itself decide to fail with some type of error.

Returns a new codec whose decoded values will be mapped by the specified function, which may itself decide to fail with some type of error.

final def mapOrFail[B](f: A => Either[String, B]): JsonDecoder[B]
Implicitly added by option

Returns a new codec whose decoded values will be mapped by the specified function, which may itself decide to fail with some type of error.

Returns a new codec whose decoded values will be mapped by the specified function, which may itself decide to fail with some type of error.

final def mapOrFail[B](f: A => Either[String, B]): JsonDecoder[B]
Implicitly added by seq

Returns a new codec whose decoded values will be mapped by the specified function, which may itself decide to fail with some type of error.

Returns a new codec whose decoded values will be mapped by the specified function, which may itself decide to fail with some type of error.

final def mapOrFail[B](f: A => Either[String, B]): JsonDecoder[B]
Implicitly added by set

Returns a new codec whose decoded values will be mapped by the specified function, which may itself decide to fail with some type of error.

Returns a new codec whose decoded values will be mapped by the specified function, which may itself decide to fail with some type of error.

final def mapOrFail[B](f: A => Either[String, B]): JsonDecoder[B]
Implicitly added by tuple1

Returns a new codec whose decoded values will be mapped by the specified function, which may itself decide to fail with some type of error.

Returns a new codec whose decoded values will be mapped by the specified function, which may itself decide to fail with some type of error.

final def mapOrFail[B](f: A => Either[String, B]): JsonDecoder[B]
Implicitly added by vector

Returns a new codec whose decoded values will be mapped by the specified function, which may itself decide to fail with some type of error.

Returns a new codec whose decoded values will be mapped by the specified function, which may itself decide to fail with some type of error.

final def mapOrFail[B](f: A => Either[String, B]): JsonDecoder[B]

Returns a new codec whose decoded values will be mapped by the specified function, which may itself decide to fail with some type of error.

Returns a new codec whose decoded values will be mapped by the specified function, which may itself decide to fail with some type of error.

final def orElse[A1 >: A](that: => JsonDecoder[A1]): JsonDecoder[A1]
Implicitly added by chunk

Returns a new codec that combines this codec and the specified codec using fallback semantics: such that if this codec fails, the specified codec will be tried instead. This method may be unsafe from a security perspective: it can use more memory than hand coded alternative and so lead to DOS.

Returns a new codec that combines this codec and the specified codec using fallback semantics: such that if this codec fails, the specified codec will be tried instead. This method may be unsafe from a security perspective: it can use more memory than hand coded alternative and so lead to DOS.

For example, in the case of an alternative between Int and Boolean, a hand coded alternative would look like:

val decoder: JsonDecoder[AnyVal] = JsonDecoder.peekChar[AnyVal] {
case 't' | 'f' => JsonDecoder[Boolean].widen
case c         => JsonDecoder[Int].widen
}
final def orElse[A1 >: A](that: => JsonDecoder[A1]): JsonDecoder[A1]
Implicitly added by hashSet

Returns a new codec that combines this codec and the specified codec using fallback semantics: such that if this codec fails, the specified codec will be tried instead. This method may be unsafe from a security perspective: it can use more memory than hand coded alternative and so lead to DOS.

Returns a new codec that combines this codec and the specified codec using fallback semantics: such that if this codec fails, the specified codec will be tried instead. This method may be unsafe from a security perspective: it can use more memory than hand coded alternative and so lead to DOS.

For example, in the case of an alternative between Int and Boolean, a hand coded alternative would look like:

val decoder: JsonDecoder[AnyVal] = JsonDecoder.peekChar[AnyVal] {
case 't' | 'f' => JsonDecoder[Boolean].widen
case c         => JsonDecoder[Int].widen
}
final def orElse[A1 >: A](that: => JsonDecoder[A1]): JsonDecoder[A1]
Implicitly added by indexedSeq

Returns a new codec that combines this codec and the specified codec using fallback semantics: such that if this codec fails, the specified codec will be tried instead. This method may be unsafe from a security perspective: it can use more memory than hand coded alternative and so lead to DOS.

Returns a new codec that combines this codec and the specified codec using fallback semantics: such that if this codec fails, the specified codec will be tried instead. This method may be unsafe from a security perspective: it can use more memory than hand coded alternative and so lead to DOS.

For example, in the case of an alternative between Int and Boolean, a hand coded alternative would look like:

val decoder: JsonDecoder[AnyVal] = JsonDecoder.peekChar[AnyVal] {
case 't' | 'f' => JsonDecoder[Boolean].widen
case c         => JsonDecoder[Int].widen
}
final def orElse[A1 >: A](that: => JsonDecoder[A1]): JsonDecoder[A1]
Implicitly added by iterable

Returns a new codec that combines this codec and the specified codec using fallback semantics: such that if this codec fails, the specified codec will be tried instead. This method may be unsafe from a security perspective: it can use more memory than hand coded alternative and so lead to DOS.

Returns a new codec that combines this codec and the specified codec using fallback semantics: such that if this codec fails, the specified codec will be tried instead. This method may be unsafe from a security perspective: it can use more memory than hand coded alternative and so lead to DOS.

For example, in the case of an alternative between Int and Boolean, a hand coded alternative would look like:

val decoder: JsonDecoder[AnyVal] = JsonDecoder.peekChar[AnyVal] {
case 't' | 'f' => JsonDecoder[Boolean].widen
case c         => JsonDecoder[Int].widen
}
final def orElse[A1 >: A](that: => JsonDecoder[A1]): JsonDecoder[A1]
Implicitly added by linearSeq

Returns a new codec that combines this codec and the specified codec using fallback semantics: such that if this codec fails, the specified codec will be tried instead. This method may be unsafe from a security perspective: it can use more memory than hand coded alternative and so lead to DOS.

Returns a new codec that combines this codec and the specified codec using fallback semantics: such that if this codec fails, the specified codec will be tried instead. This method may be unsafe from a security perspective: it can use more memory than hand coded alternative and so lead to DOS.

For example, in the case of an alternative between Int and Boolean, a hand coded alternative would look like:

val decoder: JsonDecoder[AnyVal] = JsonDecoder.peekChar[AnyVal] {
case 't' | 'f' => JsonDecoder[Boolean].widen
case c         => JsonDecoder[Int].widen
}
final def orElse[A1 >: A](that: => JsonDecoder[A1]): JsonDecoder[A1]
Implicitly added by list

Returns a new codec that combines this codec and the specified codec using fallback semantics: such that if this codec fails, the specified codec will be tried instead. This method may be unsafe from a security perspective: it can use more memory than hand coded alternative and so lead to DOS.

Returns a new codec that combines this codec and the specified codec using fallback semantics: such that if this codec fails, the specified codec will be tried instead. This method may be unsafe from a security perspective: it can use more memory than hand coded alternative and so lead to DOS.

For example, in the case of an alternative between Int and Boolean, a hand coded alternative would look like:

val decoder: JsonDecoder[AnyVal] = JsonDecoder.peekChar[AnyVal] {
case 't' | 'f' => JsonDecoder[Boolean].widen
case c         => JsonDecoder[Int].widen
}
final def orElse[A1 >: A](that: => JsonDecoder[A1]): JsonDecoder[A1]
Implicitly added by listSet

Returns a new codec that combines this codec and the specified codec using fallback semantics: such that if this codec fails, the specified codec will be tried instead. This method may be unsafe from a security perspective: it can use more memory than hand coded alternative and so lead to DOS.

Returns a new codec that combines this codec and the specified codec using fallback semantics: such that if this codec fails, the specified codec will be tried instead. This method may be unsafe from a security perspective: it can use more memory than hand coded alternative and so lead to DOS.

For example, in the case of an alternative between Int and Boolean, a hand coded alternative would look like:

val decoder: JsonDecoder[AnyVal] = JsonDecoder.peekChar[AnyVal] {
case 't' | 'f' => JsonDecoder[Boolean].widen
case c         => JsonDecoder[Int].widen
}
final def orElse[A1 >: A](that: => JsonDecoder[A1]): JsonDecoder[A1]
Implicitly added by nonEmptyChunk

Returns a new codec that combines this codec and the specified codec using fallback semantics: such that if this codec fails, the specified codec will be tried instead. This method may be unsafe from a security perspective: it can use more memory than hand coded alternative and so lead to DOS.

Returns a new codec that combines this codec and the specified codec using fallback semantics: such that if this codec fails, the specified codec will be tried instead. This method may be unsafe from a security perspective: it can use more memory than hand coded alternative and so lead to DOS.

For example, in the case of an alternative between Int and Boolean, a hand coded alternative would look like:

val decoder: JsonDecoder[AnyVal] = JsonDecoder.peekChar[AnyVal] {
case 't' | 'f' => JsonDecoder[Boolean].widen
case c         => JsonDecoder[Int].widen
}
final def orElse[A1 >: A](that: => JsonDecoder[A1]): JsonDecoder[A1]
Implicitly added by option

Returns a new codec that combines this codec and the specified codec using fallback semantics: such that if this codec fails, the specified codec will be tried instead. This method may be unsafe from a security perspective: it can use more memory than hand coded alternative and so lead to DOS.

Returns a new codec that combines this codec and the specified codec using fallback semantics: such that if this codec fails, the specified codec will be tried instead. This method may be unsafe from a security perspective: it can use more memory than hand coded alternative and so lead to DOS.

For example, in the case of an alternative between Int and Boolean, a hand coded alternative would look like:

val decoder: JsonDecoder[AnyVal] = JsonDecoder.peekChar[AnyVal] {
case 't' | 'f' => JsonDecoder[Boolean].widen
case c         => JsonDecoder[Int].widen
}
final def orElse[A1 >: A](that: => JsonDecoder[A1]): JsonDecoder[A1]
Implicitly added by seq

Returns a new codec that combines this codec and the specified codec using fallback semantics: such that if this codec fails, the specified codec will be tried instead. This method may be unsafe from a security perspective: it can use more memory than hand coded alternative and so lead to DOS.

Returns a new codec that combines this codec and the specified codec using fallback semantics: such that if this codec fails, the specified codec will be tried instead. This method may be unsafe from a security perspective: it can use more memory than hand coded alternative and so lead to DOS.

For example, in the case of an alternative between Int and Boolean, a hand coded alternative would look like:

val decoder: JsonDecoder[AnyVal] = JsonDecoder.peekChar[AnyVal] {
case 't' | 'f' => JsonDecoder[Boolean].widen
case c         => JsonDecoder[Int].widen
}
final def orElse[A1 >: A](that: => JsonDecoder[A1]): JsonDecoder[A1]
Implicitly added by set

Returns a new codec that combines this codec and the specified codec using fallback semantics: such that if this codec fails, the specified codec will be tried instead. This method may be unsafe from a security perspective: it can use more memory than hand coded alternative and so lead to DOS.

Returns a new codec that combines this codec and the specified codec using fallback semantics: such that if this codec fails, the specified codec will be tried instead. This method may be unsafe from a security perspective: it can use more memory than hand coded alternative and so lead to DOS.

For example, in the case of an alternative between Int and Boolean, a hand coded alternative would look like:

val decoder: JsonDecoder[AnyVal] = JsonDecoder.peekChar[AnyVal] {
case 't' | 'f' => JsonDecoder[Boolean].widen
case c         => JsonDecoder[Int].widen
}
final def orElse[A1 >: A](that: => JsonDecoder[A1]): JsonDecoder[A1]
Implicitly added by tuple1

Returns a new codec that combines this codec and the specified codec using fallback semantics: such that if this codec fails, the specified codec will be tried instead. This method may be unsafe from a security perspective: it can use more memory than hand coded alternative and so lead to DOS.

Returns a new codec that combines this codec and the specified codec using fallback semantics: such that if this codec fails, the specified codec will be tried instead. This method may be unsafe from a security perspective: it can use more memory than hand coded alternative and so lead to DOS.

For example, in the case of an alternative between Int and Boolean, a hand coded alternative would look like:

val decoder: JsonDecoder[AnyVal] = JsonDecoder.peekChar[AnyVal] {
case 't' | 'f' => JsonDecoder[Boolean].widen
case c         => JsonDecoder[Int].widen
}
final def orElse[A1 >: A](that: => JsonDecoder[A1]): JsonDecoder[A1]
Implicitly added by vector

Returns a new codec that combines this codec and the specified codec using fallback semantics: such that if this codec fails, the specified codec will be tried instead. This method may be unsafe from a security perspective: it can use more memory than hand coded alternative and so lead to DOS.

Returns a new codec that combines this codec and the specified codec using fallback semantics: such that if this codec fails, the specified codec will be tried instead. This method may be unsafe from a security perspective: it can use more memory than hand coded alternative and so lead to DOS.

For example, in the case of an alternative between Int and Boolean, a hand coded alternative would look like:

val decoder: JsonDecoder[AnyVal] = JsonDecoder.peekChar[AnyVal] {
case 't' | 'f' => JsonDecoder[Boolean].widen
case c         => JsonDecoder[Int].widen
}
final def orElse[A1 >: A](that: => JsonDecoder[A1]): JsonDecoder[A1]

Returns a new codec that combines this codec and the specified codec using fallback semantics: such that if this codec fails, the specified codec will be tried instead. This method may be unsafe from a security perspective: it can use more memory than hand coded alternative and so lead to DOS.

Returns a new codec that combines this codec and the specified codec using fallback semantics: such that if this codec fails, the specified codec will be tried instead. This method may be unsafe from a security perspective: it can use more memory than hand coded alternative and so lead to DOS.

For example, in the case of an alternative between Int and Boolean, a hand coded alternative would look like:

val decoder: JsonDecoder[AnyVal] = JsonDecoder.peekChar[AnyVal] {
case 't' | 'f' => JsonDecoder[Boolean].widen
case c         => JsonDecoder[Int].widen
}
final def orElseEither[B](that: => JsonDecoder[B]): JsonDecoder[Either[A, B]]
Implicitly added by chunk

Returns a new codec that combines this codec and the specified codec using fallback semantics: such that if this codec fails, the specified codec will be tried instead.

Returns a new codec that combines this codec and the specified codec using fallback semantics: such that if this codec fails, the specified codec will be tried instead.

final def orElseEither[B](that: => JsonDecoder[B]): JsonDecoder[Either[A, B]]
Implicitly added by hashSet

Returns a new codec that combines this codec and the specified codec using fallback semantics: such that if this codec fails, the specified codec will be tried instead.

Returns a new codec that combines this codec and the specified codec using fallback semantics: such that if this codec fails, the specified codec will be tried instead.

final def orElseEither[B](that: => JsonDecoder[B]): JsonDecoder[Either[A, B]]
Implicitly added by indexedSeq

Returns a new codec that combines this codec and the specified codec using fallback semantics: such that if this codec fails, the specified codec will be tried instead.

Returns a new codec that combines this codec and the specified codec using fallback semantics: such that if this codec fails, the specified codec will be tried instead.

final def orElseEither[B](that: => JsonDecoder[B]): JsonDecoder[Either[A, B]]
Implicitly added by iterable

Returns a new codec that combines this codec and the specified codec using fallback semantics: such that if this codec fails, the specified codec will be tried instead.

Returns a new codec that combines this codec and the specified codec using fallback semantics: such that if this codec fails, the specified codec will be tried instead.

final def orElseEither[B](that: => JsonDecoder[B]): JsonDecoder[Either[A, B]]
Implicitly added by linearSeq

Returns a new codec that combines this codec and the specified codec using fallback semantics: such that if this codec fails, the specified codec will be tried instead.

Returns a new codec that combines this codec and the specified codec using fallback semantics: such that if this codec fails, the specified codec will be tried instead.

final def orElseEither[B](that: => JsonDecoder[B]): JsonDecoder[Either[A, B]]
Implicitly added by list

Returns a new codec that combines this codec and the specified codec using fallback semantics: such that if this codec fails, the specified codec will be tried instead.

Returns a new codec that combines this codec and the specified codec using fallback semantics: such that if this codec fails, the specified codec will be tried instead.

final def orElseEither[B](that: => JsonDecoder[B]): JsonDecoder[Either[A, B]]
Implicitly added by listSet

Returns a new codec that combines this codec and the specified codec using fallback semantics: such that if this codec fails, the specified codec will be tried instead.

Returns a new codec that combines this codec and the specified codec using fallback semantics: such that if this codec fails, the specified codec will be tried instead.

final def orElseEither[B](that: => JsonDecoder[B]): JsonDecoder[Either[A, B]]
Implicitly added by nonEmptyChunk

Returns a new codec that combines this codec and the specified codec using fallback semantics: such that if this codec fails, the specified codec will be tried instead.

Returns a new codec that combines this codec and the specified codec using fallback semantics: such that if this codec fails, the specified codec will be tried instead.

final def orElseEither[B](that: => JsonDecoder[B]): JsonDecoder[Either[A, B]]
Implicitly added by option

Returns a new codec that combines this codec and the specified codec using fallback semantics: such that if this codec fails, the specified codec will be tried instead.

Returns a new codec that combines this codec and the specified codec using fallback semantics: such that if this codec fails, the specified codec will be tried instead.

final def orElseEither[B](that: => JsonDecoder[B]): JsonDecoder[Either[A, B]]
Implicitly added by seq

Returns a new codec that combines this codec and the specified codec using fallback semantics: such that if this codec fails, the specified codec will be tried instead.

Returns a new codec that combines this codec and the specified codec using fallback semantics: such that if this codec fails, the specified codec will be tried instead.

final def orElseEither[B](that: => JsonDecoder[B]): JsonDecoder[Either[A, B]]
Implicitly added by set

Returns a new codec that combines this codec and the specified codec using fallback semantics: such that if this codec fails, the specified codec will be tried instead.

Returns a new codec that combines this codec and the specified codec using fallback semantics: such that if this codec fails, the specified codec will be tried instead.

final def orElseEither[B](that: => JsonDecoder[B]): JsonDecoder[Either[A, B]]
Implicitly added by tuple1

Returns a new codec that combines this codec and the specified codec using fallback semantics: such that if this codec fails, the specified codec will be tried instead.

Returns a new codec that combines this codec and the specified codec using fallback semantics: such that if this codec fails, the specified codec will be tried instead.

final def orElseEither[B](that: => JsonDecoder[B]): JsonDecoder[Either[A, B]]
Implicitly added by vector

Returns a new codec that combines this codec and the specified codec using fallback semantics: such that if this codec fails, the specified codec will be tried instead.

Returns a new codec that combines this codec and the specified codec using fallback semantics: such that if this codec fails, the specified codec will be tried instead.

final def orElseEither[B](that: => JsonDecoder[B]): JsonDecoder[Either[A, B]]

Returns a new codec that combines this codec and the specified codec using fallback semantics: such that if this codec fails, the specified codec will be tried instead.

Returns a new codec that combines this codec and the specified codec using fallback semantics: such that if this codec fails, the specified codec will be tried instead.

def unsafeDecodeMissing(trace: List[JsonError]): A
Implicitly added by chunk
def unsafeDecodeMissing(trace: List[JsonError]): A
Implicitly added by hashSet
def unsafeDecodeMissing(trace: List[JsonError]): A
Implicitly added by indexedSeq
def unsafeDecodeMissing(trace: List[JsonError]): A
Implicitly added by iterable
def unsafeDecodeMissing(trace: List[JsonError]): A
Implicitly added by linearSeq
def unsafeDecodeMissing(trace: List[JsonError]): A
Implicitly added by list
def unsafeDecodeMissing(trace: List[JsonError]): A
Implicitly added by listSet
def unsafeDecodeMissing(trace: List[JsonError]): A
Implicitly added by nonEmptyChunk
def unsafeDecodeMissing(trace: List[JsonError]): A
Implicitly added by option
def unsafeDecodeMissing(trace: List[JsonError]): A
Implicitly added by seq
def unsafeDecodeMissing(trace: List[JsonError]): A
Implicitly added by set
def unsafeDecodeMissing(trace: List[JsonError]): A
Implicitly added by tuple1
def unsafeDecodeMissing(trace: List[JsonError]): A
Implicitly added by vector
def unsafeDecodeMissing(trace: List[JsonError]): A
def unsafeFromJsonAST(trace: List[JsonError], json: Json): A
Implicitly added by chunk
def unsafeFromJsonAST(trace: List[JsonError], json: Json): A
Implicitly added by hashSet
def unsafeFromJsonAST(trace: List[JsonError], json: Json): A
Implicitly added by indexedSeq
def unsafeFromJsonAST(trace: List[JsonError], json: Json): A
Implicitly added by iterable
def unsafeFromJsonAST(trace: List[JsonError], json: Json): A
Implicitly added by linearSeq
def unsafeFromJsonAST(trace: List[JsonError], json: Json): A
Implicitly added by list
def unsafeFromJsonAST(trace: List[JsonError], json: Json): A
Implicitly added by listSet
def unsafeFromJsonAST(trace: List[JsonError], json: Json): A
Implicitly added by nonEmptyChunk
def unsafeFromJsonAST(trace: List[JsonError], json: Json): A
Implicitly added by option
def unsafeFromJsonAST(trace: List[JsonError], json: Json): A
Implicitly added by seq
def unsafeFromJsonAST(trace: List[JsonError], json: Json): A
Implicitly added by set
def unsafeFromJsonAST(trace: List[JsonError], json: Json): A
Implicitly added by tuple1
def unsafeFromJsonAST(trace: List[JsonError], json: Json): A
Implicitly added by vector
def unsafeFromJsonAST(trace: List[JsonError], json: Json): A
final def widen[B >: A]: JsonDecoder[B]
Implicitly added by chunk

Returns this decoder but widened to the its given super-type

Returns this decoder but widened to the its given super-type

final def widen[B >: A]: JsonDecoder[B]
Implicitly added by hashSet

Returns this decoder but widened to the its given super-type

Returns this decoder but widened to the its given super-type

final def widen[B >: A]: JsonDecoder[B]
Implicitly added by indexedSeq

Returns this decoder but widened to the its given super-type

Returns this decoder but widened to the its given super-type

final def widen[B >: A]: JsonDecoder[B]
Implicitly added by iterable

Returns this decoder but widened to the its given super-type

Returns this decoder but widened to the its given super-type

final def widen[B >: A]: JsonDecoder[B]
Implicitly added by linearSeq

Returns this decoder but widened to the its given super-type

Returns this decoder but widened to the its given super-type

final def widen[B >: A]: JsonDecoder[B]
Implicitly added by list

Returns this decoder but widened to the its given super-type

Returns this decoder but widened to the its given super-type

final def widen[B >: A]: JsonDecoder[B]
Implicitly added by listSet

Returns this decoder but widened to the its given super-type

Returns this decoder but widened to the its given super-type

final def widen[B >: A]: JsonDecoder[B]
Implicitly added by nonEmptyChunk

Returns this decoder but widened to the its given super-type

Returns this decoder but widened to the its given super-type

final def widen[B >: A]: JsonDecoder[B]
Implicitly added by option

Returns this decoder but widened to the its given super-type

Returns this decoder but widened to the its given super-type

final def widen[B >: A]: JsonDecoder[B]
Implicitly added by seq

Returns this decoder but widened to the its given super-type

Returns this decoder but widened to the its given super-type

final def widen[B >: A]: JsonDecoder[B]
Implicitly added by set

Returns this decoder but widened to the its given super-type

Returns this decoder but widened to the its given super-type

final def widen[B >: A]: JsonDecoder[B]
Implicitly added by tuple1

Returns this decoder but widened to the its given super-type

Returns this decoder but widened to the its given super-type

final def widen[B >: A]: JsonDecoder[B]
Implicitly added by vector

Returns this decoder but widened to the its given super-type

Returns this decoder but widened to the its given super-type

final def widen[B >: A]: JsonDecoder[B]

Returns this decoder but widened to the its given super-type

Returns this decoder but widened to the its given super-type

final def zip[B](that: => JsonDecoder[B]): JsonDecoder[(A, B)]
Implicitly added by chunk

Returns a new codec that combines this codec and the specified codec into a single codec that decodes a tuple of the values decoded by the respective codecs.

Returns a new codec that combines this codec and the specified codec into a single codec that decodes a tuple of the values decoded by the respective codecs.

final def zip[B](that: => JsonDecoder[B]): JsonDecoder[(A, B)]
Implicitly added by hashSet

Returns a new codec that combines this codec and the specified codec into a single codec that decodes a tuple of the values decoded by the respective codecs.

Returns a new codec that combines this codec and the specified codec into a single codec that decodes a tuple of the values decoded by the respective codecs.

final def zip[B](that: => JsonDecoder[B]): JsonDecoder[(A, B)]
Implicitly added by indexedSeq

Returns a new codec that combines this codec and the specified codec into a single codec that decodes a tuple of the values decoded by the respective codecs.

Returns a new codec that combines this codec and the specified codec into a single codec that decodes a tuple of the values decoded by the respective codecs.

final def zip[B](that: => JsonDecoder[B]): JsonDecoder[(A, B)]
Implicitly added by iterable

Returns a new codec that combines this codec and the specified codec into a single codec that decodes a tuple of the values decoded by the respective codecs.

Returns a new codec that combines this codec and the specified codec into a single codec that decodes a tuple of the values decoded by the respective codecs.

final def zip[B](that: => JsonDecoder[B]): JsonDecoder[(A, B)]
Implicitly added by linearSeq

Returns a new codec that combines this codec and the specified codec into a single codec that decodes a tuple of the values decoded by the respective codecs.

Returns a new codec that combines this codec and the specified codec into a single codec that decodes a tuple of the values decoded by the respective codecs.

final def zip[B](that: => JsonDecoder[B]): JsonDecoder[(A, B)]
Implicitly added by list

Returns a new codec that combines this codec and the specified codec into a single codec that decodes a tuple of the values decoded by the respective codecs.

Returns a new codec that combines this codec and the specified codec into a single codec that decodes a tuple of the values decoded by the respective codecs.

final def zip[B](that: => JsonDecoder[B]): JsonDecoder[(A, B)]
Implicitly added by listSet

Returns a new codec that combines this codec and the specified codec into a single codec that decodes a tuple of the values decoded by the respective codecs.

Returns a new codec that combines this codec and the specified codec into a single codec that decodes a tuple of the values decoded by the respective codecs.

final def zip[B](that: => JsonDecoder[B]): JsonDecoder[(A, B)]
Implicitly added by nonEmptyChunk

Returns a new codec that combines this codec and the specified codec into a single codec that decodes a tuple of the values decoded by the respective codecs.

Returns a new codec that combines this codec and the specified codec into a single codec that decodes a tuple of the values decoded by the respective codecs.

final def zip[B](that: => JsonDecoder[B]): JsonDecoder[(A, B)]
Implicitly added by option

Returns a new codec that combines this codec and the specified codec into a single codec that decodes a tuple of the values decoded by the respective codecs.

Returns a new codec that combines this codec and the specified codec into a single codec that decodes a tuple of the values decoded by the respective codecs.

final def zip[B](that: => JsonDecoder[B]): JsonDecoder[(A, B)]
Implicitly added by seq

Returns a new codec that combines this codec and the specified codec into a single codec that decodes a tuple of the values decoded by the respective codecs.

Returns a new codec that combines this codec and the specified codec into a single codec that decodes a tuple of the values decoded by the respective codecs.

final def zip[B](that: => JsonDecoder[B]): JsonDecoder[(A, B)]
Implicitly added by set

Returns a new codec that combines this codec and the specified codec into a single codec that decodes a tuple of the values decoded by the respective codecs.

Returns a new codec that combines this codec and the specified codec into a single codec that decodes a tuple of the values decoded by the respective codecs.

final def zip[B](that: => JsonDecoder[B]): JsonDecoder[(A, B)]
Implicitly added by tuple1

Returns a new codec that combines this codec and the specified codec into a single codec that decodes a tuple of the values decoded by the respective codecs.

Returns a new codec that combines this codec and the specified codec into a single codec that decodes a tuple of the values decoded by the respective codecs.

final def zip[B](that: => JsonDecoder[B]): JsonDecoder[(A, B)]
Implicitly added by vector

Returns a new codec that combines this codec and the specified codec into a single codec that decodes a tuple of the values decoded by the respective codecs.

Returns a new codec that combines this codec and the specified codec into a single codec that decodes a tuple of the values decoded by the respective codecs.

final def zip[B](that: => JsonDecoder[B]): JsonDecoder[(A, B)]

Returns a new codec that combines this codec and the specified codec into a single codec that decodes a tuple of the values decoded by the respective codecs.

Returns a new codec that combines this codec and the specified codec into a single codec that decodes a tuple of the values decoded by the respective codecs.

final def zipLeft[B](that: => JsonDecoder[B]): JsonDecoder[A]
Implicitly added by chunk

Zips two codecs, but discards the output on the right hand side.

Zips two codecs, but discards the output on the right hand side.

final def zipLeft[B](that: => JsonDecoder[B]): JsonDecoder[A]
Implicitly added by hashSet

Zips two codecs, but discards the output on the right hand side.

Zips two codecs, but discards the output on the right hand side.

final def zipLeft[B](that: => JsonDecoder[B]): JsonDecoder[A]
Implicitly added by indexedSeq

Zips two codecs, but discards the output on the right hand side.

Zips two codecs, but discards the output on the right hand side.

final def zipLeft[B](that: => JsonDecoder[B]): JsonDecoder[A]
Implicitly added by iterable

Zips two codecs, but discards the output on the right hand side.

Zips two codecs, but discards the output on the right hand side.

final def zipLeft[B](that: => JsonDecoder[B]): JsonDecoder[A]
Implicitly added by linearSeq

Zips two codecs, but discards the output on the right hand side.

Zips two codecs, but discards the output on the right hand side.

final def zipLeft[B](that: => JsonDecoder[B]): JsonDecoder[A]
Implicitly added by list

Zips two codecs, but discards the output on the right hand side.

Zips two codecs, but discards the output on the right hand side.

final def zipLeft[B](that: => JsonDecoder[B]): JsonDecoder[A]
Implicitly added by listSet

Zips two codecs, but discards the output on the right hand side.

Zips two codecs, but discards the output on the right hand side.

final def zipLeft[B](that: => JsonDecoder[B]): JsonDecoder[A]
Implicitly added by nonEmptyChunk

Zips two codecs, but discards the output on the right hand side.

Zips two codecs, but discards the output on the right hand side.

final def zipLeft[B](that: => JsonDecoder[B]): JsonDecoder[A]
Implicitly added by option

Zips two codecs, but discards the output on the right hand side.

Zips two codecs, but discards the output on the right hand side.

final def zipLeft[B](that: => JsonDecoder[B]): JsonDecoder[A]
Implicitly added by seq

Zips two codecs, but discards the output on the right hand side.

Zips two codecs, but discards the output on the right hand side.

final def zipLeft[B](that: => JsonDecoder[B]): JsonDecoder[A]
Implicitly added by set

Zips two codecs, but discards the output on the right hand side.

Zips two codecs, but discards the output on the right hand side.

final def zipLeft[B](that: => JsonDecoder[B]): JsonDecoder[A]
Implicitly added by tuple1

Zips two codecs, but discards the output on the right hand side.

Zips two codecs, but discards the output on the right hand side.

final def zipLeft[B](that: => JsonDecoder[B]): JsonDecoder[A]
Implicitly added by vector

Zips two codecs, but discards the output on the right hand side.

Zips two codecs, but discards the output on the right hand side.

final def zipLeft[B](that: => JsonDecoder[B]): JsonDecoder[A]

Zips two codecs, but discards the output on the right hand side.

Zips two codecs, but discards the output on the right hand side.

final def zipRight[B](that: => JsonDecoder[B]): JsonDecoder[B]
Implicitly added by chunk

Zips two codecs, but discards the output on the left hand side.

Zips two codecs, but discards the output on the left hand side.

final def zipRight[B](that: => JsonDecoder[B]): JsonDecoder[B]
Implicitly added by hashSet

Zips two codecs, but discards the output on the left hand side.

Zips two codecs, but discards the output on the left hand side.

final def zipRight[B](that: => JsonDecoder[B]): JsonDecoder[B]
Implicitly added by indexedSeq

Zips two codecs, but discards the output on the left hand side.

Zips two codecs, but discards the output on the left hand side.

final def zipRight[B](that: => JsonDecoder[B]): JsonDecoder[B]
Implicitly added by iterable

Zips two codecs, but discards the output on the left hand side.

Zips two codecs, but discards the output on the left hand side.

final def zipRight[B](that: => JsonDecoder[B]): JsonDecoder[B]
Implicitly added by linearSeq

Zips two codecs, but discards the output on the left hand side.

Zips two codecs, but discards the output on the left hand side.

final def zipRight[B](that: => JsonDecoder[B]): JsonDecoder[B]
Implicitly added by list

Zips two codecs, but discards the output on the left hand side.

Zips two codecs, but discards the output on the left hand side.

final def zipRight[B](that: => JsonDecoder[B]): JsonDecoder[B]
Implicitly added by listSet

Zips two codecs, but discards the output on the left hand side.

Zips two codecs, but discards the output on the left hand side.

final def zipRight[B](that: => JsonDecoder[B]): JsonDecoder[B]
Implicitly added by nonEmptyChunk

Zips two codecs, but discards the output on the left hand side.

Zips two codecs, but discards the output on the left hand side.

final def zipRight[B](that: => JsonDecoder[B]): JsonDecoder[B]
Implicitly added by option

Zips two codecs, but discards the output on the left hand side.

Zips two codecs, but discards the output on the left hand side.

final def zipRight[B](that: => JsonDecoder[B]): JsonDecoder[B]
Implicitly added by seq

Zips two codecs, but discards the output on the left hand side.

Zips two codecs, but discards the output on the left hand side.

final def zipRight[B](that: => JsonDecoder[B]): JsonDecoder[B]
Implicitly added by set

Zips two codecs, but discards the output on the left hand side.

Zips two codecs, but discards the output on the left hand side.

final def zipRight[B](that: => JsonDecoder[B]): JsonDecoder[B]
Implicitly added by tuple1

Zips two codecs, but discards the output on the left hand side.

Zips two codecs, but discards the output on the left hand side.

final def zipRight[B](that: => JsonDecoder[B]): JsonDecoder[B]
Implicitly added by vector

Zips two codecs, but discards the output on the left hand side.

Zips two codecs, but discards the output on the left hand side.

final def zipRight[B](that: => JsonDecoder[B]): JsonDecoder[B]

Zips two codecs, but discards the output on the left hand side.

Zips two codecs, but discards the output on the left hand side.

final def zipWith[B, C](that: => JsonDecoder[B])(f: (A, B) => C): JsonDecoder[C]
Implicitly added by chunk

Zips two codecs into one, transforming the outputs of zip codecs by the specified function.

Zips two codecs into one, transforming the outputs of zip codecs by the specified function.

final def zipWith[B, C](that: => JsonDecoder[B])(f: (A, B) => C): JsonDecoder[C]
Implicitly added by hashSet

Zips two codecs into one, transforming the outputs of zip codecs by the specified function.

Zips two codecs into one, transforming the outputs of zip codecs by the specified function.

final def zipWith[B, C](that: => JsonDecoder[B])(f: (A, B) => C): JsonDecoder[C]
Implicitly added by indexedSeq

Zips two codecs into one, transforming the outputs of zip codecs by the specified function.

Zips two codecs into one, transforming the outputs of zip codecs by the specified function.

final def zipWith[B, C](that: => JsonDecoder[B])(f: (A, B) => C): JsonDecoder[C]
Implicitly added by iterable

Zips two codecs into one, transforming the outputs of zip codecs by the specified function.

Zips two codecs into one, transforming the outputs of zip codecs by the specified function.

final def zipWith[B, C](that: => JsonDecoder[B])(f: (A, B) => C): JsonDecoder[C]
Implicitly added by linearSeq

Zips two codecs into one, transforming the outputs of zip codecs by the specified function.

Zips two codecs into one, transforming the outputs of zip codecs by the specified function.

final def zipWith[B, C](that: => JsonDecoder[B])(f: (A, B) => C): JsonDecoder[C]
Implicitly added by list

Zips two codecs into one, transforming the outputs of zip codecs by the specified function.

Zips two codecs into one, transforming the outputs of zip codecs by the specified function.

final def zipWith[B, C](that: => JsonDecoder[B])(f: (A, B) => C): JsonDecoder[C]
Implicitly added by listSet

Zips two codecs into one, transforming the outputs of zip codecs by the specified function.

Zips two codecs into one, transforming the outputs of zip codecs by the specified function.

final def zipWith[B, C](that: => JsonDecoder[B])(f: (A, B) => C): JsonDecoder[C]
Implicitly added by nonEmptyChunk

Zips two codecs into one, transforming the outputs of zip codecs by the specified function.

Zips two codecs into one, transforming the outputs of zip codecs by the specified function.

final def zipWith[B, C](that: => JsonDecoder[B])(f: (A, B) => C): JsonDecoder[C]
Implicitly added by option

Zips two codecs into one, transforming the outputs of zip codecs by the specified function.

Zips two codecs into one, transforming the outputs of zip codecs by the specified function.

final def zipWith[B, C](that: => JsonDecoder[B])(f: (A, B) => C): JsonDecoder[C]
Implicitly added by seq

Zips two codecs into one, transforming the outputs of zip codecs by the specified function.

Zips two codecs into one, transforming the outputs of zip codecs by the specified function.

final def zipWith[B, C](that: => JsonDecoder[B])(f: (A, B) => C): JsonDecoder[C]
Implicitly added by set

Zips two codecs into one, transforming the outputs of zip codecs by the specified function.

Zips two codecs into one, transforming the outputs of zip codecs by the specified function.

final def zipWith[B, C](that: => JsonDecoder[B])(f: (A, B) => C): JsonDecoder[C]
Implicitly added by tuple1

Zips two codecs into one, transforming the outputs of zip codecs by the specified function.

Zips two codecs into one, transforming the outputs of zip codecs by the specified function.

final def zipWith[B, C](that: => JsonDecoder[B])(f: (A, B) => C): JsonDecoder[C]
Implicitly added by vector

Zips two codecs into one, transforming the outputs of zip codecs by the specified function.

Zips two codecs into one, transforming the outputs of zip codecs by the specified function.

final def zipWith[B, C](that: => JsonDecoder[B])(f: (A, B) => C): JsonDecoder[C]

Zips two codecs into one, transforming the outputs of zip codecs by the specified function.

Zips two codecs into one, transforming the outputs of zip codecs by the specified function.