Just naively using `Seq.length` may be not good enough as will blow up on infinite sequences.

Getting more fancy with using something like `ss |> Seq.truncate n |> Seq.length` will work, but behind the scene would involve double traversing of the argument sequence chunk by IEnumerator's `MoveNext()`.

The best approach I was able to come up with so far is:

```
let hasAtLeast n (ss: seq<_>) =
    let mutable result = true
    use e = ss.GetEnumerator()
    for _ in 1 .. n do result <- e.MoveNext()
    result

```

This involves only single sequence traverse (more accurately, performing `e.MoveNext()` `n` times) and correctly handles boundary cases of empty and infinite sequences. I can further throw in few small improvements like explicit processing of specific cases for lists, arrays, and `ICollection`s, or some cutting on traverse length, but wonder if any more effective approach to the problem exists that I may be missing?

Thank you for your help.

**EDIT**: Having on hand 5 overall implementation variants of `hasAtLeast` function (2 my own, 2 suggested by **Daniel** and one suggested by **Ankur**) I've arranged a marathon between these. Results that are tie for all implementations prove that **Guvante** is right: a simplest composition of existing algorithms would be the best, there is no point here in overengineering.

Further throwing in the readability factor I'd use either my own pure F#-based

```
let hasAtLeast n (ss: seq<_>) =
    Seq.length (Seq.truncate n ss) >= n

```

or suggested by **Ankur** the fully equivalent Linq-based one that capitalizes on .NET integration

```
let hasAtLeast n (ss: seq<_>) =
    ss.Take(n).Count() >= n

```