diff --git a/TypeCompose.cabal b/TypeCompose.cabal --- a/TypeCompose.cabal +++ b/TypeCompose.cabal @@ -1,5 +1,5 @@ Name: TypeCompose -Version: 0.5.1 +Version: 0.6.0 Synopsis: Type composition classes & instances Category: Composition, Control Description: @@ -27,7 +27,7 @@ Data.Bijection Data.CxMonoid Data.RefMonad - Data.Pair + Data.Zip Data.Lambda Data.Title Data.Partial diff --git a/src/Control/Compose.hs b/src/Control/Compose.hs --- a/src/Control/Compose.hs +++ b/src/Control/Compose.hs @@ -214,11 +214,20 @@ pure = O . pure . pure (<*>) = inO2 (liftA2 (<*>)) +-- Possible Alternative instances: --- Possible Monoid instances +-- instance (Applicative g, Alternative f) => Alternative (g :. f) where +-- empty = O (pure empty) +-- (<|>) = inO2 (liftA2 (<|>)) --- instance (Monoid change, Applicative m, Monoid o) --- => Monoid (SourceG change m o) where +-- instance (Alternative g, Applicative f) => Alternative (g :. f) where +-- empty = O empty +-- (<|>) = inO2 (<|>) + + +-- Possible Monoid instances: + +-- instance (Applicative g, Applicative f, Monoid a) => Monoid ((g :. f) a) where -- mempty = pure mempty -- mappend = liftA2 mappend diff --git a/src/Data/Bijection.hs b/src/Data/Bijection.hs --- a/src/Data/Bijection.hs +++ b/src/Data/Bijection.hs @@ -1,8 +1,5 @@ {-# LANGUAGE TypeOperators, CPP #-} --- For ghc 6.6 compatibility --- {-# OPTIONS -fglasgow-exts #-} - - +{-# OPTIONS_GHC -Wall #-} ---------------------------------------------------------------------- -- | -- Module : Data.Bijection diff --git a/src/Data/CxMonoid.hs b/src/Data/CxMonoid.hs --- a/src/Data/CxMonoid.hs +++ b/src/Data/CxMonoid.hs @@ -1,7 +1,5 @@ {-# LANGUAGE TypeSynonymInstances, TypeOperators, GeneralizedNewtypeDeriving #-} --- -- For ghc 6.6 compatibility --- {-# OPTIONS -fglasgow-exts #-} - +{-# OPTIONS_GHC -Wall #-} ---------------------------------------------------------------------- -- | -- Module : Data.CxMonoid diff --git a/src/Data/Lambda.hs b/src/Data/Lambda.hs --- a/src/Data/Lambda.hs +++ b/src/Data/Lambda.hs @@ -1,8 +1,6 @@ {-# LANGUAGE Rank2Types, TypeOperators, MultiParamTypeClasses , FunctionalDependencies, FlexibleInstances, TypeSynonymInstances #-} --- -- For ghc 6.6 compatibility --- {-# OPTIONS -fglasgow-exts #-} - +{-# OPTIONS_GHC -Wall #-} ---------------------------------------------------------------------- -- | -- Module : Data.Lambda diff --git a/src/Data/Pair.hs b/src/Data/Pair.hs deleted file mode 100644 --- a/src/Data/Pair.hs +++ /dev/null @@ -1,220 +0,0 @@ -{-# LANGUAGE Rank2Types, TypeOperators, FlexibleInstances, FlexibleContexts - , UndecidableInstances, TypeSynonymInstances #-} - --- -- For ghc 6.6 compatibility --- {-# OPTIONS -fglasgow-exts -fallow-undecidable-instances #-} - ----------------------------------------------------------------------- --- | --- Module : Data.Pair --- Copyright : (c) Conal Elliott 2007 --- License : BSD3 --- --- Maintainer : conal@conal.net --- Stability : experimental --- Portability : GHC --- --- Pair-related type constructor classes. See "Data.Fun" for similar classes. ----------------------------------------------------------------------- - -module Data.Pair - ( - -- * Pairings - PairTy, Pair(..) - , apPair, ppPair, arPair - -- * Unpairings - , UnpairTy, Unpair(..) - -- * Dual unpairings - , Copair(..), copair - -- * Misc - , pairEdit, pairEditM - ) where - - -import Data.Monoid -import Control.Arrow -import Control.Applicative -import Control.Monad -- for pairEdit - -import Control.Compose - - -{---------------------------------------------------------- - Pairings -----------------------------------------------------------} - --- | Type of 'pair' method -type PairTy f = forall a b. f a -> f b -> f (a,b) - --- | Type constructor class for pair-like things. Generalizes 'zip'. --- Here are some standard instance templates you can fill in. They're not --- defined in the general forms below, because they would lead to a lot of --- overlap. --- --- @ --- instance Applicative f => Pair f where --- pair = liftA2 (,) --- instance (Applicative h, Pair f) => Pair (h :. f) where --- pair = apPair --- instance (Functor g, Pair g, Pair f) => Pair (g :. f) --- where pair = ppPair --- instance (Arrow (~>), Unpair f, Pair g) => Pair (Arrw (~>) f g) where --- pair = arPair --- instance (Monoid_f h, Copair h) => Pair h where --- pair = copair --- @ --- --- Also, if you have a type constructor that's a 'Functor' and a 'Pair', --- here is a way to define '(<*>)' for 'Applicative': --- --- @ --- rf <*> rx = uncurry ($) <$> (rf `pair` rx) --- @ - -class Pair f where - pair :: PairTy f -- ^ Form a pair-like value (generalizes 'zip') - --- Standard instances (Applicative f) -instance Monoid u => Pair ((,) u) where pair = liftA2 (,) -instance Pair ((->) u) where pair = liftA2 (,) -instance Pair IO where pair = liftA2 (,) - -instance Monoid o => Pair (Const o) where - pair = inConst2 mappend - -instance Pair Id where Id a `pair` Id b = Id (a,b) - --- Standard instance, e.g., (~>) = (->) --- This one requires UndecidableInstances. Alternatively, specialize to --- (->) and other arrows as desired. -instance (Arrow (~>), Monoid_f (Flip (~>) o)) => - Pair (Flip (~>) o) where pair = copair - --- | Handy for 'Pair' instances -apPair :: (Applicative h, Pair f) => PairTy (h :. f) -apPair = inO2 (liftA2 pair) - --- | Handy for 'Pair' instances -ppPair :: (Functor g, Pair g, Pair f) => PairTy (g :. f) -ppPair = inO2 $ \ gfa gfb -> fmap (uncurry pair) (gfa `pair` gfb) - --- | Pairing of 'Arrw' values. /Warning/: definition uses 'arr', so only --- use if your arrow has a working 'arr'. -arPair :: (Arrow (~>), Unpair f, Pair g) => PairTy (Arrw (~>) f g) -arPair = inArrw2 $ \ fga fgb -> - arr unpair >>> fga***fgb >>> arr (uncurry pair) - --- Standard instance -instance (Arrow (~>), Unpair f, Pair g) => Pair (Arrw (~>) f g) - where pair = arPair - -instance (Pair f, Pair g) => Pair (f :*: g) where - pair = inProd2 (pair ***# pair) - - -{---------------------------------------------------------- - Unpairings -----------------------------------------------------------} - --- | Type of 'unpair' method. Generalizes 'unzip'. -type UnpairTy f = forall a b. f (a,b) -> (f a, f b) - --- | Dissectable as pairs. Minimal instance definition: either (a) --- 'unpair' /or/ (b) both of 'pfst' /and/ 'psnd'. --- A standard template to substitute any 'Functor' @f.@ But watch out for --- effects! --- --- @ --- instance Functor f => Unpair f where {pfst = fmap fst; psnd = fmap snd} --- @ -class Unpair f where - unpair :: UnpairTy f -- ^ Deconstruct pair-like value - pfst :: f (a,b) -> f a -- ^ First part of pair-like value - psnd :: f (a,b) -> f b -- ^ Second part of pair-like value - - unpair = pfst &&& psnd - pfst = fst.unpair - psnd = snd.unpair - -instance Unpair (Const a) where - unpair (Const a) = (Const a, Const a) - -instance Unpair Id where - unpair (Id (a,b)) = (Id a, Id b) - --- Standard instance -instance Unpair [] where { pfst = fmap fst; psnd = fmap snd } - - -{---------------------------------------------------------- - Dual unpairings -----------------------------------------------------------} - --- | Dual to 'Unpair'. --- Especially handy for contravariant functors ('Cofunctor') . Use this --- template (filling in @f@) : --- --- @ --- instance Cofunctor f => Copair f where --- { cofst = cofmap fst ; cosnd = cofmap snd } --- @ -class Copair f where - cofst :: f a -> f (a,b) -- ^ Pair-like value from first part - cosnd :: f b -> f (a,b) -- ^ Pair-like value from second part - -instance Copair (Const e) where - cofst = inConst id - cosnd = inConst id - --- Standard instance for contravariant functors -instance Arrow (~>) => Copair (Flip (~>) o) where - { cofst = cofmap fst ; cosnd = cofmap snd } - -instance (Functor h, Copair f) => Copair (h :. f) where - cofst = inO (fmap cofst) - cosnd = inO (fmap cosnd) - -instance (Copair f, Copair g) => Copair (f :*: g) where - cofst = inProd (cofst *** cofst) - cosnd = inProd (cosnd *** cosnd) - --- | Pairing of 'Copair' values. Combines contribution of each. -copair :: (Copair f, Monoid_f f) => PairTy f -fa `copair` fb = cofst fa `mappend_f` cosnd fb - --- Control.Applicative.Endo --- Handy for "partial values" - -instance Unpair Endo where -- Parital == Endo - pfst = inEndo $ (fst .) . (. (\ a -> (a, undefined))) - psnd = inEndo $ (snd .) . (. (\ b -> (undefined, b))) - -instance Copair Endo where -- Parital == Endo - cofst = inEndo first - cosnd = inEndo second - --- Standard instance for (Monoid_f h, Copair h) -instance Pair Endo where pair = copair - - - -{---------------------------------------------------------- - Misc -----------------------------------------------------------} - --- | Turn a pair of sources into a source of pair-editors. See --- . --- 'Functor'\/'Monoid' version. See also 'pairEditM'. - -pairEdit :: (Functor m, Monoid (m ((c,d) -> (c,d)))) => - (m c,m d) -> m ((c,d) -> (c,d)) -pairEdit (ce,de) = - fmap (first.const) ce `mappend` fmap (second.const) de - - --- | Turn a pair of sources into a source of pair-editors. See --- . --- Monad version. See also 'pairEdit'. -pairEditM :: MonadPlus m => (m c,m d) -> m ((c,d) -> (c,d)) -pairEditM (ce,de) = - liftM (first.const) ce `mplus` liftM (second.const) de diff --git a/src/Data/Partial.hs b/src/Data/Partial.hs --- a/src/Data/Partial.hs +++ b/src/Data/Partial.hs @@ -1,5 +1,5 @@ {-# LANGUAGE TypeSynonymInstances #-} - +{-# OPTIONS_GHC -Wall #-} ---------------------------------------------------------------------- -- | -- Module : Data.Partial @@ -28,12 +28,13 @@ -- via 'FunAble' instance ) where +import Prelude hiding (zip,unzip) import Data.Monoid import Control.Arrow import Control.Compose (FunAble(..),inEndo) -import Data.Pair +import Data.Zip -- | Partial value. Represented an endomorphism, which is a 'Monoid' -- under 'id' and '(.)'. Then 'mempty' is the completely undefined value, @@ -98,15 +99,15 @@ -- @PartialFun a@. pFirst :: PartialX a a' -> PartialX (a,b) (a',b) -pFirst f = uncurry pair . first f . unpair +pFirst f = uncurry zip . first f . unzip pSecond :: PartialX b b' -> PartialX (a,b) (a,b') -pSecond g = uncurry pair . second g . unpair +pSecond g = uncurry zip . second g . unzip -- The following is not quite equivalent, since mappend doesn't commute. -- -- pSecond g ab = pUnSnd (g b) `mappend` pUnFst a --- where (a,b) = dsPPair ab +-- where (a,b) = dsPZip ab -- TODO: DeepArrow instance for PartialFun (perhaps in the DeepArrow diff --git a/src/Data/RefMonad.hs b/src/Data/RefMonad.hs --- a/src/Data/RefMonad.hs +++ b/src/Data/RefMonad.hs @@ -1,7 +1,5 @@ {-# LANGUAGE MultiParamTypeClasses, FunctionalDependencies #-} --- -- For ghc 6.6 compatibility --- {-# OPTIONS -fglasgow-exts #-} - +{-# OPTIONS_GHC -Wall #-} ---------------------------------------------------------------------- -- | -- Module : Data.RefMonad diff --git a/src/Data/Title.hs b/src/Data/Title.hs --- a/src/Data/Title.hs +++ b/src/Data/Title.hs @@ -1,7 +1,5 @@ {-# LANGUAGE FlexibleInstances, OverlappingInstances, TypeOperators, TypeSynonymInstances #-} --- -- For ghc 6.6 compatibility --- {-# OPTIONS -fglasgow-exts -fallow-overlapping-instances #-} - +{-# OPTIONS_GHC -Wall #-} ---------------------------------------------------------------------- -- | -- Module : Data.Title diff --git a/src/Data/Zip.hs b/src/Data/Zip.hs new file mode 100644 --- /dev/null +++ b/src/Data/Zip.hs @@ -0,0 +1,232 @@ +{-# LANGUAGE Rank2Types, TypeOperators, UndecidableInstances #-} +{-# OPTIONS_GHC -Wall #-} +---------------------------------------------------------------------- +-- | +-- Module : Data.Zip +-- Copyright : (c) Conal Elliott 2007 +-- License : BSD3 +-- +-- Maintainer : conal@conal.net +-- Stability : experimental +-- Portability : GHC +-- +-- Zip-related type constructor classes. +-- +-- This module is similar to @Control.Functor.Zip@ in the +-- @category-extras@ package, but it does not require a 'Functor' +-- superclass. +-- +-- This module defines generalized 'zip' and 'unzip', so if you use it, +-- you'll have to +-- +-- @ +-- import Prelude hiding (zip,unzip) +-- @ +---------------------------------------------------------------------- + +module Data.Zip + ( + -- * Zippings + ZipTy, Zip(..) + , apZip, ppZip, arZip + -- * Unzipings + , UnzipTy, Unzip(..) + -- * Dual unzipings + , Cozip(..), cozip + -- * Misc + , pairEdit, pairEditM + ) where + + +import Prelude hiding (zip,unzip) +import qualified Prelude as P + +import Data.Monoid +import Control.Arrow +import Control.Applicative +import Control.Monad -- for pairEdit + +import Control.Compose + + +{---------------------------------------------------------- + Zippings +----------------------------------------------------------} + +-- | Type of 'zip' method +type ZipTy f = forall a b. f a -> f b -> f (a,b) + +-- | Type constructor class for 'zip'-like things. +-- Here are some standard instance templates you can fill in. They're not +-- defined in the general forms below, because they would lead to a lot of +-- overlap. +-- +-- @ +-- instance Applicative f => Zip f where +-- zip = liftA2 (,) +-- instance (Applicative h, Zip f) => Zip (h :. f) where +-- zip = apZip +-- instance (Functor g, Zip g, Zip f) => Zip (g :. f) +-- where zip = ppZip +-- instance (Arrow (~>), Unzip f, Zip g) => Zip (Arrw (~>) f g) where +-- zip = arZip +-- instance (Monoid_f h, Cozip h) => Zip h where +-- zip = cozip +-- @ +-- +-- Also, if you have a type constructor that's a 'Functor' and a 'Zip', +-- here is a way to define '(<*>)' for 'Applicative': +-- +-- @ +-- rf <*> rx = uncurry ($) <$> (rf `zip` rx) +-- @ + +class Zip f where + zip :: ZipTy f -- ^ Generalized 'P.zip' + +-- Standard instances (Applicative f) +instance Zip [] where zip = P.zip +instance Monoid u => Zip ((,) u) where zip = liftA2 (,) +instance Zip ((->) u) where zip = liftA2 (,) +instance Zip IO where zip = liftA2 (,) + +instance Monoid o => Zip (Const o) where + zip = inConst2 mappend + +instance Zip Id where Id a `zip` Id b = Id (a,b) + +-- Standard instance, e.g., (~>) = (->) +-- This one requires UndecidableInstances. Alternatively, specialize to +-- (->) and other arrows as desired. +instance (Arrow (~>), Monoid_f (Flip (~>) o)) => + Zip (Flip (~>) o) where zip = cozip + +-- | Handy for 'Zip' instances +apZip :: (Applicative h, Zip f) => ZipTy (h :. f) +apZip = inO2 (liftA2 zip) + +-- | Handy for 'Zip' instances +ppZip :: (Functor g, Zip g, Zip f) => ZipTy (g :. f) +ppZip = inO2 $ \ gfa gfb -> uncurry zip <$> (gfa `zip` gfb) + +-- | Ziping of 'Arrw' values. /Warning/: definition uses 'arr', so only +-- use if your arrow has a working 'arr'. +arZip :: (Arrow (~>), Unzip f, Zip g) => ZipTy (Arrw (~>) f g) +arZip = inArrw2 $ \ fga fgb -> + arr unzip >>> fga***fgb >>> arr (uncurry zip) + +-- Standard instance +instance (Arrow (~>), Unzip f, Zip g) => Zip (Arrw (~>) f g) + where zip = arZip + +instance (Zip f, Zip g) => Zip (f :*: g) where + zip = inProd2 (zip ***# zip) + + +{---------------------------------------------------------- + Unzipings +----------------------------------------------------------} + +-- | Type of 'unzip' method. Generalizes 'P.unzip'. +type UnzipTy f = forall a b. f (a,b) -> (f a, f b) + +-- | Unzippable. Minimal instance definition: either (a) 'unzip' /or/ (b) +-- both of 'fsts' /and/ 'snds'. A standard template to substitute any +-- 'Functor' @f.@ But watch out for effects! +-- +-- @ +-- instance Functor f => Unzip f where {fsts = fmap fst; snds = fmap snd} +-- @ +class Unzip f where + unzip :: UnzipTy f -- ^ generalized unzip + fsts :: f (a,b) -> f a -- ^ First part of pair-like value + snds :: f (a,b) -> f b -- ^ Second part of pair-like value + + unzip = fsts &&& snds + fsts = fst.unzip + snds = snd.unzip + +instance Unzip [] where + unzip = P.unzip -- single pass. don't use default + fsts = fmap fst + snds = fmap snd + +-- Some standard instances for functors +instance Unzip ((->) a) where { fsts = fmap fst; snds = fmap snd } +instance Unzip ((,) a) where { fsts = fmap fst; snds = fmap snd } +instance Unzip (Const a) where { fsts = fmap fst; snds = fmap snd } +instance Unzip Id where { fsts = fmap fst; snds = fmap snd } + + +{---------------------------------------------------------- + Dual unzipings +----------------------------------------------------------} + +-- | Dual to 'Unzip'. +-- Especially handy for contravariant functors ('Cofunctor') . Use this +-- template (filling in @f@) : +-- +-- @ +-- instance Cofunctor f => Cozip f where +-- { cofsts = cofmap fst ; cosnds = cofmap snd } +-- @ +class Cozip f where + cofsts :: f a -> f (a,b) -- ^ Zip-like value from first part + cosnds :: f b -> f (a,b) -- ^ Zip-like value from second part + +instance Cozip (Const e) where + cofsts = inConst id + cosnds = inConst id + +-- Standard instance for contravariant functors +instance Arrow (~>) => Cozip (Flip (~>) o) where + { cofsts = cofmap fst ; cosnds = cofmap snd } + +instance (Functor h, Cozip f) => Cozip (h :. f) where + cofsts = inO (fmap cofsts) + cosnds = inO (fmap cosnds) + +instance (Cozip f, Cozip g) => Cozip (f :*: g) where + cofsts = inProd (cofsts *** cofsts) + cosnds = inProd (cosnds *** cosnds) + +-- | Ziping of 'Cozip' values. Combines contribution of each. +cozip :: (Cozip f, Monoid_f f) => ZipTy f +fa `cozip` fb = cofsts fa `mappend_f` cosnds fb + +-- Control.Applicative.Endo +-- Handy for "partial values" + +instance Unzip Endo where -- Parital == Endo + fsts = inEndo $ (fst .) . (. (\ a -> (a, undefined))) + snds = inEndo $ (snd .) . (. (\ b -> (undefined, b))) + +instance Cozip Endo where -- Parital == Endo + cofsts = inEndo first + cosnds = inEndo second + +-- Standard instance for (Monoid_f h, Cozip h) +instance Zip Endo where zip = cozip + + + +{---------------------------------------------------------- + Misc +----------------------------------------------------------} + +-- | Turn a pair of sources into a source of pair-editors. See +-- . +-- 'Functor'\/'Monoid' version. See also 'pairEditM'. + +pairEdit :: (Functor m, Monoid (m ((c,d) -> (c,d)))) => + (m c,m d) -> m ((c,d) -> (c,d)) +pairEdit (ce,de) = + fmap (first.const) ce `mappend` fmap (second.const) de + + +-- | Turn a pair of sources into a source of pair-editors. See +-- . +-- Monad version. See also 'pairEdit'. +pairEditM :: MonadPlus m => (m c,m d) -> m ((c,d) -> (c,d)) +pairEditM (ce,de) = + liftM (first.const) ce `mplus` liftM (second.const) de diff --git a/wikipage.tw b/wikipage.tw new file mode 100644 --- /dev/null +++ b/wikipage.tw @@ -0,0 +1,54 @@ +[[Category:Composition]] +[[Category:Applicative]] +[[Category:Libraries]] +[[Category:Packages]] + +== Abstract == + +'''TypeCompose''' provides some classes & instances for forms of type composition, as well as some modules that haven't found another home. + +Besides this wiki page, here are more ways to find out about TypeCompose: +* Visit the [http://hackage.haskell.org/cgi-bin/hackage-scripts/package/TypeCompose Hackage page] for library documentation and to download & install. +* Or install with cabal install TypeCompose. +* Get the code repository: darcs get http://code.haskell.org/TypeCompose. +* See the [[TypeCompose/Versions| version history]]. + +== Type composition == + +The Control.Compose module includes +* Various type compositions (unary/unary, binary/unary, etc). Most are from [http://www.soi.city.ac.uk/~ross/papers/Applicative.html Applicative Programming with Effects]. In particular, g `O` f composes functors in to functors and applicative functors (AFs) into AFs. (In contrast, monads do not in general compose.) Composition makes AF-based programming simple and elegant, partly because we don't need an AF counterpart to monad transformers. +* Cofunctors (contravariant functors). Great for "consumer" types, just as functors suit "producer" (container) types. There are several composition options. +* Type argument flip. Handy for cofunctors: use Flip (->) o, for (-> o). +* Constructor in pairs: (f a, g a). +* Constructor in arrows/functions: f a ~> g a. + +== Other features == + +=== Composable bijections === + +Given all the type constructors and compositions of them, I found myself writing some pretty awkward code to wrap & unwrap through multiple layers. Composable bijections help a lot. + +The Data.Bijection module is inspired by [http://citeseer.ist.psu.edu/alimarine05there.html There and Back Again: Arrows for Invertible Programming], though done here in a less general setting. + +=== Pair- & function-like types === + +The Data.Pair and Data.Lambda patterns emerged while working on [[DeepArrow]] and [[Eros]]. Data.Pair generalizes zip and unzip from [] to other functors. It also provides variants of type f a -> f (a,b) and f a -> f (a,b). Data.Lambda is similar with classes for lambda-like constructions. + +For example uses of Pair and Lambda, see [[TV]] and [[Eros]]. + +=== References === + +Monads with references. Direct rip-off from [http://citeseer.ist.psu.edu/473734.html Global Variables in Haskell]. + +=== Titling === + +For giving titles to things. I know it sounds kind of random. More useful than I first thought. Used in [[Phooey]], [[TV]], and [[Eros]]. + +=== Partial values === + +A monoid of partial values. See the [http://conal.net/blog/posts/a-type-for-partial-values/ teaser] and [http://conal.net/blog/posts/implementing-a-type-for-partial-values/ solution] blog +posts. + +=== Context-dependent monoids === + +Bit of an oddball also. Data.CxMonoid defines a sort of meta-monoid, that can be supplied dynamically with choices of mempty and mappend. Used in [[Phooey]] (starting with version 1.3) so that layout could be a monoid but still vary in style.