Generic.Data.Internal.Microsurgery

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.

Plural of Surgery. Apply a list of microsurgeries.

Plural of ProductSurgery. Apply a list of microsurgeries.

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.

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 f to every field type of a type a to make a synthetic type.

Apply a type constructor f to the field named s in a generic record r.

data Vec a = Vec
  { len :: Int
  , contents :: [a] }

-- with (OnField "len" Sum) becomes --

data Vec a = Vec
  { len :: Sum Int
  , contents :: [a] }

This is a defunctionalized symbol, applied using GSurgery or Surgery. See also the synonym (%~).

Infix name for OnField. To be used with Surgeries or Cat.

Examples

Transform one Int field into Sum Int for deriving Monoid:

data Vec a = Vec
  { len :: Int
  , contents :: [a] }
  deriving Generic
  deriving (Eq, Show) via Generically (Vec a)
  deriving (Semigroup, Monoid) via ProductSurgeries '["len" %~ Sum] (Vec a)

Wrap unshowable fields in Generic.Data.Opaque for deriving Show:

data Unshowable = Unshowable
  { fun :: Int -> Int
  , io :: IO Bool
  , int :: Int }
  deriving Generic
  deriving Show via Surgeries '["fun" %~ Generic.Data.Opaque, "io" %~ Generic.Data.Opaque] Unshowable

-- show (Unshowable id (pure True) 42) = "Unshowable _ _ 42"

Compose surgeries together.

Make a synthetic type (Data) by chaining multiple surgeries.

Change the generic representation to that of another type a.