Um bloco é um pedaço de código que pode ser passado a um método.
Noutras linguagens de programação, isto é conhecido como função anónima ou lambda.
Um método pode converter um bloco num Proc, que representa um bloco de código.
def my_method(&block)
1 + yield
end
my_method { 2 }
# => 3
Blocos e Procs são muito usados em Crystal, por exemplo para iteração e callbacks.
Mas também para criar DSLs (linguagens específicas de domínio); alguns exemplos de DSLs são o framework web Kemal ou o framework de testes Spec (que é o que se usa para testar as tuas soluções em Crystal).
Blocos
Para criar um método que aceita um bloco, tens de acrescentar um e comercial (&) antes do último argumento.
Isto converte o bloco num Proc e atribui-o ao argumento.
Depois, usar yield executa o bloco que foi dado ao método.
def my_method(&block)
1 + yield
end
Há duas formas de passar um bloco: com as palavras-chave do ... end ou com chavetas ({}).
A principal diferença entre as duas é a precedência: o do ... end suporta blocos com várias linhas, enquanto as chavetas ({}) não.
my_method do
2
end
# => 3
my_method { 2 }
# => 3
Yield
yield é uma palavra-chave que executa o bloco dado ao método.
Isto significa que o bloco nunca será executado se o yield não for chamado.
Também se lhe podem dar argumentos, que são passados ao bloco.
Não há limite para o número de argumentos que podem ser passados ao bloco.
Para usares os argumentos no bloco, usas a sintaxe |x, y, ...|.
Aqui, x, y, ... são os nomes dos argumentos.
def my_method(&block)
1 + yield 2
end
# With curly braces:
my_method { |x| x * 3 }
# => 7
# With do ... end:
my_method do |x|
x * 3
end
# => 7
No exemplo acima, o bloco recebe o argumento 2, multiplica-o por 3 e devolve 6.
Depois, o método soma 1 ao resultado e devolve 7.
Se o número de argumentos dados ao yield for maior do que o número de argumentos que o bloco espera, é lançado um erro.
def my_method(&block)
1 + yield
end
my_method { |x| x * 3 }
# Error: too many block parameters (given 1, expected maximum 0)
Tipos de blocos
Os blocos podem ser escritos de forma explícita ou implícita.
Os blocos implícitos são os mais comuns e são os que aparecem nos exemplos acima.
Podes até dar ao bloco argumentos de tipos diferentes: o compilador infere os tipos e cria um tipo de união.
def my_method(&block)
yield "a"
yield 1
end
my_method do |x|
p typeof(x)
end
# output: (String | Int32)
Ao escreveres blocos explícitos, podes especificar os tipos dos argumentos e o tipo devolvido.
Faz-se isso com a sintaxe Arg1Type, Arg2Type, ... -> ResultType.
Aí, os argumentos são separados por vírgulas (,) e o tipo do resultado é separado por ->.
def my_method(&block : Int32, Int32 -> Int32)
1 + yield(2, 3)
end
my_method { |x, y| x * y }
# => 7
Tal como acontece com outros tipos explícitos, o compilador verifica se os tipos são os esperados.
Se o bloco não corresponder ao tipo indicado no método, é lançado um erro.
Procs
O Proc tem uma ligação muito forte aos blocos.
A diferença essencial é que um Proc é um tipo e um bloco não.
Um Proc representa um ponteiro para função e pode ser passado como uma variável.
Para definires um Proc, usas a sintaxe do literal de proc ->(args) { ... }.
Os argumentos são separados por vírgulas (,) e o bloco por { ... }.
Para invocares um Proc, usas o método call e passas-lhe os argumentos.
Os tipos dos parâmetros são obrigatórios.
O tipo devolvido é inferido a partir do corpo do proc, mas também pode ser indicado de forma explícita.
my_proc = ->(x : Int32, y : Int32) : Int32 { x * y }
my_proc.call(2, 3)
# => 6
Capturar blocos
Capturar blocos é uma forma de criar um Proc a partir de um bloco.
Faz-se isso com o operador & antes do último argumento de um método.
Isso converte o bloco num Proc e atribui-o ao argumento.
def my_method(&block)
block.call
end
my_method { 1 + 2 }
# => 3
Passar procs a métodos
Os procs podem ser passados a métodos que esperam um bloco.
Isto pode ser útil quando queres poder passar blocos diferentes consoante uma condição.
def my_method(&block)
yield 5
end
my_proc = -> (x) { x * 2 }
my_method(&my_proc)
# => 10
Declarar o tipo das variáveis
Ao declarares uma variável, podes usar a sintaxe : Type para declarar o tipo da variável.
Para os procs, usas a sintaxe Proc((ArgType, ...), ResultType).
O último tipo é sempre o tipo devolvido e os restantes são os tipos dos argumentos.
Ou seja, se houver apenas um tipo, este é o tipo devolvido e o proc não recebe argumentos.
my_proc : Proc(Int32, Int32, Int32) = ->(x, y) { x * y }
other_proc : Proc(Int32) = -> { 1 }
Exercício de aprendizagem
