Type Members

1.  abstract class AbstractCase extends CaseMethods

   Base class for case classes that reduces amount of code that the compiler generates for them.

   Base class for case classes that reduces amount of code that the compiler generates for them. Useful primarily for JS size reduction. See CaseMethods for more details.

2.  abstract class AbstractNamedEnumCompanion[T <: NamedEnum] extends AbstractSealedEnumCompanion[T] with NamedEnumCompanion[T]
3.  abstract class AbstractSealedEnumCompanion[T] extends SealedEnumCompanion[T]
4.  abstract class AbstractValueEnum extends ValueEnum

   Convenience abstract class implementing ValueEnum.

   Convenience abstract class implementing ValueEnum. For less generated code, faster compilation and better binary compatibility it's better to extend this abstract class rather than ValueEnum trait directly. See ValueEnum documentation for more information on value-based enums.

5.  abstract class AbstractValueEnumCompanion[T <: ValueEnum] extends AbstractNamedEnumCompanion[T] with ValueEnumCompanion[T]

   Convenience abstract class implementing ValueEnumCompanion.

   Convenience abstract class implementing ValueEnumCompanion. For less generated code, faster compilation and better binary compatibility it's better to use this abstract class rather than ValueEnumCompanion trait directly. See ValueEnum documentation for more information on value based enums.

6.  final case class AnnotationOf[A, T](annot: A) extends AnyVal with Product with Serializable

   Annotations

   @implicitNotFound( "${T} is not annotated with ${A}" )

7.  final case class AnnotationsOf[A, T](annots: List[A]) extends AnyVal with Product with Serializable
8.  trait Applier[T] extends AnyRef

   Typeclass which captures case class apply method in a raw form that takes untyped sequence of arguments.

   Typeclass which captures case class apply method in a raw form that takes untyped sequence of arguments.

   Annotations

   @implicitNotFound( ... )

9.  trait ApplierUnapplier[T] extends Applier[T] with Unapplier[T]

   Annotations

   @implicitNotFound( ... )

10.  trait AutoNamedEnum extends NamedEnum with Product

    Subtrait of NamedEnum which requires its values to be Products and uses Product.productPrefix as the name of each enum constant.

    Subtrait of NamedEnum which requires its values to be Products and uses Product.productPrefix as the name of each enum constant. In practice this means that all the objects extending AutoNamedEnum should be case objects so that object names are automatically used as enum constant names. That's because case classes and objects automatically implement Product and use their source name as Product.productPrefix.

11.  final case class Boxing[-A, +B](fun: (A) ⇒ B) extends AnyVal with Product with Serializable
12.  case class Bytes(bytes: Array[Byte]) extends Product with Serializable

    General purpose wrapper over byte array which adds equals, hashCode and toString which work on array elements instead of object identity.

13.  trait CaseMethods extends Product

    Implements common case class & case object methods normally synthesized by the compiler.

    Implements common case class & case object methods normally synthesized by the compiler. Extending this trait by case class or case object prevents the compiler from synthesizing these methods which can reduce generated JS size at penalty of not-exactly-precise implementation of canEqual and equals and its runtime performance. For this reason, non-abstract classes extending this trait should always be final. If possible, prefer using AbstractCase rather than this trait.

14.  trait Delegation[A, B] extends AnyRef

    A typeclass which witnesses that type A can be wrapped into trait or abstract class B

15.  sealed trait EnumCtx extends Any

    Annotations

    @implicitNotFound( ... )

16.  final class HasAnnotation[A, T] extends AnyRef

    Annotations

    @implicitNotFound( "${T} is not annotated with ${A}" )

17.  sealed trait ImplicitNotFound[T] extends AnyRef

    Extends the functionality of scala.annotation.implicitNotFound so that implicit-not-found error message is itself resolved using implicit search.

    Extends the functionality of scala.annotation.implicitNotFound so that implicit-not-found error message is itself resolved using implicit search. This mechanism is used by Implicits.infer[T]:T* and macro engines that use it.

    Example: we have a wrapper class Box[T] and we want a custom error message when GenCodec[Box[T]] for some type T is not found:

    trait Box[T]
    object Box {
      implicit def boxCodec[T: GenCodec]: GenCodec[Box[T]] = ...
    
      @implicitNotFound("GenCodec for Box[$${T}] not found. This is most likely caused by lack of GenCodec[$${T}]")
      implicit def boxCodecNotFound[T]: ImplicitNotFound[GenCodec[Box[T]]] = ImplicitNotFound()
    }

    It is also possible to compose error message for one type from error messages for other types. The example above could reuse the implicit-not-found message for GenCodec[T] when building the message for GenCodec[Box[T]]:

    @implicitNotFound("GenCodec for Box[$${T}] not found, because:\n#{forUnboxed}")
    implicit def boxCodecNotFound[T](
      implicit forUnboxed: ImplicitNotFound[GenCodec[T]]
    ): ImplicitNotFound[GenCodec[Box[T]]] = ImplicitNotFound()

