[haskell] 모나드는 무엇입니까?

첫째 : 모나드 라는 용어 는 수학자가 아니라면 약간 공허합니다. 다른 용어는 실제로 유용한 것에 대해 좀 더 설명하는 계산 빌더 입니다.

실용적인 예를 요청하십시오.

예 1 : 목록 이해 :

[x*2 | x<-[1..10], odd x]

이 표현식은 1에서 10 사이의 모든 홀수의 배가를 반환합니다. 매우 유용합니다!

이것은 List 모나드 내의 일부 연산에 대해 실제로 구문 설탕이라는 것이 밝혀졌습니다. 동일한 목록 이해는 다음과 같이 쓸 수 있습니다.

do
   x <- [1..10]
   guard (odd x)
   return (x * 2)

또는:

[1..10] >>= (\x -> guard (odd x) >> return (x*2))

예 2 : 입력 / 출력 :

do
   putStrLn "What is your name?"
   name <- getLine
   putStrLn ("Welcome, " ++ name ++ "!")

두 예제 모두 AKA 계산 빌더 인 모나드를 사용합니다. 일반적인 주제는 모나드가 특정적이고 유용한 방식으로 작업 을 연결 한다는 것입니다. 리스트 이해에서, 조작이리스트를 리턴하면리스트의 모든 항목 에 대해 다음 조작이 수행되도록 조작이 연결 됩니다. 반면에 IO 모나드는 순차적으로 작업을 수행하지만 “세계 상태”를 나타내는 “숨겨진 변수”를 전달하여 순수한 기능 방식으로 I / O 코드를 작성할 수 있습니다.

체인 작업 의 패턴 은 매우 유용하며 Haskell의 많은 다른 것들에 사용됩니다.

또 다른 예는 예외입니다. Error모나드를 사용하면 오류가 발생하는 경우를 제외하고는 체인의 나머지 부분을 버리는 경우를 제외하고 작업이 순차적으로 수행되도록 체인이 연결됩니다.

리스트 이해 구문과 do-notation은 모두 >>=연산자를 사용하여 연쇄 연산을위한 구문 설탕입니다 . 모나드는 기본적으로 >>=연산자 를 지원하는 유형입니다 .

예 3 : 파서

이것은 인용 된 문자열이나 숫자를 구문 분석하는 매우 간단한 파서입니다.

parseExpr = parseString <|> parseNumber

parseString = do
        char '"'
        x <- many (noneOf "\"")
        char '"'
        return (StringValue x)

parseNumber = do
    num <- many1 digit
    return (NumberValue (read num))

작업은 char, digit, 등 매우 간단합니다. 일치하거나 일치하지 않습니다. 마술은 제어 흐름을 관리하는 모나드입니다. 일치가 실패 할 때까지 작업이 순차적으로 수행됩니다.이 경우 모나드는 최신으로 되돌아가 <|>다음 옵션을 시도합니다. 또 다른 유용한 의미 체계를 사용하여 작업을 연결하는 방법입니다.

예 4 : 비동기 프로그래밍

위의 예제는 Haskell에 있지만 F # 은 모나드도 지원합니다. 이 예는 Don Syme 에서 도난당했습니다 .

let AsyncHttp(url:string) =
    async {  let req = WebRequest.Create(url)
             let! rsp = req.GetResponseAsync()
             use stream = rsp.GetResponseStream()
             use reader = new System.IO.StreamReader(stream)
             return reader.ReadToEnd() }

이 메소드는 웹 페이지를 가져옵니다. 펀치 라인을 사용합니다 GetResponseAsync-실제로는 별도의 스레드에서 응답을 기다리는 동안 주 스레드는 함수에서 돌아옵니다. 응답이 수신되면 생성 된 스레드에서 마지막 세 줄이 실행됩니다.

대부분의 다른 언어에서는 응답을 처리하는 행에 대해 별도의 함수를 명시 적으로 작성해야합니다. async모나드 자체에 블록 “분할”할 수 있고 후반의 실행을 연기. ( async {}구문은 블록의 제어 흐름이 async모나드에 의해 정의됨을 나타냅니다 .)

작동 방식

