Elixir Language
Liza

Sintaxis

• []
• [1, 2, 3, 4]
• [1, 2] ++ [3, 4] # -> [1,2,3,4]
• hd ([1, 2, 3, 4]) # -> 1
• tl ([1, 2, 3, 4]) # -> [2,3,4]
• [cabeza | cola]
• [1 | [2, 3, 4]] # -> [1,2,3,4]
• [1 | [2 | [3 | [4 | []]]]] -> [1,2,3,4]
• 'hola' = [? h,? e,? l,? l,? o]
• keyword_list = [a: 123, b: 456, c: 789]
• keyword_list [: a] # -> 123

Listas de palabras clave

Las listas de palabras clave son listas donde cada elemento de la lista es una tupla de un átomo seguida de un valor.

keyword_list = [{:a, 123}, {:b, 456}, {:c, 789}]

Una notación abreviada para escribir listas de palabras clave es la siguiente:

keyword_list = [a: 123, b: 456, c: 789]

Las listas de palabras clave son útiles para crear estructuras de datos ordenadas de pares clave-valor, donde pueden existir múltiples elementos para una clave determinada.

El primer elemento en una lista de palabras clave para una clave dada se puede obtener así:

iex> keyword_list[:b]
456

Un caso de uso para listas de palabras clave podría ser una secuencia de tareas nombradas para ejecutar:

defmodule TaskRunner do
  def run_tasks(tasks) do
    # Call a function for each item in the keyword list.
    # Use pattern matching on each {:key, value} tuple in the keyword list
    Enum.each(tasks, fn
      {:delete, x} ->
        IO.puts("Deleting record " <> to_string(x) <> "...")
      {:add, value} ->
        IO.puts("Adding record \"" <> value <> "\"...")
      {:update, {x, value}} ->
        IO.puts("Setting record " <> to_string(x) <> " to \"" <> value <> "\"...")
    end)
  end
end

Se puede llamar a este código con una lista de palabras clave así:

iex> tasks = [
...>   add: "foo",
...>   add: "bar",
...>   add: "test",
...>   delete: 2,
...>   update: {1, "asdf"}
...> ]

iex> TaskRunner.run_tasks(tasks)
Adding record "foo"...
Adding record "bar"...
Adding record "test"...
Deleting record 2...
Setting record 1 to "asdf"...

Listas de Char

Las cuerdas en el elixir son "binarios". Sin embargo, en el código de Erlang, las cadenas son tradicionalmente "listas de caracteres", por lo que al llamar a las funciones de Erlang, es posible que tenga que usar listas de caracteres en lugar de cadenas de Elixir normales.

Mientras que las cadenas normales se escriben con comillas dobles " , las listas de caracteres se escriben con comillas simples ' :

string = "Hello!"
char_list = 'Hello!'

Las listas de caracteres son simplemente listas de números enteros que representan los puntos de código de cada carácter.

'hello' = [104, 101, 108, 108, 111]

Una cadena se puede convertir en una lista de caracteres con to_charlist/1 :

iex> to_charlist("hello")
'hello'

Y lo contrario se puede hacer con to_string/1 :

iex> to_string('hello')
"hello"

Llamar a una función de Erlang y convertir la salida a una cadena de Elixir regular:

iex> :os.getenv |> hd |> to_string
"PATH=/usr/local/bin:/usr/bin:/bin"

Contras células

Las listas en Elixir son listas enlazadas. Esto significa que cada elemento de una lista consta de un valor, seguido de un puntero al siguiente elemento de la lista. Esto se implementa en el elixir utilizando células contras.

Las celdas en contra son estructuras de datos simples con un valor "izquierdo" y un valor "correcto", o una "cabeza" y una "cola".

Un | Se puede agregar un símbolo antes del último elemento de una lista para anotar una lista (impropia) con una cabeza y cola dadas. Lo siguiente es una única celda de contras con 1 como la cabeza y 2 como la cola:

[1 | 2]

La sintaxis estándar de Elixir para una lista es en realidad equivalente a escribir una cadena de celdas de contras anidadas:

