Weaken some a, relaxing certain invariants.

See Strongweak for class design notes and laws.

Attempt to strengthen some Weakened a, asserting certain invariants.

We take Weaken as a superclass in order to maintain strong/weak type pair consistency. We choose this dependency direction because we treat the strong type as the "canonical" one, so Weaken is the more natural (and straightforward) class to define. That does mean the instances for this class are a little confusingly worded. Alas.

See Strongweak for class design notes and laws.

When weakening (or strengthening), chain the operation n times.

You may achieve this without extra newtypes by nesting uses of SW. However, strongweak generics can't handle this, forcing you to write manual instances.

SWChain provides this nesting behaviour in a type. In return for adding a boring newtype layer to the strong representation, you can chain weakening and strengthenings without having to write them manually.

The type works as follows:

Weakened (SWChain 0 a) = a
Weakened (SWChain 1 a) = Weakened a
Weakened (SWChain 2 a) = Weakened (Weakened a)
Weakened (SWChain n a) = WeakenedN n a

And so on. (This type is only much use from n = 2 onwards.)

You may also use this as a "via" type:

newtype A (s :: Strength) = A { a1 :: SW s (Identity (SW s Word8)) }
deriving via SWChain 2 (Identity Word8) instance     Weaken (A Strong)
deriving via SWChain 2 (Identity Word8) instance Strengthen (A Strong)

A "via type" newtype for defining strongweak instances for zero-invariant, coercible newtypes.

Use like so:

deriving Weaken via SWCoercibly a

Or standalone:

via SWCoercibly a instance Weaken (Identity a)

Note that usage of this incurs UndecidableInstances. That's life. You can write the trivial instances this generates yourself if you so wish.

Lift a function on a weak type to the associated strong type by weakening first.

Strength enumeration: it's either strong, or weak.

Primarily interesting at the type level (using DataKinds).

Get either the strong or weak representation of a type, depending on the type-level "switch" provided.

This is intended to be used in data types that take a Strength type. Define your type using strong fields wrapped in SW s. You then get the weak representation for free, using the same definition.

data A (s :: Strength) = A
  { a1 :: SW s Word8
  , a2 :: String }