"Привет" это преобразователь или в нормальной форме?

Если вы скажете GHC напечатать обесахаривание "hello" в GHC Core, вы увидите, что строковый литерал обессахаривается до вызова unpackCString#. Фактическое содержимое строки хранится компактно "hello"#, а функция unpackCString# строит соответствующий связанный список 'h' : 'e' : 'l' : 'l' : 'o' : [] по запросу, поэтому при потоковом использовании требуется очень мало памяти.

> :set -ddump-ds -dsuppress-all
> x = "hello"

==================== Desugared ====================
letrec {
  x_aCa = letrec { x_aCe = unpackCString# "hello"#; } in x_aCe; } in
returnIO (: (unsafeCoerce# x_aCa) [])

Как я уже говорил ранее, это в основном связано с тем, как GHCi решает хранить значения, а не с тем, что указано в стандарте Haskell. Преобразователи/лень — это деталь реализации того, как достигается нестрогость, и иногда они также являются хорошей ментальной моделью, но не всегда. Строгость касается функций и того, как ⊥-значения могут или не могут распространяться. Любая мудрость о том, где преобразователь может или не может появиться, в основном является побочным продуктом этого.

Но есть еще пара вещей, о которых следует помнить на чистом уровне value/thunk.

Полиморфные значения всегда оцениваются по требованию; в основном это функции с невидимыми аргументами. В GHCi (в котором ограничение мономорфизма отключено по умолчанию) легко определить полиморфные значения без необходимости, в частности числовые литералы. Тогда :sprint всегда будет давать только _.
Это не проблема в ваших примерах: явное ограничение конкретным типом обеспечивает мономорфные привязки.

Пока вы напрямую используете простые конструкторы, есть большая вероятность, что компилятор/интерпретатор сохранит их напрямую в нормальной форме. Он делает это, например, для чего-то вроде ('a', (Just 'b','c')). Но я не думаю, что это когда-либо гарантировано, и обычно это в любом случае не имеет значения, потому что буквальные конструкторы только доходят до вас. Все, что гарантируется, — это то, что значение, определенное как внешний конструктор, может быть оценено как WHNF, не сталкиваясь с ⊥, но здесь мы снова находимся в области свойств строгости.

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

x = 1::Int

похоже, не производит никакого thunk. Но опять же: это зависит от компилятора, и это просто имеет смысл: нет никакого риска ⊥, значение прямо здесь, готовое к сохранению, тогда как построение санка вокруг него повлечет за собой совершенно ненужную косвенность указателя.

Стоит отметить, что это происходит не для всех числовых литералов:

ghci> let y = 1678796789876876987698768798769876986780987609876 :: Integer
ghci> :sprint y
y = _

В этом случае число больше не вписывается в 64-битное число, поэтому менее ясно, что размещение его прямо в памяти выгодно; оказывается, GHC не рискует в этом случае.

Теперь для строк у нас была бы почти такая же ситуация, если бы -XOverloadedStrings был активен, и в этом случае все строковые литералы должны были бы быть заключены в fromString . Но нет никакой гарантии, что наоборот: то, что расширение не активно, не означает, что GHC не может обернуть литерал какой-либо другой функцией. Как показал Ли-яо Ся, он оборачивает его в низкоуровневую функцию unpackCString#. (Это, безусловно, имеет смысл с точки зрения памяти, потому что строка C непрерывна и эффективна в памяти, тогда как строки связанного списка Haskell откровенно ужасны для хранения, занимая примерно в 16 раз больше памяти.) Это законно, пока компилятор убедитесь, что вы не столкнетесь с ⊥ при оценке строки.

В этом случае явное определение строки с помощью простых конструкторов приводит к ее немедленному сохранению в нормальной форме:

ghci> let x = "hello" :: String
ghci> :sprint x
x = _
ghci> let x' = 'h':'e':'l':'l':'o':[]
ghci> :sprint x'
x' = "hello"