Nesta nova série, vamos estudar a nova linguagem de programação da Apple, a Swift. Não é necessária nenhuma experiência anterior em tecnologias Apple, mas é preciso ter o mais recente Mac OSX e Xcode 6.0.1 ou superior instalados para conseguir acompanhar.

Confira o artigo anterior neste link.

Definindo funções

Swift é uma linguagem orientada a objetos construída com base em Objective-C e C++, mas também mistura técnicas de funções e programação funcional. É um pouco como Scala, mas Swift vai ser um sucesso real.

Na Swift, as funções podem ser criadas e atribuídas a variáveis, da mesma forma que acontece com JavaScript. Porém, diferentemente de JS, Swift usa a palavra-chave func para introduzir uma função.

$ swift
Welcome to Swift!  Type :help for assistance.
  1> func helloWorld() {
  2.     println("Hello World")
  3. }
  4> helloWorld()
Hello World

Assim como em outras linguagens, as variáveis definidas dentro de um bloco de uma função terão o mesmo tempo de vida da função daquela função:

  5> func helloWorld() {
  6.     let name = "World"
  7.     println("Hello \(name)")
  8. }
  9> helloWorld()
Hello World
 10> name
error: use of unresolved identifier 'name'

Swift tem argumentos posicionais (positional), nomeados (named) e padrão (default). Eles são especificados entre parênteses e com vírgulas para separar. Diferentemente das variáveis (que usam inferência de tipo para determinar qual é o tipo correto), argumentos de função devem ser tipados.

 11> func hello(name:String) {
 12.     println("Hello, \(name)")
 13. }
 14> hello("World")
Hello, World

Argumentos padrão (default) podem ser declarados ao se colocar um valor padrão depois:

 15> func greet(name:String, greeting:String = "Hello") {
 16.     println("\(greeting), \(name)")
 17. }
 18> greet("World")
Hello, World
 19> greet("World", "Hi")
error: missing argument label 'greeting:' in call

Esse erro ocorre porque argumentos padrão são, implicitamente, argumentos nomeados. Um argumento nomeado é aquele que deve ser chamado por um nome em vez de por sua posição. Nomes são especificados com o mesmo rótulo da função nome:

 20> greet("World", greeting:"Hi")
Hi, World

No entanto, argumentos nomeados não precisam ter um valor padrão. Eles podem ser declarados como argumentos nomeados ao se colocar o rótulo na frente do argumento. Argumentos nomeados geralmente possuem um “nome externo”, que é o nome que os callers devem usar para suprir a função, e um “nome interno” que é usado na implementação do corpo em si. Isso permite que as funções sejam refatoradas sem afetar a API:

 21> func greet(name:String, greeting salutation:String = "Hi") {
 22.     println("\(salutation), \(name)")
 23. }
 24> greet("World", greeting:"Yello")
Yello, World

Como um atalho especial, é possível declarar que um argumento pode ser nomeado com o mesmo nome que um argumento nomeado, usando o símbolo #.

 25> func greet(#name:String, #greeting:String) {
 26.     println("\(greeting), \(name)")
 27. }
 28> greet(name:"World", greeting:"Hello")

Observe que, apesar de os argumentos serem nomeados, eles têm uma ordem implícita. Não é possível descartar os argumentos ou reordená-los, como se faz em outra linguagem com argumentos nomeados:

 29> greet(greeting:"Hello", name:"World")
error: argument 'name' must precede argument 'greeting'
greet(greeting:"Hello", name:"World")
      ~~~~~~~~~~~~~~~~  ^    ~~~~~~~

Nota: O report de erros no Swift é realmente muito bom. Os gráficos ASCII no final destacam expressões errôneas (o pedaço em parênteses) e o caractere (^) mostra onde o erro foi encontrado. Isso é especialmente útil no REPL, onde não há um código-fonte definido ou linhas numeradas.

Argumentos nomeados são um retorno a Objective-C, e permitem que a Swift interopere com classes Objective-C (veremos sobre isso em artigos futuros). Em alguns poucos casos, eles podem fazer uma API mais clara, mas em muitos casos adicionam ruído extra onde não é necessário.

Por fim, tipos e valores de retorno. Assim como em outras linguagens, a palavra-chave return é usada para retornar de uma função e passar de volta um valor. Assim como acontece com argumentos, o tipo de retorno da função deve ser especificado (o padrão é não ter tipo de retorno se não houver a especificação), exceto se em vez de usar o :syntax, ele inventar um news -> syntax. Esse é um dos muitos contratempos da linguagem, onde não há consistência porque ainda não foi escrito código suficiente para esses casos específicos.

 29> func add(i:Int, j:Int) -> Int {
 30.     return i+j
 31. }
 32> add(1,2)
$R0: Int = 3

No próximo artigo, veremos como criar classes na Swift. Até lá.

***

Artigo traduzido pela Redação iMasters com autorização do autor. Publicado originalmente em http://alblue.bandlem.com/2014/09/swift-functions-overview.html