Лень / строгость между данными и newtype

Я пытаюсь понять, почему эти два фрагмента дают разные результаты при так называемом "анализе строгости бедного человека".

В первом примере используется data (при условии правильного применения экземпляра):

data Parser t a = Parser {
        getParser ::  [t] -> Maybe ([t], a) 
    }

> getParser (pure (,) <*> literal ';' <*> undefined ) "abc"
*** Exception: Prelude.undefined

Второй использует newtype. Другой разницы нет:

newtype Parser t a = Parser {
        getParser ::  [t] -> Maybe ([t], a) 
    }

> getParser (pure (,) <*> literal ';' <*> undefined ) "abc"
Nothing

literal x синтаксический анализатор, который успешно использует один маркер ввода, если его аргумент совпадает с первым маркером. Поэтому в этом примере он не работает, так как ; не соответствует a. Однако, пример data по-прежнему видит, что следующий синтаксический анализатор не определен, в то время как пример newtype этого не делает.

Я читал это, это , и это, но не понимаю их достаточно хорошо, чтобы понять, почему первый пример не определен. Мне кажется, что в этом примере newtype является более ленивым, чем data, что противоположно тому, что было сказано в ответах. (По крайней мере, еще один человек был смущен этим тоже).

Почему происходит переключение с data Чтобы newtype изменить определенность этого примера?

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

instance Applicative (Parser s) where
  Parser f <*> Parser x = Parser h
    where
      h xs = 
        f xs >>= (ys, f') -> 
        x ys >>= (zs, x') ->
        Just (zs, f' x')

  pure a = Parser (xs -> Just (xs, a))

В то время как с этим экземпляром парсер data выше делает не вывод undefined (предполагая правильный экземпляр монады для Parser s):

instance Applicative (Parser s) where
  f <*> x =
      f >>= f' ->
      x >>= x' ->
      pure (f' x')

  pure = pure a = Parser (xs -> Just (xs, a))

Полный фрагмент кода:

import Control.Applicative
import Control.Monad (liftM)

data Parser t a = Parser {
        getParser ::  [t] -> Maybe ([t], a) 
    }


instance Functor (Parser s) where
  fmap = liftM

instance Applicative (Parser s) where
  Parser f <*> Parser x = Parser h
    where
      h xs = f xs >>= (ys, f') -> 
        x ys >>= (zs, x') ->
        Just (zs, f' x')

  pure = return


instance Monad (Parser s) where
  Parser m >>= f = Parser h
    where
      h xs =
          m xs >>= (ys,y) ->
          getParser (f y) ys

  return a = Parser (xs -> Just (xs, a))


literal :: Eq t => t -> Parser t t
literal x = Parser f
  where
    f (y:ys)
      | x == y = Just (ys, x)
      | otherwise = Nothing
    f [] = Nothing