Implement the take function with list comprehension

Question

How would you implement take with a list comprehension?

My approach so far:

take2 :: (Num i, Ord i) => i -> [a] -> [a]
take2 n xs = [x | x <- xs, [x..n]]

Answer 1

The fundamental reason why list comprehensions are not a good fit for the take function is this:

The take function stops the evaluation of the argument list after n elements.

But lists comprehensions always evaluate all elements of the list in the generator. There is no break-statement in Haskell.

---

You can use some trick to truncate the list before or after using it in the list comprehension, but there is no real point of doing so. That would be similar to first using normal take to truncate the list, then using a list comprehension just to return the result.

Answer 2

We can use a zip approach here, and enumerate over both the elements, and indices, like:

take2 :: (Num i, Enum i) => i -> [a] -> [a]
take2 n xs = [x | (x, _) <- zip xs [1..n]]

Or with the ParallelListComp extension:

{-# LANGUAGE ParallelListComp #-}

take2 :: (Num i, Enum i) => i -> [a] -> [a]
take2 n xs = [x | x <- xs | _ <- [1..n]]

But actually take is probably not a function that is a good fit for list comprehension in the first place.

Answer 3

Without List Comprehension

take' :: Int -> [Int] -> [Int]
take' _ [] = []
take' _ [x] = [x]
take' n all@(x : xs)
        | (n > length all) = error "Index too large"
        | (n == length all) = all
        | (n == 0) = []
        | (n < length all) =  x : [] ++ (take' (n-1) xs)

Answer 4

take' :: Int -> [a] -> [a]
take' n xs = [xs !! i | i <- [0..n-1]]