Tipos básicos

Los tipos de datos fundamentales en Elixir y cómo trabajar con ellos.

Números

Elixir soporta enteros y números de punto flotante:

Enteros

iex> 42           # Decimal
42
iex> 0b1010       # Binario: 10
10
iex> 0o777        # Octal: 511
511
iex> 0xFF         # Hexadecimal: 255
255
iex> 1_000_000    # Guiones bajos para legibilidad
1000000

iex> 999999999999999999999999999999 * 2
1999999999999999999999999999998

Flotantes

iex> 3.14
3.14
iex> 1.0e10       # Notación científica
10000000000.0
iex> 1 / 2        # División siempre retorna float
0.5

Átomos

Los átomos son constantes cuyo nombre es su valor. Son extremadamente eficientes para comparaciones:

iex> :hola
:hola
iex> :elixir
:elixir
iex> :ok
:ok
iex> :error
:error

# Con espacios o caracteres especiales
iex> :"átomo con espacios"
:"átomo con espacios"

iex> true == :true
true
iex> is_atom(false)
true

Usos comunes de átomos

• :ok y :error para indicar éxito o fallo
• Como claves en mapas: %{nombre: "Juan"}
• Para referenciar módulos: String es :"Elixir.String"
• nil es el átomo :nil

Strings (Cadenas)

Las cadenas en Elixir son binarios codificados en UTF-8:

iex> "Hola Mundo"
"Hola Mundo"

# Interpolación
iex> nombre = "Elixir"
iex> "Hola, #{nombre}!"
"Hola, Elixir!"

# Concatenación
iex> "Hola" <> " " <> "Mundo"
"Hola Mundo"

# Strings multilínea
iex> """
...> Primera línea
...> Segunda línea
...> """
"Primera línea\nSegunda línea\n"

Funciones útiles del módulo String

iex> String.length("Hola")
4
iex> String.upcase("hola")
"HOLA"
iex> String.downcase("HOLA")
"hola"
iex> String.split("a,b,c", ",")
["a", "b", "c"]
iex> String.trim("  hola  ")
"hola"
iex> String.replace("hola mundo", "mundo", "elixir")
"hola elixir"

Listas

Las listas son colecciones enlazadas de valores (pueden contener cualquier tipo):

iex> [1, 2, 3]
[1, 2, 3]
iex> [1, "dos", :tres]  # Tipos mixtos
[1, "dos", :tres]

# Concatenación
iex> [1, 2] ++ [3, 4]
[1, 2, 3, 4]

# Sustracción
iex> [1, 2, 3] -- [2]
[1, 3]

# Cabeza y cola
iex> [cabeza | cola] = [1, 2, 3]
iex> cabeza
1
iex> cola
[2, 3]

# Agregar al inicio (eficiente)
iex> [0 | [1, 2, 3]]
[0, 1, 2, 3]

Tuplas

Las tuplas almacenan elementos contiguamente en memoria. Son ideales para agrupar un número fijo de elementos:

iex> {:ok, "resultado"}
{:ok, "resultado"}
iex> {:error, "no encontrado"}
{:error, "no encontrado"}

# Acceso por índice
iex> tupla = {"a", "b", "c"}
iex> elem(tupla, 0)
"a"
iex> elem(tupla, 2)
"c"

# Tamaño
iex> tuple_size({1, 2, 3})
3

# Modificar (crea una nueva tupla)
iex> put_elem({:ok, "viejo"}, 1, "nuevo")
{:ok, "nuevo"}

Patrón común: {:ok, valor} y {:error, razón}

# Muchas funciones retornan tuplas
iex> File.read("existente.txt")
{:ok, "contenido del archivo"}

iex> File.read("no_existe.txt")
{:error, :enoent}

Mapas

Los mapas son colecciones clave-valor, similares a diccionarios en otros lenguajes:

# Con átomos como claves (sintaxis corta)
iex> persona = %{nombre: "Ana", edad: 30}
%{edad: 30, nombre: "Ana"}

# Con cualquier tipo como clave
iex> %{"clave" => "valor", 1 => "uno"}
%{1 => "uno", "clave" => "valor"}

# Acceso
iex> persona[:nombre]
"Ana"
iex> persona.nombre  # Solo para claves átomo
"Ana"

# Actualizar (crea un nuevo mapa)
iex> %{persona | edad: 31}
%{edad: 31, nombre: "Ana"}

# Agregar nueva clave
iex> Map.put(persona, :ciudad, "Madrid")
%{ciudad: "Madrid", edad: 30, nombre: "Ana"}

Funciones útiles del módulo Map

iex> mapa = %{a: 1, b: 2}

iex> Map.get(mapa, :a)
1
iex> Map.get(mapa, :c, "default")
"default"
iex> Map.keys(mapa)
[:a, :b]
iex> Map.values(mapa)
[1, 2]
iex> Map.delete(mapa, :a)
%{b: 2}
iex> Map.merge(mapa, %{c: 3})
%{a: 1, b: 2, c: 3}

Keyword Lists

Las keyword lists son listas de tuplas de dos elementos donde el primer elemento es un átomo:

iex> [{:a, 1}, {:b, 2}]
[a: 1, b: 2]

# Sintaxis corta
iex> [a: 1, b: 2]
[a: 1, b: 2]

# Permiten claves duplicadas
iex> [a: 1, a: 2]
[a: 1, a: 2]

# Acceso
iex> lista = [nombre: "Ana", edad: 30]
iex> lista[:nombre]
"Ana"

Resumen de tipos