zio-json/zio.json/JsonEncoder

JsonEncoder

trait JsonEncoder[A] extends JsonEncoderPlatformSpecific[A]
Companion:
object
class Object
trait Matchable
class Any

Value members

Abstract methods

def unsafeEncode(a: A, indent: Option[Int], out: Write): Unit
Implicitly added by chunk
def unsafeEncode(a: A, indent: Option[Int], out: Write): Unit
Implicitly added by hashSet
def unsafeEncode(a: A, indent: Option[Int], out: Write): Unit
Implicitly added by indexedSeq
def unsafeEncode(a: A, indent: Option[Int], out: Write): Unit
Implicitly added by iterable
def unsafeEncode(a: A, indent: Option[Int], out: Write): Unit
Implicitly added by linearSeq
def unsafeEncode(a: A, indent: Option[Int], out: Write): Unit
Implicitly added by list
def unsafeEncode(a: A, indent: Option[Int], out: Write): Unit
Implicitly added by listSet
def unsafeEncode(a: A, indent: Option[Int], out: Write): Unit
Implicitly added by nonEmptyChunk
def unsafeEncode(a: A, indent: Option[Int], out: Write): Unit
Implicitly added by option
def unsafeEncode(a: A, indent: Option[Int], out: Write): Unit
Implicitly added by seq
def unsafeEncode(a: A, indent: Option[Int], out: Write): Unit
Implicitly added by set
def unsafeEncode(a: A, indent: Option[Int], out: Write): Unit
Implicitly added by treeSet
def unsafeEncode(a: A, indent: Option[Int], out: Write): Unit
Implicitly added by tuple1
def unsafeEncode(a: A, indent: Option[Int], out: Write): Unit
Implicitly added by vector
def unsafeEncode(a: A, indent: Option[Int], out: Write): Unit

Concrete methods

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

Returns a new encoder, with a new input type, which can be transformed to the old input type by the specified user-defined function.

Returns a new encoder, with a new input type, which can be transformed to the old input type by the specified user-defined function.

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

Returns a new encoder, with a new input type, which can be transformed to the old input type by the specified user-defined function.

Returns a new encoder, with a new input type, which can be transformed to the old input type by the specified user-defined function.

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

Returns a new encoder, with a new input type, which can be transformed to the old input type by the specified user-defined function.

Returns a new encoder, with a new input type, which can be transformed to the old input type by the specified user-defined function.

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

Returns a new encoder, with a new input type, which can be transformed to the old input type by the specified user-defined function.

Returns a new encoder, with a new input type, which can be transformed to the old input type by the specified user-defined function.

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

Returns a new encoder, with a new input type, which can be transformed to the old input type by the specified user-defined function.

Returns a new encoder, with a new input type, which can be transformed to the old input type by the specified user-defined function.

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

Returns a new encoder, with a new input type, which can be transformed to the old input type by the specified user-defined function.

Returns a new encoder, with a new input type, which can be transformed to the old input type by the specified user-defined function.

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

Returns a new encoder, with a new input type, which can be transformed to the old input type by the specified user-defined function.

Returns a new encoder, with a new input type, which can be transformed to the old input type by the specified user-defined function.

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

Returns a new encoder, with a new input type, which can be transformed to the old input type by the specified user-defined function.

Returns a new encoder, with a new input type, which can be transformed to the old input type by the specified user-defined function.

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

Returns a new encoder, with a new input type, which can be transformed to the old input type by the specified user-defined function.

Returns a new encoder, with a new input type, which can be transformed to the old input type by the specified user-defined function.

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

Returns a new encoder, with a new input type, which can be transformed to the old input type by the specified user-defined function.

Returns a new encoder, with a new input type, which can be transformed to the old input type by the specified user-defined function.

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

Returns a new encoder, with a new input type, which can be transformed to the old input type by the specified user-defined function.

Returns a new encoder, with a new input type, which can be transformed to the old input type by the specified user-defined function.

final def contramap[B](f: B => A): JsonEncoder[B]
Implicitly added by treeSet

Returns a new encoder, with a new input type, which can be transformed to the old input type by the specified user-defined function.

Returns a new encoder, with a new input type, which can be transformed to the old input type by the specified user-defined function.

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

Returns a new encoder, with a new input type, which can be transformed to the old input type by the specified user-defined function.

Returns a new encoder, with a new input type, which can be transformed to the old input type by the specified user-defined function.

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

Returns a new encoder, with a new input type, which can be transformed to the old input type by the specified user-defined function.

Returns a new encoder, with a new input type, which can be transformed to the old input type by the specified user-defined function.

final def contramap[B](f: B => A): JsonEncoder[B]

Returns a new encoder, with a new input type, which can be transformed to the old input type by the specified user-defined function.

Returns a new encoder, with a new input type, which can be transformed to the old input type by the specified user-defined function.

final def either[B](that: => JsonEncoder[B]): JsonEncoder[Either[A, B]]
Implicitly added by chunk

Returns a new encoder that can accepts an Either[A, B] to either, and uses either this encoder or the specified encoder to encode the two different types of values.

Returns a new encoder that can accepts an Either[A, B] to either, and uses either this encoder or the specified encoder to encode the two different types of values.

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

Returns a new encoder that can accepts an Either[A, B] to either, and uses either this encoder or the specified encoder to encode the two different types of values.

