Convalida in Haskell

Question

Ho alcuni record nidificati che devo convalidare, e mi chiedo quale sia un modo idiomatico di Haskell per farlo.

Per semplificare:

data Record = Record { 
    recordItemsA :: [ItemA], 
    recordItemB :: ItemB 
} deriving (Show) 

data ItemA { 
    itemAItemsC :: [ItemC] 
} deriving (Show) 

I requisiti sono:

• raccogliere e restituire tutti gli errori di convalida
• Alcune convalide possono essere tra gli elementi, ad esempio ItemsA contro ItemB
• String s sono sufficienti a rappresentare errori

Al momento ho il codice che si sente a disagio:

type ErrorMsg = String 

validate :: Record -> [ErrorMsg] 
validate record = 
    recordValidations ++ itemAValidations ++ itemBValidations 
    where 
    recordValidations :: [ErrorMsg] 
    recordValidations = ensure (...) $ 
     "Invalid combination: " ++ (show $ recordItemsA record) ++ " and " ++ (show $ recordItemsB record) 
    itemAValidations :: [ErrorMsg] 
    itemAValidations = concat $ map validateItemA $ recordItemsA record 
    validateItemA :: ItemA -> [ErrorMsg] 
    validateItemA itemA = ensure (...) $ 
     "Invalid itemA: " ++ (show itemA) 
    itemBValidations :: [ErrorMsg] 
    itemBValidations = validateItemB $ recordItemB record 
    validateItemB :: ItemB -> [ErroMsg] 
    validateItemB itemB = ensure (...) $ 
     "Invalid itemB: " ++ (show itemB) 

ensure :: Bool -> ErrorMsg -> [ErrorMsg] 
ensure b msg = if b then [] else [msg] 

Answer 1

Quello che hai già è fondamentalmente bene, ha solo bisogno di un po 'di clean-up:

• Le convalide secondarie devono essere definizioni di livello superiore, poiché sono abbastanza coinvolte. (A proposito, digitare firme su where definizioni clausola di solito sono omessi.)
• Mancanza di convenzione coerente di denominazione
• sacco di (++) s in sequenza può ottenere brutto - utilizzare concat (o forse unwords) invece
• formattazione Minore peculiarità (ci sono alcuni parentesi superflui, concat . map f è concatMap f, ecc)

Il prodotto di tutto questo:

validateRecord :: Record -> [ErrorMsg] 
validateRecord record = concat 
    [ ensure (...) . concat $ 
     [ "Invalid combination: ", show (recordItemsA record) 
     , " and ", show (recordItemB record) 
     ] 
    , concatMap validateItemA $ recordItemsA record 
    , validateItemB $ recordItemB record 
    ] 

validateItemA :: ItemA -> [ErrorMsg] 
validateItemA itemA = ensure (...) $ "Invalid itemA: " ++ show itemA 

validateItemB :: ItemB -> [ErrorMsg] 
validateItemB itemB = ensure (...) $ "Invalid itemB: " ++ show itemB 

Penso che sia abbastanza buono. Se non ti piace la notazione lista, è possibile utilizzare il Writer [ErrorMsg] monade:

validateRecord :: Record -> Writer [ErrorMsg]() 
validateRecord record = do 
    ensure (...) . concat $ 
    [ "Invalid combination: ", show (recordItemsA record) 
    , " and ", show (recordItemB record) 
    ] 
    mapM_ validateItemA $ recordItemsA record 
    validateItemB $ recordItemB record 

validateItemA :: ItemA -> Writer [ErrorMsg]() 
validateItemA itemA = ensure (...) $ "Invalid itemA: " ++ show itemA 

validateItemB :: ItemB -> Writer [ErrorMsg]() 
validateItemB itemB = ensure (...) $ "Invalid itemB: " ++ show itemB 

ensure :: Bool -> ErrorMsg -> Writer [ErrorMsg]() 
ensure b msg = unless b $ tell [msg] 

Answer 2

Sulla base di @ ehird risposta, si potrebbe introdurre un Validate typeclass:

class Validate a where 
    validate :: a -> [ErrorMsg] 

instance Validate a => Validate [a] where 
    validate = concatMap validate 

instance Validate Record where 
    validate record = concat 
    [ ensure (...) . concat $ 
     [ "Invalid combination: ", show (recordItemsA record) 
     , " and ", show (recordItemB record) 
     ] 
    , validate $ recordItemsA record 
    , validate $ recordItemB record 
    ] 

instance Validate ItemA where 
    validate itemA = ensure (...) $ "Invalid itemA: " ++ show itemA 

instance Validate ItemB where 
    validate itemB = ensure (...) $ "Invalid itemB: " ++ show itemB 

Answer 3

Leggi the 8 ways to report errors in Haskell articolo. Per il tuo caso particolare, dato che devi raccogliere tutti gli errori e non solo il primo, l'approccio con Writer monad suggerito da @ehird sembra adattarsi meglio, ma è bene conoscere altri approcci comuni.

Answer 4

Una cosa che potresti provare è, piuttosto che convalidare i tuoi dati, utilizzare gli obiettivi dell'eccellente pacchetto fclabels come interfaccia per i tuoi dati (piuttosto che i costruttori di modelli/tipi) per garantire che i tuoi dati siano sempre corretti .

Controllare la variante che supporta il guasto here e costruire l'obiettivo passando un setter e un getter che eseguono alcune convalide sul tipo di dati nella funzione lens.

Se avete bisogno di un po 'più complicato di segnalazione degli errori o roba del genere, date un'occhiata al implementation del Maybe variante di lens e definire il vostro obiettivo in termini di un'interfaccia astratta.