EN
PréludeChargé par défaut — aucun import nécessaire.

D'autres fonctions sur les listes

Synopsis 
sum : Additive a => List a -> a

Somme d'une liste (0 pour la liste vide).

elem : Eq a => a -> List a -> Bool

Une valeur est-elle un élément d'une liste ?

any : (a -> Bool) -> List a -> Bool

Au moins un élément satisfait-il le prédicat ?

all : (a -> Bool) -> List a -> Bool

Tous les éléments satisfont-ils le prédicat ?

take : Nat -> List a -> List a

Les n premiers éléments (moins si la liste est plus courte). n : Nat, le même type de compte que length.

drop : Nat -> List a -> List a

Tous les éléments sauf les n premiers.

takeWhile : (a -> Bool) -> List a -> List a

Le plus long préfixe dont tous les éléments satisfont le prédicat.

dropWhile : (a -> Bool) -> List a -> List a

Le reste après suppression du plus long préfixe satisfaisant le prédicat (le pendant de takeWhile).

index : Nat -> List a -> Maybe a

L'élément à la position n (à partir de 0) : index 0 xs est la tête ; Nothing quand n est hors bornes. L'accesseur sûr — il renvoie un Maybe au lieu d'échouer, comme head. (Pour l'indexation conteneur-d'abord, voir Core.Index : xs[i] / xs ! i.)

zip : List a -> List b -> List (a, b)

Associe les éléments de deux listes (en tronquant à la plus courte).

zipWith : (a -> b -> c) -> List a -> List b -> List c

Combine deux listes élément par élément avec une fonction.

range : Int -> Int -> List Int

Une liste d'entiers de lo à hi inclus (vide si lo > hi). [1 .. n] — l'idiome de plage comptée de la boucle for — ne déborde pas la pile pour un grand n.

rangeDown : Int -> Int -> List Int -> List Int
applyTimes : (a -> a) -> Nat -> a -> a

Applique f à x, n fois (f (f … (f x))). Sous-tend le pas par DÉFAUT ci-dessous, de sorte qu'un Enum nu (enumFromTo, succ, stepUp, stepDown) gère les plages à pas d'emblée.

interface Enum a where
enumFromTo : a -> a -> List a
succ : a -> a            -- ^ the next value; lets `for x in [lo..hi]` count without a list
enumDist : a -> a -> Nat            -- ^ PRE lo ≤ hi : count of unit steps from lo up to hi
succBy : a -> Nat -> a              -- ^ advance UP by n unit steps
-- LÀ OÙ LE TYPE S'ARRÊTE (KB-200, 07/10/2026 : une plage sans borne, `[e ..]`
-- DÉFAUTS (Thomas, 07/10/2026 : l'`Enum` d'un TP doit continuer à compiler) disent
-- exactement ce que `succ` seul permet : MONTER va aussi loin que `succ` — une
-- rien n'existe dessous).  À revoir : des bornes en interfaces (minBound,
stepUp : a -> Nat -> Maybe a        -- ^ the value n unit steps UP, if the type has one
stepDown : a -> Nat -> Maybe a      -- ^ the value n unit steps DOWN, if the type has one

Les types dont les valeurs s'énumèrent sur une plage bornée. Sous-tend la notation de plage [lo .. hi], qui se désucre en enumFromTo lo hi.

Instances : Char, Int, Nat
enumFromToExcl : Ord a => Enum a => a -> a -> List a

