Introdução ao Raku

Raku é uma linguagem de alto nível, uso geral e com tipagem gradual. Raku é multi paradigma. Ela suporta programação Procedural, Orientada a Objetos e Funcional.

Para instalar o Rakudo Star, execute os seguintes comandos no terminal:

For other options, go to https://rakudo.org/star/source

Quatro opções estão disponíveis:

Executar código Raku pode ser feito usando a REPL (Read-Eval-Print Loop). Para isso, abra um terminal, digite raku na janela do terminal e aperte [Enter]. Isso vai fazer com que um prompt de > apareça. Em seguida, digite uma linha de código e aperte [Enter]. A REPL vai exibir o valor daquela linha. Você pode então digitar outra linha, ou digitar exit e aperte [Enter] para sair da REPL.

Como alternativa, escreva seu código em um arquivo, salve e execute-o. É recomendado que programas em Raku sejam gravados em arquivos com a extensão .raku. Execute o arquivo digitando raku nomedoarquivo.raku na janela do terminal e apertando [Enter]. Ao contrário da REPL, isso não vai automaticamente imprimir o resultado de cada linha: o código precisa ter um comando say para imprimir coisas.

A REPL é usada principalmente para experimentar algum código específico, normalmente uma única linha. Para programas com mais de uma linha é recomendado escrever em um arquivo e executá-lo.

Linhas individuais também podem ser executadas de modo não interativo na linha de comando digitando raku -e 'seu código aqui' e apertando [Enter].

Como vamos passar um bom tempo escrevendo e gravando programas Raku em arquivos, é bom termos um editor de textos decente que reconheça a sintaxe do Raku.

Eu particularmente uso e recomendo o Atom. É um editor de textos moderno e já vem com reconhecimento de sintaxe em Raku. Raku-fe é um reconhecedor de sintaxe alternativo para o Atom, derivado do pacote original mas com muitas correções e adições.

Outras pessoas na comunidade também usam Vim, Emacs ou Padre.

Versões recentes do Vim já vem com reconhecimento de sintaxe. Emacs e Padre precisam da instalação de pacotes adicionais.

Vamos começar com o ritual alô mundo.

isso também pode ser escrito como:

Raku tem forma livre: Você tem liberdade (na maioria dos casos) para usar qualquer quantidade de espaços em branco.

Declarações são normalmente uma linha lógica de código, e terminam com um ponto-e-vírgula: say "Hello" if True;

Expressões são um tipo especial de declaração que retorna um valor: 1+2 retorna 3

Expressões são feitas por Termos e Operadores.

Termos são:

Operadores são classificados em tipos:

A tabela abaixo lista os operadores mais usados.

Adicionar um R antes de qualquer operador tem o efeito de inverter seus operandos.

Operadores de redução trabalham com listas de valores. Eles são formados colocando o operador entre colchetes []

Um scalar guarda um valor ou uma referência.

Um grupo específico de operações pode ser realizada em um scalar, dependendo do valor que ele armazena.

Arrays são listas contendo vários valores.

Muitas operações podem ser feitas em arrays como mostrado no exemplo abaixo:

.elems retorna o número de elementos em um array.
.push() adiciona um elemento no final do array.
Podemos acessar um elemento específico do array especificando sua posição, como @animals[0].
.pop remove o último elemento do array.
.splice(a,b) remove os b elementos que estão a partir da posição a.

Alguns métodos que podem ser chamados em hashes são:

.push: (chave => 'Valor') adiciona um novo par chave/valor.
.kv retorna uma lista contendo todas as chaves e valores.
.keys retorna uma lista contendo todas as chaves.
.values retorna uma lista contendo todos os valores.
Podemos acessar um valor específico no hash especificando sua chave %hash<chave>

Nos exemplos anteriores, nós não especificamos o tipo dos valores que as variáveis devem conter.

Como você pode ver no exemplo acima, o tipo do valor em $var foi primeiro (Str) e depois (Int).

Esse estilo de programação é chamado tipagem dinâmica. Dinâmico no sentido de que as variáveis podem conter valores de qualquer tipo.

Agora tente executar o seguinte exemplo:
Note o Int antes do nome da variável.