18.  final class JavaClassName[T] extends AnyVal

    Typeclass that contains JVM fully qualified class name corresponding to given type.

    Typeclass that contains JVM fully qualified class name corresponding to given type. JavaClassName.of[T] is always equal to classTag[T].runtimeClass.getName

    JavaClassName can be used instead of ClassTag in ScalaJS when ScalaJS linker is configured to drop class names. Also, unlike ClassTag, JavaClassName contains just a string so it can be easily serialized and deserialized.

19.  trait JavaClassNameLowPrio extends AnyRef
20.  trait LowPrioBoxing extends AnyRef
21.  trait LowPrioUnboxing extends AnyRef
22.  final class NOpt[+A] extends AnyVal with Serializable

    Like Opt but does have a counterpart for Some(null).

    Like Opt but does have a counterpart for Some(null). In other words, NOpt is a "nullable Opt".

23.  trait NamedEnum extends Serializable

    Base trait for enums implemented as sealed hierarchy with case objects where every enum value has distinct textual representation (name).

    Base trait for enums implemented as sealed hierarchy with case objects where every enum value has distinct textual representation (name).

    Typically, if a trait or class extends NamedEnum, its companion object extends NamedEnumCompanion. Enum values can then be looked up by name using NamedEnumCompanion.byName.

24.  trait NamedEnumCompanion[T <: NamedEnum] extends SealedEnumCompanion[T]

    Base trait for companion objects of sealed traits that serve as named enums.

    Base trait for companion objects of sealed traits that serve as named enums. NamedEnumCompanion is an extension of SealedEnumCompanion which additionally requires that every enum value has distinct string representation. Values can then be looked up by that representation using NamedEnumCompanion.byName

    Example:

    sealed abstract class Color(val name: String) extends NamedEnum
    object Color extends NamedEnumCompanion[Color] {
      case object Red extends Color("red")
      case object Blue extends Color("blue")
      case object Green extends Color("green")
    
      // it's important to explicitly specify the type so that `caseObjects` macro works properly
      val values: List[Color] = caseObjects
    }

    NamedEnumCompanion also automatically provides implicit typeclass instances for GenKeyCodec and GenCodec.

25.  final class Opt[+A] extends AnyVal with Serializable

    Like Option but implemented as value class (avoids boxing) and treats null as no value.

    Like Option but implemented as value class (avoids boxing) and treats null as no value. Therefore, there is no equivalent for Some(null).

    If you need a value-class version of Option which differentiates between no value and null value, use NOpt.

26.  case class OptAnnotationOf[A, T](annotOpt: Opt[A]) extends Product with Serializable
27.  final class OptArg[+A] extends AnyVal with Serializable

    OptArg is like Opt except it's intended to be used to type-safely express optional method/constructor parameters while at the same time avoiding having to explicitly wrap arguments when passing them (thanks to the implicit conversion from A to OptArg[A]).

    OptArg is like Opt except it's intended to be used to type-safely express optional method/constructor parameters while at the same time avoiding having to explicitly wrap arguments when passing them (thanks to the implicit conversion from A to OptArg[A]). For example:

    def takesMaybeString(str: OptArg[String] = OptArg.Empty) = ???
    
    takesMaybeString()         // default empty value is used
    takesMaybeString("string") // no explicit wrapping into OptArg required

    Note that like Opt, OptArg assumes its underlying value to be non-null and null is translated into OptArg.Empty.
    It is strongly recommended that OptArg type is used ONLY in signatures where implicit conversion A => OptArg[A] is intended to work. You should not use OptArg as a general-purpose "optional value" type - other types like Opt, NOpt and Option serve that purpose. For this reason OptArg deliberately does not have any "transforming" methods like map, flatMap, orElse, etc. Instead it's recommended that OptArg is converted to Opt, NOpt or Option as soon as possible (using toOpt, toNOpt and toOption methods).