L'intervalle DEMI-OUVERT [lo, hi[ (ou [lo, hi)) : lo, succ lo, … jusqu'à hi EXCLU (D7). VIDE quand hi <= lo (convention de Dijkstra : la longueur vaut exactement hi - lo, [a .. a[ est vide, [0 .. k[ ++ [k .. n[ == [0 .. n[). L'énumérateur demi-ouvert PRIMITIF — PAS enumFromTo lo (pred hi) : la garde < hi n'a besoin d'aucun pred/soustraction, donc elle reste correcte à hi <= lo et marche pour TOUT Enum (Nat, Char…), pas seulement Int. Pile constante pour les grands intervalles.

rangeStepZeroMessage : String
enumNoStepDownMessage : String
enumFromThenTo : Ord a => Enum a => a -> a -> a -> List a

La plage À PAS [a, b .. c] (D8), INCLUANT c : a, puis chaque valeur un pas plus loin que la précédente, le pas étant b − a MONTRÉ par les deux termes. [1,3..11] = 1 3 5 7 9 11. La DIRECTION se lit sur a vs b (Ord), donc la descente est native — [10,8..0] = 10 8 6 4 2 0, et sur Nat [5,3..1] = 5 3 1 sans pas signé (jamais le piège de sous-débordement monus du d = b − a). Le pas 0 (b == a, une plage sans borne) est REFUSÉ : à la COMPILATION quand les deux premiers termes sont des littéraux, en erreur d'exécution propre sinon. Pile constante.

enumFromThenToExcl : Ord a => Enum a => a -> a -> a -> List a

La plage à pas demi-ouverte [a, b .. c[ (ou [a, b .. c)) (D8) : comme enumFromThenTo mais EXCLUANT c — [1,3..11[ = 1 3 5 7 9. Même règle de direction, même refus du pas 0, même pile constante.

elemBy : (a -> a -> Bool) -> a -> List a -> Bool

Un élément est-il présent, selon un test d'égalité fourni ? (Forme générale de elem, qui utilise ==.)

concatMap : (a -> List b) -> List a -> List b

Applique une fonction à valeurs de liste sur une liste puis concatène les résultats. concatMap f = concat . map f.

insertOrd : Ord a => a -> List a -> List a

Insère dans une liste triée en la gardant triée.

sort : Ord a => List a -> List a

Trie une liste par ordre croissant (tri par insertion).

replicate : Nat -> a -> List a

n copies d'une valeur. n : Nat.

lookup : Eq k => k -> List (k, v) -> Maybe v

Recherche une clé dans une liste d'association.

maximum : Ord a => List a -> Maybe a

Plus grand élément, ou Nothing si vide (totale).

maxFrom : Ord a => a -> List a -> a
minimum : Ord a => List a -> Maybe a

Plus petit élément, ou Nothing si vide (totale).

minFrom : Ord a => a -> List a -> a
mapMaybe : (a -> Maybe b) -> List a -> List b

Applique une fonction partielle à chaque élément, en gardant les succès. mapMaybe f xs = catMaybes (map f xs), mais en une seule passe.

last' : List a -> Maybe a

Le dernier élément d'une liste, ou Nothing si elle est vide (total).

intersperse : a -> List a -> List a

Insère sep entre les éléments consécutifs d'une liste (ni en tête ni en fin). intersperse 0 [1, 2, 3] = [1, 0, 2, 0, 3]

intercalate : Monoid m => m -> List m -> m

Joint des valeurs monoïdes en insérant sep entre les éléments consécutifs (pas de séparateur final). intercalate sep = concat . intersperse sep. Généralise le Data.List.intercalate de Haskell à n'importe quel Monoid, donc sert aussi bien les chaînes que les listes de listes : intercalate ", " ["a", "b", "c"] = "a, b, c" intercalate [0] [[1], [2], [3]] = [1, 0, 2, 0, 3]

joinBy : String -> List String -> String

Joint une liste de chaînes avec sep entre elles (pas de séparateur final) — la face « chaîne » d'intercalate, nommée comme en Idris 2 (Data.String.joinBy) : joinBy "\n" ["a", "b"] = "a\nb"

lowercase : String -> String

Met chaque caractère d'une chaîne en minuscule.

trim : String -> String

Retire les espaces ASCII en début et en fin de chaîne.

Recherche, découpage, regroupement, balayage (incontournables de Data.List)

find : (a -> Bool) -> List a -> Maybe a

Le premier élément satisfaisant le prédicat, ou Nothing.

findIndex : (a -> Bool) -> List a -> Maybe Nat

L'indice (à partir de 0) du premier élément satisfaisant le prédicat.

elemIndex : Eq a => a -> List a -> Maybe Nat

L'indice (à partir de 0) de la première occurrence d'une valeur.

partition : (a -> Bool) -> List a -> (List a, List a)

Scinde en (éléments satisfaisant p, le reste), en préservant l'ordre.

span : (a -> Bool) -> List a -> (List a, List a)

(le plus long préfixe satisfaisant tous p, le reste) : span p = (takeWhile p, dropWhile p).

break : (a -> Bool) -> List a -> (List a, List a)

break p = span (not . p) : le préfixe jusqu'au premier élément satisfaisant p.

sortBy : (a -> a -> Ordering) -> List a -> List a

Trie selon un comparateur fourni (tri par insertion stable). Forme générale de sort, qui utilise compare.

sortOn : Ord b => (a -> b) -> List a -> List a

Trie selon une projection sur une clé (décorer–trier–dédécorer) : chaque élément est apparié avec sa clé, les paires sont triées par clé, puis les clés sont abandonnées — de sorte que la fonction de clé est exécutée une fois par élément, et non à chaque comparaison. Le pendant par projection de sortBy (à la sortOn de Haskell/Idris, à la sort_by_key de Rust).

nubBy : (a -> a -> Bool) -> List a -> List a

Retire les doublons selon une égalité fournie, en gardant la première occurrence.

nub : Eq a => List a -> List a

Retire les doublons (par ==), en gardant la première occurrence.

groupBy : (a -> a -> Bool) -> List a -> List (List a)

Regroupe les éléments consécutifs jugés égaux par le prédicat.

group : Eq a => List a -> List (List a)

Regroupe les éléments consécutifs égaux (par ==) : group [1,1,2,3,3] = [[1,1],[2],[3,3]].

scanl : (b -> a -> b) -> b -> List a -> List b

Balayage à gauche : l'accumulateur courant après chaque étape, initialisé avec z. scanl (+) 0 [1,2,3] = [0,1,3,6] (toujours plus long d'un que l'entrée).

scanr : (a -> b -> b) -> b -> List a -> List b

Balayage à droite : scanr (+) 0 [1,2,3] = [6,5,3,0] (toujours non vide).

zipWith3 : (a -> b -> c -> d) -> List a -> List b -> List c -> List d

Combine trois listes avec une fonction (en tronquant à la plus courte).

unfoldr : (b -> Maybe (a, b)) -> b -> List a

Construit une liste à partir d'une graine : f renvoie Just (element, next seed) pour émettre, ou Nothing pour s'arrêter.

foldl1 : (a -> a -> a) -> List a -> Maybe a

Pli à gauche sur une liste NON vide, initialisé avec son premier élément ; Nothing pour la liste vide (totale).

foldr1 : (a -> a -> a) -> List a -> Maybe a

Pli à droite sur une liste NON vide ; Nothing pour la liste vide (totale).

init' : List a -> Maybe (List a)

Tous les éléments sauf le dernier, ou Nothing si elle est vide (pendant total de last').

tails : List a -> List (List a)

Tous les suffixes d'une liste, le plus long d'abord : tails [1,2] = [[1,2],[2],[]].

isPrefixOf : Eq a => List a -> List a -> Bool

La première liste est-elle un préfixe de la seconde ?

isSuffixOf : Eq a => List a -> List a -> Bool

La première liste est-elle un suffixe de la seconde ?

isInfixOf : Eq a => List a -> List a -> Bool

La première liste est-elle une sous-séquence contiguë de la seconde ?

Découpage de chaînes (mots / lignes / découpe sur un délimiteur)

isSpaceChar : Char -> Bool
words : String -> List String

Découpe une chaîne en mots sur les suites d'espaces (pas de mots vides). words " a b " = ["a", "b"].

lines : String -> List String

Découpe une chaîne aux retours à la ligne. Un retour à la ligne final n'ajoute pas de ligne vide : lines "a\nb" = ["a", "b"], lines "a\n" = ["a"], lines "a\n\nb" = ["a", "", "b"].

splitOnChar : Char -> String -> List String

Découpe une chaîne à chaque occurrence d'un caractère délimiteur, en gardant les morceaux vides : splitOnChar ',' "a,,b" = ["a", "", "b"], splitOnChar ',' "" = [""].

Utilitaires Maybe / Either

maybeToList : Maybe a -> List a

Un Just devient une liste à un élément, un Nothing la liste vide.

fromLeft : a -> Either a b -> a

La valeur Left, ou une valeur par défaut pour un Right.

fromRight : b -> Either a b -> b

La valeur Right, ou une valeur par défaut pour un Left.

partitionEithers : List (Either a b) -> (List a, List b)

Scinde une liste d'Either en (les Left, les Right), en préservant l'ordre.