Les bases 2
Exporte des fonctions
L'export de fonctions a été vu dans le premier concept, en voici un rapide rappel.
Chaque fichier Elm est un module et doit contenir une instruction module avant tout autre code.
Le nom d'un module doit correspondre à celui de son fichier : le module Calculator doit donc se trouver dans le fichier Calculator.elm, et le module Parser.Utils dans le fichier Parser/Utils.elm.
Tout ce qui est défini dans un module y reste dans une portée privée et n'est pas accessible depuis l'extérieur de ce module, sauf si c'est listé dans exposing.
-- Calculator.elm
-- Define the Calculator module, and expose the `add` function
module Calculator exposing (add)
six = 3 + 3
add number1 number2 = number1 + number2
-- Calculator.elm
-- Define the Calculator module, and expose everything within: `six` and `add`
module Calculator exposing (..)
six = 3 + 3
add number1 number2 = number1 + number2
https://elm-lang.org/docs/syntax#modules
Importe des fonctions depuis d'autres modules
Pour accéder aux fonctions définies dans d'autres modules, on passe par des imports.
Toutes les fonctions de ce module qui ont été exposées par celui-ci deviennent accessibles lorsqu'on importe ce module.
Mais la façon d'y accéder varie selon la manière dont le module est importé.
Les imports qualifiés sont la valeur par défaut, et pour accéder à une fonction d'un tel module (par exemple la fonction map du module List), on fait précéder son nom de celui du module (List.map).
Les imports ouverts donnent un accès direct aux fonctions exposées de ce module, sans préfixe. Ils se font avec le mot-clé exposing, comme un miroir de celui utilisé pour les exports. Tu peux exposer toutes les fonctions disponibles (avec ..), ou seulement certaines (par exemple map).
Tu peux aussi importer des types et leurs constructeurs depuis d'autres modules, mais cela viendra dans un concept ultérieur.
On préfère les imports qualifiés, pour plus de clarté et pour éviter les conflits de noms.
-- qualified imports
import List -- List.map, List.foldl
import List as L -- L.map, L.foldl
-- open imports
import List exposing (..) -- map, foldl, concat, ...
import List exposing ( map, foldl ) -- map, foldl, List.concat
https://elm-lang.org/docs/syntax#modules
Annotations de type
Les annotations de type s'écrivent name : parameter types -> return type, les types des paramètres étant eux aussi séparés par ->.
add : Int -> Int -> Int
add number1 number2 = number1 + number2
On peut utiliser des parenthèses pour définir les paramètres d'une fonction (qui sont eux-mêmes définis avec la même syntaxe, d'où la nécessité des parenthèses).
-- Transform every character in a string
map : (Char -> Char) -> String -> String
map charMapperFunction string =
-- ...
https://elm-lang.org/docs/syntax#type-annotations
Les nombres
Elm propose deux types de nombres, définis par les types Int et Float.
Int correspond à l'ensemble des entiers relatifs.
Float correspond à l'ensemble des nombres réels, limité par la précision de l'ordinateur.
Les opérations définies sur les nombres fonctionnent en général sur l'un ou l'autre type, mais pas en les mélangeant.
Il existe des fonctions pour convertir de l'un à l'autre, comme toFloat, qui convertit un Int en Float, et round, floor, ceiling ou truncate, qui convertissent un Float en Int avec des sémantiques différentes.
https://package.elm-lang.org/packages/elm/core/latest/Basics#Int
Opérations sur les strings
Pour décrire des mots et des phrases dans le code, Elm dispose d'un type String natif.
Les littéraux de string s'écrivent entre guillemets anglais, comme "Hello World!".
Un opérateur de concaténation de strings ++ et un opérateur d'égalité == sont disponibles par défaut.
hello : String -> String
hello subject = "Hello " ++ subject
hello "World!" --> "Hello World!"
La plupart des autres fonctions sur les strings se trouvent dans le module String, qu'il faut importer.
https://package.elm-lang.org/packages/elm/core/latest/String
Exercice d'apprentissage
