Two Fer

Instruções

Sua tarefa é decidir o que você vai dizer ao entregar o biscoito extra.

Se você souber o nome da pessoa (por exemplo, se ela se chama Do-yun), você vai dizer:

One for Do-yun, one for me.

Se você não souber o nome da pessoa, você vai dizer you no lugar.

One for you, one for me.

Aqui estão alguns exemplos:

Instruções específicas do Odin

Odin dá suporte a argumentos padrão. Argumentos padrão são um recurso útil que permite chamar um procedimento com diferentes conjuntos de parâmetros, para casos em que você precisa de APIs relacionadas, mas diferentes.

Sem argumentos padrão, você pode acabar com uma explosão no número de procedimentos exigidos pela sua API. Linguagens que não dão suporte a argumentos padrão, como Java, contam com a sobrecarga de métodos para obter o mesmo efeito (com mais código) ou precisam fornecer procedimentos com um conjunto de argumentos que pode ser grande.

Vamos ver o exemplo de um procedimento greeting em que queremos poder especificar o idioma, se o nome está em maiúsculas e se devemos incluir um ponto de exclamação no final da saudação. Depois de alguma análise, descobrimos que o maior grupo de usuários especifica o inglês como idioma, não coloca o nome em maiúsculas e não quer um ponto de exclamação no final, e que o segundo maior grupo adiciona um ponto de exclamação no final da saudação.

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

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

Isso obrigaria todos os usuários a ler a documentação de todos os argumentos e sempre preenchê-los.

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

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 sua linguagem dá suporte a argumentos padrão, como o Odin, você pode simplesmente fornecer padrões razoáveis para os argumentos menos usados. Quem chama pode omitir os argumentos padrão, fazendo com que o procedimento use os padrões fornecidos, ou sobrescrevê-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 com todos os argumentos padrão:

greeting("John Doe")

Os argumentos importantes para quem chama podem ser sobrescritos:

greeting("John Doe", Language.Spanish)

Se os argumentos de que você precisa estão em ordem posicional, como no exemplo acima, não há necessidade de nomeá-los como no exemplo acima, mas se você precisar pular alguns, então precisa nomear os argumentos depois do primeiro que pulou.

greeting("John Doe", add_exclamation=true)

Gerenciamento de memória

Neste exercício, você vai implementar um procedimento que deve alocar a string que retorna. Liberar a string é 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)

Você também pode se interessar pela documentação oficial do Odin sobre argumentos padrão e argumentos nomeados do Odin.