Comprensione delle funzioni pure e degli effetti collaterali in Haskell - putStrLn

Di recente, ho iniziato a studiare Haskell perché volevo ampliare le mie conoscenze sulla programmazione funzionale e devo dire che finora lo adoro davvero. La risorsa che sto attualmente utilizzando è il corso "Haskell Fundamentals Part 1" su Pluralsight. Sfortunatamente ho qualche difficoltà a capire una particolare citazione del docente sul seguente codice e spero che voi ragazzi possiate far luce sull'argomento.

Codice di accompagnamento

helloWorld :: IO ()
helloWorld = putStrLn "Hello World"

main :: IO ()
main = do
    helloWorld
    helloWorld
    helloWorld

La citazione

Se hai la stessa azione IO più volte in un do-block, verrà eseguita più volte. Quindi questo programma stampa tre volte la stringa "Hello World". Questo esempio aiuta a dimostrare che putStrLnnon è una funzione con effetti collaterali. Chiamiamo la putStrLnfunzione una volta per definire la helloWorldvariabile. Se putStrLnavesse avuto un effetto collaterale nel stampare la stringa, sarebbe stata stampata una sola volta e la helloWorldvariabile ripetuta nel do-block principale non avrebbe avuto alcun effetto.

Nella maggior parte degli altri linguaggi di programmazione, un programma come questo stampa 'Hello World' una sola volta, poiché la stampa avverrebbe quando putStrLnviene chiamata la funzione. Questa sottile distinzione farebbe spesso inciampare i principianti, quindi pensaci un po 'e assicurati di capire perché questo programma stampa "Hello World" tre volte e perché lo stampa solo una volta se la putStrLnfunzione eseguisse la stampa come effetto collaterale.

Quello che non capisco

Per me sembra quasi naturale che la stringa "Hello World" venga stampata tre volte. Percepisco ilhelloWorld variabile (o la funzione?) Come una sorta di callback che viene invocato in seguito. Quello che non capisco è, come se putStrLnavesse un effetto collaterale, la stringa verrebbe stampata una sola volta. O perché sarebbe stampato solo una volta in altri linguaggi di programmazione.

Diciamo nel codice C #, presumo che sarebbe simile a questo:

C # (violino)

using System;

public class Program
{
    public static void HelloWorld()
    {
        Console.WriteLine("Hello World");
    }

    public static void Main()
    {
        HelloWorld();
        HelloWorld();
        HelloWorld();
    }
}

Sono sicuro di trascurare qualcosa di abbastanza semplice o di interpretare erroneamente la sua terminologia. Qualsiasi aiuto sarebbe molto apprezzato.

MODIFICARE:

Grazie a tutti per le vostre risposte! Le tue risposte mi hanno aiutato a capire meglio questi concetti. Non credo che sia stato ancora completamente cliccato, ma rivisiterò l'argomento in futuro, grazie!

Probabilmente sarebbe più facile capire cosa significa l'autore se definiamo helloWorlduna variabile locale:

main :: IO ()
main = do
  let helloWorld = putStrLn "Hello World!"
  helloWorld
  helloWorld
  helloWorld

che potresti confrontare con questo pseudocodice simile a C #:

void Main() {
  var helloWorld = {
    WriteLine("Hello World!")
  }
  helloWorld;
  helloWorld;
  helloWorld;
}

Vale a dire in C # WriteLineè una procedura che stampa il suo argomento e non restituisce nulla. In Haskell, putStrLnè una funzione che accetta una stringa e ti dà un'azione che stampa quella stringa se dovesse essere eseguita. Significa che non c'è assolutamente alcuna differenza tra la scrittura

do
  let hello = putStrLn "Hello World"
  hello
  hello

e

do
  putStrLn "Hello World"
  putStrLn "Hello World"

Detto questo, in questo esempio la differenza non è particolarmente profonda, quindi va bene se non ottieni esattamente ciò che l'autore sta cercando di ottenere in questa sezione e vai avanti per ora.

funziona un po 'meglio se lo confronti con Python

hello_world = print('hello world')
hello_world
hello_world
hello_world

