M&DE
main
DocsAPI
Generated with
made with ❤️ and coffee
made with ❤️ and coffee
M&DE/made

made

package made

Extended mirrors for Scala types, adding annotation metadata, element-level detail, and generated member support on top of standard scala.deriving.Mirror.

Derive a mirror with Made.derived[T]. The resulting mirror subtype depends on T: singletons, transparent wrappers, products (case classes), or sums (sealed traits/enums).

Each mirror carries a MirroredElems tuple of made.MadeElem subtypes describing constructor fields or sum subtypes, and a Metadata type member encoding annotations as an AnnotatedType chain around made.Meta.

Attributes

See also

Members list

Packages

package made.annotation

Annotation system for Made mirrors.

Annotation system for Made mirrors.

Annotations extending made.annotation.MetaAnnotation are refining annotations: they refine the type of the annotated element and are captured in the Metadata type member during Made.derived. Query them at runtime via hasAnnotation[A] and getAnnotation[A] on a Made instance.

Attributes

See also

Type members

Classlikes

object Default

Attributes

Companion
trait
Supertypes
class Object
trait Matchable
class Any
Self type
Default.type
trait Default[O] extends () => O

Type class providing a default "empty" value for optional types.

Type class providing a default "empty" value for optional types.

Used by @optionalParam to supply a default when no explicit default is provided. Instances are defined for Option[A] (returns None) and A | Null (returns null).

Type parameters

O

the type for which a default value is provided

Attributes

See also
Companion
object
Supertypes
trait () => O
class Object
trait Matchable
class Any
sealed trait Done

Mirror for operation-centric types, describing the methods and fields of a type T as a tuple of DoneOperations.

Mirror for operation-centric types, describing the methods and fields of a type T as a tuple of DoneOperations.

While Made models a type by its constructor parameters or subtypes, Done models it by its members: each val, def, or field becomes an operation whose input parameters and output type are captured at the type level. This makes Done suited to describing services, RPC interfaces, enums with behavior, and other types where the API surface (rather than the data shape) is what matters.

Attributes

See also
Example 
import made.*
trait Service:
 def ping(message: String): Boolean
 def version: Int
val done: Done.Of[Service] = Done.derived[Service]
// done type members:
//   type Type = Service
//   type Label = "Service"
//   type Metadata = Meta
//   type Operations = DoneOperation { ... "ping" ... } *: DoneOperation { ... "version" ... } *: EmptyTuple
Companion
object
Supertypes
class Object
trait Matchable
class Any
object Done

Attributes

Companion
trait
Supertypes
class Object
trait Matchable
class Any
Self type
Done.type
sealed trait DoneOperation

Element representing a single operation (field or method) in a Done mirror.

Element representing a single operation (field or method) in a Done mirror.

Each entry in Done.Operations is a DoneOperation describing one member of the mirrored type: its label, metadata, input parameters, and output type. Methods with multiple parameter lists are flattened into a single InputElems tuple.

Attributes

See also
Companion
object
Supertypes
class Object
trait Matchable
class Any
Known subtypes
trait EmptyApply
trait SingleApply
object DoneOperation

Attributes

Companion
trait
Supertypes
class Object
trait Matchable
class Any
Self type
sealed trait GeneratedMadeElem extends MadeFieldElem

Element representing a generated val or def.

Element representing a generated val or def.

Extends MadeFieldElem. Lives in Made.GeneratedElems tuple (separate from Made.Elems). A generated element computes a derived value from an instance of the outer type.

Attributes

See also
Companion
object
Supertypes
trait MadeElem
class Object
trait Matchable
class Any
object GeneratedMadeElem

Attributes

Companion
trait
Supertypes
class Object
trait Matchable
class Any
Self type
object InputElem

Attributes

Companion
trait
Supertypes
class Object
trait Matchable
class Any
Self type
InputElem.type
sealed trait InputElem

