Sugestões da boutique

Quem já usou Python quase certamente já usou compreensões de listas, que são parte central da sintaxe do Python desde as primeiras versões.

Algo tão conveniente acaba, aos poucos, chegando a outras linguagens, inclusive Julia.

Para quem programa em Julia, as compreensões são uma opção, não uma necessidade, já que geralmente existem alternativas (broadcasting, funções de ordem superior etc.).

No entanto, uma compreensão muitas vezes oferece uma forma simples, legível e eficiente de construir um array. No fim, usá-las é uma questão de gosto pessoal, e de como você se sente em relação a Python versus linguagens funcionais.

A sintaxe é, em grande parte, uma cópia direta do Python, mas com extensões para arrays de dimensões maiores.

Uma única variável

Bem ao estilo Python, incluindo a cláusula if opcional.

julia> [x^2 for x in 1:3]
3-element Vector{Int64}:
 1
 4
 9
julia> [x^2 for x in 1:3 if isodd(x^2)]
2-element Vector{Int64}:
 1
 9

O formato da saída depende dos detalhes da compreensão: normalmente é igual ao da coleção de entrada em casos simples, mas é achatado para um Vector por uma cláusula if.

julia> m
2×3 Matrix{Int64}:
 1  2  3
 4  5  6
julia> [x^2 for x in m]
2×3 Matrix{Int64}:
  1   4   9
 16  25  36
julia> [x^2 for x in m if isodd(x^2)] 
3-element Vector{Int64}:
  1
 25
  9

Múltiplas variáveis, saída em Vector

Assim como em Python, podemos ter várias cláusulas for com variáveis diferentes, usando a mesma coleção de entrada ou coleções diferentes.

julia> [x * y for x in 1:3 for y in 4:6]
9-element Vector{Int64}:
  4
  5
  6
  8
 10
 12
 12
 15
 18
julia> [x * y for x in 1:3 for y in 4:6 if isodd(x * y)]
2-element Vector{Int64}:
  5
 15

Isso equivale a laços aninhados. A saída é unidimensional, mesmo com uma matriz na entrada.

julia> m
2×3 Matrix{Int64}:
 1  2  3
 4  5  6
julia> [x*y for x in m for y in m]
36-element Vector{Int64}:
  1
  4
  2
  5
(truncated output...)

Múltiplas variáveis, saída multidimensional

A seção anterior mostrou várias cláusulas for separadas apenas por espaços.

Nesta seção, há um único for e as variáveis são separadas por vírgulas.

julia> [(x, y) for x in 1:3, y in 4:6]
3×3 Matrix{Tuple{Int64, Int64}}:
 (1, 4)  (1, 5)  (1, 6)
 (2, 4)  (2, 5)  (2, 6)
 (3, 4)  (3, 5)  (3, 6)

Cada variável da compreensão cria uma nova dimensão na saída, com uma entrada para cada combinação possível das variáveis.

No exemplo acima, x aumenta descendo pelas linhas e y aumenta percorrendo as colunas. Dimensões maiores são possíveis, com os avisos de sempre sobre a legibilidade da saída.

Expressões geradoras

As seções anteriores focaram na saída em array, com a compreensão colocada entre colchetes [ ... ].

Quando os colchetes são substituídos por parênteses ( ... ), acontece algo diferente: obtemos uma generator expression, um iterador de avaliação preguiçosa que pode fornecer o próximo valor sob demanda.

julia> g = ((x, y) for x in 1:3, y in 4:6)
Base.Generator{Base.Iterators.ProductIterator{Tuple{UnitRange{Int64}, UnitRange{Int64}}}, var"#9#10"}(var"#9#10"(), Base.Iterators.ProductIterator{Tuple{UnitRange{Int64}, UnitRange{Int64}}}((1:3, 4:6)))
# Indexing fails with a generator, the entries don't exist yet
julia> g[1, 2]
ERROR: MethodError: no method matching getindex(::Base.Generator{Base.Iterators.ProductIterator{Tuple{UnitRange{…}, UnitRange{…}}}, var"#9#10"}, ::Int64, ::Int64)
# conversion to array
julia> collect(g)
3×3 Matrix{Tuple{Int64, Int64}}:
 (1, 4)  (1, 5)  (1, 6)
 (2, 4)  (2, 5)  (2, 6)
 (3, 4)  (3, 5)  (3, 6)
# generators are mainly designed for iteration
julia> [i * j for (i, j) in g]
3×3 Matrix{Int64}:
  4   5   6
  8  10  12
 12  15  18

Quando o resultado de uma compreensão é usado imediatamente em processamento posterior, um gerador pode economizar memória, evitando a necessidade de armazenar um array intermediário grande.

Um gerador usado como argumento de função não precisa de parênteses adicionais.

# inefficient
julia> v = [x^2 for x in 1:1e6];
julia> sum(v)
3.333338333335e17
# better - use a generator
julia> sum(x^2 for x in 1:1e6)
3.3333383333312755e17

A sintaxe do gerador é idêntica à das compreensões, a não ser pelos delimitadores que os envolvem.

Geradores também podem ser úteis em construtores de dicionário.

julia> Dict(x => x^2 for x in 1:5)
Dict{Int64, Int64} with 5 entries:
  5 => 25
  4 => 16
  2 => 4
  3 => 9
  1 => 1