Perché l'accesso a System.Info non è considerato un'operazione di I / O in Haskell?

Nel modulo System.Infovedo queste funzioni:

os :: String
arch :: String
compilerName :: String
compilerVersion :: Version

Perché non IOc'è? Stanno accedendo al sistema ... Sbaglio? La mia aspettativa era qualcosa di simile:

os :: IO String
arch :: IO String
compilerName :: IO String
compilerVersion :: IO Version

Caso d'uso:

      print os            -- "darwin"
      print arch          -- "x86_64"
      print compilerName  -- "ghc"

Non stai ottenendo tali informazioni in fase di esecuzione . Sono codificati nel compilatore come installati sul sistema.

Questo è più ovvio se guardi la definizione di compilerNamecome si trova in http://hackage.haskell.org/package/base-4.12.0.0/docs/src/System.Info.html .

compilerName :: String
compilerName = "ghc"

ma anche qualcosa del genere os

os :: String
os = HOST_OS

è definito in termini di un nome altrimenti indefinito HOST_OS(un valore che inizia con una lettera maiuscola ??) che suggerisce che è solo un segnaposto che viene sostituito durante l'installazione.

Qualcuno può anche correggermi (per favore!), Ma il {-# LANGUAGE CPP #-}pragma nella parte superiore di quel file suggerisce che HOST_OSe simili sono sostituiti da stringhe appropriate dal preprocessore C prima della compilazione.

La domanda è buona. La risposta, come è, è che quei valori sono statici per la compilazione del programma. Sono essenzialmente compilati nel programma e non cambiano mai dopo. In quanto tale, nulla (nelle ipotesi utilizzate da GHC) si rompe se le trattate come costanti. Ed è più conveniente usare una costante semplice che un'azione IO.

Ma questo è tutto un ragionamento legacy. Haskell è una vecchia lingua. (No, in realtà è più vecchio di Java da diversi anni.) Molte librerie sono state costruite con ragionamenti che non sono più considerati best practice. Questi sono esempi di questo. Una moderna biblioteca che li espone probabilmente li renderebbe azioni IO anche se i risultati non cambiano dopo la compilazione. È più utile mettere le cose che non sono costanti a livello di sorgente dietro le azioni IO, anche se ci sono ancora alcune notevoli eccezioni, come Intcambiare le dimensioni tra piattaforme a 32 e 64 bit.

In ogni caso ... direi che le tue aspettative sono solide e quei tipi sono il risultato di stranezze storiche.

EDIT: Grazie a @interjay e @Antal Spector-Zabusky per aver spiegato il motivo per cui questa risposta è stata annullata. Scrissero

La documentazione è un po 'fuorviante. I valori sono codificati nel compilatore GHC. Dopo 48 anni saprai sicuramente che il codice attuale supera sempre la documentazione. - interjay ieri @ andy256 Hai perfettamente ragione sul fatto che la documentazione non è buona (in effetti, questo fa parte del motivo per cui Francisco ha posto questa domanda in primo luogo) e la tua confusione è comprensibile. La cosa su Haskell è che se quei valori di String potrebbero variare in fase di esecuzione, sarebbe un bug egregio - le variabili non possono cambiare. Questo è il significato del costruttore del tipo IO: rappresenta un calcolo a cui è consentito accedere al "mondo esterno", e quindi uno il cui risultato può cambiare. Effettuare una chiamata di sistema è un buon esempio di azione IO. ... [1/2] - Antal Spector-Zabusky 9 ore fa @ andy256 ... (Un'altra azione IO potrebbe essere "l'aggiornamento di un contatore globale".) Quindi quando vediamo una stringa, sappiamo che non può essere in comunicazione con il sistema operativo sotto il cofano. Questo è il motivo, forse sorprendentemente se non sei abituato a Haskell, non sarebbe facile implementare os :: String per fare una chiamata di sistema - un tale valore non è implementabile in Haskell di base, violerebbe le aspettative di ogni programmatore su come i programmi funziona e potenzialmente fa scattare anche il compilatore e l'ottimizzatore (non una preoccupazione teorica: ci sono risposte Stack Overflow in cui le persone incontrano problemi analoghi). [2/2] - Antal Spector-Zabusky Questo è il motivo, forse sorprendentemente se non sei abituato a Haskell, non sarebbe facile implementare os :: String per fare una chiamata di sistema - un tale valore non è implementabile in Haskell di base, violerebbe le aspettative di ogni programmatore su come i programmi funziona e potenzialmente fa scattare anche il compilatore e l'ottimizzatore (non una preoccupazione teorica: ci sono risposte Stack Overflow in cui le persone incontrano problemi analoghi). [2/2] - Antal Spector-Zabusky Questo è il motivo, forse sorprendentemente se non sei abituato a Haskell, non sarebbe facile implementare os :: String per fare una chiamata di sistema - un tale valore non è implementabile in Haskell di base, violerebbe le aspettative di ogni programmatore su come i programmi funziona e potenzialmente fa scattare anche il compilatore e l'ottimizzatore (non una preoccupazione teorica: ci sono risposte Stack Overflow in cui le persone incontrano problemi analoghi). [2/2] - Antal Spector-Zabusky e potenzialmente anche far scattare il compilatore e l'ottimizzatore (non una preoccupazione teorica - ci sono risposte Stack Overflow in cui le persone incontrano problemi analoghi). [2/2] - Antal Spector-Zabusky e potenzialmente anche far scattare il compilatore e l'ottimizzatore (non una preoccupazione teorica - ci sono risposte Stack Overflow in cui le persone incontrano problemi analoghi). [2/2] - Antal Spector-Zabusky

Attualmente ha due voti per l'eliminazione. Lascerò che il processo segua il suo corso, ma suggerisco che abbia effettivamente un certo valore. In una nota a margine, le loro spiegazioni mostrano che la domanda era debole, così come le risposte, dal momento che un neofita di Haskell potrebbe facilmente seguire il ragionamento che ho fatto.

Risposta originale:

Non sono un programmatore Haskell, ma le due risposte già fornite non corrispondono alla documentazione collegata all'OP.

La mia interpretazione della documentazione segue.

os :: String - Questo ti dà "Il sistema operativo su cui è in esecuzione il programma."

Mi aspetto che questo emetta una chiamata di sistema per ottenere le informazioni. Poiché il sistema su cui viene compilato il programma potrebbe essere diverso da quello su cui viene eseguito, non può essere un valore inserito dal compilatore. Se il codice viene interpretato, l'interprete può fornire il risultato, che deve essere ottenuto tramite una chiamata di sistema.

arch :: String - Questo ti dà "L'architettura della macchina su cui è in esecuzione il programma".

Ancora una volta, mi aspetto che questo emetta una chiamata di sistema per ottenere le informazioni. Poiché il sistema su cui viene compilato il programma potrebbe essere diverso da quello su cui viene eseguito, non può essere un valore inserito dal compilatore.

compilerName :: String - Questo ti dà "L'implementazione di Haskell con la quale il programma è stato compilato o viene interpretato".

Questo valore viene sicuramente inserito dal compilatore / interprete.

compilerVersion :: String - Questo ti dà "La versione di compilerName con cui il programma è stato compilato o viene interpretato".

Questo valore viene sicuramente inserito dal compilatore / interprete.

Sebbene si possa considerare che le prime due chiamate ottengano input, il risultato deriva dai valori conservati dal sistema operativo. L'I / O si riferisce generalmente all'accesso alla memoria secondaria.