Returns a new encoder that can accepts an Either[A, B] to either, and uses either this encoder or the specified encoder to encode the two different types of values.

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

Returns a new encoder that can accepts an Either[A, B] to either, and uses either this encoder or the specified encoder to encode the two different types of values.

Returns a new encoder that can accepts an Either[A, B] to either, and uses either this encoder or the specified encoder to encode the two different types of values.

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

Returns a new encoder that can accepts an Either[A, B] to either, and uses either this encoder or the specified encoder to encode the two different types of values.

Returns a new encoder that can accepts an Either[A, B] to either, and uses either this encoder or the specified encoder to encode the two different types of values.

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

Returns a new encoder that can accepts an Either[A, B] to either, and uses either this encoder or the specified encoder to encode the two different types of values.

Returns a new encoder that can accepts an Either[A, B] to either, and uses either this encoder or the specified encoder to encode the two different types of values.

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

Returns a new encoder that can accepts an Either[A, B] to either, and uses either this encoder or the specified encoder to encode the two different types of values.

Returns a new encoder that can accepts an Either[A, B] to either, and uses either this encoder or the specified encoder to encode the two different types of values.

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

Returns a new encoder that can accepts an Either[A, B] to either, and uses either this encoder or the specified encoder to encode the two different types of values.

Returns a new encoder that can accepts an Either[A, B] to either, and uses either this encoder or the specified encoder to encode the two different types of values.

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

Returns a new encoder that can accepts an Either[A, B] to either, and uses either this encoder or the specified encoder to encode the two different types of values.

Returns a new encoder that can accepts an Either[A, B] to either, and uses either this encoder or the specified encoder to encode the two different types of values.

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

Returns a new encoder that can accepts an Either[A, B] to either, and uses either this encoder or the specified encoder to encode the two different types of values.

Returns a new encoder that can accepts an Either[A, B] to either, and uses either this encoder or the specified encoder to encode the two different types of values.

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

Returns a new encoder that can accepts an Either[A, B] to either, and uses either this encoder or the specified encoder to encode the two different types of values.

Returns a new encoder that can accepts an Either[A, B] to either, and uses either this encoder or the specified encoder to encode the two different types of values.

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

Returns a new encoder that can accepts an Either[A, B] to either, and uses either this encoder or the specified encoder to encode the two different types of values.

Returns a new encoder that can accepts an Either[A, B] to either, and uses either this encoder or the specified encoder to encode the two different types of values.

final def either[B](that: => JsonEncoder[B]): JsonEncoder[Either[A, B]]
Implicitly added by treeSet

Returns a new encoder that can accepts an Either[A, B] to either, and uses either this encoder or the specified encoder to encode the two different types of values.

Returns a new encoder that can accepts an Either[A, B] to either, and uses either this encoder or the specified encoder to encode the two different types of values.

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

Returns a new encoder that can accepts an Either[A, B] to either, and uses either this encoder or the specified encoder to encode the two different types of values.

Returns a new encoder that can accepts an Either[A, B] to either, and uses either this encoder or the specified encoder to encode the two different types of values.

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

Returns a new encoder that can accepts an Either[A, B] to either, and uses either this encoder or the specified encoder to encode the two different types of values.

Returns a new encoder that can accepts an Either[A, B] to either, and uses either this encoder or the specified encoder to encode the two different types of values.

final def either[B](that: => JsonEncoder[B]): JsonEncoder[Either[A, B]]

Returns a new encoder that can accepts an Either[A, B] to either, and uses either this encoder or the specified encoder to encode the two different types of values.

Returns a new encoder that can accepts an Either[A, B] to either, and uses either this encoder or the specified encoder to encode the two different types of values.

final def eitherWith[B, C](that: => JsonEncoder[B])(f: C => Either[A, B]): JsonEncoder[C]
Implicitly added by chunk

Returns a new encoder with a new input type, which can be transformed to either the input type of this encoder, or the input type of the specified encoder, using the user-defined transformation function.

Returns a new encoder with a new input type, which can be transformed to either the input type of this encoder, or the input type of the specified encoder, using the user-defined transformation function.

final def eitherWith[B, C](that: => JsonEncoder[B])(f: C => Either[A, B]): JsonEncoder[C]
Implicitly added by hashSet

Returns a new encoder with a new input type, which can be transformed to either the input type of this encoder, or the input type of the specified encoder, using the user-defined transformation function.

Returns a new encoder with a new input type, which can be transformed to either the input type of this encoder, or the input type of the specified encoder, using the user-defined transformation function.

final def eitherWith[B, C](that: => JsonEncoder[B])(f: C => Either[A, B]): JsonEncoder[C]
Implicitly added by indexedSeq

Returns a new encoder with a new input type, which can be transformed to either the input type of this encoder, or the input type of the specified encoder, using the user-defined transformation function.

Returns a new encoder with a new input type, which can be transformed to either the input type of this encoder, or the input type of the specified encoder, using the user-defined transformation function.

final def eitherWith[B, C](that: => JsonEncoder[B])(f: C => Either[A, B]): JsonEncoder[C]
Implicitly added by iterable

Returns a new encoder with a new input type, which can be transformed to either the input type of this encoder, or the input type of the specified encoder, using the user-defined transformation function.

Returns a new encoder with a new input type, which can be transformed to either the input type of this encoder, or the input type of the specified encoder, using the user-defined transformation function.

