¿Qué podemos hacer con Grain?

En una entrega anterior vimos un poco del lenguaje Grain.

Grain es un lenguaje de programación funcional, moderno y de código abierto, diseñado principalmente para compilarse a WebAssembly (Wasm), lo que le permite funcionar eficientemente tanto en navegadores web como en servidores.

Grain en un vistazo

Su objetivo es hacer accesibles las características avanzadas de los lenguajes funcionales, siendo fácil de aprender, fuertemente tipado y flexible.

Definiendo variables

Tipos de datos en Grain:

• Number, para datos numéricos. 
• Bool, para datos booleanos (true, false) 
• Char, para caracteres. 
• String, para cadenas de caracteres. 

Crearemos un programa llamado ``variables.gr``:

module Variables

print("\t [  Variables en Grain  ] \n")

Es importante que el módulo tenga el mismo nombre del programa.

Ahora definamos algunas variables:

module Variables

// Variables
let numeroInt = 65
let valorBoolean = true
let otroInt:Number = numeroInt + 32
let division = numeroInt / 4.0
let otroBool: Bool = false
let cadenaString: String = "Bienvenido a Grain!" and someChar: Char = '@'
let escritor = ("Thomas Muller", 47, "El cubo blanco.")
let (nombre, edad, libro) = escritor
let resultado = if (otroBool) "Pista blanca." else "Pista azul."
let valorImprime: Void = print("Esto se vera en la pantalla.")

print("\t [  Variables en Grain  ] \n")

¿Qué podemos notar?

• Usamos la palabra ``let`` para definir variables. 
• Podemos especificar el tipo o también lo podemos omitir. 
• Usamos tipos Number, Char, Bool, String. 
• Grain es un lenguaje funcional, donde las variables son inmutables.

Imprimiendo las variables

Ahora vamos a imprimir las variables:

module Variables

// ...

print("\t [  Variables en Grain  ] \n")
print(cadenaString)
print(numeroInt)

if (valorBoolean){
  print(valorBoolean)
}

if(false){
  print("A")
}else if(54 > 100){
  print("B")
} else{
  print("C")
}

if(otroBool){
  print("Esto no se vera.")
}

print(otroInt)
print(division)
print((45 * 43 - 56 / 2))
print(escritor)
print(nombre)
print(edad)
print(libro)
print(resultado) 

Aserciones

Una aserción (assert) es una verificación lógica en el código que comprueba si una condición es verdadera; si resulta falsa, detiene el programa o lanza un error.

Grain nos permite usar instrucciones assert. Agregemoslas:

module Variables

// ...

print("\t [  Variables en Grain  ] \n")

// ...
assert true == (!false)
assert (34 < 100) == (43  > 0)
assert valorImprime == void

Todas son verdaderas; en caso de no ser así el programa fallaría.

Ahora el programa completo:

module Variables


let numeroInt = 65
let valorBoolean = true
let otroInt:Number = numeroInt + 32
let division = numeroInt / 4.0
let otroBool: Bool = false
let cadenaString: String = "Bienvenido a Grain!" and someChar: Char = '@'
let escritor = ("Thomas Muller", 47, "El cubo blanco.")
let (nombre, edad, libro) = escritor
let resultado = if (otroBool) "Pista blanca." else "Pista azul."
let valorImprime: Void = print("Esto se vera en la pantalla.")

print("\t [  Variables en Grain  ] \n")
print(cadenaString)
print(numeroInt)

if (valorBoolean){
  print(valorBoolean)
}

if(false){
  print("A")
}else if(54 > 100){
  print("B")
} else{
  print("C")
}

if(otroBool){
  print("Esto no se vera.")
}

print(otroInt)
print(division)
print((45 * 43 - 56 / 2))
print(escritor)
print(nombre)
print(edad)
print(libro)
print(resultado) 

assert true == (!false)
assert (34 < 100) == (43  > 0)
assert valorImprime == void

Ejecutemos el programa:

$ grain variables.gr

Salida:

Esto se vera en la pantalla.
         [  Variables en Grain  ]

Bienvenido a Grain!
65
true
C
97
16.25
1907
("Thomas Muller", 47, "El cubo blanco.")
Thomas Muller
47
El cubo blanco.
Pista azul.

