Opérations sur les tableaux

Instructions

Implémente les opérations de base sur les listes.

Dans les langages fonctionnels, les opérations sur les listes telles que length, map et reduce sont très courantes. Implémente une série d'opérations de base sur les listes, sans utiliser les fonctions existantes.

Le nombre et les noms exacts des opérations à implémenter dépendent du parcours, afin d'éviter les conflits avec des noms existants, mais les opérations générales que tu implémenteras incluent :

• append (étant donné deux listes, ajouter tous les éléments de la seconde liste à la fin de la première) ;
• concatenate (étant donné une série de listes, combiner tous les éléments de toutes les listes en une seule liste aplatie) ;
• filter (étant donné un prédicat et une liste, renvoyer la liste de tous les éléments pour lesquels predicate(item) est vrai) ;
• length (étant donné une liste, renvoyer le nombre total d'éléments qu'elle contient) ;
• map (étant donné une fonction et une liste, renvoyer la liste des résultats de l'application de function(item) à tous les éléments) ;
• foldl (étant donné une fonction, une liste et un accumulateur initial, replier (réduire) chaque élément dans l'accumulateur en partant de la gauche) ;
• foldr (étant donné une fonction, une liste et un accumulateur initial, replier (réduire) chaque élément dans l'accumulateur en partant de la droite) ;
• reverse (étant donné une liste, renvoyer une liste contenant tous les éléments d'origine, mais dans l'ordre inverse).

Remarque : l'ordre dans lequel les arguments sont passés aux fonctions de repli (foldl, foldr) est important.

Attends, c'est impossible !

Implémenter ces opérations sur les tableaux sans utiliser aucune fonction intégrée est pratiquement impossible en Roc, car il te faut un moyen d'ajouter des éléments à la fin ou au début d'un tableau. Dans d'autres langages, tu utiliserais peut-être des opérateurs comme : en Haskell ou += en Python, mais en Roc, tu dois passer par les fonctions de List.

Donc pour cet exercice, tu as le droit d'utiliser List.append (mais évite d'utiliser une autre fonction intégrée).

De nombreux langages de programmation fonctionnelle utilisent les listes chaînées comme type de collection principal. Il est efficace d'ajouter un élément au début ou de retirer le premier élément d'une liste chaînée, c'est pourquoi dans ces langages, tu implémenterais les opérations sur les tableaux à l'aide de List.prepend. En Roc, en revanche, un List est un tableau (un bloc contigu d'octets). Les tableaux ont des propriétés différentes de celles des listes chaînées, comme la capacité d'accéder efficacement aux éléments par leur indice et d'ajouter de nouveaux éléments à la fin. C'est pourquoi, en Roc, on utilise souvent List.append et rarement List.prepend.

Nommage

Roc utilise des noms légèrement différents de ceux indiqués dans les instructions générales :

• concat au lieu de append
• join au lieu de concatenate
• len au lieu de length
• fold au lieu de foldl
• fold_rev au lieu de foldr

Cependant, les noms de fonctions suivants sont standards en Roc :

• filter
• map
• reverse

Indice

Essaie d'utiliser :

match list {
    [] => ...
    [first, .. as rest] => ...
}

ou

match list {
    [] => ...
    [.. as rest, last] => ...
}