Ele vai falhar e retornar a mensagem de erro: Type check failed in assignment to $var; expected Int but got Str (Verificação de tipo falhou em atribuição a $var; esperava Int mas recebeu Str)

O que aconteceu foi que especificamos que aquela variável deve ser do tipo (Int). Quando tentamos atribuír uma (Str) nela, a operação falhou.

Esse estilo de programação é chamado tipagem estática. Estática no sentido de que o tipo das variáveis é definido antes das atribuições e não pode mudar.

Raku é classificado como uma linguagem com tipagem gradual; ela permite tanto tipagem estática quanto dinâmica.

Você provavelmente nunca usará os dois primeiros, mas eles foram listados para fins informacionais.

Introspec’ão é o processo de obter informações sobre as propriedades de um objeto, como seu tipo.
Em um dos exemplos acima usamos .WHAT para retornar o tipo de uma variável.

O tipo de uma variável armazenando determinado valor é correlacionado ao valor em si.
O tipo de uma variável vazia fortemente declarada é o tipo com que foi declarada.
O tipo de uma variável vazia que não foi fortemente declarada é (Any)
Para limpar o valor de uma variável, atribua Nil a ela.

Antes de usar uma variável pela primeira vez, ela precisa ser declarada.

Há muitas formas de se declarar variáveis em Raku, e my é a que utilizamos até agora em todos os exemplos acima.

O declarador my dá à variável um escopo léxico. Em outras palavras, a variável só será acessível no mesmo bloco em que foi declarada.

Um bloco em Raku é delimitado por { }. Se nenhum bloco é encontrado, a variável estará disponível em qualquer parte do programa Raku.

Como uma variável só pode ser acessada no bloco em que é definida, outra variável com o mesmo nome pode ser definida em outro bloco.

Vimos nos exemplos anteriores como atribuir valores a variáveis.
Atribuições são feitas usando o operador =.

Podemos mudar o valor atribuido a uma variável:

Por outro lado, não podemos mudar valores vinculados a uma variável.
Vinculação (ou "Binding") é feito usando o operador :=.

Vinculação de variáveis, como você já percebeu, é bidirecional.
$a := $b e $b := $a têm o mesmo efeito.

O código é executado somente se a condição foi atingida, ou em outras palavras se a expressão retornar True (verdadeiro).

Em Raku podemos inverter o código e a condição.
Mesmo se o código e a condição estiverem invertidos, a condição é sempre avaliada antes.

Se a condição não foi atingida, podemos especificar blocos com alternativas usando:

A negação de um if pode ser escrita usando unless.

O código a seguir:

pode ser escrito como:

Negação em Raku é feita usando ! ou not.

unless (condição) é usado em vez de if not (condição).

unless não pode ter bloco de else.

with funciona como um if, mas verifica se a variável está definida.

Se você executar o código acima sem atribuir um valor para a variável, o bloco não será executado.

without é a versão negada de with. É como a relação do if com o unless.

Se a primeira condição de um with não for atingida, uma alternativa pode ser especificada usando orwith.
with e orwith podem ser comparadas a if e elsif.

O laço for itera sobre vários valores.

Note que criamos uma variável de iteração $item para realizar a operação *100 em cada item do array.

given é o equivalente em Raku da função "switch" de outras linguagens.

Ao casar com uma condição, ele para de testar as outras condições.

Como alternativa, usar proceed vai instruir o Raku a continuar tentando casar com outras condições mesmo após a execução da condição atual.

loop é uma outra forma de fazer um laço do tipo for.

De fato, loop é como o for é escrito em linguagens da família do C.

Raku pertence à família de linguagens como C.

Duas sub-rotinas podem ser usadas para executar comandos externos:

echo e ls são palavras chave comuns de shell em Linux.
echo exibe texto no terminal (equivalente ao print no Raku)
ls lista todos os arquivos e diretórios no diretório atual

dir é o equivalente a ls no Windows.

Raku pode listar o conteúdo de um diretório sem precisar executar comandos da shell (usando ls) como visto em um exemplo anterior.

Você também pode criar e apagar diretórios.

mkdir cria um novo diretório.
rmdir remove um diretório vazio. Retorna erro se não estiver vazio.

