10

はじめに、この長い投稿で申し訳ありません。

Haskell でイベント駆動型アプリケーションを作成しているため、さらに使用するためにいくつかのコールバック関数を保存する必要があります。そのようなコールバックを次のようにしたいと思います。

  • 豊かな:裸の sではなくReaderT、ErrorT,の使用。StateTIO
  • ポリモーフィック: タイプ(MonadIO m, MonadReader MyContext m, MonadState MyState m, MonadError MyError m) => m ()ではなくReaderT MyContext (StateT MyState (ErrorT MyError IO)))

簡単にするために、層Stateと層については忘れましょう。Error

内に保存されたすべてのコールバックの記録を書き始めましたMyContext。次のようなものです。

    data MyContext = MyContext { _callbacks :: Callbacks {- etc -} }

    -- In this example, 2 callbacks only
    data Callbacks = Callbacks {
        _callback1 :: IORef (m ()),
        _callback2 :: IORef (m ())}

主な問題は、型クラスの制約をどこに置くmかです。次のことを試しましたが、コンパイルされたものはありません：

  • Callbacks次のようにパラメータ化できると思いmました：

    data (MonadIO m, MonadReader (MyContext m) m) => Callbacks m = Callbacks {
   _callback1 :: IORef (m ()),
   _callback2 :: IORef (m ())}

    Callbacksの一部であるためMyContext、後者もパラメータ化する必要があり、無限型の問題が発生します ( MonadReader (MyContext m) m)。

  • 次に、存在量指定子を使用することを考えました。

    data Callbacks = forall m . (MonadIO m, MonadReader MyContext m) => Callbacks {
   _callback1 :: IORef (m ()),
   _callback2 :: IORef (m ())}

    に新しいコールバックを登録する実際のコードを書くまでは、問題なく動作しているように見えましたCallbacks。

    register :: (MonadIO m, MonadReader MyContext m) => m () -> m ()
register f = do
  (Callbacks { _callback1 = ref1 }) <- asks _callbacks -- Note the necessary use of pattern matching
  liftIO $ modifyIORef ref1 (const f)

    しかし、次のエラーが発生しました（ここでは簡略化しています）：

    Could not deduce (m ~ m1)
  from the context (MonadIO m, MonadReader MyContext m)
    bound by the type signature for
         register :: (MonadIO m, MonadReader MyContext m) => m () -> m ()
  or from (MonadIO m1, MonadReader MyContext m1)
    bound by a pattern with constructor
         Callbacks :: forall (m :: * -> *).
                   (MonadIO m, MonadReader MyContext m) =>
                   IORef (m ())
                   -> IORef (m ())
                   -> Callbacks,
  Expected type: m1 ()
  Actual type: m ()

    回避策を見つけることができませんでした。

誰かが私を啓発してくれれば、本当に感謝しています。もしあれば、これを設計する良い方法は何でしょうか?

コメントありがとうございます。

[編集] ysdxの答えを理解している限り、型クラスのm制約を課すことなくデータ型をパラメータ化しようとしましたが、 ;Callbacksのインスタンスを作成できませんでした。Data.Defaultこのようなものを書く：

instance (MonadIO m, MonadReader (MyContext m) m) => Default (Callbacks m) where
  def = Callbacks {
    _callback1 = {- something that makes explicit use of the Reader layer -},
    _callback2 = return ()}

... GHCは次のように不平を言った：

Variable occurs more often in a constraint than in the instance head
  in the constraint: MonadReader (MyContext m) m

UndecidableInstances の使用を示唆していますが、理由はわかりませんが、非常に悪いことだと聞きました。使用をあきらめなければならないということData.Defaultですか？

4

1 に答える 1

6

簡単な適応 (物事をコンパイルする):

data MyContext m = MyContext { _callbacks :: Callbacks m }

data Callbacks m = Callbacks {
  _callback1 :: IORef (m ()),
  _callback2 :: IORef (m ())}

-- Needs FlexibleContexts:
register :: (MonadIO m, MonadReader (MyContext m) m) => m () -> m ()
register f = do
  (Callbacks { _callback1 = ref1 }) <- asks _callbacks
  liftIO $ modifyIORef ref1 (const f)

ただし、-XFlexibleContexts が必要です。

本当に IORef が必要ですか? 単純な状態モナドを使用しないのはなぜですか?

import Control.Monad.State
import Control.Monad.Reader.Class
import Control.Monad.Trans

data Callbacks m = Callbacks {
  _callback1 :: m (),
  _callback2 :: m ()
  }

-- Create a "new" MonadTransformer layer (specialization of StateT):

class Monad m => MonadCallback m where
  getCallbacks :: m (Callbacks m)
  setCallbacks :: Callbacks m -> m ()

newtype CallbackT m a = CallbackT (StateT (Callbacks (CallbackT m) ) m a)

unwrap (CallbackT x) = x

instance Monad m => Monad (CallbackT m) where
  CallbackT x >>= f = CallbackT (x >>= f')
    where f' x = unwrap $ f x
  return a =  CallbackT $ return a
instance Monad m => MonadCallback (CallbackT m) where
  getCallbacks = CallbackT $ get
  setCallbacks c = CallbackT $ put c
instance MonadIO m => MonadIO (CallbackT m) where
  liftIO m = CallbackT $ liftIO m
instance MonadTrans (CallbackT) where
  lift m = CallbackT $ lift m
-- TODO, add other instances

-- Helpers:

getCallback1 = do
  c <- getCallbacks
  return $ _callback1 c

-- This is you "register" function:
setCallback1 :: (Monad m, MonadCallback m) => m () -> m ()
setCallback1 f = do
  callbacks <- getCallbacks
  setCallbacks $ callbacks { _callback1 = f }   

-- Test:

test :: CallbackT IO ()
test = do
  c <- getCallbacks
  _callback1 c
  _callback2 c

main = runCallbackT test s
  where s = Callbacks { _callback1 = lift $ print "a" (), _callback2 = lift $ print "b" }

このコード コードは MonadIO がなくても機能します。

「デフォルト」の定義はうまくいくようです：

instance (MonadIO m, MonadCallback m) => Default (Callbacks m) where
def = Callbacks {
  _callback1 = getCallbacks >>= \c -> setCallbacks $ c { _callback2 = _callback1 c },
  _callback2 = return ()}
于 2012-08-20T22:11:56.917 に答える