Haskell - 函数

---

---

函数在 Haskell 中扮演着重要的角色，因为它是一种函数式编程语言。与其他语言一样，Haskell 也有其自身的函数定义和声明。

• 函数声明由函数名、参数列表及其输出组成。

• 函数定义是您实际定义函数的地方。

让我们来看一个简单的add函数示例，来详细了解这个概念。

add :: Integer -> Integer -> Integer   --function declaration 
add x y =  x + y                       --function definition 

main = do 
   putStrLn "The addition of the two numbers is:"  
   print(add 2 5)    --calling a function 

在这里，我们在第一行声明了我们的函数，在第二行，我们编写了实际的函数，它将接收两个参数并产生一个整数类型的输出。

与大多数其他语言一样，Haskell 从main方法开始编译代码。我们的代码将生成以下输出：

The addition of the two numbers is:
7

模式匹配

模式匹配是匹配特定类型表达式的过程。它只是一个简化代码的技术。此技术可以实现到任何类型的类型类中。可以使用 If-Else 语句作为模式匹配的替代方案。

模式匹配可以被认为是动态多态性的一种变体，在运行时，可以根据参数列表执行不同的方法。

请看下面的代码块。在这里，我们使用了模式匹配技术来计算一个数的阶乘。

fact :: Int -> Int 
fact 0 = 1 
fact n = n * fact ( n - 1 ) 

main = do 
   putStrLn "The factorial of 5 is:" 
   print (fact 5)

我们都知道如何计算一个数的阶乘。编译器将开始搜索一个名为“fact”且带有一个参数的函数。如果参数不等于 0，则该数字将继续调用具有比实际参数小 1 的相同函数。

当参数的模式与 0 完全匹配时，它将调用我们的模式“fact 0 = 1”。我们的代码将产生以下输出：

The factorial of 5 is:
120

保护

保护是一个与模式匹配非常相似的概念。在模式匹配中，我们通常匹配一个或多个表达式，但是我们使用保护来测试表达式的某些属性。

虽然建议使用模式匹配而不是保护，但从开发人员的角度来看，保护更易读且更简单。对于第一次使用的人来说，保护看起来可能非常类似于 If-Else 语句，但它们的功能不同。

在下面的代码中，我们使用保护的概念修改了我们的阶乘程序。

fact :: Integer -> Integer 
fact n | n == 0 = 1 
       | n /= 0 = n * fact (n-1) 
main = do 
   putStrLn "The factorial of 5 is:"  
   print (fact 5) 

在这里，我们声明了两个由“|”分隔的保护，并从main调用fact函数。在内部，编译器的工作方式与模式匹配的情况相同，以产生以下输出：

The factorial of 5 is:
120

Where 子句

Where是一个关键字或内置函数，可在运行时使用以生成所需的输出。当函数计算变得复杂时，它非常有用。

考虑一种情况，您的输入是一个具有多个参数的复杂表达式。在这种情况下，您可以使用“where”子句将整个表达式分解成小部分。

在下面的示例中，我们正在使用一个复杂的数学表达式。我们将展示如何使用 Haskell 求解多项式方程 [x^2 - 8x + 6] 的根。

roots :: (Float, Float, Float) -> (Float, Float)  
roots (a,b,c) = (x1, x2) where 
   x1 = e + sqrt d / (2 * a) 
   x2 = e - sqrt d / (2 * a) 
   d = b * b - 4 * a * c  
   e = - b / (2 * a)  
main = do 
   putStrLn "The roots of our Polynomial equation are:" 
   print (roots(1,-8,6))

请注意我们计算给定多项式函数根的表达式的复杂性。它相当复杂。因此，我们使用where子句来分解表达式。上面的代码将生成以下输出：

The roots of our Polynomial equation are:
(7.1622777,0.8377223)

递归函数

递归是一种函数反复调用自身的的情况。Haskell 没有提供任何机制来循环执行任何表达式超过一次。相反，Haskell 希望您将整个功能分解成不同的函数集合，并使用递归技术来实现您的功能。

让我们再次考虑我们的模式匹配示例，我们在其中计算了一个数字的阶乘。查找数字的阶乘是使用递归的经典案例。在这里，您可能会问，“模式匹配与递归有什么不同？”这两者之间的区别在于它们的使用方式。模式匹配用于设置终止约束，而递归是函数调用。

在下面的示例中，我们同时使用了模式匹配和递归来计算 5 的阶乘。

fact :: Int -> Int 
fact 0 = 1 
fact n = n * fact ( n - 1 ) 

main = do 
   putStrLn "The factorial of 5 is:" 
   print (fact 5) 

它将产生以下输出：

The factorial of 5 is:
120

高阶函数

到目前为止，我们看到的是 Haskell 函数接收一种类型作为输入并产生另一种类型作为输出，这与其他命令式语言非常相似。高阶函数是 Haskell 的一个独特特性，您可以在其中使用函数作为输入或输出参数。

虽然这是一个虚拟概念，但在现实世界的程序中，我们在 Haskell 中定义的每个函数都使用高阶机制来提供输出。如果您有机会查看 Haskell 的库函数，您会发现大多数库函数都是以高阶方式编写的。

让我们来看一个示例，我们将导入一个内置的高阶函数 map 并使用它来根据我们的选择实现另一个高阶函数。

import Data.Char  
import Prelude hiding (map) 

map :: (a -> b) -> [a] -> [b] 
map _ [] = [] 
map func (x : abc) = func x : map func abc  
main = print $ map toUpper "tutorialspoint.com" 

在上面的示例中，我们使用了类型类Char的toUpper函数将我们的输入转换为大写。在这里，“map”方法将函数作为参数并返回所需的输出。以下是它的输出：

sh-4.3$ ghc -O2 --make *.hs -o main -threaded -rtsopts
sh-4.3$ main
"TUTORIALSPOINT.COM" 

Lambda 表达式

有时我们必须编写一个函数，该函数在应用程序的整个生命周期中只会被使用一次。为了处理这种情况，Haskell 开发人员使用另一个称为lambda 表达式或lambda 函数的匿名块。

没有定义的函数称为 lambda 函数。lambda 函数用“\”字符表示。让我们来看下面的例子，我们将把输入值增加 1，而无需创建任何函数。

main = do 
   putStrLn "The successor of 4 is:"  
   print ((\x -> x + 1) 4)

在这里，我们创建了一个没有名称的匿名函数。它将整数 4 作为参数并打印输出值。我们基本上是在操作一个函数，甚至没有正确声明它。这就是 lambda 表达式的魅力。

我们的 lambda 表达式将产生以下输出：

sh-4.3$ main
The successor of 4 is:
5