Você também pode verificar se um determinado caminho existe, se é um arquivo ou um diretório:

No diretório onde você vai executar o script abaixo, crie um diretório vazio pasta123 e um arquivo vazio script123.raku

IO.e verifica se o diretório/arquivo existe.
IO.f verifica se o caminho é um arquivo.
IO.d verifica se o caminho é um diretório.

Sub-rotinas (também chamadas de subs ou funções) são formas de agrupar um conjunto de funcionalidades.

A definição de uma sub-rotina começa com a palavra-chave sub. Após sua definição, elas podem ser chamadas pelo nome.
Veja o exemplo abaixo:

O exemplo anterior mostra uma sub-rotina que não recebe nenhum dado de entrada.

Muitas sub-rotinas pedem alguma entrada para funcionar. Essa entrada é fornecida via argumentos. O número e tipo de argumentos que essa sub-rotina aceita é chamada de assinatura da sub-rotina.

A sub-rotina abaixo aceita uma string como argumento.

É possível definir várias sub-rotinas com o mesmo nome mas com assinaturas diferentes. Quando a sub-rotina é chamada, o ambiente de execução vai decidir qual versão usar dependendo do número e do tipo dos argumentos fornecidos. Esse tipo de subrotina é definido exatamente como uma sub normal, apenas trocando a palavra sub por multi.

Se uma sub-rotina é definida para aceitar um argumento, e fazemos a chamada sem fornecer o argumento, ela falha.

Como alternativa, o Raku nos dá a possibilidade de definir sub-rotinas com:

Argumentos opcionais são definidos colocando ? no final do nome do argumento.

Se o usuário não fornece o argumento, ele pode ser definido com um valor padrão específico.
Isso é feito atribuindo um valor ao argumento durante a definição da sub-rotina.

Todas as sub-rotinas que vimos até agora fazem alguma coisa, elas exibem algum texto no terminal.

Embora isso seja perfeitamente normal, às vezes queremos que a sub-rotina retorne um valor que possamos usar mais tarde no fluxo do nosso programa.

Em circunstâncias normais, a última linha de código de uma sub-rotina é considerada seu valor de retorno.

A medida que nosso código vai ficando maior, pode ser uma boa ideia especificar explicitamente o que queremos retornar. Isso pode ser feito usando a palavra-chave return.

Funções e sub-rotinas são cidadãs de primeira classe:

Um bom exemplo para demonstrar esse conceito é a função map.
map é uma função de ordem superior (higher-order function), que recebe outra função como argumento.

Definimos a sub-rotina chamada ao-quadrado, que vai elevar a 2 qualquer número fornecido como argumento.
Depois, usamos map uma função de ordem superior, e passamos dois argumentos, uma sub-rotina e um array.
O resultado é uma lista com todos os elementos do array elevados ao quadrado.

Note que ao passar uma sub-rotina como argumento, precisamos prefixar seu nome com &.

Todos os objetos no Raku são closures, o que significa que eles podem referenciar variáveis léxicas de escopos externos.

Uma função anônima também é chamada de uma lambda.
Uma função anônima não está associada a um identificador (ela não tem nome).

Vamos reescrever o exemplo do map usando uma função anônima

Note que em vez de declarar a sub-rotina e passá-la como argumento ao map, nós a definimos diretamente dentro do map.
A sub-rotina anônima -> $x {$x ** 2} não possui handle e não pode ser chamada.

No linguajar Raku chamamos essa notação de pointy block (bloco pontiagudo)

Em Raku, métodos podem ser encadeados, você não precisa mais passar o resultado de um método para outro como argumento.

Vamos imaginar que você recebey um array de valores. Pediram para que você retorne os valores únicos desse array, ordenados do maior para o menor.

Você pode tentar resolver esse problema escrevendo algo como isso:

Primeiro chamamos a função unique em @array, então passamos o resultado como argumento para sort e depois passamos o resultado da ordenação para reverse.

Em contraste com o exemplo acima, o encadeamento de métodos é permitido em Raku.
O exemplo acima pode ser escrito como a seguir, tirando vantagem do encadeamento de métodos (method chaining):

É fácil perceber que encadeamento de métodos é mais agradável aos olhos.

