Statically analyze type with Generics

Question

For the purpose of generically deriving instances for FromRow-kind-of-class on simple products I would like to statically analyze a type without actually providing any concrete terms.

Example:

class FromRow a where
  rowrep :: Proxy a -> [Maybe NativeType]
  fromRow :: Statement -> IO a

data User = User
  { name :: String
  , uid :: Int
  , active :: Bool
  } deriving (Show, Generic)

The "trick" is I need the rowrep before I fetch any data - to possibly override the defaults for some or even all columns. At the point in time where I want to use rowrep I don't yet have a term, thus the Proxy. Writing instances of FromRow could get extremely tedious and error prone so I thought I'd add a default implementation for Generic types. However, it seems to get the generic representation I need to provide a term of a given type (from :: a -> Rep a), knowledge of type itself is not enough.

Indeed we can see this isn't just a gimmick of the API and that Generic representations do hold values:

> from (User "foo" 1 True)
M1 {unM1 = M1 {unM1 = M1 {unM1 = K1 {unK1 = "foo"}} :*: (M1 {unM1 = K1 {unK1 = 1}} :*: M1 {unM1 = K1 {unK1 = True}})}}

Is there a way to use Generic just to analyze the structure and type of things i.e. where we don't care about actual values? Failing that, is TH going to cover this use case?

leftaroundabout · Accepted Answer · 2021-10-24T16:15:27.267

You don't need to provide a term. You don't need a value of Rep a, you just need to inspect this as a type, and that can be done without ever using from.

For that matter, you also don't need Proxy, that was always just an ugly hack to make up for a deficiency of Haskell before TypeApplications came along.

{-# LANGUAGE TypeFamilies, TypeApplications, AllowAmbiguousTypes
           , ScopedTypeVariables, UnicodeSyntax, DefaultSignatures #-}

import Data.Kind (Type)

data NativeType = Intish | Floatish

class FromRow a where
  rowrep :: [Maybe NativeType]

instance FromRow Int where
  rowrep = [Just Intish]

Now, for writing generic instances we first need a helper class that does the type-level inspection of the Rep:

class GFromRow (g :: k -> Type) where
  gRowrep :: [Maybe NativeType]

instance ∀ i c f . GFromRow f => GFromRow (M1 i c f) where
  gRowRep = gRowRep @f
instance ∀ i c . FromRow c => GFromRow (K1 i c) where
  gRowRep = rowRep @c
...  -- instances for U1 and f:*:g

Then the default implementation will be

class FromRow a where
  rowrep :: [Maybe NativeType]
  default rowrep :: GFromRow (Rep a) => [Maybe NativeType]
  rowrep = gRowrep @(Rep a)

Thank you! Had to add a kind signature for GFromRow for some reason and an annotation for gRowrep inside the default implementation but otherwise works like a charm :) — user2847643, Oct 24 '21 at 15:33
@user2847643, if you *don't* want to use type applications for some reason, the "traditional" way is to get a proxy by writing `Proxy :: Proxy a` or whatever, still using `ScopedTypeVariables` unless you're dedicated to making things hard for yourself. — dfeuer, Oct 24 '21 at 18:45

Statically analyze type with Generics

1 Answers1