[haskell] 왜 모나드가 필요합니까?

나는 IO특히 뛰어난 모나드 라고 생각 해서는 안되지만 초보자에게는 더 놀라운 모나드 중 하나이므로 설명을 위해 사용할 것입니다.

Haskell을위한 IO 시스템 구축

순전히 기능적인 언어 (그리고 실제로 Haskell이 처음 시작한 언어)를위한 가장 간단한 IO 시스템은 다음과 같습니다.

main₀ :: String -> String
main₀ _ = "Hello World"

– lazyness으로, 간단한 서명은 실제로 대화 형 터미널 프로그램을 구축하기에 충분 매우 하지만, 제한을. 가장 실망스러운 것은 텍스트 만 출력 할 수 있다는 것입니다. 좀 더 흥미로운 출력 가능성을 추가하면 어떨까요?

data Output = TxtOutput String
            | Beep Frequency

main₁ :: String -> [Output]
main₁ _ = [ TxtOutput "Hello World"
          -- , Beep 440  -- for debugging
          ]

귀엽지 만 물론 훨씬 더 현실적인 “대체 출력”은 파일에 쓰는 것 입니다. 그러나 파일 에서 읽을 방법이 필요 합니다. 어떤 기회?

우리가 main₁프로그램 을 가져 와서 파일을 프로세스로 파이프 처리 할 때 (운영 체제 기능 사용), 본질적으로 파일 읽기를 구현했습니다. Haskell 언어 내에서 파일 읽기를 트리거 할 수 있다면 …

readFile :: Filepath -> (String -> [Output]) -> [Output]

이것은 “대화식 프로그램”을 사용합니다 String->[Output] 을 사용하고 파일에서 얻은 문자열을 공급하며 주어진 대화식 프로그램을 단순히 실행하는 비 대화식 프로그램을 생성합니다.

여기에는 한 가지 문제가 있습니다. 파일을 읽는 시점에 대한 개념은 없습니다 . [Output]목록 확인에 좋은 순서 준다 출력을 , 그러나 우리는 때를 주문하지 않는 입력이 완료됩니다.

해결 방법 : 입력 이벤트도 수행 할 작업 목록에 항목을 만드십시오.

data IO₀ = TxtOut String
         | TxtIn (String -> [Output])
         | FileWrite FilePath String
         | FileRead FilePath (String -> [Output])
         | Beep Double

main₂ :: String -> [IO₀]
main₂ _ = [ FileRead "/dev/null" $ \_ ->
             [TxtOutput "Hello World"]
          ]

이제 불균형을 발견 할 수 있습니다. 파일을 읽고 출력에 의존 할 수 있지만 파일 내용을 사용하여 다른 파일을 읽도록 결정할 수는 없습니다. 명백한 해결책 : 입력 이벤트의 결과를 IO단지 유형 이 아닌 유형으로 만드십시오 Output. 그것은 간단한 텍스트 출력을 포함하지만 추가 파일 등을 읽을 수 있습니다.

data IO₁ = TxtOut String
         | TxtIn (String -> [IO₁])
         | FileWrite FilePath String
         | FileRead FilePath (String -> [IO₁])
         | Beep Double

main₃ :: String -> [IO₁]
main₃ _ = [ TxtIn $ \_ ->
             [TxtOut "Hello World"]
          ]

이제 실제로 프로그램에서 원하는 파일 작업을 표현할 수 있지만 (성능이 좋지는 않지만) 다소 복잡합니다.

• main₃전체 작업 목록 을 생성합니다 . 우리는 왜 서명을 사용하지 :: IO₁않습니까? 이것은 특별한 경우입니다.

• 이 목록은 더 이상 프로그램 흐름에 대한 신뢰할 수있는 개요를 제공하지 않습니다. 대부분의 후속 계산은 일부 입력 작업의 결과로만 “공지”됩니다. 따라서 우리는리스트 구조를 버리고, 각 출력 작업에 단순히 “만약”을 적용 할 수 있습니다.

data IO₂ = TxtOut String IO₂
         | TxtIn (String -> IO₂)
         | Terminate

main₄ :: IO₂
main₄ = TxtIn $ \_ ->
         TxtOut "Hello World"
          Terminate

나쁘지 않아!

이 모든 것이 모나드와 어떤 관련이 있습니까?

실제로 모든 프로그램을 정의하기 위해 일반 생성자를 사용하고 싶지는 않습니다. 좋은 기본 생성자 몇 개가 필요하지만 대부분의 상위 수준의 항목에는 멋진 고급 서명이있는 함수를 작성하려고합니다. 의미있는 유형의 값을 수락하고 결과로 IO 동작을 생성합니다.

getTime :: (UTCTime -> IO₂) -> IO₂
randomRIO :: Random r => (r,r) -> (r -> IO₂) -> IO₂
findFile :: RegEx -> (Maybe FilePath -> IO₂) -> IO₂

여기에 분명히 패턴이 있으며, 다음과 같이 작성하는 것이 좋습니다.

type IO₃ a = (a -> IO₂) -> IO₂    -- If this reminds you of continuation-passing
                                  -- style, you're right.

getTime :: IO₃ UTCTime
randomRIO :: Random r => (r,r) -> IO₃ r
findFile :: RegEx -> IO₃ (Maybe FilePath)

이제는 친숙해 보이기 시작하지만 여전히 위장 아래에서 얇게 위장 된 일반 기능 만 처리하고 있으며 위험합니다. 각“값-행동”에는 실제로 포함 된 기능의 결과적 행동을 전달할 책임이 있습니다. 전체 프로그램의 제어 흐름은 중간에 잘못된 동작 하나에 의해 쉽게 중단됩니다). 우리는 그 요구 사항을 명시 적으로 만드는 것이 좋습니다. 글쎄, 그것은 모나드 법칙 으로 밝혀 졌지만, 표준 바인드 / 조인 연산자없이 실제로 공식화 할 수 있는지는 확실하지 않습니다.

여하튼, 우리는 이제 적절한 모나드 인스턴스를 가진 IO의 공식화에 도달했습니다 :

data IO₄ a = TxtOut String (IO₄ a)
           | TxtIn (String -> IO₄ a)
           | TerminateWith a

txtOut :: String -> IO₄ ()
txtOut s = TxtOut s $ TerminateWith ()

txtIn :: IO₄ String
txtIn = TxtIn $ TerminateWith

instance Functor IO₄ where
  fmap f (TerminateWith a) = TerminateWith $ f a
  fmap f (TxtIn g) = TxtIn $ fmap f . g
  fmap f (TxtOut s c) = TxtOut s $ fmap f c

instance Applicative IO₄ where
  pure = TerminateWith
  (<*>) = ap

instance Monad IO₄ where
  TerminateWith x >>= f = f x
  TxtOut s c >>= f = TxtOut s $ c >>= f
  TxtIn g >>= f = TxtIn $ (>>=f) . g

분명히 이것은 효율적인 IO 구현은 아니지만 원칙적으로 사용할 수 있습니다.

답변

perm [e] = [[e]]
perm l = do (leader, index) <- zip l [0 :: Int ..]
            let shortened = take index l ++ drop (index + 1) l
            trailer <- perm shortened
            return (leader : trailer)

*Main> perm "a"
["a"]
*Main> perm "ab"
["ab","ba"]
*Main> perm ""
[]
*Main> perm "abc"
["abc","acb","bac","bca","cab","cba"]