摘要：生成隨機(jī)數(shù)對于一個函數(shù)，如果兩次調(diào)用它時使用相同的參數(shù)，它會把同樣的結(jié)果返回兩次。但是，這也使得產(chǎn)生隨機(jī)數(shù)這件事變成困難。對于同一個生成器，得到的隨機(jī)數(shù)是固定的。

系列文章

《Haskell趣學(xué)指南》筆記之基本語法

《Haskell趣學(xué)指南》筆記之類型（type）

《Haskell趣學(xué)指南》筆記之函數(shù)

《Haskell趣學(xué)指南》筆記之高階函數(shù)

《Haskell趣學(xué)指南》筆記之模塊

《Haskell趣學(xué)指南》筆記之自定義類型

《Haskell趣學(xué)指南》筆記之I/O

在 helloworld.hs 里寫入 main = putStrLn "hello, world!

運(yùn)行 ghc --make helloworld

運(yùn)行 ./helloworld

得到輸出 hello, world!

然后來看看函數(shù)的類型

ghci> :t putStrLn 
putStrLn :: String -> IO () 
ghci> :t putStrLn "hello, world" 
putStrLn "hello, world" :: IO () 
ghci> :k IO
IO :: * -> *
ghci> :k IO()
IO() :: *

IO () 返回的類型為 ()，即空元組，也叫單元。下一節(jié)會出現(xiàn)的 IO String 返回的類型為 String。

() 即使一個類型，也是對應(yīng)類型的值。

do 語法可以將多個 I/O 操作合成一個。

main = do   
    putStrLn "Hello, what" s your name");   
    name <- getLine   
    putStrLn ("Hey " ++ name ++ ", you rock!") 

getLine 的類型為 IO String

getLine 是一個產(chǎn)生字符串的 I/O 操作

注意 name <- 并沒有寫成 name =

只有在 I/O 操作的上下文中才能讀取 I/O 操作的內(nèi)容，這就是 Haskell 隔離『純代碼』和『不純的代碼』的方式

do語法會自動將最后一個操作的值作為自己的返回值

nameTag = "Hello, my name is " ++ getLine 

++ 左邊的類型是 String，右邊的類型為 IO String，所以上面的代碼會報錯。必須通過 name <- getLine 取出這個 String，才能繼續(xù)。只能在不純的環(huán)境中處理不純的數(shù)據(jù)。不然不純的代碼會像污水那樣污染其余的代碼，保持 I/ O 相關(guān)的代碼盡可能小，這對我們的健康有好處。

如果代碼寫成了這樣

myLine = getLine 

這只是給 getLine 增加了一個別名！從 I/O 操作獲取值的唯一方法是使用 <- 。每次我們在 GHCi 中按下回車鍵，GHCi 都會對返回值應(yīng)用 show，再將生成的字符串交給 putStrLn，從而輸出到終端。

Haskell 的 return 跟其他語言不一樣，return 能夠基于一個純的值來構(gòu)造 I/O 操作。而且 return 不會中斷代碼。所以，在 I/O 上下文中，return "hi" 的類型就是 IO String。那么將一個純值轉(zhuǎn)換為一個什么都不做的 I/ O 操作又有什么意義呢？作用之一是 return () 能夠構(gòu)建一個什么都不做的 I/O 操作。

putStr

putStr

print （相當(dāng)于 putStrLn . show）

when $ do IO操作

sequence [getLine getLine] 用 <- 取多個 I/O 操作的結(jié)果組成一個列表

mapM print [1, 2, 3] 等價于 sequence $ map print [1, 2, 3]

mapM_ 則是不保留返回值版本的 mapM

forever $ do IO操作

forM 則是把 mapM 的參數(shù)位置對換，某些時候比較方便

getContents 從標(biāo)準(zhǔn)輸入里讀取所有的東西直到遇到一個 end-of-file 字符，而且 getContents 是惰性的

