type Foo = {foo::Int}

bar :: Foo -> _
bar x = x + 1

Could not match type

     { foo :: Int
     }

   with type

     Int


 while trying to match type { foo :: Int
                            }
   with type Int
 while checking that type { foo :: Int
                          }
   is at least as general as type Int
 while checking that type Int
   is at least as general as type { foo :: Int
                                  }
 while checking that expression 1
   has type { foo :: Int
            }
 while applying a function ((+) (#dict Semiring _1)) x
   of type _1 -> _1
   to argument 1
 while inferring the type of ((+) x) 1
 while checking that expression ((+) x) 1
   has type _0
 while checking that expression \x ->
                                  ((+) x) 1
   has type { foo :: Int
            }
            -> _0
 in value declaration bar

 where _0 is an unknown type
       _1 is an unknown type