Riepilogo e sfida finale

I tuoi tipi, le tue parole

All’inizio del modulo i tuoi programmi parlavano la lingua del computer: int, double, String, e liste parallele da tenere allineate a mano. Adesso sai:

• raccogliere valori diversi in una struct, inizializzarla per posizione o per nome, annidarla, copiarla;
• dare ai tuoi tipi dei metodi, scegliendo tra self per leggere e &self per modificare;
• tenere collezioni di struct, modificarle senza cadere nella copia del foreach, cercarle e ordinarle con un criterio tuo;
• descrivere scelte chiuse con gli enum, con i loro valori associati e gli switch che non dimenticano nessun caso;
• dare nomi nuovi ai tipi esistenti con alias, e creare tipi incompatibili tra loro con typedef.

Il filo che lega tutto: rendere impossibili gli stati sbagliati. Un Player non può perdere il suo punteggio per strada, un Direction non può valere 7, un Meters non può finire dove servono Feet. Ogni errore che il compilatore rifiuta è un errore che non dovrai cercare di notte.

La pagina da tenere accanto

Errori che ormai riconosci

E due errori che il compilatore non vede: un metodo che modifica self invece di &self (cambia una copia), e un foreach (p : team) che modifica p (idem).

Quiz di controllo

La sfida: blackjack

Un mazzo di carte è il banco di prova perfetto per questo modulo: due enum (semi e valori), una struct (la carta), una collezione (il mazzo), e delle regole da tradurre in metodi.

import std::io;
import std::collections::list;

enum Suit : (String letter)
{
	HEARTS   { "H" },
	DIAMONDS { "D" },
	CLUBS    { "C" },
	SPADES   { "S" },
}

enum Rank : (String label, int points)
{
	TWO   { "2", 2 },
	THREE { "3", 3 },
	FOUR  { "4", 4 },
	FIVE  { "5", 5 },
	SIX   { "6", 6 },
	SEVEN { "7", 7 },
	EIGHT { "8", 8 },
	NINE  { "9", 9 },
	TEN   { "10", 10 },
	JACK  { "J", 10 },
	QUEEN { "Q", 10 },
	KING  { "K", 10 },
	ACE   { "A", 11 },
}

struct Card
{
	Rank rank;
	Suit suit;
}

fn String Card.name(self) => string::tformat("%s%s", self.rank.label, self.suit.letter);

struct Hand
{
	String owner;
	List{Card} cards;
}

fn void Hand.take(&self, Card c) => self.cards.push(c);

fn int Hand.score(self)
{
	int total = 0;
	int aces = 0;
	foreach (c : self.cards)
	{
		total += c.rank.points;
		if (c.rank == ACE) aces++;
	}
	while (total > 21 && aces > 0)
	{
		total -= 10;
		aces--;
	}
	return total;
}

fn void Hand.print(self)
{
	io::printf("%-7s", self.owner);
	foreach (c : self.cards) io::printf(" %s", c.name());
	io::printfn(" = %d", self.score());
}

fn void main()
{
	List{Card} deck;
	foreach (suit : Suit::values)
	{
		foreach (rank : Rank::values) deck.push({ rank, suit });
	}
	io::printfn("Deck: %d cards, from %s to %s", deck.len(), deck[0].name(), deck[^1].name());

	Hand player = { .owner = "Player" };
	Hand dealer = { .owner = "Dealer" };
	for (sz i = 0; i < 6; i++)
	{
		Card c = deck[(i * 19 + 12) % 52];
		if (i % 2 == 0)
		{
			player.take(c);
		}
		else
		{
			dealer.take(c);
		}
	}
	player.print();
	dealer.print();

	int p = player.score();
	int d = dealer.score();
	switch
	{
		case p > 21: io::printn("Dealer wins");
		case d > 21 || p > d: io::printn("Player wins");
		case p == d: io::printn("Draw");
		default: io::printn("Dealer wins");
	}

	int[4] per_suit;
	foreach (c : player.cards) per_suit[c.suit.ordinal]++;
	foreach (c : dealer.cards) per_suit[c.suit.ordinal]++;
	foreach (suit : Suit::values)
	{
		io::printfn("%-8s %d", suit, per_suit[suit.ordinal]);
	}
}

Cosa succede nel Modulo 5

Più volte in questo modulo abbiamo girato attorno a un problema: cosa restituisce find se il giocatore non c’è? Abbiamo usato -1, una convenzione fragile (e se -1 fosse un valore valido?). E list.pop() su una lista vuota? E "12x".to_int()? Nel prossimo modulo arrivano gli optional e la gestione degli errori di C3: un modo per dire “qui potrebbe non esserci un risultato, ed ecco perché”, che il compilatore ti obbliga a gestire. È una delle idee più originali del linguaggio.

Segna questa lezione come completata. Hai costruito un mazzo di carte da zero, e le regole di un gioco vero stanno in trenta righe di metodi.