OpenLLM-France/wikimedia huggingface dataset:
# Pour lire Platon/Bibliographie

* Platon et les mythes
* Conseils pour la lecture
* Introduction par les mythes
* Faut-il contrôler l'art ?
* Vocabulaire
** Beau
* Études de quelques passages des dialogues
* Guide des dialogues
** Introduction
** Charmide
** Ion
** Ménon
** Parménide
* Bibliographie
* Platon et les mythes
* Conseils pour la lecture
* Introduction par les mythes
* Faut-il contrôler l'art ?
* Vocabulaire
** Beau
* Études de quelques passages des dialogues
* Guide des dialogues
** Introduction
** Charmide
** Ion
** Ménon
** Parménide
* Bibliographie
[ Modifier le sommaire ]
* BibliographieCette bibliographie est une bibliographie commentée : les commentaires ont pour but de permettre au lecteur de se faire un avis sur les livres qu'il peut lire sur Platon en fonction de ses besoins. Si les commentaires comportent inévitablement une part de subjectivité, nous aurons toujours à l'esprit qu'il s'agit de dire ce qu'apporte un livre pour la lecture de notre auteur. On ne vise pas à fournir une bibliographie très fournie qui serait inutile et décourageante pour un lecteur débutant.
Commencer par un ouvrage qui regroupe les textes de Platon à l'aide d'un fil conducteur peut donner à comprendre que chaque philosophe traite avant tout d'un problème dont il hérite ou qu'il met en place;
* Brisson, Luc et Francesco Fronterotta, sous la direction de, Lire Platon, Quadrige, Presses Universitaires de France, Paris, 2006
    Ce livre couvre de nombreux domaines, des influences sur Platon à sa philosophie politique. Les articles sont clairs et directs. Cette diversité de sujets est très utile pour acquérir une bonne représentation générale de la pensée platonicienne. De ce point de vue, c'est une introduction idéale.
* Brisson, Luc et Pradeau, Jean-François, Le Vocabulaire de Platon, Ellipses, 1998
    Un ouvrage qui permet d'apprendre la pensée de Platon de manière synthétique. Une méthode pour l'utiliser est de lire les notions relatives à un même thème (morale, cosmologie, par exemple). On peut toutefois regretter que les articles ne paraissent pas toujours très bien structurés.
* Goldschmidt, V., Les Dialogues de Platon, PUF, 1935, Paris
* Pradeau, Jean-François (coordonné par), Platon : les formes intelligibles, PUF, Paris, 2001
    Un recueil d'articles sur la théorie des formes. Certains articles sont très spécialisés et arides, mais toujours clairs et instructifs. Incontournable pour approfondir la théorie fondamentale du platonisme.
* Richard H. Kraut (ed.), The Cambridge Companion to Plato, New York Cambridge (Univ. Press), 1992
* Robin, Léon, Platon, PUF, 1935 (rééd. 1997)
# Pour lire Platon/Guide des dialogues

* Platon et les mythes
* Conseils pour la lecture
* Introduction par les mythes
* Faut-il contrôler l'art ?
* Vocabulaire
** Beau
* Études de quelques passages des dialogues
* Guide des dialogues
** Introduction
** Charmide
** Ion
** Ménon
** Parménide
* Bibliographie
* Platon et les mythes
* Conseils pour la lecture
* Introduction par les mythes
* Faut-il contrôler l'art ?
* Vocabulaire
** Beau
* Études de quelques passages des dialogues
* Guide des dialogues
** Introduction
** Charmide
** Ion
** Ménon
** Parménide
* Bibliographie
[ Modifier le sommaire ]
| Guide des dialogues platoniciens | Introduction |
| Premier Alcibiade Second Alcibiade Hippias majeur Hippias mineur Ion Lachès Charmide Lysis | Protagoras Euthyphron Gorgias Ménon Apologie de Socrate Criton Euthydème | Ménexène Cratyle Phédon Le Banquet La République Phèdre Théétète | Parménide Le Sophiste Le Politique Philèbe Timée Critias Les Lois Lettre 7 |
# Pour lire Platon/Guide des dialogues/Charmide

