Faz sentido ter o conceito de 'nulo' e 'Talvez'?

Ao criar um cliente para uma API da web em C #, deparei-me com um problema referente a nullum valor em que representaria duas coisas diferentes:

• nada , por exemplo, um foopode ou não ter umbar
• desconhecido : por padrão, a resposta da API inclui apenas um subconjunto de propriedades, é necessário indicar quais propriedades adicionais você deseja. Tão desconhecido significa que a propriedade não foi solicitada da API.

Após algumas pesquisas, descobri o tipo Maybe (ou Option), como ele é usado em linguagens funcionais e como "resolve" problemas de cancelamento de referência nulos, forçando o usuário a pensar na possível ausência de um valor. No entanto, todos os recursos que encontrei falaram sobre a substituição de null por Maybe . Eu encontrei algumas menções à lógica de três valores , mas não a entendo completamente e, na maioria das vezes, sua menção estava no contexto de "é uma coisa ruim".

Agora estou me perguntando se faz sentido ter o conceito de null e Maybe , para representar desconhecido e nada, respectivamente. Essa é a lógica de três valores sobre a qual li ou tem outro nome? Ou é a maneira pretendida de aninhar um Talvez em um Talvez?

O nullvalor como presente padrão em todos os lugares é apenas uma ideia realmente quebrada , então esqueça isso.

Você sempre deve ter exatamente o conceito que melhor descreve seus dados reais. Se você precisar de um tipo que indique "desconhecido", "nada" e "valor", deve ter exatamente isso. Mas se não atender às suas necessidades reais, você não deve fazê-lo. É uma boa ideia ver o que outras pessoas usam e o que elas propuseram, mas você não precisa segui-las cegamente.

As pessoas que projetam bibliotecas padrão tentam adivinhar padrões de uso comuns, e geralmente o fazem bem, mas se houver algo específico de que você precisa, você deve defini-lo. Por exemplo, em Haskell, você pode definir:

data UnknownNothing a =
     Unknown
   | Nothing
   | Value a

Pode até ser o caso de você usar algo mais descritivo e mais fácil de lembrar:

data UserInput a =
     Unknown
   | NotGiven
   | Answer a

Você pode definir 10 desses tipos para serem usados ​​em diferentes cenários. A desvantagem é que você não terá funções de biblioteca preexistentes disponíveis (como as de Maybe), mas isso geralmente acaba sendo um detalhe. Não é tão difícil adicionar sua própria funcionalidade.

Até onde eu sei, o valor nullem C # é um valor possível para algumas variáveis, dependendo do seu tipo (estou certo?). Por exemplo, instâncias de alguma classe. Para o restante dos tipos (como int, booletc), você pode adicionar esse valor de exceção declarando variáveis ​​com int?ou em bool?vez disso (é exatamente isso que o Maybeconstrutor faz, como descreverei a seguir).

O Maybeconstrutor de tipos da programação funcional adiciona esse novo valor de exceção para um determinado tipo de dados. Portanto, se Inté o tipo de números inteiros ou Gameo tipo de estado de um jogo, Maybe Intpossui todos os números inteiros mais um valor nulo (às vezes chamado de nada ). O mesmo para Maybe Game. Aqui, não há tipos que acompanham o nullvalor. Você o adiciona quando precisar.

Na OMI, essa última abordagem é a melhor para qualquer linguagem de programação.

Se você pode definir uniões de tipo, como X or Y, e se você tem um tipo nomeado Nullque representa apenas o nullvalor (e nada mais), então, para qualquer tipo T, T or Nullna verdade não é tão diferente Maybe T. O único problema nullé quando a linguagem trata um tipo de Tforma T or Nullimplícita, criando nullum valor válido para cada tipo (exceto os tipos primitivos nos idiomas que os possuem). É o que acontece, por exemplo, em Java, onde uma função que aceita a Stringtambém aceita null.

Se você tratar os tipos como conjunto de valores e orcomo união de conjuntos, (T or Null) or Nullrepresenta o conjunto de valores T ∪ {null} ∪ {null}, que é o mesmo que T or Null. Existem compiladores que realizam esse tipo de análise (SBCL). Como dito nos comentários, você não pode distinguir facilmente entre Maybe Te Maybe Maybe Tquando visualiza os tipos como domínios (por outro lado, essa visualização é bastante útil para programas de tipo dinâmico). Mas você também pode manter os tipos como expressões algébricas, onde (T or Null) or Nullrepresenta vários níveis do Maybes.

Você precisa descobrir o que deseja expressar e, em seguida, encontrar uma maneira de expressá-lo.

Primeiro, você tem valores no domínio do problema (como números, seqüências de caracteres, registros de clientes, booleanos etc.). Segundo, você tem alguns valores genéricos adicionais sobre os valores do domínio do problema: por exemplo "nada" (a ausência conhecida de um valor), "desconhecido" (nenhum conhecimento sobre presença ou ausência de um valor), não mencionado, foi " alguma coisa "(existe definitivamente um valor, mas não sabemos qual). Talvez você possa pensar em outras situações.

Se você quisesse representar todos os valores mais esses três valores adicionais, criaria uma enumeração com os casos "nada", "desconhecido", "alguma coisa" e "valor" e partir daí.

Em alguns idiomas, alguns casos são mais simples. Por exemplo, em Swift, você tem para todo tipo T o tipo "opcional T" que tem como valores possíveis nulos mais todos os valores de T. Isso permite lidar com muitas situações facilmente e é perfeito se você não tiver "nada" e " valor". Você pode usá-lo se tiver "desconhecido" e "valor". Você não pode usá-lo se precisar manipular "nada", "desconhecido" e "valor". Outros idiomas podem usar "null" ou "talvez", mas isso é apenas outra palavra.

No JSON, você tem dicionários com pares de chave / valor. Aqui, uma chave pode estar ausente de um dicionário ou pode ter um valor nulo. Portanto, descrevendo cuidadosamente como as coisas são armazenadas, você pode representar valores genéricos mais dois valores adicionais.