Haskell语法基础 #

-- 这是单行注释
x = 5  -- 行尾注释

-- 计算平方
square x = x * x  -- 返回x的平方

{-
  这是多行注释
  可以跨越多行
  用于详细说明
-}

add x y = x + y

{- 也可以用于行内注释 -}

{-
  外层注释开始
  {- 内层注释 -}
  外层注释结束
-}

-- | 计算阶乘
-- 
-- >>> factorial 5
-- 120
factorial :: Integer -> Integer
factorial 0 = 1
factorial n = n * factorial (n - 1)

-- | 加法函数
-- 接受两个参数，返回它们的和
add :: Int -> Int -> Int
add x y = x + y

-- 合法的变量名
name = "Haskell"
firstName = "John"
_count = 0
myFunction x = x + 1

-- 非法变量名（以大写开头）
-- Name = "Haskell"  -- 错误！

-- 合法的类型和构造器名
data Color = Red | Green | Blue

data Person = Person String Int

-- 类型变量使用小写
identity :: a -> a
identity x = x

-- 驼峰命名（推荐）
firstName = "John"
lastName = "Doe"
calculateTotal = sum

-- 下划线命名（不推荐，但合法）
first_name = "John"
last_name = "Doe"

-- 类型参数使用单字母
map :: (a -> b) -> [a] -> [b]

-- 或有意义的名称
map :: (input -> output) -> [input] -> [output]

-- 自定义操作符
(+-) :: Int -> Int -> Int
x +- y = x + y - 1

-- 使用反引号将函数变为中缀
add x y = x + y
result = 5 `add` 3  -- 等于 8

-- if-then-else
absolute x = if x >= 0 then x else -x

-- case-of
describe 0 = "zero"
describe 1 = "one"
describe _ = "many"

-- let-in
result = let x = 5 in x * x

-- where
area r = pi * r * r
  where pi = 3.14159

-- data
data Maybe a = Nothing | Just a

-- class
class Show a where
    show :: a -> String

-- instance
instance Show Bool where
    show True = "True"
    show False = "False"

-- 算术运算
(+)  :: Num a => a -> a -> a
(-)  :: Num a => a -> a -> a
(*)  :: Num a => a -> a -> a
(/)  :: Fractional a => a -> a -> a
(^)  :: Num a => a -> Int -> a   -- 整数幂
(^^) :: Fractional a => a -> Integer -> a
(**) :: Floating a => a -> a -> a

-- 比较运算
(==) :: Eq a => a -> a -> Bool
(/=) :: Eq a => a -> a -> Bool
(<)  :: Ord a => a -> a -> Bool
(<=) :: Ord a => a -> a -> Bool
(>)  :: Ord a => a -> a -> Bool
(>=) :: Ord a => a -> a -> Bool

-- 逻辑运算
(&&) :: Bool -> Bool -> Bool
(||) :: Bool -> Bool -> Bool
not  :: Bool -> Bool

-- 普通函数应用（最高优先级）
f x = f $ x

-- 低优先级应用
($) :: (a -> b) -> a -> b
f $ x = f x

-- 示例
result = sum $ map (*2) [1..10]
-- 等价于
result = sum (map (*2) [1..10])

-- 组合操作符
(.) :: (b -> c) -> (a -> b) -> (a -> c)
(f . g) x = f (g x)

-- 示例
doubleAndAddOne = (+1) . (*2)
-- doubleAndAddOne 5 = 11

-- 构造器
(:) :: a -> [a] -> [a]
1 : [2, 3]  -- [1, 2, 3]

-- 拼接
(++) :: [a] -> [a] -> [a]
[1, 2] ++ [3, 4]  -- [1, 2, 3, 4]

-- 访问
(!!) :: [a] -> Int -> a
[1, 2, 3] !! 1  -- 2

-- 函数应用优先级最高（10）
f x y  -- 从左到右

-- 常见优先级
infixl 9  !!            -- 列表索引
infixr 9  .             -- 函数组合
infixl 8  ^, ^^, **     -- 幂运算
infixl 7  *, /, `div`, `mod`
infixl 6  +, -          -- 加减
infixr 5  ++            -- 列表拼接
infix  4  ==, /=, <, <=, >, >=
infixr 3  &&            -- 逻辑与
infixr 2  ||            -- 逻辑或
infixr 1  >>, >>=       -- Monad操作
infixr 0  $, $!, `seq`  -- 低优先级应用

-- 使用缩进
main = do
    putStrLn "Hello"
    putStrLn "World"

-- 等价于使用大括号
main = do { putStrLn "Hello"; putStrLn "World" }

-- 正确：where块缩进
factorial n
    | n <= 0    = 1
    | otherwise = n * factorial (n - 1)
  where
    helper = ...

-- 错误：缩进不一致
-- factorial n
-- | n <= 0 = 1    -- 错误！缩进不够

-- let-in表达式
result = let x = 1
             y = 2
         in x + y

-- where子句
area width height = width * height
  where
    width = 10
    height = 5

-- 推荐
add :: Int -> Int -> Int
add x y = x + y

-- 不推荐（虽然类型推断可以工作）
add x y = x + y

-- 推荐：每个参数单独一行
longFunction :: Int -> Int -> Int -> Int
longFunction a b c = a + b + c

-- 或使用对齐
function :: Int
         -> Int
         -> Int
function x y = x + y

-- 标准模块结构
module MyModule
    ( -- 导出列表
      func1
    , func2
    , Type1(..)
    ) where

-- 导入
import Data.List (sort, nub)
import qualified Data.Map as M

-- 类型定义
data Type1 = ...

-- 函数定义
func1 :: ...
func1 = ...

-- 布尔值使用is/has前缀
isEmpty :: [a] -> Bool
hasElement :: Eq a => a -> [a] -> Bool

-- 转换函数使用to前缀
toString :: Show a => a -> String

-- 危险函数使用unsafe前缀
unsafeHead :: [a] -> a