[1, 2, 3, 4] = [1 | [2 | [3 | [4 | []]]]]

La lista vacía [] se usa como la cola de una celda de contras para representar el final de una lista.

Todas las listas en Elixir son equivalentes a la forma [head | tail] , donde head es el primer elemento de la lista y tail es el resto de la lista, menos la cabeza.

iex> [head | tail] = [1, 2, 3, 4]
[1, 2, 3, 4]
iex> head
1
iex> tail
[2, 3, 4]

Usando la [head | tail] notación de [head | tail] es útil para la coincidencia de patrones en funciones recursivas:

def sum([]), do: 0

def sum([head | tail]) do
  head + sum(tail)
end

Listas de mapas

map es una función en la programación funcional que, dada una lista y una función, devuelve una nueva lista con la función aplicada a cada elemento de esa lista. En Elixir, la función map/2 está en el módulo Enum .

iex> Enum.map([1, 2, 3, 4], fn(x) -> x + 1 end)
[2, 3, 4, 5]

Usando la sintaxis de captura alternativa para funciones anónimas:

iex> Enum.map([1, 2, 3, 4], &(&1 + 1))
[2, 3, 4, 5]

Haciendo referencia a una función con sintaxis de captura:

iex> Enum.map([1, 2, 3, 4], &to_string/1)
["1", "2", "3", "4"]

Encadenamiento de operaciones de lista utilizando el operador de tubería:

iex> [1, 2, 3, 4]
...> |> Enum.map(&to_string/1)
...> |> Enum.map(&("Chapter " <> &1))
["Chapter 1", "Chapter 2", "Chapter 3", "Chapter 4"]

Lista de Comprensiones

Elixir no tiene bucles. En lugar de ellos, para listas, hay excelentes módulos Enum y List , pero también hay Comprensiones de listas.

List Comprehensions puede ser útil para:

• crear nuevas listas

iex(1)> for value <- [1, 2, 3], do: value + 1
[2, 3, 4] 

• filtrando listas, usando expresiones de guard pero las usas sin when palabra clave.

iex(2)> odd? = fn x -> rem(x, 2) == 1 end
iex(3)> for value <- [1, 2, 3], odd?.(value), do: value
[1, 3]

• crear mapa personalizado, usando into palabra clave:

iex(4)> for value <- [1, 2, 3], into: %{}, do: {value, value + 1}
%{1 => 2, 2=>3, 3 => 4}

Ejemplo combinado

iex(5)> for value <- [1, 2, 3], odd?.(value), into: %{}, do: {value, value * value}
%{1 => 1, 3 => 9}

Resumen

Lista de Comprensiones:

• se usa for..do sintaxis de ... for..do con guardias adicionales después de comas y into palabras clave cuando se devuelve otra estructura que las listas, es decir. mapa.
• En otros casos devuelven nuevas listas.
• no soporta acumuladores
• no se puede detener el procesamiento cuando se cumple cierta condición
• guard declaraciones de guard deben ser las primeras en orden después for antes y antes de do o into símbolos. El orden de los símbolos no importa.

De acuerdo con estas restricciones, las Comprensiones de lista están limitadas solo para uso simple. En casos más avanzados, usar las funciones de los módulos Enum y List sería la mejor idea.

Diferencia de lista

iex> [1, 2, 3] -- [1, 3]
[2]

-- elimina la primera aparición de un elemento en la lista izquierda para cada elemento a la derecha.

Lista de miembros

Use in operador para verificar si un elemento es miembro de una lista.

iex> 2 in [1, 2, 3]
true
iex> "bob" in [1, 2, 3]
false

Convertir listas a un mapa

Use Enum.chunk/2 para agrupar elementos en sub-listas, y Map.new/2 para convertirlo en un Mapa:

[1, 2, 3, 4, 5, 6]
|> Enum.chunk(2)
|> Map.new(fn [k, v] -> {k, v} end)

Daría:

%{1 => 2, 3 => 4, 5 => 6}