如何在狀態monad的字段上匹配匹配？

Question

有沒有可能寫使用模式匹配/守衛功能a？

{-# LANGUAGE PatternGuards #-} 
import Control.Monad.State.Strict(State, gets, runStateT) 
data MyState = MyState 
    { counter :: Int 
    } deriving (Show) 


a :: State MyState String 
a = do 
    i <- gets counter 
    case i of 
     0 -> return "hello" 
     1 -> return "bye" 

run = runStateT a (MyState{counter=0}) 

我試着寫a作爲

a' :: State MyState String 
a' | i <- gets counter, i == 0 = return "hello" 

，但得到的錯誤：

No instance for (Control.Monad.State.Class.MonadState MyState m0) 
    arising from a use of ‘gets’ 
The type variable ‘m0’ is ambiguous 
Note: there are several potential instances: 
    instance Control.Monad.State.Class.MonadState s m => 
      Control.Monad.State.Class.MonadState 
      s (Control.Monad.Trans.Cont.ContT r m) 
    -- Defined in ‘Control.Monad.State.Class’ 
    instance (Control.Monad.Trans.Error.Error e, 
      Control.Monad.State.Class.MonadState s m) => 
      Control.Monad.State.Class.MonadState 
      s (Control.Monad.Trans.Error.ErrorT e m) 
    -- Defined in ‘Control.Monad.State.Class’ 
    instance Control.Monad.State.Class.MonadState s m => 
      Control.Monad.State.Class.MonadState 
      s (Control.Monad.Trans.Except.ExceptT e m) 
    -- Defined in ‘Control.Monad.State.Class’ 
    ...plus 12 others 
In a stmt of a pattern guard for 
       an equation for ‘a'’: 
    i <- gets counter 
In an equation for ‘a'’: 
    a' | i <- gets counter, i == 0 = return "hello" 

No instance for (Eq (m0 Int)) arising from a use of ‘==’ 
The type variable ‘m0’ is ambiguous 
Relevant bindings include 
    i :: m0 Int (bound at src/TestGen/Arbitrary/Helpers/Z.hs:18:6) 
Note: there are several potential instances: 
    instance Eq a => Eq (GHC.Real.Ratio a) -- Defined in ‘GHC.Real’ 
    instance (Eq e, Data.Functor.Classes.Eq1 m, Eq a) => 
      Eq (Control.Monad.Trans.Error.ErrorT e m a) 
    -- Defined in ‘Control.Monad.Trans.Error’ 
    ...plus 118 others 
In the expression: i == 0 
In a stmt of a pattern guard for 
       an equation for ‘a'’: 
    i == 0 
In an equation for ‘a'’: 
    a' | i <- gets counter, i == 0 = return "hello" 

Answer 1

這是不可能的。模式保護語法中的左箭頭是，主要是，與do-notation中的左箭頭無關。

您可以使用新的λ-情況下擴展，如果你喜歡：如果

{-# LANGUAGE LambdaCase #-} 
a :: State MyState String 
a = gets counter >>= \case 
     0 -> return "hello" 
     1 -> return "bye" 

或多路，也許？

{-# LANGUAGE MultiWayIf #-} 
a :: State MyState String 
a = do 
    i <- gets counter 
    if 
     | i == 0 -> return "hello" 
     | i == 1 -> return "bye" 

Answer 2

爲什麼不寫一個幫手？

pureA :: MyState -> String 
pureA (MyState 0) = "hello" 
pureA (MyState 1) = "bye" 
pureA _   = "" 

a :: State MyState String 
a = fmap doA get 

這也遵循了從你的不純邏輯中分離純邏輯問題的哲學。

Answer 3

不，這裏有一些非常基本的概念錯配。

模式匹配當表達的最上部是一個構造功能，但do風格塊的頭部將是一個正常功能（在這種情況下所定義的函數>>=只能在類型類Monad）中。

衛隊期望Bool類型的值，但你要交出他們將不得不State MyState Bool類型的（因爲大約單子與衆不同的事情之一是，你不能從他們逃脫）的值。所以警衛也永遠不會工作。

您可以但是達到仿函數實例。 Functor在Prelude中定義;在Control.Applicative中有fmap的中綴形式<$>。你會說這樣做：

a' = process <$> gets counter 
    where 
     process 0 = "hello" 
     process _ = "bye" 

任何你想用 process功能

或做。要獲得更類似>>=的內容，您還可以將自己的運營商定義爲flip fmap，然後您可以編寫例如gets counter >= \x -> case x of ...。

Answer 4

是的，這是可能的，但我建議你不要這樣做 - 很難跟蹤哪一塊去哪裏。

import Control.Monad.State.Strict(StateT(..)) 
import Data.Functor.Identity(Identity(..)) 

data MyState = MyState 
    { counter :: Int 
    } deriving (Show) 

a :: StateT MyState Identity String 
a = StateT $ \ s@(MyState i) -> Identity $ 
    case i of 
    0 -> ("hello", s) 
    1 -> ("bye", s)