Costruire il testo

Il problema

Molti linguaggi hanno una funzione come printf o le f-string, dove scrivi un modello di testo con dei segnaposto e il linguaggio li riempie. Gleam no: in Gleam il testo si costruisce a pezzi, attaccando stringhe con <> e convertendo i numeri con le funzioni che hai già visto.

Funziona, ma con qualche numero in più la riga diventa un groviglio di parentesi:

  io.println(string.pad_start(int.to_string(total), 6, " "))

Per leggerla devi partire dal centro (total) e uscire verso l’esterno: prima int.to_string, poi string.pad_start, poi io.println. L’esatto contrario dell’ordine in cui scorre l’occhio. Gleam ha uno strumento apposta per questo.

Il tubo: |>

L’operatore |> si chiama pipe (tubo) e fa una cosa semplicissima: prende il valore a sinistra e lo passa come primo argomento alla funzione a destra.

  total |> int.to_string

è esattamente come scrivere int.to_string(total). E se la funzione ha altri argomenti, li scrivi normalmente: il valore che arriva dal tubo si mette al primo posto.

  "7" |> string.pad_start(3, "0")

equivale a string.pad_start("7", 3, "0"), e vale "007". La forza del tubo si vede quando i passaggi sono tanti: si mettono in fila, e si leggono nell’ordine in cui avvengono.

  total
  |> int.to_string
  |> string.pad_start(6, " ")
  |> io.println

“Prendi total, trasformalo in testo, allungalo a 6 caratteri, stampalo.” Stessa identica cosa della riga aggrovigliata di prima, ma si legge dall’alto in basso come una ricetta.

C’è un dettaglio di precedenza che torna utile: |> viene calcolato prima di <>. Quindi questa riga fa quello che speri, senza graffe:

  io.println("Total: " <> total |> int.to_string)

Prima total |> int.to_string, poi l’attacco con "Total: ".

Il caso dei decimali

float.to_string è comodo, ma ha le sue idee su come scrivere un numero. Guarda:

import gleam/float
import gleam/io

pub fn main() -> Nil {
  io.println(float.to_string(6.9))
  io.println(float.to_string(2.0))
  io.println(float.to_string(1250.0))
  io.println(float.to_string(1000.0))
  io.println(float.to_string(0.1 +. 0.2))
}

6.9
2.0
1250.0
1.0e3
0.30000000000000004

Tre sorprese in un colpo solo:

• 6.9 non diventa 6.90: float.to_string non aggiunge zeri, quindi le colonne di prezzi non si allineano.
• 1000.0 diventa 1.0e3, in notazione scientifica, mentre 1250.0 resta com’è. La regola è che viene scelta la scrittura più corta che rappresenta il numero esattamente: 1.0e3 ha un carattere in meno di 1000.0.
• 0.1 +. 0.2 si porta dietro il suo piccolo errore, come abbiamo visto nella lezione precedente.

float.to_precision(x, 2) arrotonda un Float a due decimali (float.to_precision(3.14159, 2) vale 3.14), ma non risolve i primi due problemi: 6.9 resta 6.9.

Colonne allineate

Per stampare tabelle ordinate ti servono stringhe tutte della stessa lunghezza. Il modulo gleam/string ha tre funzioni perfette:

Se la stringa è già lunga almeno n, pad_start e pad_end la lasciano com’è: non tagliano mai. E contano i caratteri come li vede una persona, quindi una è conta per uno, anche se pesa due byte.

Di solito i testi si allineano a sinistra (pad_end) e i numeri a destra (pad_start), così le unità finiscono una sotto l’altra:

import gleam/int
import gleam/io
import gleam/string

pub fn main() -> Nil {
  io.println(string.pad_end("Item", 10, " ") <> string.pad_start("Qty", 5, " "))
  io.println(string.repeat("=", 15))
  io.println(
    string.pad_end("Apples", 10, " ")
    <> string.pad_start(int.to_string(12), 5, " "),
  )
  io.println(
    string.pad_end("Pears", 10, " ")
    <> string.pad_start(int.to_string(7), 5, " "),
  )
  io.println(
    string.pad_end("Melons", 10, " ")
    <> string.pad_start(int.to_string(150), 5, " "),
  )
}

