Re: Pas mieux

Oui, cela doit dépendre des langages qu'on leur enseigne et comment l'on s'y prend. J'aimerai bien voir un esprit non matheux faire du Haskell ! Rien que pour faire des entrées-sorties, il faut déjà passer par la monade IO. Heu ? C'est quoi une monade ? C'est simple, c'est juste un monoïde dans la catégorie des enfodoncteurs ! :-D

Sinon, on fait comment pour traduire naturellement les concepts de bases de l'algèbre en OCaml ? C'est simple :

(*
 un concept mathématique est un type 
 dans les cas des structures, ce sont des modules
*)
 module type Groupe = sig
 type t
 val zero : t
 val add : t -> t -> t
 val neg : t -> t
end
module type Anneau = sig
 include Groupe
 val one : t
 val mul : t -> t -> t
end
(* maintenant on définit le polynôme `x2 + x + 1` *)
let poly (type a) (module R : Anneau with type t = a) x =
 let (+), ( * ) = R.(add, mul) in
 x * x + x + R.one
(* on l'utilise sur différents anneaux *)
poly (module Int) 5;;
- : int = 31
poly (module Float) 5.4;;
- : float = 35.56
(* la notion d'anneau produit *)
module Prod (R : Anneau) (S : Anneau) : Anneau with type t = R.t * S.t = struct
 type t = R.t * S.t
 let zero = (R.zero, S.zero)
 let one = (R.one, S.one)
 let add (x, y) (x', y') = (R.add x x', S.add y y')
 let mul (x, y) (x', y') = (R.mul x x', S.mul y y')
 let neg (x, y) (x', y') = (R.neg x x', S.neg y y')
end
(* utilisation *)
 poly (module Prod (Int) (Float)) (5, 5.4);;
- : int * float = (31, 35.56)

Bon, la syntaxe est un peu lourde pour définir le polynôme, mais bientôt on pourra se contenter de:

let poly (R : Anneau) x = ...

En Haskell, on passerait par des types classes avec une syntaxe plus légère et il ne serait même pas nécessaire de passer explicitement l'anneau en paramètre lors de l'appel de fonction. En Rust, ce serait avec des Traits avec une syntaxe aussi lourde et sans instantiation explicite de l'anneau.

On peut ensuite continuer la hiérarchie des structures algébriques:

module type Corps = sig
 include Anneau
 val div : t -> t -> t
end
module Espace_vectoriel = sig
 module K : Corps
 module V : Groupe
 type vecteur = V.t
 type scalaire = K.t
 val scale : scalaire -> vecteur -> vecteur
end

On fait comment dans les autres langages pour formaliser tout ça ? Le premier qui me propose un idiome de POO (comme en C++ ou Python), je l'envoie au piquet et lui demande de retourner étudier l'algèbre ! :-P

Sapere aude ! Aie le courage de te servir de ton propre entendement. Voilà la devise des Lumières.