Какой объем Haskell использует?

Поскольку первой части вопроса уже отвечают другие, вот вторая часть:

Я принимаю aliasing Вы имеете в виду one name for another. Поскольку haskell является функциональным языком, и функции ведут себя как нормальные идентификаторы в любом случае, можно сделать это как это:

y = x

который определил бы псевдоним y для функции x. Обратите внимание, что все - функция. Даже если это похоже на "переменную", это - просто функция nullary, берущая аргументы. Псевдонимы для типов похожи на это:

type Function = Double -> Double

который определил бы псевдоним Function для типа Double -> Double

Использование Haskell (вообще говоря) точно тот же лексический обзор как большинство других языков.

например.

x = 10

Результаты в значении, на которое ссылаются через x в глобальной области видимости, тогда как

square x = x * x

приведет к x будучи лексически ограниченным по объему к функциональному квадрату. Может помочь, думаете ли Вы о вышеупомянутой форме, являющейся синтаксической точностью для:

square = \ x -> x * x

Относительно Вашего другого вопроса я не уверен, что Вы подразумеваете под искажением

Ответ только на вторую часть вопроса:

У Вас может быть несколько псевдонимов для той же "ячейки памяти", но так как они все неизменны, она не имеет значения большую часть времени.

Немой пример:

foo x y = x * y
bar z = foo z z

Когда в foo названный от bar, оба x и y ясно то же значение. Но так как Вы не можете изменить также x или y, Вы даже не заметите.

В Вашем примере глобальное определение x затенено по локальному определению x. В Haskell объем переменной определяется статическим чтением исходного кода - это называют лексическим контекстом, но может получить что-то подобное динамическому обзору с неявными параметрами (но это может привести к некоторому неожиданному поведению (я читал; никогда не пробовал их самостоятельно)).

Подвести итог других ответов кратко:

1. лексический контекст
2. искажение так же легко как x = 1; y = x но обычно не имеет значения, потому что вещи неизменны.

let синтаксис, который Вы используете в своем примере, похож, это в интерактивном ghci> подсказка. Все в интерактивном режиме происходит в монаде IO, таким образом, вещи могут казаться более изменяемыми там, чем нормальный.

Haskell использует статические вложенные контексты. То, что немного сбивает с толку по сравнению с другими языками, которые имеют статические вложенные контексты, - то, что объемом имени является блок, который включает тесты, предшествующие его определению. Например,

evens = 0 : map (+1) odds
odds  = map : (+1) evens

здесь имя 'разногласия' находится в объеме в определении, 'выравнивает', несмотря на удивительное то, что 'разногласия' еще не были определены. (Пример определяет два бесконечных списка четных и нечетных чисел.)

Мертвый язык с подобным правилом обзора данных был Modula-3. Но Haskell немного более хитер в этом, можно попытаться 'переопределить' переменную в том же объеме, но вместо этого Вы просто представляете другое уравнение рекурсии. Это - ловушка для людей, которые изучили ML или Схему сначала:

let x = 2 * n
    x = x + 1   -- watch out!

Это - совершенно хороший ML, или Схема позволила*, но Haskel имеет схему letrec семантика без ограничения на значения лямбды. Неудивительный это - хитрый материал!

Ну, поскольку я думаю, что люди уже сказали, у Haskell нет переменных, как найдено на большинстве других языков, это только имеет выражения. В Вашем примере let x = 10 x является выражением, которое всегда оценивает к 10. Вы не можете на самом деле изменить значение x позже, хотя можно использовать правила обзора данных для сокрытия его путем определения x, чтобы быть другим выражением.

Да, у Haskell есть псевдонимы. Попробуйте эту небольшую программу:

import Data.IORef

main :: IO ()
main = do x <- newIORef 0         -- write 0 into x
          readIORef x >>= print   -- x contains 0
          let y = x
          readIORef y >>= print   -- y contains 0
          writeIORef x 42         -- write 42 into x
          readIORef y >>= print   -- y contains 42