final def eitherWith[B, C](that: => JsonEncoder[B])(f: C => Either[A, B]): JsonEncoder[C]
Implicitly added by linearSeq

Returns a new encoder with a new input type, which can be transformed to either the input type of this encoder, or the input type of the specified encoder, using the user-defined transformation function.

Returns a new encoder with a new input type, which can be transformed to either the input type of this encoder, or the input type of the specified encoder, using the user-defined transformation function.

final def eitherWith[B, C](that: => JsonEncoder[B])(f: C => Either[A, B]): JsonEncoder[C]
Implicitly added by list

Returns a new encoder with a new input type, which can be transformed to either the input type of this encoder, or the input type of the specified encoder, using the user-defined transformation function.

Returns a new encoder with a new input type, which can be transformed to either the input type of this encoder, or the input type of the specified encoder, using the user-defined transformation function.

final def eitherWith[B, C](that: => JsonEncoder[B])(f: C => Either[A, B]): JsonEncoder[C]
Implicitly added by listSet

Returns a new encoder with a new input type, which can be transformed to either the input type of this encoder, or the input type of the specified encoder, using the user-defined transformation function.

Returns a new encoder with a new input type, which can be transformed to either the input type of this encoder, or the input type of the specified encoder, using the user-defined transformation function.

final def eitherWith[B, C](that: => JsonEncoder[B])(f: C => Either[A, B]): JsonEncoder[C]
Implicitly added by nonEmptyChunk

Returns a new encoder with a new input type, which can be transformed to either the input type of this encoder, or the input type of the specified encoder, using the user-defined transformation function.

Returns a new encoder with a new input type, which can be transformed to either the input type of this encoder, or the input type of the specified encoder, using the user-defined transformation function.

final def eitherWith[B, C](that: => JsonEncoder[B])(f: C => Either[A, B]): JsonEncoder[C]
Implicitly added by option

Returns a new encoder with a new input type, which can be transformed to either the input type of this encoder, or the input type of the specified encoder, using the user-defined transformation function.

Returns a new encoder with a new input type, which can be transformed to either the input type of this encoder, or the input type of the specified encoder, using the user-defined transformation function.

final def eitherWith[B, C](that: => JsonEncoder[B])(f: C => Either[A, B]): JsonEncoder[C]
Implicitly added by seq

Returns a new encoder with a new input type, which can be transformed to either the input type of this encoder, or the input type of the specified encoder, using the user-defined transformation function.

Returns a new encoder with a new input type, which can be transformed to either the input type of this encoder, or the input type of the specified encoder, using the user-defined transformation function.

final def eitherWith[B, C](that: => JsonEncoder[B])(f: C => Either[A, B]): JsonEncoder[C]
Implicitly added by set

Returns a new encoder with a new input type, which can be transformed to either the input type of this encoder, or the input type of the specified encoder, using the user-defined transformation function.

Returns a new encoder with a new input type, which can be transformed to either the input type of this encoder, or the input type of the specified encoder, using the user-defined transformation function.

final def eitherWith[B, C](that: => JsonEncoder[B])(f: C => Either[A, B]): JsonEncoder[C]
Implicitly added by treeSet

Returns a new encoder with a new input type, which can be transformed to either the input type of this encoder, or the input type of the specified encoder, using the user-defined transformation function.

Returns a new encoder with a new input type, which can be transformed to either the input type of this encoder, or the input type of the specified encoder, using the user-defined transformation function.

final def eitherWith[B, C](that: => JsonEncoder[B])(f: C => Either[A, B]): JsonEncoder[C]
Implicitly added by tuple1

Returns a new encoder with a new input type, which can be transformed to either the input type of this encoder, or the input type of the specified encoder, using the user-defined transformation function.

Returns a new encoder with a new input type, which can be transformed to either the input type of this encoder, or the input type of the specified encoder, using the user-defined transformation function.

final def eitherWith[B, C](that: => JsonEncoder[B])(f: C => Either[A, B]): JsonEncoder[C]
Implicitly added by vector

Returns a new encoder with a new input type, which can be transformed to either the input type of this encoder, or the input type of the specified encoder, using the user-defined transformation function.

Returns a new encoder with a new input type, which can be transformed to either the input type of this encoder, or the input type of the specified encoder, using the user-defined transformation function.

final def eitherWith[B, C](that: => JsonEncoder[B])(f: C => Either[A, B]): JsonEncoder[C]

Returns a new encoder with a new input type, which can be transformed to either the input type of this encoder, or the input type of the specified encoder, using the user-defined transformation function.

Returns a new encoder with a new input type, which can be transformed to either the input type of this encoder, or the input type of the specified encoder, using the user-defined transformation function.

final def encodeJson(a: A, indent: Option[Int]): CharSequence
Implicitly added by chunk

Encodes the specified value into a JSON string, with the specified indentation level.

Encodes the specified value into a JSON string, with the specified indentation level.

final def encodeJson(a: A, indent: Option[Int]): CharSequence
Implicitly added by hashSet

Encodes the specified value into a JSON string, with the specified indentation level.

Encodes the specified value into a JSON string, with the specified indentation level.

final def encodeJson(a: A, indent: Option[Int]): CharSequence
Implicitly added by indexedSeq

Encodes the specified value into a JSON string, with the specified indentation level.

Encodes the specified value into a JSON string, with the specified indentation level.

