> 
> **Possible Duplicate:**  
> 
> [Linked list partition function and reversed results](https://stackoverflow.com/questions/7199122/linked-list-partition-function-and-reversed-results) 
> 
> 
> 

Actually I don't care about the input type or the output type, any of `seq, array, list` will do. (It doesn't have to be generic) Currently my code takes `list` as input and `(list * list)` as output

```
let takeWhile predicator list =
   let rec takeWhileRec newList remain =
       match remain with
       | [] -> (newList |> List.rev, remain)
       | x::xs -> if predicator x then
                     takeWhileRec (x::newList) xs
                  else
                     (newList |> List.rev, remain)
   takeWhileRec [] list

```

However, there is a pitfall. As fas as I see, `List.rev` is O(n^2), which would likely to dominate the overall speed? I think it is even slower than the ugly solution: `Seq.takeWhile`, then `count`, and then take `tail` n times... which is still O(n) 

(If there is a C# List, then i would use that without having to reverse it...)

A side question, what's difference between `Array.ofList` and `List.toArray` , or more generally, `A.ofB` and `B.ofA` in `List, Seq, Array`?

is `seq myList` identical to `List.toSeq myList`?

Another side question, is nested `Seq.append` have same complexity as `Seq.concat`?

e.g. 

```
  Seq.append (Seq.append (Seq.append a b) c) d // looks aweful
  Seq.concat [a;b;c;d]

```