Programmation ocaml

J'ai utiliser ~ pour le flèche que j'ai pas sur mo. Clavie

D'accord merci je vais consulte vos lien et essais de comprendre comment vous avez fait .

En fait il n'y a pas besoin de deux fonctions (ça marcherait sûrement mais ce n'est pas le plus simple). Sur le même principe de pattern matching tu peux utiliser la clause

when

qui permet de rajouter une condition sur une valeur.

Exemple :

function [] -> ... | x::seq when x mod 2 = 0 -> ... | x::seq -> ...

On a ainsi nos 3 cas : liste vide, liste avec x pair, liste avec x impair.

Reprenons les bases (que tu retrouveras dans plein de cours sur internet)

OCaml est un langage fortement typé (c'est d'ailleurs le plus typé que je connaisse), par exemple si tu fais x + y il sait que x et y sont des int parce que + ne peut s'utiliser que sur des int, du coup il n'y a pas besoin - contrairement à d'autres langages - que x et y sont des int, OCaml va le deviner tout seul (on appelle ça l'inférence de type).

Le pattern matching (ou "filtrage par motif" en français) permet de décomposer un type de données pour identifier les différents éléments de sa structure. C'est ce qui rend l'utilisation des listes intéressantes puisque OCam va être capable de découper la liste en deux morceaux : l'élément de tête, et le reste de la liste derrière.

L'écriture générale du pattern matching en OCaml c'est

match x with

sauf dans le cas particulier où

x

est le dernier paramètre d'une fonction et le résultat du match est exactement le résultat de la fonction (ce que l'on essaye de faire le plus souvent possible et c'est le cas dans tes exercices).
Dans ce cas on peut remplacer

let f x = match x with

par

let f = function

pour revenir à la programmation fonctionnelle de OCaml.
La suite du code est identique, à savoir une succession de pattern possibles pour la valeur

x

et les différentes opérations à réaliser pour chacun de ces pattern, ce qui s'écrit

| y -> z

avec

y

le pattern et

z

le résultat de ce fonction pour ce pattern.

Je résume, OCaml est capable de déstructurer une variable en différents pattern possibles et associer à chacun d'entre eux un résultat différent.

Remarque : OCaml est également capable de savoir si tous les pattern possibles ont un résultat associé et générera une erreur s'il en manque.

Dans le cas d'une liste (ce qui nous intéresse dans tes exercices) il y a deux patterns possibles : soit la liste est vide et elle vaut donc

[]

, soit elle est décomposable en

a::b

avec deux éléments

a

est la première valeur de la liste et

b

est la liste qui contient tous les autres éléments.

Mais le pattern matching peut aller plus loin en rajoutant des conditions sur ces différents éléments, c'est là qu'intervient le

when

. Ainsi au lieu d'avoir un seul résultat pour chaque pattern possible, on va pouvoir affiner et créer des sous-pattern (qui ne sont plus structurels mais logique) et leur associer des résultats différents, dans ton cas il s'agit de différencier les nombres pairs et les nombres impairs.

let f = function
    | [] -> 0
    | x::y when x mod 2 = 0 -> 2
    | x::y -> 1
;;

Ce code là va renvoyer si la liste est vide, 1 si le premier nombre est impair, 2 si le deuxième nombre est pair.

Remarque : dans ce code on ne se sert pas de

y

, on peut le remplacer par

_

:

let f = function
    | [] -> 0
    | x::_ when x mod 2 = 0 -> 2
    | x::_ -> 1
;;

De plus, dans le dernier cas on ne se sert pas de x non plus donc on pourrait aussi le remplacer par code <caml>_</code> :

let f = function
    | [] -> 0
    | x::_ when x mod 2 = 0 -> 2
    | _::_ -> 1
;;

Et dernière simplification, on peut dire à la fin "prends tous les autres cas possibles" et mettre un _ sur l'ensemble de la clause.

let f = function
    | [] -> 0
    | x::_ when x mod 2 = 0 -> 2
    | _ -> 1
;;

Littéralement on peut traduire ceci par "soit f une fonction qui prend en entrée une liste vide et renvoie 0, ou qui prends en entrée une liste commençant par un nombre x tel que x mod 2=0 et renvoie 2, ou qui renvoie 1 dans les autres cas"

Le

0 +

est inutile et cela créé une surcharge de travail pour le programme (concept de récursion terminale dont on n'a pas parlé précédemment).

Sinon, on pourrait considérer 0 comme étant positif et donc vouloir le compter dans ta fonction, ce qui n'est pas le cas pour l'instant.

À part ça, je ne vois pas de problème (mais je n'ai pas testé).

Tout s'apprend.
Mais on ne peut pas comparer OCaml avec Java/C++ car ce sont des langages qui ne servent pas à la même chose. Jamais tu ne feras un jeu vidéo en OCaml...

En soit c'est rarement le langage en lui même qui est compliqué, c'est les concepts théoriques qu'il y a derrière.

Les langages fonctionnels comme OCaml sont difficiles à appréhender par des développeurs qui connaissent uniquement des langages procéduraux ou objets comme Java/C++

ok j'ai compris mais c'est évident que je cherche de l'aide pas a faire exécuter mon exercice par quelqu'un et pour cela j'ai besoin d'une personne qui maitrise le domaine

D'accord

Bonjour,

Quel rapport avec la programmation OCaml ?

Si tu as une question à ce sujet poses la dans une discussion dédiée, mais ne mélange pas tout...