Zig (programozási nyelv)

A Zig egy imperatív, általános célú, statikusan tipizált, fordított rendszerprogramozási nyelv, amelyet Andrew Kelley tervezett. A C nyelv utódjának szánják, azzal a szándékkal, hogy még kisebb és egyszerűbb legyen a programozás, ugyanakkor több funkciót kínáljon. A Zig szabad és nyílt forráskódú szoftver, amelyet MIT licenc alatt adnak ki.

Zig
Paradigma	imperatív (procedurális), strukturált, generikus
Jellemző kiterjesztés	.zig, .zir, .zigr, .zon
Megjelent	2015
Tervező	Andrew Kelley
Fejlesztő	Andrew Kelley
Utolsó kiadás	0.13.0 (2024. június 6.)
Típusosság	statikus, következtetett
Hatással volt rá	C C++ Go Rust JavaScript
Licenc	MIT
Weboldal

A nyelv egyszerűségét érintő fejlesztések a folyamatkezelésre, a függvényhívásokra, a könyvtárimportra, a változók deklarálására és a Unicode támogatásra vonatkoznak. A nyelv nem használ makrókat vagy preprocesszor utasításokat. A modern nyelvekből átvett funkciók közé tartozik a fordítási idejű általános típusok hozzáadása, amelyek lehetővé teszik, hogy a függvények különböző adatokkal dolgozzanak, valamint egy kis számú új fordítói utasítás, amely lehetővé teszi a típusokra vonatkozó információk elérését a tükrözés segítségével.

A Zig egy másik kiegészítése a kódbiztonságot hivatott javítani. A C-hez hasonlóan a Zig nem tartalmaz szemétgyűjtést (garbage collection), és a memóriakezelés manuális. Az ilyen rendszerekben felmerülő potenciális hibák kiküszöbölése érdekében tartalmaz opciós típusokat és egyszerű szintaxist a használatukhoz. A nyelvbe egy tesztelési keretrendszer is beépítésre került.

Leírás

Célok

A Zig elsődleges célja, hogy jobb megoldást kínáljon a jelenleg C-vel megoldott feladatokra. Ebben a tekintetben elsődleges szempont az olvashatóság; a Zig megpróbálja a meglévő fogalmakat és szintaxist használni, ahol csak lehetséges, elkerülve a hasonló fogalmak eltérő szintaxisának hozzáadását. Továbbá a „robusztusság, optimalizálás és karbantarthatóság” érdekében tervezték, számos olyan funkciót tartalmaz, amelyek javítják a biztonságot, az optimalizálást és a tesztelést. A kis és egyszerű szintaxis fontos része a karbantartásnak, mivel a nyelv célja, hogy a karbantartók anélkül tudják hibakeresni a kódot, hogy meg kellene tanulniuk egy olyan nyelv bonyolultságát, amelyet esetleg nem ismernek. A Zig még ezekkel a változtatásokkal együtt is képes a meglévő C kódba és a meglévő C kóddal szemben fordítani; a C fejléceket („header”) be lehet építeni egy Zig projektbe, azok függvényeit meg lehet hívni, és a Zig kódot a fordító által készített fejlécek beépítésével be lehet linkelni a C projektekbe.

A kód egyszerű és könnyen olvashatóvá tételének általános tervezési filozófiájával összhangban a Zig rendszer egésze számos stilisztikai változást is tartalmaz a C-hez és más C-szerű nyelvekhez képest. A Rust nyelv például rendelkezik operátor-túlterheléssel, ami azt jelenti, hogy az a = b + c típusú utasítás valójában a plus operátor egy típushoz tartozó, túlterhelt változatának függvényhívása lehet. Továbbá, ez a függvény pánikba eshet, ami megelőzheti a következő kódot. A Zig-ben, ha valami meghív egy függvényt, akkor az függvényhívásnak tűnik, ha nem, akkor nem függvénynek. Ha hibát vet fel, az explicit a szintaxisban a hibakezelés hibatípusokon keresztül történik, és catch vagy try segítségével kezelhető.

A Zig céljai ellentétben állnak sok más, ugyanebben az időszakban tervezett nyelvvel, mint például a Go, a Rust, a Carbon és a Nim. Ezek a nyelvek általában összetettebbek, olyan kiegészítő funkciókkal, mint az operator overloading, az értékeknek (tulajdonságoknak) álcázott függvények és sok más, a nagyméretű programok felépítését segíteni hivatott funkció. Ezek a fajta funkciók inkább a C++ megközelítésével közösek, és ezek a nyelvek inkább annak a nyelvnek a vonalait követik. A Zig a típusrendszer konzervatívabb kiterjesztése, amely támogatja a fordítási idejű generikusokat, és a comptime direktívával a „kacsatipizálás” egy formáját alkalmazza.