interact fn 取一個類型為 String -> String 的函數(shù) fn 作為參數(shù)，返回這樣一個 I/ O 操作：接受輸入，把一個函數(shù)作用在輸入上，然后輸出函數(shù)運(yùn)行結(jié)果

getArgs 獲取命令行參數(shù)

getProgName 獲取程序名

創(chuàng)建文件 test.txt，內(nèi)容如下

 Hi! How are you");

創(chuàng)建文件 capslocker.hs，內(nèi)容如下

 import Control.Monad 
 import Data.Char 
 main = forever $ do
      l <- getLine
      putStrLn $ map toUpper l 

編譯：運(yùn)行 ghc --make capslocker

將 test.txt 的內(nèi)容傳給 capslocker：運(yùn)行 ./capslocker < test.txt

然后你就會看到所有字母變成了大寫上面代碼也能用 getContents 簡化

import Data.Char 
main = do
    contents <- getContents
    putStr $ map toUpper contents 

也可以不傳入 test.txt 文件，直接運(yùn)行 ./capslocker，然后輸入一行行文本，但是注意，最終你要按 Ctrl+D 來表示內(nèi)容結(jié)束。

一種理解從終端讀入數(shù)據(jù)的方式是設(shè)想我們在讀取一個文件。輸出到終端也可以同樣理解——它就像在寫文件。我們可以把這兩個文件叫做 stdout 和 stdin，分別表示標(biāo)準(zhǔn)輸出和標(biāo)準(zhǔn)輸入。

創(chuàng)建 gf.txt，內(nèi)容如下：

 Hey! Hey! You! You! 
 I don" t like your girlfriend! 
 No way! No way! 
 I think you need a new one! 

創(chuàng)建 gf.hs，內(nèi)容如下：

 import System.IO 
 main = do
     handle <- openFile "gf. txt" ReadMode
     contents <- hGetContents handle
     putStr contents
     hClose handle
 -- 注意 openFile ReadMode hGetContents hClose 這幾個函數(shù)，其中的 h 前綴表示它接收 handle

編譯并運(yùn)行如何知道 openFile 的各個參數(shù)的意思呢？

λ> :t openFile
openFile :: FilePath -> IOMode -> IO Handle
λ> :info FilePath
type FilePath = String  -- Defined in ‘GHC.IO’λ> :info IOMode
data IOMode = ReadMode | WriteMode | AppendMode | ReadWriteMode
        -- Defined in ‘GHC.IO.IOMode’λ> :info Handle
data Handle
  = GHC.IO.Handle.Types.FileHandle FilePath...

import System.IO 
main = do
     withFile "girlfriend.txt" ReadMode (handle -> do
         contents <- hGetContents handle
         putStr contents) 

bracket :: IO a -> (a -> IO b) -> (a -> IO c) -> IO c 

怎么用

bracket (openFile name mode)-- 打開文件
    (handle -> hClose handle) -- 失敗了怎么辦
    (handle -> fn handle)         -- 成功了怎么辦

用 bracket 很容易實現(xiàn) withFile。

random :: (RandomGen g, Random a) => g -> (a, g) 

random 接受一個隨機(jī)數(shù)生成器，返回一個隨機(jī)數(shù)和一個新的隨機(jī)數(shù)生成器。然后你可以用新的生成器再去生成一個新的隨機(jī)數(shù)和一個新的生成器。以此類推。對于同一個生成器，得到的隨機(jī)數(shù)是固定的。

ghci>import System.Random
ghci> random (mkStdGen 100) :: (Int, StdGen) 
(-1352021624, 651872571 1655838864) 
ghci> random (mkStdGen 100) :: (Int, StdGen) 
(-1352021624, 651872571 1655838864)
ghci> random (mkStdGen 949494) :: (Int, StdGen) 
(539963926, 466647808 1655838864)
ghci> random (mkStdGen 949488) :: (Float, StdGen) 
(0. 8938442, 1597344447 1655838864) 
ghci> random (mkStdGen 949488) :: (Bool, StdGen) 
(False, 1485632275 40692) 
ghci> random (mkStdGen 949488) :: (Integer, StdGen) 
(1691547873, 1597344447 1655838864) 

