专业Haskell编程指南：速查与实例

需积分: 9 170 浏览量更新于2024-07-19 收藏 1.89MB PDF 举报

《Haskell专业笔记》是一本针对专业开发者的免费教程，以笔记的形式呈现，旨在提供超过200页的深入且实用的Haskell编程指南。该书覆盖了从基础入门到高级特性的广泛内容，帮助读者快速上手并掌握函数式编程语言Haskell。第1章是“Haskell语言入门”，包括以下子节： 1.1 起步：这部分会引导读者安装和配置Haskell环境，并介绍编程的基本概念。 1.2 "Hello, World!" 示例：通过一个简单的问候程序，展示如何编写和运行第一个Haskell程序。 1.3 计算阶乘：通过实例学习递归和函数定义，展示基本数学运算在Haskell中的应用。 1.4 使用惰性求值计算斐波那契数列：探讨如何利用Haskell的特性优化性能，尤其是在处理无穷序列时。 1.5 检测素数：演示数字分解和条件逻辑在查找质数中的运用。第二章是“重载符法”，涵盖了不同类型数据的操作： 2.1 字符串操作：介绍字符串的处理，如创建、连接和格式化。 2.2 浮点数和整数：理解不同数值类型以及它们在表达式中的处理方式。 2.3 列表的重载：探讨如何使用不同的语法创建和操作列表。 2.4 更广泛的数值和类型转换示例。第三章深入解析“可折叠”（Foldable）特性： 3.1 可折叠的定义：解释这个概念在Haskell中的作用，它是处理数据结构的一种核心工具。 3.2 二叉树的实例：通过具体例子展示如何将抽象数据类型与Foldable接口相结合。 3.3 统计结构元素：学习如何用foldl、foldr等函数计算结构中的元素数量。 3.4 反向折叠：探索如何在数据结构中实现倒序处理。 3.5 折叠结构转化为列表：展示如何将复杂结构扁平化为简单的列表操作。这本书不仅适合希望提升Haskell技能的专业开发者，也对想要理解函数式编程理念的读者具有参考价值。通过逐章学习和实践，读者可以快速成长为Haskell编程高手。同时，由于这是一本非官方教程，确保所有内容都经过作者精心整理，适合初学者和有经验的开发者查阅和参考。

GoalKicker.com – Haskell Notes for Professionals 6

Section 1.3: Factorial

The factorial function is a Haskell "Hello World!" (and for functional programming generally) in the sense that it

succinctly demonstrates basic principles of the language.

Variation 1

fac :: (Integral a) => a -> a

fac n = product [1..n]

Live demo

Integral is the class of integral number types. Examples include Int and Integer.

(Integral a) => places a constraint on the type a to be in said class

fac :: a -> a says that fac is a function that takes an a and returns an a

product is a function that accumulates all numbers in a list by multiplying them together.

[1..n] is special notation which desugars to enumFromTo 1 n, and is the range of numbers 1 ≤ x ≤ n.

Variation 2

fac :: (Integral a) => a -> a

fac 0 = 1

fac n = n * fac (n - 1)

Live demo

This variation uses pattern matching to split the function deﬁnition into separate cases. The ﬁrst deﬁnition is

invoked if the argument is

(sometimes called the stop condition) and the second deﬁnition otherwise (the order of

deﬁnitions is signiﬁcant). It also exempliﬁes recursion as fac refers to itself.

It is worth noting that, due to rewrite rules, both versions of fac will compile to identical machine code when using

GHC with optimizations activated. So, in terms of eﬃciency, the two would be equivalent.

Section 1.4: Fibonacci, Using Lazy Evaluation

Lazy evaluation means Haskell will evaluate only list items whose values are needed.

The basic recursive deﬁnition is:

f (0) <- 0

f (1) <- 1

f (n) <- f (n-1) + f (n-2)

If evaluated directly, it will be very slow. But, imagine we have a list that records all the results,

fibs !! n <- f (n)

Then

┌──────┐ ┌──────┐ ┌──────┐

│ f(

) │ │ f(1) │ │ f(2) │

fibs ->

: 1 : │ + │ : │ + │ : │ + │ : .....

│ f(1) │ │ f(2) │ │ f(3) │

└──────┘ └──────┘ └──────┘

┌────────────────────────────────────────┐

GoalKicker.com – Haskell Notes for Professionals 7

│ f(

) : f(1) : f(2) : ..... │

└────────────────────────────────────────┘

-> 0 : 1 : +

┌────────────────────────────────────────┐

│ f(1) : f(2) : f(3) : ..... │

└────────────────────────────────────────┘

This is coded as:

fibn n = fibs !! n

where

fibs = 0 : 1 : map f [2..]

f n = fibs !! (n-1) + fibs !! (n-2)

Or even as

GHCi> let fibs = 0 : 1 : zipWith (+) fibs (tail fibs)

GHCi> take 10 fibs

[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

zipWith makes a list by applying a given binary function to corresponding elements of the two lists given to it, so

zipWith (+) [x1, x2, ...] [y1, y2, ...] is equal to [x1 + y1, x2 + y2, ...].

Another way of writing fibs is with the scanl function:

GHCi> let fibs = 0 : scanl (+) 1 fibs

GHCi> take 10 fibs

[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

scanl builds the list of partial results that foldl would produce, working from left to right along the input list. That

is, scanl f z0 [x1, x2, ...] is equal to [z0, z1, z2, ...] where z1 = f z0 x1; z2 = f z1 x2; ....

Thanks to lazy evaluation, both functions deﬁne inﬁnite lists without computing them out entirely. That is, we can

write a fib function, retrieving the nth element of the unbounded Fibonacci sequence:

GHCi> let fib n = fibs !! n -- (!!) being the list subscript operator

-- or in point-free style:

GHCi> let fib = (fibs !!)

GHCi> fib 9

Section 1.5: Primes

A few most salient variants:

Below 100

import Data.List ( (\\) )

ps100 = ((([2..100] \\ [4,6..100]) \\ [6,9..100]) \\ [10,15..100]) \\ [14,21..100]

-- = (((2:[3,5..100]) \\ [9,15..100]) \\ [25,35..100]) \\ [49,63..100]

-- = (2:[3,5..100]) \\ ([9,15..100] ++ [25,35..100] ++ [49,63..100])

Unlimited

Sieve of Eratosthenes, using data-ordlist package:

剩余229页未读，继续阅读

欧林猫

粉丝: 3
资源: 3

专业Haskell编程指南：速查与实例

haskell-mode emacs

Functional Systems In Haskell Lecture Notes(Stanford CS240h)

Notes on Functional Programming with Haskell

haskell 安装

haskell学习网站

centos7安装haskell

Describe and contrast overloading in Java and Haskell.

haskell趣学指南 pdf

haskell函数式编程基础 pdf

haskell实现冒泡排序

最新资源