FilterMapForeach

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

def ->[B](y: B): (FilterMapForeach, B)

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def andThen[A](g: (Type) ⇒ A): (Type) ⇒ A

def apply(tp: Type): Type

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def collect(tp: Type): List[Type]

def compose[A](g: (A) ⇒ Type): (A) ⇒ Type

def ensuring(cond: (FilterMapForeach) ⇒ Boolean, msg: ⇒ Any): FilterMapForeach

def ensuring(cond: (FilterMapForeach) ⇒ Boolean): FilterMapForeach

def ensuring(cond: Boolean, msg: ⇒ Any): FilterMapForeach

def ensuring(cond: Boolean): FilterMapForeach

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def foreach[U](f: (Type) ⇒ U): Unit

def formatted(fmtstr: String): String

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def map[T](f: (Type) ⇒ T): List[T]

def mapOver(tree: Tree, giveup: () ⇒ Nothing): Tree

Map a tree that is part of an annotation argument.

def mapOver(tree: Tree): Tree

def mapOver(annot: AnnotationInfo): AnnotationInfo

def mapOver(origSyms: List[Symbol]): List[Symbol]

Map this function over given list of symbols

def mapOver(scope: Scope): Scope

Map this function over given scope

def mapOver(tp: Type): Type

Map this function over given type

def mapOverAnnotArgs(args: List[Tree]): List[Tree]

Map over a set of annotation arguments.

def mapOverAnnotations(annots: List[AnnotationInfo]): List[AnnotationInfo]

def mapOverArgs(args: List[Type], tparams: List[Symbol]): List[Type]

final def ne(arg0: AnyRef): Boolean

def noChangeToSymbols(origSyms: List[Symbol]): Boolean

Called by mapOver to determine whether the original symbols can be returned, or whether they must be cloned.

final def notify(): Unit

final def notifyAll(): Unit

var result: List[Type]

val self: Any

val self: Any

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

def toString(): String

def traverse(tp: Type): Unit

def variance: Int

Mix in VariantTypeMap if you want variances to be significant.

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def withFilter(q: (Type) ⇒ Boolean): FilterTypeCollector

def →[B](y: B): (FilterMapForeach, B)

def x: FilterMapForeach

def x: FilterMapForeach