eskiuv0.12.0
EN / ES Instalar 0.12.0
Inicio rápido

Pon Eskiu a correr

Instala el compilador, escribe tu primer programa y córrelo. Unos cuantos minutos de principio a fin, sin toolchain que armar.

Instalación

En macOS o Linux, el script de instalación elige el build para tu máquina y lo pone en tu PATH:

curl -fsSL https://eskiu-lang.org/install.sh | sh
eskiuc --version
Eskiu 0.12.0 (LLVM ...)

Con Homebrew:

brew install eskiu-lang/eskiu/eskiu

O descarga el archivo de un release y descomprímelo donde quieras: trae bin/eskiuc y la biblioteca estándar en lib/eskiu/stdlib/. En Windows, descomprímelo y agrega su carpeta bin al PATH.

↓ macOS (Apple Silicon) ↓ Linux (x86-64) ↓ Linux (arm64) ↓ Windows (x86-64)

Para enlazar hace falta un toolchain de C en tu máquina (clang o gcc), el mismo al que llaman Rust y Clang para generar un binario. macOS lo trae con las Command Line Tools de Xcode; en Linux, instala build-essential (o gcc); en Windows, MinGW de MSYS2. Windows se valida de punta a punta en un runner nativo de CI, pero todavía no forma parte del release gate.

Hola, Eskiu

Un archivo de instrucciones corre como script. Crea hello.esk:

import <io>;

println("Hello, Eskiu!");
eskiuc run hello.esk
Hello, Eskiu!

eskiuc run genera un binario nativo, lo corre y limpia. Los programas más grandes tienen un main: 

import <io>;

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

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

Para conservar el binario, dale un nombre; un nombre .o se queda en el archivo objeto:

eskiuc hello.esk -o hello && ./hello
eskiuc hello.esk -o hello.o

Un struct con un método

Un método se escribe dentro del struct, o como una función Point_sum(Point* self); p.sum() llama a cualquiera de los dos. Un literal de struct nombra sus campos, y los que faltan empiezan en cero. 

import <io>;

struct Point {
    int x;
    int y;

    int sum() {
        return self.x + self.y;
    }
}

int main() {
    let p: Point = Point{x: 3, y: 7};
    printf("sum = %d\n", p.sum());   // sum = 10
    return 0;
}

Memoria que tú manejas

alloc<T>(n) de <mem> da n elementos de tipo T en cero, y defer los libera sin importar cómo termine la función: 

import <io>;
import <mem>;

int main() {
    *int buf = alloc<int>(4);
    defer free(buf);
    for (i in 0..4) {
        buf[i] = (i + 1) * 10;
    }
    printf("sum = %d\n", buf[0] + buf[1] + buf[2] + buf[3]);   // sum = 100
    return 0;
}

Lambdas

Las funciones son valores. Una lambda tiene la sintaxis de una función, sin el nombre:

import <io>;

int apply(fn(int)->int f, int x) {
    return f(x);
}

int main() {
    let double_it: fn(int)->int = int(int x) { return x * 2; };
    printf("%d\n", double_it(5));          // 10
    printf("%d\n", apply(double_it, 4));   // 8
    return 0;
}

Un proyecto con paquetes

eskiuc new crea un paquete, y eskiuc add trae otro desde git. Un paquete que usa una biblioteca de C la descarga en el primer build: 

eskiuc new myapp && cd myapp
eskiuc add onnx --git https://github.com/eskiu-lang/onnx --rev v0.1.0
eskiuc run

La página de paquetes lista los oficiales.

Qué sigue