Почему определение функции для всех типов одновременно не разрешено в Haskell?

Это особенность, и на самом деле очень фундаментальная. Это сводится к свойству, известному как параметричность в теории языков программирования. Грубо говоря, это означает, что вычисление никогда не должно зависеть от типов, являющихся переменными во время компиляции. Вы не можете смотреть на значение, если вы не знаете его конкретный тип статически.

Почему это хорошо? Это дает гораздо более сильные инварианты о программах. Например, вы знаете только из типа, что a -> a должна быть функцией тождества (или расходится). Подобные «свободные теоремы» применимы ко многим другим полиморфным функциям. Параметричность также является основой для более продвинутых методов абстракции на основе типов. Например, тип ST s a в Haskell (монада состояния) и тип соответствующей функции runST полагаются на то, что s является параметрическим. Это гарантирует, что работающая функция не сможет возиться с внутренним представлением состояния.

Это также важно для эффективной реализации. Программе не нужно передавать дорогостоящую информацию о типах во время выполнения (удаление типов), и компилятор может выбирать перекрывающиеся представления для разных типов. В качестве примера последнего, 0 и False и () и [] представлены 0 во время выполнения. Это было бы невозможно, если бы была разрешена такая функция, как ваша.

Haskell использует стратегию реализации, известную как «стирание типов»: типы не имеют вычислительной значимости, поэтому код, который вы создаете, не должен их отслеживать. Это значительный плюс для производительности.

Цена, которую вы платите за это преимущество в производительности, заключается в том, что типы не имеют никакого вычислительного значения: функция не может изменить свое поведение в зависимости от типа переданного ей аргумента. Если бы вы разрешили что-то вроде

f () = "foo"
f [] = "bar"

тогда это свойство не было бы истинным: поведение f действительно зависело бы от типа его первого аргумента.

Конечно, есть языки, которые допускают такие вещи, особенно в языках с зависимой типизацией, где типы, как правило, все равно не могут быть стерты.

Для функции a -> Integer разрешено только одно поведение - возвращать постоянное целое число. Почему? Потому что вы понятия не имеете, что такое тип a. Без указания ограничений это может быть абсолютно что угодно, а поскольку Haskell статически типизирован, вам нужно разрешать все, что связано с типами, во время компиляции. Во время выполнения информация о типе больше не существует, и поэтому к ней нельзя обратиться — все выборы функций для использования уже сделаны.

Самое близкое, что Haskell допускает к такому поведению, - это использование классов типов - если вы создали класс типов с именем Foo с одной функцией:

class Foo a where
    foo :: a -> Integer

Затем вы можете определить его экземпляры для разных типов

instance Foo [a] where
    foo [] = 0
    foo (x:xs) = 1 + foo xs

instance Foo Float where
    foo 5.2 = 10
    foo _ = 100

Затем, пока вы можете гарантировать, что какой-то параметр x является Foo, вы можете вызвать для него foo. Вам все равно это нужно - вы не можете написать функцию

bar :: a -> Integer
bar x = 1 + foo x

Поскольку компилятор не знает, что a является экземпляром Foo. Вы должны сказать это или пропустить сигнатуру типа, и пусть она разберется сама.

bar :: Foo a => a -> Integer
bar x = 1 + foo x

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

Тип a -> Integer на самом деле не означает «функция от любого типа до Integer», как вы его описываете. Когда определение или выражение имеет тип a -> Integer, это означает, что для любого типа T можно специализировать или создать экземпляр этого определения или выражения в функцию типа T -> Integer.

Немного изменив нотацию, можно представить, что foo :: forall a. a -> Integer на самом деле является функцией двух аргументов: типа a и значения этого типа a. Или, с точки зрения каррирования, foo :: forall a. a -> Integer — это функция, которая принимает тип T в качестве аргумента и создает специализированную функцию типа T -> Integer для этого T. Используя функцию тождества в качестве примера (функция, которая выдает свой аргумент в качестве результата), мы можем продемонстрировать это следующим образом:

-- | The polymorphic identity function (not valid Haskell!)
id :: forall a. a -> a
id = \t -> \(x :: t) -> x

Идея реализации полиморфизма в качестве аргумента типа для полиморфной функции исходит из математической структуры под названием System F. , который Haskell фактически использует как один из своих теоретических источников. Однако Haskell полностью скрывает идею передачи параметров типа в качестве аргументов функциям.

Этот вопрос основан на ошибочной предпосылке, Haskell может это сделать! (хотя обычно он используется только в очень специфических обстоятельствах)

{-# LANGUAGE ScopedTypeVariables, NoMonomorphismRestriction #-}

import Data.Generics

q1 :: Typeable a => a -> Int
q1 = mkQ 0 (\s -> if s == "aString" then 100 else 0)

q2 :: Typeable a => a -> Int
q2 = extQ q1 (\(f :: Float) -> round f)

Загрузите это и поэкспериментируйте с ним:

Prelude Data.Generics> q2 "foo"
0
Prelude Data.Generics> q2 "aString"
100
Prelude Data.Generics> q2 (10.1 :: Float)
10

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

Большинство так называемых универсальных функций (например, SYB) полагаются либо на ограничение Typeable, либо на ограничение Data. Некоторые пакеты вводят свои собственные альтернативные функции, по сути, для той же цели. Без чего-то вроде этих классов это невозможно сделать.