randoms 接受一個生成器，返回一個無限長的隨機(jī)值列表

ghci> take 5 $ randoms (mkStdGen 11) :: [Int] 
[-1807975507, 545074951,- 1015194702,- 1622477312,- 502893664] 

并沒有返回一個新的生成器，因為這個生成器在列表的末尾，而這個列表是無限長的……

randomR 在一個范圍內(nèi)生成隨機(jī)數(shù)

ghci> randomR (1, 6) (mkStdGen 359353) 
(6, 149428957840692) 

之前我們每次生成隨機(jī)數(shù)都要自己先寫一個數(shù)字，這很傻……所以 System.Random 提供了 getStdGen，它會向系統(tǒng)索要初始的全局生成器。但 getStdGen 是一個 IO 操作，它返回的類型是 IO stdGen。

import System.Random 
main = do
    gen <- getStdGen
    putStr $ take 20 (randomRs ("a"," z") gen) 

但是如果你調(diào)用 getStdGen 兩次，你會獲得同一個 gen。第二次應(yīng)該使用 newStdGen。這個函數(shù)除了返回一個 IO stdGen 類型的值，還會把全局生成器給更新了。你再調(diào)用 getStdGen 就能得到不同的隨機(jī)數(shù)這時你會疑惑，getStdGen 為什么能返回不同的結(jié)果呢？因為它是一個 I/O 操作！

import System.Random

main = do
  gen <- getStdGen
  let a = fst ((random gen) :: (Int, StdGen))
  print a
  gen" <- newStdGen
  let b = fst ((random gen") :: (Int, StdGen))
  print b
  gen"" <- getStdGen
  let c = fst ((random gen"") :: (Int, StdGen))
  print c
  print "end"

這是我瞎寫的代碼。

形如[ 1, 2, 3, 4] 的列表只是 1: 2: 3: 4:[] 的語法糖。當(dāng)?shù)谝粋€元素被強(qiáng)制求值時（比如說輸出它），列表的其余部分 2: 3: 4:[] 只是一個許諾將會產(chǎn)生列表的承諾。我們把這個承諾叫做 thunk。 thunk 大致上是一個延遲的計算。字節(jié)串有兩種風(fēng)格：嚴(yán)格的（strict）和惰性的（lazy）。

strict bytestring 廢除了惰性，沒有 thunk。在 Data.ByteString 中實現(xiàn)了。 lazy bytestring 是惰性的，但比列表效率高。在 Data.ByteString.Lazy 中實現(xiàn)了。惰性的字節(jié)串的數(shù)據(jù)存儲在一些塊（chunk）里（不要和 thunk 混淆了），每個塊的大小是 64 KB。所以，如果你要對惰性的字節(jié)串的一個字節(jié)求值（比如說輸出它），最開頭的 64 KB 都會被求值。在那之后，其余塊實現(xiàn)為一個承諾（thunk）。使用示例

import qualified Data. ByteString. Lazy as B 
import qualified Data. ByteString as S

ghci> B. pack [99, 97, 110] 
Chunk "can" Empty 
ghci> B. pack [98.. 120] 
Chunk "bcdefghijklmnopqrstuvwx" Empty 
ghci> let by = B. pack [98, 111, 114, 116] 
ghci> by 
Chunk "bort" Empty 
ghci> B. unpack by 
[98, 111, 114, 116] 
ghci> B. fromChunks [S. pack [40, 41, 42], S. pack [43, 44, 45], S. pack [46, 47, 48]] 
Chunk "()*" (Chunk "+,-" (Chunk "./0" Empty)) 
ghci> B. cons 85 $ B. pack [80, 81, 82, 84] 
Chunk "U" (Chunk "PQRT" Empty)