Extensible errors

Question

Describe a problem in several words. Guess I have an algorithms to check something, and depending on algorithm it can fail with slightly different errors, for example:

data Error1 = Error1
data Error2 = Error2
data Error3 = Error3

class Algorithm a where
    type CanFailWith a :: *
    check :: Something -> Maybe (CanFailWith a)

instance Algorithm FirstAlgorithm where
    type CanFailWith FirstAlgorithm = Either Error1 Error2
    ...

instance Algorithm SecondAlgorithm where
    type CanFailWith SecondAlgorithm = Either Error1 (Either Error2 Error3)
    ...

This option is not very friendly to user because of difficulty to work with it's branchy structure, e.g.

 testError (Left Error1)          = ...
 testError (Right (Left Error2))  = ...
 testError (Right (Right Error3)) = ...

It looks not so bad with three errors, but it worth with every extra error.

Error could be a simple sum type:

 data Error = Error1
            | Error2
            | Error3

But in this case I force user to cover impossible case in first algorithm, that can not fail with Error3

A question is: is there any common and desirable simple to end user solutions for extending errors?

You can make Eithers slightly easier to handle using TypeOperators like data a :+: b = a :+: b with, say, infixr 6 :+:. Now you can write instance Algorithm SecondAlgorithm where type CanFailWith SecondAlgorithm = Error1 :+: Error2 :+: Error3. There's probably a tricky-typed way of making a generalized eliminator function for such a type, but I can't think of it right now. — J. Abrahamson
– J. Abrahamson, Commented Jul 10, 2013 at 5:27
What is type signature of testError? You need to decide upon the type of this function first — Ankur
– Ankur, Commented Jul 10, 2013 at 6:02
It's testError :: CanFailWith SecondAlgorithm -> ... in this example, but it not necessary to be exactly same. — Fedor Gogolev
– Fedor Gogolev, Commented Jul 10, 2013 at 6:05

Ankur · Accepted Answer · 2013-07-10 06:11:48Z

You can try something like this where each algo has its own error sum type.

{-# LANGUAGE TypeFamilies #-}

class Algorithm a where
    data CanFailWith a :: *
    check :: a -> [Int] -> Maybe (CanFailWith a)

data FirstAlgo = FirstAlgo deriving (Show)

instance Algorithm FirstAlgo where
    data CanFailWith FirstAlgo = FError1 |  FError2
    check a x = Nothing

data SecondAlgo = SecondAlgo deriving (Show)

instance Algorithm SecondAlgo where
    data CanFailWith SecondAlgo = SError1 | SError2 | SError3
    check a x = Nothing


testError :: CanFailWith SecondAlgo -> ()
testError SError1 = ()
testError SError2 = ()
testError SError3 = ()

Collectives™ on Stack Overflow

Extensible errors

1 Answer 1

Comments

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

Comments

Related