HasField for SqlExpr (Maybe (Entity a)) should use Nullable

[parsonsmatt]

@rampion suggested this in the Mercury slack, and I like the idea.

Quoting:

-- that is, change this
instance
    (PersistEntity rec, PersistField typ, SymbolToField sym rec typ)
  =>
    HasField sym (SqlExpr (Maybe (Entity rec))) (SqlExpr (Value (Maybe typ)))

-- to this
instance
    (PersistEntity rec, PersistField typ, SymbolToField sym rec typ)
  =>
    HasField sym (SqlExpr (Maybe (Entity rec))) (SqlExpr (Value (Maybe (Nullable typ))))

With this in place, mBar.thing would instead have type SqlExpr (Value (Maybe Thing)) .

[rampion]

Proposed because one of the most common sources of the SqlExpr (Value (Maybe (Maybe a))) values I encounter is from mEntity.fieldA where mEntity :: SqlExpr (Maybe (Entity b)) and fieldA :: Maybe a in record b.

[parsonsmatt]

This may not actually be super beginner friendly - the Nullable type family may not have the right inference properties. Plus we need a value-level function witness to make the type work (though I guess veryUnsafeCoerceSqlExpr does it).

[parsonsmatt]

Ah, alas, we can't use Nullable directly:

/home/matt/Projects/esqueleto/src/Database/Esqueleto/Internal/Internal.hs:2483:5: error: [GHC-73138]
    • Illegal type synonym family application ‘Nullable typ’ in instance:
        HasField
          sym
          (SqlExpr (Maybe (Entity rec)))
          (SqlExpr (Value (Maybe (Nullable typ))))
    • In the instance declaration for
        ‘HasField sym (SqlExpr (Maybe (Entity rec))) (SqlExpr (Value (Maybe (Nullable typ))))’
     |      
2483 |     HasField sym (SqlExpr (Maybe (Entity rec))) (SqlExpr (Value (Maybe (Nullable typ))))
     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

So we need a class...

This works, but it's real ugly:

instance
    (PersistEntity rec, PersistField typ, PersistField typ', SymbolToField sym rec typ
    , NullableFieldProjection typ typ'
    , HasField sym (SqlExpr (Maybe (Entity rec))) (SqlExpr (Value (Maybe typ')))
    )
  =>
    HasField sym (SqlExpr (Maybe (Entity rec))) (SqlExpr (Value (Maybe typ')))
  where
    getField expr = veryUnsafeCoerceSqlExpr (expr ?. symbolToField @sym)

class NullableFieldProjection typ typ'
instance {-# overlapping #-} NullableFieldProjection (Maybe typ) typ
instance {-# overlappable #-} NullableFieldProjection typ typ

The type inference is really bad, too. We can't have a functional dependency because there's an overlap in the two instances.

However, we do get this working:

instance
    (PersistEntity rec, PersistField typ, PersistField typ', SymbolToField sym rec typ
    , NullableFieldProjection typ typ'
    , HasField sym (SqlExpr (Maybe (Entity rec))) (SqlExpr (Value (Maybe typ')))
    )
  =>
    HasField sym (SqlExpr (Maybe (Entity rec))) (SqlExpr (Value (Maybe typ')))
  where
    getField expr = veryUnsafeCoerceSqlExpr (expr ?. symbolToField @sym)
class NullableFieldProjection typ typ'
instance {-# overlapping #-} (typ ~ typ') => NullableFieldProjection (Maybe typ) typ'
instance {-# overlappable #-} (typ ~ typ') => NullableFieldProjection typ typ'

But unfortunately the errors are pretty bad where joinV would be used. Consider this existing query:

    itDb "joins Maybe together" $ do
        void $ select $ do
            deed :& lord <-
                Experimental.from $
                    table @Deed
                    `leftJoin` table @Lord
                        `Experimental.on` do
                            \(deed :& lord) ->
                                lord.id ==. just deed.ownerId
            where_ $ joinV lord.dogs >=. just (val 10)
            pure lord

This fails with:

/home/matt/Projects/esqueleto/test/Common/Test.hs:2508:28: error: [GHC-18872]
    • Couldn't match type ‘Int’ with ‘Maybe typ0’
        arising from selecting the field ‘dogs’
    • In the first argument of ‘joinV’, namely ‘lord.dogs’
      In the first argument of ‘(>=.)’, namely ‘joinV lord.dogs’
      In the second argument of ‘($)’, namely
        ‘joinV lord.dogs >=. just (val 10)’
     |      
2508 |             where_ $ joinV lord.dogs >=. just (val 10)
     |                            ^^^^^^^^^

We can fix this by changing joinV and giving an Incoherent pragma:

joinV
    :: (NullableFieldProjection typ typ')
    => SqlExpr (Value (Maybe typ))
    -> SqlExpr (Value (Maybe typ'))
joinV = veryUnsafeCoerceSqlExprValue

class NullableFieldProjection typ typ'
instance {-# incoherent #-} (typ ~ typ') => NullableFieldProjection (Maybe typ) typ'
instance {-# overlappable #-} (typ ~ typ') => NullableFieldProjection typ typ'

This feels dicey enough that I want to experiment with this separately on the work project to see how it works out.