Element representing a single input parameter of a DoneOperation.

Element representing a single input parameter of a DoneOperation.

Carries the parameter's type, label, and annotation metadata.

Attributes

See also
Companion
object
Supertypes
class Object
trait Matchable
class Any
sealed trait Made

Extended mirror for Scala types, providing annotation metadata, element-level detail, and generated member support beyond standard scala.deriving.Mirror.

Extended mirror for Scala types, providing annotation metadata, element-level detail, and generated member support beyond standard scala.deriving.Mirror.

A Made instance describes the structure of a type T at both the type level and runtime. Unlike the standard library Mirror, Made carries per-element metadata (annotations, default values, labels) and supports @generated members that compute derived values.

Attributes

See also
Example 
import made.*
case class User(name: String, age: Int)
val mirror: Made.Of[User] = Made.derived[User]
// mirror type members:
//   type Type = User
//   type Label = "User"
//   type Metadata = Meta
//   type Elems = MadeFieldElem { ... } *: MadeFieldElem { ... } *: EmptyTuple
val (nameFld, ageFld) = mirror.mirroredElems
val user = mirror.fromUnsafeArray(Array("Alice", 30))
Companion
object
Supertypes
class Object
trait Matchable
class Any
Known subtypes
trait Product
trait Singleton
trait Sum
trait Transparent
object Made

Attributes

Companion
trait
Supertypes
class Object
trait Matchable
class Any
Self type
Made.type
sealed trait MadeElem

Base type for elements within a Made.Elems tuple.

Base type for elements within a Made.Elems tuple.

Each element in the Made.Elems tuple is a subtype of MadeElem, carrying the element's type, label, and annotation metadata. The concrete subtype depends on the mirror kind:

Attributes

See also
Example 
import made.*
case class User(name: String, age: Int)
val mirror = Made.derived[User]
val (nameFld, ageFld) = mirror.elems
// nameFld: MadeFieldElem { type Type = String; type Label = "name" }
// ageFld:  MadeFieldElem { type Type = Int;    type Label = "age"  }
Companion
object
Supertypes
class Object
trait Matchable
class Any
Known subtypes
trait MadeSubElem
object MadeElem

Attributes

Companion
trait
Supertypes
class Object
trait Matchable
class Any
Self type
MadeElem.type
object MadeFieldElem

Attributes

Companion
trait
Supertypes
class Object
trait Matchable
class Any
Self type
sealed trait MadeFieldElem extends MadeElem

Element representing a constructor parameter in a product type mirror.

Element representing a constructor parameter in a product type mirror.

Each entry in Made.Product.Elems tuple is a MadeFieldElem, providing the field's type, label, metadata, and default value.

Attributes

See also
Companion
object
Supertypes
trait MadeElem
class Object
trait Matchable
class Any
Known subtypes
sealed trait MadeSubElem extends MadeElem

Element representing a non-singleton subtype in a sum type mirror.

Element representing a non-singleton subtype in a sum type mirror.

Used in Made.Sum.Elems for subtypes that are not singleton types (e.g., case classes with parameters). For singleton subtypes (case objects, parameterless enum cases), see MadeSubSingletonElem.

Attributes

See also
Companion
object
Supertypes
trait MadeElem
class Object
trait Matchable
class Any
Known subtypes
object MadeSubElem

Attributes

Companion
trait
Supertypes
class Object
trait Matchable
class Any
Self type
sealed trait MadeSubSingletonElem extends MadeSubElem

Element representing a singleton subtype in a sum type mirror.

Element representing a singleton subtype in a sum type mirror.

Extends MadeSubElem. Used in Made.Sum.Elems for case objects and parameterless enum cases. Provides access to the singleton instance via the value method.

Attributes

See also
Companion
object
Supertypes
trait MadeSubElem
trait MadeElem
class Object
trait Matchable
class Any
object MadeSubSingletonElem

Attributes