28.  final class OptRef[+A >: Null] extends AnyVal with Serializable

    Like Opt but has better Java interop thanks to the fact that wrapped value has type A instead of Any.

    Like Opt but has better Java interop thanks to the fact that wrapped value has type A instead of Any. For example, Scala method defined like this:

    def takeMaybeString(str: OptRef[String]): Unit

    will be seen by Java as:

    public void takeMaybeString(String str);

    and null will be used to represent absence of value.

    This comes at the cost of A having to be a nullable type. Also, empty value is represented internally using null which unfortunately makes OptRef suffer from SI-7396 (hashCode fails on OptRef.Empty which means that you can't add OptRef values into hash sets or use them as hash map keys).

29.  trait OrderedEnum extends AnyRef

    Trait to be extended by enums whose values are ordered by declaration order.

    Trait to be extended by enums whose values are ordered by declaration order. Ordering is derived from SourceInfo object, which is typically accepted as an implicit, e.g.

    sealed abstract class MyOrderedEnum(implicit val sourceInfo: SourceInfo) extends OrderedEnum
    object MyOrderedEnum {
      case object First extends MyOrderedEnum
      case object Second extends MyOrderedEnum
      case object Third extends MyOrderedEnum
    
      val values: List[MyOrderedEnum] = caseObjects
    }

    In the example above, values is guaranteed to return First, Second and Third objects in exactly that order.

30.  abstract class ProductApplierUnapplier[T <: Product] extends ProductUnapplier[T] with ApplierUnapplier[T]
31.  class ProductUnapplier[T <: Product] extends Unapplier[T]
32.  abstract class SamCompanion[T, F] extends AnyRef
33.  trait SealedEnumCompanion[T] extends AnyRef

    Base trait for companion objects of sealed traits that serve as enums, i.e.

    Base trait for companion objects of sealed traits that serve as enums, i.e. their only values are case objects. For example:

    sealed trait SomeEnum
    object SomeEnum extends SealedEnumCompanion[SomeEnum] {
      case object FirstValue extends SomeEnum
      case object SecondValue extends SomeEnum
      case object ThirdValue extends SomeEnum
    
      // it's important to explicitly specify the type so that `caseObjects` macro works properly
      val values: List[SomeEnum] = caseObjects
    }

34.  final case class SelfAnnotation[A](annot: A) extends AnyVal with Product with Serializable
35.  final case class SelfAnnotations[A](annots: List[A]) extends AnyVal with Product with Serializable
36.  case class SelfInstance[C[_]](instance: C[_]) extends Product with Serializable
37.  case class SelfOptAnnotation[A](annotOpt: Opt[A]) extends Product with Serializable
38.  final case class SimpleClassName[T](name: String) extends AnyVal with Product with Serializable
39.  case class SourceInfo(filePath: String, fileName: String, offset: Int, line: Int, column: Int, lineContent: String, enclosingSymbols: List[String]) extends Product with Serializable

    Macro-materialized implicit value that provides information about callsite source file position.

    Macro-materialized implicit value that provides information about callsite source file position. It can be used in runtime for logging and debugging purposes. Similar to Scalactic's Position, but contains more information.

40.  final class Timestamp extends AnyVal with Comparable[Timestamp]

    Millisecond-precision, general purpose, cross compiled timestamp representation.

41.  final class TimestampConversions extends AnyVal
42.  final class TypeString[T] extends AnyVal

    Typeclass that contains string representation of a concrete type.

    Typeclass that contains string representation of a concrete type. This representation should correctly parse and typecheck when used as a type in Scala source code.

    Instances of TypeString are implicitly macro-materialized. The macro will fail if the type contains references to local symbols, i.e. symbols that only exist in limited scope and cannot be referred to from any place in source code. This includes type parameters, this-references to enclosing classes, etc.

    For example, the code below will NOT compile:

    def listTypeRepr[T]: String = TypeString.of[List[T]]

    because T is a local symbol that only has meaning inside its own method. However, if you provide external TypeString instance for T, the macro will pick it up and no longer complain:

    def listTypeRepr[T: TypeString]: String = TypeString.of[List[T]]

    Then, listTypeRepr[Int] will produce a string "List[Int]"

43.  abstract class TypedKey[T] extends AnyRef

    Base class for sealed enums which can be used as key type for a TypedMap.

    Base class for sealed enums which can be used as key type for a TypedMap. It also ensures that the TypedMap using TypedKey as a key type will always have a GenCodec.

44.  trait TypedKeyCompanion[K[X] <: TypedKey[X]] extends SealedEnumCompanion[K[_]]
45.  final class TypedMap[K[_]] extends AnyVal
46.  trait Unapplier[T] extends AnyRef

    Typeclass which captures case class unapply/unapplySeq method in a raw form that returns untyped sequence of values.

    Typeclass which captures case class unapply/unapplySeq method in a raw form that returns untyped sequence of values.

    Annotations

    @implicitNotFound( ... )

47.  final case class Unboxing[+A, -B](fun: (B) ⇒ A) extends AnyVal with Product with Serializable
48.  trait ValueEnum extends NamedEnum

    Base trait for val-based enums, i.e.

    Base trait for val-based enums, i.e. enums implemented as a single class with companion object keeping enum values as instances of the enum class in final val fields. This is an alternative way of implementing enums as compared to traditional Scala approach of using a sealed hierarchy with objects representing enum values.

    Advantages of value based enums over object based enums include:

    • Much less classes generated, which in particular contributes to much less JavaScript output in ScalaJS. This may also speed up compilation.
    • No need to explicitly implement values in enum's companion object as it is necessary when using SealedEnumCompanion and NamedEnumCompanion
    • It is possible to define all enum values in a single line of code (assuming they don't take parameters)

    Disadvantages of value based enums over object based enums include:

    • Every object can have its own separate public API, values cannot (although you can have a separate anonymous class for every value)
    • Scala compiler does not perform exhaustive checking for pattern matching enum values - this is however provided separately by commons-analyzer compiler plugin.

    Enum classes must have a companion object which extends ValueEnumCompanion (prefer using AbstractValueEnumCompanion where possible). Every enum constant must be declared as a final val in the companion object and must have the Value type explicitly ascribed (which is just a type alias for enum class itself). The enum class itself must take an implicit EnumCtx argument which provides information about enum ordinal and name as well as makes sure that enum value is registered in the companion object. If possible, you should always extend AbstractValueEnum instead of mixing in this trait. ValueEnum trait should only be mixed in directly when your enum class already has another superclass, incompatible with AbstractValueEnum.

    Example:

    1. final class Weekday(implicit enumCtx: EnumCtx) extends AbstractValueEnum
       object Weekday extends AbstractValueEnumCompanion[Weekday] {
         final val Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday: Value = new Weekday
       }

       Value based enums can take parameters:

       final class Status(val description: String)(implicit enumCtx: EnumCtx) extends AbstractValueEnum
       object Status extends AbstractValueEnumCompanion[Status] {
         final val Enabled: Value = new Status("Something is enabled and working")
         final val Disabled: Value = new Status("Something is disabled and not working")
       }

49.  trait ValueEnumCompanion[T <: ValueEnum] extends NamedEnumCompanion[T]

    Base trait for companion objects of value based enums.

    Base trait for companion objects of value based enums. See ValueEnum for more information. NOTE: if possible, prefer using AbstractValueEnumCompanion instead of this trait directly.

50.  final class ValueOf[T] extends AnyVal

    Macro materialized typeclass which captures the single value of a singleton type.

    Macro materialized typeclass which captures the single value of a singleton type.

    Annotations

    @implicitNotFound( ... )

51.  final class MacroGenerated[C, T] extends AnyVal

    Wrapper class for macro-generated typeclasses.

    Wrapper class for macro-generated typeclasses. Usually, a typeclass is wrapped in MacroGenerated when it's accepted as implicit super constructor parameter of some base class for companion objects of types for which the typeclass is being generated. Example: HasGenCodec, which is a base class for companion objects of classes that want GenCodec to be macro-generated for them.

    Instead of materializing the type class instance directly, a function from some base companion type C is materialized. To obtain the actual typeclass instance, companion object must be passed as this function's argument. This serves two purposes:

    - contents of C will be wildcard-imported into macro-materialization, allowing injection of additional implicits - working around too strict Scala validation of super constructor arguments: https://github.com/scala/bug/issues/7666

    Annotations

    @deprecated

    Deprecated

    (Since version 1.34) Use MacroInstances instead