| Guide des dialogues platoniciens | Charmide |
| | << lire le texte >> |
* Platon et les mythes
* Conseils pour la lecture
* Introduction par les mythes
* Faut-il contrôler l'art ?
* Vocabulaire
** Beau
* Études de quelques passages des dialogues
* Guide des dialogues
** Introduction
** Charmide
** Ion
** Ménon
** Parménide
* Bibliographie
* Platon et les mythes
* Conseils pour la lecture
* Introduction par les mythes
* Faut-il contrôler l'art ?
* Vocabulaire
** Beau
* Études de quelques passages des dialogues
* Guide des dialogues
** Introduction
** Charmide
** Ion
** Ménon
** Parménide
* Bibliographie
[ Modifier le sommaire ]
Ce dialogue met en scène Charmide, Critias, Khairéphon et Socrate. Ce dernier examine les définitions de la sagesse proposées par Charmide puis par Critias.
* Le calme et la modération ;
* La pudeur ;
* faire ses propres affaires.
* faire le bien ;
* la connaissance de soi-même ;
* la science d'elle-même et des autres sciences.
Le dialogue échoue à définir la sagesse.
Examinons la réfutation de la première définition de Charmide : la sagesse consiste à agir avec calme et modération. Socrate objecte que la sagesse est d'apprendre vite, de lire ou d'écrire à une vitesse convenable ; donc la lenteur n'est pas la sagesse. On a reproché à Socrate de remplacer le calme par la lenteur, ce qui ferait de cette réfutation un piètre procédé de sophiste. Une autre explication est possible, qui explique aussi pourquoi les définitions de Critias, si proches de celles de Socrate, sont rejetées par ce dernier : Charmide ne comprend pas, lorsqu'il parle de modération, que ce qu'il nomme modération doit être rapporté à la partie de l'âme qui juge de ce qui est avantageux et de ce qui est nuisible. Il n'a donc qu'une opinion droite de ce qu'est la modération, mais il n'en a pas une connaissance vraie. Ce que Socrate cherche à lui suggérer, c'est que la modération, pour être réellement sage, doit reposer sur une connaissance de ce qu'il convient de faire et de ne pas faire, connaissance relative au bien de l'âme et qui fonde donc la vertu. Le même reproche peut être fait à Critias.
On peut donc affirmer que la réfutation de Socrate n'est en rien sophistique et que la grande absente de cette conversation, c'est l'âme, alors même qu'elle constitue l'essentiel du propos de Socrate dans le prologue.
# Programmation C-C++/Compilation séparée en C/C++

Cours de C/C++ :
| Modularité et compilation ||
| | Pourquoi faire une programmation modulaire ? |
| | Les différentes phases du processus de génération des exécutables |
| | Compilation séparée en C/C++ |
| | Syntaxe des outils de compilation |
| | Problèmes syntaxiques relatifs à la compilation séparée |
| Livre original de C. Casteyde ||
La compilation séparée en C/C++ se fait au niveau du fichier. Il existe trois grands types de fichiers sources en C/C++ :
* les fichiers d'en-tête, qui contiennent toutes les déclarations communes à plusieurs fichiers sources. Ce sont les fichiers d'en-têtes qui, en séparant la déclaration de la définition des symboles du programme, permettent de découper l'ensemble des sources en fichiers compilables séparément ;
* les fichiers C, qui contiennent les définitions des symboles en langage C ;
* les fichiers C++, qui contiennent les définitions des symboles en langage C++.
On utilise une extension différente pour les fichiers C et les fichiers C++ afin de les différencier. Les conventions utilisées dépendent du compilateur. Cependant, on peut en général établir les règles suivantes :
* les fichiers C ont l'extension .c ;
* les fichiers C++ prennent l'extension .cc, ou .C (majuscule) sur UNIX, ou .cpp sur les PC sous DOS ou Windows (ces deux systèmes ne faisant pas la différence entre les majuscules et les minuscules dans leurs systèmes de fichiers) ;
* les fichiers d'en-tête ont l'extension .h, parfois .hpp (en-tête C++).
Les programmes modulaires C/C++ auront donc typiquement la structure suivante :
# Programmation C-C++/Exemple de programme

Ce livre est en cours de copie depuis le site http://casteyde.christian.free.fr/cpp/cours/online/book1.html qui le fournit sous licence GFDL.
Cours de C/C++ :
| Première approche ||
| | Les commentaires |
| | Les types prédéfinis |
| | Notation des valeurs |
| | La définition des variables |
| | Instructions et opérations |
| | Les fonctions |
| | La fonction main |
| | Entrée / sortie de base |
| | Exemple de programme |
| Livre original de C. Casteyde ||

