Filosofía de diseño y posición central de Cangjie

El lenguaje Cangjie, como nuevo paradigma en desarrollo de software, tiene como misión equilibrar rendimiento excepcional, seguridad en memoria y concurrencia, junto con alta eficiencia en desarrollo. Su diseño se enfoca en abordar desafíos modernos como la gestión de recursos, la paralelización y la portabilidad multiplataforma.

Seguridad en memoria y concurrancia

Para garantizar la seguridad, Cangjie incorpora un sistema de propiedad y préstamo inspirado en Rust, con comprobaciones en tiempo de compilación para eliminar errores comunes como punteros nulos o datos compartidos sin control. Ejemplo conceptual:

// Mecanismo de seguridad en memoria de Cangjie
función procesar_datos(datos: &mut [entero]) {
    // Operaciones sobre datos mutables
} // El préstamo finaliza aquí

función principal() {
    declarar números = [1, 2, 3, 4, 5];
    procesar_datos(&mut números);
    // No se permiten otros préstamos durante la ejecución
    mostrar!("Números procesados: {:?}", números);
}

La seguridad en concurrencia se logra mediante primitivas integradas, como canales de paso de mensajes o traits de tipo Enviar y Sincronizar que verifican la seguridad de hilos en compilación. Ejemplo con canales:

importar canal::concurrencia;

función principal() {
    declarar (emisor, receptor) = canal::nuevo();

    lanzar(|| { // Tarea concurrente
        declarar mensaje = "Saludo desde otro hilo".a_texto();
        emisor.enviar(mensaje).esperar("Fallo en envío");
    });

    declarar recibido = receptor.recibir().esperar("Fallo en recepción");
    mostrar!("Recibido: {}", recibido);
}

Además, el lenguaje impone verificación de valores opcionales mediante un tipo Opción para evitar excepciones por nulos.

Rendimiento y expresividad

Cangjie busca ofrecer rendimiento cercano a C/C++ con abstracciones de costo cero, compilación AOT y acceso controlado a bajo nivel. Su sintaxis moderna, inspirada en Swift y Kotlin, permite expresar lógica compleja con código conciso, apoyado por un sistema de tipos fuerte con inferencia.

Estructura léxica y palabras clave

La base léxica de Cangjie define tokens significativos. El lenguaje utiliza codificación UTF-8 por defecto para soportar caracteres internacionales en código fuente.

Identificadores y convenciones

Los identificadores pueden contener letras, números y guiones bajos, con distinción de mayúsculas. Ejemplo válido:

declarar nombre_usuario: Texto = "Ana";
función calcular_área(ancho: doble, alto: doble) -> doble { /* ... */ }
estructura Punto2D { x: entero, y: entero }
constante MÁXIMO_REINTENTOS: sin_signo = 3;

Se recomiendan convenciones como snake\_case para variables y funciones, PascalCase para tipos, y MAYÚSCULAS\_SNAKE para constantes.

Palabras clave

El conjunto de palabras clave incluye términos para declaración, control de flujo y tipos, como declarar, mut, constante, función, estructura, enumeración, interfaz, implementar, si, coincidir, para, mientras, bucle, romper, continuar, retorno.

Valores literales y operadores

Cangjie soporta literales numéricos (enteros, flotantes), booleenos, caracteres y cadenas, incluyendo cadenas sin procesar. Operadores abarcan aritméticos, lógicos, bit a bit y de asignación. Ejemplo:

declarar edad: u8 = 30;
declarar pi: f64 = 3.14;
declarar activo: bool = verdadero;
declarar saludo: Texto = "Hola, Cangjie!";
declarar suma = edad + 5;
declarar resultado = (edad > 20) && (pi < 4.0);

Los separadores como paréntesis, corchetes, comas y punto y coma estructuran el código.

Expresiones, sentencias y control de flujo

Las expresiones producen valores, mientras que las sentencias ejecutan acciones. Ejemplos de expresiones incluyen literales, llamadas a funciones y operaciones; las sentencias terminan con punto y coma.

Estructuras de control

Las sentencias condicionales y bucles se implementan con si, coincidir, para, mientras y bucle. Ejemplo de coincidir para coincidencia de patrones:

enumeración Mensaje {
    Salir,
    Mover { x: entero, y: entero },
    Escribir(Texto),
    CambiarColor(entero, entero, entero),
}

