Zig (lenguaje de programación)

El objetivo principal de Zig es ofrecer una mejor solución para las tareas que actualmente se resuelven con C. Una preocupación fundamental en este sentido es la legibilidad; Zig intenta utilizar conceptos y sintaxis existentes siempre que sea posible, evitando añadir sintaxis diferentes para conceptos similares. Además, su objetivo es ser un lenguaje diseñado para la robustez, la optimización y la mantenibilidad. La sintaxis pequeña y sencilla es una parte importante de esa mantenibilidad, ya que uno de los objetivos del lenguaje es permitir a los mantenedores depurar código escrito en Zig sin tener que aprender las complejidades de un lenguaje con el que quizás no estén familiarizados. ^{[ 18 ]} Incluso con estos cambios, Zig puede compilarse en y contra código C existente; los encabezados de C pueden incluirse en un proyecto Zig y sus funciones pueden llamarse, y el código Zig puede vincularse a proyectos C incluyendo los encabezados generados por el compilador. ^{[ 19 ]}

El manejo de errores se realiza mediante tipos de error y se puede manejar con catcho try. Los genéricos se logran mediante la generación de código en tiempo de compilación y la adaptación a una forma de tipado dinámico con la comptimedirectiva.

La asignación de memoria en la biblioteca estándar de Zig sigue la convención de que la asignación se maneja a través de structinstrucciones que describen la acción, en lugar de llamar a las funciones de administración de memoria en libc . Por ejemplo, en C, si se quiere escribir una función que cree una cadena que contenga múltiples copias de otra cadena, la función podría tener este aspecto:

const char * repeat ( const char * original , size_t times );

En el código, la función examinaría el tamaño originaly luego timesasignaría memoria con `malloc` para reservar esa longitud para la cadena que construirá. Esta asignación es invisible para las funciones que la llaman; si no liberan la memoria posteriormente, se producirá una fuga de memoria. En Zig, esto podría manejarse usando una función como:

const Asignador = std.mem.Asignador ;​​​​fn repeat ( allocator : Allocator , original : [] const u8 , times : usize ) Allocator . Error ! [] const u8 ;

En este código, a la allocatorvariable se le pasa una estructura que describe qué código debe realizar la asignación, y la repeatfunción devuelve la cadena resultante o, utilizando el tipo opcional indicado por !, un Allocator.Error. Al expresar directamente el asignador como entrada, la asignación de memoria nunca se "oculta" dentro de otra función, sino que siempre se expone a la API mediante la función que finalmente solicita la memoria que se va a asignar. No se realizan asignaciones dentro de la biblioteca estándar de Zig . Además, como la estructura puede apuntar a cualquier cosa, se pueden usar asignadores alternativos, incluso los escritos en el programa. Esto puede permitir, por ejemplo, asignadores de objetos pequeños que no utilizan las funciones del sistema operativo que normalmente asignan una página de memoria completa . ^{[ 20 ]}

Los tipos opcionales son un ejemplo de una característica del lenguaje que ofrece funcionalidad general sin dejar de ser simple y genérica. No es necesario usarlos para resolver problemas de punteros nulos; también son útiles para cualquier tipo de valor donde "ningún valor" sea una respuesta apropiada. Consideremos una función countTheNumberOfUsersque devuelve un entero y una variable entera theCountedUsersque almacena el resultado. En muchos lenguajes, se colocaría un número mágicotheCountedUsers para indicar que countTheNumberOfUsersaún no se ha llamado a la función, mientras que muchas implementaciones simplemente lo establecerían a cero. En Zig, esto podría implementarse como un valor que establece la variable a un valor claro de "no se ha llamado". ^{[ 20 ]}vartheCountedUsers:?i32=null

Otra característica más general de Zig que también ayuda a gestionar los problemas de memoria es el concepto de defer, que marca cierto código para que se ejecute al final de un ámbito pase lo que pase, incluidos los posibles errores de tiempo de ejecución. Si una función en particular asigna memoria y luego la libera cuando la operación se completa, se puede agregar una línea para diferir un freey asegurar que se libere pase lo que pase. ^{[ 20 ]}

La biblioteca estándar de Zig evita las asignaciones ocultas. La asignación no se gestiona directamente en el lenguaje. En cambio, el acceso al montón se realiza a través de la biblioteca estándar , explícitamente. ^{[ 21 ]}

Zig promueve un enfoque gradual hacia la portabilidad que combina el nuevo código Zig con el código C existente. Para ello, busca que la interacción con las bibliotecas C existentes sea lo más fluida posible. Zig importa sus propias bibliotecas con la @importdirectiva, generalmente de esta manera:

const std = @import ( "std" );

El código Zig dentro de ese archivo ahora puede llamar a funciones dentro de std, por ejemplo:

std.debug.print ( " ¡ Hola, mundo! \ n " , . { });

Para trabajar con código C, simplemente se reemplaza @importpor @cImport:

const c = @cImport ( @cInclude ( "soundio/soundio.h" ));

El código Zig ahora puede llamar a funciones de la biblioteca soundio como si fueran código Zig nativo. Como Zig utiliza nuevos tipos de datos que se definen explícitamente, a diferencia de los más genéricos de C int, floatse utiliza un pequeño número de directivas para transferir datos entre los tipos de C y Zig, incluidas @intCasty @ptrCast. ^{[ 20 ]}

