---
title: Cours de programmation séquentielle
subtitle: Fonctions
author: Orestis Malaspinas
<!-- date: 25 avril 2018 -->
sansfont: Sans Serif
<!-- header-includes:
	<link rel="stylesheet" href="reveal.js/lib/css/zenburn.css" >
  	<link rel="stylesheet" href="reveal.js/css/theme/simple.css" id="theme">
  	<link rel="stylesheet" href="css/console.css" id="theme">
  	<script src="jquery/dist/jquery.min.js"></script> -->
    <!-- <script src="reveal.js/lib/js/classList.js"></script> -->
    <!-- <script src="reveal.js/plugin/zoom-js/zoom.js"></script> -->
    <!-- <script src="reveal.js/plugin/highlight/highlight.js"></script> -->
    <!-- <script src="js/remote-diagrams.js"></script> -->
    <!-- <script src="reveal.js/plugin/notes/notes.js"></script> -->
<!-- include-after:
	<script src="js/playRust.js"></script>
	<script src="js/remote-code.js"></script>
	<script src="js/remote-diagrams.js"></script>
	<script src="js/em-artiste.js"></script> -->
<!-- slide-numbers: true -->
---

# Instructions et expressions

## Les instructions (statements)

- Une **instruction** est une commande effectuant une action mais ne retournant aucune valeur.
- Exemple:

    ```{.lang-rust}
    let x = 1; // une instruction
    ```
- On ne peut pas assigner une instruction `let`{.rust}

<pre><code data-trim="hljs rust" class="lang-rust">
    fn main() {
        let y = (let x = 1);
    }
</code></pre>

## Les expressions

- Une **expression** est une combinaison de variables, d'opérations, ... retournant une valeur.
- Exemple: 
    
    ```{.lang-rust}
    3 + 5
    ```

- La plupart du code rust est une expression.
- N'importe quel **bloc** peut effectuer des opérations et retourner une valeur.

<pre><code data-trim="hljs rust" class="lang-rust">
fn main() {
    let y = {
        let x = 5 + 3;
        x - 9
    };
    println!("5 + 3 - 9 = {}", y);
}
</code></pre>

- **Important:** Une expression sans `;` dans un bloc retourne la valeur evaluée de l'expression.

# Fonctions

## Généralités

- Les fonctions s'écrivent en *snake_case* (le compilateur vous avertiras...).
- La définition d'une fonction commence par un `fn`{.rust}.
- La définition des fonctions peut se faire avant ou après l'endroit où elle est appelée.
- Une fonction contient des instructions et se termine parfois avec une expression.

<pre><code data-trim="hljs rust" class="lang-rust">
fn main() {
    println!("La fonction main est une fonction.");

    fonction_fonction();
}

fn fonction_fonction() {
    println!("La fonction fonction_fonction est une fonction.");
}
</code></pre>

## Paramètres de fonctions

- Une fonction peut prendre des arguments séparés par des "`,`{.rust}".
- Le type des arguments doit toujours être explicitement déclaré.

    <pre><code data-trim="hljs rust" class="lang-rust">
    fn main() {
        affiche_entier(1024);
}

  fn affiche_entier(x: i32) {
        println!("Affiche l'entier {}.", x);
}
    </code></pre>

## Valeur de retour de fonctions

- On déclare le type de retour d'une fonction avec `-> Type`{.rust}.

    <pre><code data-trim="hljs rust" class="lang-rust">
    fn main() {
        println!("La réponse est {}.", la_reponse());
}

  fn la_reponse() -> i32 {
      42
}
</code></pre>

- **Important:** La valeur de retour d'une fonction n'est pas suivie d'un "`;`{.rust}".
- Les instructions ne retournent pas de valeur et sont représentées par le type `()`{.rust} (le type vide). D'où

    <pre><code data-trim="hljs rust" class="lang-rust">
    fn main() {
        println!("La réponse est {}.", la_reponse());
}

  fn la_reponse() -> i32 {
      42;
}
</code></pre>