Un vistazo a Koka

Koka es un lenguaje de programación:

• Funcional fuertemente tipado.
• Sistema de tipos con efectos.
• Handlers de efectos algebraicos.
• Compilación directa a C con referencia contada (Perceus).
• Optimización para reutilización en estilo funcional.

Hola, mundo en Koka

Para conocer el lenguaje no hay como crear el clásico programa de "Hola, mundo".

holamundo.kk

module holamundo

fun main() {
  println("Hola, mundo en Koka") 
}

A primera vista nos recuerda un poco a Go o hasta Python.

Para ejecutar el programa abrimos una terminal y tecleamos::

$ koka holamundo.kk
# O con este otro comando
$ koka --execute holamundo.kk

Si todo va bien, se mostrará este mensaje en la consola:

Hola, mundo en Koka

REPL de Koka

Abrimos el REPL de koka:

$ koka

Veremos esto en la consola. Y escribiremos un sencillo mensaje:

 _         _
| |       | |
| | _ ___ | | _ __ _   welcome to the koka interactive compiler
| |/ / _ \| |/ / _' |  version 3.2.3, Mar 18 2026, libc x64 (clang-cl)
|   ( (_) |   ( (_| |  output dir: .koka/v3.2.3/clang-cl-debug-240165
|_|\_\___/|_|\_\__,_|  type :? for help, and :q to quit

load    : std/core
load    : std/core/types
load    : std/core/unsafe
load    : std/core/hnd
load    : std/core/exn
load    : std/core/undiv
load    : std/core/bool
load    : std/core/vector
load    : std/core/order
load    : std/core/char
load    : std/core/sslice
load    : std/core/either
load    : std/core/list
load    : std/core/string
load    : std/core/maybe
load    : std/core/tuple
load    : std/core/lazy
load    : std/core/delayed
load    : std/core/int
load    : std/core/show
load    : std/core/maybe2
load    : std/core/console
load    : std/core/debug

> println("Hola, mundo")

Si todo va bien lo veremos:

linking : std/core/@main
created : .koka\v3.2.3\clang-cl-debug-240165\std_core__main.exe

Hola, mundo

Una vez que ya ejecutamos el REPL, hagamos algunas pruebas:

> :t "Hola, mundo"
string

> :t 45.0
float64

> :t 9
int

> :t '@'
char

> :t println("Hola")
console/console ()

Quien haya usado el REPL de Haskell (ghci) le parecerá muy familiar. Con esto :t entrada verificamos el tipo de dato usado. Una entrada como está "Hola" nos dará el tipo string, una entrada como esta 33 nos dará un tipo int, una entrada 56.0 nos dará un tipo float64. Esto es importante pues, al igual que Haskell, Koka es un lenguaje que respeta los tipos de datos.

Aquí no aplica el dicho de "Una variable es una variable".

Artitmética en Koka

Realicemos algunas operaciones aritméticas en el REPL:

> 34 + 32
linking : std/core/@main
created : .koka\v3.2.3\clang-cl-debug-240165\std_core__main.exe

66

> 56 / 45
linking : std/core/@main
created : .koka\v3.2.3\clang-cl-debug-240165\std_core__main.exe

1

> 330 mod 300
      ^
/@virtual/std/core/@main.kk(1, 7): parse error: invalid syntax
  unexpected /@virtual/std/core/@main.kk(1,7-1,9): identifier "mod"
  expecting ".", "(", "[", "{", "fn", operator, ":=", ";" or end of input

> 330 % 300
linking : std/core/@main
created : .koka\v3.2.3\clang-cl-debug-240165\std_core__main.exe

30

> 45 * 32
linking : std/core/@main
created : .koka\v3.2.3\clang-cl-debug-240165\std_core__main.exe

1440

> 450 - 521
linking : std/core/@main
created : .koka\v3.2.3\clang-cl-debug-240165\std_core__main.exe

-71

Como vemos el operador mod no existe en este lenguaje, en su lugar empleamos el operador % para obtener el residuo de una división. Mientras que los demás operadores de suma, resta, multiplicación y división no son diferentes de otros lenguajes.

También podemos notar que incluso una sencilla operación lleva más tiempo de ser procesada o evaluada comparada a lo que se hace en el REPL de otros lenguajes (Haskell, Erland, Python, Elixir, etc.)

Salimos del REPL:

> :q

Programando en Koka

Crearemos algunos programas en este lenguaje para poderlo conocer mejor.

Fibonacci en Koka

Ejemplo 1. Crearemos un programa que calcule el fibonacci de un número.

fibonacci.kk

module fibonacci

fun fib(n : int) : div int
  if n <= 0   then 0
  elif n == 1 then 1
  else fib(n - 1) + fib(n - 2)
  

fun main()
  println(fib(5))
  println(fib(12))

Ejecutamos el programa:

$ koka fibonacci.kk

Salida:

5
144

Factorial en Koka

Ejemplo 2. Crearemos un programa para calcular el factorial de un número.

factorial.kk

module factorial

fun fact(n : int) : div int
  if n <= 0   then 0
  elif n == 1 then 1
  else n * fact(n - 1)
  

fun main()
  println(fact(5))
  println(fact(12))

Ejecutamos el programa:

$ koka factorial.kk

Salida:

120
479001600

Operaciones aritméticas en Koka

Ejemplo 3. Crearemos un programa para realizar operaciones aritméticas básicas: suma, resta, multiplicación y división.

operaciones.kk

module operaciones

fun sumar(x : int, y: int) : div int
  x + y

fun restar(x : int, y: int) : div int
  x - y

fun mult(x : int, y: int) : div int
  x * y

fun divi(x : int, y: int) : div int
  x / y  
  

fun main()
  println(sumar(5,4))
  println(restar(324,87))
  println(mult(3,7))
  println(divi(330,2))

Ejecutamos el programa:

$ koka operaciones.kk

Salida:

9
237
21
165

Este es un vistazo rápido al lenguaje Koka.

Continuaremos más adelante con este y más temas sobre Haskell y la programación funcional

Enlaces:

https://koka-lang.github.io/koka/doc/index.html
https://onlyhaskellforyou.blogspot.com/2026/06/koka-un-lenguaje-funcional-con-tipos-de.html
https://koka-lang.github.io/koka/doc/book.html
https://alquimistadecodigo.blogspot.com/2026/02/nuevos-lenguajes-de-programacion.html