Создание монад в Haskell

Question

Я хочу создать свою собственную монаду.Вот что я написал:

data LeafConType a = LeafCon (a,Int,Int)

instance Monad (LeafConType ) where
return = LeafCon 
lc@(LeafCon (t,i,n)) >>= f = if i>=n
                                then lc
                                else f (t,i,n)

Но это не работает.GHC говорит:

leafcon.hs:26:1:
    Occurs check: cannot construct the infinite type: a = (a, Int, Int)
    When generalising the type(s) for `return'
    In the instance declaration for `Monad LeafConType'

leafcon.hs:27:1:
    Occurs check: cannot construct the infinite type: a = (a, Int, Int)
    When generalising the type(s) for `>>='
    In the instance declaration for `Monad LeafConType'

Что в этом плохого?

---

Я хочу выполнять вычисления, пока я меньше n.n должно быть константой. Я пока не знаю, как это сделать правильно.Это должна быть смесь State и Maybe.Если у вас есть какие-то советы, не стесняйтесь поделиться ими со мной: P

Answer 1

О return:

Prelude> :t return
return :: (Monad m) => a -> m a 

Так return принимает аргумент типа a, и возвращает что-то типа m a.В этом случае m является LeafConType, так LeafConType a возвращается.

Теперь предположим, что мы проходим True.Затем a = Bool, поэтому тип возвращаемого значения должен быть LeafConType Bool.Однако вы определяете:

return = LeafCon

Так, return True становится LeafCon True.Но это недопустимо, поскольку определение типа LeafConType говорится, что

data LeafConType a = LeafCon (a, Int, Int)

Таким образом, для LeafConType Bool аргумент в пользу LeafCon должен иметь тип (Bool, Int, Int), не просто Bool.И вот что означает ошибка компиляции: a не может быть таким же, как (a, Int, Int).Вы заявляете:

Я хочу сделать расчеты, пока i ниже, чем n.

Это означает, что вам понадобятся некоторые значения по умолчанию для i и n, иначе невозможно будет определить return.Если оба они по умолчанию равны нулю, вы можете определить:

return a = LeafCon (a, 0, 0)

О (>>=):

Prelude> :t (>>=)
(>>=) :: (Monad m) => m a -> (a -> m b) -> m b

Теперь посмотрите на вашу реализацию (немного другое обозначение, та же идея):

lc@(LeafCon (t, i, n)) >>= f | i >= n    = lc 
                             | otherwise = f t

То, что мы видим здесь, это то, что lc возвращается, когда i >= n.Но lc имеет тип LeafConType a, пока f это функция, которая может возвращать значение типа LeafConType b, для любой b.В результате может быть так b не равен a и, следовательно, эти типы не совпадают.В заключение вы серьезно должны задать себе один вопрос:

  Можно ли вообще выразить этот тип вычислений в виде монады?

Answer 2

Функции, которые вы указали для >>= и return не удовлетворяют типам, требуемым Monad:

return :: a -> LeafConType a

Учитывая декларацию

return = LeafCon

вы присваиваете функции несовместимый тип

return :: (a, Int, Int) -> LeafConType a

Заявление типа return 42 поэтому было бы невозможно в вашей монаде.

Я вообще не понимаю, что должна делать ваша монада.Сначала взгляните на простые работающие монады!

instance Monad [] where
    (>>=) = concatMap
    return a = [a]

instance Monad Maybe where
    return = Just
    (Just x) >>= f = f x
    Nothing >>= f = Nothing

Answer 3

Судя по вашему описанию того, что вы хотите от своей монады, я думаю, вам нужно что-то вроде этого:

data LeafConType a = LeafCon { runLeafCon' :: Int -> Int -> (Maybe a, Int, Int) }

runLeafCon :: Int -> Int -> LeafConType a -> Maybe a
runLeafCon i n lc = let (t, _, _) = runLeafCon' lc i n in t

getI :: LeafConType Int
getI = LeafCon $ \i n -> (Just i, i, n)

getN :: LeafConType Int
getN = LeafCon $ \i n -> (Just n, i, n)

setI :: Int -> LeafConType ()
setI i = LeafCon $ \_ n -> (Just (), i, n)

setN :: Int -> LeafConType ()
setN n = LeafCon $ \i _ -> (Just (), i, n)

instance Monad LeafConType where
    return t = LeafCon $ \i n -> if (i < n) 
                                 then (Just t, i, n) 
                                 else (Nothing, i, n)

    (LeafCon k) >>= f = 
        LeafCon $ \i n -> 
            let (t, i', n') = k i n
            in case t of
                 Nothing -> (Nothing, i', n')
                 (Just t') -> if (i' < n')
                              then runLeafCon' (f t') i' n'
                              else (Nothing, i, n)


example :: Int -> LeafConType ((), Int)
example x = do 
  i <- getI
  m <- setI (i + x)
  return (m, i + x)

Некоторые примеры:

*Main> runLeafCon 2 10 $ example 4
Just ((),6)
*Main> runLeafCon 2 10 $ example 8
Nothing
*Main> runLeafCon 2 10 $ example 7
Just ((),9)

Я собрал это довольно быстро, оно довольно уродливое, и я не проверял, подчиняется ли оно каким-либо законам Монады, так что используйте на свой страх и риск!:)