Zig 0.16.0 está obsoleto @cImport; en adelante, la traducción a C se gestionará a través del sistema de compilación en lugar de utilizar la @cImportfunción integrada del lenguaje, que ha sido eliminada. Además, esta versión está obsoleta std.Build.Step.TranslateC y se recomienda utilizar una dependencia explícita del paquete oficial translate-c, que es la misma implementación que la versión anterior del paso de compilación con opciones de configuración adicionales. ^{[ 22 ]}

Como resultado, el ejemplo utilizado anteriormente para la inclusión de código C, tal como lo usaban las versiones de Zig antes del cambio, requiere migración; cualquier archivo de encabezado C tendría que importarse usando el sistema de compilación. Para migrar el ejemplo anterior, por ejemplo, se requiere la creación de un archivo de encabezado simple con líneas de inclusión C estándar añadidas: ^{[ 23 ]}

#include <soundio/soundio.h>

Este archivo de encabezado debe referenciarse de la siguiente manera dentro del build.zigarchivo utilizado por el proyecto (en este ejemplo, el archivo se ha nombrado c.hen el srcdirectorio): ^{[ 22 ]}

const Translator = @import ( "translate_c" ). Translator ;const translate_c = b . dependency ( "translate_c" , .{});const traductor : Traductor = .init ( translate_c , .{ .c_source_file = b .path ( " src /ch" ) , .target = target , .optimize = optimize , } ) ; traductor .linkSystemLibrary ( "soundio" , . { });const exe = b . addExecutable (.{ . name = "hello-sound" , . root_module = b . createModule (.{ . root_source_file = b . path ( "src/main.zig" ), . optimize = optimize , . target = target , . imports = & .{ .{ . name = "c" , . module = translator . mod , }, }, }), });

Tras el cambio para llamar a las funciones de la biblioteca soundio, se requeriría lo siguiente en el código nativo de Zig:

const c = @import ( "c" );

Al usar la comptimepalabra clave, el programador puede hacer que Zig evalúe explícitamente secciones de código en tiempo de compilación , en lugar de en tiempo de ejecución . Poder ejecutar código en tiempo de compilación permite que Zig tenga la funcionalidad de macros y compilación condicional sin necesidad de un lenguaje de preprocesador independiente . ^{[ 24 ]}

Durante el tiempo de compilación, los tipos se convierten en ciudadanos de primera clase . Esto permite el tipado dinámico en tiempo de compilación y es como Zig implementa los tipos genéricos. ^{[ 15 ]}

Por ejemplo, en Zig, un tipo genérico de lista enlazada podría implementarse utilizando una función como:

fn ListaEnlazada ( comptime T : tipo ) tipo ;

Esta función recibe un tipo de dato Ty devuelve structuna lista enlazada personalizada que define ese tipo de dato.

const std = @import ( "std" ); const FormatOptions = std . fmt . FormatOptions ; const stdout = std . io . getStdOut (). writer ();fn LinkedList ( comptime T : type ) type { return struct { const Self = @This ();pub const Nodo = struct { siguiente : ?* Nodo = null , datos : T , };primero : ?* Nodo = null ,pub fn prepend ( lista : * Self , nuevo_nodo : * Nodo , ) void { nuevo_nodo . siguiente = lista . primero ; lista . primero = nuevo_nodo ; }pub fn format ( list : Self , comptime fmt : [] const u8 , options : FormatOptions , out_stream : anytype , ) ! void { try out_stream . writeAll ( "( " );var it = list . first ; while ( it ) | node | : ( it = node . next ) { try std . fmt . formatType ( node . data , fmt , options , out_stream , 1 , );prueba out_stream.writeAll ( " " ) ; }prueba out_stream.writeAll ( " )" ); } } ; }pub fn main () ! void { const ListU32 = LinkedList ( u32 );lista var = ListaU32 {}; var nodo1 = ListaU32 . Nodo { . datos = 1 }; var nodo2 = ListaU32 . Nodo { . datos = 2 }; var nodo3 = ListaU32 . Nodo { . datos = 3 };lista.anteponer ( & nodo1 ) ; lista.anteponer ( & nodo2 ) ; lista.anteponer ( & nodo3 ) ;​​​try stdout . print ( "{} \n " , .{ list }); try stdout . print ( "{b} \n " , .{ list }); }

Producción:

( 3 2 1 ) ( 11 10 1 )

const std = @import ( "std" ); const ArenaAllocator = std . heap . ArenaAllocator ; const Allocator = std . mem . Allocator ;fn repeat ( allocator : Allocator , original : [] const u8 , times : usize , ) Allocator . Error ! [] u8 { const buffer = try allocator . alloc ( u8 , original . len * times , );para ( 0 .. veces ) | i | { std . mem . copyForwards ( u8 , buffer [( original . len * i )..], original , ); }devolver buffer ; }pub fn main () ! void { var arena = ArenaAllocator . init ( std . heap . page_allocator , ); defer arena . deinit ();const asignador = arena.allocator ( ) ;const original = "Hola " ; const repetido = intentar repetir ( asignador , original , 3 , );std.debug.print ( " { s} \ n " , .{ repetido } ) ; }

Producción:

Hola Hola Hola

• Elizabeth, Jane (19 de octubre de 2017). "¿Cansado de C? El nuevo lenguaje de programación Zig pretende ser más pragmático y legible" . jaxenter . Archivado del original el 1 de octubre de 2020. Consultado el 22 de abril de 2020 .
• Yegulalp, Serdar (29 de agosto de 2016). "Un nuevo competidor se une a Rust para derrocar al lenguaje C" . InfoWorld . Recuperado el 11 de febrero de 2020 .