How to use partial functions and partial applied functions in Java and Scala

Partial Function

Partial Function (Partial Function) is a mathematical concept. It is not a type of "function". It is a parallel concept to the function.

Partia Function in Scala is a Trait whose type is PartialFunction[A,B], which receives a parameter of type A and returns a result of type B.

For example:

    val pf: PartialFunction[Int, String] = {
      case 1 => "One"
      case 2 => "Two"
      case 3 => "Three"
      case _ => "Other"
    }
    println(pf(1))   //One
    println(pf(2))   //Two
    println(pf(3))   //Three
    println(pf(4))   //Other

There are some methods inside the partial function, such as isDefinedAt, OrElse, andThen, applyOrElse, etc.

isDefinedAt

isDefinedAt: The function of this function is to determine whether the incoming parameters are within the range processed by this partial function.

Try to use isDefinedAt() with the pf just defined. As long as the number is a number, it is correct because there is case _=>"Other". If you change it to another type, an error will be reported.

    val pf: PartialFunction[Int, String] = {
      case 1 => "One"
      case 2 => "Two"
      case 3 => "Three"
      case _ => "Other"
    }
    println(pf.isDefinedAt(1)) //true
    println(pf.isDefinedAt(2)) //true
    println(pf.isDefinedAt(3)) //true
    println(pf.isDefinedAt(4)) //true
    println(pf.isDefinedAt("1"))
    /**
     * 类型不匹配
     * type mismatch;
     * found   : String("1")
     * required: Int
     * println(pf.isDefinedAt("1")) */

orElse

orElse: Use multiple partial functions in combination, the effect is similar to a case statement.

    val onePF: PartialFunction[Int, String] = {
      case 1 => "One"
    }
    val twoPF: PartialFunction[Int, String] = {
      case 2 => "Two"
    }
    val threePF: PartialFunction[Int, String] = {
      case 3 => "Three"
    }
    val otherPF: PartialFunction[Int, String] = {
      case _ => "Other"
    }
    val newPF = onePF orElse twoPF orElse threePF orElse otherPF
    println(newPF(1))  //One
    println(newPF(2))  //Two
    println(newPF(3))  //Three
    println(newPF(4))  //Other

In this way, newPF has the same effect as the original PF.

andThen

andThen: Equivalent to continuous calls of methods, such as g(f(x)).

The result return type of pf1 must be consistent with the parameter input type of pf2, otherwise an error will be reported.

   val pf1: PartialFunction[Int, String] = {
      case i if i == 1 => "One"
    }
    val pf2: PartialFunction[String, String] = {
      case str if str eq "One" => "The num is 1"
    }
    val num = pf1 andThen pf2
    println(num(1)) //The num is 1

applyOrElse

applyOrElse: It receives 2 parameters, the first is the calling parameter, and the second is a callback function. If the parameters of the first call match, the matching value is returned, otherwise the callback function is called.

  val pf: PartialFunction[Int, String] = {
      case 1 => "One"
    }
    println(pf.applyOrElse(1, { num: Int => "two" }))  //One
    println(pf.applyOrElse(2, { num: Int => "two" }))  //two

Partial Applied Function

Partial Applied Function (Partial Applied Function) is also called partially applied function. Judging from the English name of Partial Function, there is only one word difference, but they There is a world of difference between the two.

Partial application function means that a function has n parameters, and if we provide it with less than n parameters, we get a partial application function.

For example, define a function with 3 parameters, and then provide several partial application functions with 1-2 known parameters

def add(x: Int, y: Int, z: Int) = x + y + z
    // x 已知
    def addX = add(1, _: Int, _: Int)
    println(addX(2, 3)) //6
    println(addX(3, 4)) //8
    // x 和 y 已知
    def addXAndY = add(10, 100, _: Int)
    println(addXAndY(1)) //111
    // z 已知
    def addZ = add(_: Int, _: Int, 10)
    println(addZ(1, 2)) //13

The above is the detailed content of How to use partial functions and partial applied functions in Java and Scala. For more information, please follow other related articles on the PHP Chinese website!