# AP1 · 1 — Des expressions, des noms et des résultats

## Où allons-nous ?

À la fin de la séance, nous saurons lire `"1 2 3 * +"` et obtenir 7.
Cette écriture peut paraître curieuse : l'opération vient après ses deux
arguments. Elle nous permettra de construire une calculatrice complète
avec quelques fonctions, en cinq carnets, puis de comprendre ce qui
manque pour lire `"1.0 + 2.0 * 3.0"` en AP2.

Vous avez déjà programmé avec Python, NumPy et pandas. Nous réutilisons
cette expérience ; les valeurs immuables, les motifs et la récursion
demanderont en revanche de nouvelles habitudes. Les explications sont
placées au moment où une nouvelle forme devient utile : vous n'avez pas
à mémoriser un catalogue avant de commencer.

Dans Livebook, une cellule de code affiche la valeur de sa dernière
expression. `#` commence un commentaire. Une cellule de texte conserve
une prédiction ou une explication. Après avoir changé une définition,
réévaluez-la, puis ses cellules de vérification.

## Notre question

Qu'est-ce qu'une cellule renvoie, et qu'est-ce qu'elle affiche ? Nous
distinguons la valeur d'une expression, le nom qu'on lui donne et le
résultat étiqueté que nous saurons bientôt construire.

> **Repères.** Poly, chap. 1 « Décoller » ; keynote AP1. Le cours se fait ici, dans le carnet.

> 💡 Durée indicative : 20 min, reprise collective comprise. Ce carnet
> est autonome : aucune cellule d'un autre carnet n'est nécessaire. Je le
> projette au tableau ; écrivez une prédiction avant d'exécuter, puis
> expliquez un résultat qui vous a surpris. **Sauvegardez-le dès maintenant
> sous `AP1/ap1-01-expressions.livemd`.**

Les cellules `assert` sont des vérifications fournies : si une condition
est fausse, Livebook montre le résultat obtenu et celui attendu.
Évaluez cet import une fois, puis réévaluez votre code avant ses tests
après chaque modification.

```elixir
import ExUnit.Assertions
```

## Prévoir ce qu'une cellule renvoie

Nous connaissons les nombres, les chaînes et les booléens. En Elixir,
`/` produit un flottant ; `div/2` et `rem/2` calculent le quotient et le
reste entiers. Le suffixe `/2` indique deux arguments, ce n'est pas une
division dans le nom de la fonction.

Les accolades construisent un *tuple*, c'est-à-dire quelques valeurs
regroupées. Prévoyez les quatre éléments du tuple ci-dessous.

```elixir
{2 + 3 * 4, 7 / 2, div(7, 2), rem(7, 2)}
```

Tout bloc produit une valeur : même `if` peut fournir le résultat d'un
calcul. Sa forme sur une ligne s'écrit `if condition, do: valeur, else:
autre_valeur`. Il n'y a pas de `return` à ajouter en fin de bloc.
Prévoyez maintenant `message`, puis changez la quantité.

```elixir
quantity = 3
message = if quantity > 0, do: "commande reçue", else: "panier vide"
message
```

Un nom peut être réassocié à une nouvelle valeur, mais nous ne modifions
pas la valeur précédente. C'est l'*immuabilité*. Quel prix retrouve-t-on
dans `previous_price` ? Écrivez votre réponse avant l'exécution.

```elixir
unit_price = 7
previous_price = unit_price
unit_price = 5
{unit_price, previous_price, 3 * unit_price}
```

## E1 — Fabriquer un résultat

Un *atome*, par ex. `:ok` ou `:error`, est une constante nommée. Nous
l'utiliserons pour étiqueter un résultat. `:ok` et la chaîne `"ok"` sont
deux valeurs différentes. Le tuple `{:ok, 21}` contient l'étiquette de
réussite et le nombre 21 ; les accolades ne créent pas un dictionnaire.

Trois billets coûtent 7 euros chacun. Complétez `total` puis `ticket`.
Ici, `nil` signale une réponse à écrire ; il représente normalement
l'absence de valeur, comme `None` en Python.

```elixir
unit_price = 7
quantity = 3
total = nil
ticket = nil
ticket
```

```elixir
assert total == 21
assert ticket == {:ok, 21}
assert :ok != "ok"
```

Ajoutez un autre exemple dont vous avez calculé le résultat à la main,
par ex. une quantité nulle. Notre prochain souci est de réutiliser le
calcul sans recopier ses lignes : c'est l'objet du carnet suivant.

## Garder une trace

Dans une cellule de texte, notez une prédiction que vous avez dû corriger
et ce qui vous a trompé. Ces quelques lignes font partie du travail de
séance, au même titre que le code.

Enregistrez ce carnet sous `AP1/ap1-01-expressions.livemd` dans votre dépôt privé
`ap-homework`, puis ouvrez `ap1-02-fonctions-motifs.livemd` depuis la page AP1 quand nous
y passons ensemble. Chaque carnet repart d'une session neuve : vos modules
précédents ne sont pas chargés, et ce n'est pas nécessaire.

Un bout de syntaxe oublié ? Les chapitres 1 à 4 du [poly](https://ap-2026.noce.fr/poly/poly-elixir.pdf)
reprennent les formes du langage, chacune avec un exemple et son résultat ;
le cours, lui, se fait dans les carnets.

Pour toute question, vous pouvez me contacter par email :
[aurelien.noce@minesparis.psl.eu](mailto:aurelien.noce@minesparis.psl.eu).