4.1 PolymorphismYouTube↗  IA↗(long shot)
Education  1.3K views 7 likes 0 dislikes   11 Sep 2017
Functional Programming Principles in Scala 1.3K subscribers N/A YouTube↗


Please select the problem
You must specify your email and describe the problem in detail
Describe your problem in detail if it's not obvious

Click to Play Video Click to Play Video
The first three weeks courses have focused on functions, classes, data items, and a
Les cours de trois premières semaines ont mis l'accent sur les fonctions, les classes, les éléments de données et un
model how they are evaluated. In this week, we are going to concentrate
model de la façon dont elles sont évaluées. Cette semaine, nous allons plus nous concentrer
more on types. That is the way the compiler sees these
sur les types. C'est la façon dont le compilateur voit ces
classes and functions. In particular, we're going to learn about
classes et fonctions. En particulier, nous allons en savoir plus façons
fundamental ways to abstract and compose types.
fondamentales d'abstraction et de composition de types.
The principal concept here is type parameterization.
Le concept principal est la paramétrisation de type.
Type parameterization means that classes as well as methods can now have types as
la paramétrisation du type signifie que les classes ainsi que des méthodes peuvent avoir maintenant des types comme
parameters. The running example for this week is a
paramètres. L'exemple en cours d'exécution pour cette semaine est une
data structure which is fundamental for many functional languages.
structure de données qui est fondamental pour de nombreux langages fonctionnels.
That's the immutable list that's built from individual consoles.
C'est la liste immuable qui est construite à partir des consoles.
Over the last sessions we have seen quite a few different forms of types.
Au cours des dernières sessions, nous avons vu quelques différentes formes de types.
From simple types such as int or double, to class types such as rational and inset.
Des types simples comme int ou double, aux types de classes telles que rational et inset.
What we're going to see this week is more flexible ways to express and parameterize
Ce que nous allons voir cette semaine est des manières plus flexibles d'exprimer et de paramétrer les
types. This is called polymorphism.
types. C'est ce qu'on appelle le polymorphisme.
So as a motivating example lets looks at the data structure that's been fundamental
Donc comme exemple regardons la structure de données qui a été fondamentale
in many functional languages from the beginnings of list, its called the cons list. So cons list is an immutable link list
dans de nombreux langages fonctionnels depuis le début de la liste, c'est appelé la cons list.
constructed from two building blocks. The empty list which we call mill and the cell
construite à partir de deux blocs de construction. La liste vide que nous appelons nil et la cellule
that contains first element of the list and a pointer reference to the rest of the
qui contient le premier élément de la liste et une référence de pointeur vers le reste de la
list, that is called cons. Let's look at some examples.
liste, qui est appelé cons. Regardons quelques exemples.
The list one, two, three could be drawn as follows.
La liste un, deux, trois pourraient être dessinés comme suit.
You would have a first Cons cell that contains the one.
Vous auriez une première cellule Cons qui contient le 1.
And a reference to the next Cons cell that contains the two.
Et une référence à la cellule suivante de Cons qui contient les deux.
And a reference to a Cons cell that contains the three.
Et une référence à une cellule Cons qui contient les trois.
And finally, this right field is nil. Here's a somewhat more complicated
Et enfin, ce domaine du droit est égal à zéro. Voici un peu plus compliqué
example. A list containing two nested lists.
par exemple. Une liste qui contient deux listes imbriquées.
So that could be visualized as follows. We would have here, let's start with the
Sorte que pourraient être visualisés comme suit. Nous avons ici, nous allons commencer avec le
list that contains true. And false,
liste qui contient la valeur true. Et la valeur false,
That would be the first element of the outer list.
Ce serait le premier élément de la liste externe.
Then there would be another list which is three and nil.
Puis, il y aurait une autre liste qui regroupe les trois et « néant ».
That will be the second element and then we would connect those two lists like
Ce sera le deuxième élément et puis nous relierait ces deux listes comme
that. And,
qui. Et,
We would finally, get a little here. So that would be, the list, list of true,
Nous voudrions Enfin, obtenir un peu ici. Afin que soit, la liste, liste de vrai,
false, and the list of three here. So you see the general principle.
false et la liste des trois ici. Vous voyez donc le principe général.
The question now is, how do we write that as a class heirarchy in Scala?
Maintenant la question est, comment nous écrire que comme une hiérarchie de classe en Scala ?
Okay, so here's an outline of a class heirarchy that would represent list of
OK, Voici donc un aperçu d'une hiérarchie de classe qui représente la liste des
integers in this fashion. We would start with a base trait, call it
entiers de cette façon. Nous appelons, commencent par un trait de base
IntList and two subclasses, Cons and Nil Cons subclass takes a head which is an
IntList et deux sous-classes, Cons et sous-classe Cons Nil prend une tête qui est un
integer, the first element of the list, and a tail which is the remainder of the
entier, le premier élément de la liste et une queue qui est le reste de la
list of Type intList and extends IntList The Nil class,
liste de Type intList et étend la classe IntList le Nil,
Representing the empty list, simply extends inclist.
Qui représente la liste vide, étend simplement inclist.
And, we will have to fill in the dots here, to show what methods are in this
Et, il va falloir remplir les points ici, afin de montrer quelles sont les méthodes dans cette
class hierarchy and how we would implement them.
hiérarchie de classes et comment nous serait mise en œuvre.
Now, there is one piece of new syntax here, I have written directly val head int
Maintenant, il y a une seule pièce de la nouvelle syntaxe ici, j'ai écrit directement val int tête
and val tail inclist. What that does is, it defines at the same
et val queue inclist. Ce que cela ne soit, elle définit en même
time a parameter of the class and a field value definition in the class itself.
temps un paramètre de la classe et une définition de valeur de champ dans la classe elle-même.
So the parameters that you see here are in fact equivalent to two fields, head and
Les paramètres que vous voyez ici sont en fait équivalents à deux champs, la tête et
tail, that I initialized by parameters that have some other name that's not
sa queue, j'ai initialisé par des paramètres qui ont un autre nom qui n'est pas
otherwise used in the program. So you can always express the val
dans le cas contraire, utilisés dans le programme. Donc vous pouvez toujours exprimer le val
parameters in, in this way but of course val parameters are much more concise so
paramètres de, dans ce sens, mais bien sûr paramètres val sont beaucoup plus concis afin
they're preferred as a syntax form. But there's actually one other problem
ils sont plus comme une forme de syntaxe. Mais il est en fait un autre problème
with our type hierarchy, and that's that it's way too narrow to define on the list
avec notre hiérarchie des types, et c'est que c'est beaucoup trop étroit pour définir la liste
with int elements. If we do it that way we'ld need another
avec des éléments de type int. Si nous le faisons ce feed-back façon besoin d'un autre
class hierarchy for double lists, and one for list of booleans and so on.
hiérarchie de classes pour double listes et l'autre pour obtenir la liste des valeurs booléennes et ainsi de suite.
One for each possible element type so lets clear an unscalable.
Un pour chaque type d'élément possible permet donc clairement un infranchissables.
What we need to do is generalize the definition and we can do that using a type
Ce que nous devons faire est de généraliser la définition, et nous pouvons le faire à l'aide d'un type
parameter. So as an outline, what we're going to do
paramètre. Alors que les grandes lignes, ce que nous allons faire
is, we're going to define now a base trait list, which takes a type parameter t.
est, nous allons définir maintenant une liste de caractères de base, qui prend un paramètre de type t.
So type parameters are written, in square brackets.
Si des paramètres de type sont rédigés, crochets.
And that base trait list of T would have two subclasses, cons and middle.
Et cette liste de caractères de base de T aurait deux sous-classes, inconvénients et au Moyen-Orient.
Both of them are again parametrized. Also we call their type parameters T.
Deux d'entre eux sont à nouveau paramétré. Aussi nous appelons leurs paramètres de type T.
And in the case of cons we would now have a head element that is of type T, no
Dans le cas des inconvénients, nous aurions maintenant un élément head de type T, aucune
longer imp, but the parameter T. And a tail element that is of type list of
imp plus longtemps, mais le paramètre T. Et un élément de la liste type de queue
T. And cons of T itself extends list of T.
Cons T. et t s'allonge la liste des T.
The middle class is analogous, so middle of T would simply extend list of T.
La classe moyenne est analogue, donc moyen t prolongerait simplement liste de T.
What we're going to do now is flesh out this hierarchy, adding the necessary
Ce que nous allons faire maintenant est de concrétiser cette hiérarchie, ajoutant le nécessaire
methods and the implementations. And we're going to do that using Eclipse
les méthodes et les implémentations. Et nous allons le faire à l'aide d'Eclipse
again. So what I'm going to do is create a Scala
encore une fois. Donc ce que je vais faire est créer un Scala
trait, call it list. And the first thing I will do is add, the
trait, appel le gîte. Et la première chose que je vais faire est d'ajouter, le
type parameter, to, list, t. We could have any name, but, if this is
paramètre de type, à répertorier, t. Nous pourrions avoir n'importe quel nom, mais, si cela est
just a single type parameter at play, t is quite common.
juste un paramètre de type unique à jouer, t est tout à fait commun.
So what methods should, we put into that trait?
Donc ce qui devraient les méthodes, nous avons mis dans ce trait ?
Well, there seem to be three fundamental ones.
Eh bien, il semble y avoir trois principes fondamentaux.
The first method is, we need to distinguish between whether the list is a
La première méthode est, nous devons faire la distinction entre la question de savoir si la liste est un
Cons cell the empty list. So let's call this method is empty.
Inconvénients la cellule la liste vide. Nous allons donc appeler cette méthode est vide.
Of type Boolean. So that tells us what kind of list we
De type booléen. Ce qui nous dit quel type de liste que nous
have. Second method would be if we have a non
a. Seconde méthode serait si nous avons un non
empty list, then we would be interested what is the first element of that list, so
vider la liste, alors nous serions intéressés de savoir ce qui est le premier élément de cette liste, alors
that would be head as a method name, and what should it's type be?
Ce serait la tête comme un nom de méthode, et quel devrait être son type ?
Well, it would be element type of the list, so that would be T.
Eh bien, ce serait le type d'élément de la liste, alors ce serait T.
And finally, the last method would be tail, which gives us the remaining list
Et enfin, la dernière méthode serait de queue, ce qui nous donne la liste restante
and its type would be list of T. Good, now that we have fleshed out the
et son type serait la liste de T. bien, maintenant que nous avons étoffé la
base trait, let's go the implementations. First implementation would be the class
trait de base, Let ' s go les implémentations. Première mise en œuvre serait la classe
cons, which takes the type parameter t and head and tail as you've seen.
inconvénients, qui prend le paramètre de type t, la tête et la queue, comme vous l'avez vu.
And it's an extension of list of T and what do we need to implement, well let's
Et c'est une extension de la liste de T et de quoi avons-nous besoin mettre en œuvre, Eh bien nous allons
start is MT. If a console is empty is always false
Start est Mt Si une console est vide est toujours false
because consoles are never empty. What about the other two?
parce que les consoles ne sont jamais vides. Qu'en est-il des deux autres ?
Definitions head and tail. Well actually, we have already implemented
Tête de définitions et une queue. Eh bien en fait, nous avons déjà mis en œuvre
them using the parameter names here. So the vowel had T.
en utilisant les noms de paramètres ici. Si la voyelle a T.
T is actually a legal implementation for the method head t in the base class.
T est en fait une mise en œuvre juridique pour le t tête de méthode dans la classe de base.
And the same holds for the tail value that we have here.
Et il en va de même pour la valeur de queue que nous avons ici.
Oh, I just forgot, we have to put the tail value here in front because otherwise, it
Oh, j'ai juste oublié, nous devons mettre la valeur de la queue ici en face parce que sinon, il
wouldn't count as a field, and it wouldn't implement.
compterais pas comme un champ, et il ne serait pas mise en œuvre.
So what that shows is that in, Scala val definitions.
Donc ce que cela montre qui est in, Scala val définitions.
So field definitions in classes are really special cases of methods.
Définitions des champs dans les classes sont donc vraiment exceptionnellement des méthodes.
And they can override methods, and they can implement abstract methods and traits.
Ils peuvent substituer les méthodes et ils peuvent implémenter des traits et des méthodes abstraites.
The difference between eval and the def concerns only the initialization.
La différence entre l'évaluation et la définition concerne uniquement l'initialisation.
Eval is evaluated when the object is first initialized.
Eval est évaluée lors de la première initialisation de l'objet.
Where, whereas a def is evaluated each time it is referenced.
Où, alors qu'un def est évalué à chaque fois qu'il est référencé.
So now we have cons. Let's look at the final one, Nil.
Alors maintenant, nous avons cons. Penchons-nous sur le Nil, une finale.
Nil of T also extends list of T and we have to implement the three methods.
Nul t étend également liste des T et nous devrons mettre en place les trois méthodes.
What should this empty be? Well for Nil that would always be true.
Quel devrait être ce vide ? Eh bien pour « néant » qui serait toujours vrai.
What should head be? Well the problem with head is that we
Quelle devrait être la tête ? Eh bien, le problème avec la tête est que nous
cannot take the head of an empty list. So we should do is draw an exception, is
ne peut pas prendre la tête d'une liste vide. Alors que nous devrions faire est de dessiner une exception, est
actually a handy exception in java code. No such element exception which we could
en fait une exception très pratique dans le code java. Aucune telle exception élément dont nous pourrions
throw here and we can give it a message which says well you just hit nil.head.
Jetez ici et nous pouvons lui donner un message qui dit Eh bien, vous appuyez simplement sur nil.head.
So new no such element exception and finally tail.
Si nouveau aucune dérogation élément et enfin la queue.
Would be the same thing. We cannot also, cannot take the remainder
Serait la même chose. On ne peut pas également, ne peut pas prendre le reste
of an empty list. So, it would also throw a no such element
d'une liste vide. Ainsi, il ne serait aussi lancer un tel aucun élément
exception. What is the type of head and tails?
exception. Quel est le type de tête et la queue ?
Well, you've learned that throw exception has type nothing and that then is also the
Eh bien, vous avez appris que throw exception a type rien et cette époque est aussi le
inferred type of head and tails so to be explicit, we could try that like this.
déduit le type de tête et la queue pour être explicite, nous pourrions essayer ça comme ceci.
And then, we also see why that works, because head is, now is type nothing.
Et puis, nous voyons aussi pourquoi cela fonctionne, parce que la tête est, est maintenant type rien.
Nothing is a subtype of any other type, including T, so it's perfectly okay to
Rien n'est un sous-type d'un autre type, y compris T, donc il est parfaitement acceptable de
have a head definition here that returns nothing and that can implement a head,
tête définie ici qui ne renvoie rien et qui peut mettre en place une tête,
abstract method in the trait list that returns a T, simply because a nothing is a
Résumé de la méthode dans la liste de trait qui renvoie un T, simplement parce qu'un rien est un
T, a nothing is a subtype of any other type.
T, une Null est un sous-type d'un autre type.
Good. So, that was our implementation of lists,
Bonne. Donc, ça a été notre mise en œuvre des listes,
which relied on the fact that we could parameter as classes with type parameters.
qui s'est appuyée sur le fait que nous pourrions paramètre sous forme de classes avec des paramètres de type.
Type parameters are there not only for classes, but we can apply them also to
Paramètres de type sont là non seulement pour les classes, mais on peut les appliquer aussi au
functions. So, functions can have type parameters.
fonctions. Alors, fonctions peuvent avoir des paramètres de type.
For instance, here's a function that creates a list consisting of a single
Par exemple, Voici une fonction qui crée une liste composée d'un seul
element. So we would write def singleton and it
élément. Donc on écrirait def singleton et il
takes a element of the type of the list. And again that could be any type, so we
prend un élément du type de la liste. Et encore une fois, cela pourrait être n'importe quel type, donc nous
parametrize here singleton with a type parameter T.
paramétrer un singleton ici avec un paramètre de type T.
And the body of the singleton is that simply creates a new Cons cell. it passes
Et le corps du singleton qui crée simplement une nouvelle cellule Cons. Il passe
on the type parameter T to say well, it needs to be a, a Cons cell of type T.
sur le paramètre de type T à dire Eh bien, il doit être un nombre, une cellule Cons de type T.
Its first element is elem and its tail is an empty list and it's an empty list of
Son premier élément est elem et sa queue est une liste vide et c'est une liste vide de
element type T. The same T as the Cons cell. And if we do
type d'élément T. Le même T comme la cellule Cons. Et si nous le faisons
that, we can then write singleton, and we can pass the type along.
que, nous pouvons alors écrire singleton, et nous pouvons passer le type long.
So we want a singleton of type int now and the actual value should be one.
Si nous voulons un singleton de type int maintenant et la valeur réelle devrait être une.
And that would give us, of course, the singleton list.
Et qui nous donnerait, bien sûr, la liste de singleton.
One and nil. Or the other one would be, that Singerton
L'un et zéro. Ou l'autre se serait, que Singerton
lists ture and Nil. So we can create lists like that by passing in first the type
ture de listes et de néant. Si nous pouvons créer des listes comme ça en passant en premier le type
parameter and then the value parameter. In fact, the type parameters are often
paramètre, puis le paramètre value. En fait, les paramètres de type sont souvent
redundant, because the Scala compiler can usually deduce the correct type parameter
redondante, car le compilateur Scala peut habituellement déduire le paramètre de type correct
from the value arguments of a function call here.
les arguments de valeur d'un appel de fonction ici.
So, for instance, for the singleton, examples you could also write simply
Ainsi, par exemple, pour le singleton, vous pouvez également écrire simplement des exemples
singleton of one. And, the compiler would infer that this is
singleton d'une. Et, le compilateur pourrait déduire qu'il s'agit
a singleton of type Int. Simply because, it knows that the constant one is of type
un singleton de type int. tout simplement, parce qu'il sait que la constante un est de type
Int so Int is the best fitting parameter type.
Int Int est le meilleur type de paramètre de raccord.
And, the same way, it could infer that singleton of True has type parameter
Et, la même façon, on pouvait inférer que singleton true comporte un paramètre de type
boolean because, True is a value of type Boolean.
booléenne True est une valeur de type Boolean.
So that gives us a quite significant simplification of notation.
Nous obtenons donc une simplification très importante de la notation.
Where, then, the types really get out of the way.
Où, ensuite, les types vraiment obtenir de la route.
They're not in your face anymore but they do in the background what needs to happen.
Ils ne sont pas dans votre visage plus mais ils le font en arrière-plan que doit-il se passer.
So when I drew data structures like this, Then in fact the actual type Int and
Alors quand j'ai dessiné structures de données comme ça, alors en fait le type réel Int et
boolean doesn't form part of the data structure,
Boolean ne forme pas partie de la structure des données,
It's not stored anywhere. And that's a principle that affects all of
Il n'est pas stocké n'importe où. Et c'est un principe qui touche l'ensemble des
evaluation. So it turns out that type parameters do
évaluation. Si il s'avère que les paramètres de type ne
not affect evaluation in Scala at all. So, to use our substitution model, we can
n'affecte pas evaluation in Scala à tous. Donc, pour utiliser notre modèle de substitution, nous pouvons
simply assume that all type parameters and type arguments are removed before
simplement supposer que tous les paramètres de type et des arguments de type sont supprimés avant
evaluating the program. Otherwise said, pipes are only important
évaluation du programme. Autrement dit, pipes sont seulement importantes
for the compiler to verify that the program satisfies certain correctness
pour le compilateur afin de vérifier que le programme satisfait à certain rectitude
properties, but they're not relevant for the actual execution.
Propriétés, mais ils ne sont pas pertinents pour l'exécution réelle.
That's a property which is called type erasure so types erased at run-time.
C'est une propriété appelée type effacement alors effacement de types au moment de l'exécution.
And it's a property that some languages have and others don't.
Et c'est une propriété qu'ont certains langages et d'autres pas.
So, if we look at the camp of languages that use type erasure, then we'll see Java
Donc, si nous regardons le camp de langues qui utilisent le type effacement, nous allons voir Java
and also Scala. And functional languages such as Haskell,
et aussi de Scala. Et les langages fonctionnels tels que Haskell,
ML or OCaml. But other languages actually keep the type
ML ou OCaml. Mais d'autres langues en fait garder le type
parameters around at run time. So for those languages, type parameters.
paramètres autour de l'exécution. Donc pour ces langues, paramètres de type.
Would affect run time behavior, so those languages include c++ and languages in
Affect irait comportement de temps, alors ces langues comprennent c ++ et des langues
the.NET family, such as C# or F#. So what we've seen here is a form of
famille.net, tel que c# ou F #. Donc ce que nous avons vu ici est une forme de
polymorphism. Polymorphism is a Greek word and its
polymorphisme. Le polymorphisme est un mot grec et ses
original meaning was having many forms. So applied to a function, it means that
signification originale était d'avoir plusieurs formes. Si appliqué à une fonction, cela signifie que
the function can be applied to arguments of many different types.
la fonction peut être appliquée aux arguments de différents types.
Applied to a class or a type, it means that the type can have instances of many
Appliqué à une classe ou un type, cela signifie que le type peut avoir des instances d'un grand nombre
different types. In fact, what we have seen are two
différents types. En fait, ce que nous avons vu sont deux
principle forms of polymorphism, namely sub typing and generics.
formes de principe du polymorphisme, sub nommément dactylographie et les génériques.
So sub-typing means that instances of a sub-class can be base, passed to a base
Ce sous-type signifie que les instances d'une sous-classe peuvent être base, transmises à une base de
class. So, for instance, in the case of list.
classe. Ainsi, par exemple, dans le cas de la liste.
I would have two subtypes. One was the class new, and the other was
J'aurais deux sous-types. L'un était la nouvelle classe, et l'autre a été
the class cons. And wherever I would have a parameter that
les inconvénients de la classe. Et partout où j'aurais un paramètre qui
accepts a list that could pass either a nil or a cons.
accepte une liste qui pourrait passer soit un zéro ou un contre.
That which would be. Just as just as good as, as a channelist.
Ce qui serait. Tout comme aussi bon que, comme un channelist.
So that means that it is a form of polymorphism that it could have one of
Donc, cela signifie que c'est une forme de polymorphisme que cela pourrait avoir un des
those two forms. The other form of polymorphism we've seen
ces deux formes. L'autre forme de polymorphisme que nous avons vu
was generics where we can create many instances of a function or a class by type
a médicaments génériques où nous pouvons créer plusieurs instances d'une fonction ou une classe par type
parameterization. So using generics we could create a list
paramétrage. Si l'utilisation de génériques, nous pourrions créer une liste
of int's or a list of doubles or a list of list of booleans.
d'int ou une liste de doubles ou une liste de liste de valeurs booléennes.
The two forms of polymorphism complement each other well and Scala has both of
Les deux formes de polymorphisme complètent bien et Scala possède à la fois de
them. Typically you would say that subtyping was
eux. En règle générale, vous diriez que le sous-typage a été
traditionally a form that object-oriented languages had first whereas generics was a
traditionnellement un formulaire que les langages orientés objet avaient d'abord alors que les médicaments génériques a été un
form that functional languages had first. So let's do an exercise.
formulaire qui avaient d'abord des langages fonctionnels. Nous allons donc faire un exercice.
Given our definition of lists, write a function nth that takes an integer n and
Notre définition des listes, écrire une fonction nième qui prend un entier n et
the list and selects the nth element of the list.
la liste et sélectionne le nième élément de la liste.
So we assume that elements in the list are numbered from zero.
Nous supposons donc que les éléments de la liste sont numérotés à partir de zéro.
So the first element in the list has index zero, the second has index one, and so on.
Donc le premier élément de la liste a index zéro, le second a indice un et ainsi de suite.
The other specification is that if an index is outside the range from zero up to
Les autres spécifications, c'est que si un index est en dehors de la plage de zéro jusqu'à
the length of the list minus one, so it's outside range, then you should throw an
la longueur de la liste moins un, n'est en dehors de la plage, alors vous devriez jeter un
index out of bounds exception. So let's see how we would solve the
index hors exception limites. Voyons donc comment nous permettrait de résoudre le
exercise. I have here our implementation of lists.
exercice. J'ai ici notre implémentation de listes.
What I want to do is create a worksheet in which I could.
Ce que je veux faire est de créer une feuille de calcul dans laquelle j'ai pu.
Implement this method. Call it Nth.
Implémentez cette méthode. Appelez-le Nth.
So I want to import in the worksheet what we have defined in the list class.
Je tiens donc à importer dans la feuille de calcul de ce que nous avons définies dans la classe de liste.
And I want to define a method. .
Et je veux définir une méthode. .
Call it nth that takes an index of type int.
Appelez-le nième qui accepte un index de type int.
And a list of type, list of. Well, we want to be flexible in the
Et une liste de type, la liste des. Eh bien, nous voulons faire preuve de souplesse dans la
element type. So that should be a type parameter of our
type d'élément. Donc cela devrait être un paramètre de type de notre
nth method. Have to return an element of type t.
méthode nième. Retourner un élément de type t.
So how do we implement that method? Well one good way to do it would be to ask
Alors, comment nous mettre en œuvre cette méthode ? Eh bien une bonne façon de le faire est de demander
whether the. Index n equals zero and if it is then we
Si le. Index n est égal à zéro et si c'est alors que nous
would have the answer immediately we could just return xs.head first element of x.
aurait la réponse immédiatement nous pourrions simplement renvoyer xs.head premier élément de x.
On the other hand if xn is not zero then what do we do.
En revanche si xn n'est pas égal à zéro alors que faire.
Well the idea then is would be to say well to take say the third element end of a
Bien que l'idée est alors serait de dire bien de prendre dire le troisième élément end d'une
list. That would be the same as taking the
liste. Ce serait la même que la prise de la
second element of the remainder of the list.
deuxième élément du reste de la liste.
So we would do an nth of n minus one as the index.
Donc, nous ferions une nième n moins 1 comme index.
And x as [inaudible] as the list argument. Okay, so now we have to find M.
Et x en tant que [inaudible] comme argument de la liste. OK, alors maintenant il faut trouver M.
Let's test it. Let's do a list ,, .
Nous allons le tester. Nous allons faire une liste.
So we have to find the list one two three And lets do n of two in the list.
Alors il faut trouver la liste de l'un deux trois et permet de faire des n de deux dans la liste.
What could we expect Well, It's three because we have arranged the elements in a
Ce que nous pourrions attendre bien, c'est trois, parce que nous avons organisé les éléments dans un
list, starting from zero. So, the one element will be at index zero,
liste, en commençant par zéro. Ainsi, le seul élément sera à l'index zéro,
two at index one, three at index two. So far so good, but, there was another
deux index, trois à l'index 2. Bien, mais, il y avait un autre
part of it, and that says well, what do we do if the index is not in the range of the
partie de celui-ci et qui dit bien, que faire si l'index n'est pas dans la plage de la
list. So, that would be something like that.
liste. Donc, ce serait quelque chose comme ça.
. And here we see a.
. Et ici, nous voyons une.
Java you till no such element exception nil.tail.
Java vous ne till aucun tel élément exception nil.tail.
That's an exception alright, but it's not the one we wanted.
C'est une exception bien, mais ce n'est pas celui que nous voulions.
The exercise said we should return an index out of bound exception.
L'exercice a dit que nous devrions retourner un index hors exception liée.
So what do we do here? Well, we have to change our definition of
Alors que faisons-nous ici ? Eh bien, nous devons changer notre définition de la
Nth to guard against index out of bound exceptions.
Nième pour se prémunir contre l'index hors exceptions liées.
So what we need to do is change the definition of Nth to take account of this
Donc ce que nous devons faire, c'est changer la définition de nième pour tenir compte de cette
behavior with exceptions. So the idea here is to say well, if our
comportement avec les exceptions. L'idée ici est de dire, Eh bien, si notre
list is empty then we can essentially, not select any element no matter what the
la liste est vide, puis nous pouvons essentiellement, ne sélectionnez aucun élément n'importe quoi la
index. So we have to catch this case beforehand.
index. Il faut donc prendre cette affaire au préalable.
So what I would do here is I would say, if X is empty then we throw a new index out
Ce que je ferais ici est donc que je dirais que, si X est vide puis nous jeter un nouvel index
of bounds. The exception.
des limites. L'exception.
And now we see the, worksheet behaves as we want.
Et maintenant, nous voyons le, feuille de calcul se comporte comme nous le voulons.
Nth minus one of list will throw an index out of bound exception, and I would hope
Nième moins de liste lèvera un index hors exception liée, et j'espère
that nth and four of list would do the same thing.
cette énième et quatre de la liste ferait la même chose.
Yes, it does. Index out of bound exception in both
Oui, il le fait. Index hors exception liée à la fois
Similar videos:

