Patternmatching on 'Or' of 2 newtypes in haskell

Question

I am using a decision diagram library within a haskell program. For this i want to declare 2 different (new)types that keeps track of which kind of decision diagram i am dealing with. The library i am using is cudd, and decision diagram base type from there is a DdNode, but my question is only haskell related.

newtype Bdd = ToBdd Cudd.Cudd.DdNode
newtype Zdd = ToZdd Cudd.Cudd.DdNode

Normally i want to discriminate between them when calling functions, but now i want to use a function which does not have to discriminate between the 2 types. i mainly tried to solve this in 3 different ways:

data Dd = ToBdd Bdd | ToZdd Zdd

printDdInfo :: Dd -> IO()
printDdInfo (ToZdd dd) = do
    putStrLn "Hello, zdd!"
    Cudd.Cudd.cuddPrintDdInfo manager dd
printDdInfo (ToBdd dd) = do
    putStrLn "Hello, bdd!"
    Cudd.Cudd.cuddPrintDdInfo manager dd

printDdInfo :: Either Bdd Zdd -> IO()
printDdInfo (ToZdd dd) = do
    putStrLn "Hello, zdd!"
    Cudd.Cudd.cuddPrintDdInfo manager dd
printDdInfo (ToBdd dd) = do
    putStrLn "Hello, bdd!"
    Cudd.Cudd.cuddPrintDdInfo manager dd
    
printDdInfo :: Either Bdd Zdd -> IO()
printDdInfo dd = case dd of
  Zdd dd -> do
    putStrLn "Hello, bdd!"
    Cudd.Cudd.cuddPrintDdInfo manager dd
  Bdd dd -> do
    putStrLn "Hello, bdd!"
    Cudd.Cudd.cuddPrintDdInfo manager dd

All of these methods failed. What is the most elegant way of writing this code? Thanks for your attention.

What is the type of `Cudd.Cudd.cuddPrintDdInfo`? Does it take a `Cudd.Cudd.DdNode`? — Aplet123, Jul 15 '20 at 12:31
I'm a fan of passing the `DdNode` directly instead of trying to do this with type magic. If it is too messy, I think [@DanielWagner's understated suggestion](https://stackoverflow.com/questions/62914847/patternmatching-on-or-of-2-newtypes-in-haskell#comment111262427_62915656) is quite good. `printDdInfo :: (HasNode a) => a -> IO ()` — luqui, Jul 17 '20 at 06:07

dfeuer · Accepted Answer · 2020-07-16T19:16:12.727

5

I haven't dug too deeply into your code, but from your description it sounds like you might be interested in the idea of a phantom type.

newtype Dd x = ToDd (Cudd.Cudd.DdNode)
data B
data Z

Now you can distinguish between Dd B and Dd Z when you want, and work polymorphically with Dd x when you don't care.

In modern GHC Haskell, if you want to indicate that B and Z are the only tags, you can use the DataKinds and KindSignatures extensions and do it like this:

newtype Dd (x :: DdTag) = ToDd (Cudd.Cudd.DdNode)
data DdTag = B | Z

In this context, you'll deal with Dd 'B and Dd 'Z, where the single quote (pronounced "tick") "promotes" the data constructor to the type level.

To write a function that behaves differently depending on which tag the type has, you'll need a class.

class Zoop tag where
  zoop :: Dd tag -> Int
  zeep :: Char -> Dd tag
  zaaaaap :: Dd tag -> Dd tag

Now you can write a Zoop instance for B (or 'B) and one for Z (or 'Z) to let users use the method for either. Remember, though, that types are erased in compilation, so you'll need a Zoop a constraint anytime you want to apply these methods with polymorphic tags.

edited Jul 16 '20 at 19:16

answered Jul 15 '20 at 21:00

dfeuer

48,079
5
63
167

I like it, but you should still answer how the actual “pattern matching” is achieved, which the question was about. (Classes, I'd say.) – leftaroundabout Jul 16 '20 at 08:48
@leftaroundabout, good point. I'll try to remember to edit that in. – dfeuer Jul 16 '20 at 10:30
Hey this is exactly what im looking for!, what advantages do i get from indicating they are the only tags? – Daniel Miedema Jul 16 '20 at 10:53
@DanielMiedema, mostly clarity of intention. It can also help people writing class (or type family) instances relating to your type to know they've covered all the options. – dfeuer Jul 16 '20 at 16:36
@leftaroundabout, how's that look? – dfeuer Jul 16 '20 at 19:16

score 1 · Answer 2 · answered Jul 15 '20 at 13:09

I'd go with something very similar to your first approach, but you need to rename the constructors different from the newtype ones:

data Dd = FromBdd Bdd | FromZdd Zdd

printDdInfo :: Dd -> IO()
printDdInfo (FromZdd (ToZdd dd)) = do
    putStrLn "Hello, zdd!"
    Cudd.Cudd.cuddPrintDdInfo manager dd
printDdInfo (FromBdd (ToBdd dd)) = do
    putStrLn "Hello, bdd!"
    Cudd.Cudd.cuddPrintDdInfo manager dd

Alternatively, knowing that all the different dd-types share the same underlying representation, you could also forego storing the newtypes and instead set up Dd independently:

data DdKind = IsBdd | IsZdd

data Dd = Dd { ddKind :: DdKind
             , ddImplementation :: Cudd.Cudd.DdNode }

printDdInfo :: Dd -> IO()
printDdInfo (Dd ddk dd) = do
    putStrLn $ case ddk of
       IsBdd -> "Hello, bdd!"
       IsZdd -> "Hello, zdd!"
    Cudd.Cudd.cuddPrintDdInfo manager dd

Thanks, i will look into your options. What is the terminology for the { } part? that way i can look up its specifics on internet. — Daniel Miedema, Jul 15 '20 at 13:37
A third alternative would be to use a typeclass (perhaps `class HasNode a where implementation :: a -> Cudd.Cudd.DdNode`) that has instances for `Bdd` and `Zdd`, then skip the data definitions entirely. — Daniel Wagner, Jul 15 '20 at 14:29

Patternmatching on 'Or' of 2 newtypes in haskell

2 Answers2