
French: 
Ces deux dernieres semaines, vous avez vu differentes manieres d'exprimer des fonctions,
de les créer, et de les utiliser dans vos programmes. Dans cette section, nous allons examiner les
constructions de langage que vous avez déja vues, dans un résumé de la syntaxe que vous pouvez utiliser
comme référence. En fait, il y a une maniere standard de décrire ces éléments
avec la grammaire, et la notation la plus communément utilisée pour ce genre
de grammaire est appelée "Extended Backus-Naur form".
Ainsi, dans cette "Extended Backus-Naur form", une barre verticale dénoterait une alternative.
Les crochets dénoteraient un optionnel élément, zéro ou une occurence d'un élément,
et les accolades dénoteraient une répétition : zéro, ou plus d'occurences d'un élément.
Commençons par les types. Nous avons vu deux formes de types, on a donc
une barre ici. Un type, dans notre langage est un "SimpleType"

English: 
Over the last two weeks you've seen
several ways to express functions, to
compose them, to use them in your program.
In this session we are going to review the
language constructs that you have seen so
far in one syntax summary that you can use
as a reference.
In fact there's a standard way to describe
elements like that with grammar and one of
the most commonly used notations for such
a grammar is called extended backwards now
form.
So in that standard backwards now form a
vertical bar would denote an alternative.
Brackets would denote an optional element
zero or one occurrences of an element and
braces would denote a repartition zero or
more occurrences of an element.
Let's start with types.
We've seen two form of types, so we would
have a bar here.
A type in our language is a simple type or

French: 
ou un "FunctionType". Un "SimpleType" jusqu'a maintenant est juste un identifieur,
et le "FunctionType" est ainsi : il contient toujours une fleche,
et a gauche de cette fleche, il peut y avoir un SimpleType, ou un set de types
entre parentheses. Une autre maniere de noter cela serait
comme suit : un type peut ętre premierement un type numérique.
Nous avons déja vu les int et les double. Mais il y a aussi les byte, short, character,
long, et float. Ce sont les męmes que les types primitifs en java.
comme nous l'avons vu. Troisiemement, nous avons le type String. On a également
les "function type" comme la fonction int vers int ou une paire d'int vers int.
Plus tard, nous verrons d'autres sortes de types.
Voyons les expressions. Ici, vous voyez la syntaxe complete des
expressions.
 Je ne vais pas aller dans les détails, mais C'est ici

English: 
a function type.
A simple type so far is just an
identifier, and the function type is
always contains an arrow.
And on the left hand side of this arrow
could be either a simple type, or a set of
types in parenthesis.
Another way to put it would be the
following.
A type can be either a numeric type.
So we've seen int and double.
But there's also bite, short, character,
long, and float.
That's the same as the primitive types in
Java.
Or it could be the boolean types that has
values true and false as we have seen.
Or it could be the string type.
Or it could be a function type such as int
to int or a pair of ints to ints.
Later, we're going to see more form of
types than these.
Let's look at expressions.
So here you see the complete syntax of
expressions.
I'm not going to go into detail but it's

English: 
there for you as reference.
Let's look instead at categories of
expressions and some examples.
So an expressions can be an identifier,
such as x or, IsGoodEnough, or it can be a
literal, such as zero or 1.0, or "abc".
Or it can be a function application, such
as square root of x.
Or an operator application, such as y + x.
Or a selection.
We've seen math.abs that selected the abs
method from the math module.
Or a conditional expression, such as if (x
< zero) - x else x.
Or it can be a block, like the one that
you see here in braces, or finally an
anonymous function such as x arrow x plus
one.
The last syntactic category are
definitions.
We have seen so far function definitions
and value definitions.
Function definitions start with a def,
followed by an identifier, followed by

French: 
pour vous servir de référence. 
Voyons plutôt les catégories d'expressions
et quelques exemples. 
Une expression peut ętre un identifieur, comme x, ou
IsGoodEnough, ou un littéral, comme 0, 1.0, ou "abc" entre guillemets.
Elle peut ętre également une "function application", comme racine carrée de x,
ou un "operator application", comme y + x. Ou encore une sélection :
Nous avons vu math.abs qui sélectionne la méthode abs du module math.
Ou une expression conditionnelle, comme if (x
< zero) - x else x.
L'expression peut ętre un bloc, comme celle que l'on voit ici entre accolades, ou
finallement une fonction anonyme comme "x fleche x plus 1".
Les dernieres catégories syntaxiques sont les définitions.
Nous avons vu jusqu'a maintenant des définitions de fonctions et de valeurs.
Les définitions de fonctions commencent avec "def" suivi d'un identifieur, suivi de

French: 
zéro ou plus liste(s) de parametres, suivi d'un optionnel type de résultat, suivi par
un signe égal puis finallement une expression. Les définitions de valeurs sont plus simples,
Elles consistent en le mot clé "val" puis un identifieur, un optionnel type, puis égal,
et enfin une expression. Les parametres peuvent ętre appelés par nom ou par valeur. Donc
un parametre est un identifieur, puis une colonne, puis viens un type, mais vous pouvez
précéder le type par une fleche, et vous voyez que cela signifie un appel par nom.
C'est toute la syntaxe que nous avons vu jusqu'a maintenant, et dont nous avions besoin dans
nos exemples. Nous allons maintenant ajouter des éléments supplémentaires au fur et a mesure
que nous en aurons besoin, au cours des prochaines semaines. Ceux qu'on vient de voir sont tous les
éléments de langage que nous avons déja utilisé. Vous noterez qu'ils sont tous en rapport avec des
fonctions et que nous avons parlé tres, tres peu de données. Il y a seulement eu

English: 
zero or more parameter lists, followed by
an optional result type, followed by an
equal sign and finally an expression.
Value definitions are simpler, they
consists of val, then an ident, then an
optional type, then equals, then
expressions.
Parameters can be by name, or by value.
So a parameter is an identifier, then a
colon and then comes a type, but you can
prefix the type with the arrow, and you've
seen that means a call by name parameter.
So that's all the syntax that we've seen
so far, that we've needed so far in our
examples.
We will add more elements as we need them
over the coming weeks.
So those are all the language elements
that we have used so far.
You will notice that they're all related
to functions and that we have spoken very,
very little about data.

French: 
quelques types primitifs de données comme les doules, les ints ou les booleans.
Cela va changer la semaine prochaine oů nous allons étudier de nouvelles manieres d'introduire
des données qui seront centrées sur les classes et les objets.

English: 
You had only some primitive data types
like doubles or ints or booleans.
This is going to change next week where we
are going to study new ways to indroduce
data that are centered around classes and
