Трейт scala.PartialFunction

трейт PartialFunction[-A, +B] extends A => B

Частичная функция типа PartialFunction[A, B] — это унарная функция, область определения которой не обязательно включает все значения типа A. Функция isDefinedAt позволяет динамически проверить, принадлежит ли значение области определения функции.

Даже если isDefinedAt возвращает true для a: A, вызов apply(a) всё ещё может выбросить исключение, поэтому следующий код является корректным:

val f: PartialFunction[Int, Any] = { case x => x / 0 }   // ArithmeticException: / by zero

Ответственность вызывающей стороны состоит в вызове isDefinedAt перед вызовом apply, потому что если isDefinedAt ложно, не гарантируется, что apply выбросит исключение для обозначения ошибки. Если исключение не выброшено, вычисление может привести к произвольному значению.

Обычно этот контракт соблюдается с помощью вызова applyOrElse, который ожидается более эффективным, чем вызов как isDefinedAt, так и apply.

Основное различие между PartialFunction и scala.Function1 заключается в том, что пользователь PartialFunction может выбрать другое поведение для входных данных, которые объявлены вне области определения. Например:

val sample = 1 to 10
def isEven(n: Int) = n % 2 == 0
val 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 as
val 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]"))

Абстрактные методы

Источник

def isDefinedAt(x: A): Boolean

Проверяет, содержится ли значение в области определения функции.

Конкретные методы

Источник

override def andThen[C](k: B => C): PartialFunction[A, C]

Компонует эту частичную функцию с функцией преобразования, которая применяется к результатам этой частичной функции.

Если тип выполнения функции — PartialFunction, то используется другой метод andThen (обратите внимание на его предостережения).

Источник

def andThen[C](k: PartialFunction[B, C]): PartialFunction[A, C]

Компонует эту частичную функцию с другой частичной функцией, которая применяется к результатам этой частичной функции.

Обратите внимание, что вызов isDefinedAt для полученной частичной функции может применить первую частичную функцию и выполнить её побочный эффект. Для повышения эффективности рекомендуется вызывать applyOrElse вместо isDefinedAt или apply.

Источник

def applyOrElse[A1 <: A, B1 >: B](x: A1, default: A1 => B1): B1

Применяет эту частичную функцию к заданному аргументу, когда он содержится в области определения функции. Применяет функцию по умолчанию, когда эта частичная функция не определена.

Обратите внимание, что выражение pf.applyOrElse(x, default) эквивалентно

if(pf isDefinedAt x) pf(x) else default(x)

за исключением того, что метод applyOrElse может быть реализован более эффективно. Для всех литералов частичных функций компилятор генерирует реализацию applyOrElse, которая избегает двойной оценки совпадений шаблонов и условий. Это делает applyOrElse основой для эффективной реализации во многих операциях и сценариях, таких как:

- объединение частичных функций в цепочки orElse/andThen не приводит к чрезмерной оценке apply/isDefinedAt - lift и unlift не оценивают исходные функции дважды при каждом вызове - runWith позволяет эффективно объединять частичные функции с условными действиями

Для нелитеральных классов частичных функций с нетривиальным методом isDefinedAt рекомендуется переопределять applyOrElse с пользовательской реализацией, которая избегает двойной оценки isDefinedAt. Это может привести к лучшей производительности и более предсказуемому поведению относительно побочных эффектов.

Источник

def compose[R](k: PartialFunction[R, A]): PartialFunction[R, B]

Компонует другую частичную функцию k с этой частичной функцией так, что эта частичная функция применяется к результатам k.

Обратите внимание, что вызов isDefinedAt для полученной частичной функции может применить первую частичную функцию и выполнить её побочный эффект. Для повышения эффективности рекомендуется вызывать applyOrElse вместо isDefinedAt или apply.

Источник

def elementWise: ElementWiseExtractor[A, B]

Возвращает объект-экстрактор с методом unapplySeq, который извлекает каждый элемент данных последовательности.

val firstChar: String => Option[Char] = _.headOption
Seq("foo", "bar", "baz") match {
  case firstChar.unlift.elementWise(c0, c1, c2) =>
    println(s"$c0, $c1, $c2") // Output: f, b, b
}

Источник

def lift: A => Option[B]

Преобразует эту частичную функцию в обычную функцию, возвращающую Option результат.

Источник

def orElse[A1 <: A, B1 >: B](that: PartialFunction[A1, B1]): PartialFunction[A1, B1]

Компонует эту частичную функцию с резервной частичной функцией, которая применяется в тех случаях, когда эта частичная функция не определена.

Источник

def runWith[U](action: B => U): A => Boolean

Компонует эту частичную функцию с функцией действия, которая применяется к результатам этой частичной функции. Функция действия вызывается только для побочных эффектов; ее результат игнорируется.

Обратите внимание, что выражение pf.runWith(action)(x) эквивалентно

if(pf isDefinedAt x) { action(pf(x)); true } else false

за исключением того, что runWith реализована с помощью applyOrElse и, следовательно, потенциально более эффективна. Использование runWith позволяет избежать двойной оценки совпадений шаблонов и условий для литералов частичных функций.

Источник

def unapply(a: A): Option[B]

Пытается извлечь B из A в выражении сопоставления с образцом.

Наследованные методы

Источник

def apply(v1: A): B

Применяет тело этой функции к аргументу.

Источник@unspecialized

def compose[A](g: A => A): A => B

Компонует два экземпляра Function1 в новый Function1, с применением этой функции последней.

Исходный код

override def toString(): String