O operador de alimentação, chamado de pipe em algumas linguagens de programação funcional, permite uma visualização ainda melhor do encadeamento de métodos.

Como você pode ver o fluxo das chamadas é de cima para baixo.

A alimentação para trás é como a alimentação para frente, mas escrita ao contrário.
O fluxo das chamadas é de baixo para cima.

O hiperoperador (hyper operator) >>. chama um método em todos os elementos de uma lista e retorna uma lista com todos os resultados.

Usando o hiperoperador podemos chamar métodos já definidos no Raku, como is-prime que nos diz se um número é primo ou não.
Além disso podemos definir novas sub-rotinas e chamá-las usando o hiperoperador. Nesse caso precisamos prefixar um & ao nome do método. Por exemplo, &é-par

Isso é muito prático pois nos poupa de ter que escrever loops for para iterar sobre cada valor de um array.

Uma junction é uma sobreposição lógica de valores.

No exemplo abaixo 1|2|3 é uma junction.

O uso de junctions normalmente ativa autothreading; a operação é executada para cada elemento da junction, e todos os resultados são combinados em uma nova junction e retornados.

Uma lista preguiçosa (lazy) é uma lista que é avaliada de forma preguiçosa.
Avaliação preguiçosa atrasa a avaliação de uma expressão até ela ser necessária, e evita repetir avaliações armazenando resultados em uma tabela de referência.

Os benefícios incluem:

Para construir uma lista preguiçosa usamos o operador infixo …​
Uma lista preguiçosa tem elementos iniciais, um gerador e um final (endpoint).

