Tag

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def appliedTag[R](tag: HKTag[_], args: List[LightTypeTag]): Tag[R]

Create a Tag of a type formed by applying the type in tag to args.

implicit def tagFromTagTAKA[T[_, _[_], _], K[_]: TagK, A0: Tag, A1: Tag](implicit t: LTagK3[T]): Tag[T[A0, K, A1]] =
  Tag.appliedTag(t.tag, List(Tag[A0].tag, TagK[K].tag, Tag[A1].tag))

def apply[T](cls: Class[_], tag0: LightTypeTag): Tag[T]

def apply[T](implicit arg0: Tag[T]): Tag[T]

final def asInstanceOf[T0]: T0

macro def auto: Any

Use Tag.auto.T[TYPE_PARAM] syntax to summon a Tag for a type parameter of any kind:

def module1[F[_]: Tag.auto.T] = new ModuleDef {
  ...
}

def module2[F[_, _]: Tag.auto.T] = new ModuleDef {
  ...
}

def y[K[_[_, _], _[_], _[_[_], _, _, _]](implicit ev: Tag.auto.T[K]): Tag.auto.T[K] = ev

def x[K[_[_, _], _[_], _[_[_], _, _, _]: Tag.auto.T]: Tag.auto.T[K] = implicitly[Tag.auto.T[K]]

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def refinedTag[R](lubClass: Class[_], intersection: List[LightTypeTag], structType: LightTypeTag): Tag[R]

Create a Tag of a type formed from an intersection of types (A with B) with a structural refinement taken from structType

Tag[A with B {def abc: Unit}] == refinedTag(List(LTag[A].tag, LTag[B].tag), LTag.Weak[A with B { def abc: Unit }].tag)

final def synchronized[T0](arg0: ⇒ T0): T0

implicit final macro def tagFromTagMacro[T]: Tag[T]

def toString(): String

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

final def wait(): Unit

def finalize(): Unit