Does F# have an equivalent to Haskell's take?

Question

In Haskell, there is a function \"take n list\" which returns the first n elements from a list. For example \"sum (take 3 xs)\" sums up the first three elements in the list

Answer 1

To clarify a few things, the difference between Seq.take and Seq.truncate (as pointed out by @sepp2k) is that the second one will give you a sequence that returns at most the number of elements you specified (but if the length of the sequence is less, it will give you less elements).

The sequence generated Seq.take function will throw an exception if you try to access an element beyond the length of the original list (Note that the Seq.take function doesn't throw the exception immediately, because the result is lazily generated sequence).

Also, you don't need to convert the list to a sequence explicitly. Under the cover, list<'a> is a .NET class that inherits from the seq<'a> type, which is an interface. The type seq<'a>is actually just a type alias for IEnumerable<'a>, so it is implemented by all other collections (including arrays, mutable lists, etc.). The following code will work fine:

let list = [ 1 .. 10 ]
let res = list |> Seq.take 5

However, if you want to get a result of type list you'll need to convert sequence back to a list (because a list is more specific type than a sequence):

let resList = res |> List.ofSeq

I'm not sure why F# libraries don't provide List.take or List.truncate. I guess the goal was to avoid reimplementing the whole set of functions for all types of collections, so those where the implementation for sequences is good enough when working with a more specific collection type are available only in the Seq module (but that's only my guess...)