Gren: un lenguaje de programación funcional

Gren es un lenguaje de programación funcional con efectos secundarios cuidadosamente gestionados y un sólido sistema de tipos estático. El lenguaje se compone de pocos conceptos con nombres legibles para humanos que se combinan bien, lo que permite lograr más con menos.

Su objetivo es poder escribir código que se ejecute tanto en el navegador como en el backend.

Algunas de sus características más notables son:

• Compila a JS, con enfoque a WASM. 
• Es muy portable. 
• Tiene soporte incorporado para Node. 
• Tiene evaluación estricta y soporte de source-map. 
• Fácil  depuración y el perfilado utilizando las mismas herramientas que usarías para Node o navegadores.

Para instalarlo tenemos dos opciones.

Con Npm:

$ npm install -g gren-lang

Con Nix:

$ nix-shell -p gren

Un vistazo a Gren

Gren es bastante similar al lenguaje de programación Elm. 

Demos un pequeño vistazo al lenguaje.

Tipos de datos en Gren.

Tipo	Descripción	Ejemplo
Int	Números enteros (positivos o negativos)	42, -7
Float	Números decimales de precisión doble	3.14, -0.5
Bool	Valores lógicos verdadero/falso	True, False
String	Texto Unicode	"Hola mundo"
Char	Un solo carácter Unicode	'a', 'Z'
List	Lista inmutable de elementos del mismo tipo	[1, 2, 3]
Tuple	Par ordenado de valores (máx. 2)	(1, "uno")
Maybe	Representa un valor opcional (Just o Nothing)	Just 5, Nothing
Result	Representa éxito o error	Ok "bien", Err "falló"

Esta tabla muestra los tipos básicos del lenguaje.

REPL

$ gren repl

Esto nos permitirá entrar al REPL del lenguaje Gren.

---- Gren 0.6.5 -----------------------------------------------------------------
Say :help for help and :exit to exit!
--------------------------------------------------------------------------------
> 3 + 2
5 : number
> True
True : Bool
> 56 > 33
True : Bool
> 56 > 333
False : Bool
> "ANITA LAVA LA TINA"
"ANITA LAVA LA TINA" : String

Creando un proyecto Gren

Ahora iniciaremos con un proyecto Gren.

$ mkdir demo-gren
$ cd demo-gren
$ gren init -y

Esto creará los archivos y directorios del proyecto.

El primer archivo a notar será ``gren.json``, el cual es similar al ``package.json`` de un proyecto Node:

{
    "type": "application",
    "platform": "browser",
    "source-directories": [
        "src"
    ],
    "gren-version": "0.6.5",
    "dependencies": {
        "direct": {
            "gren-lang/browser": "6.0.2",
            "gren-lang/core": "7.4.0"
        },
        "indirect": {
            "gren-lang/url": "6.0.0"
        }
    }
}

También creará un directorio ``gren_packages`` con ciertos paquetes.

gren_lang_browser__6_0_2.pkg.gz
gren_lang_core__7_4_0.pkg.gz
gren_lang_url__6_0_0.pkg.gz

Dentro del directorio ``src`` crearemos el siguiente programa:

src/Main.gren

module Main exposing (main)

import Html

main =
  Html.text "Hola, mundo en Gren"

Compilamos:

$ gren make Main

Esto nos creará un archivo ``index.html`` el cual abriremos con un navegador:

Hola, mundo en Gren

Ahora modifiquemos el código del Main.gren. Haremos un programa que calcule el interés compuesto dado un monto (valor presente), una tasa de interés y un plazo de pago.

Fórmulas:

futuro=presente*pow(1+tasa,periodo) y extra = futuro - presente

src/Main.gren

module Main exposing (..)

import Html exposing (Html, text)
import String


-- Tipo para el resultado
type alias Resultado =
    { futuro : Float
    , extra : Float
    }


-- Potencia para Float con exponente entero
powFloat : Float -> Int -> Float
powFloat base exp =
    if exp == 0 then
        1
    else
        base * powFloat base (exp - 1)


-- Función que calcula el monto futuro y el extra
calcular : Float -> Float -> Int -> Resultado
calcular presente tasa periodo =
    let
        tasaDecimal =
            tasa / 100

        futuro =
            presente * powFloat (1 + tasaDecimal) periodo

        extra =
            futuro - presente
    in
    { futuro = futuro, extra = extra }


-- Ejemplo de uso: mostramos resultados como HTML
main : Html msg
main =
    let
        presente = 1000.0
        tasa = 5.0
        periodo = 12

        resultado =
            calcular presente tasa periodo

        salida =
            "Monto a pagar: " ++ String.fromFloat resultado.futuro
                ++ "\nExtra a pagar: "
                ++ String.fromFloat resultado.extra
    in
    text salida

Compilamos:

$ gren make Main

Esto nos creará (nuevamente) un archivo ``index.html`` el cual abriremos con un navegador:

Monto a pagar: 1795.8563260221301 Extra a pagar: 795.8563260221301

Quienes han usado Haskell notarán que las funciones usan su misma sintaxis. Y es que Elm usa Haskell indirectamente y Gren es como Elm(sic).

Continuaremos con Gren en próximas entregas.

Enlaces:

https://gren-lang.org/
https://www.reddit.com/r/ProgrammingLanguages/comments/1gbqe09/gren_a_language_for_modern_software_development/?tl=es-419
Gren: A Language for Modern Software Development (Youtube)
https://emanuelpeg.blogspot.com/2026/03/empezando-con-elm.html
https://www.sanityinc.com/articles/why-we-use-haskell-and-elm/