Misc.Stdlib.List(3)

🎀 NAME 🎀

Misc.Stdlib.List — Extensions to the List module ✨ and yes bestie, this is the Misc.Stdlib.List(3) page from the OCaml library — we're literally about to go through every single extension, no skipping, no cap 💅

🌸 Module 🌸

• Module — Misc.Stdlib.List 💜

✨ Documentation ✨

Module List — : sig end 🫶

💖 Extensions to the List module 💖

Okay so here's the whole squad of extensions to List. Every type and every val is right here, with all the details intact, because we do not leave the group chat on read 😭💖

• type 'a t = 'a list — the type is literally 'a list, cute and simple 🎀
• val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int — this is the lexicographic order supported by the provided order. There is no constraint on the relative lengths of the lists. Slay 🦋
• val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool — Returns true if and only if the given lists have the same length and content with respect to the given equality function. periodt 💖
• val some_if_all_elements_are_some : 'a option t -> 'a t option — If all elements of the given list are Some _ then Some xs is returned with the xs being the contents of those Some s, with order preserved. Otherwise return None. 🌈
• val map2_prefix : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t * 'b t — here's the exact example vibe:

let r1, r2 = map2_prefix f l1 l2

If l1 is of length n and l2 = h2 @ t2 with h2 of length n, r1 is List.map2 f l1 h1 and r2 is t2. Yes, that's what the page says, bestie 🫶🔥

• val iteri2 : (int -> 'a -> 'b -> unit) -> 'a list -> 'b list -> unit — Same as List.iter2, but the function is applied to the index of the element as first argument (counting from 0). iconic 💅
• val split_at : int -> 'a t -> 'a t * 'a t — split_at n l returns the pair before, after where before is the n first elements of l and after the remaining ones. If l has less than n elements, raises Invalid_argument. 😭
• val chunks_of : int -> 'a t -> 'a t t — chunks_of n t returns a list of nonempty lists whose concatenation is equal to the original list. Every list has n elements, except for possibly the last list, which may have fewer. chunks_of raises if n <= 0. 🍓
• val is_prefix : equal:('a -> 'a -> bool) -> 'a list -> of_:'a list -> bool — Returns true if and only if the given list, with respect to the given equality function on list members, is a prefix of the list of_. ✨

Then there's this private record type — yes, it's private, so it's giving "look but don't touch" energy 👑:

type 'a longest_common_prefix_result = private {
 longest_common_prefix : 'a list ;
 first_without_longest_common_prefix : 'a list ;
 second_without_longest_common_prefix : 'a list ;
 }

• val find_and_chop_longest_common_prefix : equal:('a -> 'a -> bool) -> first:'a list -> second:'a list -> 'a longest_common_prefix_result — Returns the longest list that, with respect to the provided equality function, is a prefix of both of the given lists. The input lists, each with such longest common prefix removed, are also returned. 💖

---

That's the whole page, bestie. Brought to you by OCamldoc, dated 2026-06-22, and filed under Misc.Stdlib.List(3). slay, bye 💅✨