El creador de Wisp, Louis Pilfol, nos ofrece un vistazo a su framework desde su canal del Youtube (https://www.youtube.com/@lpil).
Recordemos que ya hemos hablado de el en este blog. Se trata de un nuevo framework para desarrollo web empleando el lenguagle Gleam. Un lenguaje inspirado en Elixir.
Enlaces:
http://codemonkeyjunior.blogspot.com/2025/04/wisp-un-nuevo-framework-para-gleam.html
El lenguaje de programación Gleam ahora cuenta con un nuevo framework: Wisp.
Wisp fue creado por Louis Pilfol.
Este nuevo framework ofrece:
Este ejemplo sacado de la página oficial es una muestra de lo que se puede hacer:
import my_app/people import my_app/web.{Context} import gleam/result.{try} import wisp.{Request, Response} pub fn handle_request(req: Request, ctx: Context) -> Response { use json <- wisp.require_json(req) let result = { use params <- try(people.parse_params(json)) use person <- try(people.save(params, ctx.db)) Ok(people.to_json(person)) } case result { Ok(body) -> wisp.json_response(body, 201) Error(_) -> wisp.bad_request() } }
Aquí vemos una solicitud a un JSON API y guarda un elemento en una base de datos.
Como hemos mencionado en esta serie de entregas sobre Gleam, se trata de un nuevo lenguaje de programación (que corre sobre la máqina de BEAM) que toma lo mejor de lenguajes Elixir y Erlang para proveer un camino más sencillo al programador.
Continuaremos con esta serie más adelante.
Enlaces:
https://elixirforum.com/t/gleam-has-a-new-web-framework/59874
Continuamos con el tema de Gleam, un lenguaje que corre sobre la máquina virtual de Erlang (BEAM). Similar a Elixir en algunos aspectos.
Si quieres programar usando este lenguaje y además usas VsCode como editor, existe un plugin que podrás instalar:
https://marketplace.visualstudio.com/items?itemName=Gleam.gleamTe ayudará en el resaltado de estilo, formato, definición y autocompletado.
Recordemos cómo crear un proyecto en Gleam:
gleam new proyecto
Nos ubicamos en el directorio creado:
cd proyecto
Podemos usar VsCode. Abrimos una terminal y tecleamos:
code .
Esto abrirá el editor de código.
Ejemplo 1. Crear una función que mande un saludo.
La sintaxis para crear una función es la siguiente:
pub fn nombre_funcion() { // Cuerpo del procedimiento o función }
Nuestra función será esta:
pub fn saludo() { io.println("\t Hola, mundo desde Gleam") }
La invocamos desde el método main del programa principal.
proyecto.gleam
import gleam/io pub fn main() { saludo() } pub fn saludo() { io.println("\t Hola, mundo desde Gleam") }
Construimos y ejecutamos:
gleam build gleam run
Salida:
Hola, mundo desde Gleam
Ejemplo 2. Crear una función que calcula el factorial de un número.
Teniendo el siguiente pseudo código:
numero = 5 IF numero = 0 THEN result = 1 IF ELSE numero = 1 THEN result = 1 ELSE result = numero * FACTORIAL(numero - 1)
La función en Gleam quedaría de tal modo:
pub fn factorial(x: Int) -> Int { case x { 0 -> 1 1 -> 1 _ -> x * factorial(x - 1) } }
La invocamos de esta manera:
import gleam/io import gleam/int pub fn main() { io.println("\t===== Factorial en Gleam =====") io.println("El factorial de 5: ") io.debug(factorial(5)) io.println("El factorial de 7: ") io.debug(factorial(7)) }
Ejemplo 3. Crear una función anónima que sume dos número enteros.
fn suma(a: Int, b: Int) -> Int { a + b }
Y la invocamos de la siguiente forma:
import gleam/io import gleam/int pub fn main() { io.println("\t===== Sumando en Gleam =====") let add = suma(3, 4) io.println("Suma (3,4) es: ") io.debug(add) }
Este post se irá actualizando para agregar más ejemplos.
Enlaces:
https://codemonkeyjunior.blogspot.com/2024/03/conociendo-gleam-un-lenguaje-que-corre.html
En un post anterior vimos qué es el lenguaje Gleam, además de como instalarlo. Esta ocasión vamos a crear un proyecto con este lenguaje de programación funcional.
Abrimos una terminal y tecleamos:
gleam new proyecto
Esto nos creará un proyecto.
$ tree
Listado de rutas de carpetas
El número de serie del volumen es F4A1-89BE
C:.
├───.github
│ └───workflows
├───build
│ ├───dev
│ │ ├───erlang
│ │ │ ├───gleam_stdlib
│ │ │ │ ├───ebin
│ │ │ │ ├───include
│ │ │ │ └───_gleam_artefacts
│ │ │ ├───gleeunit
│ │ │ │ ├───ebin
│ │ │ │ └───_gleam_artefacts
│ │ │ └───proyecto
│ │ │ ├───ebin
│ │ │ └───_gleam_artefacts
│ │ └───javascript
│ ├───lsp
│ │ ├───erlang
│ │ └───javascript
│ ├───packages
│ │ ├───gleam_stdlib
│ │ │ ├───include
│ │ │ └───src
│ │ │ └───gleam
│ │ └───gleeunit
│ │ └───src
│ │ └───gleeunit
│ └───prod
│ ├───erlang
│ └───javascript
├───src
└───test
El programa principal será src/proyecto.gleam . Lo editaremos:
// Pruebas con Gleam import gleam/io pub fn main() { io.println("\t===== Programando en Gleam =====") }
Para compilar y ejecutar tecleamos:
$ gleam build $ gleam run
Nota: Podemos solo teclear el segundo comando, iniciará la compilación y después ejecutará el código:
Si la compilación es correcta, se ejecutará:
$ gleam run Compiling proyecto Compiled in 1.32s Running proyecto.main ===== Programando en Gleam =====
La declaración de variables es algo con lo que comenzaremos a ver.
// Int let entero = 33 // String let cadena = "ABC" // Int con formato let num_binario = 0b00001111 let num_octal = 0o17 let num_hexa = 0xF // Float let num_flotante = 7.0e7 // Boolean let booleano = 43 < 33 // Esto es False
Se pude apreciar que la declaración de variables es similar a Rust. Existen tipos Int, Float, String y Boolean.
Si queremos declarar una variable sin usar podemos hacer esto:
// Int let _no_se_usa = 33
Notar que usamos el guión bajo para declarar variables que no usamos.
Código completo:
src/proyecto.gleam
// Pruebas con Gleam import gleam/io pub fn main() { io.println("\t===== Programando en Gleam =====") test_a() } pub fn test_a(){ let entero = 33 let cadena = "ABC" let num_binario = 0b00001111 let num_octal = 0o17 let num_hexa = 0xF let num_flotante = 7.0e7 let booleano = 43 < 33 // Esto es False io.println("\t ====== Variables en Gleam ======") io.println("Entero: ") io.debug(entero) io.println("Cadena: ") io.debug(cadena) io.println("Booleano: ") io.debug(booleano) io.println("Numero binario: ") io.debug(num_binario) io.println("Numero hexadecimal: ") io.debug(num_hexa) io.println("Numero octal: ") io.debug(num_octal) io.println("Numero flotante: ") io.debug(num_flotante) }
Ejecutamos el proyecto:
gleam run
Compiling proyecto
Compiled in 1.32s
Running proyecto.main
===== Programando en Gleam =====
====== Variables en Gleam ======
Entero:
33
Cadena:
"ABC"
Booleano:
False
Numero binario:
15
Numero hexadecimal:
15
Numero octal:
15
Numero flotante:
7.0e7
Hemos creado nuestro primer proyecto con este lenguaje de programación. Más en próximos posts.
Enlaces:
https://codemonkeyjunior.blogspot.com/2024/03/conociendo-gleam-un-lenguaje-que-corre.html
Gleam es: un lenguaje de programación funcional que corre sobre la máquina virtual de Erlang (BEAM) o como lo dice el sitio oficial:
"Es un lenguaje amigable para construir sistemas con seguridad de tipos que escalan".
El clásico "Hello world" en Gleam:
// Import a Gleam module from the standard library import gleam/io pub fn main() { io.println("Hola, mundo en Gleam!") }
Si quieres probarlo sin tener que instalarlo, checha este sitio: https://tour.gleam.run/
A primera vista Gleam nos recuerda a lenguajes como Rust o quizás Golang y hasta Ballerina language.
En Linux:
sudo xbps-install gleam
En Windows necesitamos instalar Scoop antes de Gleam. Debemos abrir una terminal de Powershell como administrador y teclear estos comandos:
Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser Invoke-RestMethod -Uri https://get.scoop.sh | Invoke-Expression
En caso de que no permita instalar, teclear este comando:
iex "& {$(irm get.scoop.sh)} -RunAsAdmin"
Verificar instalación de Scoop:
scoop help
Procedemos a instalar Gleam:
scoop install gleam
Verificar instalación de Gleam:
$ gleam --version
gleam 0.34.1
Más sobre este lenguaje en próximos posts.
Enlaces:
https://gleam.run/Hoy hablaremos de un nuevo lenguaje de programación llamado Jai . Se trata de un lenguaje de programación que está desarrolland...
