Kann eine benutzerdefinierte Wache Mechanismus in Haskell definiert werden?

Question

Wenn Sie sich das Beispiel sucht catches:

 f = expr `catches` [Handler (\ (ex :: ArithException) -> handleArith ex),
                     Handler (\ (ex :: IOException)    -> handleIO    ex)]

Es sieht aus wie catches einen benutzerdefinierten Mechanismus auf Muster (die beiden Ausnahmetypen) übereinstimmen definiert hat. Täusche ich mich, oder kann dies verallgemeinert werden, um eine zu ermöglichen, eine Funktion zu definieren, die Lambda-Funktionen übernehmen kann, dass Spiel auf einem bestimmten Muster?

Edit: Zu Ihrer Information unten ist die GHC Quelle für Fänge. Wenn jemand etwas Licht auf vergießen kann, wie dies funktioniert wäre es toll.

catches :: IO a -> [Handler a] -> IO a
catches io handlers = io `catch` catchesHandler handlers

catchesHandler :: [Handler a] -> SomeException -> IO a
catchesHandler handlers e = foldr tryHandler (throw e) handlers
    where tryHandler (Handler handler) res
              = case fromException e of
                Just e' -> handler e'
                Nothing -> res

Answer 1

Dies ist die Scoped Typ Variablen GHC Erweiterung bei der Arbeit. Folgen Sie den Link um mehr zu erfahren.

Grundsätzlich Sie eine Aussage über Art definieren, die durch den Rüttler erfüllt werden müssen, bevor sie mithalten können. Also, ja, es ist verwandt mit Wachen, aber nicht ganz so.

Wie dieses Beispiel funktioniert? Tauchen Sie ein in

Answer 2

case () of 
  ()| foo expr1 -> handleFooCase
    | bar expr2 -> handleBarCase
    | otherwise -> blah

Answer 3

case () of 
  ()| foo expr1 -> handleFooCase
    | bar expr2 -> handleBarCase
    | otherwise -> blah