tl; dr
{-# LANGUAGE InstanceSigs #-}
newtype Id t = Id t
instance Monad Id where
return :: t -> Id t
return = Id
(=<<) :: (a -> Id b) -> Id a -> Id b
f =<< (Id x) = f x
Mở đầu
Toán tử ứng dụng $của hàm
forall a b. a -> b
được xác định theo quy tắc
($) :: (a -> b) -> a -> b
f $ x = f x
infixr 0 $
về mặt ứng dụng hàm nguyên thủy Haskell f x( infixl 10).
Thành phần .được định nghĩa theo $như
(.) :: (b -> c) -> (a -> b) -> (a -> c)
f . g = \ x -> f $ g x
infixr 9 .
và thỏa mãn tương đương forall f g h.
f . id = f :: c -> d Right identity
id . g = g :: b -> c Left identity
(f . g) . h = f . (g . h) :: a -> d Associativity
.là liên kết, và idlà bản sắc bên phải và bên trái của nó.
Bộ ba Kleisli
Trong lập trình, một đơn vị là một hàm tạo kiểu functor với một thể hiện của lớp loại đơn nguyên. Có một số biến thể tương đương của định nghĩa và thực hiện, mỗi biến thể mang một chút trực giác khác nhau về sự trừu tượng của đơn nguyên.
Một functor là một hàm tạo fkiểu * -> *với một thể hiện của lớp kiểu functor.
{-# LANGUAGE KindSignatures #-}
class Functor (f :: * -> *) where
map :: (a -> b) -> (f a -> f b)
Ngoài việc tuân theo giao thức loại được thi hành tĩnh, các thể hiện của lớp loại functor phải tuân theo luật functor đại số forall f g.
map id = id :: f t -> f t Identity
map f . map g = map (f . g) :: f a -> f c Composition / short cut fusion
Tính toán Functor có loại
forall f t. Functor f => f t
Một tính toán c rbao gồm các kết quả r trong bối cảnh c .
Các hàm đơn nguyên hoặc mũi tên Kleisli có loại
forall m a b. Functor m => a -> m b
Mũi tên Kleisi là các hàm lấy một đối số avà trả về một phép tính đơn trị m b.
Các đơn nguyên được định nghĩa theo quy tắc của bộ ba Kleisli forall m. Functor m =>
(m, return, (=<<))
thực hiện như lớp loại
class Functor m => Monad m where
return :: t -> m t
(=<<) :: (a -> m b) -> m a -> m b
infixr 1 =<<
Bản sắc Kleisli return là một mũi tên Kleisli nhằm thúc đẩy một giá trị tvào bối cảnh đơn nguyên m. Ứng dụng mở rộng hoặc Kleisli =<< áp dụng một mũi tên Kleisli a -> m bcho kết quả tính toán m a.
Thành phần Kleisli <=< được định nghĩa theo nghĩa mở rộng là
(<=<) :: Monad m => (b -> m c) -> (a -> m b) -> (a -> m c)
f <=< g = \ x -> f =<< g x
infixr 1 <=<
<=< kết hợp hai mũi tên Kleisli, áp dụng mũi tên trái vào kết quả của ứng dụng mũi tên phải.
Các thể loại của lớp loại đơn nguyên phải tuân theo luật đơn nguyên , được nêu rõ nhất theo thành phần của Kleisli:forall f g h.
f <=< return = f :: c -> m d Right identity
return <=< g = g :: b -> m c Left identity
(f <=< g) <=< h = f <=< (g <=< h) :: a -> m d Associativity
<=<là liên kết, và returnlà bản sắc bên phải và bên trái của nó.
Danh tính
Loại nhận dạng
type Id t = t
là chức năng nhận dạng trên các loại
Id :: * -> *
Giải thích như một functor,
return :: t -> Id t
= id :: t -> t
(=<<) :: (a -> Id b) -> Id a -> Id b
= ($) :: (a -> b) -> a -> b
(<=<) :: (b -> Id c) -> (a -> Id b) -> (a -> Id c)
= (.) :: (b -> c) -> (a -> b) -> (a -> c)
Trong Haskell chính tắc, đơn sắc được xác định
newtype Id t = Id t
instance Functor Id where
map :: (a -> b) -> Id a -> Id b
map f (Id x) = Id (f x)
instance Monad Id where
return :: t -> Id t
return = Id
(=<<) :: (a -> Id b) -> Id a -> Id b
f =<< (Id x) = f x
Lựa chọn
Một loại tùy chọn
data Maybe t = Nothing | Just t
mã hóa tính toán Maybe tmà không nhất thiết phải mang lại một kết quả t, tính toán có thể làm hỏng thất bại. Đơn vị tùy chọn được xác định
instance Functor Maybe where
map :: (a -> b) -> (Maybe a -> Maybe b)
map f (Just x) = Just (f x)
map _ Nothing = Nothing
instance Monad Maybe where
return :: t -> Maybe t
return = Just
(=<<) :: (a -> Maybe b) -> Maybe a -> Maybe b
f =<< (Just x) = f x
_ =<< Nothing = Nothing
a -> Maybe bchỉ được áp dụng cho một kết quả nếu Maybe amang lại kết quả.
newtype Nat = Nat Int
Các số tự nhiên có thể được mã hóa khi các số nguyên lớn hơn hoặc bằng 0.
toNat :: Int -> Maybe Nat
toNat i | i >= 0 = Just (Nat i)
| otherwise = Nothing
Các số tự nhiên không được đóng dưới phép trừ.
(-?) :: Nat -> Nat -> Maybe Nat
(Nat n) -? (Nat m) = toNat (n - m)
infixl 6 -?
Các đơn vị tùy chọn bao gồm một hình thức xử lý ngoại lệ cơ bản.
(-? 20) <=< toNat :: Int -> Maybe Nat
Danh sách
Danh sách đơn nguyên, trên loại danh sách
data [] t = [] | t : [t]
infixr 5 :
và hoạt động đơn chất phụ gia của nó
(++) :: [t] -> [t] -> [t]
(x : xs) ++ ys = x : xs ++ ys
[] ++ ys = ys
infixr 5 ++
mã hóa tính toán phi tuyến[t] mang lại một lượng 0, 1, ...kết quả tự nhiên t.
instance Functor [] where
map :: (a -> b) -> ([a] -> [b])
map f (x : xs) = f x : map f xs
map _ [] = []
instance Monad [] where
return :: t -> [t]
return = (: [])
(=<<) :: (a -> [b]) -> [a] -> [b]
f =<< (x : xs) = f x ++ (f =<< xs)
_ =<< [] = []
Tiện ích mở rộng =<<nối ++tất cả các danh sách [b]từ các ứng dụng f xcủa mũi tên Kleisli a -> [b]thành các thành phần của [a]một danh sách kết quả [b].
Đặt các ước số thích hợp của một số nguyên dương nlà
divisors :: Integral t => t -> [t]
divisors n = filter (`divides` n) [2 .. n - 1]
divides :: Integral t => t -> t -> Bool
(`divides` n) = (== 0) . (n `rem`)
sau đó
forall n. let { f = f <=< divisors } in f n = []
Khi xác định lớp loại đơn, thay vì mở rộng =<<, tiêu chuẩn Haskell sử dụng toán tử lật của nó, toán tử liên kết>>= .
class Applicative m => Monad m where
(>>=) :: forall a b. m a -> (a -> m b) -> m b
(>>) :: forall a b. m a -> m b -> m b
m >> k = m >>= \ _ -> k
{-# INLINE (>>) #-}
return :: a -> m a
return = pure
Để đơn giản, giải thích này sử dụng hệ thống phân cấp lớp loại
class Functor f
class Functor m => Monad m
Trong Haskell, hệ thống phân cấp tiêu chuẩn hiện tại là
class Functor f
class Functor p => Applicative p
class Applicative m => Monad m
bởi vì không chỉ mỗi đơn vị là một functor, mà mỗi ứng dụng là một functor và mỗi đơn vị cũng là một ứng dụng.
Sử dụng danh sách đơn nguyên, mã giả mệnh lệnh
for a in (1, ..., 10)
for b in (1, ..., 10)
p <- a * b
if even(p)
yield p
tạm dịch là khối làm ,
do a <- [1 .. 10]
b <- [1 .. 10]
let p = a * b
guard (even p)
return p
sự hiểu biết đơn nguyên tương đương ,
[ p | a <- [1 .. 10], b <- [1 .. 10], let p = a * b, even p ]
và biểu thức
[1 .. 10] >>= (\ a ->
[1 .. 10] >>= (\ b ->
let p = a * b in
guard (even p) >> -- [ () | even p ] >>
return p
)
)
Ký hiệu và hiểu đơn âm là đường cú pháp cho các biểu thức liên kết lồng nhau. Toán tử liên kết được sử dụng để liên kết tên cục bộ của các kết quả đơn âm.
let x = v in e = (\ x -> e) $ v = v & (\ x -> e)
do { r <- m; c } = (\ r -> c) =<< m = m >>= (\ r -> c)
Ở đâu
(&) :: a -> (a -> b) -> b
(&) = flip ($)
infixl 0 &
Chức năng bảo vệ được xác định
guard :: Additive m => Bool -> m ()
guard True = return ()
guard False = fail
trong đó loại đơn vị hoặc trống trống tuple
data () = ()
Các đơn vị cộng gộp hỗ trợ sự lựa chọn và thất bại có thể được trừu tượng hóa bằng cách sử dụng một lớp loại
class Monad m => Additive m where
fail :: m t
(<|>) :: m t -> m t -> m t
infixl 3 <|>
instance Additive Maybe where
fail = Nothing
Nothing <|> m = m
m <|> _ = m
instance Additive [] where
fail = []
(<|>) = (++)
ở đâu failvà <|>tạo thành một monoidforall k l m.
k <|> fail = k
fail <|> l = l
(k <|> l) <|> m = k <|> (l <|> m)
và faillà phần tử không hấp thụ / hủy diệt của các đơn vị phụ gia
_ =<< fail = fail
Nếu trong
guard (even p) >> return p
even plà đúng, sau đó bảo vệ tạo ra [()], và theo định nghĩa của >>hàm hằng số cục bộ
\ _ -> return p
được áp dụng cho kết quả (). Nếu sai, thì người bảo vệ tạo ra danh sách monad fail( []), điều này không mang lại kết quả nào cho một mũi tên Kleisli được áp dụng >>, vì vậy điều này pđược bỏ qua.
Tiểu bang
Khét tiếng, các đơn nguyên được sử dụng để mã hóa tính toán trạng thái.
Bộ xử lý trạng thái là một chức năng
forall st t. st -> (t, st)
chuyển trạng thái stvà mang lại kết quả t. Nhà nước st có thể là bất cứ điều gì. Không có gì, cờ, đếm, mảng, xử lý, máy, thế giới.
Loại bộ xử lý trạng thái thường được gọi là
type State st t = st -> (t, st)
Các bộ xử lý nhà nước là * -> *functor loại State st. Mũi tên Kleisli của bộ xử lý trạng thái là các chức năng
forall st a b. a -> (State st) b
Trong Haskell chính tắc, phiên bản lười biếng của bộ xử lý trạng thái được xác định
newtype State st t = State { stateProc :: st -> (t, st) }
instance Functor (State st) where
map :: (a -> b) -> ((State st) a -> (State st) b)
map f (State p) = State $ \ s0 -> let (x, s1) = p s0
in (f x, s1)
instance Monad (State st) where
return :: t -> (State st) t
return x = State $ \ s -> (x, s)
(=<<) :: (a -> (State st) b) -> (State st) a -> (State st) b
f =<< (State p) = State $ \ s0 -> let (x, s1) = p s0
in stateProc (f x) s1
Một bộ xử lý trạng thái được chạy bằng cách cung cấp trạng thái ban đầu:
run :: State st t -> st -> (t, st)
run = stateProc
eval :: State st t -> st -> t
eval = fst . run
exec :: State st t -> st -> st
exec = snd . run
Quyền truy cập trạng thái được cung cấp bởi người nguyên thủy getvà put, phương pháp trừu tượng hóa trên các đơn nguyên nhà nước :
{-# LANGUAGE MultiParamTypeClasses, FunctionalDependencies #-}
class Monad m => Stateful m st | m -> st where
get :: m st
put :: st -> m ()
m -> sttuyên bố một sự phụ thuộc chức năng của loại trạng thái sttrên đơn nguyên m; rằng State t, ví dụ, sẽ xác định loại trạng thái là tduy nhất.
instance Stateful (State st) st where
get :: State st st
get = State $ \ s -> (s, s)
put :: st -> State st ()
put s = State $ \ _ -> ((), s)
với loại đơn vị được sử dụng tương tự voidtrong C.
modify :: Stateful m st => (st -> st) -> m ()
modify f = do
s <- get
put (f s)
gets :: Stateful m st => (st -> t) -> m t
gets f = do
s <- get
return (f s)
gets thường được sử dụng với các bộ truy cập trường bản ghi.
Các trạng thái đơn nguyên tương đương của luồng
let s0 = 34
s1 = (+ 1) s0
n = (* 12) s1
s2 = (+ 7) s1
in (show n, s2)
trong đó s0 :: Int, là minh bạch không kém phần tham khảo, nhưng vô cùng thanh lịch và thiết thực
(flip run) 34
(do
modify (+ 1)
n <- gets (* 12)
modify (+ 7)
return (show n)
)
modify (+ 1)là một tính toán của loại State Int (), ngoại trừ hiệu ứng của nó tương đương với return ().
(flip run) 34
(modify (+ 1) >>
gets (* 12) >>= (\ n ->
modify (+ 7) >>
return (show n)
)
)
Luật đơn nguyên của sự kết hợp có thể được viết theo >>= forall m f g.
(m >>= f) >>= g = m >>= (\ x -> f x >>= g)
hoặc là
do { do { do {
r1 <- do { x <- m; r0 <- m;
r0 <- m; = do { = r1 <- f r0;
f r0 r1 <- f x; g r1
}; g r1 }
g r1 }
} }
Giống như trong lập trình hướng biểu thức (ví dụ Rust), câu lệnh cuối cùng của một khối biểu thị năng suất của nó. Toán tử liên kết đôi khi được gọi là dấu chấm phẩy có thể lập trình được.
Nguyên tắc cấu trúc điều khiển lặp từ lập trình mệnh lệnh có cấu trúc được mô phỏng đơn điệu
for :: Monad m => (a -> m b) -> [a] -> m ()
for f = foldr ((>>) . f) (return ())
while :: Monad m => m Bool -> m t -> m ()
while c m = do
b <- c
if b then m >> while c m
else return ()
forever :: Monad m => m t
forever m = m >> forever m
Đầu ra đầu vào
data World
Bộ xử lý trạng thái thế giới I / O là sự hòa giải của Haskell thuần túy và thế giới thực, về ngữ nghĩa hoạt động biểu thị và mệnh lệnh chức năng. Một sự tương tự gần gũi của việc thực hiện nghiêm ngặt thực tế:
type IO t = World -> (t, World)
Tương tác được tạo điều kiện bởi các nguyên thủy không tinh khiết
getChar :: IO Char
putChar :: Char -> IO ()
readFile :: FilePath -> IO String
writeFile :: FilePath -> String -> IO ()
hSetBuffering :: Handle -> BufferMode -> IO ()
hTell :: Handle -> IO Integer
. . . . . .
Tạp chất của mã sử dụng IOnguyên thủy được giao thức vĩnh viễn bởi hệ thống loại. Bởi vì độ tinh khiết là tuyệt vời, những gì xảy ra IO, ở lại IO.
unsafePerformIO :: IO t -> t
Hoặc, ít nhất, nên.
Chữ ký loại của chương trình Haskell
main :: IO ()
main = putStrLn "Hello, World!"
mở rộng đến
World -> ((), World)
Một chức năng biến đổi một thế giới.
Phần kết
Các thể loại mà các đối tượng là các loại Haskell và các hình thái đó là các chức năng giữa các loại Haskell là, nhanh và lỏng lẻo, thể loại Hask.
Một functor Tlà một ánh xạ từ một thể loại Cđến một thể loại D; cho mỗi đối tượng trong Cmột đối tượng trongD
Tobj : Obj(C) -> Obj(D)
f :: * -> *
và cho mỗi hình thái trong Cmột hình thái trongD
Tmor : HomC(X, Y) -> HomD(Tobj(X), Tobj(Y))
map :: (a -> b) -> (f a -> f b)
trong đó X, Ylà các đối tượng trong C. HomC(X, Y)là lớp đồng hình của tất cả các hình thái X -> Ytrong C. Functor phải bảo tồn bản sắc và thành phần hình thái, cấu trúc của thành Cphố D.
Tmor Tobj
T(id) = id : T(X) -> T(X) Identity
T(f) . T(g) = T(f . g) : T(X) -> T(Z) Composition
Các loại Kleisli thuộc một thể loại Cđược đưa ra bởi một Kleisli triple
<T, eta, _*>
của một endofunctor
T : C -> C
( f), một hình thái nhận dạng eta( return) và một toán tử mở rộng *( =<<).
Mỗi hình thái Kleisli trong Hask
f : X -> T(Y)
f :: a -> m b
bởi toán tử mở rộng
(_)* : Hom(X, T(Y)) -> Hom(T(X), T(Y))
(=<<) :: (a -> m b) -> (m a -> m b)
được đưa ra một hình thái trong Haskthể loại Kleisli
f* : T(X) -> T(Y)
(f =<<) :: m a -> m b
Thành phần trong danh mục Kleisli .Tđược đưa ra dưới dạng mở rộng
f .T g = f* . g : X -> T(Z)
f <=< g = (f =<<) . g :: a -> m c
và thỏa mãn các tiên đề thể loại
eta .T g = g : Y -> T(Z) Left identity
return <=< g = g :: b -> m c
f .T eta = f : Z -> T(U) Right identity
f <=< return = f :: c -> m d
(f .T g) .T h = f .T (g .T h) : X -> T(U) Associativity
(f <=< g) <=< h = f <=< (g <=< h) :: a -> m d
trong đó, áp dụng các phép biến đổi tương đương
eta .T g = g
eta* . g = g By definition of .T
eta* . g = id . g forall f. id . f = f
eta* = id forall f g h. f . h = g . h ==> f = g
(f .T g) .T h = f .T (g .T h)
(f* . g)* . h = f* . (g* . h) By definition of .T
(f* . g)* . h = f* . g* . h . is associative
(f* . g)* = f* . g* forall f g h. f . h = g . h ==> f = g
về mặt mở rộng được đưa ra theo quy tắc
eta* = id : T(X) -> T(X) Left identity
(return =<<) = id :: m t -> m t
f* . eta = f : Z -> T(U) Right identity
(f =<<) . return = f :: c -> m d
(f* . g)* = f* . g* : T(X) -> T(Z) Associativity
(((f =<<) . g) =<<) = (f =<<) . (g =<<) :: m a -> m c
Monads cũng có thể được định nghĩa theo thuật ngữ không phải là phần mở rộng của Kleislian, mà là một phép biến đổi tự nhiên mu, trong lập trình được gọi là join. Một đơn vị được định nghĩa theo nghĩa mulà một bộ ba trên một danh mục C, của một endofunctor
T : C -> C
f :: * -> *
và hai sự yên tĩnh tự nhiên
eta : Id -> T
return :: t -> f t
mu : T . T -> T
join :: f (f t) -> f t
thỏa mãn tương đương
mu . T(mu) = mu . mu : T . T . T -> T . T Associativity
join . map join = join . join :: f (f (f t)) -> f t
mu . T(eta) = mu . eta = id : T -> T Identity
join . map return = join . return = id :: f t -> f t
Lớp loại đơn nguyên sau đó được định nghĩa
class Functor m => Monad m where
return :: t -> m t
join :: m (m t) -> m t
Việc muthực hiện chính tắc của đơn vị tùy chọn:
instance Monad Maybe where
return = Just
join (Just m) = m
join Nothing = Nothing
các concatchức năng
concat :: [[a]] -> [a]
concat (x : xs) = x ++ concat xs
concat [] = []
là joindanh sách đơn nguyên.
instance Monad [] where
return :: t -> [t]
return = (: [])
(=<<) :: (a -> [b]) -> ([a] -> [b])
(f =<<) = concat . map f
Việc triển khai joincó thể được dịch từ hình thức mở rộng bằng cách sử dụng tương đương
mu = id* : T . T -> T
join = (id =<<) :: m (m t) -> m t
Bản dịch ngược từ musang dạng mở rộng được đưa ra bởi
f* = mu . T(f) : T(X) -> T(Y)
(f =<<) = join . map f :: m a -> m b
Nhưng tại sao một lý thuyết quá trừu tượng nên được sử dụng cho lập trình?
Câu trả lời rất đơn giản: là các nhà khoa học máy tính, chúng tôi coi trọng sự trừu tượng ! Khi chúng tôi thiết kế giao diện cho một thành phần phần mềm, chúng tôi muốn nó tiết lộ ít nhất có thể về việc triển khai. Chúng tôi muốn có thể thay thế việc triển khai bằng nhiều lựa chọn thay thế, nhiều 'trường hợp' khác của cùng một 'khái niệm'. Khi chúng tôi thiết kế một giao diện chung cho nhiều thư viện chương trình, điều quan trọng hơn nữa là giao diện chúng tôi chọn có nhiều cách triển khai. Đó là tính khái quát của khái niệm đơn nguyên mà chúng tôi đánh giá rất cao, đó là vì lý thuyết phạm trù quá trừu tượng nên các khái niệm của nó rất hữu ích cho lập trình.
Do đó, hầu như không ngạc nhiên khi việc khái quát hóa các đơn nguyên mà chúng tôi trình bày dưới đây cũng có mối liên hệ chặt chẽ với lý thuyết thể loại. Nhưng chúng tôi nhấn mạnh rằng mục đích của chúng tôi rất thiết thực: không phải là 'thực hiện lý thuyết thể loại', mà là tìm một cách tổng quát hơn để cấu trúc các thư viện kết hợp. Chỉ đơn giản là may mắn của chúng tôi mà các nhà toán học đã thực hiện nhiều công việc cho chúng tôi!
từ Tướng quân Monads đến Mũi tên của John Hughes