final def encodeJson(a: A, indent: Option[Int]): CharSequence
Implicitly added by iterable

Encodes the specified value into a JSON string, with the specified indentation level.

Encodes the specified value into a JSON string, with the specified indentation level.

final def encodeJson(a: A, indent: Option[Int]): CharSequence
Implicitly added by linearSeq

Encodes the specified value into a JSON string, with the specified indentation level.

Encodes the specified value into a JSON string, with the specified indentation level.

final def encodeJson(a: A, indent: Option[Int]): CharSequence
Implicitly added by list

Encodes the specified value into a JSON string, with the specified indentation level.

Encodes the specified value into a JSON string, with the specified indentation level.

final def encodeJson(a: A, indent: Option[Int]): CharSequence
Implicitly added by listSet

Encodes the specified value into a JSON string, with the specified indentation level.

Encodes the specified value into a JSON string, with the specified indentation level.

final def encodeJson(a: A, indent: Option[Int]): CharSequence
Implicitly added by nonEmptyChunk

Encodes the specified value into a JSON string, with the specified indentation level.

Encodes the specified value into a JSON string, with the specified indentation level.

final def encodeJson(a: A, indent: Option[Int]): CharSequence
Implicitly added by option

Encodes the specified value into a JSON string, with the specified indentation level.

Encodes the specified value into a JSON string, with the specified indentation level.

final def encodeJson(a: A, indent: Option[Int]): CharSequence
Implicitly added by seq

Encodes the specified value into a JSON string, with the specified indentation level.

Encodes the specified value into a JSON string, with the specified indentation level.

final def encodeJson(a: A, indent: Option[Int]): CharSequence
Implicitly added by set

Encodes the specified value into a JSON string, with the specified indentation level.

Encodes the specified value into a JSON string, with the specified indentation level.

final def encodeJson(a: A, indent: Option[Int]): CharSequence
Implicitly added by treeSet

Encodes the specified value into a JSON string, with the specified indentation level.

Encodes the specified value into a JSON string, with the specified indentation level.

final def encodeJson(a: A, indent: Option[Int]): CharSequence
Implicitly added by tuple1

Encodes the specified value into a JSON string, with the specified indentation level.

Encodes the specified value into a JSON string, with the specified indentation level.

final def encodeJson(a: A, indent: Option[Int]): CharSequence
Implicitly added by vector

Encodes the specified value into a JSON string, with the specified indentation level.

Encodes the specified value into a JSON string, with the specified indentation level.

final def encodeJson(a: A, indent: Option[Int]): CharSequence

Encodes the specified value into a JSON string, with the specified indentation level.

Encodes the specified value into a JSON string, with the specified indentation level.

@nowarn("msg=is never used")
def isNothing(a: A): Boolean
Implicitly added by chunk

This default may be overriden when this value may be missing within a JSON object and still be encoded.

This default may be overriden when this value may be missing within a JSON object and still be encoded.

@nowarn("msg=is never used")
def isNothing(a: A): Boolean
Implicitly added by hashSet

This default may be overriden when this value may be missing within a JSON object and still be encoded.

This default may be overriden when this value may be missing within a JSON object and still be encoded.

@nowarn("msg=is never used")
def isNothing(a: A): Boolean
Implicitly added by indexedSeq

This default may be overriden when this value may be missing within a JSON object and still be encoded.

This default may be overriden when this value may be missing within a JSON object and still be encoded.

@nowarn("msg=is never used")
def isNothing(a: A): Boolean
Implicitly added by iterable

This default may be overriden when this value may be missing within a JSON object and still be encoded.

This default may be overriden when this value may be missing within a JSON object and still be encoded.

@nowarn("msg=is never used")
def isNothing(a: A): Boolean
Implicitly added by linearSeq

This default may be overriden when this value may be missing within a JSON object and still be encoded.

This default may be overriden when this value may be missing within a JSON object and still be encoded.

@nowarn("msg=is never used")
def isNothing(a: A): Boolean
Implicitly added by list

This default may be overriden when this value may be missing within a JSON object and still be encoded.

This default may be overriden when this value may be missing within a JSON object and still be encoded.

@nowarn("msg=is never used")
def isNothing(a: A): Boolean
Implicitly added by listSet

This default may be overriden when this value may be missing within a JSON object and still be encoded.

This default may be overriden when this value may be missing within a JSON object and still be encoded.

@nowarn("msg=is never used")
def isNothing(a: A): Boolean
Implicitly added by nonEmptyChunk

This default may be overriden when this value may be missing within a JSON object and still be encoded.

This default may be overriden when this value may be missing within a JSON object and still be encoded.

@nowarn("msg=is never used")
def isNothing(a: A): Boolean
Implicitly added by option

This default may be overriden when this value may be missing within a JSON object and still be encoded.

This default may be overriden when this value may be missing within a JSON object and still be encoded.

@nowarn("msg=is never used")
def isNothing(a: A): Boolean
Implicitly added by seq

This default may be overriden when this value may be missing within a JSON object and still be encoded.

This default may be overriden when this value may be missing within a JSON object and still be encoded.

@nowarn("msg=is never used")
def isNothing(a: A): Boolean
Implicitly added by set

This default may be overriden when this value may be missing within a JSON object and still be encoded.

This default may be overriden when this value may be missing within a JSON object and still be encoded.

