Sum optimization, ZipList, Vector and unboxed types

Question

I defined the following hotspot function, which currently accounts for 25% of the execution time of my program:

type EncodeLookup = [(GF256Elm, [GF256Elm])]

-- | Given the coefficients of a Polynomial and an x value,
-- calculate its corresponding y value.
-- coefficients are in ascending order [d, a1, a2, a3...] where y = d + a1*x + a2*x^2 ...
calc :: EncodeLookup -> [GF256Elm] -> [GF256Elm]
calc xsLookup poly =
    map f xsLookup
        where
            f (_, pList) = 
                let zl = (*) <$> ZipList (pList)  <*> ZipList poly
                    lst = getZipList zl
                    s = sum lst 
                in s

Where GF256Elm- this is just a shell newtypearound Int, with custom *and other operations defined for it (FiniteFields).

Here are the related profiling data for this function:

                                    individual     inherited
COST CENTRE       no.     entries  %time %alloc   %time %alloc
calc              544      794418    1.6    3.1    27.5   19.7
 calc.f           698     3972090    0.9    0.0    25.9   16.6
  calc.f.s        709     3972090    7.4    6.2    11.0    7.8
   fromInteger    711     3972090    0.7    0.0     0.7    0.0
   +              710    11916270    2.9    1.6     2.9    1.6
  calc.f.lst      708     3972090    0.0    0.0     0.0    0.0
  calc.f.zl       699     3972090    6.8    8.8    14.0    8.8
   *              712    11916270    7.2    0.0     7.2    0.0

My observations:

• sum Slowness probably came from a lazy thunks list
• *The calculation takes some time. You can see the full implementation GF256Elm here . *- This is basically a vector search for the regenerated table and some bit-throwing.
• 'ZipList` seems to take a considerable amount of time.

My questions:

• ? sum - deepSeq ?

• unboxed Int# GF256Elm? GF256Elm?

!