Item        Qty
===============
Apples       12
Pears         7
Melons      150

Caratteri speciali: le sequenze di escape

Come si mette una virgoletta dentro una stringa, se le virgolette la chiudono? Con una sequenza di escape: una barra rovesciata \ seguita da un carattere, che insieme significano “un carattere speciale”.

E se ti serve un testo su più righe, puoi semplicemente andare a capo dentro la stringa: le stringhe di Gleam possono occupare più righe.

import gleam/io

pub fn main() -> Nil {
  io.println("She said: \"Hi!\"")
  io.println("Path: C:\\games\\gleam")
  io.println("One\nTwo")
  io.println("Col1\tCol2")
  io.println("Caff\u{00E8}")
  io.println(
    "Line A
Line B",
  )
}

She said: "Hi!"
Path: C:\games\gleam
One
Two
Col1	Col2
Caffè
Line A
Line B

Due uscite: stdout e stderr

Nella lezione 2 abbiamo visto che ogni programma ha due canali di uscita: lo standard output, per i risultati, e lo standard error, per i messaggi di errore e di diagnostica. io.println e io.print scrivono sul primo; io.println_error e io.print_error sul secondo. E anche echo scrive sullo standard error, perché è uno strumento di diagnostica.

Nel terminale finiscono tutti sullo schermo, e sembrano uguali. La differenza si vede quando redirigi l’uscita, per esempio per salvarla in un file:

gleam run -m report > report.txt

Il simbolo > manda lo standard output nel file report.txt, mentre lo standard error continua ad apparire sullo schermo (insieme alle righe Compiling e Running di gleam, che stanno anche loro sullo standard error). Così i messaggi di servizio non sporcano i risultati.

Coffee x2 ......... 2.40
Croissant x3 ...... 3.90
------------------------
Total ............. 6.30

import gleam/int
import gleam/io
import gleam/string

pub fn main() -> Nil {
  let coffee = 120 * 2
  let croissant = 130 * 3
  let total = coffee + croissant

  let coffee_text =
    int.to_string(coffee / 100)
    <> "."
    <> { coffee % 100 |> int.to_string |> string.pad_start(2, "0") }
  let croissant_text =
    int.to_string(croissant / 100)
    <> "."
    <> { croissant % 100 |> int.to_string |> string.pad_start(2, "0") }
  let total_text =
    int.to_string(total / 100)
    <> "."
    <> { total % 100 |> int.to_string |> string.pad_start(2, "0") }

  io.println(
    string.pad_end("Coffee x2 ", 19, ".")
    <> string.pad_start(coffee_text, 5, " "),
  )
  io.println(
    string.pad_end("Croissant x3 ", 19, ".")
    <> string.pad_start(croissant_text, 5, " "),
  )
  io.println(string.repeat("-", 24))
  io.println(
    string.pad_end("Total ", 19, ".") <> string.pad_start(total_text, 5, " "),
  )
}

Ricapitolando

• In Gleam non c’è printf: il testo si costruisce con <> e le funzioni di conversione.
• x |> f(a) equivale a f(x, a): il tubo mette in fila le trasformazioni, nell’ordine in cui avvengono.
• |> viene calcolato prima di <>: "Total: " <> n |> int.to_string funziona.
• float.to_string sceglie la scrittura più corta: niente zeri finali, e a volte notazione scientifica (1.0e3).
• Per i soldi: Int in centesimi, poi / 100, % 100 e string.pad_start(2, "0").
• string.pad_start, string.pad_end e string.repeat per colonne e righe.
• Escape: \", \\, \n, \t, \u{...}; le stringhe possono andare a capo.
• io.println scrive sullo standard output; io.println_error ed echo sullo standard error.

Nella prossima lezione tiriamo le somme del modulo, con un riepilogo e una sfida finale da scrivere da zero.