A memória kezelése

A C programokban a hibák egyik elsődleges forrása a memóriakezelő rendszer, amelynek alapja a malloc. A malloc egy memóriablokkot különít el a kódban való használatra, és egy hivatkozást ad vissza erre a memóriára mutató formájában (pointer). Nincs olyan rendszer, amely biztosítaná, hogy a memória felszabaduljon, amikor a programnak már nincs rá szüksége, ami ahhoz vezethet, hogy a programok az összes rendelkezésre álló memóriát felhasználják, ami memóriaszivárgást jelent. Gyakoribb a lógó mutató, amely nem megfelelően kiosztott memóriaobjektumra hivatkozik.

Ezekre a problémákra gyakori megoldás a szemétgyűjtő (GC), amely megvizsgálja a programot a korábban betöltött memóriára mutató mutatók után, és eltávolítja azokat a blokkokat, amelyekre már nem mutat semmi. Bár ez nagymértékben csökkenti, vagy akár meg is szünteti a memóriahibákat, a GC rendszerek viszonylag lassúak a kézi (utasítással előírt) memóriakezeléshez képest, és kiszámíthatatlan a teljesítményük, ami alkalmatlanná teszi őket a rendszerprogramozásra. Egy másik megoldás az automatikus referenciaszámlálás (ARC), amely ugyanazt az alapkoncepciót valósítja meg a használaton kívüli memóriablokkok azonosítására, de ezt a mutató létrehozásakor és megsemmisítésekor az adott blokkra mutató mutatók számának rögzítésével teszi, ami azt jelenti, hogy nincs szükség kimerítő mutatókeresésre, hanem minden malloc (allokálás) és release (felszabadítás) művelethez hozzáadódik a referenciaszámláló beállításának többletköltsége.

A Zig célja, hogy a C-hez hasonló vagy annál jobb teljesítményt nyújtson, ezért a GC és az ARC nem megfelelő megoldások. Ehelyett egy modern, 2022-től kezdődő koncepciót használ, az úgynevezett opciós típusokat. Ahelyett, hogy egy mutató a semmire vagy nil-re mutathatna, egy külön típust használunk az opcionálisan üres adatok jelölésére. Ez hasonló ahhoz, mintha egy struktúrát használnánk egy mutatóval és egy boolean értékkel, amely jelzi, hogy a mutató érvényes-e, de a boolean állapotát a nyelv láthatatlanul kezeli, és nem kell a programozónak explicit módon kezelnie. Így például a mutató deklarálásakor „nem allokált” állapotba kerül, és amikor ez a mutató értéket kap egy malloc-tól, akkor „allokált” állapotba kerül, ha a malloc sikeres volt.

Ennek a modellnek az az előnye, hogy nagyon alacsony vagy nulla overheaddel jár; a fordítónak kell létrehoznia a kódot, hogy a mutatók manipulálásakor továbbadja az opcionális típust, szemben egy egyszerű mutatóval, de ez lehetővé teszi, hogy közvetlenül kifejezze az esetleges memóriaproblémákat fordítási időben, futásidejű támogatás nélkül. Például egy null értékű mutató létrehozása, majd annak felhasználási kísérlete tökéletesen elfogadható C-ben, ami nullmutató hibához vezet (null pointer assignment). Ezzel szemben egy opcionális típusokat használó nyelv ellenőrizni tudja, hogy minden kódút csak akkor próbálja meg használni a mutatókat, ha azok érvényesek. Ez ugyan nem küszöböli ki az összes lehetséges problémát, de ha futásidőben problémák merülnek fel, a hiba pontosabban lokalizálható és megmagyarázható.

Egy másik változás a memóriakezelésben a Zigben az, hogy a tényleges kiosztás a műveletet leíró struktúrákon (struct) keresztül történik, szemben a libc memóriakezelő függvényeinek meghívásával. Például, ha C nyelven olyan függvényt akarunk írni, amely egy másik karakterlánc többszörös másolatát tartalmazó karakterláncot készít, a függvény így nézhet ki:

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

A kódban a függvény megvizsgálná az original méretét, majd a times malloc-méretét, hogy memóriát különítsen el a felépítendő karakterlánc számára. Ez a malloc láthatatlan az azt hívó függvények számára, ha nem sikerül később felszabadítani a memóriát, szivárgás lép fel. A Zig-ben ezt egy olyan függvénnyel lehetne kezelni, mint a következő:

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

