I implemented a function that I chose to call `divideAt`:

```
module List =
    let divideAt predicate list =
        let rec divideAt' acc = function
            | [] -> (List.rev acc, [])
            | h::_ as ls when predicate h -> (List.rev acc, ls)
            | h::t -> divideAt' (h::acc) t
        divideAt' [] list

```

The idea is relatively simple: sometimes you want to, given an element in a list, separate all the elements before it into a left list and all the elements after it into another.

I looked all over List's functions and I couldn't find anything that would allow me to do this in a performant way. Or is there? An equivalent, albeit slower implementation relying entirely in high order functions can be accomplished in this way, for instance:

```
let divideAt predicate list =
    match List.tryFindIndex predicate list with
    | None -> (list, [])
    | Some(index) -> (List.take index list, List.skip index list)

```

Is there something that would allow me to implement this even more succinctly without having to rely on the "low level" recursion algorithm yet without having a performance penalty as I have when using this HOF implementation?

Thanks