Sichere Anwendung in Haskell

Question

Ich habe ein Stück Code, wo innerhalb einer Liste Monade, eine Funktion angewendet wird. Funktion möglicherweise möglicherweise nicht erschöpfenden Mustervergleich für seine Argumente. Wenn die Funktion angewendet wird, könnte ich daher "Non-exhaustive pattern matching" Fehler erhalten. Ich möchte diesen Fehler in einen monadischen Fehler umwandeln (in diesem Fall eine leere Liste). Mit anderen Worten, ich möchte ein ähnliches Verhalten wie bei Some Pattern Here <- some value innerhalb eines do Blocks erhalten.

Frage: Gibt es eine effiziente Art und Weise eine Funktion Anwendung sicher zu machen? Mit effizient meine ich etwas, das analog dazu wäre, die angewandte Funktion erschöpfend zusammenzuführen und explizit zu versagen.

Answer 1

Eine Option wäre, spoon zu verwenden, um die Funktion von einer, die Ausnahmen auslöst, in eine zu konvertieren, die Maybe a Werte zurückgibt. Dann sollte es einfach sein, Nothing zu [] zu konvertieren.

Answer 2

Hum, vielleicht mit einem Haken? Sie sollten jedoch in den IO Monade arbeiten:

import Prelude hiding (catch) 
import Control.Monad (MonadPlus, mzero) 
import Control.Exception (catch, SomeException) 

data B = T | F 
    deriving (Show) 

f :: B -> B 
f T = F 

justCatch :: (MonadPlus m) => a -> IO (m a) 
justCatch x = catch (x `seq` (return . return) x) handler 
    where 
    handler :: (MonadPlus m) => SomeException -> IO (m a) 
    handler _ = return mzero 

ich über mögliche Probleme mit dieser Lösung nicht sicher bin. Auf den ersten Blick scheint es zu funktionieren, aber ich möchte auch einige Meinungen von sachkundigen Haskellers lesen. Ich würde nicht verwenden diese Lösung sicher in meinem Code: ein Fehler sollte als solcher behandelt werden, ohne es zu verstecken.

*Main> justCatch $ f T :: IO [B] 
[F] 
*Main> justCatch $ f F :: IO [B] 
[] 
*Main> justCatch $ f F :: IO (Maybe B) 
Nothing 
*Main> justCatch $ f T :: IO (Maybe B) 
Just F 
*Main> f T 
F 
*Main> f F 
*** Exception: except.hs:8:1-7: Non-exhaustive patterns in function Main.f