그렇다면 모나드는이 모든 멋진 제어 흐름을 어떻게 수행 할 수 있습니까? 실제로 do-block (또는 F #에서 호출 되는 계산 식 )에서 발생하는 것은 모든 작업 (기본적으로 모든 행)이 별도의 익명 함수로 래핑된다는 것입니다. 이 함수는 bind연산자를 사용하여 결합됩니다 ( >>=Haskell에서 철자 ). bind연산은 기능을 결합 하기 때문에 순차적으로, 여러 번, 반대로, 일부를 버리고, 느낌이들 때 별도의 스레드에서 일부를 실행하는 것처럼 적절하다고 생각되면 실행할 수 있습니다.

예를 들어, 이것은 예제 2의 확장 된 IO 코드 버전입니다.

putStrLn "What is your name?"
>>= (\_ -> getLine)
>>= (\name -> putStrLn ("Welcome, " ++ name ++ "!"))

이것은 더 나쁘지만 실제로 진행되고있는 것이 더 분명합니다. >>=연산자 마법 성분이다 : 또한, (우측) 함수와 (왼쪽) 값을 결합하여 얻어 새로운 값을 생성한다. 이 새로운 값은 다음 >>=연산자에 의해 다시 취해지고 새로운 값을 생성하는 함수와 다시 결합됩니다. >>=미니 평가자로 볼 수 있습니다.

참고 >>=모든 모나드는 자체 구현이 있으므로, 다른 종류의 오버로드 >>=. (체인의 모든 작업은 동일한 모나드 유형이어야 >>=합니다. 그렇지 않으면 작업자가 작동하지 않습니다.)

가능한 가장 간단한 구현은 >>=왼쪽의 값을 가져 와서 오른쪽의 함수에 적용하고 결과를 반환하지만 이전에 언급했듯이 모나드의 구현에 추가로 진행되는 일이있을 때 전체 패턴을 유용하게 만드는 것은 >>=.

값이 한 작업에서 다음 작업으로 전달되는 방식에는 약간의 영리함이 있지만 Haskell 유형 시스템에 대한 자세한 설명이 필요합니다.

합산

Haskell-terms에서 모나드는 모나드 타입 클래스의 인스턴스 인 매개 변수화 된 타입 >>=으로, 몇몇 다른 연산자와 함께 정의 됩니다. 평신도의 관점에서 모나드는 >>=작업이 정의 된 유형일뿐 입니다.

그 자체로 >>=는 귀찮은 연쇄 함수 방식이지만 “배관”을 숨기는 do-notation의 존재로 monadic 연산은 매우 훌륭하고 유용한 추상화이며 언어의 많은 곳에서 유용하며 유용합니다. 언어로 자신의 미니 언어를 만들 수 있습니다.

모나드는 왜 어려운가요?

많은 Haskell-learners에게 모나드는 벽돌 벽처럼 치는 장애물입니다. 모나드 자체가 복잡하지는 않지만 구현은 매개 변수화 된 유형, 유형 클래스 등과 같은 다른 많은 고급 Haskell 기능에 의존합니다. 문제는 Haskell I / O가 모나드를 기반으로한다는 것이며, I / O는 아마도 새로운 언어를 배울 때 가장 먼저 이해하고 싶을 것입니다. 결국, 전혀 생산하지 않는 프로그램을 만드는 것은 그리 재미 있지 않습니다. 산출. 다른 언어 부분에 대한 경험이 충분할 때까지 I / O를 “매직 발생”과 같이 처리하는 것을 제외하고는이 닭과 계란 문제에 대한 즉각적인 해결책은 없습니다. 죄송합니다.

모나드에 대한 훌륭한 블로그 :
http://adit.io/posts/2013-04-17-functors,_applicatives,_and_monads_in_pictures.html

답변

data Wrapped a = Wrap a

return :: a -> Wrapped a
return x = Wrap x

fmap :: (a -> b) -> (Wrapped a -> Wrapped b)
fmap f (Wrap x) = Wrap (f x)

bind :: (a -> Wrapped b) -> (Wrapped a -> Wrapped b)
bind f (Wrap x) = f x

class Monad m where
  return :: a -> m a
  (>>=) :: forall a b . m a -> (a -> m b) -> m b

instance Monad [ ] where
    []     >>= k = []
    (x:xs) >>= k = k x ++ (xs >>= k)
    return x     = [x]

instance Monad Maybe where
    Just x  >>= k = k x
    Nothing >>= k = Nothing
    return x      = Just x

map id = id
map (p . q) = map p . map q

join :: [[a]] -> [a]
pure :: a -> [a]