Question

I need the Numeric.FAD library, albeit still being completely puzzled by existential types.

This is the code:

error_diffs :: [Double] -> NetworkState [(Int, Int, Double)]
error_diffs desired_outputs = do diff_error <- (diff_op $ error' $ map FAD.lift desired_outputs)::(NetworkState ([FAD.Dual tag Double] -> FAD.Dual tag Double))
                                 weights <- link_weights
                                 let diffs = FAD.grad (diff_error::([FAD.Dual tag a] -> FAD.Dual tag b)) weights

                                 links <- link_list
                                 return $ zipWith (\link diff ->
                                                       (linkFrom link, linkTo link, diff)
                                                  ) links diffs

error’ runs in a Reader monad, ran by diff_op, which in turn generates an anonymous function to take the current NetworkState and the differential inputs from FAD.grad and stuffs them into the Reader.

Haskell confuses me with the following:

Inferred type is less polymorphic than expected
  Quantified type variable `tag' is mentioned in the environment:
    diff_error :: [FAD.Dual tag Double] -> FAD.Dual tag Double
      (bound at Operations.hs:100:33)
In the first argument of `FAD.grad', namely
    `(diff_error :: [FAD.Dual tag a] -> FAD.Dual tag b)'
In the expression:
    FAD.grad (diff_error :: [FAD.Dual tag a] -> FAD.Dual tag b) weights
In the definition of `diffs':
    diffs = FAD.grad
              (diff_error :: [FAD.Dual tag a] -> FAD.Dual tag b) weights

Answer 1

If I write,

bigNumber :: (Num a) => a
bigNumber = product [1..100]

then when bigNumber :: Int is evaluated,
it’s evaluating (product :: [Int] -> Int) [(1 :: Int) .. (100 :: Int)],

and when bigNumber :: Integer is evaluated,
it’s evaluating (product :: [Integer] -> Integer) [(1 :: Integer) .. (100 :: Integer)].

Nothing is shared between the two.

error_diffs has a single type, that is: [Double] -> NetworkState [(Int, Int, Double)]. It must evaluate in exactly one way.

However, what you have inside:

... :: NetworkState ([FAD.Dual tag Double] -> FAD.Dual tag Double)

can be evaluated in different ways, depending on what tag is.

See the problem?