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
프롤로그
$함수 의 응용 연산자
forall a b. a -> b
정식으로 정의
($) :: (a -> b) -> a -> b
f $ x = f x
infixr 0 $
Haskell-primitive function application f x( infixl 10)과 관련하여.
구성 .은 다음과 $같이 정의 됩니다.
(.) :: (b -> c) -> (a -> b) -> (a -> c)
f . g = \ x -> f $ g x
infixr 9 .
등가를 충족 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
.연관성 id이 있으며 오른쪽과 왼쪽의 정체성입니다.
클라이 슬리 트리플
프로그래밍에서 모나드는 모나드 유형 클래스의 인스턴스가있는 functor 유형 생성자입니다. 모나드 추상화에 대해 약간 다른 직관을 갖는 정의 및 구현의 몇 가지 동등한 변형이 있습니다.
functor는 functor 타입 클래스의 인스턴스를 가진 종류의 생성자 f입니다 * -> *.
{-# LANGUAGE KindSignatures #-}
class Functor (f :: * -> *) where
map :: (a -> b) -> (f a -> f b)
정적으로 시행되는 유형 프로토콜을 따르는 것 외에도 functor 유형 클래스의 인스턴스는 대수 functor 법을 준수해야합니다. 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
펑터 계산 유형
forall f t. Functor f => f t
계산 c r은 컨텍스트 내 결과 로 구성됩니다 .r c
단항 모나 딕 함수 또는 Kleisli 화살표 는
forall m a b. Functor m => a -> m b
Kleisi 화살표는 하나의 인수를 취하고 a모나드 계산을 반환하는 함수입니다 m b.
모나드는 Kleisli 트리플의 관점에서 정식으로 정의됩니다 forall m. Functor m =>
(m, return, (=<<))
타입 클래스로 구현
class Functor m => Monad m where
return :: t -> m t
(=<<) :: (a -> m b) -> m a -> m b
infixr 1 =<<
Kleisli ID는 return 값 촉진하는 Kleisli 화살표입니다 t모나드 맥락을 m. 확장 또는 Kleisli 응용 프로그램 =<< 은 Kleisli 화살표 a -> m b를 계산 결과에 적용합니다 m a.
Kleisli 구성 <=< 은 다음과 같이 확장 측면에서 정의됩니다.
(<=<) :: Monad m => (b -> m c) -> (a -> m b) -> (a -> m c)
f <=< g = \ x -> f =<< g x
infixr 1 <=<
<=< Kleisli 화살표 2 개를 작성하고 왼쪽 화살표를 오른쪽 화살표 적용 결과에 적용합니다.
모나드 유형 클래스의 인스턴스는 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
<=<연관성 return이 있으며 오른쪽과 왼쪽의 정체성입니다.
정체
신원 유형
type Id t = t
유형에 대한 항등 함수입니다
Id :: * -> *
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)
정식 Haskell에서 아이디 모나드는 정의됩니다
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
선택권
옵션 유형
data Maybe t = Nothing | Just t
Maybe t반드시 t“실패”할 수 있는 결과를 산출하지는 않는 계산 을 인코딩 합니다. 옵션 모나드가 정의됩니다
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 b결과를 Maybe a산출하는 경우에만 결과에 적용됩니다 .
newtype Nat = Nat Int
자연수는 0 이상의 정수로 인코딩 될 수 있습니다.
toNat :: Int -> Maybe Nat
toNat i | i >= 0 = Just (Nat i)
| otherwise = Nothing
빼기에서 자연수는 닫히지 않습니다.
(-?) :: Nat -> Nat -> Maybe Nat
(Nat n) -? (Nat m) = toNat (n - m)
infixl 6 -?
옵션 monad는 기본적인 형태의 예외 처리를 다룹니다.
(-? 20) <=< toNat :: Int -> Maybe Nat
명부
목록 유형에 대한 목록 모나드
data [] t = [] | t : [t]
infixr 5 :
그리고 부가적인 단일체 작동“추가”
(++) :: [t] -> [t] -> [t]
(x : xs) ++ ys = x : xs ++ ys
[] ++ ys = ys
infixr 5 ++
비선형 계산 [t]을 인코딩 하여 자연스러운 0, 1, ...결과를 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)
_ =<< [] = []
확장 =<<연접 ++모든 목록 [b]애플리케이션 인한 f xKleisli의 화살표 a -> [b]의 요소를 [a]단일 결과리스트로 [b].
양의 정수의 적절한 약수가 보자 n수
divisors :: Integral t => t -> [t]
divisors n = filter (`divides` n) [2 .. n - 1]
divides :: Integral t => t -> t -> Bool
(`divides` n) = (== 0) . (n `rem`)
그때
forall n. let { f = f <=< divisors } in f n = []
확장 대신 모나드 유형 클래스를 정의 할 =<<때 Haskell 표준은 플립 연산자 인 bind 연산자를 사용 >>=합니다.
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
간단히하기 위해이 설명에서는 형식 클래스 계층 구조를 사용합니다.
class Functor f
class Functor m => Monad m
Haskell에서 현재 표준 계층 구조는
class Functor f
class Functor p => Applicative p
class Applicative m => Monad m
모든 모나드는 functor 일뿐만 아니라 모든 적용은 functor이고 모든 모나드는 적용되기 때문입니다.
목록 모나드를 사용하여 명령형 의사 코드
for a in (1, ..., 10)
for b in (1, ..., 10)
p <- a * b
if even(p)
yield p
대략적으로 변환 DO 블록 ,
do a <- [1 .. 10]
b <- [1 .. 10]
let p = a * b
guard (even p)
return p
동등한 모나드 이해 ,
[ p | a <- [1 .. 10], b <- [1 .. 10], let p = a * b, even p ]
그리고 표현
[1 .. 10] >>= (\ a ->
[1 .. 10] >>= (\ b ->
let p = a * b in
guard (even p) >> -- [ () | even p ] >>
return p
)
)
표기법 및 모나드 이해는 중첩 된 바인드 표현식의 구문 설탕입니다. 바인드 연산자는 모나드 결과의 로컬 이름 바인딩에 사용됩니다.
let x = v in e = (\ x -> e) $ v = v & (\ x -> e)
do { r <- m; c } = (\ r -> c) =<< m = m >>= (\ r -> c)
어디
(&) :: a -> (a -> b) -> b
(&) = flip ($)
infixl 0 &
보호 기능이 정의됩니다
guard :: Additive m => Bool -> m ()
guard True = return ()
guard False = fail
여기서 단위 유형 또는 "빈 튜플"
data () = ()
선택 과 실패 를 지원하는 추가 모나드 는 타입 클래스를 사용하여 추상화 될 수 있습니다
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 = []
(<|>) = (++)
어디서 fail그리고 <|>monoid를 형성forall k l m.
k <|> fail = k
fail <|> l = l
(k <|> l) <|> m = k <|> (l <|> m)
및 fail첨가제 모나드 제로 소자 전멸 / 흡수되고
_ =<< fail = fail
만약에
guard (even p) >> return p
even p가드 (guard)는 가드를 [()]정의 >>하고 로컬 상수 함수를 정의함으로써
\ _ -> return p
결과에 적용됩니다 (). False 인 경우 경비원은 목록 모나드 fail( [])를 생성하여 Kleisli 화살표를 적용 >>할 결과를 얻지 않으므로 p건너 뜁니다.
상태
유감스럽게도 모나드는 상태 저장 계산을 인코딩하는 데 사용됩니다.
상태 프로세서 함수
forall st t. st -> (t, st)
상태를 전환하고 st결과를 산출합니다 t. 상태는 st 아무것도 할 수있다. 아무것도, 깃발, 카운트, 배열, 핸들, 기계, 세계.
상태 프로세서의 유형은 일반적으로
type State st t = st -> (t, st)
상태 프로세서 모나드는 종류가있는 * -> *functor State st입니다. 상태 프로세서 모나드의 Kleisli 화살표는 기능입니다
forall st a b. a -> (State st) b
표준 Haskell에서는 게으른 버전의 상태 프로세서 모나드가 정의됩니다.
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
상태 프로세서는 초기 상태를 제공하여 실행됩니다.
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
스테이트 풀 모나드에 대한 프리미티브 get및 put추상화 방법으로 스테이트 액세스를 제공합니다 .
{-# LANGUAGE MultiParamTypeClasses, FunctionalDependencies #-}
class Monad m => Stateful m st | m -> st where
get :: m st
put :: st -> m ()
m -> st모나드에 대한 상태 유형 의 기능적 종속성 을 선언합니다 . 예를 들어, a 는 상태 유형을 고유하게 결정합니다 .stmState tt
instance Stateful (State st) st where
get :: State st st
get = State $ \ s -> (s, s)
put :: st -> State st ()
put s = State $ \ _ -> ((), s)
유사하게 사용 된 장치 유형 voidC.에서
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 레코드 필드 접근 자와 함께 자주 사용됩니다.
변수 스레딩에 해당하는 상태 모나드
let s0 = 34
s1 = (+ 1) s0
n = (* 12) s1
s2 = (+ 7) s1
in (show n, s2)
어디 s0 :: Int에서 똑같이 참조 투명하지만, 더 우아하고 실용적
(flip run) 34
(do
modify (+ 1)
n <- gets (* 12)
modify (+ 7)
return (show n)
)
modify (+ 1)형식은 다음 과 같은 효과를State Int () 제외하고 형식의 계산입니다 .return ()
(flip run) 34
(modify (+ 1) >>
gets (* 12) >>= (\ n ->
modify (+ 7) >>
return (show n)
)
)
연관성의 모나드 법칙은 >>= forall m f g.
(m >>= f) >>= g = m >>= (\ x -> f x >>= g)
또는
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 }
} }
식 지향 프로그래밍 (예 : Rust)에서와 같이 블록의 마지막 명령문은 수율을 나타냅니다. 바인드 연산자를 "프로그래밍 가능한 세미콜론"이라고도합니다.
구조적 명령형 프로그래밍의 반복 제어 구조 프리미티브는 모나드 방식으로 에뮬레이트됩니다.
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
입출력
data World
I / O 세계 상태 프로세서 모나드는 순수한 Haskell과 실제 세계, 기능적 표현 및 명령 운영 시맨틱의 조정입니다. 실제 엄격한 구현과 밀접한 유사 :
type IO t = World -> (t, World)
불완전한 프리미티브로 상호 작용이 촉진됩니다.
getChar :: IO Char
putChar :: Char -> IO ()
readFile :: FilePath -> IO String
writeFile :: FilePath -> String -> IO ()
hSetBuffering :: Handle -> BufferMode -> IO ()
hTell :: Handle -> IO Integer
. . . . . .
IO프리미티브 를 사용하는 코드의 불순은 유형 시스템에 의해 영구적으로 프로토콜됩니다. 순도는 굉장하기 때문에에 일어난 일은 IO에 남아 있습니다 IO.
unsafePerformIO :: IO t -> t
또는 적어도해야합니다.
하스켈 프로그램의 형식 서명
main :: IO ()
main = putStrLn "Hello, World!"
~로 확장
World -> ((), World)
세상을 변화시키는 기능.
발문
객체가 하스켈 유형이고 하스켈 유형 사이의 함수 인 형태는 카테고리 "빠르고 느슨 함" Hask입니다.
functor T는 카테고리에서 카테고리 C로의 맵핑입니다 D. 개체의 각 개체에 C대한D
Tobj : Obj(C) -> Obj(D)
f :: * -> *
그리고 형태의 각 형태에 C대해D
Tmor : HomC(X, Y) -> HomD(Tobj(X), Tobj(Y))
map :: (a -> b) -> (f a -> f b)
여기서 X, Y의 개체입니다 C. HomC(X, Y)는 IS 이체 동형 클래스 의 모든 morphisms의 X -> Y의는 C. 펑 터는 morphism에 정체성과 구성의 "구조"를 보존해야 C에 D.
Tmor Tobj
T(id) = id : T(X) -> T(X) Identity
T(f) . T(g) = T(f . g) : T(X) -> T(Z) Composition
Kleisli 카테고리 범주의이 CKleisli 트리플 주어진다
<T, eta, _*>
Endofunctor의
T : C -> C
( f), ID 형태 eta( return) 및 확장 연산자 *( =<<).
각 Kleisli 형태 Hask
f : X -> T(Y)
f :: a -> m b
확장 연산자에 의해
(_)* : Hom(X, T(Y)) -> Hom(T(X), T(Y))
(=<<) :: (a -> m b) -> (m a -> m b)
HaskKleisli 범주에 형태가 부여됩니다
f* : T(X) -> T(Y)
(f =<<) :: m a -> m b
Kleisli 범주의 구성 .T은 확장 측면에서 제공됩니다
f .T g = f* . g : X -> T(Z)
f <=< g = (f =<<) . g :: a -> m c
범주 공리를 충족
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
등가 변환을 적용하는
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
확장 측면에서 정식으로 제공됩니다
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는 Kleislian 확장이 아니라 mu라는 프로그래밍에서 자연스러운 변형이라는 용어로 정의 할 수도 있습니다 join. 모나드는 endofunctor mu의 카테고리에 대한 트리플로 정의됩니다.C
T : C -> C
f :: * -> *
그리고 두 자연 변형
eta : Id -> T
return :: t -> f t
mu : T . T -> T
join :: f (f t) -> f t
동등성을 만족시키는
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
그런 다음 모나드 타입 클래스가 정의됩니다
class Functor m => Monad m where
return :: t -> m t
join :: m (m t) -> m t
mu옵션 모나드 의 표준 구현 :
instance Monad Maybe where
return = Just
join (Just m) = m
join Nothing = Nothing
concat기능
concat :: [[a]] -> [a]
concat (x : xs) = x ++ concat xs
concat [] = []
는 IS join리스트 모나드의는.
instance Monad [] where
return :: t -> [t]
return = (: [])
(=<<) :: (a -> [b]) -> ([a] -> [b])
(f =<<) = concat . map f
join등가를 사용하여 확장 양식에서 구현을 번역 할 수 있습니다.
mu = id* : T . T -> T
join = (id =<<) :: m (m t) -> m t
에서 mu확장 형식으로 의 역변환 은
f* = mu . T(f) : T(X) -> T(Y)
(f =<<) = join . map f :: m a -> m b
그러나 왜 이론이 그렇게 추상적이어야 프로그래밍에 사용되어야 하는가?
답은 간단합니다. 컴퓨터 과학자로서 우리는 추상화 를 중요하게 생각 합니다 ! 소프트웨어 구성 요소에 대한 인터페이스를 설계 할 때 구현에 대해 가능한 한 적은 정보를 공개하기를 원합니다 . 우리는 구현을 많은 대안, 같은 '개념'의 다른 많은 '인스턴스'로 대체 할 수 있기를 원합니다. 많은 프로그램 라이브러리에 대한 일반 인터페이스를 설계 할 때, 선택한 인터페이스가 다양한 구현을 갖는 것이 더욱 중요합니다. 우리가 매우 중요하게 생각하는 것은 모나드 개념의 일반성입니다. 범주 이론이 너무 추상적 이기 때문에 개념이 프로그래밍에 매우 유용하기 때문입니다.
그러므로 우리가 아래에 제시하는 모나드의 일반화가 범주 이론과 밀접한 관련이 있다는 것은 놀라운 일이 아닙니다. 그러나 우리는 우리의 목적이 매우 실용적이라고 강조합니다. '범주 이론을 구현하는 것'이 아니라 결합기 라이브러리를 구성하는보다 일반적인 방법을 찾는 것입니다. 수학자들이 이미 우리를 위해 많은 일을 해낸 것은 단순히 우리의 행운입니다!
에서 화살표로 일반화 모나드 존 휴즈에 의해
