Saltar al contenido principal

Hew

Hew compila programas basados en actores a código nativo. Cada actor posee su estado y los supervisores deciden cómo se reinician los actores que fallan.

Leer estado actual · GitHub

El estado permanece con el actor

Este actor de sesión posee su vector de mensajes. post es el único código que lo modifica y cada llamada espera a que el handler termine antes de devolver un Result.

count lee el mismo estado privado y devuelve el valor al caller. El caso de error permanece visible porque el actor puede haberse detenido antes de terminar la llamada.

Leer el modelo de actores → EN
session.hew
// A chat session is an actor: state lives in fields and only its handlers
// can mutate it. Ordinary actor calls wait for the handler and return a
// Result, whether or not the handler itself returns a value.
actor Session {
    let user: string;
    var messages: Vec<string> = Vec.new();
    receive fn post(text: string) {
        messages.push(text);
    }
    receive fn count() -> i64 {
        messages.len()
    }
}
 
fn main() {
    let chat = spawn Session { user: "ada", messages: [] };
    chat.post("hello").expect("actor stopped");
    chat.post("world").expect("actor stopped");
    let total = chat.count();
    match total {
        .Ok(n) => println(f"{n} messages posted"),
        .Err(_) => println("session unavailable"),
    }
}

Instalar Hew

Elige tu sistema operativo y la versión del compilador.

v0.9.3 · Versión

Lee la guía de instalación completa.

Lo que el lenguaje hace explícito

Las superficies de actores, supervisión, concurrencia y wire disponibles en v0.9.3.

Una llamada a Session
  1. Llamante: chat.post("hello"). Espera el resultado del manejador.
  2. Buzón: post("hello").
  3. Un turno del manejador: messages.push(text). Estado privado: messages: ["hello"].
  4. Resultado de la llamada → Llamante.

Una llamada post exitosa actualiza el estado privado de Session antes de devolver su resultado.

Aislamiento de actores

Cada actor posee su estado de forma exclusiva. El compilador aplica los límites de actores locales y las verificaciones Send.

Árboles de supervisión

Los servicios fallan; Hew lo espera. Los actores supervisores, los presupuestos de reinicio y las estrategias principales de reinicio forman parte del lenguaje, no de un framework aparte.

Concurrencia estructurada

Un scope limita el trabajo hijo y espera a que termine antes de volver; fork inicia llamadas independientes que pueden reunirse después.

Contratos wire

Los tipos wire ponen esquemas, tags de campo y verificaciones de compatibilidad dentro del lenguaje, junto a los actores que los envían.

Diario de ingeniería

Hew 0.6.2: safer values, steadier services Edit parsed configuration without changing its source value, then see how Hew 0.6.2 carries the same actor reference across local and remote services. 21 oct 2026
Leer el Blog → EN

Hew Notes

Language development, engineering articles, releases and community projects. About once a month, with an extra issue for a significant release. Written in English.

Subscribe to Hew Notes