monix.newtypes

Signals a failed decoding operation, via HasBuilder.build.

For example, this can happen when decoding from JSON, this result being used to signal an issue with the JSON document.

Type-class used for decoding types.

Used for automatically deriving decoders (e.g. from JSON) for newtypes.

Type-class used for encoding types.

Used for automatically deriving encoders (e.g. to JSON) for newtypes.

Like Newtype, except as a subtype of the underlying type instead of as an entirely new type.

 type Level = Level.Type
 object Level extends NewsubtypeWrapped[Int]

 val level1: Level = Level(1)
 // This works too
 val level2: Int = Level(2)
 // This fails compilation
 // val level3: Level = 3

Similar to NewtypeCovariantK, except that the type created is a sub-type.

Similar to NewtypeK, except that the type created is a sub-type.

A validated Newsubtype.

This class is for defining newsubtypes with a builder that validates values.

Example:

 type EmailAddress = EmailAddress.Type

 object EmailAddress extends NewsubtypeValidated[String] {
   def apply(v: String): Either[BuildFailure[Type], Type] =
     if (v.contains("@"))
       Right(unsafeCoerce(v))
     else
       Left(BuildFailure[EmailAddress]("missing @"))
 }

Simple variant of Newsubtype that provides an apply builder.

Such newsubtypes are meant for simple wrappers that don't do any validation.

Usage:

 type FullName = FullName.Type

 object FullName extends NewsubtypeWrapped[String]

 // Initializing
 val name: FullName = FullName("Alexandru Nedelcu")
 // No need to extract the value when a string is needed:
 assert(name === "Alexandru Nedelcu")

 // We can pattern-match too:
 name match {
   case FullName(nameStr) =>
     assert(nameStr === "Alexandru Nedelcu")
 }

Base class for defining newtypes that have no type parameters.

This class does not define any "builder", or related HasBuilder instance, as you're expected to provide one yourself.

Usage sample:

 type EmailAddress = EmailAddress.Type

 object EmailAddress extends Newtype[String] { self =>
   def apply(value: String): Option[Type] =
     if (value.contains("@"))
       Some(unsafeCoerce(value))
     else
       None

   // Recommended instance, but not required;
   // use Newtype.Validated to get rid of this boilerplate ;-)
   implicit val builder: HasBuilder.Aux[EmailAddress, String] =
     new HasBuilder[EmailAddress] {
       type Source = String

       def build(v: String): Either[BuildFailure[Type], Type] =
         apply(v) match {
           case Some(r) =>
             Right(r)
           case None =>
             Left(BuildFailure[EmailAddress]("missing @"))
         }
     }
 }

For building newtypes over types that have a covariant type parameter (higher-kinded types).

Example:

 // Only needed for type-class derivation
 import cats._
 import cats.implicits._

 type NonEmptyList[A] = NonEmptyList.Type[A]

 object NonEmptyList extends NewtypeCovariantK[List] {
   def apply[A](head: A, tail: A*): NonEmptyList[A] =
     unsafeCoerce(head :: tail.toList)

   def unapply[F[_], A](list: F[A])(
     implicit ev: F[A] =:= NonEmptyList[A]
   ): Some[(A, List[A])] = {
     val l = value(list)
     Some((l.head, l.tail))
   }

   implicit def eq[A: Eq]: Eq[NonEmptyList[A]] = derive

   implicit val traverse: Traverse[NonEmptyList] = deriveK

   implicit val monad: Monad[NonEmptyList] = deriveK
 }

NOTE: the type-parameter is covariant.

For building newtypes over types that have an invariant type parameter (higher-kinded types).

Example:

 // Only needed for type-class derivation
 import cats._
 import cats.implicits._

 type Nel[A] = Nel.Type[A]

 object Nel extends NewtypeK[List] {
   def apply[A](head: A, tail: A*): Nel[A] =
     unsafeCoerce(head :: tail.toList)

   def unapply[F[_], A](list: F[A])(
     implicit ev: F[A] =:= Nel[A]
   ): Some[(A, List[A])] = {
     val l = value(list)
     Some((l.head, l.tail))
   }

   implicit def eq[A: Eq]: Eq[Nel[A]] = derive

   implicit val traverse: Traverse[Nel] = deriveK

   implicit val monad: Monad[Nel] = deriveK
 }

NOTE: the type-parameter is invariant. See NewtypeCovariantK for working with covariant type parameters.

A validated Newtype.

This class is for defining newtypes with a builder that validates values.

Example:

 type EmailAddress = EmailAddress.Type

 object EmailAddress extends NewtypeValidated[String] {
   def apply(v: String): Either[BuildFailure[Type], Type] =
     if (v.contains("@"))
       Right(unsafeCoerce(v))
     else
       Left(BuildFailure("missing @"))
 }

Simple variant of Newtype that provides an apply builder.

Such newtypes are meant for simple wrappers that don't do any validation.

Usage:

 type FullName = FullName.Type

 object FullName extends NewtypeWrapped[String]

 // Initializing
 val name: FullName = FullName("Alexandru Nedelcu")
 // Extracting the value when a string is needed:
 val nameStr: String = name.value
 assert(nameStr === "Alexandru Nedelcu")

 // We can pattern-match too:
 name match {
   case FullName(nameStr) =>
     assert(nameStr === "Alexandru Nedelcu")
 }

TypeInfo values are used as replacement for ClassTag, to extract type info at compile-time (name, package) and use that for debugging purposes (e.g. better error messages).