O elemento inicial é 1 e o final é 10. Nenhum gerador foi definido então o gerador padrão é o sucessor (+1)
Em outras palavras essa lista preguiçosa pode retornar (se pedido) os seguintes elementos (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

Essa lista pode retornar (se pedido) qualquer inteiro entre 1 e infinito, em outras palavras qualquer número inteiro.

Os elementos iniciais são 0 e 2 e o final é 10. Nenhum gerador foi definido, mas usando os elementos iniciais, Raku vai deduzir que o gerador é (+2)
Essa lista preguiçosa pode retornar (se pedido) os seguintes elementos (0, 2, 4, 6, 8, 10)

Nesse exemplo, definimos explicitamente um gerador entre { }
Essa lista preguiçosa pode retornar (se pedido) os seguintes elementos (0, 3, 6, 9, 12)

Orientação a Objetos é um dos paradigmas mais utilizados hoje em dia.
Um objeto é um conjunto de variáveis e sub-rotinas agrupadas.
As variáveis são chamadas atributos e as sub-rotinas são chamadas métodos.
Atributos definem o estado de um objeto e métodos definem seu comportamento.

Uma classe define a estrutura de um grupo de objetos.

Para entender esse relacionamento considere o exemplo abaixo:

No linguajar de orientação a objetos, dizemos que objetos são instâncias de uma classe.

Considere o script abaixo:

A palavra-chave class é usada para definir uma classe.
A palavra-chave has é usada para definir atributos de uma classe.
O método .new() é chamado de construtor. Ele cria um objeto como uma instância da classe que o chamou.

O script acima, uma nova variável $joão guarda uma referência para uma nova instância de "Humano" definida por Humano.new().
Os argumentos passados para o método .new() são usados para dar valores aos atributos do novo objeto.

Podemos dar escopo léxico a uma classe usando my:

Encapsulamento é um conceito de orientação a objetos que agrupa um conjunto de dados e métodos.
Os dados (atributos) dentro de um objeto devem ser privados. Em outras palavras, acessíveis somente de dentro do objeto.
Para acessar os atributos de fora do objeto usamos métodos que chamamos de acessores (ou accessors, em inglês).

Os dois scripts abaixo fazem a mesma coisa.

O método sayvar é um accessor. Ele nos permite acessar o valor de uma variável de forma indireta.

Encapsulamento é facilitado em Raku pelo uso dos twigils.
Twigils são sigils (símbolos) segundários. Eles vem entre o símbolo da variável e o nome do atributo.
Dois twigils são usados em classes:

Por padrão, todos os atributos são privados, mas é considerado boa prática sempre usar o twigil !.

Considerando isso, deveríamos reescrever a classe acima de outro jeito:

Adicione ao final desse script a declaração: say $joão.idade;
Ela vai retornar o seguinte erro: Method 'idade' not found for invocant of class 'Humano' ("Método 'idade' não encontrado para classe invocante 'Humano'")
A razão é que $!idade é privado e só pode ser usado de dentro do objeto. Tentar acessar atributos privados de fora do objeto vai retornar um erro.

Agora substitua has $!idade por has $.idade e veja o resultado de say $joão.idade;

Em Raku, todas as classes herdam o construtor padrão .new().
Ele pode ser usado para criar objetos chamando-o com alguns argumentos.
O construtor padrão só aceita argumentos por nome.
Considerando o exemplo acima, repare que todos os argumentos passados para .new() são definidos pelo próprio nome:

E se não quiséssemos passar o nome de cada atributo ao criar um novo objeto?
Para isso precisamos criar um outro construtor que aceite argumentos por posição.

Atributos de Classe são atributos que pertencem à própria classe e não aos seus objetos.
Eles podem ser inicializados durante a definição.
Atributos de Classe são declarados com my em vez de has.
Eles são chamados na classe em si em vez de nos objetos.

Até agora todos os exemplos que vimos usaram accessors para obter informações dos atributos de objetos.

E se quiséssemos modificar o valor de um atributo?
Precisamos classificar o atributo como leitura/escrita (read/write) usando as palavras-chave is rw

Por padrão, todos os atributos são declarados como somente leitura mas você pode fazer isso de forma explícita usando is readonly

Herança múltipla é permitida em Raku. Uma classe pode herdar de várias outras classes.

A classe gráfico-combinado é capaz de guardar duas séries, uma para os valores reais em barra, e outra para valores previstos em linha.
Por isso que o definimos como filho de gráfico-de-linhas e gráfico-de-barras.
Você deve ter reparado que chamar o método exibir em gráfico-combinado não gerou o resultado desejado. Só uma das séries foi exibida.
Por que isso aconteceu?
gráfico-combinado herdou de gráfico-de-linhas e de gráfico-de-barras, e ambos possuem um método chamado exibir. Quando chamamos esse método em gráfico-combinado o Raku vai tentar resolver esse conflito chamando um dos métodos herdados.

Para que se comporte corretamente, devemos sobrescrever o método exibir em gráfico-combinado.

Roles (Papéis) são parecidos com classes no sentido de que são uma coleção de atributos e métodos.

Roles são declarados com a palavra-chave role e classes que quiserem implementar o role (o papel) podem fazer isso usando a palavra-chave does (faz).

Execute o script acima e você verá que o resultado é o mesmo.

Agora você deve estar se perguntando; se roles se comportam igual a classes, qual o seu propósito?
Para responder essa pergunta modifique o primeiro script usado para demonstrar herança múltipla, aquele em que esquecemos de sobrescrever o método exibir.

Se múltiplos roles são aplicados à mesma classe, e um conflito surge, um erro em tempo de compilação será gerado.
Essa é uma abordagem muito mais segura que herança múltipla onde conflitos não são considerados erros e são simplesmente resolvidos em tempo de execução (runtime).

Roles vão te avisar quando houver um conflito.

Introspecção é o processo de obter informação sobre as propriedades de um objeto como seu tipo, seus atributos ou seus métodos.

Introspecção é facilitada por:

Exceções são um comportamento especial que acontece durante a execução quando algo dá errado.
Dizemos que as exceções são lançadas (thrown).

Considere o script abaixo que roda corretamente:

Agora considere esse script que lança uma exceção:

Você deve ter percebido que sempre que um erro ocorre (nesse caso, atribuir um número a uma variável de string) o programa vai parar e outras linhas de código não serão avaliadas, mesmo que estejam corretas.

Tratamento de exceções é o processo de capturar uma exceção que foi lançada para que o script continue funcionando.

Tratamento de exceções é feito usando um bloco try-catch.

O bloco CATCH pode ser definido da mesma forma que um bloco given. Isso significa que podemos capturar e tratar de forma diferente muitos tipos de exceção.

Assim como capturar exceções, Raku também permite que você explicitamente lance exceções.
Dois tipos de exceções podem ser lançados:

Exceções ad-hoc são lançadas usando a sub-rotina die seguido da mensagem de exceção.

Exceções tipadas são objetos, por isso o uso do construtor .new() no exemplo acima.
Todas as exceções tipadas descendem da classe X, abaixo seguem alguns exemplos:
X::AdHoc é o tipo mais simples de exceção
X::IO é para exceções relacionadas a erros de IO
X::OS é para erros do sistema operacional (OS)
X::Str::Numeric é relacionada a errors tentando converter strings em números

Uma expressão regular pode ser definida da seguinte maneira:

A menos que você peça explicitamente, espaços em branco são irrelevantes, m/ilumina/ e m/ ilumina / são iguais.

Caracteres alfanuméricos e o underscore _ são escritos normalmente.
Todos os outros caracteres precisam ser escapados usando contrabarra ou colocados entre aspas.

Caracteres podem ser classificados em categorias que podemos usar para casar.
Também podemos casar com o inverso daquela categoria (tudo menos ela):

Casar contra categorias de caracteres como vimos na seção anterior é conveniente.
Dito isso, uma abordagem mais sistemática seria utilizarmos propriedades Unicode.
Propriedades Unicode são definidas entre <: e >

Curingas também podem ser usados em uma regex.

O ponto . casa com qualquer caractere simples.

Quantificadores vem depois de um caractere e são usados para especificar quantas vezes o esperamos.

A interrogação ? significa zero ou uma vez.

O asterisco * significa zero ou mais vezes.

O + significa pelo menos uma vez.

Sempre que casamos uma string com uma regex, o resultado é armazenado na variável especial $/

$/ retorna um Objeto de Match (a string que casa com a regex)
Os seguintes métodos podem ser chamados no Objeto de Match:
.prematch retorna a string que precede a sequência casada.
.postmatch retorna a string que sucede a sequência casada.
.from retorna a posição na string em que a sequência casada começa.
.to retorna a posição na string em que a sequência casada termina.

Vamos verificar se um email é válido ou não.
Para esse exemplo vamos assumir que um email válido é formado por:
primeiro nome [ponto] último nome [arroba] empresa [ponto] (com/org/net)

mario.silva@raku.org é um email válido

<:L> casa com uma letra
<:L>` casa com uma ou mais letras + `\.` casa com um caractere de [ponto] + `\@` casa com um caractere de [arroba] + `<:L:N> casa com uma letra e um número
<:L+:N>+ casa com uma ou mais (letras e números)

Essa regex pode ser decomposta da seguinte forma:

Uma regex rotulada é definida usando a seguinte sintaxe: my regex nome-da-regex { definição da regex }
Uma regex rotulada pode ser chamada usando a seguinte sintaxe: <nome-da-regex>

MD5 é uma função de hash criptográfico que produz um valor de 128 bits.
MD5 tem uma variedade de aplicações como o armazenamento de senhas em um banco de dados. Quando um usuário se cadastra, suas credenciais não são armazenadas em texto puro e sim na forma de um hash. O raciocínio por trás disso é que se o banco de dados for comprometido, quem fez o ataque não conseguirá descobrir as senhas de acesso.

Digamos que você precise de um script que gere um hash MD5 de uma senha antes de guardá-la no banco de dados.

Felizmente existe um módulo em Raku que já implementa o algoritmo MD5. Vamos instalá-lo:
zef install Digest::MD5

Agora execute o script abaixo:

Para executar a função md5_hex() que cria os hashes MD5, precisamos carregar o módulo relacionado.
A palavra-chave use carrega o módulo para ser usado no script.

As 3 linhas acima mostram formas diferentes de se construir o mesmo caractere:

A letra á pode ser escrita:

NFC retorna o code point único.
NFD decompõe o caractere e retorna o code point de cada parte.
uniname retorna o nome do code point.

Em circunstâncias normais, todas as tarefas de um programa executam em sequência.
Isso pode não ser um problema, a menos que o que esteja tentando fazer consuma muito tempo.

Raku possui recursos que permitem que você execute tarefas em paralelo.
Nesse ponto, é importante notar que paralelismo pode significar uma dessas duas coisas:

Vamos começar pelo segundo.