JsonSchemas

An algebra interface for describing algebraic data types. Such descriptions can be interpreted to produce a JSON schema of the data type, a JSON encoder, a JSON decoder, etc.

A description contains the fields of a case class and their type, and the constructor names of a sealed trait.

For instance, consider the following record type:

case class User(name: String, age: Int)

Its description is the following:

object User {
implicit val schema: JsonSchema[User] = (
  field[String]("name") zip
  field[Int]("age")
).invmap((User.apply _).tupled)(Function.unlift(User.unapply))
}

The description says that the record type has two fields, the first one has type String and is named “name”, and the second one has type Int and name “age”.

To describe sum types you have to explicitly “tag” each alternative:

sealed trait Shape
case class Circle(radius: Double) extends Shape
case class Rectangle(width: Double, height: Double) extends Shape

object Shape {
  implicit val schema: JsonSchema[Shape] = {
    val circleSchema = field[Double]("radius").invmap(Circle)(Function.unlift(Circle.unapply))
    val rectangleSchema = (
      field[Double]("width") zip
      field[Double]("height")
    ).invmap((Rectangle.apply _).tupled)(Function.unlift(Rectangle.unapply))
    (circleSchema.tagged("Circle") orElse rectangleSchema.tagged("Rectangle"))
      .invmap[Shape] {
        case Left(circle) => circle
        case Right(rect)  => rect
      } {
        c: Circle    => Left(c)
        r: Rectangle => Right(r)
      }
  }
}

Source: JsonSchemas.scala

Linear Supertypes

AnyRef, Any

Known Subclasses

JsonSchemas

Type Members

abstract type JsonSchema[A]

The JSON schema of a type A
implicit final class JsonSchemaOps[A] extends AnyRef

Convenient infix operations
abstract type Record[A] <: JsonSchema[A]

The JSON schema of a record type (case class) A
implicit final class RecordOps[A] extends AnyRef

Convenient infix operations
abstract type Tagged[A] <: JsonSchema[A]

A JSON schema containing the name of the type A.
A JSON schema containing the name of the type A. Tagged schemas are useful to describe sum types (sealed traits).
implicit final class TaggedOps[A] extends AnyRef

Abstract Value Members

implicit abstract def arrayJsonSchema[C[X] <: Seq[X], A](implicit jsonSchema: JsonSchema[A], cbf: CanBuildFrom[_, A, C[A]]): JsonSchema[C[A]]

A JSON schema for sequences
implicit abstract def bigdecimalJsonSchema: JsonSchema[BigDecimal]

A JSON schema for type BigDecimal
implicit abstract def booleanJsonSchema: JsonSchema[Boolean]

A JSON schema for type Boolean
abstract def choiceTagged[A, B](taggedA: Tagged[A], taggedB: Tagged[B]): Tagged[Either[A, B]]

The JSON schema of a coproduct made of the given alternative tagged records
implicit abstract def doubleJsonSchema: JsonSchema[Double]

A JSON schema for type Double
abstract def field[A](name: String, documentation: Option[String] = None)(implicit tpe: JsonSchema[A]): Record[A]

The JSON schema of a record with a single field name of type A
implicit abstract def intJsonSchema: JsonSchema[Int]

A JSON schema for type Int
abstract def invmapJsonSchema[A, B](jsonSchema: JsonSchema[A], f: (A) ⇒ B, g: (B) ⇒ A): JsonSchema[B]

Transforms the type of the JSON schema
abstract def invmapRecord[A, B](record: Record[A], f: (A) ⇒ B, g: (B) ⇒ A): Record[B]

Transforms the type of the JSON schema
abstract def invmapTagged[A, B](taggedA: Tagged[A], f: (A) ⇒ B, g: (B) ⇒ A): Tagged[B]

Transforms the type of the JSON schema
implicit abstract def longJsonSchema: JsonSchema[Long]

A JSON schema for type Long
abstract def optField[A](name: String, documentation: Option[String] = None)(implicit tpe: JsonSchema[A]): Record[Option[A]]

The JSON schema of a record with a single optional field name of type A
implicit abstract def stringJsonSchema: JsonSchema[String]

A JSON schema for type String
abstract def taggedRecord[A](recordA: Record[A], tag: String): Tagged[A]

Tags a schema for type A with the given tag name
abstract def zipRecords[A, B](recordA: Record[A], recordB: Record[B]): Record[(A, B)]

The JSON schema of a record merging the fields of the two given records

Concrete Value Members

final def !=(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def !=(arg0: Any): Boolean

Definition Classes
Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def ==(arg0: Any): Boolean

Definition Classes
Any
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )

trait JsonSchemas extends AnyRef

Type Members

abstract type JsonSchema[A]

implicit final class JsonSchemaOps[A] extends AnyRef

abstract type Record[A] <: JsonSchema[A]

implicit final class RecordOps[A] extends AnyRef

abstract type Tagged[A] <: JsonSchema[A]

implicit final class TaggedOps[A] extends AnyRef

Abstract Value Members

implicit abstract def arrayJsonSchema[C[X] <: Seq[X], A](implicit jsonSchema: JsonSchema[A], cbf: CanBuildFrom[_, A, C[A]]): JsonSchema[C[A]]

implicit abstract def bigdecimalJsonSchema: JsonSchema[BigDecimal]

implicit abstract def booleanJsonSchema: JsonSchema[Boolean]

abstract def choiceTagged[A, B](taggedA: Tagged[A], taggedB: Tagged[B]): Tagged[Either[A, B]]

implicit abstract def doubleJsonSchema: JsonSchema[Double]

abstract def field[A](name: String, documentation: Option[String] = None)(implicit tpe: JsonSchema[A]): Record[A]

implicit abstract def intJsonSchema: JsonSchema[Int]

abstract def invmapJsonSchema[A, B](jsonSchema: JsonSchema[A], f: (A) ⇒ B, g: (B) ⇒ A): JsonSchema[B]

abstract def invmapRecord[A, B](record: Record[A], f: (A) ⇒ B, g: (B) ⇒ A): Record[B]

abstract def invmapTagged[A, B](taggedA: Tagged[A], f: (A) ⇒ B, g: (B) ⇒ A): Tagged[B]

implicit abstract def longJsonSchema: JsonSchema[Long]

abstract def optField[A](name: String, documentation: Option[String] = None)(implicit tpe: JsonSchema[A]): Record[Option[A]]

implicit abstract def stringJsonSchema: JsonSchema[String]

abstract def taggedRecord[A](recordA: Record[A], tag: String): Tagged[A]

abstract def zipRecords[A, B](recordA: Record[A], recordB: Record[B]): Record[(A, B)]

Concrete Value Members

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

Inherited from AnyRef

Inherited from Any

Ungrouped