Data.Transhare

This module is my answer to the pattern discussed in http:blog.ezyang.com201106a-pattern-for-increasing-sharing about maximizing sharing when transforming an algebraic data type.

The' Transhare class is a kind of degerate case of Traverse building on a new Applicative data type called TransResult defined below. The result transM is a way to lift a parsimonious transformer 'a -> Maybe a', which indicates identity with Nothing, to work on a container with maximized sharing.

Documentation

data TransResult a

Constructors

Original

Fields

getTrans :: a

Transformed

Fields

getTrans :: a

Instances

Functor TransResult

Applicative TransResult

Transhare TransResult

Eq a => Eq (TransResult a)

Show a => Show (TransResult a)

type TransM a = a -> Maybe a

TransM is a parsimonious transformer that can return Nothing when the transformation is an identity.

If the result is Just t then the result t might or might not be identical to the argument.

type TransR a = a -> TransResult a

TransR is a parsimonious transformer that returns (Original x) only if x is the original argument.

This must follow the law that TransMR . TransRM . t = t

The disadvantage of TransR compared to TransM is ensuring the above law and that sharing for Original results is actually being done.

TransR which implement sharing correctly are proper implementations of TransR

transMR :: TransM a -> TransR a

transMR creates a proper implementation of transR from any transM

transRM :: TransR a -> TransM a

transRM creates a proper implementation of transM only from a proper implementation of transR

fromO :: a -> TransResult a -> TransResult a

fromO is a helper function used with Applicative to ensure the TransR computed by transR are proper implementations.

class Transhare f where

Methods

transM :: TransM a -> TransM (f a)

transR :: TransR a -> TransR (f a)

Instances

Transhare []

Transhare Tree

Transhare TransResult

Transhare (Either a)

Transhare ((,) a)

transResult_laws :: Bool