Base class for case classes that reduces amount of code that the compiler generates for them.
Convenience abstract class implementing ValueEnum.
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.
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.
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.
A typeclass which witnesses that type A
can be wrapped into trait or abstract class B
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, probably because: #{forUnboxed}") implicit def boxCodecNotFound[T]( implicit forUnboxed: ImplicitNotFound[GenCodec[T]] ): ImplicitNotFound[GenCodec[Box[T]]] = ImplicitNotFound()
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.
Like Opt but does have a counterpart for Some(null)
.
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.
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.
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.
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).
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).
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.
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 }
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.
Millisecond-precision, general purpose, cross compiled timestamp representation.
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]"
Base class for sealed enums which can be used as key type for a TypedMap.
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.
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:
values
in enum's companion object as it is necessary when using
SealedEnumCompanion and NamedEnumCompanionDisadvantages of value based enums over object based enums include:
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.
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") }
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.
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
(Since version 1.34) Use MacroInstances instead
Creates reversed partial function.
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.