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
La Programación Funcional (Functional Programming)es un paradigma de programación declarativa (decir qué queremos, pero no cómo hacerlo) basado en el uso de funciones matemáticas donde:
Ejemplo 1. Crear una función pura que nos sume dos números enteros. Este ejemplo lo haremos en Haskell.
suma.hs
suma :: Int -> Int -> Int suma x y = x + y main :: IO() main = print (suma 8 3)
Como se puede ver, iniciamos con la delaración de tipos (Int). Definimos la función (suma) y en la d¿función principal (main) asignamos dos valores por default (8 y 3), lo cual nos dará como resultado 11.
Si solo queremos ejecutar el programa, abrimos una terminal y tecleamos lo siguiente:
runghc suma.hs
Si queremos compilar y crear un ejecutable, entonces:
ghc -o suma.exe suma.hs
Como la definición de una Función Pura indica, el resultado será el mismo cuando los argumentos son los mismos. Si invertimos el lugar del los valores (8, 3 por 3,8) el resultado seguirá siendo el mismo.
Aprender programación funcional se ha vuelto una "moda" que ya no solo implica el ámbito académico. Puesto que ya son muchos proyectos como la I.A. o Aprendizaje Automático que cada vez más requieren desarrolladores que dominen los principios de la matemática y, por ende, la programación funcional.
Enlaces:
https://codemonkeyjunior.blogspot.com/search?q=erlang
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
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/
Ejercicio: Un programa que determine si una cadena ("ABC") tiene una longitud distinta de cero. Si la longitud de cadena es distinta de cero, que imprima la cadena en pantalla. Si no cumple la condición deberá mandar el mensaje: "Cadena vacía".
En pseudo código sería algo como esto:
// Pseudo code language prog longitud:{ var cadena:String = "ABC"; var longitud:Int = cadena.size; if longitud != 0 then disp "${cadena}" else disp "Cadena vacía" }
Por temas de espacio algunos bloques de código son omitidos para no hacer más grande el código, usted disculpe.
En Powershell:
longitud.ps1
$cadena="ABC" if($cadena.Length -ne 0){ Write-Host $cadena } else{ Write-Host "Cadena vacia" }
En Clojure:
longitud.clj
(ns longitud) (def cadena "ABC") (def longitud (count cadena)) (if (not= longitud 0) (println cadena) (println "Cadena vacia") )
En Erlang:
longitud.erl
-module(longitud). -author("Codemonkey Junior Blogspot"). -version("1.0.0"). -export([start/0]). println(Cosa) -> io:format("~p~n", [Cosa]). start()-> Cadena="ABC", Longitud=string:length(Cadena), if Longitud /= 0 -> println(Cadena); true -> println("Cadena vacia") end.
En OpenEdge ABL:
longitud.p
define var as char no-undo initial "ABC". if length(cadena)<>0 then disp cadena. else disp "Cadena vacia".
En Rust:
longitud.rs
let cadena:String = String::from("ABC"); if cadena.chars().count()!=0 { println!("{}",cadena) } else{ println!("Cadena vacia") }
En PL/SQL:
longitud.sql
SET SERVEROUTPUT ON DECLARE cadena varchar2(3):='ABC'; BEGIN IF LENGTH(cadena) != 0 THEN dbms_output.put_line(cadena); ELSE dbms_output.put_line('Cadena vacia'); END IF; END; /
En Elixir:
longitud.exs
cadena = "ABC" if String.length(cadena) != 0 do IO.puts "#{cadena}" else IO.puts "Cadena vacia" end
En R:
longitud.r
cadena <- "ABC" if(nchar(cadena) != 0) { sprintf("%s",cadena) }else{ print("Cadena vacia") }
En DataStage BASIC:
longitud.dsx
Option Explicit ' Declaración de variables Dim cadena As String ' Asignación de valor a la variable cadena = "ABC" ' Verificación de la longitud de la cadena If Len(cadena) <> 0 Then ' Imprimir la cadena si no está vacía Print cadena Else ' Imprimir un mensaje si la cadena está vacía Print "Cadena vacia" End If
En Ballerina:
longitud.bal
import ballerina/io; public function main() { string cadena = "ABC"; if (lengthof cadena != 0) { io:println(cadena); } else { io:println("Cadena vacia"); } }
En C:
longitud.c
#include <stdio.h> #include <string.h> int main() { char cadena[] = "ABC"; if (strlen(cadena) != 0) { printf("%s\n", cadena); } else { printf("Cadena vacia\n"); } return 0; }
En C++:
longitud.cpp
#include <iostream> #include <string> int main() { std::string cadena = "ABC"; if (!cadena.empty()) { std::cout << cadena << std::endl; } else { std::cout << "Cadena vacia" << std::endl; } return 0; }
En Haskell:
longitud.hs
main :: IO () main = do let cadena = "ABC" if length cadena /= 0 then putStrLn cadena else putStrLn "Cadena vacia"
En Prolog:
longitud.pl
cadena_valida('ABC') :- write('ABC'). cadena_valida('') :- write('Cadena vacia'). main :- cadena_valida('ABC').
En Python:
longitud.py
cadena="ABC" if len(cadena) !=0: print(cadena) else: print("Cadena vacia")
Este post se irá actualizando... see you later !!
Como vimos en un post anterior de Erlang vimos cómo emplear algunas funciones. En este post vamos a ver como emplear funciones propias de Erlang y a crear las nuestras.
Pero antes vamos a repasar algunas cosas sobre módulos en Erlang:
fundamentos.erl
%% @doc Fundamentos en Erlang. %% @copyright Codemonkey Junior 2023. %% Nombre de nuestro módulo. -module(fundamentos). %% autor del módulo -author("Codemonkey Junior"). %% versión del módulo -version("1.0.0"). %% Exportamos las funciones que vamos a usar. -export([start/0]). %% Para importar funciones. -import(io, [fwrite/1]). %% Para exportar todas las funciones. -compile(export_all). %% Para exportar todas las funciones sin warnings. -compile(nowarn_export_all).
Como buena práctica podemos documentar el código usando las etiquetas @doc. También escribir comentarios de lo que hace cada función. En este caso exponemos como importar y exportar funciones en nuesto módulo. Para obtener información de nuestro módulo podemos hacer algo como esto:
$ erl > c(fundamentos). > fundamentos:module_info().
La función module_info() mostrará la información del módulo.
Como vimos en un post anterior. Podemos crear funciones para realizar alguna acción. En el caso de abajo, se trata de una función para convertir números binario, octal y hexadecimal a decimal.
-module(fundamentos). -author("Codemonkey Junior"). -version("1.0"). -export([start/0,convierte/0]). println(Cosa) -> io:format("~p~n", [Cosa]). start()-> println(" ==== Erlang ===="), Funcion = fun(X)-> X*2 end, println(Funcion(45)), println(self()), convierte(). convierte()-> X = 2#101, Y = 8#0677, Z = 16#AE, io:format("De binario a decimal: ~p~n",[X]), io:format("De octal a decimal: ~p~n",[Y]), io:format("De hexadecimal a decimal: ~p~n",[Z]). % erl % c(fundamentos). % fundamentos:start().
Entramos al REPL o Shell de Erlang, cargamos el programa e invocamos la función.
Erlang al igual que otros lenguajes de programación funcionales plantean una nueva forma de pensar para los programadores que usan Java, C#, C, C++ o Python. Mientras que los programadores Java requieren crear clases y clases, módulos y módulos para resolver un problema planteado con Erlang (Haskell, etc.) bastarán algunos bloques de código para hacer lo mismo. Aunque el código, en un principio, parezca incomprensible.
Pero, antes que nada, ¿qué es una función? Una función es un bloque de código que realizar una operación específica. Este bloque tiene un nombre y contiene las instrucciones necesarias para realizar esa tarea. Se puede invocar y devolverá un valor: el resultado de dicha operación.
# Función para sumar 2 números suma = fn (a,b) -> a+b end # Función para restar dos números resta = fn (a,b) -> a-b end
En este código definimos dos funciones anónimas (suma y resta) que nos devolverán el resultado. Invocamos las funciones.
IO.puts suma.(3,5) # 8 IO.puts resta.(6,2) # 4
Abajo hacemos uso de una función propia de Elixir para medir la longitud de una cadena.
String.length("CODE-MONKEY-JUNIOR") 18
Existen más funciones para manipulaciones de cadena de caracteres que son muy útiles y nos ahorrarán tiempo de desarrollo.
String.contains?("code for life", "for") true String.capitalize("elixir") "Elixir" String.downcase("CODEMONKEY") "codemonkey"
¿Y qué con los procedimientos? Un procedimiento es similar a una función. Es un bloque que tendrá un nombre y podrá ser invocado, pero no devolverá ningún valor.
Esto (los procedimientos) se puede ver en un clásico Hola mundo o cualquier operación que no devuelva algo con lo que podamos hacer alguna operación.
holamundo.exs
defmodule Hello do def print(lang \\ :en) def print(:de), do: "Hallo Welt" def print(:en), do: "Hello World" def print(:es), do: "Hola Mundo" def print(:ru), do: "Привет мир" end IO.puts Hello.print() IO.puts Hello.print(:es) Io.puts Hello.print(:ru)
Ejecutamos:
$ elixir holamundo.exs Hello World Hola Mundo Привет мир
Ahora procedemos a crear dos funciones de suma y resta (funciones con nombre):
defmodule Operaciones do def sumar(x,y) do x+y end def restar(x,y) do x-y end end
Invocamos las funciones:
x=2 y=4 IO.puts "Suma de #{x} + #{y} da: #{Operaciones.sumar(x,y)}" IO.puts "Resta de #{x} - #{y} da: #{Operaciones.restar(x,y)}"
Más post sobre elixir en futuras entregas.
Enlaces:
https://elixir-lang.org/
Básicamente, se trata de un REPL online.
> 34 + 31. 65 > 20 - 3. 17 > "Alpha". Alpha > [1,2,3,4,5]. [1,2,3,4,5]
> X = 33. 33 > X = Y. "variable 'Y' is unbound" > Y = X. 33
Seguiremos con los post de Erlang más adelante.
Seguimos con esta serie.
Para obtener información del compilador/emulador de Erlang tecleamos:
man erl
Abrimos una terminal y comenzamos a realizar algunas pruebas:
erl Erlang/OTP 25 [erts-13.0.4] [source] [64-bit] [smp:4:4] [ds:4:4:10] [async-threads:1] [jit:ns] Eshell V13.0.4 (abort with ^G) 1> A="abc". "abc" 2> string:to_upper(A). "ABC" 3> B="ABC". "ABC" 4> string:to_lower(B). "abc" 5> erlang:is_number(B). false 6> erlang:is_number(A). false 7> erlang:is_number(66). true 8> erlang:is_binary(A). false 9> erlang:is_binary(54). false 10> erlang:is_port(54). false 11> erlang:is_port(8080). false 12> erlang:is_list(B). true 13> erlang:is_tuple(B). false 14> Suma = fun(X,Y)-> X+Y end. #Fun<erl_eval.41.3316493> 15> Suma(43,32). 75 16> MiSuma= Suma(8,5). 13 17> elang:is_function(Suma). ** exception error: undefined function elang:is_function/1 18> erlang:is_function(Suma). true 19> 45 + "32". ** exception error: an error occurred when evaluating an arithmetic expression in operator +/2 called as 45 + "32" 20> 23*43/(21+32+43+44)-45. -37.93571428571428 21> 89+(32*4/32). 93.0 22> 33=33. 33 23> 12=9. ** exception error: no match of right hand side value 9 24> N=43. 43 25> N+43. 86 26> (N+43)/2. 43.0 27> erlang:is_list(N). false 28> erlang:is_number(N). true 29> erlang:is_integer(N). true 30> erlang:is_float(N). false 31> Lista=[1,2,3,4,5]. [1,2,3,4,5] 32> erlang:is_list(Lista). true 33> erlang:is_tuple(Lista). false 34> Division= fun(X,Y)-> X div Y end. #Fun<erl_eval.41.3316493> 35> Division(23,32). 0 36> erlang:is_integer(Division(8,3)). true 37> Residuo=fun(X,Y)-> X rem Y end. #Fun<erl_eval.41.3316493> 38> Resisuo(220,200). * 1:1: variable 'Resisuo' is unbound 39> Residuo(220,200). 20 40> erlang:is_number(Residuo(220,200)). true 41> Perfil={1,"Fernando"}. {1,"Fernando"} 42> erlang:is_tuple(Perfil). true 43> Message = {"MX",true,345,Perfil}. {"MX",true,345,{1,"Fernando"}} 44> {Id,Name}=Perfil. {1,"Fernando"} 45> Id. 1 46> Name. "Fernando" 47> {Code,Available,Numer,User}=Message. {"MX",true,345,{1,"Fernando"}} 48> Code. "MX" 49> Available. true 50> Numer. 345 51> User. {1,"Fernando"} 52> {_,MyName}=Perfil. {1,"Fernando"} 53> MyName. "Fernando" 54>q().
Como se puede observar Erlang tiene ciertas particularidades y funciones propias para realizar cosas como tratamiento de cadenas, verificar si una variable es de determinado tipo (integer, float, etc.), si alguna declaración es una lista, una tupla, una función. Así como declarar funciones, crear tuplas, etc.
Algunas funciones de Erlang
| Función | Uso |
|---|---|
| is_atom/2 | Verificar si es atom |
| is_binary/2 | Verificar si es binary |
| is_bitstring/1 | Verificar si es bitstring |
| is_boolean/1 | Verificar si es boolean |
| is_float/1 | Verificar si es float |
| is_function/1 | Verificar si es function |
| is_port/1 | Verificar si es port |
| is_integer/1 | Verificar si es integer |
| is_number/1 | Verificar si es number |
| is_record/1 | Verificar si es record |
| is_tuple/1 | Verificar si es tuple |
Cosas importantes para no olvidar
Obtener informacíon del módulo.
$ erl > c(programa). > programa:module_info().
Con esto se mostrará la información del módulo
Documentación, exportación e importación de módulos/funciones. Definición de constantes y macros.
%% @doc Fundamentos en Erlang %% @copyright Codemonkey Junior 2022 -module(fundamentos). -author("Codemonkey Junior"). -version("1.0.0"). -export([start/0]). -import(io, [fwrite/1]). -compile(export_all). % Para exportar todas las funciones -compile(nowarn_export_all). % Para exportar todas las funciones sin warnings -define(MAX, 1000). %% constante -define(CUADRADO (X), X*X). %% macro, similar a C
Continuaremos en próximos post.
https://codemonkeyjunior.blogspot.com/2021/12/erlang-constuir-aplicaciones-erlang-con.htmlHoy hablaremos de un nuevo lenguaje de programación llamado Jai . Se trata de un lenguaje de programación que está desarrolland...
