eskiu

1.Vista general

Eskiu compila con LLVM a un binario nativo independiente. No trae recolector de basura ni un runtime administrado, así que lo único que despliegas es ese binario. La sintaxis es de estilo C, así que lo básico se siente familiar; a eso la semántica le suma tipos suma, genéricos con restricciones, async/await, canales, atómicos y una biblioteca estándar de HTTP/2. El compilador está escrito en el propio Eskiu.

hello.esk

extern int printf(string fmt, ...);

int add(int a, int b) {
    return a + b;
}

int main() {
    printf("Hello from Eskiu!\n");
    printf("2 + 3 = %d\n", add(2, 3));
    return 0;
}

$ eskiuc run hello.esk
Hello from Eskiu!
2 + 3 = 5

2.Tipos y matching

Los tipos suma (enum) llevan datos en cada variante, y el match se verifica por exhaustividad en tiempo de compilación: el compilador rechaza un match al que se le olvida un caso.

parse_port.esk

enum ParseResult {
    Port(int),
    InvalidRange(int),
    NotANumber,
}

ParseResult parse_port(string s) {
    let n: int = atoi(s);
    if (n == 0) { return NotANumber; }
    if (n < 1 || n > 65535) { return InvalidRange(n); }
    return Port(n);
}

match parse_port("8080") {
    Port(p)         -> printf("listening on :%d\n", p);
    InvalidRange(n) -> printf("%d out of range\n", n);
    NotANumber      -> printf("not a number\n");
}

3.Genéricos

Las funciones y los tipos se parametrizan por tipo, con restricciones de interfaz. Una restricción como <T: Ord> obliga a que T implemente la interfaz, así que las llamadas se verifican y se monomorfizan en tiempo de compilación.

max.esk

interface Ord { int cmp(Ord* o); }

struct Coin {
    int value;
    int cmp(Coin* o) { if (self.value < o.value) { return -1; } return 1; }
}

T max<T: Ord>(T* a, T* b) {
    if (a.cmp(b) > 0) { return a[0]; }
    return b[0];
}

let hi: Coin = max<Coin>(&x, &y);   // hi.value == 7

4.Concurrencia

Las funciones async devuelven un Future; await suspende la ejecución hasta que haya un valor listo. Los canales tipados (Chan<T>) pasan valores entre tareas.

sum_squares.esk

import <future>;
import <channel>;

async int sum_squares(Chan<int>* ch) {
    let a: int = await chan_recv(ch);
    let b: int = await chan_recv(ch);
    let c: int = await chan_recv(ch);
    return a + b + c;
}

Chan<int>* ch = chan_new<int>(8);
for (i in 1..4) { chan_send(ch, i * i); }   // 1, 4, 9 -> 14

5.Herramientas

Un solo binario, eskiuc, se encarga de todo. eskiuc run compila y ejecuta de una vez; eskiuc build genera un binario nativo. La biblioteca estándar viene incluida, así que los imports funcionan sin configurar nada.

$ eskiuc run app.esk          # compila + ejecuta en un paso
$ eskiuc build app.esk -o app  # emite un binario nativo independiente
$ eskiuc --version

Pruébalo

Edita el programa de abajo y córrelo. El servidor lo compila con LLVM y lo ejecuta con el mismo eskiuc run.

La salida aparece aquí. Presiona Ejecutar (o ⌘/Ctrl + Enter).

6.En producción

Eskiu ya se usa para reemplazar código nativo sensible a la memoria y pipelines criptográficos en software que ya está en producción, y para llegar a hardware que un lenguaje de sistemas joven rara vez toca.

Ya lo usan: ReactVision, The Morrow Digital.

7.Instalación

Descarga un binario precompilado, descomprímelo en /usr/local y ejecuta eskiuc --version.

Windows es experimental: el compilador corre y emite objetos; el linking end-to-end, las excepciones y la red aún se están portando en 0.7.x.

# o compila desde el código fuente
$ git clone https://github.com/doranteseduardo/eskiu
$ cd eskiu && make