Just brainstorming here: what do you think about extracting out findFirst into findFirstIndex and reusing that here? Pseudocode being:

commonPrefixLength list1 list2 =
    let pairs = zipLists list1 list2
    let firstDiffIndex = findFirstIndex ({ fst, snd }: fst != snd) pairs
    if firstDiffIndex was found then
        firstDiffIndex
    else
        length pairs

Not sure about the performance of this or if firstFindIndex is the best generalization of the foldl' idea you have.

Thinking about this a little more, the following can also be a route if commonPrefixLength is otherwise not too useful by itself (which I am unsure about but think it might be only useful as a helper function for commonPrefix):

We use your algorithm and create the more general:

findFirstWithIndex = predicate: list:
    return first { index, value } matching predicate

and then use that to define:

takeWhile = predicate: list:
    let sentinel = findFirstWithIndex (elem: !(predicate elem)) list in
    if sentinel != null then
        take sentinel.index list
    else
        list

and finally:

commonPrefix = list1: list2:
    takeWhile (predicate comparing list1[i] with list2[i])

where forming that last predicate depends on some design decisions (like does predicate accept the index, do we use zipLists, do we first get the shorter list and take over it explicitly).

findFirstWithIndex

This seems like a useful function to factor out.
To simplify it a bit, you could return just the index. That way you don't have to allocate the { index, value } attrset just to ignore value. You could call it findFirstIndex then.

@tjni Nice idea! This turned out to work out really well since I was able to reuse a lot of code. I removed commonPrefixLength again, it's not really necessary to expose that, it's really just a helper function as you suggested. Instead findFirstIndex is now available :)