Scala 中的部分函数

介绍：
当一个函数不能为给它的每一个变量输入数据产生一个返回值时，这个函数被称为部分函数。它只能确定一些实际输入的子集的输出。它只能部分应用于所述输入。
一些重要的点：

偏函数有助于理解许多不一致的 Scala 函数。
它可以通过使用 case 语句来解释。
它是一个Trait，需要两个方法isDefinedAt和apply才能实现。

例子：

// Scala program of 
// Partial function
  
// Creating object 
object Case
{
  
    // Main method
    def main(args: Array[String])
    {
  
        // Creating Partial function 
        // using two methods
        val r = new PartialFunction[Int, Int] 
        {
  
            // Applying isDefinedAt method 
            def isDefinedAt(q: Int) = q != 0
  
            // Applying apply method
            def apply(q: Int) = 12 * q
  
        } 
  
        // Displays output if the
        // condition is satisfied
        println(r(10))
    }
}

输出：

这里，定义了两种方法来应用 Partial 函数，其中isDefinedAt说明条件， apply在满足给定条件时执行操作。
定义偏函数的方法：
有一些方法可以定义 Partial函数，包括case 语句、 collect 方法、 andThen和orElse 。

使用 Case 语句的偏函数：
我们将在下面使用 case 语句创建一个 Partial函数。
例子：

// Scala program using
// case statements
  
// Creating object 
object Case
{
  
    // Main method
    def main(args: Array[String])
    {
  
        // Creating Partial function
        val d: PartialFunction[Int, Int] =
        {
  
            // using case statement 
            case x if (x % 3) == 0 => x * 3
        }
  
        // Displays output if 
        // the condition is 
        // satisfied
        println(d(3))
    }
}

输出：

在这里，Partial函数是使用case语句创建的，因此这里不需要apply和isDefinedAt 。

使用 orElse 的偏函数：
此方法有助于将 Partial 函数链接在一起。
例子：

// Scala program using
// orElse
  
// Creating object 
object orElse
{
  
    // Main method
    def main(args: Array[String])
    {
  
        // Creating Partial function1
        val M: PartialFunction[Int, Int] = 
        {
  
            // using case statement 
            case x if (x % 5) == 0 => x * 5
        }
  
        // Creating Partial function2 
        val m: PartialFunction[Int, Int] = 
        {
  
            // using case statement 
            case y if (y % 2) == 0 => y * 2
        }
  
        // chaining two partial 
        // functions using orElse 
        val r = M orElse m
  
        // Displays output for 
        // which the given condition 
        // is satisfied
        println(r(5))
        println(r(4))
    }
}

输出：

25
8

在这里， orElse将返回满足给定条件的输出。

使用 Collect 方法的部分函数：
Collect方法向集合的每个元素请求 Partial函数，因此有助于构建新集合。
例子：

// Scala program using
// collect method
  
// Creating object 
object Collect
{
  
    // Main method
    def main(args: Array[String])
    {
  
        // Creating Partial function
        val M: PartialFunction[Int, Int] = 
        {
  
            // using case statement 
            case x if (x % 5) != 0 => x * 5
        }
  
        // Applying collect method
        val y = List(7, 15, 9) collect { M }
  
        // Displays output for which 
        // the given condition 
        // is satisfied
        println(y)
    }
}

输出：

List(35, 45)

在这里， Collect将对 List 的所有元素应用 Partial函数，并根据所述条件返回一个新的 List。

使用 andThen 的偏函数：
此方法附加在链的末尾，用于继续向附加的部分函数链。
例子：

// Scala program using
// andThen method
  
// Creating object 
object andThen
{
  
    // Main method
    def main(args: Array[String])
    {
  
        // Creating Partial function
        val M: PartialFunction[Int, Int] =
        {
  
            // using case statement 
            case x if (x % 4) != 0 => x * 4
        }
  
        // Creating another function
        val append = (x: Int) => x * 10
  
        // Applying andThen method 
        val y = M andThen append
  
        // Displays output after 
        // appending the another
        // function given
        println(y(7))
    }
}

输出：

在这里， andThen会将 Partial函数的输出附加到给定的另一个函数，然后返回该值。