Ebben a kódban az allocator változónak átadunk egy struktúrát, amely leírja, hogy milyen kódnak kell végrehajtania az allokációt, és a repeat függvény vagy az eredményül kapott karakterláncot adja vissza, vagy az opcionális típus használatával, amint azt a ! jelzi, egy Allocator.Error. Azáltal, hogy az allokátor közvetlenül bemenetként van kifejezve, a memória kiosztása soha nem „rejtőzik” egy másik függvényen belül, hanem mindig az a függvény teszi hozzáférhetővé az API számára, amely végül a memória kiosztását kéri. A Zig szabványos könyvtárán belül nem történik allokálás. Továbbá, mivel a struktúra bármire mutathat, használhatunk alternatív allokátorokat, akár a programban írtakat is. Ez lehetővé teheti például olyan kis objektum-allokátorok használatát, amelyek nem használják az operációs rendszer azon függvényeit, amelyek általában egy teljes memóriaoldalt allokálnak.

Az opcionális típusok egy olyan nyelvi jellemző példája, amely általános funkcionalitást kínál, miközben egyszerű és általános. Nem feltétlenül a nullmutatós problémák megoldására kell használni őket, hanem minden olyan értéktípusnál hasznosak, ahol a „nincs érték” megfelelő válasz. Tekintsünk egy countTheNumberOfUsers függvényt, amely egy egész számot ad vissza, és egy egész szám változót, theCountedUsers-t, amely az eredményt tartalmazza. Sok nyelvben a theCountedUsers változóba egy bűvös számot helyeznének el, hogy jelezzék, hogy a countTheNumberOfUsers még nem került meghívásra, míg sok implementáció egyszerűen nullára állítja azt. A Zig-ben ez úgy valósítható meg, hogy var theCountedUsers: ?i32 = null, ami a változót egyértelműen „nem hívták meg” értékre állítja.

A Zig egy másik általánosabb funkciója, amely szintén segít a memóriaproblémák kezelésében, a defer fogalma, amely bizonyos kódokat jelöl meg, amelyeket a függvény végén kell végrehajtani, függetlenül attól, hogy mi történik, beleértve az esetleges futásidejű hibákat is. Ha egy adott függvény memóriát foglal, majd a művelet befejeztével el is távolítja azt, akkor hozzáadhatunk egy sort, hogy elhalasszunk egy free-t, hogy biztosítsuk, hogy az felszabaduljon, bármi történjen is.

A Zig memóriakezelés elkerüli a rejtett allokációkat. A kiosztás nem közvetlenül a nyelvben történik. Ehelyett a halomhoz való hozzáférés egy szabványos könyvtárban történik, explicit módon.

Közvetlen interakció a C-vel

A Zig elősegíti a nyelv használatának evolúciós megközelítését, amely az új Zig kódot a meglévő C kóddal kombinálja. Ennek érdekében arra törekszik, hogy a meglévő C könyvtárakkal való kölcsönhatás a lehető legzökkenőmentesebb legyen. A Zig a saját könyvtárait az @import utasítással importálja, jellemzően ilyen módon:

const std = @import("std");

A fájlon belüli zig-kód mostantól std-n belüli függvényeket hívhat meg, például:

std.debug.print("Hello, world!\n", .{});

A C kóddal való munkához egyszerűen cserélje le az @import-ot @cImport-ra:

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

A Zig kód mostantól úgy hívhatja a soundio könyvtár függvényeit, mintha azok natív Zig kódok lennének. Mivel a Zig új, explicit módon definiált adattípusokat használ, ellentétben a C általánosabb int és float típusaival, az adatok C és Zig típusok közötti mozgatására néhány direktívát használunk, köztük az @intCast és @ptrCast-ot.

Cross compiling

A Zig a keresztfordítást a nyelv első osztályú felhasználási eseteként kezeli. Ez azt jelenti, hogy bármelyik Zig fordító képes futtatható binárisokat fordítani bármelyik célplatformra, amelyekből több tucat van. Ezek közé nemcsak a széles körben használt modern rendszerek tartoznak, mint az ARM és az x86-64, hanem a PowerPC, SPARC, MIPS, RISC-V és még az IBM z/Architektúrák (S390) is. Az eszközlánc bármelyik ilyen célrendszerre képes fordítani további szoftverek telepítése nélkül, minden szükséges támogatás megtalálható az alaprendszerben.

