CODEWITHSUNDEEP
haskellfunctional-programmingghcfunctional-dependencies
Invoke
Invoke

Reputation: 215

List of a Type Classe instance

I've been playing around with Haskell type classes and I am facing a problem I hope someone could help me to solve. Consider that I come from a Swift background and "trying" to port some of protocol oriented knowledge to Haskell code.

Initially I declared a bunch of JSON parsers which had the same structure, just a different implementation:

data Candle = Candle {
  mts :: Integer,
  open :: Double,
  close :: Double
}

data Bar = Bar {
  mts :: Integer,
  min :: Double,
  max :: Double
}

Then I decided to create a "Class" that would define their basic operations:

class GenericData a where
  dataName :: a -> String
  dataIdentifier :: a -> Double
  dataParsing :: a -> String -> Maybe a
  dataEmptyInstance :: a


instance GenericData Candle where
  dataName _ = "Candle"
  dataIdentifier = fromInteger . mts
  dataParsing _ = candleParsing
  dataEmptyInstance = emptyCandle

instance GenericData Bar where
  dataName _ = "Bar"
  dataIdentifier = fromInteger . mts
  dataParsing _ = barParsing
  dataEmptyInstance = emptyBar

My first code smell was the need to include "a" when it was not needed (dataName or dataParsing) but then I proceded.

analyzeArguments :: GenericData a => [] -> [String] -> Maybe (a, [String])
analyzeArguments [] _             = Nothing
analyzeArguments _ []             = Nothing
analyzeArguments name data
    | name == "Candles" = Just (head possibleCandidates, data)
    | name == "Bar" = Just (last possibleRecordCandidates, data)
    | otherwise  = Nothing

possibleCandidates :: GenericData a => [a]
possibleCandidates = [emptyCandle, emptyBar]

Now, when I want to select if either instance should be selected to perform parsing, I always get the following error

• Couldn't match expected type ‘a’ with actual type ‘Candle’
  ‘a’ is a rigid type variable bound by
    the type signature for:
      possibleCandidates :: forall a. GenericData a => [a]
    at src/GenericRecords.hs:42:29

My objective was to create a list of instances of GenericData because other functions depend on that being selected to execute the correct dataParser. I understand this has something to do with the type class checker, the * -> Constraint, but still not finding a way to solve this conflict. I have used several GHC language extensions but none has solved the problem.

Upvotes: 0

Views: 105

Answers (1)

John F. Miller
John F. Miller

Reputation: 27225

You have a type signature:

possibleCandidates :: GenericData a => [a]

Which you might thing implies that you can put anything in that list as long as it is GenericData. But that is not the way Haskell's type system actually works. The value possibleCandidates can be a list of any type which has a GenericData class but every element of the list must be of the same type.

What the GHC error message is telling you (in its own special way) is that the first element of the list is a Candle so it thinks that the rest of the list should also be of type Candle but the second element is actually a Bar.

Now there are ways to make heterogeneous lists (and other collections) in Haskell, but it is almost never the right thing to do.

One typical solution to this problem is to just merge everything down into one sum data type:

data GenericData = GenericCandle Candle | GenericBar Bar

You could even forgo the step of indirection and just put the Candle and Bar data directly into the data structure.

Now instead f a class you just have a datatype and your class functions become normal functions:

dataName :: GenericData -> String
dataIdentifier :: GenericData -> Double
dataParsing :: GenericData -> String -> Maybe a
dataEmptyInstance :: String -> GenericData

There are some other more complex ways to make this work, but if a sum data type fits the bill, use it. It is very common for parsers in Haskell to have a large sum data type (usually also recursive) as their result. Take a look at the Value type in Aeson the standard JSON library for an example.

Upvotes: 2

Related Questions