It will infer you mean Integer if you just evaluate it, read what it says about ":set +t". Crudely put, `:t foo` puts a question to the interpeter that is about the expression "foo" - "in what sense can this expression be taken?" -- it would be tiresome but maybe a little clearer if `:t` demanded quotes. If you just ask it what 5 or (4 + 1) or 2+2+1 is, it will say that it is 5 and assume that we were talking about an `Integer` -- the command `:t it` gives the type it is associating with the sign it is exhibiting to you as the result of calculation or evaluation, the second sign, not the one you entered.

In the type query `:t 5`, ghci doesn't have to decide or resolve anything, it gives all the possibilities, `5: Num a => a`. But if it is to evaluate the expression it needs you or it to make decisions. You can see this pretty clearly in the following:

     Prelude> :t 5
     5 :: (Num t) => t
     Prelude> 5
     5
     Prelude> :t it
     it :: Integer
     Prelude> 5 :: Float
     5.0
     Prelude> :m + Data.Ratio
     Prelude Data.Ratio> 5 :: Rational
     5 % 1
     Prelude Data.Ratio> :t it
     it :: Rational

In the first case, it decided, in the other two, I decided what type I meant.

I'm not sure I grasp everything about this, but in your example, `p [1,2,3,4,5]` ghci couldn't make its natural assumption - i.e. the one you in fact think should be it's natural assumption -- since no Monoid (in your sense) instance had been declared for its preferred case, Integer, so it backed off and demanded clarification.

You had unconsciously over-ruled the defaults you wanted. As has been pointed out, if you had realized that Integer is the name for Haskell's integer type, and Int a dirty approximation like Float, and had used it, everything would have gone as you claim to have wanted. In fact you get everything you want if you just add these lines to your module:

    instance Monoid Integer
        where
          addId = 0
          add = (+)

keeping all of the other Int stuff intact. Then in ghci can use its defaults -- the defaults you want -- and you get:

    Ok, modules loaded: Main.
    *Main> p [1,2,3,4,5]
    (5x^4 + 4x^3 + 3x^2 + 2x + 1)
    *Main> :t it
    it :: UnivariatePolynomial Integer

Though of course the unevaluated expression is given a more general type:

    *Main> :t  p [1,2,3,4,5]
    p [1,2,3,4,5] :: (Num t, Monoid t) => 
                       UnivariatePolynomial t

-- and rightly, since this very module permits an Int interpretation of the expression. In a case that goes against its defaults, I have to tell it that that's how I want the complex functional expression to be understood, before I ask for evaluation:

    *Main> p [1,2,3,4,5] :: UnivariatePolynomial Int
    (5x^4 + 4x^3 + 3x^2 + 2x + 1)
     *Main> :t it
     it :: UnivariatePolynomial Int

It is the same if you add another Monoid instance for the non-default reading of "1", e.g.

    instance Monoid Float
        where
          addId = 0
          add = (+)

This can exist side by side with the others. Then you get:

     *Main> p [1,2,3,4,5] :: UnivariatePolynomial Float
     (5.0x^4 + 4.0x^3 + 3.0x^2 + 2.0x + 1.0)
     *Main> :t it
     it :: UnivariatePolynomial Float

Note that even with three Monoid instances in play in the module, we still get what you wanted:

    *Main> p [1,2,3,4,5] 
    (5x^4 + 4x^3 + 3x^2 + 2x + 1)
    *Main> :t it
    it :: UnivariatePolynomial Integer