On 11/01/2013 11:14 PM, Nickolay Kudasov wrote:

Hi Christopher,

What you want is to make b (and a) depend on f. This can be done in several ways.

With functional dependencies:
class (Integral a, Num b) => PartialSum a b f | f -> a b where
  partialSum :: f -> a -> b

instance (Integral a, Num b) => PartialSum a b (a -> b) where
  partialSum f n = foldl (\u v -> u + f v) 0 [1..n]
With type families:
class PartialSum f where
  type End f
  type Res f
  partialSum' :: f -> End f -> Res f

instance (Integral a, Num b) => PartialSum (a -> b) where
  type End (a -> b) = a
  type Res (a -> b) = b
  partialSum f n = foldl (\u v -> u + f v) 0 [1..n]
I can’t see though what you’re trying to achieve. Could you provide some more use cases for that class?

Thanks for the response. I'll have to read up more on functional dependencies and type families. Which do you think is more appropriate?

This little class is mostly just a test case for me to use in exploring the specialization idea. Partial sums are something mentioned in my math class. Generically, you can calculate any partial sum by adding up the terms (a_1 + a_2 + a_3 + ... + a_n). However, when the terms are in certain forms, you can use shortcut formulas. E.g., if the term is just n, then you can just plug n into n*(n+1)/2.

So, the idea was to have a partialSum function that can calculate the partial sum with any function passed to it (the long and slow way) but can use a shortcut method when the function is of a particular form. Say, a term of this type:

data LinearTerm f = LinearTerm f -- constructor not exported
linearTerm coefficient = LinearTerm (\x -> coefficient * x)

If my toy case is silly, I'm sure there are plenty of better examples that could be given. For example, sorting functions that can "choose" better algorithms depending on the type. (Say, the generic function uses a comparison sort, but a type with a small number of possible values would be better suited for a pigeon hole algorithm.)