## Exemple de programme complet

Le programme suivant est donné à titre d'exemple. Il calcule la moyenne de deux nombres entrés au clavier et l'affiche :

### Exemple - Programme complet simple

Programme en C :
Dans cet exemple, les chaînes de format spécifient des flottants (f) en quadruple précision (L).
# Programmation C-C++/DANGER

Ce livre est en cours de copie depuis le site http://casteyde.christian.free.fr/online/cours_cpp/ qui le fournit sous licence GFDL.
Cours de C/C++ :
| Pointeurs et références ||
| | Notion d'adresse |
| | Notion de pointeur |
| | Référencement, indirection |
| | Notion de référence |
| | Lien entre les pointeurs et les références |
| | Passage de paramètres par variable ou par valeur |
| | Références et pointeurs constants et volatiles |
| | Arithmétique des pointeurs |
| | Utilisation des pointeurs avec les tableaux |
| | Les chaînes de caractères : pointeurs et tableaux à la fois ! |
| | Allocation dynamique de mémoire |
| | Pointeurs et références de fonctions |
| | Paramètres de la fonction main - ligne de commande |
| | DANGER |
| Livre original de C. Casteyde ||
Les pointeurs sont, comme on l'a vu, très utilisés en C/C++. Il faut donc bien savoir les manipuler.
Mais ils sont très dangereux, car ils permettent d'accéder à n'importe quelle zone mémoire, s'ils ne sont pas correctement initialisés. Dans ce cas, ils pointent n'importe où. Accéder à la mémoire avec un pointeur non initialisé peut altérer soit les données du programme, soit le code du programme lui-même, soit le code d'un autre programme ou celui du système d'exploitation. Cela conduit dans la majorité des cas au plantage du programme, et parfois au plantage de l'ordinateur si le système ne dispose pas de mécanismes de protection efficaces.
Pour initialiser un pointeur qui ne pointe sur rien (c'est le cas lorsque la variable pointée n'est pas encore créée ou lorsqu'elle est inconnue lors de la déclaration du pointeur), on utilisera le pointeur prédéfini NULL.
La fonction malloc renvoie le pointeur NULL lorsqu'il n'y a plus ou pas assez de mémoire. Le comportement des opérateurs new et new est différent. Théoriquement, ils doivent lancer une exception si la demande d'allocation mémoire n'a pas pu être satisfaite. Cependant, certains compilateurs font en sorte qu'ils renvoient le pointeur nul du type de l'objet à créer.
S'ils renvoient une exception, le programme sera arrêté si aucun traitement particulier n'est fait. Bien entendu, le programme peut traiter cette exception s'il le désire, mais en général, il n'y a pas grand chose à faire en cas de manque de mémoire. Vous pouvez consulter le chapitre traitant des exceptions pour plus de détails à ce sujet.
Dans tous les cas,
(par un test avec NULL ou le pointeur nul, ou en analysant l'algorithme). Cette vérification inclut le test de débordement lors des accès aux chaînes de caractères et aux tableaux. Cela est extrêmement important lorsque l'on manipule des données provenant de l'extérieur du programme, car on ne peut dans ce cas pas supposer que ces données sont valides.
# Programmation C-C++/Identification des types

Cours de C/C++ :
| C++ : Identification des types ||
| | Identification dynamique des types |
| | Transtypages C++ |
| Livre original de C. Casteyde ||
Le C++ est un langage fortement typé. Malgré cela, il se peut que le type exact d'un objet soit inconnu à cause de l'héritage. Par exemple, si un objet est considéré comme un objet d'une classe de base de sa véritable classe, on ne peut pas déterminer a priori quelle est sa véritable nature.
Cependant, les objets polymorphiques (qui, rappelons-le, sont des objets disposant de méthodes virtuelles) conservent des informations sur leur type dynamique, à savoir leur véritable nature. En effet, lors de l'appel des méthodes virtuelles, la méthode appelée est la méthode de la véritable classe de l'objet.
Il est possible d'utiliser cette propriété pour mettre en place un mécanisme permettant d'identifier le type dynamique des objets, mais cette manière de procéder n'est pas portable. Le C++ fournit donc un mécanisme standard permettant de manipuler les informations de type des objets polymorphiques. Ce mécanisme prend en charge l'identification dynamique des types et la vérification de la validité des transtypages dans le cadre de la dérivation.
# Simscript III/Dictionnaire des instructions/CREATE EACH

Lénoncé create eachalloue les tableaux pour les attributs de lentité permanente spécifiée. Tous ces tableaux sont initialisés à zéro.
| Syntaxe : | |
| | $\color {blue}{\text{create }}\color {black}\left\{{\begin{aligned}&\color {blue}{\text{each}}\\&\color {blue}{\text{ all}}\\\end{aligned}}\color {black}\right\}{\text{ }}Nom\_Entit{\acute {e}}\_Permanente{\text{ }}\!\![\!\!{\text{ (N) }}\!\!]\!\!{\text{ }}$ |
avec N = valeur ou expression entière (dimensionnement de l’entité). Si (N) est omis, on doit obligatoirement affecter une valeur non nulle à l’attribut prédéfini N.Nom_Entité_Permanente avant le create each.
Exemples :
# Simscript III/Dictionnaire des instructions/AFTER/BEFORE

Un appel à une routine ou une méthode peut être effectué implicitement en spécifiant avec lénoncé after/beforedans le préambule le nom de la méthode ou routine à appeler. Cette méthode ou routine ne doit pas posséder de paramètres, mais cette méthode/routine peut faire appel à un autre sous-programme avec des paramètres, permettant ainsi par exemple dinitialiser un objet après sa création.
Cet appel implicite peut être effectué après la création ou avant la destruction d’un objet, d’un processus ou d’une entité temporaire. Un appel implicite peut également être effectué avant d’ajouter ou retirer un élément d’un ensemble. Enfin, un appel implicite à une routine/méthode peut être effectué après l’ordonnancement d’un processus ou d’une méthode processus ou après avoir annuler un processus ou une méthode processus.
Si l’énoncé before/after scheduling/canceling apparaît à l’intérieur d’un bloc begin class … end, l’énoncé nomme une méthode processus ou une méthode d’un objet ou d’une classe. En dehors d’un bloc d’une classe, l’énoncé nomme un processus ou une routine.L’énoncé before/after filing/removing fait référence à un ensemble possédé par un objet ou la classe et à une méthode d’un objet ou d’une classe. La méthode doit avoir été définies dans la classe ou héritée d’une autre classe.
| Syntaxe : | |
| | $\left\{{\begin{matrix}\left\{{\begin{matrix}\color {blue}{\text{after creating}}\\\color {blue}{\text{before destroying}}\\\end{matrix}}\right\}^{c}\left[\color {blue}{\text{a}}\color {black}\right]{\text{ }}\left\{{\begin{matrix}Entit{\acute {e}}{\text{ }}\!\!\_\!\!{\text{ }}Temporaire\\Processus\\Objet\\\end{matrix}}\right\}\\\\\left\{\left\{{\begin{matrix}\color {blue}{\text{after}}\\\color {blue}{\text{before }}\\\end{matrix}}\right\}\left\{{\begin{matrix}\color {blue}{\text{filing}}\\\color {blue}{\text{removing }}\\\end{matrix}}\right\}^{c}\right\}^{c}\left[{\begin{matrix}\color {blue}{\text{in}}\\\color {blue}{\text{from}}\\\end{matrix}}\right]{\text{ }}Ensemble{\text{ }}\\\\\left\{\left\{{\begin{matrix}\color {blue}{\text{after}}\\\color {blue}{\text{before }}\\\end{matrix}}\right\}\left\{{\begin{matrix}\color {blue}{\text{scheduling}}\\\color {blue}{\text{canceling}}\\\end{matrix}}\right\}^{c}\right\}^{c}\left[\color {blue}{\text{a}}\color {black}\right]{\text{ }}Processus{\text{ }}\\\end{matrix}}\right\},\color {blue}{\text{ call }}\color {black}\left\{{\begin{matrix}Routine\\M{\acute {e}}thode\\\end{matrix}}\right\}$ |
Exemple :
       after creating a Véhicule, call Construire;
       after destroying a Véhicule, call Détruire;
       after filing and removing from Réservation, call Vérifier_Réservation;
       after scheduling an Arrivée, call Vendre_Ticket;
# Simscript III/Dictionnaire des instructions/BREAK ... TIES

Cet énoncé, qui ne peut apparaître que dans le préambule (preamble), établit des priorités dexécution entre plusieurs processus d’une même classe dans le cas où ils se trouvent activés simultanément (même heure dactivation time.a). Elle doit se situer après la déclaration des attributs utilisés pour définir les priorités (phrase everyde la rubrique processes).
${\begin{aligned}&\color {blue}{\text{break }}\color {black}Nom{\text{ }}\!\!\_\!\!{\text{ }}Processus\quad \color {blue}{\text{ties by }}\color {black}\left\{{\begin{aligned}&\color {blue}{\text{high}}\\&\color {blue}{\text{low}}\\\end{aligned}}\right\}\quad Attribut\\&{\text{ }}\qquad \qquad \qquad \qquad \qquad \left[\color {blue}{\text{then by }}\color {black}Attribut\right]\\\end{aligned}}$
Nom_Processus est un processus et Attribut est un attribut (de priorité) qui a dû être déclaré auparavant dans un "every Nom_Processus has a Attribut,...". Les phrases optionnelles "then by" permettent d’ajouter d’autres attributs de priorité pour résoudre les conflits en cas d’égalité des attributs précédents.
Il faut savoir que lorsque plusieurs processus ont la même heure d’activation (attribut time.a identique sur 16 digits), ils sont exécutés dans l’ordre correspondant aux règles suivantes :
    1. Pour des processus de classes différentes, on suit l’ordre défini par l’énoncé priority order si il existe, ou bien l’ordre de leur déclaration dans la rubrique processes, sinon
    2. Pour les processus d’une même classe, on suit l’ordre défini par l’énoncé break ... ties si il existe, ou bien l’ordre fifo (premier activé, premier exécuté), sinon
Voir à priority order pour un exemple complet.
# Simscript III/Dictionnaire des instructions/CREATE

Lénoncé createalloue une zone mémoire pour les attributs dun exemplaire spécifié dune entité temporaire, et assigne un pointeur à cette zone mémoire. De plus, tous les attributs sont initialisés à zéro
| Syntaxe : | |
| | $\color {blue}{\text{create a }}\color {black}\left\{{\begin{matrix}Entit{\acute {e}}{\text{ }}\!\!\_\!\!{\text{ }}Temporaire\\Objet\\\end{matrix}}\right\}\left[\color {blue}{\text{called }}\color {black}Variable{\text{ }}\!\!\_\!\!{\text{ }}Pointeur\right]$ |
Entité_Temporaire a été être déclaré dans le preamble (par un "every"..., sous la rubrique temporary entities).
Attention, très important : si "called Variable_Pointeur" est omis, le pointeur de l’entité est mis dans une variable globale (de type entier) de même nom que l’entité. C’est le cas le plus courant. On manipule alors les attributs de l’entité/objet en faisant référence à cette variable (simplicité d’écriture); par exemple :
Mais, si entre le "create" et le "if" d’autres bateaux sont créés, le test portera sur le dernier Bateau créé. D’où l’existence de la "forme longue" :
                         $\color {blue}\qquad \qquad \qquad \quad {\text{create a }}\color {black}Paquebot\color {blue}{\text{ called }}\color {black}France{\text{ }}\!\!\_\!\!{\text{ }}II$
dans laquelle France_II sera une variable entière (pointeur), éventuellement indicée, le plus souvent locale, qui contiendra le pointeur de l’entité que l’on vient de créer. Ce cas ne se produit en fait que lorsqu’on doit manipuler plusieurs exemplaires d’une même entité temporaire dans une même routine, ce qui est rare...
# Simscript III/Dictionnaire des instructions/COMPUTE

Lénoncé computepermet de calculer des quantités statistiques sur un ensemble de valeurs défini par une boucle for(ou whileou until).
| Syntaxe : | |
| | ${\begin{aligned}&\color {blue}{\text{compute }}\color {black}Nom_{1}{\text{ }}\left\{{\begin{matrix}{\text{=}}\\\color {blue}{\text{as }}\color {black}\left[\color {blue}{\text{the}}\color {black}\right]\\\end{matrix}}\right\}Mot\_Cl{\acute {e}}_{1}\\&{\text{ }}\left[{\text{, }}Nom_{n}{\text{ }}\left\{{\begin{matrix}{\text{=}}\\\color {blue}{\text{as }}\color {black}\left[\color {blue}{\text{the}}\color {black}\right]\\\end{matrix}}\right\}Mot\_Cl{\acute {e}}_{n}\right]\color {blue}{\text{ of }}\color {black}x\\\end{aligned}}$ |
x doit être un attribut d’entité(s) permanente(s) ou un attribut d’entité temporaire.
Nom$_1$,...,Nom$_n$ sont des noms de variables qui doivent être déclarées avant le compute et qui donnent en fin de boucle les quantités demandées par les mots-clés de l’énoncé.
Voici les mots clés et les calculs effectués par un compute:
    Number N = nombre de valeurs de x sélectionnées dans la boucle Sum $\sum \limits _{i=1}^{N}{x_{i}^}$ sum.of.square $\sum \limits _{i=1}^{N}{x_{i}^{2}}$ Mean $Moy=\sum \limits _{i=1}^{n}{{x_{i}}/{n}\;}$ mean.square sum.of.squares / n Variance variance de x = mean.square – mean**2 std.dev écart-type de x = sqrt.f(varaince) Maximum maximum des x Minimum minimum des x max(Repère) valeur du repère (index ou pointeur) de la boucle min(Repère) plus interne pour lequel x atteint son max (ou son min)
Voici maintenant quelques exemples:
    1.
    2.
===> Si l'on veut aussi récupérer le IMax, il faut ajouter :
    3. Trouver la plus courte file d'attente:
Après la boucle, Plus_Courte_File contient la longueur de la plus courte file
    4. Trouver le numéro de la plus courte file d’attente:
Après la boucle, Meilleur_Pompiste contient le numéro de la plus courte file d'attente de pompiste
    5. Trouver le minimum et le maximum d’un ensemble ainsi que les numéros de des ensembles.
Après la boucle,
| Vol_Max : | contient le numéro de vol avec le plus grand nombre de passagers. |
| Passager_Max : | contient le nombre de passagers maximum dans le vol Vol_Max. |
| Vol_Min : | contient le numéro de vol avec le plus petit nombre de passagers. |
| Passager_Min : | contient le nombre de passagers minimum dans le vol Vol_Min. |
# Simscript III/Dictionnaire des instructions/CREATE OBJECT

Lénoncé createest également utilisé pour créer un objet déclaré par une variable de référence. De plus, tous les attributs de lobjet sont initialisés à zéro.
| Syntaxe : | |
| | $\color {blue}{\text{create }}\left[{\text{a}}\right]\color {black}{\text{ }}Obj_{1},....Obj_{n}$ |
où Obj$_1$, … Obj$_n$ est une liste d’objets déclarés par des variables de référence.
Exemples :
# Simscript III/Dictionnaire des instructions/CLOSE

Lénoncé close ferme un fichier ouvert avec lénoncé open.
| Syntaxe : | |
| | $\color {blue}{\text{close}}\color {black}\left[\color {blue}{\text{unit}}\color {black}\right]{\text{ }}unit{\acute {e}}{\text{ }}$ |
Exemple :
# Simscript III/Dictionnaire des instructions/CALL

Lénoncé callappelle un sous-programme de type routine(Sous_Programme), process method(Méthode_Processus), ou method(Méthode d’un objet).
| Syntaxe : | |
| | $\left\{{\begin{matrix}\color {blue}{\text{call}}\\\color {blue}{\text{now}}\\\color {blue}{\text{perform}}\\\end{matrix}}\right\}{\text{ }}\left\{{\begin{matrix}Sous{\text{ }}\!\!\_\!\!{\text{ }}Programme\\M{\acute {e}}thode\\M{\acute {e}}thode{\text{ }}\!\!\_\!\!{\text{ }}Processus\\\end{matrix}}\right\}{\text{ }}\left[{\begin{aligned}&\left[{\begin{matrix}\left[\left(v_{\text{1}}{\text{,}}v_{\text{2}}{\text{,}}...{\text{,}}v_{\text{n}}\right)\right]\\\left[\color {blue}{\text{ giving }}\color {black}v_{\text{1}}{\text{,}}v_{\text{2}}{\text{,}}...{\text{,}}v_{\text{n}}\right]\\\end{matrix}}\right]\\&\left[\color {blue}{\text{yielding }}\color {black}r_{\text{1}}{\text{,}}r_{\text{2}}{\text{,}}...{\text{,}}r_{\text{m}}\right]\\\end{aligned}}\right]{\text{ }}$ |
giving introduit la liste des paramètres d’entrée et yielding celle des paramètres de sortie.
Exemple :