Haskell Monad Transformer Stack and Type Signatures - программирование

Я пытаюсь создать стек монадных трансформаторов, и у меня возникают проблемы с получением правильных сигнатур типов для моих функций. (Я все еще довольно новичок в Haskell)

Стек объединяет несколько трансформаторов StateT, так как у меня есть несколько состояний, которые мне нужно отслеживать (два из которых могут быть скопированы, но я получу это через секунду) и WriterT для ведения журнала.

Я хотел бы, чтобы popLine вошел в состояние [Line] и функции xLineNum, чтобы повлиять на состояние Int. evalr - это вычисление, которое будет передано в runPass1.

Всякий раз, когда я загружаю код, я запускаю ошибки, которые обычно имеют следующий вид:

Ни одна из подписей не кажется правильной, но popLine - это первая функция, поэтому она единственная, которая сразу вызывает ошибку.

Я пытаюсь добавить то, что он предлагает в сигнатуре типа (например: popLine :: (MonadState [Line] m) => ..., но затем он выглядит так:

Я всегда получаю это сообщение, когда пытаюсь сделать что-то, что не является переменной типа. Похоже, (MonadState s m) ok и ошибка на что-то еще, но когда я пытаюсь использовать его с [a] вместо s, это приводит к ошибкам, аналогичным приведенным выше. (Изначально [Line] и Int были включены в одно состояние, но я получал эту ошибку, поэтому я думал, что попытаюсь поместить их в отдельные состояния).

Итак, может ли кто-нибудь сказать мне, что происходит, и дать объяснение/показать мне правильные подписи типов, или кто-нибудь знает хорошую ссылку на этот материал (единственное, что помогло до сих пор, это "Monad Transformers Step" by Step ", но это просто использует одну функцию состояния aux и одно StateT)?

Edit
Здесь компиляционный код, включающий предложения JFT и Edward:

Я объединил incLineNum и popLine в nextLine Мне все еще нужно, чтобы часть монады Writer работала, но думаю, что я знаю, куда идти отсюда. Спасибо, ребята.

Ответы

Ответ 1

Было много проблем с вашим фрагментом кода. Я исправил ваш фрагмент, добавив объяснения относительно того, что было сломано, и добавил, если вам будет нужно посоветовать какой-нибудь стиль.

module Pass1_JFT where
import Control.Monad.Identity
import Control.Monad.State
import Control.Monad.Writer
import Data.Maybe
import qualified Data.Map as Map

{- замена типов импорта с помощью простых определений -}

--import Types
type Line       = String
type Address    = String
type LineNumber = Int

{- Не часть вашего вопроса, но мои 2 цента здесь... Скажите, что вы хотите изменить коллекцию для своих штатов, если вы не используйте псевдоним типа, который вам нужно будет искать везде, где вы его использовали. Вместо этого просто при необходимости измените эти определения -}

type Lines     = [Line]
type Addresses = [Address]
type Messages  = [Msg]


data Msg = Error String
         | Warning String

{- Что такое Int в StateT Int? Назовите его легче читать, рассудите и изменить. Декларативный FTW позволяет вместо этого использовать LineNumber -}

--type Pass1 a = WriterT [Msg] (StateT Int (StateT [Line] (StateT [Address] Identity))) a

{- Позвольте использовать "реальный" тип, чтобы экземпляры могли быть получены. Поскольку Pass1 не является переносом монады, то есть не определяется как Pass1 m a, нет точки, использующей StateT для самого глубокого состояния, то есть StateT [Address] Identity поэтому позвольте просто использовать State [Address] -}

newtype Pass1 a = Pass1 {
    unPass1 :: WriterT Messages (StateT LineNumber (StateT Lines (State Addresses))) a
                        }
                        deriving (Functor,Monad)

--runIdentity (runStateT (runStateT (runStateT (runWriterT msgs) 1) instrs) addrs)

{- Пусть отслаивается, что стек от внешнего (lefmost в декларации) до самого внутреннего был Identity в вашей первоначальной декларации. Обратите внимание, что runWriterT НЕ принимает начальное состояние... Первый параметр для runStateT (и runState) не является начальным состоянием но монада... так пусть флип! -}

runPass1' :: Addresses -> Lines -> Messages -> Pass1 a ->  ((((a, Messages), LineNumber), Lines), Addresses)
runPass1' addrs instrs msgs = flip runState addrs   .
                              flip runStateT instrs .
                              flip runStateT 1      .
                              runWriterT            . -- then get process the WriterT (the second outermost)
                              unPass1                 -- let peel the outside Pass1

{- теперь, когда последняя функция НЕ делает то, что вы хотите, поскольку вы хотите предоставить начальный журнал для добавления в WriterT. Так как это монадный трансформатор, мы сделаем здесь трюк -}

-- I keep the runStateT convention for the order of the arguments: Monad then state
runWriterT' :: (Monad m,Monoid w) => WriterT w m a -> w -> m (a,w)
runWriterT' writer log = do
    (result,log') <- runWriterT writer
    -- let use the monoid generic append in case you change container...
    return (result,log `mappend` log')

runPass1 :: Addresses -> Lines -> Messages -> Pass1 a ->  ((((a, Messages), LineNumber), Lines), Addresses)
runPass1 addrs instrs msgs = flip runState addrs   .
                             flip runStateT instrs .
                             flip runStateT 1      .
                             flip runWriterT' msgs . -- then get process the WriterT (the second outermost)
                             unPass1                 -- let peel the outside Pass1

{- Вы собираетесь называть popLine непосредственно из стека Pass1? Если это так, вам нужно "научить" Pass1 быть "MonadState Lines", Для этого давайте получим Pass1 (вот почему мы объявили его с помощью newtype!) -}

instance MonadState Lines Pass1 where
    -- we need to dig inside the stack and "lift" the proper get
    get   = Pass1 . lift . lift $ get
    put s = Pass1 . lift . lift $ put s

{- Лучше держите вещи родовыми, но теперь мы могли бы написать: popLine:: Pass1 (возможно, линия) -}

popLine :: (MonadState Lines m) => m (Maybe Line)
popLine = do
        ls <- get
        case ls of
          x:xs -> do
                    put xs
                    return $ Just x
          []   -> return Nothing

{- Теперь я получаю Int = > LineNumber.... мы могли бы сделать Pass1 и экземпляр MonadState LineNumber, но LineNumber не следует смешивать, поэтому вместо этого я бы закодировал incLine напрямую и предоставил бы экземпляр MonadReader для консуляции, если требуется

check ":t incLineNum and :t curLineNum"

incLineNum = Pass1 . lift $ modify (+1)

curLineNum = Pass1 $ lift get

evalr = do l <- popLine
           incLineNum
           return l

Там это длинный ответ, но монада и монада, как вы видите, сначала сложны. Я исправил код, но я призываю вас играть и проверять типы различных функций, чтобы понять, что происходит и сравнивать с вашим оригиналом. Вывод типа Haskell означает, что обычно аннотации типа являются излишними (если только для устранения двусмысленности). В общем, тип, который мы даем функции, является менее общим, что было сделано, поэтому лучше не вводить аннотацию. Типовая аннотация является окончательно хорошей техникой отладки, хотя:)

Приветствия

P.S. Реальный мир Haskell глава о Monad Transformer превосходна: http://book.realworldhaskell.org/read/monad-transformers.html

Ответ 2

В общем, вы обнаружите, что код становится намного яснее, используя одно StateT с большей составной структурой для всех бит состояния, которое вам нужно. Одна из веских причин состоит в том, что, когда вы придумываете часть состояния, которую вы забыли, вы всегда можете вырастить структуру по одному полю, и вы можете использовать звуковой сахар, чтобы выписывать одно полевые обновления или переходить к чему-то вроде fclabels или data-accessor пакеты для управления состоянием.

data PassState = PassState { passLine :: Int, passLines :: [Line] }

popLine :: MonadState PassState m => m (Maybe Line).   
popLine = do
   state <- get
   case passLines state of
      x:xs -> do 
         put state { passLines = xs }
         return (Just x)
      _ -> return Nothing