Tipi di somma - Perché in Haskell è `show (Int | Double)` diverso da `(show Int) | (mostra Double) `

Perché questi non sono equivalenti?

show $ if someCondition then someInt else some double

e

if someCondition then show someInt else show someDouble

Capisco che se si isola la if ... elseparte nel primo esempio in un'espressione da sola, non è possibile rappresentare il suo tipo con un tipo di somma anonimo, il tipo di Int | Double, come qualcosa che si potrebbe fare facilmente in TypeScript (menzionando TypeScript perché è il langauge che ho usato spesso e che supporta i tipi di somma), e dovrei ricorrere all'utilizzo dei Eitherdati che poi basandomi su di esso chiamerebbe show.

L'esempio che ho dato qui è banale, ma per me ha più senso pensare "Va bene, mostreremo qualcosa, e quel qualcosa dipende da someCondition" piuttosto che "Va bene, se alcune condizioni sono vere, quindi mostra alcune, altrimenti mostra alcune cose doppie", e permette anche per una duplicazione del codice minore (qui lo spettacolo viene ripetuto due volte ma potrebbe anche essere un'applicazione con funzione lunga e al posto di un if ... elseci potrebbero essere> 2 rami da considerare)

Nella mia mente dovrebbe essere facile per il compilatore verificare se ciascuno dei tipi che rendono il tipo di somma (qui Int | Double) possa essere usato come parametro per showfunzionare e decide se i tipi sono corretti o meno. Ancora meglio è che la showfunzione restituisce sempre stringnon importa i tipi di parametri, quindi il compilatore non deve portare con sé tutti i possibili "rami" (quindi tutti i tipi possibili).

È per scelta che una tale funzione non esiste? O è più difficile implementarlo?

Tutte le parti di un'espressione devono essere ben digitate. Il tipo di if someCondition then someInt else someDoubledovrebbe essere qualcosa di simile exists a. Show a => a, ma Haskell non supporta questo tipo di quantificazione esistenziale.

Aggiornamento: come sottolinea Chi in un commento , ciò sarebbe possibile anche se Haskell avesse il supporto per tipi di unione / intersezione (che non sono uguali ai tipi di somma / prodotto), ma sfortunatamente non lo è.

Esistono tipi di prodotti con sintassi leggera, scritti (,) in Haskell. Uno direbbe che un tipo di somma con una sintassi leggera, qualcosa del genere (Int | String), sarebbe un'ottima idea. La realtà è più complicata. Vediamo perché (mi sto prendendo delle libertà Num, non sono importanti).

if someCondition then 42 else "helloWorld"

Se questo dovesse restituire un valore di tipo like (Int | String) , quale dovrebbe essere il seguente ritorno?

if someCondition then 42 else 0

(Int | Int)ovviamente, ma se questo è distinto dalla pianura, Intallora siamo in grossi guai. Quindi (Int | Int)dovrebbe essere identico al semplice Int.

Si può immediatamente vedere che questa non è solo una sintassi leggera per i tipi di somma, ma una funzionalità del linguaggio completamente nuova. Un diverso tipo di sistema di tipi, se vuoi. Dovremmo averne uno?

Diamo un'occhiata a questa funzione.

mysteryType x a b = if x then a else b

Ora che tipo fa mysteryType ha? Ovviamente

mysteryType :: Bool -> a -> b -> (a|b)

destra? Ora cosa succede se aeb sono dello stesso tipo?

let x = mysteryType True 42 0

Questo dovrebbe essere chiaro Intcome abbiamo concordato in precedenza. Ora a mysteryTypevolte restituisce un tipo di somma anonima, a volte no, a seconda degli argomenti passati. In che modo corrisponderesti a una simile espressione? Cosa diavolo puoi farci? Tranne cose banali come "show" (o qualunque metodo di altre classi di tipo sarebbe un'istanza di), non molto. A meno che non si aggiungano informazioni sul tipo di runtime alla lingua, ovvero typeofsono disponibili, e ciò rende Haskell una lingua completamente diversa.

Quindi si Perché Haskell non è un TypeScript? Perché non abbiamo bisogno di un altro TypeScript. Se vuoi TypeScript, sai dove trovarlo.