Companion
trait
Supertypes
class Object
trait Matchable
class Any
Self type
trait Meta

Attributes

Supertypes
class Object
trait Matchable
class Any
object TransparentWrapping

Attributes

Companion
trait
Supertypes
class Object
trait Matchable
class Any
Self type
trait TransparentWrapping[R, T]

Bidirectional conversion between a transparent wrapper type T and its single wrapped field type R.

Bidirectional conversion between a transparent wrapper type T and its single wrapped field type R.

Used by Made.Transparent to implement wrap and unwrap. Derived at compile time via TransparentWrapping.derived[R, T] for single-field case classes annotated with @transparent.

Type parameters

R

the wrapped field type

T

the transparent wrapper type

Attributes

See also
Companion
object
Supertypes
class Object
trait Matchable
class Any
object containsOnly

Attributes

Supertypes
class Object
trait Matchable
class Any
Self type

Types

type HasDuplicates[Tup <: Tuple] = Tup match { case EmptyTuple => false case h *: t => Contains[t, h] || HasDuplicates[t] }
type Indices[Tup <: Tuple] = Tup match { case EmptyTuple => EmptyTuple case h *: t => 0 *: IndicesAux[t, 1] }
type IndicesAux[Tup <: Tuple, N <: Int] = Tup match { case EmptyTuple => EmptyTuple case h *: t => N *: IndicesAux[t, S[N]] }
infix opaque type containsOnly[Tup <: Tuple, T]

Value members

Concrete methods

def reportOnDuplicates(labels: Seq[(label: String, original: String)])(using Quotes): Unit
def stringToType(str: String)(using quotes: Quotes): Type[_ <: String]
def traverseTuple(tpe: Type[_ <: Tuple])(using Quotes): List[Type[_ <: AnyKind]]
def traverseTypes(tpes: List[Type[_ <: AnyKind]])(using Quotes): Type[_ <: Tuple]
def typeToString[S <: String](using evidence$1: Type[S], quotes: Quotes): S

Extensions

Extensions

extension (comp: Expr.type)
def ofOption[A](opt: Option[Expr[A]])(using evidence$1: Type[A], Quotes): Expr[Option[A]]
extension [L <: String](l: { type Label = L; })
inline def label: L

Returns the label of the mirror.

Returns the label of the mirror.

Attributes

extension [Ls <: Tuple](l: { type ElemLabels = Ls; })
inline def elemLabels: Ls

Returns the labels of the mirror's elements.

Returns the labels of the mirror's elements.

Attributes

extension [M <: Meta](self: { type Metadata = M; })
inline def getAnnotation[A <: Annotation]: Option[A]

Returns Some(annotation) if the mirror's Metadata type member contains an annotation of type A, None otherwise.

Returns Some(annotation) if the mirror's Metadata type member contains an annotation of type A, None otherwise.

The returned annotation instance provides access to annotation parameters (e.g., getAnnotation[JsonName].get.value). Inline - resolved at compile time. A must extend [[made.annotation.MetaAnnotation]`.

Attributes

transparent inline def hasAnnotation[A <: Annotation]: Boolean

Returns true if the mirror's Metadata type member contains an annotation of type A.

Returns true if the mirror's Metadata type member contains an annotation of type A.

Transparent inline - resolved entirely at compile time, no runtime cost. A must extend made.annotation.MetaAnnotation.

Attributes

extension (tup: Tuple)
inline def foreach(f: [t] => t => Unit): Unit
inline def hasDuplicates: HasDuplicates[tup.type]
inline def indices: Indices[tup.type]
inline def mapAs[T](using containsOnly[tup.type, T])[F[_ <: T]](inline f: [t <: T] => t => F[t]): Map[tup.type, [X] =>> F[X & T]]
def toArrayOf[T](using evidence$1: ClassTag[T], containsOnly[tup.type, T]): Array[T]
Generated with
made with ❤️ and coffee
made with ❤️ and coffee