@nowarn("msg=is never used")
def isNothing(a: A): Boolean
Implicitly added by treeSet

This default may be overriden when this value may be missing within a JSON object and still be encoded.

This default may be overriden when this value may be missing within a JSON object and still be encoded.

@nowarn("msg=is never used")
def isNothing(a: A): Boolean
Implicitly added by tuple1

This default may be overriden when this value may be missing within a JSON object and still be encoded.

This default may be overriden when this value may be missing within a JSON object and still be encoded.

@nowarn("msg=is never used")
def isNothing(a: A): Boolean
Implicitly added by vector

This default may be overriden when this value may be missing within a JSON object and still be encoded.

This default may be overriden when this value may be missing within a JSON object and still be encoded.

@nowarn("msg=is never used")
def isNothing(a: A): Boolean

This default may be overriden when this value may be missing within a JSON object and still be encoded.

This default may be overriden when this value may be missing within a JSON object and still be encoded.

final def narrow[B <: A]: JsonEncoder[B]
Implicitly added by chunk

Returns this encoder but narrowed to the its given sub-type

Returns this encoder but narrowed to the its given sub-type

final def narrow[B <: A]: JsonEncoder[B]
Implicitly added by hashSet

Returns this encoder but narrowed to the its given sub-type

Returns this encoder but narrowed to the its given sub-type

final def narrow[B <: A]: JsonEncoder[B]
Implicitly added by indexedSeq

Returns this encoder but narrowed to the its given sub-type

Returns this encoder but narrowed to the its given sub-type

final def narrow[B <: A]: JsonEncoder[B]
Implicitly added by iterable

Returns this encoder but narrowed to the its given sub-type

Returns this encoder but narrowed to the its given sub-type

final def narrow[B <: A]: JsonEncoder[B]
Implicitly added by linearSeq

Returns this encoder but narrowed to the its given sub-type

Returns this encoder but narrowed to the its given sub-type

final def narrow[B <: A]: JsonEncoder[B]
Implicitly added by list

Returns this encoder but narrowed to the its given sub-type

Returns this encoder but narrowed to the its given sub-type

final def narrow[B <: A]: JsonEncoder[B]
Implicitly added by listSet

Returns this encoder but narrowed to the its given sub-type

Returns this encoder but narrowed to the its given sub-type

final def narrow[B <: A]: JsonEncoder[B]
Implicitly added by nonEmptyChunk

Returns this encoder but narrowed to the its given sub-type

Returns this encoder but narrowed to the its given sub-type

final def narrow[B <: A]: JsonEncoder[B]
Implicitly added by option

Returns this encoder but narrowed to the its given sub-type

Returns this encoder but narrowed to the its given sub-type

final def narrow[B <: A]: JsonEncoder[B]
Implicitly added by seq

Returns this encoder but narrowed to the its given sub-type

Returns this encoder but narrowed to the its given sub-type

final def narrow[B <: A]: JsonEncoder[B]
Implicitly added by set

Returns this encoder but narrowed to the its given sub-type

Returns this encoder but narrowed to the its given sub-type

final def narrow[B <: A]: JsonEncoder[B]
Implicitly added by treeSet

Returns this encoder but narrowed to the its given sub-type

Returns this encoder but narrowed to the its given sub-type

final def narrow[B <: A]: JsonEncoder[B]
Implicitly added by tuple1

Returns this encoder but narrowed to the its given sub-type

Returns this encoder but narrowed to the its given sub-type

final def narrow[B <: A]: JsonEncoder[B]
Implicitly added by vector

Returns this encoder but narrowed to the its given sub-type

Returns this encoder but narrowed to the its given sub-type

final def narrow[B <: A]: JsonEncoder[B]

Returns this encoder but narrowed to the its given sub-type

Returns this encoder but narrowed to the its given sub-type

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

Returns a new encoder that can accepts an Either[A, B] to either, and uses either this encoder or the specified encoder to encode the two different types of values. The difference with the classic either encoder is that the resulting JSON has no field Left or Right. What should be: {"Right": "John Doe"} is encoded as "John Doe"

Returns a new encoder that can accepts an Either[A, B] to either, and uses either this encoder or the specified encoder to encode the two different types of values. The difference with the classic either encoder is that the resulting JSON has no field Left or Right. What should be: {"Right": "John Doe"} is encoded as "John Doe"

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

Returns a new encoder that can accepts an Either[A, B] to either, and uses either this encoder or the specified encoder to encode the two different types of values. The difference with the classic either encoder is that the resulting JSON has no field Left or Right. What should be: {"Right": "John Doe"} is encoded as "John Doe"

Returns a new encoder that can accepts an Either[A, B] to either, and uses either this encoder or the specified encoder to encode the two different types of values. The difference with the classic either encoder is that the resulting JSON has no field Left or Right. What should be: {"Right": "John Doe"} is encoded as "John Doe"

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

Returns a new encoder that can accepts an Either[A, B] to either, and uses either this encoder or the specified encoder to encode the two different types of values. The difference with the classic either encoder is that the resulting JSON has no field Left or Right. What should be: {"Right": "John Doe"} is encoded as "John Doe"

Returns a new encoder that can accepts an Either[A, B] to either, and uses either this encoder or the specified encoder to encode the two different types of values. The difference with the classic either encoder is that the resulting JSON has no field Left or Right. What should be: {"Right": "John Doe"} is encoded as "John Doe"

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