Il punto qui è che le azioni IO a Haskell sono valori “veri” che non hanno bisogno di essere avvolto in ulteriori “callback” o qualcosa del genere per impedire loro di esecuzione - anzi, l'unico modo per fare ottenere loro da eseguire è metterli in un posto particolare (cioè da qualche parte all'interno maino un filo generatomain ).

Questo non è solo un trucco da parlatore, finisce per avere alcuni effetti interessanti su come si scrive il codice (ad esempio, fa parte del motivo per cui Haskell non ha davvero bisogno di nessuna delle strutture di controllo comuni che si avrebbero familiarità con da linguaggi imperativi e può cavarsela facendo invece tutto in termini di funzioni), ma ancora una volta non mi preoccuperei troppo di questo (analogie come queste non sempre fanno clic immediatamente)

Potrebbe essere più facile vedere la differenza come descritto se si utilizza una funzione che fa effettivamente qualcosa, piuttosto che helloWorld. Pensa a quanto segue:

add :: Int -> Int -> IO Int
add x y = do
  putStrLn ("I am adding " ++ show x ++ " and " ++ show y)
  return (x + y)

plus23 :: IO Int
plus23 = add 2 3

main :: IO ()
main = do
  _ <- plus23
  _ <- plus23
  _ <- plus23
  return ()

Questo stamperà "Sto aggiungendo 2 e 3" 3 volte.

In C #, potresti scrivere quanto segue:

using System;

public class Program
{
    public static int add(int x, int y)
    {
        Console.WriteLine("I am adding {0} and {1}", x, y);
        return x + y;
    }

    public static void Main()
    {
        int x;
        int plus23 = add(2, 3);
        x = plus23;
        x = plus23;
        x = plus23;
        return;
    }
}

Che sarebbe stampato solo una volta.

Se la valutazione di putStrLn "Hello World" avesse effetti collaterali, allora il messaggio verrebbe stampato solo una volta.

Possiamo approssimare quello scenario con il seguente codice:

import System.IO.Unsafe (unsafePerformIO)
import Control.Exception (evaluate)

helloWorld :: ()
helloWorld = unsafePerformIO $ putStrLn "Hello World"

main :: IO ()
main = do
    evaluate helloWorld
    evaluate helloWorld
    evaluate helloWorld

unsafePerformIOprende IOun'azione e "dimentica" è IOun'azione, smontandola dal solito sequenziamento imposto dalla composizione delle IOazioni e lasciando che l'effetto abbia luogo (o meno) secondo i capricci della valutazione pigra.

evaluateassume un valore puro e garantisce che il valore venga valutato ogni volta che viene valutata l' IOazione risultante , cosa che per noi sarà, perché si trova sul percorso di main. Lo stiamo usando qui per collegare la valutazione di alcuni valori all'uscita del programma.

Questo codice stampa "Hello World" solo una volta. Trattiamo helloWorldcome un valore puro. Ciò significa che verrà condiviso tra tutte le evaluate helloWorldchiamate. E perchè no? Dopotutto è un valore puro, perché ricalcolarlo inutilmente? La prima evaluateazione "apre" l'effetto "nascosto" e le azioni successive valutano semplicemente il risultato (), il che non causa ulteriori effetti.

C'è un dettaglio da notare: si chiama putStrLnfunzione una sola volta, durante la definizione helloWorld. In mainfunzione, basta usare il valore restituito per putStrLn "Hello, World"tre volte.

Il docente afferma che la putStrLnchiamata non ha effetti collaterali ed è vera. Ma guarda il tipo di helloWorld- è un'azione IO. putStrLnlo crea solo per te. Più tardi, ne fai una catena 3 con il doblocco per creare un'altra azione IO - main. Successivamente, quando esegui il tuo programma, quell'azione verrà eseguita, ecco dove si trovano gli effetti collaterali.

Il meccanismo che sta alla base di questo - monadi . Questo potente concetto ti consente di utilizzare alcuni effetti collaterali come la stampa in un linguaggio che non supporta direttamente gli effetti collaterali. Basta concatenare alcune azioni e quella catena verrà eseguita all'avvio del programma. Dovrai comprendere a fondo questo concetto se vuoi usare seriamente Haskell.