Enteros
En Gleam hay dos tipos de números diferentes: enteros y números de punto flotante.
Los enteros son números sin parte fraccionaria.
let integer = 3
// -> 3
Gleam tiene varios operadores que funcionan con enteros.
1 + 1 // -> 2
5 - 1 // -> 4
5 / 2 // -> 2
3 * 3 // -> 9
5 % 2 // -> 1
2 > 1 // -> True
2 < 1 // -> False
2 >= 1 // -> True
2 <= 1 // -> False
Números de punto flotante
Los números de punto flotante son números con uno o más dígitos detrás del separador decimal.
let float = 3.45
// -> 3.45
Los números de punto flotante también tienen su propio conjunto de operadores.
1.0 +. 1.4 // -> 2.4
5.0 -. 1.5 // -> 3.5
5.0 /. 2.0 // -> 2.5
3.0 *. 3.1 // -> 9.3
2.0 >. 1.0 // -> True
2.0 <. 1.0 // -> False
2.0 >=. 1.0 // -> True
2.0 <=. 1.0 // -> False
Módulos
Módulos
El código de Gleam se organiza en módulos, y cada archivo es un módulo de Gleam.
Hasta ahora escribimos funciones con la sintaxis pub fn, que define una función disponible públicamente para otros módulos. Las funciones definidas con fn son privadas del módulo en el que se definen y no pueden ser usadas por otros módulos.
// This function is public
pub fn add(x, y) {
x + y
}
// This function is private
fn subtract(x, y) {
x - y
}
Los módulos de Gleam tienen nombres, y el nombre se basa en la ruta de su archivo dentro del directorio src o test.
Por ejemplo, un módulo definido en src\geometry\rectangle.gleam (en Windows) o src/geometry/rectangle.gleam (en sistemas operativos tipo UNIX) se llamaría geometry/rectangle.
Importar funciones de otros módulos
Se accede a las funciones definidas en otros módulos mediante importaciones.
Todas las funciones de ese módulo que fueron expuestas por él se vuelven accesibles al importar ese módulo.
Pero la forma de acceder a ellas varía según cómo se importe el módulo.
Las importaciones calificadas son las predeterminadas, y para acceder a una función dentro de ese módulo (por ejemplo, la función map en el módulo gleam/list) se antepone el nombre del módulo (list.map).
// Import the int module
import gleam/int
pub fn run(x: Int) -> String {
// Use the to_string function from the int module
int.to_string(x)
}
Por defecto, el nombre que se usa para referirse al módulo es la última parte del nombre del módulo, en este caso int, pero esto se puede cambiar usando la palabra clave as.
// Import the int module and refer to it as i
import gleam/int as i
pub fn run(x: Int) -> String {
i.to_string(x)
}
Las importaciones no calificadas permiten el acceso directo a las funciones expuestas dentro de ese módulo, sin prefijo.
// Import the to_string function from the int module
import gleam/int.{to_string}
pub fn run(x: Int) -> String {
to_string(x)
}
Se prefieren las importaciones calificadas porque dejan más claro para quien lee de dónde viene una función, y ayudan a evitar conflictos de nombres.
Biblioteca estándar
Gleam tiene una biblioteca estándar rica y bien documentada. La documentación está disponible en línea en hexdocs.pm/gleam_stdlib. Guarda este enlace en algún lugar, ¡lo vas a usar mucho!
La mayoría de los tipos de datos integrados tiene un módulo correspondiente que ofrece funciones para trabajar con ese tipo de datos; por ejemplo, está el módulo gleam/int para los enteros, el módulo gleam/string para los strings, el módulo gleam/list para los arrays, y así sucesivamente.
Ejercicio de aprendizaje