Returns a new encoder that can accepts an Either[A, B] to either, and uses either this encoder or the specified encoder to encode the two different types of values. The difference with the classic either encoder is that the resulting JSON has no field Left or Right. What should be: {"Right": "John Doe"} is encoded as "John Doe"

Returns a new encoder that can accepts an Either[A, B] to either, and uses either this encoder or the specified encoder to encode the two different types of values. The difference with the classic either encoder is that the resulting JSON has no field Left or Right. What should be: {"Right": "John Doe"} is encoded as "John Doe"

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

Returns a new encoder that can accepts an Either[A, B] to either, and uses either this encoder or the specified encoder to encode the two different types of values. The difference with the classic either encoder is that the resulting JSON has no field Left or Right. What should be: {"Right": "John Doe"} is encoded as "John Doe"

Returns a new encoder that can accepts an Either[A, B] to either, and uses either this encoder or the specified encoder to encode the two different types of values. The difference with the classic either encoder is that the resulting JSON has no field Left or Right. What should be: {"Right": "John Doe"} is encoded as "John Doe"

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

Returns a new encoder that can accepts an Either[A, B] to either, and uses either this encoder or the specified encoder to encode the two different types of values. The difference with the classic either encoder is that the resulting JSON has no field Left or Right. What should be: {"Right": "John Doe"} is encoded as "John Doe"

Returns a new encoder that can accepts an Either[A, B] to either, and uses either this encoder or the specified encoder to encode the two different types of values. The difference with the classic either encoder is that the resulting JSON has no field Left or Right. What should be: {"Right": "John Doe"} is encoded as "John Doe"

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

Returns a new encoder that can accepts an Either[A, B] to either, and uses either this encoder or the specified encoder to encode the two different types of values. The difference with the classic either encoder is that the resulting JSON has no field Left or Right. What should be: {"Right": "John Doe"} is encoded as "John Doe"

Returns a new encoder that can accepts an Either[A, B] to either, and uses either this encoder or the specified encoder to encode the two different types of values. The difference with the classic either encoder is that the resulting JSON has no field Left or Right. What should be: {"Right": "John Doe"} is encoded as "John Doe"

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

Returns a new encoder that can accepts an Either[A, B] to either, and uses either this encoder or the specified encoder to encode the two different types of values. The difference with the classic either encoder is that the resulting JSON has no field Left or Right. What should be: {"Right": "John Doe"} is encoded as "John Doe"

Returns a new encoder that can accepts an Either[A, B] to either, and uses either this encoder or the specified encoder to encode the two different types of values. The difference with the classic either encoder is that the resulting JSON has no field Left or Right. What should be: {"Right": "John Doe"} is encoded as "John Doe"

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

Returns a new encoder that can accepts an Either[A, B] to either, and uses either this encoder or the specified encoder to encode the two different types of values. The difference with the classic either encoder is that the resulting JSON has no field Left or Right. What should be: {"Right": "John Doe"} is encoded as "John Doe"

Returns a new encoder that can accepts an Either[A, B] to either, and uses either this encoder or the specified encoder to encode the two different types of values. The difference with the classic either encoder is that the resulting JSON has no field Left or Right. What should be: {"Right": "John Doe"} is encoded as "John Doe"

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

Returns a new encoder that can accepts an Either[A, B] to either, and uses either this encoder or the specified encoder to encode the two different types of values. The difference with the classic either encoder is that the resulting JSON has no field Left or Right. What should be: {"Right": "John Doe"} is encoded as "John Doe"

Returns a new encoder that can accepts an Either[A, B] to either, and uses either this encoder or the specified encoder to encode the two different types of values. The difference with the classic either encoder is that the resulting JSON has no field Left or Right. What should be: {"Right": "John Doe"} is encoded as "John Doe"

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

Returns a new encoder that can accepts an Either[A, B] to either, and uses either this encoder or the specified encoder to encode the two different types of values. The difference with the classic either encoder is that the resulting JSON has no field Left or Right. What should be: {"Right": "John Doe"} is encoded as "John Doe"

Returns a new encoder that can accepts an Either[A, B] to either, and uses either this encoder or the specified encoder to encode the two different types of values. The difference with the classic either encoder is that the resulting JSON has no field Left or Right. What should be: {"Right": "John Doe"} is encoded as "John Doe"

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

Returns a new encoder that can accepts an Either[A, B] to either, and uses either this encoder or the specified encoder to encode the two different types of values. The difference with the classic either encoder is that the resulting JSON has no field Left or Right. What should be: {"Right": "John Doe"} is encoded as "John Doe"

Returns a new encoder that can accepts an Either[A, B] to either, and uses either this encoder or the specified encoder to encode the two different types of values. The difference with the classic either encoder is that the resulting JSON has no field Left or Right. What should be: {"Right": "John Doe"} is encoded as "John Doe"

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

Returns a new encoder that can accepts an Either[A, B] to either, and uses either this encoder or the specified encoder to encode the two different types of values. The difference with the classic either encoder is that the resulting JSON has no field Left or Right. What should be: {"Right": "John Doe"} is encoded as "John Doe"

Returns a new encoder that can accepts an Either[A, B] to either, and uses either this encoder or the specified encoder to encode the two different types of values. The difference with the classic either encoder is that the resulting JSON has no field Left or Right. What should be: {"Right": "John Doe"} is encoded as "John Doe"

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

