Set of functions that are instances in a common way

Question

I'm pretty new to haskell and I think I'm falling into some OO traps. Here's a sketch of a structure (simplified) that I'm having trouble implementing:

• A concept of an Observable that acts on a list of samples (Int) to produce a result (Int)

  • A concept SimpleObservable that achieves the result using a certain pattern (while there will be Observables that do it other ways), e.g. something like an average

• A function instance, e.g. one that's just an average times a constant

My first thought was to use a subclass; something like (the below is kinda contrived but hopefully gets the idea across)

class Observable a where
  estimate :: a -> [Int] -> Int

class (Observable a) => SimpleObservable a where
  compute :: a -> Int -> Int
  simpleEstimate :: a -> [Int] -> Int
  simpleEstimate obs list = sum $ map compute list

data AveConst = AveConst Int

instance Observable AveConst where
  estimate = simpleEstimate

instance SimpleObservable AveConst  where
  compute (AveConst c) x = c * x

However, even if something like the above compiles it's ugly. Googling tells me DefaultSignatures might help in that I don't have to do estimate = simpleEstimate for each instance but from discussions around it it seems doing it this way would be an antipattern.

Another option would be to have no subclass, but something like (with the same Observable class):

data AveConst = AveConst Int

instance Observable AveConst where
  estimate (AveConst c) list = sum $ map (*c) list

But this way I'm not sure how to reuse the pattern; each Observable has to contain the complete estimate definition and there will be code repetition.

A third way is a type with a function field:

data SimpleObservable = SimpleObservable {
  compute :: [Int] -> Int
} 

instance Observable SimpleObservable where
  estimate obs list =
    sum $ map (compute obs) list

aveConst :: Int -> SimpleObservable
aveConst c = SimpleObservable {
  compute = (*c)
}

But I'm not sure this is idiomatic either. Any advice?

Answer 1

I propose going even simpler:

type Observable = [Int] -> Int

Then, an averaging observable is:

average :: Observable
average ns = sum ns `div` length ns

If your Observable needs some data inside -- say, a constant to multiply by -- no problem; that's what closures are for. For example:

sumTimesConst :: Int -> Observable
sumTimesConst c = sum . map (c*)

You can abstract over the construction of Observables without trouble; e.g. if you want a SimpleObservable which only looks at elements, and then sums, you can:

type SimpleObservable = Int -> Int

timesConst :: Int -> SimpleObservable
timesConst = (*)

liftSimple :: SimpleObservable -> Observable
liftSimple f = sum . map f

Then liftSimple . timesConst is another perfectly fine way to spell sumTimesConst.

...but honestly, I'd feel dirty doing any of the above things. sum . map (c*) is a perfectly readable expression without introducing a questionable new name for its type.

Answer 2

I do not fully understand the question yet but I'll edit this answer as I learn more.

Something which acts on a list and produces a result can simply be a function. The interface (that is, the type) of this function can be [a] -> b. This says the function accepts a list of elements of some type and returns a result of a possibly different type.

Now, lets invent a small problem as an example. I want to take a list of lists, some function on lists which produces a number, apply this function to every list, and return the average of the numbers.

average :: (Fractional b) => ([a] -> b) -> [[a]] -> b
average f xs = sum (fmap f xs) / genericLength xs

For example, average genericLength will tell me the average length of the sub-lists. I do not need to define any type classes or new types. Simply, I use the function type [a] -> b for those functions which map a list to some result.