haskell函数

  1. 带有类型类的函数定义
  2. 带有多个类型的函数定义
    1. 不带有类型类的函数定义
    2. 函数定义
    3. 类型自动推断的函数定义
    4. 函数后跟’
  • 函数类型
    1. 柯里化函数
    2. 偏函数
    3. 非柯里化函数
    4. 多态函数
    5. 重载类型函数
  • 参数绑定
    1. let…in…
      1. 替换表达式
      2. 替换多个表达式
      3. 替换函数
      4. 常用函数
      5. 列表函数

    我们采用如下格式定义一个函数
    1
    2
    函数名 :: 参数1的类型 -> 参数2的类型 -> ... -> 结果类型 (1)
    函数名 参数1 参数2 ... = 函数体 (2)
    1. 定义函数签名
    2. 定义函数

    下面我们举例出多种函数定义变体形式:

    带有类型类的函数定义

    1
    2
    add :: Num t => t -> t -> t
    add x y = x + y

    带有多个类型的函数定义

    1
    2
    add :: (Show t, Int t) => t -> t -> t
    add x y = x + y

    不带有类型类的函数定义

    1
    2
    add :: Int -> Int -> Int
    add x y = x + y

    函数定义

    1
    add x y = x + y :: Int

    类型自动推断的函数定义

    1
    add x y = x + y

    函数后跟’

    在函数名后加一个',与原函数这代表着俩个函数.

    1
    2
    3
    4
    5
    6
    add' :: Num t => t -> t -> t
    add' x y = x + y

    add :: Num t => t -> t -> t
    add x y = x + y

    函数类型

    柯里化函数

    当调用一个N参数的函数时, 传递M个参数(N < M),那么该参数返回的结果也是一个函数.这个过程称为柯里化.

    但是并不是每种函数都可以这么调用,只有下面形式的函数才可以这么调用.

    1
    2
    add :: Num t => t -> t -> t
    add x y = x + y

    当我们只向add函数传递一个参数5的时候,我们会得到下面一个这样子的函数:

    1
    2
    3
    4
    add 5 y = 5 + y

    函数类型为:
    add :: Num t => t -> t

    偏函数

    如果调用函数时,参数列表不完整,这时就称为函数的不完全应用,也称为偏函数.

    非柯里化函数

    非柯里化的函数,必须在调用的时候,将所有参数都放到元组中,然后传递给函数.

    1
    2
    add :: Num t => (t ,t) -> t
    add (x, y) = x + y

    多态函数

    1

    重载类型函数

    1

    参数绑定

    let…in…

    let里定义的部分会在函数体中进行替换

    替换表达式

    1
    2
    3
    4
    s :: Double -> Double -> Double -> Double
    s a b c =
    let p = (a + b + c) / 2
    in sqrt (p * (p - a) * (p - b) * (p - c))

    替换多个表达式

    1

    替换函数

    • where
      1
      2
      3
      s :: Double -> Double -> Double -> Double
      s a b c = sqrt (p * (p - a) * (p - b) * (p - c))
      where p = (a + b + c) / 2

    常用函数

    • 恒值函数id
    1

    • 常数函数const
    1

    • 参数反置函数flip
    1

    • 错误函数error
    1

    • undifine函数
    1

    • min/max函数
      1

    列表函数

    • null
    1

    • length
    1

    • !!
    1

    • reverse
    1

    • head
    1

    • last
    1

    • tail
    1

    • init
    1

    • map
    1

    • filter
    1

    • take
    1

    • drop
    1

    • span
    1

    • break
    1

    • takeWhile
    1

    • dropWhile
    1

    • spiltAt
    1

    • repeat
    1

    • replicate
    1

    • any
    1

    • all
    1

    • elem
    1

    • notelem
    1

    • iterate
    1

    • until
    1

    • zip
    1

    • concat
    1

    • concatMap