Okay, I think I got what you are trying to accomplish.

With separate data types for each term type this could be done like that:

newtype Constant a = Constant a deriving (Eq, Show, Enum, Num)

data Linear    a = Linear    a (Constant a)
data Quadratic a = Quadratic a (Linear a) 
data Arbitrary a = Arbitrary (a -> a)

 class PartialSum term where
  partialSum :: (Integral a) => a -> term a -> a

instance PartialSum Constant where
  partialSum n (Constant c) = n * c 

instance PartialSum Linear where
  partialSum n (Linear k c) = k * n * (n + 1) `div` 2 + partialSum n c 

instance PartialSum Quadratic where
  partialSum n (Quadratic k l) = k * n * (n + 1) * (2 * n + 1) `div` 6  + partialSum n l 

instance PartialSum Arbitrary where
  partialSum n (Arbitrary f) = sum $ map f [1..n]

Now you can calculate partialSum effectively like that:

partialSum 10 $ Quadratic 1 $ Linear 2 1    -- sum = 505,  a_n = n^2 + 2n + 1
partialSum 10 $ Linear 3 (-1)               -- sum = 155,  a_n = 3n - 1
partialSum 10 $ Arbitrary (2^)              -- sum = 2046, a_n = 2^n

Note that I didn’t use any of FunctionalDependencies or TypeFamilies extensions. Instead I made terms accept a type parameter. You can easily make types of a_n and n different using 2 type parameters, but I kept them the same for simplicity.

The problem with this implementation is that you can’t compose different terms. E.g. if you have term1 :: Linear Int and term2 :: Quadratic Int, you can’t write term1 + term2. If you’d like to do that, you can make a single data structure representing all kinds of terms:

data Term a
  = Constant  a
  | Linear    a a
  | Quadratic a a a
  | Arbitrary (a -> a)

Now you could implement a Num instance on that:

instance Num a => Num (Term a) where
  fromInteger = Constant ∘ fromInteger

  Constant c + Linear k c'       = Linear k (c + c')
  Constant c + Quadratic a k  c' = Quadratic a k (c + c')
  Linear k c + Quadratic a k' c' = Quadratic a (k + k') (c + c')
  -- ...
  x + y = y + x

  Constant c * Linear      k c' = Linear (c * k) (c * c')
  Constant c * Quadratic a b c' = Quadratic (c * a) (c * b) (c * c')
  -- ...
  x * y = y * x

  negate (Constant c)      = Constant  (negate c)
  negate (Linear k b)      = Linear    (negate k) (negate b)
  negate (Quadratic a b c) = Quadratic (negate a) (negate b) (negate c)
  -- ...

as well as partialSum:

partialSum :: (Integral a) => a -> Term a -> a
partialSum n (Constant  c)      = n * c
partialSum n (Linear    k b)    = k * n * (n + 1) `div` 2 + partialSum n (Constant b)
partialSum n (Quadratic a b c)  = a * n * (n + 1) * (2 * n + 1) `div` 6 + partialSum n (Linear b c)
partialSum n (Arbitrary f)      = sum $ map f [1..n]

Note that we don’t have to use typeclasses for that!

Finally, you could make some useful aliases:

n :: Integral a => Term a
n = Linear 1 0

n2 :: Integral a => Term a
n2 = Quadratic 1 0 0

And go on calculating what you want:

partialSum 10 $ 3 * n2 - 5 * n + 10  -- sum = 980

Hope that helps,
Nick