dualizer: Automatically generate dual constructions.

This is a package candidate release! Here you can preview how this package release will appear once published to the main package index (which can be accomplished via the 'maintain' link below). Please note that once a package has been published to the main package index it cannot be undone! Please consult the package uploading documentation for more information.

[maintain]

A library for defining duals automatically, as well as labeling duals in existing packages.


[Skip to ReadMe]

Properties

Version0.1.0.0
Change logNone available
Dependenciesbase (>=4.7 && <5), bifunctors, comonad, containers, lens, template-haskell, transformers [details]
LicenseLicenseRef-AGPL
Copyright2017 Greg Pfeil
AuthorGreg Pfeil
Maintainergreg@technomadic.org
CategoryCategories
Home pagehttps://github.com/sellout/dualizer#readme
Source repositoryhead: git clone https://github.com/sellout/dualizer
UploadedWed Jan 17 03:14:36 UTC 2018 by sellout

Modules

Downloads

Maintainers' corner

For package maintainers and hackage trustees


Readme for dualizer-0.1.0.0

[back to package description]

→ dualizer ←

Delete half (minus ε) of your Haskell code!

Join the chat at <a href="https://gitter.im/dualizer/Lobby">https://gitter.im/dualizer/Lobby</a> Hackage

Dualizer allows you to eliminate the dual of all your code. Rather than implementing, say, Comonad directly, you can define it in terms of its dual – Monad:

-- indicates that Functor is its own dual
labelSelfDual ''Functor

-- expands to:
--
--   class Functor f => Coapplicative f where
--     extract :: f a -> a -- the dual of pure
makeDualClass ''Applicative "Coapplicative" [('pure, "extract")]

-- expands to:
--
--   class Coapplicative m => Comonad m where
--     (=>>) :: m b -> (m b -> a) -> m a
makeDualClass ''Monad "Comonad" [('(>>=) , "=>>")]

See Categorical.Dual.Example for a bit more.

The Template Haskell You Need to Know

This library is written using Template Haskell, and while it tries to minimize the familiarity needed to use it (and accepting suggestions/PRs for reducing it further), some still leaks through. Here’s what you need to know.

When naming an existing type, prefix with '' (e.g., ''Either), and for an existing value, prefix with ' (e.g., 'fmap). Names of things to be created are plain Strings.

To allow code to be reified into an AST that Template Haskell can work with, it uses a special “quasiquotation” syntax, opening with [d| and closing with |] that looks like [d|your :: Code -> Here|] when used. There are variants of this that use something other than d in the opening, but we don’t need them in this library.

Defining Duals

There are three approaches here to defining duals, and they are listed in order of preference.

  1. define them simultaneously
  2. define the dual of an existing thing
  3. label two existing things as duals of each other

Simultaneous definition is the only way to automatically define duals of expressions. If you define the dual of an existing value, you will only get its type, and you will still need to provide the expression.

You can, however, still label existing values as duals of each other.

Defining Duals Simultaneously

makeDualDec
  [d| cata :: Functor f => (f a -> a) -> Fix f -> a
      cata f = f . fmap (cata f) . unfix |]
  "ana"

makeDualDec [d|type Algebra f a = f a -> a|] "Coalgebra"

This form can also be nested, allowing the definition of duals for type classes, etc. (NB: This can’t actually work this way).

makeDualDec [d|
  class Functor f => Applicative f where
    $$(makeDualDec [d|pure :: a -> f a|] "extract")
|] "Coapplicative"

makeDualDec [d|
  class Applicative f => Monad f where
    $$(makeDualDec [d|>>= :: f a -> (a -> f b) -> f b|] "=>>")
    fail :: f ()
|] "Comonad"

Defining the Dual of an Existing Thing

If one side of the construct already exists, then you can assign the duals like

makeDualType 'cata "ana"
makeDualType ''Algebra "Coalgebra"
makeDualClass ''Applicative "Coapplicative" [('pure, "extract")]
makeDualClass ''Monad "Comonad" [('(>>=) , "=>>")]

Labeling Existing Duals

Labeling is especially useful when things are duals of themselves.

labelSelfDual ''Functor
labelSelfDual 'fmap -- not implied by the former because:

class Steppable t f | t -> f where
  project :: t -> f t
  embed :: f t -> t

labelSelfDual ''Steppable
labelDual 'project 'embed

Also, if there are things that are both equivalent to some other thing, you can label one as “semi-dual”, mapping in one direction but not the other.

labelDual 'pure 'extract

-- `return` is overconstrained, so we let it dualize to `extract`, but `extract`
-- will be converted to `pure` on any return trip.
labelSemiDual 'return 'extract