Unapply

case
class Unapply(fun: Tree, implicits: List[Tree], patterns: List[Tree])(span: Span) extends Tree

extractor(patterns) in a pattern:

Value Params
fun

is extractor.unapply (or, for backwards compatibility, extractor.unapplySeq) possibly with type parameters

implicits

Any implicit parameters passed to the unapply after the selector

patterns

The argument patterns in the pattern match. It is typed with same type as first fun argument Given a match selector sel a pattern UnApply(fun, implicits, patterns) is roughly translated as follows val result = fun(sel)(implicits) if (result.isDefined) "match patterns against result"

trait Serializable
trait Product
trait Equals
class Tree
class Object
trait Matchable
class Any

Value members

Concrete methods

final override
def withSpan(span: Span): Unapply
Definition Classes

Inherited methods

def productElementNames: Iterator[String]
Inherited from
Product
def productIterator: Iterator[Any]
Inherited from
Product
protected
def subtrees: List[Tree]
Inherited from
Tree
final
def tpe(using Context): Type

The term type of this tree.

The term type of this tree.

If this tree is not a term (e.g., it is a definition), its tpe is NoType.

Inherited from
Tree
protected
def typeTrees: List[TypeTree]
Inherited from
Tree
def walkTree(op: Tree => Unit): Unit
Inherited from
Tree
def walkTree[R](op: Tree => R)(reduce: (R, R) => R, default: => R): R
Inherited from
Tree
def walkTypeTrees(op: TypeTree => Unit): Unit
Inherited from
Tree
def walkTypeTrees[R](op: TypeTree => R)(reduce: (R, R) => R, default: => R): R
Inherited from
Tree