Safe Haskell | Safe-Inferred |
---|---|
Language | GHC2021 |
Generic strengthen
and weaken
.
Synopsis
- weakenGeneric :: (Generic s, Generic w, GWeaken (Rep s) (Rep w)) => s -> w
- strengthenGeneric :: (Generic w, Generic s, GStrengthenD (Rep w) (Rep s)) => w -> Result s
- newtype GenericallySW s (w :: Type) = GenericallySW {
- unGenericallySW :: s
Generic derivation compatibility
The Strengthen
and Weaken
generic derivers allow you to derive instances
between any compatible pair of types. Compatibility is defined as follows:
- Both types' generic representation (the SOP tree structure) match exactly.
- For each leaf pair of types, either the types are identical, or the appropriate instance exists to transform from source to target.
If they aren't compatible, the derivation will fail with a type error. I'm fairly certain that if it succeeds, your instance is guaranteed correct (assuming the instances it uses internally are all OK!).
I don't think GHC strongly guarantees the SOP property, so if you receive
surprising derivation errors, the types might have differing generic
representation structure, even if their flattened representations are identical.
If you experience this let me know, since in my experience GHC's stock Generic
derivation is highly deterministic.
Also, generic strengthening requires that all metadata is present for both types: for the datatype, constructors and selectors. GHC will always add this metadata for you, but manually-derived Generic instances (which are usually a bad idea) do not require it.
Generic derivers
weakenGeneric :: (Generic s, Generic w, GWeaken (Rep s) (Rep w)) => s -> w Source #
Weaken a value generically.
The weak and strong types must be compatible. See Generic
for
the definition of compatibility in this context.
strengthenGeneric :: (Generic w, Generic s, GStrengthenD (Rep w) (Rep s)) => w -> Result s Source #
Strengthen a value generically.
The weak and strong types must be compatible. See Generic
for
the definition of compatibility in this context.
Generic wrapper
newtype GenericallySW s (w :: Type) Source #
DerivingVia
wrapper for strongweak instances.
We can't use Generically
conveniently because we need to talk about two data
types, not one -- we would have to do something like
, which is ugly. So we instead define our own adorable little "via type"
here!Generically
(Tagged
w
s)
Use like so:
data XYZ (s :: Strength) = XYZ { xyz1 :: SW s Word8 , xyz2 :: Word8 , xyz3 :: () } deriving stock Generic deriving via (GenericallySW (XYZ 'Strong) (XYZ 'Weak)) instance Weaken (XYZ 'Strong) deriving via (GenericallySW (XYZ 'Strong) (XYZ 'Weak)) instance Strengthen (XYZ 'Strong)
TODO can't figure out a way around multiple standalone deriving declarations :(
Instances
(Generic s, Generic w, GStrengthenD (Rep w) (Rep s), Weaken (GenericallySW s w)) => Strengthen (GenericallySW s w) Source # | |
Defined in Strongweak.Generic.Via strengthen :: Weak (GenericallySW s w) -> Result (GenericallySW s w) Source # | |
(Generic s, Generic w, GWeaken (Rep s) (Rep w)) => Weaken (GenericallySW s w) Source # | |
Defined in Strongweak.Generic.Via type Weak (GenericallySW s w) Source # weaken :: GenericallySW s w -> Weak (GenericallySW s w) Source # | |
type Weak (GenericallySW s w) Source # | |
Defined in Strongweak.Generic.Via |