Al ejecutar con este comando, el programa generará otros archivos (variables.gro y variables.wasm); el que nos interesa es el código WASM, pues el que se ejecutará en el navegador y otros entornos que lo soporten.

Grain y WebAssembly

WebAssembly es un formato de código binario portable y un formato de texto correspondiente, así como interfaces de software para facilitar la comunicación entre dichos programas y su entorno anfitrión. Grain nos permite generar ese código binario.

Todo hasta aquí va bien, pero no hemos respondido la pregunta:

¿Qué podemos hacer con Grain?

Podemos decir que:

• Se puede crear aplicaciones WebAssembly para ejecutarse con gran eficiencia dentro de los navegadores o del lado del servidor. 
• Desarrollar servicios y microservicios sin servidor (Serverless).

Seguiremos hablando de este lenguaje en próximas entregas.

Enlaces:

https://grain-lang.org/
https://codemonkeyjunior.blogspot.com/2015/03/aserciones.html
WASM: ¿Qué es?¿Por qué es importante? (Youtube)

Grain, un lenguaje para WebAssembly

Grain es un lenguaje de programación funcional, moderno y de código abierto, diseñado principalmente para compilarse a WebAssembly (Wasm), lo que le permite funcionar eficientemente tanto en navegadores web como en servidores. Su objetivo es hacer accesibles las características avanzadas de los lenguajes funcionales, siendo fácil de aprender, fuertemente tipado y flexible.

¿Qué es WebAssembly?

• Un formato de instrucciones binarias para una máquina virtual basada en pila. 
• Diseñado como un destino de compilación portátil para lenguajes de programación, lo que permite su implementación en la web para aplicaciones cliente y servidor.

Características más importantes:

• Eficiente y rápido. 
• Seguro. 
• Abierto y depurable. 
• Parte de la plataforma web abierta.

Grain es una alternativa directa a la compilación de código wasm. Si quieres usar lenguajes como C o C++ tendrías que usar https://emscripten.org/. Si quieres usar Python podrás elegir entre https://pyodide.org/en/stable/, https://github.com/wasmerio/py2wasm o https://pygame-web.github.io/. Entre otras alternativas dependiende el lenguaje de programación (Java, C#, Kotlin, Scala, Go, etc.).

Grain posee sus propias herramientas para compilar código y su línea de comandos.

Lo puedes instalar en sistemas Mac OS, Linux y Windows.  Si no deseas instalarlo, puede visitar este sitio y probar el lenguaje: https://grain-lang.org/try/

Otra forma de obtenerlo es con Node (V22 como mínima versión). Primero clonamos el repositorio:

$ git clone https://github.com/grain-lang/grain
$ cd grain

Una vez clonado el repositorio y ubicandonos en el directorio ejecutamose estos comandos para su construcción:

$ npm ci
$ npm run compiler build

Validamos la instalación:

$ grain --version

¡Tenemos instalado Grain en nuestro sistema!

Ahora demos un vistazo al lenguaje.

Al ser un lenguaje fuertemente tipado posee tipos básicos como Number, Bool, String y Char. Observemos la siguiente tabla:

Tipo	Descripción	Ejemplo
Number	Representa números enteros o decimales.	let x: Number = 42
Bool	Valores booleanos: verdadero o falso.	let flag: Bool = true
String	Secuencia de caracteres, texto.	let msg: String = "Hola Grain"
Char	Un solo carácter Unicode.	let letter: Char = 'A'

Grain usa la palabra clave ``let`` para introducir nuevos valores con un nombre determinado, a los que se les llama enlaces:

module Main

let numero = 42
let bandera = true
let saludo = "Bienvenido a Grain!"
and letra = 'A'

Hola mundo en Grain

Probemos el clásico programa "Hola, mundo" en este lenguaje.

holamundo.gr

module HolaMundo

print("Hola, mundo en Grain")

Para compilar y ejecutarlo directamente tecleamos:

$ grain holamundo.gr

Con pasos separados:

$ grain compile holamundo.gr 
# Te creará un archivo `holamundo.gr.wasm`
$ grain run holamundo.gr.wasm

Notar que te crea un archivo WASM ejecutable.

Continuaremos con este tema en próximas entregas.

Enlaces:

https://grain-lang.org/
https://webassembly.org/
https://alquimistadecodigo.blogspot.com/2026/04/webassembly-hola-mundo-en-python-con.html