3.4 Evaluation and Operators
Functional Programming Principles in Scala
788 views 3 likes 0 dislikes 11 Sep 2017100% match

1.6 Blocks and Lexical Scope
Functional Programming Principles in Scala
819 views 7 likes 0 dislikes 11 Sep 2017100% match

1.1 Programming Paradigms
Functional Programming Principles in Scala
1.7K views 16 likes 0 dislikes 11 Sep 2017100% match

1.3 Evaluation Strategies and Termination
Functional Programming Principles in Scala
850 views 6 likes 0 dislikes 11 Sep 2017100% match

3.5 How Classes Are Organized
Functional Programming Principles in Scala
711 views 2 likes 0 dislikes 11 Sep 2017100% match

2.1 Tail Recursion
Functional Programming Principles in Scala
2.5K views 19 likes 0 dislikes 11 Sep 2017100% match

1.4 Conditionals and Value Definitions
Functional Programming Principles in Scala
775 views 3 likes 0 dislikes 11 Sep 2017100% match

1.2 Elements of Programming
Functional Programming Principles in Scala
1.3K views 6 likes 0 dislikes 11 Sep 2017100% match

3.1 Functions and Data
Functional Programming Principles in Scala
1.2K views 2 likes 0 dislikes 29 Sep 2017100% match

