How to use nextval with a newtyped ID?

[sullyj3]

I have the following table:

newtype UserId = UserId { toInt32 :: Int32 }
  deriving newtype (DBEq, DBType, Eq, Show)

deriving newtype instance DBType (PasswordHash a)

data User f = User
  { userId :: Column f UserId,
    userName :: Column f Text,
    userPassword :: Column f (PasswordHash Bcrypt)
  }
  deriving stock (Generic)
  deriving anyclass (Rel8able)

And I'm trying to figure out how to insert a user. I have this snippet in a Yesod Handler

    hashed <- liftIO <| hashPassword <| mkPassword password
    let user = User {
          userId = nextval "user_id_seq",
          userName = lit username,
          userPassword = lit hashed
        }
    Yesoder conn <- getYesod
    liftIO $ run (insertUser user) conn
    pure "registered"

But I'm getting

    • Couldn't match type ‘GHC.Int.Int64’ with ‘UserId’
      Expected: Column Expr UserId
        Actual: Expr GHC.Int.Int64
    • In the ‘userId’ field of a record
      In the expression:
        User
          {userId = nextval "user_id_seq", userName = lit username,
           userPassword = lit hashed}
      In an equation for ‘user’:
          user
            = User
                {userId = nextval "user_id_seq", userName = lit username,
                 userPassword = lit hashed}
   |
87 |             userId = nextval "user_id_seq",
   |                      ^^^^^^^^^^^^^^^^^^^^^

I thought I might be able to do something like UserId <$> nextval "user_id_seq" to obtain an Expr UserId, but Expr doesn't have a Functor instance. I only have the fuzziest understanding of how expr works, so I assume there's some good reason for this. On reflection this probably doesn't make sense.

How do I handle this correctly? It seems like a pretty foundational use case.

[ocharles]

I think you have a few options:

• Define your own version of nextval with the type you want.
• Use unsafeCoerceExpr to cast Int64 into UserId.
• Add a DBNum instance to UserId, and then you can use Rel8.Expr.Num.fromIntegral to cast Int64 to UserId. This might be a bit unfortunate as it means you can now + UserIds.

I'm not sure we have a great story here, but hopefully one of these options will work for you!

[sullyj3]

I was about to resort to unsafeDefault, but I think unsafeCoerceExpr appeals the most. I'll go with that for now. Thanks!

[sullyj3]

I'm assuming you meant unsafeCastExpr?

[ocharles]

Yes 😄

[JackKelly-Bellroy]

Could we have a safe coercion operator for this? Something like:

coerceExpr :: forall b a . (Coercible a b) => Expr a -> Expr b
coerceExpr = unsafeCoerceExpr

I think it should be safe because it only works on things that are representationally equal.