Comptime

A comptime kulcsszó használatával a programozó kifejezetten elérheti, hogy a Zig a kód egyes részeit a fordítási időben értékelje ki, nem pedig futásidőben. A kód fordítási időben történő futtatásának lehetősége lehetővé teszi a Zig számára a makrók és a feltételes fordítás funkcionalitását anélkül, hogy külön előfeldolgozó nyelvre lenne szükség.

A fordítási idő alatt a típusok első osztályú polgárokká válnak. Ez lehetővé teszi a fordítási idejű kacsatipizálást, és a Zig így valósítja meg a generikus típusokat.

Például a Zigben egy generikus láncolt lista típus egy ilyen függvény segítségével valósulhat meg:

fn LinkedList(comptime T: type) type;

Ez a függvény valamilyen T típust vesz fel, és egy egyéni struct-ot ad vissza, amely egy láncolt listát definiál az adott adattípussal.

A név eredete

A „Zig” nevet állítólag egy olyan eljárás során választották ki, amelyben egy Python-szkript véletlenszerűen kombinálta a „Z” betűvel kezdődő és egy magánhangzóval vagy „Y”-val követett betűket, hogy négybetűs szavakat hozzon létre. A tervezett hosszúság ellenére a szkript által előállított különböző kombinációk közül végül a három betűből álló „Zig” szót választották ki.

Egyéb jellemzők

A Zig támogatja az általános fordítási időket, a tükrözést és kiértékelést, a keresztfordítást és a kézi memóriakezelést. A nyelv egyik fő célja a C nyelv fejlesztése, miközben többek között Rustból is merít ihletet. A Zig számos funkcióval rendelkezik az alacsony szintű programozáshoz, nevezetesen a csomagolt struktúrák (a mezők közötti kitöltés nélküli struktúrák), a tetszőleges szélességű egész számok és a többszörös mutatótípusok.

A Zig nem csak egy új nyelv: tartalmaz egy C/C++ fordítót is, és bármelyik vagy mindkét nyelven használható.

Hátrányok

A Zig-nek számos hátránya van. Ha a memória nincs megfelelően felszabadítva, az a rejtett vezérlés hiánya miatt memóriaszivárgáshoz vezethet. A Zig tanulási görbéje meredek lehet, különösen azok számára, akik nem ismerik az alacsony szintű programozási koncepciókat. Bár a zig közössége egyre növekszik, 2024-től ez továbbra is új nyelv marad, ahol az érettség, az ökoszisztéma és a szerszámok terén még javítani kell. A más nyelvekkel való interoperabilitás kihívásokat jelenthet, mivel gyakran több erőfeszítést igényel az adatsorolás és a kommunikáció kezelése. Végül, a tanulási források elérhetősége korlátozott az összetett felhasználási esetekben, bár ez fokozatosan javul, ahogy az érdeklődés és az elfogadottság nő.

Verziók

A 0.10-es verzió óta az (új alapértelmezett) Zig fordító a Zig programozási nyelven íródott, azaz egy önfordító fordító, és ez egy fontos újdonsága ennek a kiadásnak. A régebbi, C++ nyelven írt, régebbi bootstrapping fordító továbbra is választható, de a 0.11-es verzióban már nem lesz. Az új Zig fordítóval történő fordítás során sokkal kevesebb memóriát használ és egy kicsit gyorsabban fordít. A régebbi, most már örökölt, C++ alapú fordító 3,5x több memóriát használ.

A Zig alapértelmezett optimalizálási háttere továbbra is az LLVM, az LLVM pedig C++ nyelven íródott. A Zig fordító az LLVM-mel 169 MiB, míg LLVM nélkül 4,4 MiB. Az új Zig-lang alapú fordítóval általában gyorsabb futtatható kódot fordítanak, az LLVM kódgenerálása jobb, és sok hibát kijavít, de a régebbi legacy fordítóhoz is vannak fejlesztések a 0.10-es verzióban. A saját fejlesztésű linker szorosan kapcsolódik a saját fejlesztésű fordítóhoz. Az új verzió emellett kísérleti (tier-3) támogatást ad az AMD GPU-knak (van még egy kisebb támogatás az Nvidia GPU-knak és a PlayStation 4 és 5 számára is).

