Você conhece APL?
Tags: apl, programming, tutorial, uncommon
Published: 2022-06-14 21:43:46

> AVISO! Esse artigo contém exemplos de código. Se você quiser rodá-los, copie e cole as linhas **identadas à direita** (as linhas identadas à esquerda são os resultados) nesse site: https://tryapl.org
 
APL é uma linguagem com certeza mais velha que muitos dos desenvolvedores de hoje em dia. Criada em 1966 por Kenneth E. Iverson, é uma das linguagens mais antigas ainda em uso hoje (mais velha que C, a propósito, e do que B também!).
Olhando um código APL, no entanto, você pode ter várias sensações. Uma comum é de que existe algum problema de encoding te impedindo de ler o que está escrito. De qualquer maneira, sua sintaxe não se parece nada com as linguagens de sua época, ou de hoje em dia.
Exemplo de programa em APL:

```
⍝ média aritmética de uma lista
(+/÷≢)w
```

Esse é um programa que te retorna a média aritmética de uma lista (`w` é a lista).
Mas, cadê o loop para somar todos os elementos? E a divisão dessa soma pelo tamanho da lista?

Essa é a magia de APL. Originalmente significando "A Programming Language", nome inspirado no livro que a introduziu, teve seu nome ressignificado para "Array Programming Language", justamente porque suas construções funcionam com dados de qualquer dimensão.

Opa, pera, mas como assim dimensão? Vem comigo!

Mas antes, um porém sobre a interpretação dos símbolos. Ao contrário da maior parte das linguagens de programação, APL é interpretada da direita para a esquerda.

Ou seja, a expressão `10 - 5 - 2`, em matemática tradicional, resultaria em 3. Mas em APL
```
      10 - 7 - 2
5
```
Porque primeiro foi computado `7 - 2`, resultando em 5, e depois `10 - 5`, resultando também em 5.

Agora sobre as dimensões.

### Dimensões
Vejamos uma variável aqui

```
      ⍝ definindo uma variável
      a←2
      a
2
```
(ah, sim, variáveis não recebem seu valor usando `=`, mas sim usando `←`. Você acostuma rápido)

A variável `a` tem uma dimensão de 0, porque é um valor único. Você pode verificar a dimensão de uma variável usando `⍴⍴` (não são duas letras 'p', mas sim duas letras gregas rô).

```
      ⍝ número de dimensões de uma variável escalar
      ⍴⍴a
0
```
Se fosse uma lista, a dimensão seria 1.
```
      ⍝ número de dimensões de uma lista
      a←1 2 3 4 5
      ⍴⍴a
1
```
Beleza. Agora vamos somar dois valores escalares, nome de valores de dimensão 0, e duas listas (dimensão 1).
```
      ⍝ soma entre dois escalares e duas listas
      a←1
      b←2
      a+b
3
      a←1 2 3 4 5
      b←6 7 8 9 10
      a+b
7 9 11 13 15
```
Note que a sintaxe é a mesma para somar escalares ou listas.
É sobre isso que falo quando digo que as construções de APL são feitas para funcionar com diferentes dimensões. Por isso o exemplo da média aritmética acima não precisa de loop. O loop é intrínseco à linguagem.

### Tá, mas e daí?
Claro, é muito legal isso, mas e daí? Por que eu usaria essa linguagem quando eu poderia fazer a mesma coisa com outra?

Há uma série de vantagens em usar APL, principalmente se você precisa lidar com muitos dados (arrays).

Vamos pegar um exemplo do [Advent of Code de 2021](https://adventofcode.com/).
Se você quiser ler todo o problema, accesse [aqui](https://adventofcode.com/2021/day/1)

**Problema**
Há uma lista de leituras de profundidade do oceano e você precisa contar quantas vezes a profundidade aumenta. Ou seja, das leituras, deve-se contar toda vez que uma leitura é maior que a anterior.

Vamos fazer uma solução em Java (sem todo o boilerplate, embora ele exista)

```
public int contarDescidas(int[] leituras) {
    int leituraAnterior = 0;
    int totalDescidas = 0;
    for(int i = 0; i < leituras.length; i++) {
        if(leituras[i] > leituraAnterior) {
            totalDescidas++;
        }
        leituraAnterior = leituras[i];
    }
    return totalDescidas;
}
```

Agora em APL

```
{+/0>2-/⍵}leituras
```

Isso que eu nem me preocupei em como os dados seriam de fato lidos, o que é toda uma parada complicada no Java, e em APL é isso aqui
```
leituras←⍎⍤1⊢↑⊃⎕NGET'arquivo'1
```
Parece complicado mas é muito claro quando se conhece o que cada símbolo faz.

### Conclusão
O objetivo desse artigo foi dar um gostinho do que APL é capaz. Eu não tenho nem de longe a expertise de outras pessoas que podem falar mais sobre essa linguagem.

Uma delas é o Rodrigo Girão Serrão. Ele é um desenvolvedor português que está trabalhando para reescrever o livro "Mastering Dyalog APL" (Dyalog APL é uma implementação da linguagem). O canal dele no YouTube é [esse aqui](https://www.youtube.com/channel/UCd_24S_cYacw6zrvws43AWg)
O canal code_report também faz vídeos comparando APL com outras linguagens. Link [aqui](https://www.youtube.com/c/codereport/).

Se você quiser já mergulhar no mundo da APL, pode ler online de maneira gratuita o livro "Mastering Dyalog APL", a [versão antiga](https://www.dyalog.com/uploads/documents/MasteringDyalogAPL.pdf) ou a [versão nova](https://mastering.dyalog.com/README.html) (ainda em fase de desenvolvimento).

É isso então. Espero que vocês tenham gostado. Até mais!