一、源文件
介绍这个主要是因为下文很多代码写在源文件中,然后从ghci加载源文件进行测试。
创建一个文本文件,在其中输入,并保存为add.hs文件
-- file: add.hs
add x y = x - y
打开ghci,加载刚才的文件(假设文件目录为e:haskelladd.hs),命令如下
ghci> :cd e:haskell ghci> :load add.hs ghci> add 2 1
二、语言特性
1. 延迟计算
表达式的值在需要用到的时候才被计算,比如在一个文本文档中输入如下,并保存为lazy.hs
-- file: lazy.hs add x y = if left || right then x + y else x -y left = True right = length [1..] > 0
然后加载这个文件,并执行 add 2 1,你会发现结果为3,而不是一直等待计算结果,说明right的值并没有被计算出来。在很多其他语言中(如C#),逻辑或or被特殊处理,从而在左分量为真的时候对右分量短路(short-circuits),而haskell中,(||)运算符只是一个普通的函数,并由于其延迟计算的特性,导致左分量为真的时候,右分量不被计算出来。当然了,haskell中也可以写出短路的逻辑或函数
myOr l r = if l then l else r
haskell中还有一个称作守卫表达式的东东,上面说的myOr函数等价于
-- file: myOr.hs myOr l r | l = l myOr l r = r
2. 类型
a) 函数类型
我们看take函数的类型
ghci> :type take
take :: Int -> [a] -> [a]
符号->是右结合的,即,类型说明等价于
take :: Int -> ([a] -> [a])
b)代数数据类型
定义一个新的数据类型
-- file: Object.hs data ObjectProperty = Object Int String [String] deriving (Show)
这个类型ObjectProperty与三元组(Int, String, [String])的元素相同,然而haskell认为它们类型不相同。如果要定义一个ObjectProperty类型变量,
ghci> let object = Object 0 "i" ["j", "k"] ghci> :type it it :: ObjectProperty
ghci> :type Object
Object :: Int -> String -> [String] -> ObjectProperty
分析: Object是值(数据)构造器,ObjectProperty是对象类型,当然,也可以将对象类型与值构造器写成相同的,如
data Object = Object Int String [String]
然而两者仅仅是名称相同而已。
对于Object的元素分别为Int,String等类型,还可以自定义这些类型的同义类型,如下
-- file: Object.hs type ObjectId = Int type ObjectName = String type ObjectFields = [String] data Object = Object ObjectId ObjectName ObjectFields
其实跟C++中的typedef关键字类似。
可以查看值构造器Object的类型(是一个函数)
ghci> :type Object
Object :: ObjectId -> ObjectName -> ObjectFields -> Object
由于Object类型中元素是匿名的,可以通过匹配来获取元素值,例如
ghci> let object = Object 0 "a" ["b", "c"] ghci> let Object x y z = object ghci> x 0 ghci> :type x x :: ObjectId
c)枚举类型
-- file: Roygbiv.hs data Roygbiv = Red | Orange | Yellow | Green | Blue deriving (Eq, Show)
其中Red、Orange等都为值构造器
d) 记录类型
前面简单介绍过模式匹配。比如想内窥一下Object(前文介绍的自定义代数数据类型)的内部元素,则可以使用模式匹配,我们这次定义一个函数来获取某个元素
getId (Object id _ _) = id getName (Object _ name _) = name getFields (Object _ _ fields) = fields
然而这种方法还是显得代码大块,看起来不爽。
可以定义记录类型,如下
-- file: Object.hs data Object = Object { oid :: Int, oname :: String, ofields :: [String] } deriving (Show)
这个类型定义其实跟下面的形式几乎相同
-- file: Object.hs data Object = Object Int String [String] deriving (Show) getId :: Object -> Int getId (Object id _ _) = id getName :: Object -> String getName (Object _ name _) = name getFields :: Object -> [String] getFields (Object _ _ fields) = fields
加载上面那个文件时,依然可以向以前那么使用Object类型
ghci> let object = Object 1 "az" ["b"]
或者如下使用
ghci> -- order of elements can be varied
ghci> let object = Object{oid = 10, ofields = ["i"], oname="str"}
e)参数化类型
跟C#中的泛型类似。比如定义一个类型MyMaybe如下(注意与Prelude模块中的Maybe区分,虽然功能类似)
-- file: Maybe.hs data MyMaybe a = MyJust a | MyNothing
这里a就是参数化类型,a可以是String或者Int等,还可以是MyMaybe类型,即嵌套
ghci> let a = MyJust 1 ghci> let b = Just a ghci> :type b b :: Num a => Maybe (MyMaybe a)
f)递归类型
haskell中的List类型与C#中的不同,它是一个递归类型,如下
-- file: MyList.hs data MyList a = Cons a (MyList a) | Empty deriving (Show)
这样设计,使得对其进行递归计算方便。
比如获取List的首项,可以写成如下
-- append to the former MyList.hs file end x = Empty y = Cons 1 x myHead (Cons i j) = i myHead Empty = error "MyList.myHead: empty list"
这里对Empty获取首项会抛出一个错误,这样处理还是可以的,我们不能返回Empty,否则跟myHead的第一个计算式的返回类型不同(第一个计算式返回类型为a,而Empty类型为MyList a)。不过,如果结合Maybe类型,或者上面介绍的MyMaybe类型,则可以避免抛出错误,从而使得代码更好看些。处理如下
myHead (Cons i j) = MyJust i
myHead Empty = MyNothing