EndpointTransput

sealed

A transput is EITHER an input, or an output (see: https://ell.stackexchange.com/questions/21405/hypernym-for-input-and-output). The transput traits contain common functionality, shared by all inputs and outputs.

Note that implementations of EndpointIO can be used both as inputs and outputs.

The hierarchy is as follows:

                       /---> `EndpointInput`  >---\
`EndpointTransput` >---                            ---> `EndpointIO`
                       \---> `EndpointOutput` >---/

Inputs and outputs additionally form another hierarchy:

                                     /--> `Single` >--> `Basic` >--> `Atom`
`EndpointInput` / `EndpointOutput` >--
                                     \--> `Pair`

where the intuition behind the traits is:

  • single: represents a single value, as opposed to a pair (tuple); a pair, but transformed using .map is also a single value
  • basic: corresponds to an input/output which is encoded/decoded in one step; always single
  • atom: corresponds to a single component of a request or response. Such inputs/outputs contain a Codec and Info meta-data, and are always basic
Companion
object
class Object
trait Matchable
class Any
trait EndpointInput[T]
trait EndpointIO[T]
class Pair[T, U, TU]
trait Single[I]
trait Basic[I]
trait Atom[I]
class Body[R, T]
class Empty[T]
class FixedHeader[T]
class Header[T]
class Headers[T]
class StreamBodyWrapper[BS, T]
class OneOfBody[O, T]
class MappedPair[T, U, TU, V]
class Pair[T, U, TU]
trait Single[T]
class Auth[T, INFO]
trait Basic[T]
trait Atom[T]
class Cookie[T]
class FixedMethod[T]
class FixedPath[T]
class PathCapture[T]
class PathsCapture[T]
class Query[T]
class QueryParams[T]
class MappedPair[T, U, TU, V]
class Pair[T, U, TU]
trait Single[T]
trait Basic[T]
trait Atom[T]
class StatusCode[T]
class WebSocketBodyWrapper[PIPE_REQ_RESP, T]
class MappedPair[T, U, TU, V]
class OneOf[O, T]
class Void[T]
trait Basic[T]
trait Atom[T]
class StreamBodyIO[BS, T, S]
class WebSocketBodyOutput[PIPE_REQ_RESP, REQ, RESP, T, S]
trait Pair[T]

Value members

Abstract methods

def map[U](mapping: Mapping[T, U]): ThisType[U]
def show: String

Concrete methods

def map[U](f: T => U)(g: U => T): ThisType[U]
def mapDecode[U](f: T => DecodeResult[U])(g: U => T): ThisType[U]
def validate(v: Validator[T]): ThisType[T]

Inherited methods

inline
def mapTo[CASE_CLASS <: Product](using mc: ProductOf[CASE_CLASS]): ThisType[CASE_CLASS]