【Haskell】分支表达式

最新推荐文章于 2022-08-15 11:30:00 发布

cheniie

最新推荐文章于 2022-08-15 11:30:00 发布

阅读量997

点赞数 2

分类专栏： Haskell 文章标签： haskell 分支语句

本文链接：https://blog.csdn.net/puss0/article/details/118393163

版权

Haskell 专栏收录该内容

7 篇文章 1 订阅

订阅专栏

文章目录

if-then-else
guard
多路if
case-of
小贴士：等号的误区

分支结构是编程中非常重要的语法结构，在Go语言中有if-else和switch-case，Haskell中也有对应的if-then-else和case-of。不同的是Haskell中的分支结构都是表达式，而不是语句。事实上，在Haskell中任何东西都是表达式。即便是向putStrLn这样的打印函数也是表达式，也就是说在Haskell中任何东西都必须是有值的。

if-then-else

我们以一个判断奇偶数的例子开始。

oddEeven a = if even a 
    then "even"
    else "old"

习惯了其他语言的if-else，在面对Haskell的if-else-then时，会感觉很不习惯，因为它必须有一个值。在Go语言中，if语句表达的是如果xxx做什么，否则做什么。而在Haskell中的if表达式表达的是如果xxx是什么，否则是什么。

我们在来实现一个简单的计算函数，感受if-then-else的嵌套。

caculate a b c = if b == '+' then Just(a + c)
            else if b == '-' then Just(a - c)
            else if b == '*' then Just(a * c)
            else if b == '/' then 
                 if c == 0 then Nothing
                           else Just(a / c)
            else Nothing

guard

guard称为哨兵模式，它是对if语法的扩展，用来简化有许多if判断的情况下的代码编写。我们还是以上面的计算函数为例，首先让我们来看看Go语言对多if分支的优化。

func calculate(a, b float64, c byte) (float64, error) {
	switch {
	case c == '+':
		return a + b, nil
	case c == '-':
		return a - b, nil
	case c == '*':
		return a * b, nil
	case c == '/':
		if b == 0 {
			return 0, fmt.Errorf("divide zero")
		} else {
			return a / b, nil
		}
	default:
		return 0, fmt.Errorf("operation not support")
	}
}

Haskell的哨兵模式和Go语言的switch有些相似，写法上要简洁许多。

caculate' a b c | b == '+' = Just (a + c)
                | b == '-' = Just (a - c)
                | b == '*' = Just (a * c)
                | b == '/' && c == 0 = Nothing 
                | b == '/' = Just (a / c)
                | otherwise = Nothing

注意看哨兵模式和普通函数在写法上的区别，Bool表达式出现在参数和=之间，以|开始，语法模式变成了函数名参数 | 条件 = 值。除了哨兵模式，在函数参数和=之间是不会有其他内容的。这也是一个经常让初学者感到困惑不已的地方。

哨兵模式最后的otherwise相当于Go里面的default，otherwise虽然也不是必须的，但是如果没有你会收到一条警告，并且当出现无法匹配的条件时，函数会直接崩溃。显然，遗漏otherwise并不是一个程序员该有的素养。

在哨兵模式中，条件会从上到下依次匹配。所以我们将b == '/' && c == 0放到了b=='/'的前面，当然也可以不去判断除数是否为零，因为在Haskell中除0会得到Infinity而不是崩溃，只是这里我们希望除0的结果是Nothing。

哨兵模式不能自我嵌套，从它的语法结构就决定了这一点。至于=后面，只要是表达式就行，比如我们可以用if表达式重写上面的代码。

caculate'' a b c | b == '+' = Just (a + c)
                 | b == '-' = Just (a - c)
                 | b == '*' = Just (a * c)
                 | b == '/' = if c == 0 then Nothing else Just (a / c)
                 | otherwise = Nothing

缩进对于Haskell来说非常重要，因为它会通过缩进来识别段落。但是无论编译器是否依赖于缩进，你都应该把你的代码对齐，因为这也是程序员的基本素养。

多路if

多路if英文名叫 MultiWayIf，这是Haskell的一个语言扩展，必须打开这个扩展才能支持多路if的语法。注意是语法级别的支持，开启的方式是在文件开头加上一行特殊的注释{-# LANGUAGE MultiWayIf #-}。

{-# LANGUAGE MultiWayIf #-}

caculate''' a b c = if | b == '+' -> Just (a + c)
                       | b == '-' -> Just (a - c)
                       | b == '*' -> Just (a * c)
                       | b == '/' -> if c == 0 then Nothing else Just (a / c)
                       | otherwise -> Nothing

MultiWayIf 要比else if简洁许多，看完简直想把else-if丢进垃圾桶。

case-of

case-of对于Go语言中的switch-case，不同的是，case-of也是表达式。

caculate'''' a b c = case b of '+' -> Just (a + c)
                               '-' -> Just (a - c)
                               '*' -> Just (a * c)
                               '/' -> case c of 0 -> Nothing
                                                _ -> Just (a / c)
                               _   -> Nothing