[Haskell-cafe] Functional dependencies and type inference

[Malcolm Wallace]

Thomas Jäger <thjaeger at gmail.com> writes:

> I believe there may be some nasty interactions with generalized
> newtype-deriving, since we can construct two Leibniz-equal types which
> are mapped to different types using fundeps:
> 
>   class Foo a where
>     foo :: forall f. f Int -> f a
> 
>   instance Foo Int where
>     foo = id
> 
>   newtype Bar = Bar Int deriving Foo

I think this is where your example falls apart.  The compiler cannot
sensibly derive the instance of Foo for Bar.  Why?  Because, if written
explicitly, its implementation would need to be something like

    instance Foo Bar where
      foo = fmap Bar

but that is invalid, because the signature is different:

      foo :: forall f . Functor f => f Int -> f Bar

As it happens, the compiler probably does derive some different code
for 'foo', namely an unsafe coercion, but it is code that could not
be written explicitly by the user.  That is why you are able to reveal
the coercion via some other route.

Regards,
    Malcolm