Introducción a Elixir | SocraCan

Introducción

Elixir es un lenguaje de programación puramente funcional, el cual funciona sobre la VM de Erlang. Esto quiere decir que nuestro código será transpilado a Erlang y ejecutado por dicha máquina virtual.

Para hacer un símil, es lo mismo que ocurre con Kotlin y Java. Nuestro código es transpilado de Kotlin a Java, es compilado a ficheros .class y estos son ejecutados por la vm.

Curiosidades

Tenemos que entender que al tratarse de un lenguaje de programación puramente funcional, no vamos a encontrar clases.
Por el contrario, lo que veremos serán módulos que contienen funciones, las cuales esperan recibir parámetros y que podrán ser concatenadas con otras, con la idea de recibir por parámetro el valor devuelto por la primera y seguir trabajando con él.

Matching Operator y Pattern Matching

Es uno de los puntos más importantes del lenguaje, puesto que nos permitirá no sólo asignar valores:

x = 1

Sino que también nos permitirá aplicar desestructuración a nuestras variables:

{a, b, c} = {:hello, "world", 42}

Para el ejemplo anterior podremos afirmar las siguientes correspondencias: a -> :hello, b -> "world", c -> 42

Este mismo patrón también nos vale para los arrays.

{a, b, c} = [:hello, "world", 42]

Sin embargo, otro caso muy típico es hacer desestructuraciones más complejas:

[head | tail] = [1, 2, 3]

En este caso lo que va a ocurrir es que head -> 1 mientras que tail -> [2, 3]

Por otro lado, utilizando esta misma sintaxis podemos añadir contenido al array:

list = [1, 2, 3]
newList = [0 | list]

De esta forma el resultado sería [0, 1, 2, 3]

Otro caso muy interesante es el del uso del operador _. Este es un operador reservado para desestructuración, que nunca puede ser leído. Veamos un ejemplo:

[head | _][1, 2, 3]

En esta ocasión head -> 1, sin embargo _ -> Error ya que no puede ser leído. Es un caso muy útil cuando el resto de datos son irrelevantes para nuestro código.

Pipe operator |>

Este operador viene a ser un método de concatenación. Por ejemplo, en una forma clásica, si quisiéramos definir una sucesión de llamadas:

defmodule Socracan do
  def reversedDigits(number) do
    Integer.digits(Enum.reverse(number))
  end
end

En este caso, lo que hacemos es recibir un número, invertirlo, y dividirlo en dígitos. Aunque nuestro código conste de una sola línea, es muy difícil de comprender. Usando el operador |> podemos hacerlo más legible de la siguiente forma:

defmodule Socracan do
  def reversedDigits(number) do
    number
    |> Integer.digits
    |> Enum.reverse
  end
end

En este caso, number es pasado al método Integer.digits y a su vez, este le pasa su resultado a Enum.reverse.

Otra cosa que me resultó curiosa en Elixir, es que a parte de los test unitarios a los que estamos acostumbrados:

defmodule ExampleTest do
  use ExUnit.Case
  doctest Example

  test "greets the world" do
    assert Example.hello() == :word
  end
end

También tenemos los test de documentación, los doctest . Estos test hacen una prueba sencilla, dada una entrada comprueban la salida y están encima de la definición del método como documentación. Es una manera de tener documentación viva, la cual se autocomprueba:

defmodule Example do
  @moduledoc """
  Documentation for Example.
  """

  @doc """
  Hello world.

  ## Examples

      iex> Example.hello
      :world

  """
  def hello do
    :world
  end
end

Si quieres empezar con Elixir y no sabes por dónde, existe un repositorio muy guapo con Koams para practicar con el lenguaje. En él, básicamente nos va llevando desde lo más básico a casos más complejos del lenguaje, con test en rojo, los cuales tenemos que completar sustituyendo los tres guiones bajos ___

github.com

elixirkoans/elixir-koans