Forma normal de cabeça fraca de Haskells

Eu tropecei em algumas coisas irritantes. Eu sei que o haskell funciona com a forma normal da cabeça fraca (WHNF) e eu sei o que é isso. Digitando o seguinte código no ghci (estou usando o comando: sprint que reduz a expressão para WHNF, pelo que sei.):

let intlist = [[1,2],[2,3]]
:sprint intlist

dá intlist = _isso faz totalmente sentido para mim.

let stringlist = ["hi","there"]
:sprint stringlist 

dá stringlist = [_,_]Isso já me confunde. Mas então:

let charlist = [['h','i'], ['t','h','e','r','e']]
:sprint charlist

surpreendentemente dá charlist = ["hi","there"]

Pelo que entendi Haskell, strings nada mais são do que listas de caracteres, o que parece ser confirmado pela verificação dos tipos "hi" :: [Char]e ['h','i'] :: [Char].

Estou confuso, porque no meu entendimento todos os três exemplos acima são mais ou menos iguais (uma lista de listas) e, portanto, deveriam reduzir-se ao mesmo WHNF, ou seja, _. o que estou perdendo?

obrigado

Note-se que :sprintse não reduzir a uma expressão para WHNF. Se assim fosse, o seguinte daria em 4vez de _:

Prelude> let four = 2 + 2 :: Int
Prelude> :sprint four
four = _

Em vez disso, :sprintrecebe o nome de uma ligação, atravessa a representação interna do valor da ligação e mostra as "partes já avaliadas" (ou seja, as partes que são construtores), enquanto usa _como um marcador para thunks não avaliados (ou seja, a função preguiçosa suspensa chamadas). Se o valor for totalmente desvalorizado, nenhuma avaliação será feita, nem mesmo para o WHNF. (E se o valor for completamente avaliado, você obterá isso, não apenas WHNF.)

O que você está observando em seus experimentos é uma combinação de tipos numéricos polimórficos versus monomórficos, diferentes representações internas para strings literais versus listas explícitas de caracteres, etc. Basicamente, você está observando diferenças técnicas em como diferentes expressões literais são compiladas em código de bytes. Portanto, interpretar esses detalhes de implementação como tendo algo a ver com WHNF vai confundi-lo desesperadamente. Geralmente, você deve usar apenas :sprintcomo uma ferramenta de depuração, não como uma forma de aprender sobre o WHNF e a semântica da avaliação de Haskell.

Se você realmente deseja entender o que :sprintestá acontecendo, pode ativar alguns sinalizadores no GHCi para ver como as expressões estão realmente sendo tratadas e, portanto, eventualmente compiladas para bytecode:

> :set -ddump-simpl -dsuppress-all -dsuppress-uniques

Depois disso, podemos ver a razão do seu intlistdá _:

> let intlist = [[1,2],[2,3]]
==================== Simplified expression ====================
returnIO
  (: ((\ @ a $dNum -> : (: (fromInteger $dNum 1) (: (fromInteger $dNum 2) [])) (: (: (fromInteger $dNum 2) (: (fromInteger $dNum 3) [])) []))
      `cast` <Co:10>)
     [])

Você pode ignorar o returnIOe a :chamada externa e se concentrar na parte que começa com((\ @ a $dNum -> ...

Aqui $dNumestá o dicionário da Numrestrição. Isso significa que o código gerado ainda não resolveu o tipo real ano tipo Num a => [[a]], portanto, a expressão inteira ainda é representada como uma chamada de função tomando um (dicionário para) um Numtipo apropriado . Em outras palavras, é uma ideia não avaliada e obtemos:

> :sprint intlist
_

Por outro lado, especifique o tipo como Inte o código será completamente diferente:

> let intlist = [[1::Int,2],[2,3]]
==================== Simplified expression ====================
returnIO
  (: ((: (: (I# 1#) (: (I# 2#) []))
         (: (: (I# 2#) (: (I# 3#) [])) []))
      `cast` <Co:6>)
     [])

e assim é a :sprintsaída:

> :sprint intlist
intlist = [[1,2],[2,3]]

Da mesma forma, strings literais e listas explícitas de caracteres têm representações completamente diferentes:

> let stringlist = ["hi", "there"]
==================== Simplified expression ====================
returnIO
  (: ((: (unpackCString# "hi"#) (: (unpackCString# "there"#) []))
      `cast` <Co:6>)
     [])

> let charlist = [['h','i'], ['t','h','e','r','e']]
==================== Simplified expression ====================
returnIO
  (: ((: (: (C# 'h'#) (: (C# 'i'#) []))
         (: (: (C# 't'#)
               (: (C# 'h'#) (: (C# 'e'#) (: (C# 'r'#) (: (C# 'e'#) [])))))
            []))
      `cast` <Co:6>)
     [])

e as diferenças na :sprintsaída representam artefatos de quais partes da expressão GHCi considera avaliadas ( :construtores explícitos ) versus não avaliados (os unpackCString#thunks).