A régebbi bootstrapping ("stage1") fordító Zig és C++ nyelven íródott, LLVM 13-at használ háttérként, amely számos natív célt támogat. A fordító ingyenes és nyílt forráskódú szoftver, amelyet MIT Licenc alatt adtak ki. A Zig fordító lehetővé teszi a C és C++ fordítását a Clang-hez hasonlóan a zig cc és zig c++ parancsokkal, számos fejlécet biztosítva, beleértve a C standard könyvtárat (libc) és a C++ Standard Library (libcxx) számos különböző platformra. A Zig cc és c++ alparancsai keresztfordítóként működnek.

Ráadásul az operációs rendszerek (főleg az asztaliak) hivatalosan támogatottak (és dokumentáltak), (minimális) alkalmazások készülhetnek és készültek is Androidra (Android NDK-val), és iOS-re is lehet programozni.

A 0.11.0 verzió előtt a Zig nem rendelkezett csomagkezelővel, de a 0.11.0-ban megjelent egy kísérleti verzió, amelyet a 0.12.0 verzióban tovább bővítettek. Nincs hivatalos csomagtár; ehelyett a csomag egyszerűen egy URL, amely egy tömörített fájlra mutat, amely kitömörítve tartalmaz egy szabványos build.zig fájlt (amelyet a Zig fordító konvenció szerint a forráskód lefordításához használ) és ideális esetben egy build.zig.zon fájlt, amely a csomag nevének és verziójának meghatározására szolgál.

A Zig fejlesztését a Zig Software Foundation (ZSF), egy nonprofit társaság finanszírozza, amelynek Andrew Kelley az elnöke, amely adományokat fogad el és több teljes munkaidős alkalmazottat alkalmaz.

Példák

Hello World

const std = @import("std");

pub fn main() !void {
    const stdout = std.io.getStdOut().writer();
    try stdout.print("Hello, {s}!\n", .{"world"});
}

Generic linked list

const std = @import("std");
const stdout = std.io.getStdOut().writer();

fn LinkedList(comptime T: type) type {
    return struct {
        const Self = @This();
        pub const Node = struct {
            next: ?*Node = null,
            data: T,
        };

        first: ?*Node = null,

        pub fn prepend(
            list: *Self,
            new_node: *Node,
        ) void {
            new_node.next = list.first;
            list.first = new_node;
        }
        pub fn format(
            list: Self,
            comptime fmt: []const u8,
            options: std.fmt.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,
                );
                try out_stream.writeAll(" ");
            }
            try out_stream.writeAll(")");
        }
    };
}

pub fn main() !void {
    const ListU32 = LinkedList(u32);
    var list = ListU32{};
    var node1 = ListU32.Node{ .data = 1 };
    var node2 = ListU32.Node{ .data = 2 };
    var node3 = ListU32.Node{ .data = 3 };
    list.prepend(&node1);
    list.prepend(&node2);
    list.prepend(&node3);
    try stdout.print("{}\n", .{list});
    try stdout.print("{b}\n", .{list});
}

output

( 3 2 1 ) 
( 11 10 1 )

String ismétlés allokátorral

const std = @import("std");

fn repeat(
    allocator: *std.mem.Allocator,
    original: []const u8,
    times: usize,
) std.mem.Allocator.Error![]const u8 {
    var buffer = try allocator.alloc(
        u8,
        original.len * times,
    );

    for (0..times) |i| {
        std.mem.copyForwards(
            u8,
            buffer[(original.len * i)..],
            original,
        );
    }

    return buffer;
}

pub fn main() !void {
    const stdout = std.io.getStdOut().writer();

    var arena = std.heap.ArenaAllocator.init(
        std.heap.page_allocator,
    );
    defer arena.deinit();

    var allocator = arena.allocator();

    const original = "Hello ";
    const repeated = try repeat(
        &allocator,
        original,
        3,
    );

    // Prints "Hello Hello Hello "
    try stdout.print("{s}\n", .{repeated});
}

output:

Hello Hello Hello

Projektek

• A Bun egy Zig nyelven írt JavaScript és TypeScript futtató, amely a Safari JavaScriptCore virtuális gépét használja.

Kapcsolódó szócikkek

C (programozási nyelv)

Jegyzetek

Irodalom

• Tired of C? New programming language Zig aims to be more pragmatic and readable
• New challenger joins Rust to topple C language
• Mastering Zig Programming (angol nyelven). Independently Published (2023. december 2.). ISBN 979-8870587332 
• Zig Programming Mastery (angol nyelven). Independently Published (2024. június 20.). ISBN 979-8329021424 

További információk

• Honlapja
• Zig a GitHub-on
• Video: Bemutatkozik a Zig
• Zig leírás