Generic record validation and error data structure

[the-dr-lazy]

Generic record validation and error data structure

[the-dr-lazy]

With the proposed design, there is no way to have multiple Validatable a instances for type a with different raw inputs.
So, this is my new suggestion:

newtype Username = Username { un :: Text }

instance Validatable A Username where
  type Parsed Username = Username
  type Errors Username = AValidationErrors
  
  validate :: A -> Sem '[] (Validation ValidationErrors Username)
  validate = undefined

instance Validatable B Username where
  type Parsed Username = Username
  type Errors Username = BValidationErrors
  
  validate :: B -> Sem '[] (Validation ValidationErrors Username)
  validate = undefined

And for Form v:

data Form (v :: Validity) = Form
  { usernameA :: Validate v A Username
  , usernameB :: Validate v B Username
  }
  deriving stock Generic

-- Because the Validatable is a multi-param typeclass we should use standalone deriving
deriving via (Generically (Form v)) instance Validatable (Form 'Raw) (From 'Parsed)

[the-dr-lazy]

There was an issue with safe coercion through Sem r a type from polysemy.

https://github.com/polysemy-research/polysemy/blob/c37d485b614e98622f5e7473a478b781a6ad5c45/src/Polysemy/Internal.hs-boot#L7

Both type variables of Sem r a are nominal which causes Sem r (Generically a) not to be coercible with Sem r a.
So here is the deal!

I made a type family called Parsed which deconstruct Generically type:

type family Parsed (a :: Type) :: Type where
  Parsed (Generically a) = a
  Parsed a               = a

Then the Validatable.validate function type signature would become:

validate :: raw -> Sem (Effects raw parsed) (Validation (Errors raw parsed) (Parsed parsed))

By now we are able to derive Validatable typeclass via Generically but due to usage of Parsed parsed in the return type of validate compiler needs disambiguation.

f :: Form 'Raw -> Sem '[] (Validation (Errors (Form 'Raw) (From 'Parsed)) (Form 'Parsed))
f = validate -- Ambiguous parsed0

To solve ambiguity, I renamed the Validatable.validate function to Validatable.parse and introduced another function with the following constraints:

validate :: forall raw parsed
          . Validatable raw parsed
         => parsed ~ Parsed parsed
         => raw
         -> Sem
              (Effects raw parsed)
              (Validation (Errors raw parsed) parsed)
validate = parse @raw @parsed