Two Fer

Instruções

A tua tarefa é decidir o que vais dizer quando deres a bolacha extra.

Se souberes o nome da pessoa (por exemplo, se a pessoa se chamar Do-yun), vais dizer:

One for Do-yun, one for me.

Se não souberes o nome da pessoa, dizes you em vez do nome.

One for you, one for me.

Aqui estão alguns exemplos:

Instruções específicas do Odin

O Odin suporta argumentos por omissão. Os argumentos por omissão são uma funcionalidade útil que permite chamar um procedimento com diferentes conjuntos de parâmetros, para casos de uso em que precisas de APIs relacionadas, mas diferentes.

Sem argumentos por omissão, podes acabar com uma explosão do número de procedimentos necessários para a tua API. As linguagens que não suportam argumentos por omissão, como o Java, recorrem à sobrecarga de métodos para obter o mesmo efeito (com mais código) ou têm de fornecer procedimentos com um conjunto de argumentos potencialmente grande.

Vamos ver o exemplo de um procedimento greeting em que queremos poder especificar a linguagem, se o nome fica em maiúsculas e se devemos incluir um ponto de exclamação no fim da saudação. Depois de alguma análise, concluímos que o maior grupo de utilizadores especifica o inglês como linguagem, não põe o nome em maiúsculas e não quer um ponto de exclamação no fim; o segundo maior grupo acrescenta um ponto de exclamação no fim da saudação.

Podíamos criar um único procedimento com todos os argumentos:

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

Isto obrigaria todos os utilizadores a ler a documentação de todos os argumentos e a preenchê-los sempre.

Sem argumentos por omissão, também podíamos definir vários procedimentos com conjuntos de parâmetros diferentes:

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,
}

Se a tua linguagem suportar argumentos por omissão, como o Odin, basta fornecer valores por omissão sensatos aos argumentos menos usados. Quem chama pode omitir os argumentos por omissão, fazendo com que o procedimento use os valores por omissão fornecidos, ou substituí-los.

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) {...}

O procedimento pode ser chamado apenas com os argumentos por omissão:

greeting("John Doe")

Os argumentos importantes para quem chama podem ser substituídos:

greeting("John Doe", Language.Spanish)

Se os argumentos de que precisas estiverem na ordem posicional, como no exemplo acima, não é preciso nomeá-los, mas se tiveres de saltar alguns, tens de nomear os argumentos a partir do primeiro que saltaste.

greeting("John Doe", add_exclamation=true)

Gestão de memória

Neste exercício vais implementar um procedimento cujo objetivo é alocar a string que devolve. A libertação da string é da responsabilidade de quem chama o procedimento.

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

Também podes ter interesse na documentação oficial do Odin sobre argumentos por omissão e argumentos nomeados do Odin.