Apply a microsurgery s to a type a for DerivingVia.

For the Monoid class, see ProductSurgery.

Example

{-# LANGUAGE DerivingVia #-}

-- The constructors must be visible.
import Generic.Data.Microsurgery
  (Surgery, Surgery'(..), Generically(..), Derecordify)

data T = T { unT :: Int }
  deriving Show via (Surgery Derecordify T)

-- T won't be shown as a record:
--   show (T {unT = 3}) == "T 3"

Apply a microsurgery s to a type a for DerivingVia for the Monoid class.

See Surgery.

Apply a microsurgery represented by a symbol s (declared as a dummy data type) to a generic representation f.

Forget that a type was declared using record syntax.

data Foo = Bar { baz :: Zap }

-- becomes --

data Foo = Bar Zap

Concretely, set the last field of MetaCons to False and forget field names.

This is a defunctionalized symbol, applied using GSurgery or Surgery.

Forget that a type is a newtype. (The pun is that "aging" a type makes it no longer "new".)

newtype Foo = Bar Baz

-- becomes --

data Foo = Bar Baz

This is a defunctionalized symbol, applied using GSurgery or Surgery.

Rename fields using the function rnm given as a parameter.

data Foo = Bar { baz :: Zap }

-- becomes, renaming "baz" to "bag" --

data Foo = Bar { bag :: Zap }

This is a defunctionalized symbol, applied using GSurgery or Surgery.

Rename constructors using the function rnm given as a parameter.

data Foo = Bar { baz :: Zap }

-- becomes, renaming "Bar" to "Car" --

data Foo = Car { baz :: Zap }

This is a defunctionalized symbol, applied using GSurgery or Surgery.

f @@ s is the application of a type-level function symbolized by f to a s :: Symbol.

A function FooToBar can be defined as follows:

data FooToBar
type instance FooToBar @@ "foo" = "bar"

Identity function Symbol -> Symbol.

Empty function (compile-time error when applied).

Constant function.

Define a function for a fixed set of strings, and fall back to f for the others.

Closed type family for SRename.

Unify the "spines" of two generic representations (the "spine" is everything except the field types).

onData :: _ => (Data r x -> Data s y) -> (Data r x -> Data s y)  -- possible specialization

Can be used with generic-lens for type-changing field updates with field_ (and possibly other generic optics).

A specialization of the identity function to be used to fix types of functions on Data, unifying the "spines" of input and output generic representations (the "spine" is everything except field types, which may thus change).

Apply a type constructor f to every field type of a generic representation r.

data Color = RGB
  { r :: Int
  , g :: Int
  , b :: Int }

-- becomes --

data Color f = RGB
  { r :: f Int
  , g :: f Int
  , b :: f Int }

This is a defunctionalized symbol, applied using GSurgery or Surgery.

Apply a type constructor to every field type of a type a to make a synthetic type.

Change the generic representation to that of another type a.