I&#39;m puzzled by how the haskell compiler sometimes infers types that are less
polymorphic than what I&#39;d expect, for example when using point-free definitions.

It seems like the issue is the &quot;monomorphism restriction&quot;, which is on by default on
older versions of the compiler.

Consider the following haskell program:

    {-# LANGUAGE MonomorphismRestriction #-}

    import Data.List(sortBy)

    plus = (+)
    plus&#39; x = (+ x)

    sort = sortBy compare

    main = do
      print $ plus&#39; 1.0 2.0
      print $ plus 1.0 2.0
      print $ sort [3, 1, 2]


If I compile this with `ghc` I obtain no erros and the output of the executable is:

    3.0
    3.0
    [1,2,3]

If I change the `main` body to:

    main = do
      print $ plus&#39; 1.0 2.0
      print $ plus (1 :: Int) 2
      print $ sort [3, 1, 2]

I get no compile time errors and the output becomes:

    3.0
    3
    [1,2,3]

as expected. However if I try to change it to:

    main = do
      print $ plus&#39; 1.0 2.0
      print $ plus (1 :: Int) 2
      print $ plus 1.0 2.0
      print $ sort [3, 1, 2]

I get a type error:

&lt;!-- language: lang-none --&gt;

    test.hs:13:16:
        No instance for (Fractional Int) arising from the literal ‘1.0’
        In the first argument of ‘plus’, namely ‘1.0’
        In the second argument of ‘($)’, namely ‘plus 1.0 2.0’
        In a stmt of a &#39;do&#39; block: print $ plus 1.0 2.0

The same happens when trying to call `sort` twice with different types:

    main = do
      print $ plus&#39; 1.0 2.0
      print $ plus 1.0 2.0
      print $ sort [3, 1, 2]
      print $ sort &quot;cba&quot;

produces the following error:

&lt;!-- language: lang-none --&gt;

    test.hs:14:17:
        No instance for (Num Char) arising from the literal ‘3’
        In the expression: 3
        In the first argument of ‘sort’, namely ‘[3, 1, 2]’
        In the second argument of ‘($)’, namely ‘sort [3, 1, 2]’


 - Why does `ghc` suddenly think that `plus` isn&#39;t polymorphic and requires an `Int` argument?
   The only reference to `Int` is in *an application* of `plus`, how can that matter
   when the definition is clearly polymorphic?
 - Why does `ghc` suddenly think that `sort` requires a `Num Char` instance?

Moreover if I try to place the function definitions into their own module, as in:

    {-# LANGUAGE MonomorphismRestriction #-}

    module TestMono where

    import Data.List(sortBy)

    plus = (+)
    plus&#39; x = (+ x)

    sort = sortBy compare

I get the following error when compiling:

&lt;!-- language: lang-none --&gt;

    TestMono.hs:10:15:
        No instance for (Ord a0) arising from a use of ‘compare’
        The type variable ‘a0’ is ambiguous
        Relevant bindings include
          sort :: [a0] -&gt; [a0] (bound at TestMono.hs:10:1)
        Note: there are several potential instances:
          instance Integral a =&gt; Ord (GHC.Real.Ratio a)
            -- Defined in ‘GHC.Real’
          instance Ord () -- Defined in ‘GHC.Classes’
          instance (Ord a, Ord b) =&gt; Ord (a, b) -- Defined in ‘GHC.Classes’
          ...plus 23 others
        In the first argument of ‘sortBy’, namely ‘compare’
        In the expression: sortBy compare
        In an equation for ‘sort’: sort = sortBy compare

 - Why isn&#39;t `ghc` able to use the polymorphic type `Ord a =&gt; [a] -&gt; [a]` for `sort`?
 - And why does `ghc` treat `plus` and `plus&#39;` differently? `plus` should have the
  polymorphic type `Num a =&gt; a -&gt; a -&gt; a` and I don&#39;t really see how this is different
  from the type of `sort` and yet only `sort` raises an error.

Last thing: if I comment the definition of `sort` the file compiles. However
if I try to load it into `ghci` and check the types I get:

&lt;!-- language: lang-none --&gt;

    *TestMono&gt; :t plus
    plus :: Integer -&gt; Integer -&gt; Integer
    *TestMono&gt; :t plus&#39;
    plus&#39; :: Num a =&gt; a -&gt; a -&gt; a

Why isn&#39;t the type for `plus` polymorphic?


----

&lt;sup&gt;
This is the canonical question about monomorphism restriction in Haskell
as discussed in [the meta question](https://meta.stackoverflow.com/questions/294053/can-we-provide-a-canonical-questionanswer-for-haskells-monomorphism-restrictio).
&lt;/sup&gt;

All Monomorphism Restriction Solutions on Gang of Coders

Total of 1 Monomorphism Restriction Solutions

What is the monomorphism restriction?