Tipos de soma - Por que no Haskell é `show (Int | Double)` diferente de `(show Int) | (mostre o dobro) `

Por que estes não são equivalentes?

show $ if someCondition then someInt else some double

e

if someCondition then show someInt else show someDouble

Entendo que se você isolar a if ... elseparte no primeiro exemplo de uma expressão por si só, não poderá representar seu tipo com um tipo de soma anônima Int | Double, como algo que você poderia fazer facilmente no TypeScript (mencionando o TypeScript porque é o langauge que eu costumava usar e que suporta tipos Sum), e teria que recorrer ao uso dos Eitherdados que seriam chamados show.

O exemplo que dei aqui é trivial, mas para mim faz mais sentido pensar "Ok, vamos mostrar algo, e que algo depende someCondition", em vez de "Ok, se algumaCondição for verdadeira, mostrar someInt caso contrário mostrar someDouble" e também permitir para menos duplicação de código (aqui o programa é repetido duas vezes, mas também pode ser uma aplicação de função longa e, em vez de uma if ... else, pode haver> 2 ramificações a serem consideradas)

Na minha opinião, deve ser fácil para o compilador verificar se cada um dos tipos que compõem o tipo de soma (aqui Int | Double) pode ser usado como parâmetro para showfuncionar e decide se os tipos estão corretos ou não. Melhor ainda é que a showfunção sempre retorna a stringqualquer que seja o tipo de parâmetro, portanto o compilador não precisa carregar todos os "desvios" possíveis (portanto, todos os tipos possíveis).

É por opção que esse recurso não existe? Ou está implementando mais difícil do que eu acho?

Todas as partes de uma expressão devem ser bem digitadas. O tipo de if someCondition then someInt else someDoubleteria que ser algo como exists a. Show a => a, mas Haskell não suporta esse tipo de quantificação existencial.

Atualização: Como o chi aponta em um comentário , isso também seria possível se Haskell tivesse suporte para tipos de união / interseção (que não são iguais aos tipos de soma / produto), mas infelizmente não.

Existem tipos de produtos com sintaxe leve, escritos (,), em Haskell. Uma coisa seria que um tipo de soma com uma sintaxe leve, algo como (Int | String), seria uma ótima idéia. A realidade é mais complicada. Vamos ver o porquê (estou tomando algumas liberdades Num, elas não são importantes).

if someCondition then 42 else "helloWorld"

Se isso deve retornar um valor do tipo like (Int | String), então o que deve retornar a seguir?

if someCondition then 42 else 0

(Int | Int)obviamente, mas se isso é distinto da planície, Intentão estamos com problemas profundos. Portanto, (Int | Int)deve ser idêntico ao simples Int.

Pode-se ver imediatamente que essa não é apenas uma sintaxe leve para tipos de soma, mas um recurso de linguagem totalmente novo. Um tipo diferente de sistema de tipos, se você preferir. Deveríamos ter um?

Vamos olhar para esta função.

mysteryType x a b = if x then a else b

Agora que tipo mysteryTypetem? Obviamente

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

direita? Agora, o que se ae bsão do mesmo tipo?

let x = mysteryType True 42 0

Isso deve ficar claro Intcomo concordamos anteriormente. Agora, mysteryTypeàs vezes, retorna um tipo de soma anônima e, às vezes, não, dependendo dos argumentos que você passa. Como você padronizaria essa expressão? O que diabos você pode fazer com isso? Exceto coisas triviais como "show" (ou quaisquer métodos de outras classes de tipos dos quais seria uma instância), não muito. A menos que você adicione informações do tipo em tempo de execução ao idioma, isto é, ele também typeofestá disponível - e isso faz do Haskell um idioma totalmente diferente.

Então sim. Por que Haskell não é um TypeScript? Porque não precisamos de outro TypeScript. Se você deseja TypeScript, sabe onde encontrá-lo.