Maybes obbligatori nel sistema di tipo

Question

ho qualcosa simile al seguente

data A = A 
    { id :: Integer 
    , foo :: Maybe String 
    , bar :: Maybe String 
    , baz :: Maybe String 
    } 

Questi dati è in arrivo al mio servizio come JSON. Questa richiesta è considerata valida solo se vengono forniti uno o più numeri di foo, bar o baz. Esiste un modo migliore per esprimere ciò nel sistema di tipi di Haskell?

Nota: Purtroppo non riesco a fare richieste separate. Sto solo seguendo un protocollo definito.

Answer 1

http://hackage.haskell.org/package/these-0.4.2/docs/Data-These.html

import Data.These 
data A = A 
    { id :: Integer 
    , fooBarBaz :: These Foo (These Bar Baz) 
    } 

type Foo = String 
type Bar = String 
type Baz = String 

Answer 2

vorrei usare un Map Field String con data Field = Foo | Bar | Baz (questo può essere facilmente sostituito con String, se necessario, e poi:

data A = A 
    { id :: Integer 
    , fields :: Map Field String 
    } 

Ora il controllo per la condizione di validità è semplice come:

isValid :: A -> Bool 
isValid = not . Map.null . fields 

Answer 3

Se non è obbligatorio avere tre campi separati con foo, bar e baz, vorrei andare con questo, NonEmpty garantisce che ci sia almeno un elemento, anche se ovviamente può essercene di più.

import Data.List.NonEmpty 

data Impression = Banner String | Video String | Native String 

data A = A 
    { id :: Integer 
    , fooBarBaz :: NonEmpty Impression 
    } 

Answer 4

espansione su suggerimento di ʎǝɹɟɟɟǝs di utilizzare una mappa: there's also a type specifically for non-empty maps. (Si noti, tuttavia, che questo tipo di scontri con la più popolare tipo non vuoto-list from the semigroups library.)

import qualified Data.NonEmpty.Map as NEM 

data Field = Foo | Bar | Baz 
data A = A { id :: Integer 
      , fields :: NEM.T Field String 
      } 

Answer 5

considerazione dando un ramo per ogni possibile campo obbligatorio:

data A 
    = Foo 
     { foo :: String 
     , barM, bazM :: Maybe String 
     } 
    | Bar 
     { bar :: String 
     , fooM, barM :: Maybe String 
     } 
    | Baz 
     { baz :: String 
     , fooM, barM :: Maybe String 
     } 

E 'un bel po' di boilerplate, ma è molto diretto e abbastanza chiaro su ciò che è richiesto.