Есть ли способ разделить бесконечные и конечные списки?

length просматривает весь список, но чтобы определить, имеет ли список определенную длину n, вам нужно просмотреть только первые n элементы.

Ваша идея использовать take будет работать. В качестве альтернативы вы можете написать функцию lengthIs следующим образом:

-- assume n >= 0
lengthIs 0 [] = True
lengthIs 0 _  = False
lengthIs n [] = False
lengthIs n (x:xs) = lengthIs (n-1) xs

Вы можете использовать ту же идею для написания вариантов lengthIsAtLeast и lengthIsAtMost.

О редактировании: я в первую очередь отвечаю на вопрос в вашем заголовке, а не на особенности вашего конкретного примера (для которого ответ ErikR превосходен).

Многие функции (например, сама length) в списках имеют смысл только для конечных списков. Если функция, которую вы пишете, имеет смысл только для конечных списков, укажите это в документации (если это не очевидно). Нет никакого способа применить ограничение, поскольку проблема остановки неразрешима. Просто не существует алгоритма, который заранее определял бы, правильное понимание или нет.

takeWhile f [1..]

(где f — предикат целых чисел) создает конечный или бесконечный список.

Nats и снова удар лени:

import Data.List

data Nat = S Nat | Z deriving (Eq)

instance Num Nat where
    fromInteger 0 = Z
    fromInteger n = S (fromInteger (n - 1))

    Z   + m = m
    S n + m = S (n + m)

lazyLength :: [a] -> Nat
lazyLength = genericLength

main = do
    print $ lazyLength [1..]    == 100 -- False
    print $ lazyLength [1..100] == 100 -- True

ErikR и John Coleman уже ответили на основные части вашего вопроса, однако я хотел бы отметить еще кое-что:

Лучше всего писать свои функции таким образом, чтобы они просто не зависели от конечности или бесконечности своих входных данных — иногда это невозможно, но в большинстве случаев это просто вопрос редизайна. Например, вместо вычисления среднего значения всего списка вы можете вычислить скользящее среднее значение, которое само по себе является списком; и сам этот список будет бесконечным, если входной список бесконечен, и конечным в противном случае.

avg :: [Double] -> [Double]
avg = drop 1 . scanl f 0.0 . zip [0..]
  where f avg (n, i) = avg * (dbl n / dbl n') +
                       i            / dbl n'      where n'  = n+1
                                                        dbl = fromInteger

в этом случае вы можете усреднять бесконечный список, не беря его length:

*Main> take 10 $ avg [1..]
[1.0,1.5,2.0,2.5,3.0,3.5,4.0,4.5,5.0]

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

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

Существует несколько различных способов создания конечного списка. Первый — просто сделать списки строгими в своих корешках:

data FList a = Nil | Cons a !(FList a)

К сожалению, это сводит на нет все преимущества эффективности лени. Некоторые из них можно восстановить, используя вместо этого списки с индексом длины:

{-# LANGUAGE GADTs #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE KindSignatures #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# OPTIONS_GHC -fwarn-incomplete-patterns #-}

data Nat = Z | S Nat deriving (Show, Read, Eq, Ord)

data Vec :: Nat -> * -> * where
  Nil :: Vec 'Z a
  Cons :: a -> Vec n a -> Vec ('S n) a

instance Functor (Vec n) where
  fmap _f Nil = Nil
  fmap f (Cons x xs) = Cons (f x) (fmap f xs)

data FList :: * -> * where
  FList :: Vec n a -> FList a

instance Functor FList where
  fmap f (FList xs) = FList (fmap f xs)

fcons :: a -> FList a -> FList a
fcons x (FList xs) = FList (Cons x xs)

funcons :: FList a -> Maybe (a, FList a)
funcons (FList Nil) = Nothing
funcons (FList (Cons x xs)) = Just (x, FList xs)

-- Foldable and Traversable instances are straightforward
-- as well, and in recent GHC versions, Foldable brings
-- along a definition of length.

GHC не допускает бесконечных типов, поэтому невозможно построить бесконечный Vec и, следовательно, невозможно создать бесконечный FList (1). Однако FList можно преобразовывать и потреблять несколько лениво, что влечет за собой преимущества кэширования и сборки мусора.

(1) Обратите внимание, что система типов заставляет fcons быть строгим в аргументе FList, поэтому любая попытка завязать узел с FList обречена на провал.