Каково правило порядка нескольких переменных типа в haskell?

Например, ParsecT имеет в своем определении несколько переменных типа.

newtype ParsecT s u m a
    = ParsecT {unParser :: forall b .
                 State s u
              -> (a -> State s u -> ParseError -> m b) 
              -> (ParseError -> m b)                   
              -> (a -> State s u -> ParseError -> m b) 
              -> (ParseError -> m b)                   
              -> m b
             }

Можем ли мы сделать это так?

newtype ParsecT m a s u     -- Only the order of s u m a is changed to m a s u.
    = ParsecT {unParser :: forall b .
                 State s u
              -> (a -> State s u -> ParseError -> m b) 
              -> (ParseError -> m b)                   
              -> (a -> State s u -> ParseError -> m b) 
              -> (ParseError -> m b)                   
              -> m b
             }

Мне интересно, существует ли правило или принцип порядка переменных типа при определении нового типа.

Ответ 1

В этом случае a является последним, потому что мы хотим, чтобы ParsecT s u m __ была монадой, таким образом, то, что ищут наши парсеры, может зависеть от того, что они нашли раньше, и так далее. Если u пришел последним, мы не смогли написать

 instance Monad m => Monad (ParsecT s u m) where ...

m является последним, потому что мы хотим, чтобы ParsecT s u был "монадным трансформатором"

 class MonadTrans t where 
     lift :: m a -> t m a 

 instance MonadTrans (ParsecT s u) where ...

Если сначала поставить m, этот экземпляр будет невозможен. Кажется, не существует какой-либо подобной причины для упорядочения s и u.