2.5 Scala Syntax Summary
Functional Programming Principles in Scala
759 views 2 likes 0 dislikes 11 Sep 2017100% match

1.5 Example, square roots with Newton's method
Functional Programming Principles in Scala
843 views 2 likes 1 dislikes 11 Sep 2017100% match

2.4 Example, Finding Fixed Points
Functional Programming Principles in Scala
750 views 1 likes 0 dislikes 11 Sep 2017100% match

Data Types
CS50
61.8K views 185 likes 7 dislikes 07 Oct 201528% match










0. ¿Qué es una Ecuación Diferencial? Tipos de ecuaciones diferenciales, solución de ED
MateFacil
1.3M views 16K likes 230 dislikes 11 Dec 201728% match

Transforming a Photo into a 3D model using Numpy-stl and Python - Part II
CODE MENTAL
1.2K views 19 likes 0 dislikes 08 Oct 202027% match

Tableaux dynamiques
MOOC EPFL Initiation à la programmation (en Java)
2.6K views 17 likes 0 dislikes 24 Jul 201427% match

server, 1 of 2
CS50
10.9K views 0 likes 0 dislikes 26 Oct 201527% match










10 - Introducing Lists
onlineeducation1993
2.9K views 20 likes 0 dislikes 26 Jan 201326% match

Binary Search
CS50
128.6K views 0 likes 0 dislikes 26 Sep 201226% match










Val vs Def functions in Scala
fp-tower
2.3K views 82 likes 1 dislikes 27 Oct 202026% match

Adventures In BASH: INFO BOTANICA | Kumputer Kar

33K views 831 likes 0 dislikes 27 Nov 202025% match



Code a bot in python to find the latest Nvidia RTX 3060 and Ryzen 5000
CODE MENTAL
2K views 31 likes 2 dislikes 31 Dec 202025% match

Supersection, Less Comfortable
CS50
19.6K views 0 likes 0 dislikes 14 Sep 201525% match










Electrostatics (part 1): Introduction to Charge and Coulomb's Law
Khan Academy
1.3M views 4.4K likes 208 dislikes 23 Jan 201025% match


Android 101 by Fred Widjaja
CS50
9.3K views 0 likes 0 dislikes 22 Nov 201425% match










2016 1 20 Analyzing and Visualizing Data with Power BI MOD PowerBI Desktop Jan UPdate
Microsoft Power BI
1K views 5 likes 0 dislikes 26 Feb 201625% match


Settings Privacy About Contact Donate