ZIG - I booleani

---

I booleani in Zig, definiti tramite la keyword bool, si possono definire "rigidi" e "sicuri". Nel senso che non ammettono molte "divagazioni" e pertanto hanno un comportamento che non dà adito a sorprese, come invece avviene ad esempio nel linguaggio C.
Iniziamo subito con un esempio che chiarisce questo importante aspetto:

const b1: bool = 1;

questa istruzione dà errore:

error: expected type 'bool', found 'comptime_int'
const b1: bool = 1;

In Zig i valori attributi ad un elemento booleano devono essere true o false, vero o falso, non ci sono eccezioni. Non sono quindi ammesse conversioni implicite, fonte di bug pericolosi. Se si vuole effettuare una conversione verso gli interi questa deve essere espressa in forma esplicita tramite apposita funzione evidenziata nel frammento di codice seguente:

const x: u8 = @intFromBool(true); // 1
const y: u8 = @intFromBool(false); // 0

Non esiste però il metodo inverso, ovvero da intero (sia esso 0, 1 o qualsiasi altro valore numerico) verso bool. Quindi, deve essere chiaro, niente valori numerici interpretati come booleani.
Se dovete dichiarare ed inizializzare un elemento booleano dovete essere molto precisi, come vediamo nel breve esempio seguente:

Esempio 5.1

const std = @import("std");
pub fn main() void {
  const b1 = true;
  var b2: bool = false;
  b2 = true;
  std.debug.print("b1: {any}, b2: {any}\n", .{ b1, b2 });
}

con uso di inferenza nel caso di una costante o senza di essa.
L'atttribuzione di un valore booleano avviene molto spesso non direttamente ma attraverso operazioni di confronto. Si può lavorare con gli operatori logici con i quali si possono costruire espressioni booleane. Tali espressioni le incontreremo spesso quando parleremo del controllo di flusso del programma tramite iterazioni e selezioni. Concettualmente è tutto molto semplice, le espressioni di uguaglianza e disuguaglianza e quelle di confronto sono comunemente usate in tutti i linguaggi di programmazione. In Zig (e non solo ovviamente) abbiamo:

• ==    per l'uguaglianza
• !=     diverso da
• >      maggiore di
• >      minore di
• >=   maggiore o uguale
• <=   minore o uguale

ad esempio:

const x1: i32 = 4;
const b1: bool = (x1 < 3);
std.debug.print("b1: {}\n", .{b1});

questo spezzone di codice pone b1 a false, come si vede, sulla base di un confronto, alla seconda riga in quanto x1 non è minore di 3. Questa situazione come detto la incontreremo ancora spesso, sovente l'espressione booleana non sarà nemmeno assegnata ad una variabile o ad una costante ma valutata diciamo "in loco".

Gli operatori logici:

• and

• or

• xor

• ! (not)

funzionano solo sui booleani.

Le tabelle relative a questi operatori sono banalmente reperibili in rete, li vedremo in azione, insieme ad altri operatori di confronto, quando avremo a che fare con le operazioni di selezione. Ad ogni modo per comodità le riporto di seguito:

AND

A	B	A AND B
false	false	false
false	true	false
true	false	false
true	true	true

OR

A	B	A OR B
false	false	false
false	true	true
true	false	true
true	true	true

XOR

A	B	A XOR B
false	false	false
false	true	true
true	false	true
true	true	false

NOT

A	NOT A
false	true
true	false

Una raccomandazione: usate esplicitamente le parole and, or, xor. Zig non ama i simbolismi tipo && oppure || che trovate in altri linguaggi ma che in Zig hanno usi diversi. Quindi siate "verbosi" senza problemi.