Two Fer

Instructions

Ta tâche consiste à déterminer ce que tu diras au moment de donner le cookie en trop.

Si tu connais le nom de la personne (par exemple si elle s'appelle Do-yun), tu diras :

One for Do-yun, one for me.

Si tu ne connais pas le nom de la personne, tu diras you à la place.

One for you, one for me.

Voici quelques exemples :

Instructions spécifiques à Odin

Odin prend en charge les arguments par défaut. Les arguments par défaut sont une fonctionnalité utile qui permet d'appeler une procédure avec différents ensembles de paramètres, pour des cas d'usage où l'on a besoin d'API apparentées mais différentes.

Sans arguments par défaut, on peut se retrouver avec une explosion du nombre de procédures nécessaires pour son API. Les langages qui ne prennent pas en charge les arguments par défaut, comme Java, s'appuient sur la surcharge de méthodes pour obtenir le même effet (avec plus de code), ou doivent fournir des procédures avec un ensemble d'arguments potentiellement important.

Prenons l'exemple d'une procédure greeting dans laquelle on veut pouvoir préciser le langage, si le nom est en majuscules, et si l'on doit ajouter un point d'exclamation à la fin du message de salutation. Après analyse, nous avons constaté que le groupe d'utilisateurs le plus important précise l'anglais comme langage, ne met pas le nom en majuscules et ne veut pas de point d'exclamation à la fin, tandis que le deuxième groupe en importance ajoute un point d'exclamation à la fin du message de salutation.

On pourrait produire une seule procédure avec tous les arguments :

greeting :: proc(name: string, language: Language, do_uppercase: bool, add_exclamation: bool) {
	...
}

Cela obligerait tous les utilisateurs à lire la documentation de tous les arguments et à toujours les renseigner.

Sans arguments par défaut, on pourrait aussi définir plusieurs procédures avec différents ensembles de paramètres :

greeting_common :: proc(name: string) {...}

greeting_with_exclamation :: proc(name: string) {...}

greeting_general :: proc(name: string, language: Language, do_uppercase: bool, add_exclamation: bool) {...}

// Odin supports overloading but it has to be explicitly defined
greeting :: proc {
	greeting_common,
	greeting_with_exclamation,
	greeting_general,
}

Si ton langage prend en charge les arguments par défaut, comme c'est le cas d'Odin, tu peux simplement donner des valeurs par défaut pertinentes aux arguments les moins utilisés. Les appelants peuvent omettre les arguments par défaut, ce qui fait que la procédure utilise les valeurs fournies, ou les remplacer.

greeting :: proc(name: string, language: Language = Language.English, do_uppercase : bool = false, add_exclamation: bool = false) {...}

// Note: because Odin supports type inference, we can simplify the interface.
greeting :: proc(name: string, language:= Language.English, do_uppercase := false, add_exclamation:= false) {...}

On peut appeler la procédure avec tous les arguments par défaut :

greeting("John Doe")

Les arguments importants pour l'appelant peuvent être remplacés :

greeting("John Doe", Language.Spanish)

Si les arguments dont tu as besoin se suivent dans l'ordre positionnel, comme dans l'exemple ci-dessus, il n'est pas nécessaire de les nommer comme dans l'exemple ci-dessus, mais si tu dois en sauter certains, tu dois alors nommer les arguments à partir du premier que tu as sauté.

greeting("John Doe", add_exclamation=true)

Gestion de la mémoire

Dans cet exercice, tu vas implémenter une procédure destinée à allouer la string qu'elle renvoie. La libération de la string incombe à l'appelant de la procédure.

// The procedure will be called like that:
str := two_fer("Alice")
// ...
// and eventually the caller will delete the string
delete(str)

Tu peux aussi consulter la documentation officielle d'Odin sur les arguments par défaut et les arguments nommés d'Odin.