Returns a new encoder that can accepts an Either[A, B] to either, and uses either this encoder or the specified encoder to encode the two different types of values. The difference with the classic either encoder is that the resulting JSON has no field Left or Right. What should be: {"Right": "John Doe"} is encoded as "John Doe"

Returns a new encoder that can accepts an Either[A, B] to either, and uses either this encoder or the specified encoder to encode the two different types of values. The difference with the classic either encoder is that the resulting JSON has no field Left or Right. What should be: {"Right": "John Doe"} is encoded as "John Doe"

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

Returns a new encoder that can accepts an Either[A, B] to either, and uses either this encoder or the specified encoder to encode the two different types of values. The difference with the classic either encoder is that the resulting JSON has no field Left or Right. What should be: {"Right": "John Doe"} is encoded as "John Doe"

Returns a new encoder that can accepts an Either[A, B] to either, and uses either this encoder or the specified encoder to encode the two different types of values. The difference with the classic either encoder is that the resulting JSON has no field Left or Right. What should be: {"Right": "John Doe"} is encoded as "John Doe"

def toJsonAST(a: A): Either[String, Json]
Implicitly added by chunk

Converts a value to a Json AST

Converts a value to a Json AST

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

def toJsonAST(a: A): Either[String, Json]
Implicitly added by hashSet

Converts a value to a Json AST

Converts a value to a Json AST

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

def toJsonAST(a: A): Either[String, Json]
Implicitly added by indexedSeq

Converts a value to a Json AST

Converts a value to a Json AST

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

def toJsonAST(a: A): Either[String, Json]
Implicitly added by iterable

Converts a value to a Json AST

Converts a value to a Json AST

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

def toJsonAST(a: A): Either[String, Json]
Implicitly added by linearSeq

Converts a value to a Json AST

Converts a value to a Json AST

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

def toJsonAST(a: A): Either[String, Json]
Implicitly added by list

Converts a value to a Json AST

Converts a value to a Json AST

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

def toJsonAST(a: A): Either[String, Json]
Implicitly added by listSet

Converts a value to a Json AST

Converts a value to a Json AST

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

def toJsonAST(a: A): Either[String, Json]
Implicitly added by nonEmptyChunk

Converts a value to a Json AST

Converts a value to a Json AST

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

def toJsonAST(a: A): Either[String, Json]
Implicitly added by option

Converts a value to a Json AST

Converts a value to a Json AST

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

def toJsonAST(a: A): Either[String, Json]
Implicitly added by seq

Converts a value to a Json AST

Converts a value to a Json AST

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

def toJsonAST(a: A): Either[String, Json]
Implicitly added by set

Converts a value to a Json AST

Converts a value to a Json AST

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

def toJsonAST(a: A): Either[String, Json]
Implicitly added by treeSet

Converts a value to a Json AST

Converts a value to a Json AST

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

def toJsonAST(a: A): Either[String, Json]
Implicitly added by tuple1

Converts a value to a Json AST

Converts a value to a Json AST

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

def toJsonAST(a: A): Either[String, Json]
Implicitly added by vector

Converts a value to a Json AST

Converts a value to a Json AST

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

def toJsonAST(a: A): Either[String, Json]

Converts a value to a Json AST

Converts a value to a Json AST

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

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

Returns a new encoder that is capable of encoding a tuple containing the values of this encoder and the specified encoder.

Returns a new encoder that is capable of encoding a tuple containing the values of this encoder and the specified encoder.

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

Returns a new encoder that is capable of encoding a tuple containing the values of this encoder and the specified encoder.

Returns a new encoder that is capable of encoding a tuple containing the values of this encoder and the specified encoder.

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

Returns a new encoder that is capable of encoding a tuple containing the values of this encoder and the specified encoder.

Returns a new encoder that is capable of encoding a tuple containing the values of this encoder and the specified encoder.

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

Returns a new encoder that is capable of encoding a tuple containing the values of this encoder and the specified encoder.

Returns a new encoder that is capable of encoding a tuple containing the values of this encoder and the specified encoder.

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

Returns a new encoder that is capable of encoding a tuple containing the values of this encoder and the specified encoder.

Returns a new encoder that is capable of encoding a tuple containing the values of this encoder and the specified encoder.

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

Returns a new encoder that is capable of encoding a tuple containing the values of this encoder and the specified encoder.

Returns a new encoder that is capable of encoding a tuple containing the values of this encoder and the specified encoder.

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

Returns a new encoder that is capable of encoding a tuple containing the values of this encoder and the specified encoder.

Returns a new encoder that is capable of encoding a tuple containing the values of this encoder and the specified encoder.

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

Returns a new encoder that is capable of encoding a tuple containing the values of this encoder and the specified encoder.

Returns a new encoder that is capable of encoding a tuple containing the values of this encoder and the specified encoder.

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

Returns a new encoder that is capable of encoding a tuple containing the values of this encoder and the specified encoder.

Returns a new encoder that is capable of encoding a tuple containing the values of this encoder and the specified encoder.

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

Returns a new encoder that is capable of encoding a tuple containing the values of this encoder and the specified encoder.

Returns a new encoder that is capable of encoding a tuple containing the values of this encoder and the specified encoder.

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

Returns a new encoder that is capable of encoding a tuple containing the values of this encoder and the specified encoder.

