Стопка преобразователя монады Haskell и подписи типа

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

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

Вот то, что я имею до сих пор:

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

data Msg = Error String
         | Warning String

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


runPass1 addrs instrs msgs = runIdentity (runStateT (runStateT (runStateT (runWriterT msgs) 1) instrs) addrs)


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


incLineNum :: (Num s, MonadState s m) => m ()
incLineNum = do
               ln <- get
               put $ ln + 1

curLineNum :: (MonadState s m) => m s
curLineNum = do
               ln <- get
               return ln

evalr = do l <- popLine
           --incLineNum
           return l

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

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

Pass1.hs:23:14:
    No instance for (MonadState [t] m)
      arising from a use of `get' at Pass1.hs:23:14-16
    Possible fix: add an instance declaration for (MonadState [t] m)
    In a stmt of a 'do' expression: ls <- get
    In the expression:
        do ls <- get
           case ls of {
             x : xs -> do ...
             [] -> return Nothing }
    In the definition of `popLine':
        popLine = do ls <- get
                     case ls of {
                       x : xs -> ...
                       [] -> return Nothing }


Pass1.hs:22:0:
    Couldn't match expected type `s' against inferred type `[Line]'
      `s' is a rigid type variable bound by                        
          the type signature for `popLine' at Pass1.hs:21:23        
    When using functional dependencies to combine                  
      MonadState [Line] m,                                         
        arising from a use of `get' at Pass1.hs:23:14-16            
      MonadState s m,                                              
        arising from the type signature for `popLine'              
                     at Pass1.hs:(22,0)-(28,31)                     
    When generalising the type(s) for `popLine'         




Pass1.hs:23:14:
    Could not deduce (MonadState [Line] m)
      from the context (MonadState s m)   
      arising from a use of `get' at Pass1.hs:23:14-16
    Possible fix:                                    
      add (MonadState [Line] m) to the context of    
        the type signature for `popLine'             
      or add an instance declaration for (MonadState [Line] m)
    In a stmt of a 'do' expression: ls <- get
    In the expression:
        do ls <- get
           case ls of {
             x : xs -> do ...
             [] -> return Nothing }
    In the definition of `popLine':
        popLine = do ls <- get
                     case ls of {
                       x : xs -> ...
                       [] -> return Nothing }

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

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

Pass1.hs:21:0:
    Non type-variable argument in the constraint: MonadState [Line] m
    (Use -XFlexibleContexts to permit this)                          
    In the type signature for `popLine':                             
      popLine :: (MonadState [Line] m) => m (Maybe Line)

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

GHC 6.10.4, Kubuntu

Так, кто-либо может сказать мне, что продолжается, и дайте объяснение / показывают мне правильные подписи типа, или кто-либо знает о хорошей ссылке на этом материале (единственная вещь, которая помогла, до сих пор были "Преобразователи монады Шаг за шагом", но это просто использует одну функцию состояния aux и один StateT)?

Заранее большое спасибо.

Править
Вот код компиляции, включающий предложения JFT и Edward:

{-# LANGUAGE GeneralizedNewtypeDeriving #-} -- needed for: deriving (Functor,Monad)
{-# LANGUAGE MultiParamTypeClasses #-}      -- needed for: MonadState instance
{-# LANGUAGE FlexibleContexts #-}           -- needed for: (MonadState PassState m) => ...

module Pass1 where
import Control.Monad.State
import Control.Monad.Writer
import Data.Maybe
import Types

type Lines     = [Line]
type Addresses = [Address]
type LineNum   = Int
type Messages  = [Msg]
data Msg = Error String
         | Warning String

data PassState = PassState { passLineNum :: LineNum
                           , passLines :: Lines
                           , passAddresses :: Addresses
                           }

newtype Pass1 a = Pass1 { unPass1 :: WriterT Messages (State PassState) a
                        }
                        deriving (Functor,Monad)

instance MonadState PassState Pass1 where
        get   = Pass1 . lift $ get
        put s = Pass1 . lift $ put s



runPass1 :: PassState -> Pass1 a -> ((a, Messages), PassState)
runPass1 state = flip runState state .
                 runWriterT          .
                 unPass1


curLineNum :: (MonadState PassState m) => m LineNum
curLineNum = do
               state <- get
               return $ passLineNum state


nextLine :: (MonadState PassState m) => m (Maybe Line)
nextLine = do
             state <- get
             let c = passLineNum state
             let l = passLines state
             case l of
               x:xs -> do
                         put state { passLines = xs, passLineNum = (c+1) }
                         return $ Just x
               _ -> return Nothing



evalr :: Pass1 (Maybe Line,LineNum)
evalr = do
          l <- nextLine
          c <- curLineNum
          --tell $ Warning "hello"
          return (l,c)

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