A partial function of typePartialFunction[A, B] is a unary function where the domain does not necessarily include all values of typeA. The functionisDefinedAt allows to test dynamically if a value is in the domain of the function.
Even ifisDefinedAt returns true for ana: A, callingapply(a) may still throw an exception, so the following code is legal:
val f: PartialFunction[Int, Any] = { case x => x / 0 } // ArithmeticException: / by zeroIt is the responsibility of the caller to callisDefinedAt before callingapply, because ifisDefinedAt is false, it is not guaranteedapply will throw an exception to indicate an error condition. If an exception is not thrown, evaluation may result in an arbitrary value.
The usual way to respect this contract is to callapplyOrElse, which is expected to be more efficient than calling bothisDefinedAt andapply.
The main distinction betweenPartialFunction andscala.Function1 is that the user of aPartialFunction may choose to do something different with input that is declared to be outside its domain. For example:
val sample = 1 to 10def isEven(n: Int) = n % 2 == 0val eveningNews: PartialFunction[Int, String] = { case x if isEven(x) => s"$x is even"}// The method collect is described as "filter + map"// because it uses a PartialFunction to select elements// to which the function is applied.val evenNumbers = sample.collect(eveningNews)val oddlyEnough: PartialFunction[Int, String] = { case x if !isEven(x) => s"$x is odd"}// The method orElse allows chaining another PartialFunction// to handle input outside the declared domain.val numbers = sample.map(eveningNews orElse oddlyEnough)// same asval numbers = sample.map(n => eveningNews.applyOrElse(n, oddlyEnough))val half: PartialFunction[Int, Int] = { case x if isEven(x) => x / 2}// Calculating the domain of a composition can be expensive.val oddByHalf = half.andThen(oddlyEnough)// Invokes `half.apply` on even elements!val oddBalls = sample.filter(oddByHalf.isDefinedAt)// Better than filter(oddByHalf.isDefinedAt).map(oddByHalf)val oddBalls = sample.collect(oddByHalf)// Providing "default" values.val oddsAndEnds = sample.map(n => oddByHalf.applyOrElse(n, (i: Int) => s"[$i]"))Attributes
- Note
OptionalFunctions,PartialFunctions and extractor objects can be converted to each other as shown in the following table.
How to convert ...
to aPartialFunction
to an optionalFunction
to an extractor
from aPartialFunction
from optionalFunction
from an extractor
{ case extractor(x) => x }extractor.unapply _- Companion
- object
- Source
- PartialFunction.scala
- Graph
- Supertypes
- Known subtypes
- classIntMap[T]classLongMap[T]classLongMap[V]classSystemPropertiestraitSeq[A]traitSeq[A]classAbstractSeq[A]classArraySeq[A]classofBooleanclassofByteclassofCharclassofDoubleclassofFloatclassofIntclassofLongclassofRef[T]classofShortclassofUnitclassLazyList[A]classList[A]class::[A]objectNilclassNumericRange[T]classExclusive[T]classInclusive[T]classQueue[A]classRangeclassExclusiveclassInclusiveclassStream[A]classCons[A]objectEmptyclassVector[A]classWrappedStringtraitIndexedSeq[A]traitLinearSeq[A]traitSeq[A]classAbstractSeq[A]classAbstractBuffer[A]classArrayBuffer[A]classArrayDeque[A]classQueue[A]classStack[A]classListBuffer[A]classUnrolledBuffer[T]classArraySeq[T]classofBooleanclassofByteclassofCharclassofDoubleclassofFloatclassofIntclassofLongclassofRef[T]classofShortclassofUnitclassStringBuildertraitBuffer[A]traitIndexedBuffer[A]traitIndexedSeq[T]classAnyAccumulator[A]classDoubleAccumulatorclassIntAccumulatorclassLongAccumulatorclassAbstractSeq[A]traitIndexedSeq[A]traitLinearSeq[A]Show all
- Self type
Members list
Value members
Abstract methods
Checks if a value is contained in the function's domain.
Checks if a value is contained in the function's domain.
Value parameters
- x
the value to test
Attributes
- Returns
true, iffxis in the domain of this function,falseotherwise.- Source
- PartialFunction.scala
Concrete methods
Composes this partial function with a transformation function that gets applied to results of this partial function.
Composes this partial function with a transformation function that gets applied to results of this partial function.
If the runtime type of the function is aPartialFunction then the otherandThen method is used (note its cautions).
Type parameters
- C
the result type of the transformation function.
Value parameters
- k
the transformation function
Attributes
- Returns
a partial function with the domain of this partial function, possibly narrowed by the specified function, which maps arguments
xtok(this(x)).- Definition Classes
- Source
- PartialFunction.scala
Composes this partial function with another partial function that gets applied to results of this partial function.
Composes this partial function with another partial function that gets applied to results of this partial function.
Note that callingisDefinedAt on the resulting partial function may apply the first partial function and execute its side effect. For efficiency, it is recommended to callapplyOrElse instead ofisDefinedAt orapply.
Type parameters
- C
the result type of the transformation function.
Value parameters
- k
the transformation function
Attributes
- Returns
a partial function with the domain of this partial function narrowed by other partial function, which maps arguments
xtok(this(x)).- Source
- PartialFunction.scala
Applies this partial function to the given argument when it is contained in the function domain.
Applies this partial function to the given argument when it is contained in the function domain. Applies fallback function where this partial function is not defined.
Note that expressionpf.applyOrElse(x, default) is equivalent to
if(pf isDefinedAt x) pf(x) else default(x)except thatapplyOrElse method can be implemented more efficiently. For all partial function literals the compiler generates anapplyOrElse implementation which avoids double evaluation of pattern matchers and guards. This makesapplyOrElse the basis for the efficient implementation for many operations and scenarios, such as:
- combining partial functions intoorElse/andThen chains does not lead to excessiveapply/isDefinedAt evaluation -lift andunlift do not evaluate source functions twice on each invocation -runWith allows efficient imperative-style combining of partial functions with conditionally applied actions
For non-literal partial function classes with nontrivialisDefinedAt method it is recommended to overrideapplyOrElse with custom implementation that avoids doubleisDefinedAt evaluation. This may result in better performance and more predictable behavior w.r.t. side effects.
Value parameters
- default
the fallback function
- x
the function argument
Attributes
- Returns
the result of this function or fallback function application.
- Source
- PartialFunction.scala
Composes another partial functionk with this partial function so that this partial function gets applied to results ofk.
Composes another partial functionk with this partial function so that this partial function gets applied to results ofk.
Note that callingisDefinedAt on the resulting partial function may apply the first partial function and execute its side effect. For efficiency, it is recommended to callapplyOrElse instead ofisDefinedAt orapply.
Type parameters
- R
the parameter type of the transformation function.
Value parameters
- k
the transformation function
Attributes
- Returns
a partial function with the domain of other partial function narrowed by this partial function, which maps arguments
xtothis(k(x)).- Source
- PartialFunction.scala
Returns an extractor object with aunapplySeq method, which extracts each element of a sequence data.
Returns an extractor object with aunapplySeq method, which extracts each element of a sequence data.
Attributes
- Example
val firstChar: String => Option[Char] = _.headOptionSeq("foo", "bar", "baz") match { case firstChar.unlift.elementWise(c0, c1, c2) => println(s"$c0, $c1, $c2") // Output: f, b, b}- Source
- PartialFunction.scala
Turns this partial function into a plain function returning anOption result.
Turns this partial function into a plain function returning anOption result.
Attributes
- Returns
a function that takes an argument
xtoSome(this(x))ifthisis defined forx, and toNoneotherwise.- See also
Function.unlift
- Source
- PartialFunction.scala
Composes this partial function with a fallback partial function which gets applied where this partial function is not defined.
Composes this partial function with a fallback partial function which gets applied where this partial function is not defined.
Type parameters
- A1
the argument type of the fallback function
- B1
the result type of the fallback function
Value parameters
- that
the fallback function
Attributes
- Returns
a partial function which has as domain the union of the domains of this partial function and
that. The resulting partial function takesxtothis(x)wherethisis defined, and tothat(x)where it is not.- Source
- PartialFunction.scala
Composes this partial function with an action function which gets applied to results of this partial function.
Composes this partial function with an action function which gets applied to results of this partial function. The action function is invoked only for its side effects; its result is ignored.
Note that expressionpf.runWith(action)(x) is equivalent to
if(pf isDefinedAt x) { action(pf(x)); true } else falseexcept thatrunWith is implemented viaapplyOrElse and thus potentially more efficient. UsingrunWith avoids double evaluation of pattern matchers and guards for partial function literals.
Value parameters
- action
the action function
Attributes
- Returns
a function which maps arguments
xtoisDefinedAt(x). The resulting function runsaction(this(x))wherethisis defined.- See also
applyOrElse.- Source
- PartialFunction.scala
Tries to extract aB from anA in a pattern matching expression.
Tries to extract aB from anA in a pattern matching expression.
Attributes
- Source
- PartialFunction.scala
Inherited methods
Composes two instances ofFunction1 in a newFunction1, with this function applied last.
Composes two instances ofFunction1 in a newFunction1, with this function applied last.
Type parameters
- A
the type to which function
gcan be applied
Value parameters
- g
a function A => T1
Attributes
- Returns
a new function
fsuch thatf(x) == apply(g(x))- Inherited from:
- Function1
- Source
- Function1.scala
Returns a string representation of the object.
Returns a string representation of the object.
The default representation is platform dependent.
Attributes
- Returns
a string representation of the object.
- Definition Classes
- Inherited from:
- Function1
- Source
- Function1.scala
Inherited and Abstract methods
Apply the body of this function to the argument.
Apply the body of this function to the argument.
Attributes
- Returns
the result of function application.
- Inherited from:
- Function1
- Source
- Function1.scala