Returns a new encoder that is capable of encoding a tuple containing the values of this encoder and the specified encoder.

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

Returns a new encoder that is capable of encoding a tuple containing the values of this encoder and the specified encoder.

Returns a new encoder that is capable of encoding a tuple containing the values of this encoder and the specified encoder.

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

Returns a new encoder that is capable of encoding a tuple containing the values of this encoder and the specified encoder.

Returns a new encoder that is capable of encoding a tuple containing the values of this encoder and the specified encoder.

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

Returns a new encoder that is capable of encoding a tuple containing the values of this encoder and the specified encoder.

Returns a new encoder that is capable of encoding a tuple containing the values of this encoder and the specified encoder.

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

Returns a new encoder that is capable of encoding a tuple containing the values of this encoder and the specified encoder.

Returns a new encoder that is capable of encoding a tuple containing the values of this encoder and the specified encoder.

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

Returns a new encoder that is capable of encoding a user-defined value, which is create from a tuple of the values of this encoder and the specified encoder, from the specified user- defined function.

Returns a new encoder that is capable of encoding a user-defined value, which is create from a tuple of the values of this encoder and the specified encoder, from the specified user- defined function.

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

Returns a new encoder that is capable of encoding a user-defined value, which is create from a tuple of the values of this encoder and the specified encoder, from the specified user- defined function.

Returns a new encoder that is capable of encoding a user-defined value, which is create from a tuple of the values of this encoder and the specified encoder, from the specified user- defined function.

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

Returns a new encoder that is capable of encoding a user-defined value, which is create from a tuple of the values of this encoder and the specified encoder, from the specified user- defined function.

Returns a new encoder that is capable of encoding a user-defined value, which is create from a tuple of the values of this encoder and the specified encoder, from the specified user- defined function.

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

Returns a new encoder that is capable of encoding a user-defined value, which is create from a tuple of the values of this encoder and the specified encoder, from the specified user- defined function.

Returns a new encoder that is capable of encoding a user-defined value, which is create from a tuple of the values of this encoder and the specified encoder, from the specified user- defined function.

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

Returns a new encoder that is capable of encoding a user-defined value, which is create from a tuple of the values of this encoder and the specified encoder, from the specified user- defined function.

Returns a new encoder that is capable of encoding a user-defined value, which is create from a tuple of the values of this encoder and the specified encoder, from the specified user- defined function.

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

Returns a new encoder that is capable of encoding a user-defined value, which is create from a tuple of the values of this encoder and the specified encoder, from the specified user- defined function.

Returns a new encoder that is capable of encoding a user-defined value, which is create from a tuple of the values of this encoder and the specified encoder, from the specified user- defined function.

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

Returns a new encoder that is capable of encoding a user-defined value, which is create from a tuple of the values of this encoder and the specified encoder, from the specified user- defined function.

Returns a new encoder that is capable of encoding a user-defined value, which is create from a tuple of the values of this encoder and the specified encoder, from the specified user- defined function.

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

Returns a new encoder that is capable of encoding a user-defined value, which is create from a tuple of the values of this encoder and the specified encoder, from the specified user- defined function.

Returns a new encoder that is capable of encoding a user-defined value, which is create from a tuple of the values of this encoder and the specified encoder, from the specified user- defined function.

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

Returns a new encoder that is capable of encoding a user-defined value, which is create from a tuple of the values of this encoder and the specified encoder, from the specified user- defined function.

Returns a new encoder that is capable of encoding a user-defined value, which is create from a tuple of the values of this encoder and the specified encoder, from the specified user- defined function.

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

Returns a new encoder that is capable of encoding a user-defined value, which is create from a tuple of the values of this encoder and the specified encoder, from the specified user- defined function.

Returns a new encoder that is capable of encoding a user-defined value, which is create from a tuple of the values of this encoder and the specified encoder, from the specified user- defined function.

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

Returns a new encoder that is capable of encoding a user-defined value, which is create from a tuple of the values of this encoder and the specified encoder, from the specified user- defined function.

Returns a new encoder that is capable of encoding a user-defined value, which is create from a tuple of the values of this encoder and the specified encoder, from the specified user- defined function.

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

Returns a new encoder that is capable of encoding a user-defined value, which is create from a tuple of the values of this encoder and the specified encoder, from the specified user- defined function.

Returns a new encoder that is capable of encoding a user-defined value, which is create from a tuple of the values of this encoder and the specified encoder, from the specified user- defined function.

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

Returns a new encoder that is capable of encoding a user-defined value, which is create from a tuple of the values of this encoder and the specified encoder, from the specified user- defined function.

Returns a new encoder that is capable of encoding a user-defined value, which is create from a tuple of the values of this encoder and the specified encoder, from the specified user- defined function.

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

Returns a new encoder that is capable of encoding a user-defined value, which is create from a tuple of the values of this encoder and the specified encoder, from the specified user- defined function.

Returns a new encoder that is capable of encoding a user-defined value, which is create from a tuple of the values of this encoder and the specified encoder, from the specified user- defined function.

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

Returns a new encoder that is capable of encoding a user-defined value, which is create from a tuple of the values of this encoder and the specified encoder, from the specified user- defined function.

Returns a new encoder that is capable of encoding a user-defined value, which is create from a tuple of the values of this encoder and the specified encoder, from the specified user- defined function.