Hi,

 

I'm trying to compile the following two modules:

 

```

{-# LANGUAGE NoImplicitPrelude #-}

module MiniMonad where

 

class Functor f where

    fmap :: (a -> b) -> f a -> f b

 

class (Functor f) => Applicative f where

    pure :: a -> f a

 

class (Applicative m) => Monad m where

    return :: a -> m a

    return = pure

 

    (>>=)  :: m a -> (a -> m b) -> m b

    infixl 1 >>=

```

 

```

{-# LANGUAGE NoImplicitPrelude #-}

module SpecMain where

 

import MiniMonad

 

data Identity a = MkIdentity a

 

instance Functor Identity where

    fmap f (MkIdentity x) = MkIdentity (f x)

 

instance Applicative Identity where

    pure x = MkIdentity x

 

instance Monad Identity where

 

run :: Identity a -> a

run (MkIdentity x) = x

 

foo :: ()

foo = run (return ())

```

 

If I compile these from the CLI, I see three rules firing:

 

```

./_build/stage1/bin/ghc -debug -fforce-recomp -dno-typeable-binds input/SpecMain.hs -iinput -O0  -ddump-rule-rewrites -dsuppress-all

```

 

```

[1 of 2] Compiling MiniMonad        ( input/MiniMonad.hs, input/MiniMonad.o )

[2 of 2] Compiling SpecMain         ( input/SpecMain.hs, input/SpecMain.o )

tc_iface_decl/2 Monad

 

input/SpecMain.hs:14:10: warning: [-Wmissing-methods]

    • No explicit implementation for

        ‘>>=’

    • In the instance declaration for ‘Monad Identity’

   |

14 | instance Monad Identity where

   |          ^^^^^^^^^^^^^^

Rule fired

    Rule: Class op $p1Monad

    Module: (BUILTIN)

    Before: MiniMonad.$p1Monad

              TyArg SpecMain.Identity ValArg SpecMain.$fMonadIdentity

    After:  SpecMain.$fApplicativeIdentity

    Cont:   StrictArg MiniMonad.pure

            ApplyToTy a_avS

            Stop[RhsCtxt(Recursive)] a_avS -> SpecMain.Identity a_avS

Rule fired

    Rule: Class op pure

    Module: (BUILTIN)

    Before: MiniMonad.pure

              TyArg SpecMain.Identity ValArg SpecMain.$fApplicativeIdentity

    After:  $cpure_aw8

    Cont:   ApplyToTy a_avS

            Stop[RhsCtxt(Recursive)] a_avS -> SpecMain.Identity a_avS

Rule fired

    Rule: Class op return

    Module: (BUILTIN)

    Before: MiniMonad.return

              TyArg SpecMain.Identity ValArg SpecMain.$fMonadIdentity

    After:  $creturn_avP

    Cont:   ApplyToTy ()

            ApplyToVal nodup hole () -> SpecMain.Identity () GHC.Tuple.Prim.()

            Select nodup wild_X1

            Stop[RhsCtxt(NonRecursive)] ()

```

 

However, if I try this via the API (see attached `main.hs`), then only `Class op return` fires:

 

 

```

Processing module MiniMonad

Processing module SpecMain

 

input/SpecMain.hs:14:10: warning: [-Wmissing-methods]

    • No explicit implementation for

        ‘>>=’

    • In the instance declaration for ‘Monad Identity’

   |

14 | instance Monad Identity where

   |          ^^^^^^^^^^^^^^

Rule fired

    Rule: Class op return

    Module: (BUILTIN)

    Before: MiniMonad.return

              TyArg SpecMain.Identity ValArg SpecMain.$fMonadIdentity

    After:  $creturn_aqm

    Cont:   ApplyToTy ()

            ApplyToVal nodup hole () -> SpecMain.Identity () GHC.Tuple.Prim.()

            Select nodup wild_X1

            Stop[RhsCtxt(NonRecursive)] ()

All done.

```

 

This of course leads to much worse code further downstream (and is catastrophic for my use case where I rely on extensive specialisation).

 

Why is that? What is missing from my `main.hs` that only one of the three method rules is correctly used when compiling the second module?

 

Thanks,

Gergo