Compiler can't infer type while using Newtype class Constraint purescript

Question

I was trying to write a function that can get the data that a newtype wraps.

newtype Person = Person {name :: String, age :: Int}

getRecord :: forall r. Newtype Person r => Person -> r
getRecord (Person p) = p

This fails to compile and complains

Could not match type

    { age :: Int
    , name :: String
    }

  with type

    r0


while checking that type { age :: Int
                         , name :: String
                         }
  is at least as general as type r0
while checking that expression p
  has type r0
in value declaration getRecord

But when I do

getRecord :: forall r. Newtype Person r => Person -> r
getRecord  = unwrap 

It works fine !! My Question is why it can't infer the type the first time?

The newtype type class is defined like,

class (Coercible t a) <= Newtype t a | t -> a

which means it can infer the a when it knows what t is. Then why its not working the first time.

Answer 1

Constraint solving happens when calling the function, but not when defining one.

At call site, the compiler will solve the Newtype Person r constraint and figure out that r ~ { age :: Int, name :: String } , so you can use its fields.

But at definition site, the compiler doesn't do that. There, it's just some unknown type r . And since it's unknown, the compiler can't in good faith tell that r ~ { age :: Int, name :: String } , so there is a type mismatch.

---

Using unwrap works, because there the type r doesn't need to be known. Whatever it is, it's just passed straight to unwrap , and your function doesn't need to know anything about it.

---

Why does the compiler not do constraint solving at definition site? I mean it technically could, but that would be kinda useless anyway: after all, if you already know the type, just write it out:

getRecord :: Person -> { age :: Int, name :: String }
getRecord (Person p) = p