Почему длина возвращает 1 для кортежа с 2 элементами и дает ошибку для кортежа с большим количеством элементов?

Ответ 1

Вы столкнулись с причиной Haskell célèbre, которая вызвала много дискуссий и скрежетов зубов.

В принципе, для Foldable (класс стилей, который предоставляет length), 2-кортежи не считаются контейнером из двух элементов, но контейнер одного элемента, сопровождаемый некоторым контекстом.

Вы можете извлечь список элементов типа a из любого Foldable a. Обратите внимание, что для 2-х кортежей переменная типа Foldable является переменной второго элемента кортежа и может отличаться от типа первого элемента.

Если у вас был кортеж ('c',2) :: (Char,Int), было бы не секрет, что вы не смогли бы извлечь два Int в этом случае! Но когда типы равны, он становится запутанным.

Что касается того, почему length (1::Int, 1::Int, 1::Int) не работает, 3-кортежи не имеют определенного экземпляра Foldable, но, возможно, они должны иметь один для согласованности. 3-кортежи также имели бы длину 1.

Кстати, функтор Identity, который можно было считать одним из 1-кортежей, также имеет значение Foldable и, конечно, имеет длину 1.

Если экземпляр Foldable для кортежей существует вообще? Я думаю, что основополагающая философия в пользу "да" - это одна из, мы будем называть ее "полнотой". Если тип может быть создан экземпляром класса в корректном, законном виде, он должен иметь этот экземпляр. Даже если это не очень полезно и в некоторых случаях может быть запутанным.

Ответ 2

Мне нравится ответ danidiaz, потому что он обеспечивает интуицию высокого уровня о том, как работает экземпляр Foldable для кортежей и что он интуитивно означает. Однако, похоже, все еще есть путаница в механизме его; поэтому в этом ответе я сосредоточусь на "закулисных" битах. Полный текст рассматриваемого экземпляра Foldable доступен в Интернете и выглядит следующим образом:

instance Foldable ((,) a) where
    foldMap f (_, y) = f y
    foldr f z (_, y) = f y z

Вы уже можете видеть из этого экземпляра, что первая часть каждого кортежа полностью игнорируется во всех методах Foldable. Однако, чтобы завершить изображение, нам нужно посмотреть определения для minimum и length. Поскольку этот экземпляр не включает определения для minimum и length, мы должны посмотреть на определения по умолчанию для них. Объявление класса для Foldable выглядит так (с несоответствующими битами):

class Foldable t where
    length :: t a -> Int
    length = foldl' (\c _ -> c+1) 0

    foldl' :: (b -> a -> b) -> b -> t a -> b
    foldl' f z0 xs = foldr f' id xs z0
      where f' x k z = k $! f z x

    minimum :: forall a . Ord a => t a -> a
    minimum = fromMaybe (error "minimum: empty structure") .
       getMin . foldMap (Min #. (Just :: a -> Maybe a))

Итак, давайте разложим эти определения и посмотрим, откуда они.

length (a, b)
= { definition of length }
foldl' (\c _ -> c+1) 0 (a, b)
= { definition of foldl' }
foldr (\x k z -> k $! (\c _ -> c+1) z x) id (a, b) 0
= { definition of foldr }
(\x k z -> k $! (\c _ -> c+1) z x) b id 0
= { beta reduction }
id $! (\c _ -> c+1) 0 b
= { id $! e = e }
(\c _ -> c+1) 0 b
= { beta reduction }
1

Обратите внимание, что вывод выполняется независимо от того, что мы подключаем для a и b. Теперь давайте minimum. Для наших целей мы заменим (#.) на (.) - единственное различие - это эффективность, которую мы не заботимся об этой конкретной линии рассуждений.

minimum (a, b)
= { definition of minimum }
( fromMaybe (error "minimum: empty structure")
. getMin
. foldMap (Min . Just)
) (a, b)
= { definition of (.) }
( fromMaybe (error "minimum: empty structure")
. getMin
) (foldMap (Min . Just) (a, b))
= { definition of foldMap }
( fromMaybe (error "minimum: empty structure")
. getMin
) ((Min . Just) b)
= { definition of (.) }
fromMaybe (error "minimum: empty structure")
(getMin (Min (Just b)))
= { definition of getMin }
fromMaybe (error "minimum: empty structure") (Just b)
= { definition of fromMaybe }
b