función procesar_mensaje(msg: Mensaje) {
    coincidir msg {
        Mensaje::Salir => mostrar!("Aplicación cerrada."),
        Mensaje::Mover { x, y } => mostrar!("Mover a x: {}, y: {}", x, y),
        Mensaje::Escribir(texto) => mostrar!("Escribir: {}", texto),
        Mensaje::CambiarColor(r, g, b) => mostrar!("Color: R:{}, G:{}, B:{}", r, g, b),
    }
}

Manejo de errores

Se utiliza un tipo Resultado<t e=""> para errores recuperables, con un operador ? para propagación simplificada. Ejemplo:

importar archivo::io;
importar error::io;

función leer_usuario_desde_archivo() -> Resultado<texto error=""> {
    declarar archivo = archivo::abrir("datos.txt")?; // Propagación de error
    declarar contenido = Texto::nuevo();
    archivo.leer_a_texto(&mut contenido)?;
    Ok(contenido)
}
</texto>

Sistema de tipos y genéricos

Cangjie es un lenguaje de tipos estáticos y fuertes, con comprobación en compilación para mayor seguridad. Soporta tipos primitivos como enteros, flotantes, booleanos, caracteres y textos, además de tipos compuestos como estructuras y enumeraciones algebraicas.

Estructuras y enumeraciones

Las estructuras agrupan datos heterogéneos, y las enumeraciones definen tipos con variantes que pueden contener datos. Ejemplo:

estructura Usuario {
    id: sin_signo,
    nombre_usuario: Texto,
    correo: Texto,
    activo: bool,
}

enumeración EventoWeb {
    CargaPágina,
    DescargaPágina,
    PulsarTecla(carácter),
    Pegar(Texto),
    Clic { x: entero, y: entero },
}

Genéricos y restricciones

Los genéricos permiten reutilización de código con tipos parametrizados, restringidos por interfaces. Ejemplo de función genérica:

función mayor<t: copiar="" parcialorden="">(lista: &[T]) -> T {
    declarar mayor_valor = lista[0];
    para elemento en lista.iter() {
        si elemento > mayor_valor {
            mayor_valor = elemento;
        }
    }
    mayor_valor
}
</t:>

Seguridad de nulos e inferencia de tipos

El tipo Opción<t> maneja valores ausentes de forma segura. La inferencia de tipos reduce anotaciones explícitas, basándose en el contexto del código.

Clases, interfaces y extensión

Cangjie favorece la composición sobre la herencia, utilizando estructuras con bloques de implementación para métodos. Las interfaces definen contratos de comportamiento para polimorfismo. Ejemplo de interfaz:

interfaz Dibujable {
    fn dibujar(&self);
    fn obtener_color(&self) -> Texto;
}

estructura Cuadrado {
    lado: doble,
    color: Texto,
}

implementar Dibujable para Cuadrado {
    fn dibujar(&self) {
        mostrar!("Dibujar cuadrado con lado {} y color {}", self.lado, self.color);
    }
    fn obtener_color(&self) -> Texto {
        self.color.clonar()
    }
}

Los métodos de extensión permiten añadir funcionalidades a tipos existentes sin modificar su definición original.

Sistema de macros y metaprogramación

Las macros en Cangjie facilitan la generación de código en compilación, con macros declarativas para sustitución basada en patrones y macros procedurales para manipulación avanzada de AST. Ejemplo de macro declarativa:

macro_reglas! imprimir_debug {
    ($expr:expr) => {
        mostrar!("{}: {:?}", texto_de!($expr), $expr);
    };
}

función principal() {
    declarar valor = 42;
    imprimir_debug!(valor); // Expande a mostrar!("valor: {:?}", valor);
}

Las macros derivadas pueden implementar interfaces automáticamente, como serialización o depuración.

Comparación con lenguajes existentes

Frente a C++, Cangjie elimina la gestión manual de memoria y complejidad, manteniendo rendimiento similar con mayor seguridad. Comparado con Rust, busca una curva de aprendizaje más suave sin sacrificar seguridad. En contraste con Swift, se enfoca en rendimiento de bajo nivel con costos de ejecución reducidos, ideal para sistemas multiplataforma.

Innovaciones potenciales encluyen soporte nativo para WebAssembly, integración de concurrencia con async/await, y un sistema de módulos avanzado con gestión de versiones.