tagging/com.softwaremill.tagging

com.softwaremill.tagging

package com.softwaremill.tagging

Tag instances with arbitrary types. The tags are usually empty traits. Tags have no runtime overhead and are only used at compile-time for additional type safety.

For example:

 class Berry()

 trait Black
 trait Blue

 val berry = new Berry()
 val blackBerry: Berry @@ Black = berry.taggedWith[Black]
 val blueBerry: Berry @@ Blue = berry.taggedWith[Blue]

 // compile error: val anotherBlackBerry: Berry @@ Black = blueBerry

Original idea by Miles Sabin, see: https://gist.github.com/milessabin/89c9b47a91017973a35f

Type members

Classlikes

final implicit class AndTagger[T, U](val t: T @@ U) extends AnyVal
final implicit class AndTaggingF[F[_], T, U](val ft: F[T @@ U]) extends AnyVal
final implicit class AndTaggingF2[F1[_], F2[_], T, U](val ft: F1[F2[T @@ U]]) extends AnyVal
final implicit class AndTaggingMapKey[M[_, _], K, A, V](val mkv: M[K @@ A, V]) extends AnyVal
trait AnyTypeclassTaggingCompat
Companion:
object
object AnyTypeclassTaggingCompat extends AnyTypeclassTaggingCompat
Companion:
class
final implicit class Function2Tagger[A, B, C](val f: (A, B) => C) extends AnyVal
final implicit class Function3Tagger[A, B, C, D](val f: (A, B, C) => D) extends AnyVal
final implicit class Function4Tagger[A, B, C, D, E](val f: (A, B, C, D) => E) extends AnyVal
final implicit class FunctionTagger[A, B](val f: A => B) extends AnyVal
trait Tag[+U]
final implicit class Tagger[T](val t: T) extends AnyVal
final implicit class TaggingF[F[_], T](val fa: F[T]) extends AnyVal
final implicit class TaggingF2[F1[_], F2[_], T](val ft: F1[F2[T]]) extends AnyVal
final implicit class TaggingMapKey[M[_, _], K, V](val mkv: M[K, V]) extends AnyVal
trait TypeclassTaggingCompat[Typeclass[_]]

Types

type @@[+T, +U] = T & Tag[U]
type Tagged[+T, +U] = T & Tag[U]

Implicits

Implicits

final implicit def AndTagger[T, U](t: T @@ U): AndTagger[T, U]
final implicit def AndTaggingF[F[_], T, U](ft: F[T @@ U]): AndTaggingF[F, T, U]
final implicit def AndTaggingF2[F1[_], F2[_], T, U](ft: F1[F2[T @@ U]]): AndTaggingF2[F1, F2, T, U]
final implicit def AndTaggingMapKey[M[_, _], K, A, V](mkv: M[K @@ A, V]): AndTaggingMapKey[M, K, A, V]
final implicit def Function2Tagger[A, B, C](f: (A, B) => C): Function2Tagger[A, B, C]
final implicit def Function3Tagger[A, B, C, D](f: (A, B, C) => D): Function3Tagger[A, B, C, D]
final implicit def Function4Tagger[A, B, C, D, E](f: (A, B, C, D) => E): Function4Tagger[A, B, C, D, E]
final implicit def FunctionTagger[A, B](f: A => B): FunctionTagger[A, B]
final implicit def Tagger[T](t: T): Tagger[T]
final implicit def TaggingF[F[_], T](fa: F[T]): TaggingF[F, T]
final implicit def TaggingF2[F1[_], F2[_], T](ft: F1[F2[T]]): TaggingF2[F1, F2, T]
final implicit def TaggingMapKey[M[_, _], K, V](mkv: M[K, V]): TaggingMapKey[M, K, V]