packages feed

comonad 3.1 → 5.0.10

raw patch · 27 files changed

Files

.gitignore view
@@ -1,4 +1,5 @@ dist+dist-* docs wiki TAGS@@ -11,3 +12,21 @@ *.hi *~ *#+.stack-work/+cabal-dev+*.chi+*.chs.h+*.dyn_o+*.dyn_hi+.hpc+.hsenv+.cabal-sandbox/+cabal.sandbox.config+*.prof+*.aux+*.hp+*.eventlog+cabal.project.local+cabal.project.local~+.HTF/+.ghc.environment.*
+ .hlint.yaml view
@@ -0,0 +1,4 @@+- arguments: [--cpp-define=HLINT, --cpp-ansi]++- ignore: {name: Eta reduce}+- ignore: {name: Use import/export shortcut}
− .travis.yml 
@@ -1,26 +0,0 @@-language: haskell-before_install:-  # Uncomment whenever hackage is down.-  # - mkdir -p ~/.cabal && cp travis/config ~/.cabal/config && cabal update-  - cabal update--  # Try installing some of the build-deps with apt-get for speed.-  - travis/cabal-apt-install $mode--install:-  - cabal configure -flib-Werror $mode-  - cabal build--script:-  - $script && hlint src --cpp-define HLINT--notifications:-  irc:-    channels:-      - "irc.freenode.org#haskell-lens"-    skip_join: true-    template:-      - "\x0313comonad\x03/\x0306%{branch}\x03 \x0314%{commit}\x03 %{build_url} %{message}"--env:-  - mode="--enable-tests" script="cabal test --show-details=always"
+ .vim.custom view
@@ -0,0 +1,31 @@+" Add the following to your .vimrc to automatically load this on startup++" if filereadable(".vim.custom")+"     so .vim.custom+" endif++function StripTrailingWhitespace()+  let myline=line(".")+  let mycolumn = col(".")+  silent %s/  *$//+  call cursor(myline, mycolumn)+endfunction++" enable syntax highlighting+syntax on++" search for the tags file anywhere between here and /+set tags=TAGS;/++" highlight tabs and trailing spaces+set listchars=tab:‗‗,trail:‗+set list++" f2 runs hasktags+map <F2> :exec ":!hasktags -x -c --ignore src"<CR><CR>++" strip trailing whitespace before saving+" au BufWritePre *.hs,*.markdown silent! cal StripTrailingWhitespace()++" rebuild hasktags after saving+au BufWritePost *.hs silent! :exec ":!hasktags -x -c --ignore src"
CHANGELOG.markdown view
@@ -1,3 +1,118 @@+5.0.10 [2026.01.10]+-------------------+* Support building with MicroHs.+* Remove unused `transformers-compat` dependency.++5.0.9 [2024.12.04]+------------------+* Drop support for pre-8.0 versions of GHC.++5.0.8 [2020.12.30]+-----------------+* Explicitly mark modules as Safe or Trustworthy+* The build-type has been changed from `Custom` to `Simple`.+  To achieve this, the `doctests` test suite has been removed in favor of using [`cabal-docspec`](https://github.com/phadej/cabal-extras/tree/master/cabal-docspec) to run the doctests.++5.0.7 [2020.12.15]+------------------+* Move `FunctorWithIndex (TracedT m w)` instance from `lens`.+  This instance depends on the `indexed-traversable` package. This can be disabled using the flag of the same name.++5.0.6 [2019.11.26]+------------------+* Achieve forward compatibility with+  [GHC proposal 229](https://github.com/ghc-proposals/ghc-proposals/blob/master/proposals/0229-whitespace-bang-patterns.rst).++5.0.5 [2019.05.02]+------------------+* Raised the minimum `semigroups` version to 0.16.2. In addition, the+  package will only be required at all for GHCs before 8.0.+* Drop the `contravariant` flag from `comonad.cabal`, as `comonad` no longer+  depends on the `contravariant` library.++5.0.4 [2018.07.01]+------------------+* Add `Comonad` instances for `Tagged s` with `s` of any kind. Before the+  change, `s` had to be of kind `*`.+* Allow `containers-0.6`.++5.0.3 [2018.02.06]+------------------+* Don't enable `Safe` on GHC 7.2.++5.0.2+-----+* Support `doctest-0.12`++5.0.1+-----+* Revamp `Setup.hs` to use `cabal-doctest`. This makes it build+  with `Cabal-1.25`, and makes the `doctest`s work with `cabal new-build` and+  sandboxes.++5+-+* Removed module `Data.Functor.Coproduct` in favor of the `transformers`+  package's `Data.Functor.Sum`. n.b. Compatibility with older versions of+  `transformers` is possible using `transformers-compat`.+* Add `Comonad` instance for `Data.Functor.Sum.Sum`+* GHC 8 compatibility++4.2.7.2+-------+* Compiles warning-free on GHC 7.10++4.2.7.1+-------+* Use CPP++4.2.7+-----+* `Trustworthy` fixes for GHC 7.2++4.2.6+-----+* Re-export `(Data.Functor.$>)` rather than supply our own on GHC 7.8++* Better SafeHaskell support.+* `instance Monoid m => ComonadTraced m ((->) m)`++4.2.5+-------+* Added a `MINIMAL` pragma to `Comonad`.+* Added `DefaultSignatures` support for `ComonadApply` on GHC 7.2+++4.2.4+-----+* Added Kenneth Foner's fixed point as `kfix`.++4.2.3+-----+* Add `Comonad` and `ComonadEnv` instances for `Arg e` from `semigroups 0.16.3` which can be used to extract the argmin or argmax.++4.2.2+-----+* `contravariant` 1.0 support++4.2.1+-----+* Added flags that supply unsupported build modes that can be convenient for sandbox users.++4.2+---+* `transformers 0.4` compatibility++4.1+---+* Fixed the 'Typeable' instance for 'Cokleisli on GHC 7.8.1++4.0.1+-----+* Fixes to avoid warnings on GHC 7.8.1++4.0+---+* Merged the contents of `comonad-transformers` and `comonads-fd` into this package.+ 3.1 --- * Added `instance Comonad (Tagged s)`.
LICENSE view
@@ -1,4 +1,4 @@-Copyright 2008-2013 Edward Kmett+Copyright 2008-2014 Edward Kmett Copyright 2004-2008 Dave Menendez  All rights reserved.@@ -13,10 +13,6 @@ 2. Redistributions in binary form must reproduce the above copyright    notice, this list of conditions and the following disclaimer in the    documentation and/or other materials provided with the distribution.--3. Neither the name of the author nor the names of his contributors-   may be used to endorse or promote products derived from this software-   without specific prior written permission.  THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
README.markdown view
@@ -1,9 +1,10 @@ comonad ======= -[![Build Status](https://secure.travis-ci.org/ekmett/comonad.png?branch=master)](http://travis-ci.org/ekmett/comonad)+[![Build Status](https://github.com/ekmett/comonad/workflows/Haskell-CI/badge.svg)](https://github.com/ekmett/comonad/actions?query=workflow%3AHaskell-CI) -This package provides comonads, the categorical dual of monads.+This package provides comonads, the categorical dual of monads. The typeclass+provides three methods:  `extract`, `duplicate`, and `extend`.      class Functor w => Comonad w where         extract :: w a -> a@@ -12,42 +13,42 @@  There are two ways to define a comonad: -I. Provide definitions for 'extract' and 'extend' satisfying these laws:+I. Provide definitions for `extract` and `extend` satisfying these laws:      extend extract      = id     extract . extend f  = f     extend f . extend g = extend (f . extend g) -In this case, you may simply set 'fmap' = 'liftW'.+In this case, you may simply set `fmap` = `liftW`. -These laws are directly analogous to the laws for monads-and perhaps can be made clearer by viewing them as laws stating-that Cokleisli composition must be associative, and has extract for-a unit:+These laws are directly analogous to the [laws for+monads](https://wiki.haskell.org/Monad_laws). The comonad laws can+perhaps be made clearer by viewing them as stating that Cokleisli composition+must be a) associative and b) have `extract` for a unit:      f =>= extract   = f     extract =>= f   = f     (f =>= g) =>= h = f =>= (g =>= h) -II. Alternately, you may choose to provide definitions for 'fmap',-'extract', and 'duplicate' satisfying these laws:+II. Alternately, you may choose to provide definitions for `fmap`,+`extract`, and `duplicate` satisfying these laws:      extract . duplicate      = id     fmap extract . duplicate = id     duplicate . duplicate    = fmap duplicate . duplicate -In this case you may not rely on the ability to define 'fmap' in-terms of 'liftW'.+In this case, you may not rely on the ability to define `fmap` in+terms of `liftW`. -You may of course, choose to define both 'duplicate' /and/ 'extend'.-In that case you must also satisfy these laws:+You may, of course, choose to define both `duplicate` _and_ `extend`.+In that case, you must also satisfy these laws:      extend f  = fmap f . duplicate     duplicate = extend id     fmap f    = extend (f . extract) -These are the default definitions of 'extend' and'duplicate' and-the definition of 'liftW' respectively.+These implementations are the default definitions of `extend` and`duplicate` and+the definition of `liftW` respectively.  Contact Information -------------------
Setup.lhs view
@@ -1,55 +1,6 @@-#!/usr/bin/runhaskell \begin{code}-{-# OPTIONS_GHC -Wall #-} module Main (main) where--import Data.List ( nub )-import Data.Version ( showVersion )-import Distribution.Package ( PackageName(PackageName), Package, PackageId, InstalledPackageId, packageVersion, packageName )-import Distribution.PackageDescription ( PackageDescription(), TestSuite(..) )-import Distribution.Simple ( defaultMainWithHooks, UserHooks(..), simpleUserHooks )-import Distribution.Simple.Utils ( rewriteFile, createDirectoryIfMissingVerbose, copyFiles )-import Distribution.Simple.BuildPaths ( autogenModulesDir )-import Distribution.Simple.Setup ( BuildFlags(buildVerbosity), Flag(..), fromFlag, HaddockFlags(haddockDistPref))-import Distribution.Simple.LocalBuildInfo ( withLibLBI, withTestLBI, LocalBuildInfo(), ComponentLocalBuildInfo(componentPackageDeps) )-import Distribution.Text ( display )-import Distribution.Verbosity ( Verbosity, normal )-import System.FilePath ( (</>) )-+import Distribution.Simple (defaultMain) main :: IO ()-main = defaultMainWithHooks simpleUserHooks-  { buildHook = \pkg lbi hooks flags -> do-     generateBuildModule (fromFlag (buildVerbosity flags)) pkg lbi-     buildHook simpleUserHooks pkg lbi hooks flags-  , postHaddock = \args flags pkg lbi -> do-     copyFiles normal (haddockOutputDir flags pkg) []-     postHaddock simpleUserHooks args flags pkg lbi-  }--haddockOutputDir :: Package p => HaddockFlags -> p -> FilePath-haddockOutputDir flags pkg = destDir where-  baseDir = case haddockDistPref flags of-    NoFlag -> "."-    Flag x -> x-  destDir = baseDir </> "doc" </> "html" </> display (packageName pkg)--generateBuildModule :: Verbosity -> PackageDescription -> LocalBuildInfo -> IO ()-generateBuildModule verbosity pkg lbi = do-  let dir = autogenModulesDir lbi-  createDirectoryIfMissingVerbose verbosity True dir-  withLibLBI pkg lbi $ \_ libcfg -> do-    withTestLBI pkg lbi $ \suite suitecfg -> do-      rewriteFile (dir </> "Build_" ++ testName suite ++ ".hs") $ unlines-        [ "module Build_" ++ testName suite ++ " where"-        , "deps :: [String]"-        , "deps = " ++ (show $ formatdeps (testDeps libcfg suitecfg))-        ]-  where-    formatdeps = map (formatone . snd)-    formatone p = case packageName p of-      PackageName n -> n ++ "-" ++ showVersion (packageVersion p)--testDeps :: ComponentLocalBuildInfo -> ComponentLocalBuildInfo -> [(InstalledPackageId, PackageId)]-testDeps xs ys = nub $ componentPackageDeps xs ++ componentPackageDeps ys-+main = defaultMain \end{code}
comonad.cabal view
@@ -1,6 +1,6 @@ name:          comonad category:      Control, Comonads-version:       3.1+version:       5.0.10 license:       BSD3 cabal-version: >= 1.10 license-file:  LICENSE@@ -9,60 +9,114 @@ stability:     provisional homepage:      http://github.com/ekmett/comonad/ bug-reports:   http://github.com/ekmett/comonad/issues-copyright:     Copyright (C) 2008-2013 Edward A. Kmett,+copyright:     Copyright (C) 2008-2014 Edward A. Kmett,                Copyright (C) 2004-2008 Dave Menendez-synopsis:      Haskell 98 compatible comonads-description:   Haskell 98 compatible comonads-build-type:    Custom+synopsis:      Comonads+description:   Comonads.+build-type:    Simple+tested-with:   GHC == 8.0.2+             , GHC == 8.2.2+             , GHC == 8.4.4+             , GHC == 8.6.5+             , GHC == 8.8.4+             , GHC == 8.10.7+             , GHC == 9.0.2+             , GHC == 9.2.8+             , GHC == 9.4.8+             , GHC == 9.6.7+             , GHC == 9.8.4+             , GHC == 9.10.3+             , GHC == 9.12.2+             , GHC == 9.14.1 extra-source-files:   .gitignore-  .travis.yml+  .hlint.yaml+  .vim.custom+  coq/Store.v   README.markdown   CHANGELOG.markdown   examples/History.hs --- You can disable the doctests test suite with -f-test-doctests-flag test-doctests+flag containers+  description:+    You can disable the use of the `containers` package using `-f-containers`.+    .+    Disabing this is an unsupported configuration, but it may be useful for accelerating builds in sandboxes for expert users.   default: True   manual: True +flag distributive+  description:+    You can disable the use of the `distributive` package using `-f-distributive`.+    .+    Disabling this is an unsupported configuration, but it may be useful for accelerating builds in sandboxes for expert users.+    .+    If disabled we will not supply instances of `Distributive`+    .+  default: True+  manual: True++flag indexed-traversable+  description:+    You can disable the use of the `indexed-traversable` package using `-f-indexed-traversable`.+    .+    Disabling this is an unsupported configuration, but it may be useful for accelerating builds in sandboxes for expert users.+    .+    If disabled we will not supply instances of `FunctorWithIndex`+    .+  default: True+  manual: True++ source-repository head   type: git-  location: git://github.com/ekmett/comonad.git+  location: https://github.com/ekmett/comonad.git  library   hs-source-dirs: src   default-language: Haskell2010-  other-extensions: CPP+  ghc-options: -Wall    build-depends:-    base         >= 4       && < 5,-    transformers >= 0.2     && < 0.4,-    containers   >= 0.3     && < 0.6,-    semigroups   >= 0.8.3   && < 1,-    tagged       >= 0.1     && < 1+    base                >= 4.9 && < 5,+    tagged              >= 0.8.6.1 && < 1,+    transformers        >= 0.5 && < 0.7 -  exposed-modules:-    Control.Comonad+  if flag(containers)+    build-depends: containers >= 0.3 && < 0.9 -  ghc-options: -Wall+  if flag(distributive)+    build-depends: distributive >= 0.5.2 && < 1 -test-suite doctests-  type:           exitcode-stdio-1.0-  default-language: Haskell2010-  main-is:        doctests.hs-  ghc-options:    -Wall -threaded-  hs-source-dirs: tests+  if flag(indexed-traversable)+    build-depends: indexed-traversable >= 0.1.1 && < 0.2 -  if !flag(test-doctests)-    buildable: False-  else-    build-depends:-      base,-      directory      >= 1.0,-      doctest        >= 0.9.1,-      filepath+  if impl(ghc >= 9.0)+    -- these flags may abort compilation with GHC-8.10+    -- https://gitlab.haskell.org/ghc/ghc/-/merge_requests/3295+    ghc-options: -Winferred-safe-imports -Wmissing-safe-haskell-mode -  if impl(ghc<7.6.1)-    ghc-options: -Werror+  exposed-modules:+    Control.Comonad+    Control.Comonad.Env+    Control.Comonad.Env.Class+    Control.Comonad.Hoist.Class+    Control.Comonad.Identity+    Control.Comonad.Store+    Control.Comonad.Store.Class+    Control.Comonad.Traced+    Control.Comonad.Traced.Class+    Control.Comonad.Trans.Class+    Control.Comonad.Trans.Env+    Control.Comonad.Trans.Identity+    Control.Comonad.Trans.Store+    Control.Comonad.Trans.Traced+    Data.Functor.Composition +  other-extensions:+    CPP+    RankNTypes+    MultiParamTypeClasses+    FunctionalDependencies+    FlexibleInstances+    UndecidableInstances
+ coq/Store.v view
@@ -0,0 +1,96 @@+(* Proof StoreT forms a comonad -- Russell O'Connor *)++Set Implict Arguments.+Unset Strict Implicit.++Require Import FunctionalExtensionality.++Record Comonad (w : Type -> Type) : Type :=+ { extract : forall a, w a -> a+ ; extend : forall a b, (w a -> b) -> w a -> w b+ ; law1 : forall a x, extend _ _ (extract a) x = x+ ; law2 : forall a b f x, extract b (extend a _ f x) = f x+ ; law3 : forall a b c f g x, extend b c f (extend a b g x) = extend a c (fun y => f (extend a b g y)) x+ }.++Section StoreT.++Variables (s : Type) (w:Type -> Type).+Hypothesis wH : Comonad w.++Definition map a b f x := extend _ wH a b (fun y => f (extract _ wH _ y)) x.++Lemma map_extend : forall a b c f g x, map b c f (extend _ wH a b g x) = extend _ wH _ _ (fun y => f (g y)) x.+Proof.+intros a b c f g x.+unfold map.+rewrite law3.+apply equal_f.+apply f_equal.+extensionality y.+rewrite law2.+reflexivity.+Qed.++Record StoreT (a:Type): Type := mkStoreT+  {store : w (s -> a)+  ;loc   : s}.++Definition extractST a (x:StoreT a) : a := + extract _ wH _ (store _ x) (loc _ x).++Definition mapST a b (f:a -> b) (x:StoreT a) : StoreT b :=+ mkStoreT _ (map _ _ (fun g x => f (g x)) (store _ x)) (loc _ x).++Definition duplicateST a (x:StoreT a) : StoreT (StoreT a) :=+ mkStoreT _ (extend _ wH _ _ (mkStoreT _) (store _ x)) (loc _ x).++Let extendST := fun a b f x => mapST _ b f (duplicateST a x).++Lemma law1ST : forall a x, extendST _ _ (extractST a) x = x.+Proof.+intros a [v b].+unfold extractST, extendST, duplicateST, mapST.+simpl.+rewrite map_extend.+simpl.+replace (fun (y : w (s -> a)) (x : s) => extract w wH (s -> a) y x)+ with (extract w wH (s -> a)).+ rewrite law1.+ reflexivity.+extensionality y.+extensionality x.+reflexivity.+Qed.++Lemma law2ST : forall a b f x, extractST b (extendST a _ f x) = f x.+Proof.+intros a b f [v c].+unfold extendST, mapST, extractST.+simpl.+rewrite map_extend.+rewrite law2.+reflexivity.+Qed.++Lemma law3ST : forall a b c f g x, extendST b c f (extendST a b g x) = extendST a c (fun y => f (extendST a b g y)) x.+Proof.+intros a b c f g [v d].+unfold extendST, mapST, extractST.+simpl.+repeat rewrite map_extend.+rewrite law3.+repeat (apply equal_f||apply f_equal).+extensionality y.+extensionality x.+rewrite map_extend.+reflexivity.+Qed.++Definition StoreTComonad : Comonad StoreT :=+ Build_Comonad _ _ _ law1ST law2ST law3ST.++End StoreT.++Check StoreTComonad.+
examples/History.hs view
@@ -2,12 +2,13 @@ {-# OPTIONS_GHC -Wall #-}  -- http://www.mail-archive.com/haskell@haskell.org/msg17244.html+module History where -import Prelude hiding (id,(.),sum) import Control.Category import Control.Comonad import Data.Foldable hiding (sum) import Data.Traversable+import Prelude hiding (id,(.),sum)  infixl 4 :> @@ -51,7 +52,7 @@ ini dx = extract dx `fby` extend ini dx  fibo :: Num b => History a -> b-fibo d = wfix $ d $> fby 0 . extend (\dfibo -> extract dfibo + fby 1 dfibo) +fibo d = wfix $ d $> fby 0 . extend (\dfibo -> extract dfibo + fby 1 dfibo)  fibo' :: Num b => History a -> b fibo' d = fst $ wfix $ d $> fby (0, 1) . fmap (\(x, x') -> (x',x+x'))
src/Control/Comonad.hs view
@@ -1,15 +1,12 @@ {-# LANGUAGE CPP #-}-#ifdef __GLASGOW_HASKELL__-#if __GLASGOW_HASKELL__ >= 707-{-# LANGUAGE DeriveDataTypeable, StandaloneDeriving, Safe #-}-#elif __GLASGOW_HASKELL__ >= 702-{-# LANGUAGE Trustworthy #-}-#endif-#endif+{-# LANGUAGE DefaultSignatures #-}+{-# LANGUAGE Safe #-}+{-# LANGUAGE StandaloneDeriving #-}+{-# LANGUAGE PolyKinds #-}  ----------------------------------------------------------------------------- -- | -- Module      :  Control.Comonad--- Copyright   :  (C) 2008-2012 Edward Kmett,+-- Copyright   :  (C) 2008-2015 Edward Kmett, --                (C) 2004 Dave Menendez -- License     :  BSD-style (see the file LICENSE) --@@ -24,6 +21,7 @@   , liftW     -- :: Comonad w => (a -> b) -> w a -> w b   , wfix      -- :: Comonad w => w (w a -> a) -> a   , cfix      -- :: Comonad w => (w a -> a) -> w a+  , kfix      -- :: ComonadApply w => w (w a -> a) -> w a   , (=>=)   , (=<=)   , (<<=)@@ -42,30 +40,25 @@   ) where  -- import _everything_+import Data.Functor import Control.Applicative import Control.Arrow import Control.Category import Control.Monad (ap)-#if MIN_VERSION_base(4,7,0)--- Control.Monad.Instances is empty-#else-import Control.Monad.Instances-#endif import Control.Monad.Trans.Identity import Data.Functor.Identity+import qualified Data.Functor.Sum as FSum import Data.List.NonEmpty hiding (map) import Data.Semigroup hiding (Product) import Data.Tagged-import Data.Tree import Prelude hiding (id, (.)) import Control.Monad.Fix-#if __GLASGOW_HASKELL__ >= 707--- Data.Typeable is redundant-#else-import Data.Typeable++#ifdef MIN_VERSION_containers+import Data.Tree #endif -infixl 4 <@, @>, <@@>, <@>, $>+infixl 4 <@, @>, <@@>, <@> infixl 1 =>> infixr 1 <<=, =<=, =>= @@ -76,9 +69,11 @@ I. Provide definitions for 'extract' and 'extend' satisfying these laws: -> extend extract      = id-> extract . extend f  = f-> extend f . extend g = extend (f . extend g)+@+'extend' 'extract'      = 'id'+'extract' . 'extend' f  = f+'extend' f . 'extend' g = 'extend' (f . 'extend' g)+@  In this case, you may simply set 'fmap' = 'liftW'. @@ -87,16 +82,20 @@ that Cokleisli composition must be associative, and has extract for a unit: -> f =>= extract   = f-> extract =>= f   = f-> (f =>= g) =>= h = f =>= (g =>= h)+@+f '=>=' 'extract'   = f+'extract' '=>=' f   = f+(f '=>=' g) '=>=' h = f '=>=' (g '=>=' h)+@  II. Alternately, you may choose to provide definitions for 'fmap', 'extract', and 'duplicate' satisfying these laws: -> extract . duplicate      = id-> fmap extract . duplicate = id-> duplicate . duplicate    = fmap duplicate . duplicate+@+'extract' . 'duplicate'      = 'id'+'fmap' 'extract' . 'duplicate' = 'id'+'duplicate' . 'duplicate'    = 'fmap' 'duplicate' . 'duplicate'+@  In this case you may not rely on the ability to define 'fmap' in terms of 'liftW'.@@ -104,9 +103,11 @@ You may of course, choose to define both 'duplicate' /and/ 'extend'. In that case you must also satisfy these laws: -> extend f  = fmap f . duplicate-> duplicate = extend id-> fmap f    = extend (f . extract)+@+'extend' f  = 'fmap' f . 'duplicate'+'duplicate' = 'extend' id+'fmap' f    = 'extend' (f . 'extract')+@  These are the default definitions of 'extend' and 'duplicate' and the definition of 'liftW' respectively.@@ -115,27 +116,43 @@  class Functor w => Comonad w where   -- |-  -- > extract . fmap f = f . extract+  -- @+  -- 'extract' . 'fmap' f = f . 'extract'+  -- @   extract :: w a -> a    -- |-  -- > duplicate = extend id-  -- > fmap (fmap f) . duplicate = duplicate . fmap f+  -- @+  -- 'duplicate' = 'extend' 'id'+  -- 'fmap' ('fmap' f) . 'duplicate' = 'duplicate' . 'fmap' f+  -- @   duplicate :: w a -> w (w a)   duplicate = extend id    -- |-  -- > extend f = fmap f . duplicate+  -- @+  -- 'extend' f = 'fmap' f . 'duplicate'+  -- @   extend :: (w a -> b) -> w a -> w b   extend f = fmap f . duplicate +  {-# MINIMAL extract, (duplicate | extend) #-} + instance Comonad ((,)e) where   duplicate p = (fst p, p)   {-# INLINE duplicate #-}   extract = snd   {-# INLINE extract #-} +instance Comonad (Arg e) where+  duplicate w@(Arg a _) = Arg a w+  {-# INLINE duplicate #-}+  extend f w@(Arg a _) = Arg a (f w)+  {-# INLINE extend #-}+  extract (Arg _ b) = b+  {-# INLINE extract #-}+ instance Monoid m => Comonad ((->)m) where   duplicate f m = f . mappend m   {-# INLINE duplicate #-}@@ -148,6 +165,13 @@   extract = runIdentity   {-# INLINE extract #-} +-- $+-- The variable `s` can have any kind.+-- For example, here it has kind `Bool`:+-- >>> :set -XDataKinds+-- >>> import Data.Tagged+-- >>> extract (Tagged 42 :: Tagged 'True Integer)+-- 42 instance Comonad (Tagged s) where   duplicate = Tagged   {-# INLINE duplicate #-}@@ -159,43 +183,67 @@   extract = extract . runIdentityT   {-# INLINE extract #-} +#ifdef MIN_VERSION_containers instance Comonad Tree where   duplicate w@(Node _ as) = Node w (map duplicate as)   extract (Node a _) = a   {-# INLINE extract #-}+#endif  instance Comonad NonEmpty where-  extend f w@ ~(_ :| aas) = f w :| case aas of+  extend f w@(~(_ :| aas)) =+    f w :| case aas of       []     -> []       (a:as) -> toList (extend f (a :| as))   extract ~(a :| _) = a   {-# INLINE extract #-} +coproduct :: (f a -> b) -> (g a -> b) -> FSum.Sum f g a -> b+coproduct f _ (FSum.InL x) = f x+coproduct _ g (FSum.InR y) = g y+{-# INLINE coproduct #-}++instance (Comonad f, Comonad g) => Comonad (FSum.Sum f g) where+  extend f = coproduct+               (FSum.InL . extend (f . FSum.InL))+               (FSum.InR . extend (f . FSum.InR))+  extract = coproduct extract extract+  {-# INLINE extract #-}++ -- | @ComonadApply@ is to @Comonad@ like @Applicative@ is to @Monad@. -- -- Mathematically, it is a strong lax symmetric semi-monoidal comonad on the -- category @Hask@ of Haskell types. That it to say that @w@ is a strong lax--- symmetric semi-monoidal functor on Hask, where both extract and duplicate are+-- symmetric semi-monoidal functor on Hask, where both 'extract' and 'duplicate' are -- symmetric monoidal natural transformations. -- -- Laws: ----- > (.) <$> u <@> v <@> w = u <@> (v <@> w)--- > extract (p <@> q) = extract p (extract q)--- > duplicate (p <@> q) = (<@>) <$> duplicate p <@> duplicate q+-- @+-- ('.') '<$>' u '<@>' v '<@>' w = u '<@>' (v '<@>' w)+-- 'extract' (p '<@>' q) = 'extract' p ('extract' q)+-- 'duplicate' (p '<@>' q) = ('<@>') '<$>' 'duplicate' p '<@>' 'duplicate' q+-- @ ----- If our type is both a ComonadApply and Applicative we further require+-- If our type is both a 'ComonadApply' and 'Applicative' we further require ----- > (<*>) = (<@>)+-- @+-- ('<*>') = ('<@>')+-- @ -- -- Finally, if you choose to define ('<@') and ('@>'), the results of your -- definitions should match the following laws: ----- > a @> b = const id <$> a <@> b--- > a <@ b = const <$> a <@> b+-- @+-- a '@>' b = 'const' 'id' '<$>' a '<@>' b+-- a '<@' b = 'const' '<$>' a '<@>' b+-- @  class Comonad w => ComonadApply w where   (<@>) :: w (a -> b) -> w a -> w b+  default (<@>) :: Applicative w => w (a -> b) -> w a -> w b+  (<@>) = (<*>)    (@>) :: w a -> w b -> w b   a @> b = const id <$> a <@> b@@ -224,28 +272,43 @@ instance ComonadApply w => ComonadApply (IdentityT w) where   IdentityT wa <@> IdentityT wb = IdentityT (wa <@> wb) +#ifdef MIN_VERSION_containers instance ComonadApply Tree where   (<@>) = (<*>)   (<@ ) = (<* )   ( @>) = ( *>)+#endif  -- | A suitable default definition for 'fmap' for a 'Comonad'. -- Promotes a function to a comonad. ----- > fmap f = liftW f = extend (f . extract)+-- You can only safely use 'liftW' to define 'fmap' if your 'Comonad'+-- defines 'extend', not just 'duplicate', since defining+-- 'extend' in terms of duplicate uses 'fmap'!+--+-- @+-- 'fmap' f = 'liftW' f = 'extend' (f . 'extract')+-- @ liftW :: Comonad w => (a -> b) -> w a -> w b liftW f = extend (f . extract) {-# INLINE liftW #-} --- | Comonadic fixed point à la Menendez+-- | Comonadic fixed point à la David Menendez wfix :: Comonad w => w (w a -> a) -> a wfix w = extract w (extend wfix w) --- | Comonadic fixed point à la Orchard+-- | Comonadic fixed point à la Dominic Orchard cfix :: Comonad w => (w a -> a) -> w a cfix f = fix (extend f) {-# INLINE cfix #-} +-- | Comonadic fixed point à la Kenneth Foner:+--+-- This is the @evaluate@ function from his <https://www.youtube.com/watch?v=F7F-BzOB670 "Getting a Quick Fix on Comonads"> talk.+kfix :: ComonadApply w => w (w a -> a) -> w a+kfix w = fix $ \u -> w <@> duplicate u+{-# INLINE kfix #-}+ -- | 'extend' with the arguments swapped. Dual to '>>=' for a 'Monad'. (=>>) :: Comonad w => w a -> (w a -> b) -> w b (=>>) = flip extend@@ -256,12 +319,12 @@ (<<=) = extend {-# INLINE (<<=) #-} --- | Right-to-left Cokleisli composition+-- | Right-to-left 'Cokleisli' composition (=<=) :: Comonad w => (w b -> c) -> (w a -> b) -> w a -> c f =<= g = f . extend g {-# INLINE (=<=) #-} --- | Left-to-right Cokleisli composition+-- | Left-to-right 'Cokleisli' composition (=>=) :: Comonad w => (w a -> b) -> (w b -> c) -> w a -> c f =>= g = g . extend f {-# INLINE (=>=) #-}@@ -271,12 +334,12 @@ (<@@>) = liftW2 (flip id) {-# INLINE (<@@>) #-} --- | Lift a binary function into a comonad with zipping+-- | Lift a binary function into a 'Comonad' with zipping liftW2 :: ComonadApply w => (a -> b -> c) -> w a -> w b -> w c liftW2 f a b = f <$> a <@> b {-# INLINE liftW2 #-} --- | Lift a ternary function into a comonad with zipping+-- | Lift a ternary function into a 'Comonad' with zipping liftW3 :: ComonadApply w => (a -> b -> c -> d) -> w a -> w b -> w c -> w d liftW3 f a b c = f <$> a <@> b <@> c {-# INLINE liftW3 #-}@@ -284,25 +347,6 @@ -- | The 'Cokleisli' 'Arrow's of a given 'Comonad' newtype Cokleisli w a b = Cokleisli { runCokleisli :: w a -> b } -#if __GLASGOW_HASKELL__ >= 707--- instance Typeable (Cokleisli w) derived automatically-#else-#ifdef __GLASGOW_HASKELL__-instance Typeable1 w => Typeable2 (Cokleisli w) where-  typeOf2 twab = mkTyConApp cokleisliTyCon [typeOf1 (wa twab)]-        where wa :: Cokleisli w a b -> w a-              wa = undefined-#endif--cokleisliTyCon :: TyCon-#if MIN_VERSION_base(4,4,0)-cokleisliTyCon = mkTyCon3 "comonad" "Control.Comonad" "Cokleisli"-#else-cokleisliTyCon = mkTyCon "Control.Comonad.Cokleisli"-#endif-{-# NOINLINE cokleisliTyCon #-}-#endif- instance Comonad w => Category (Cokleisli w) where   id = Cokleisli extract   Cokleisli f . Cokleisli g = Cokleisli (f =<= g)@@ -332,9 +376,5 @@   Cokleisli f <*> Cokleisli a = Cokleisli (\w -> f w (a w))  instance Monad (Cokleisli w a) where-  return = Cokleisli . const+  return = pure   Cokleisli k >>= f = Cokleisli $ \w -> runCokleisli (f (k w)) w---- | Replace the contents of a functor uniformly with a constant value.-($>) :: Functor f => f a -> b -> f b-($>) = flip (<$)
+ src/Control/Comonad/Env.hs view
@@ -0,0 +1,39 @@+{-# LANGUAGE Safe #-}+-----------------------------------------------------------------------------+-- |+-- Module      :  Control.Comonad.Env+-- Copyright   :  (C) 2008-2014 Edward Kmett+-- License     :  BSD-style (see the file LICENSE)+--+-- Maintainer  :  Edward Kmett <ekmett@gmail.com>+-- Stability   :  experimental+-- Portability :  non-portable (fundeps, MPTCs)+--+-- The Env comonad (aka the Coreader, Environment, or Product comonad)+--+-- A co-Kleisli arrow in the Env comonad is isomorphic to a Kleisli arrow+-- in the reader monad.+--+-- (a -> e -> m) ~ (a, e) -> m ~ Env e a -> m+----------------------------------------------------------------------------+module Control.Comonad.Env (+  -- * ComonadEnv class+    ComonadEnv(..)+  , asks+  , local+  -- * The Env comonad+  , Env+  , env+  , runEnv+  -- * The EnvT comonad transformer+  , EnvT(..)+  , runEnvT+  -- * Re-exported modules+  , module Control.Comonad+  , module Control.Comonad.Trans.Class+  ) where++import Control.Comonad+import Control.Comonad.Env.Class (ComonadEnv(..), asks)+import Control.Comonad.Trans.Class+import Control.Comonad.Trans.Env (Env, env, runEnv, EnvT(..), runEnvT, local)
+ src/Control/Comonad/Env/Class.hs view
@@ -0,0 +1,56 @@+{-# LANGUAGE MultiParamTypeClasses #-}+{-# LANGUAGE FunctionalDependencies #-}+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE UndecidableInstances #-}+{-# LANGUAGE Safe #-}+-----------------------------------------------------------------------------+-- |+-- Module      :  Control.Comonad.Env.Class+-- Copyright   :  (C) 2008-2015 Edward Kmett+-- License     :  BSD-style (see the file LICENSE)+--+-- Maintainer  :  Edward Kmett <ekmett@gmail.com>+-- Stability   :  experimental+-- Portability :  non-portable (fundeps, MPTCs)+----------------------------------------------------------------------------+module Control.Comonad.Env.Class+  ( ComonadEnv(..)+  , asks+  ) where++import Control.Comonad+import Control.Comonad.Trans.Class+import qualified Control.Comonad.Trans.Env as Env+import Control.Comonad.Trans.Store+import Control.Comonad.Trans.Traced+import Control.Comonad.Trans.Identity+import Data.Semigroup++class Comonad w => ComonadEnv e w | w -> e where+  ask :: w a -> e++asks :: ComonadEnv e w => (e -> e') -> w a -> e'+asks f wa = f (ask wa)+{-# INLINE asks #-}++instance Comonad w => ComonadEnv e (Env.EnvT e w) where+  ask = Env.ask++instance ComonadEnv e ((,)e) where+  ask = fst++instance ComonadEnv e (Arg e) where+  ask (Arg e _) = e++lowerAsk :: (ComonadEnv e w, ComonadTrans t) => t w a -> e+lowerAsk = ask . lower+{-# INLINE lowerAsk #-}++instance ComonadEnv e w => ComonadEnv e (StoreT t w) where+  ask = lowerAsk++instance ComonadEnv e w => ComonadEnv e (IdentityT w) where+  ask = lowerAsk++instance (ComonadEnv e w, Monoid m) => ComonadEnv e (TracedT m w) where+  ask = lowerAsk
+ src/Control/Comonad/Hoist/Class.hs view
@@ -0,0 +1,27 @@+{-# LANGUAGE RankNTypes #-}+{-# LANGUAGE Safe #-}+-----------------------------------------------------------------------------+-- |+-- Module      :  Control.Comonad.Hoist.Class+-- Copyright   :  (C) 2008-2013 Edward Kmett+-- License     :  BSD-style (see the file LICENSE)+--+-- Maintainer  :  Edward Kmett <ekmett@gmail.com>+-- Stability   :  provisional+-- Portability :  portable+----------------------------------------------------------------------------+module Control.Comonad.Hoist.Class+  ( ComonadHoist(cohoist)+  ) where++import Control.Comonad+import Control.Monad.Trans.Identity++class ComonadHoist t where+  -- | Given any comonad-homomorphism from @w@ to @v@ this yields a comonad+  -- homomorphism from @t w@ to @t v@.+  cohoist :: (Comonad w, Comonad v) => (forall x. w x -> v x) -> t w a -> t v a++instance ComonadHoist IdentityT where+  cohoist l = IdentityT . l . runIdentityT+  {-# INLINE cohoist #-}
+ src/Control/Comonad/Identity.hs view
@@ -0,0 +1,20 @@+{-# LANGUAGE Safe #-}+-----------------------------------------------------------------------------+-- |+-- Module      :  Control.Comonad.Identity+-- Copyright   :  (C) 2008-2014 Edward Kmett+-- License     :  BSD-style (see the file LICENSE)+--+-- Maintainer  :  Edward Kmett <ekmett@gmail.com>+-- Stability   :  experimental+-- Portability :  non-portable (fundeps, MPTCs)+----------------------------------------------------------------------------+module Control.Comonad.Identity (+    module Control.Comonad+  , module Data.Functor.Identity+  , module Control.Comonad.Trans.Identity+  ) where++import Control.Comonad+import Data.Functor.Identity+import Control.Comonad.Trans.Identity
+ src/Control/Comonad/Store.hs view
@@ -0,0 +1,30 @@+{-# LANGUAGE Safe #-}+-----------------------------------------------------------------------------+-- |+-- Module      :  Control.Comonad.Store+-- Copyright   :  (C) 2008-2014 Edward Kmett+-- License     :  BSD-style (see the file LICENSE)+--+-- Maintainer  :  Edward Kmett <ekmett@gmail.com>+-- Stability   :  experimental+-- Portability :  non-portable (fundeps, MPTCs)+----------------------------------------------------------------------------+module Control.Comonad.Store (+  -- * ComonadStore class+    ComonadStore(..)+  -- * The Store comonad+  , Store+  , store+  , runStore+  -- * The StoreT comonad transformer+  , StoreT(..)+  , runStoreT+  -- * Re-exported modules+  , module Control.Comonad+  , module Control.Comonad.Trans.Class+  ) where++import Control.Comonad+import Control.Comonad.Store.Class (ComonadStore(..))+import Control.Comonad.Trans.Class+import Control.Comonad.Trans.Store (Store, store, runStore, StoreT(..), runStoreT)
+ src/Control/Comonad/Store/Class.hs view
@@ -0,0 +1,78 @@+{-# LANGUAGE MultiParamTypeClasses #-}+{-# LANGUAGE FunctionalDependencies #-}+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE UndecidableInstances #-}+{-# LANGUAGE Safe #-}+-----------------------------------------------------------------------------+-- |+-- Module      :  Control.Comonad.Store.Class+-- Copyright   :  (C) 2008-2012 Edward Kmett+-- License     :  BSD-style (see the file LICENSE)+--+-- Maintainer  :  Edward Kmett <ekmett@gmail.com>+-- Stability   :  experimental+-- Portability :  non-portable (fundeps, MPTCs)+----------------------------------------------------------------------------+module Control.Comonad.Store.Class+  ( ComonadStore(..)+  , lowerPos+  , lowerPeek+  ) where++import Control.Comonad+import Control.Comonad.Trans.Class+import Control.Comonad.Trans.Env+import qualified Control.Comonad.Trans.Store as Store+import Control.Comonad.Trans.Traced+import Control.Comonad.Trans.Identity++class Comonad w => ComonadStore s w | w -> s where+  pos :: w a -> s+  peek :: s -> w a -> a++  peeks :: (s -> s) -> w a -> a+  peeks f w = peek (f (pos w)) w++  seek :: s -> w a -> w a+  seek s = peek s . duplicate++  seeks :: (s -> s) -> w a -> w a+  seeks f = peeks f . duplicate++  experiment :: Functor f => (s -> f s) -> w a -> f a+  experiment f w = fmap (`peek` w) (f (pos w))++instance Comonad w => ComonadStore s (Store.StoreT s w) where+  pos = Store.pos+  peek = Store.peek+  peeks = Store.peeks+  seek = Store.seek+  seeks = Store.seeks+  experiment = Store.experiment++lowerPos :: (ComonadTrans t, ComonadStore s w) => t w a -> s+lowerPos = pos . lower+{-# INLINE lowerPos #-}++lowerPeek :: (ComonadTrans t, ComonadStore s w) => s -> t w a -> a+lowerPeek s = peek s . lower+{-# INLINE lowerPeek #-}++lowerExperiment :: (ComonadTrans t, ComonadStore s w, Functor f) => (s -> f s) -> t w a -> f a+lowerExperiment f = experiment f . lower+{-# INLINE lowerExperiment #-}++instance ComonadStore s w => ComonadStore s (IdentityT w) where+  pos = lowerPos+  peek = lowerPeek+  experiment = lowerExperiment++instance ComonadStore s w => ComonadStore s (EnvT e w) where+  pos = lowerPos+  peek = lowerPeek+  experiment = lowerExperiment++instance (ComonadStore s w, Monoid m) => ComonadStore s (TracedT m w) where+  pos = lowerPos+  peek = lowerPeek+  experiment = lowerExperiment
+ src/Control/Comonad/Traced.hs view
@@ -0,0 +1,32 @@+{-# LANGUAGE Safe #-}+-----------------------------------------------------------------------------+-- |+-- Module      :  Control.Comonad.Traced+-- Copyright   :  (C) 2008-2014 Edward Kmett+-- License     :  BSD-style (see the file LICENSE)+--+-- Maintainer  :  Edward Kmett <ekmett@gmail.com>+-- Stability   :  experimental+-- Portability :  non-portable (fundeps, MPTCs)+----------------------------------------------------------------------------+module Control.Comonad.Traced (+  -- * ComonadTraced class+    ComonadTraced(..)+  , traces+  -- * The Traced comonad+  , Traced+  , traced+  , runTraced+  -- * The TracedT comonad transformer+  , TracedT(..)+  -- * Re-exported modules+  , module Control.Comonad+  , module Control.Comonad.Trans.Class+  , module Data.Monoid+  ) where++import Control.Comonad+import Control.Comonad.Traced.Class (ComonadTraced(..), traces)+import Control.Comonad.Trans.Class+import Control.Comonad.Trans.Traced (Traced, traced, runTraced, TracedT(..), runTracedT)+import Data.Monoid
+ src/Control/Comonad/Traced/Class.hs view
@@ -0,0 +1,54 @@+{-# LANGUAGE MultiParamTypeClasses #-}+{-# LANGUAGE FunctionalDependencies #-}+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE UndecidableInstances #-}+{-# LANGUAGE Safe #-}+-----------------------------------------------------------------------------+-- |+-- Module      :  Control.Comonad.Traced.Class+-- Copyright   :  (C) 2008-2012 Edward Kmett+-- License     :  BSD-style (see the file LICENSE)+--+-- Maintainer  :  Edward Kmett <ekmett@gmail.com>+-- Stability   :  experimental+-- Portability :  non-portable (fundeps, MPTCs)+----------------------------------------------------------------------------+module Control.Comonad.Traced.Class+  ( ComonadTraced(..)+  , traces+  ) where++import Control.Comonad+import Control.Comonad.Trans.Class+import Control.Comonad.Trans.Env+import Control.Comonad.Trans.Store+import qualified Control.Comonad.Trans.Traced as Traced+import Control.Comonad.Trans.Identity++class Comonad w => ComonadTraced m w | w -> m where+  trace :: m -> w a -> a++traces :: ComonadTraced m w => (a -> m) -> w a -> a+traces f wa = trace (f (extract wa)) wa+{-# INLINE traces #-}++instance (Comonad w, Monoid m) => ComonadTraced m (Traced.TracedT m w) where+  trace = Traced.trace++instance Monoid m => ComonadTraced m ((->) m) where+  trace m f = f m++lowerTrace :: (ComonadTrans t, ComonadTraced m w) => m -> t w a -> a+lowerTrace m = trace m . lower+{-# INLINE lowerTrace #-}++-- All of these require UndecidableInstances because they do not satisfy the coverage condition++instance ComonadTraced m w => ComonadTraced m (IdentityT w) where+  trace = lowerTrace++instance ComonadTraced m w => ComonadTraced m (EnvT e w) where+  trace = lowerTrace++instance ComonadTraced m w => ComonadTraced m (StoreT s w) where+  trace = lowerTrace
+ src/Control/Comonad/Trans/Class.hs view
@@ -0,0 +1,23 @@+{-# LANGUAGE Safe #-}+-----------------------------------------------------------------------------+-- |+-- Module      :  Control.Comonad.Trans.Class+-- Copyright   :  (C) 2008-2015 Edward Kmett+-- License     :  BSD-style (see the file LICENSE)+--+-- Maintainer  :  Edward Kmett <ekmett@gmail.com>+-- Stability   :  provisional+-- Portability :  portable+----------------------------------------------------------------------------+module Control.Comonad.Trans.Class+  ( ComonadTrans(..) ) where++import Control.Comonad+import Control.Monad.Trans.Identity++class ComonadTrans t where+  lower :: Comonad w => t w a -> w a++-- avoiding orphans+instance ComonadTrans IdentityT where+  lower = runIdentityT
+ src/Control/Comonad/Trans/Env.hs view
@@ -0,0 +1,153 @@+{-# LANGUAGE CPP #-}+{-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE Safe #-}+{-# LANGUAGE StandaloneDeriving #-}+-----------------------------------------------------------------------------+-- |+-- Module      :  Control.Comonad.Trans.Env+-- Copyright   :  (C) 2008-2013 Edward Kmett+-- License     :  BSD-style (see the file LICENSE)+--+-- Maintainer  :  Edward Kmett <ekmett@gmail.com>+-- Stability   :  provisional+-- Portability :  portable+--+-- The environment comonad holds a value along with some retrievable context.+--+-- This module specifies the environment comonad transformer (aka coreader),+-- which is left adjoint to the reader comonad.+--+-- The following sets up an experiment that retains its initial value in the+-- background:+--+-- >>> let initial = env 0 0+--+-- Extract simply retrieves the value:+--+-- >>> extract initial+-- 0+--+-- Play around with the value, in our case producing a negative value:+--+-- >>> let experiment = fmap (+ 10) initial+-- >>> extract experiment+-- 10+--+-- Oh noes, something went wrong, 10 isn't very negative! Better restore the+-- initial value using the default:+--+-- >>> let initialRestored = experiment =>> ask+-- >>> extract initialRestored+-- 0+----------------------------------------------------------------------------+module Control.Comonad.Trans.Env+  (+  -- * The strict environment comonad+    Env+  , env+  , runEnv+  -- * The strict environment comonad transformer+  , EnvT(..)+  , runEnvT+  , lowerEnvT+  -- * Combinators+  , ask+  , asks+  , local+  ) where++import Control.Comonad+import Control.Comonad.Hoist.Class+import Control.Comonad.Trans.Class+import Data.Data+import Data.Functor.Identity+#if !(MIN_VERSION_base(4,11,0))+import Data.Semigroup+#endif++#ifdef __MHS__+import Data.Foldable+import Data.Traversable+#endif++-- $setup+-- >>> import Control.Comonad++instance+  ( Data e+  , Typeable w, Data (w a)+  , Data a+  ) => Data (EnvT e w a) where+    gfoldl f z (EnvT e wa) = z EnvT `f` e `f` wa+    toConstr _ = envTConstr+    gunfold k z c = case constrIndex c of+        1 -> k (k (z EnvT))+        _ -> error "gunfold"+    dataTypeOf _ = envTDataType+    dataCast1 f = gcast1 f++envTConstr :: Constr+envTConstr = mkConstr envTDataType "EnvT" [] Prefix+{-# NOINLINE envTConstr #-}++envTDataType :: DataType+envTDataType = mkDataType "Control.Comonad.Trans.Env.EnvT" [envTConstr]+{-# NOINLINE envTDataType #-}++type Env e = EnvT e Identity+data EnvT e w a = EnvT e (w a)++-- | Create an Env using an environment and a value+env :: e -> a -> Env e a+env e a = EnvT e (Identity a)++runEnv :: Env e a -> (e, a)+runEnv (EnvT e (Identity a)) = (e, a)++runEnvT :: EnvT e w a -> (e, w a)+runEnvT (EnvT e wa) = (e, wa)++instance Functor w => Functor (EnvT e w) where+  fmap g (EnvT e wa) = EnvT e (fmap g wa)++instance Comonad w => Comonad (EnvT e w) where+  duplicate (EnvT e wa) = EnvT e (extend (EnvT e) wa)+  extract (EnvT _ wa) = extract wa++instance ComonadTrans (EnvT e) where+  lower (EnvT _ wa) = wa++instance (Monoid e, Applicative m) => Applicative (EnvT e m) where+  pure = EnvT mempty . pure+  EnvT ef wf <*> EnvT ea wa = EnvT (ef `mappend` ea) (wf <*> wa)++-- | Gets rid of the environment. This differs from 'extract' in that it will+--   not continue extracting the value from the contained comonad.+lowerEnvT :: EnvT e w a -> w a+lowerEnvT (EnvT _ wa) = wa++instance ComonadHoist (EnvT e) where+  cohoist l (EnvT e wa) = EnvT e (l wa)++instance (Semigroup e, ComonadApply w) => ComonadApply (EnvT e w) where+  EnvT ef wf <@> EnvT ea wa = EnvT (ef <> ea) (wf <@> wa)++instance Foldable w => Foldable (EnvT e w) where+  foldMap f (EnvT _ w) = foldMap f w++instance Traversable w => Traversable (EnvT e w) where+  traverse f (EnvT e w) = EnvT e <$> traverse f w++-- | Retrieves the environment.+ask :: EnvT e w a -> e+ask (EnvT e _) = e++-- | Like 'ask', but modifies the resulting value with a function.+--+--   > asks = f . ask+asks :: (e -> f) -> EnvT e w a -> f+asks f (EnvT e _) = f e++-- | Modifies the environment using the specified function.+local :: (e -> e') -> EnvT e w a -> EnvT e' w a+local f (EnvT e wa) = EnvT (f e) wa
+ src/Control/Comonad/Trans/Identity.hs view
@@ -0,0 +1,17 @@+{-# LANGUAGE Safe #-}+-----------------------------------------------------------------------------+-- |+-- Module      :  Control.Comonad.Trans.Identity+-- Copyright   :  (C) 2008-2011 Edward Kmett+-- License     :  BSD-style (see the file LICENSE)+--+-- Maintainer  :  Edward Kmett <ekmett@gmail.com>+-- Stability   :  provisional+-- Portability :  portable+--+----------------------------------------------------------------------------+module Control.Comonad.Trans.Identity+  ( IdentityT(..)+  ) where++import Control.Monad.Trans.Identity
+ src/Control/Comonad/Trans/Store.hs view
@@ -0,0 +1,175 @@+{-# LANGUAGE CPP #-}+{-# LANGUAGE Safe #-}+{-# LANGUAGE StandaloneDeriving #-}+-----------------------------------------------------------------------------+-- |+-- Module      :  Control.Comonad.Trans.Store+-- Copyright   :  (C) 2008-2013 Edward Kmett+-- License     :  BSD-style (see the file LICENSE)+--+-- Maintainer  :  Edward Kmett <ekmett@gmail.com>+-- Stability   :  provisional+-- Portability :  portable+--+--+-- The store comonad holds a constant value along with a modifiable /accessor/+-- function, which maps the /stored value/ to the /focus/.+--+-- This module defines the strict store (aka state-in-context/costate) comonad+-- transformer.+--+-- @stored value = (1, 5)@, @accessor = fst@, @resulting focus = 1@:+--+-- >>> :{+--  let+--    storeTuple :: Store (Int, Int) Int+--    storeTuple = store fst (1, 5)+-- :}+--+-- Add something to the focus:+--+-- >>> :{+--  let+--    addToFocus :: Int -> Store (Int, Int) Int -> Int+--    addToFocus x wa = x + extract wa+-- :}+--+-- >>> :{+--   let+--     added3 :: Store (Int, Int) Int+--     added3 = extend (addToFocus 3) storeTuple+-- :}+--+-- The focus of added3 is now @1 + 3 = 4@. However, this action changed only+-- the accessor function and therefore the focus but not the stored value:+--+-- >>> pos added3+-- (1,5)+--+-- >>> extract added3+-- 4+--+-- The strict store (state-in-context/costate) comonad transformer is subject+-- to the laws:+--+-- > x = seek (pos x) x+-- > y = pos (seek y x)+-- > seek y x = seek y (seek z x)+--+-- Thanks go to Russell O'Connor and Daniel Peebles for their help formulating+-- and proving the laws for this comonad transformer.+----------------------------------------------------------------------------+module Control.Comonad.Trans.Store+  (+  -- * The Store comonad+    Store, store, runStore+  -- * The Store comonad transformer+  , StoreT(..), runStoreT+  -- * Operations+  , pos+  , seek, seeks+  , peek, peeks+  , experiment+  ) where++import Control.Comonad+import Control.Comonad.Hoist.Class+import Control.Comonad.Trans.Class+import Data.Functor.Identity+#if !(MIN_VERSION_base(4,11,0))+import Data.Semigroup+#endif++-- $setup+-- >>> import Control.Comonad+-- >>> import Data.Tuple (swap)++type Store s = StoreT s Identity++-- | Create a Store using an accessor function and a stored value+store :: (s -> a) -> s -> Store s a+store f s = StoreT (Identity f) s++runStore :: Store s a -> (s -> a, s)+runStore (StoreT (Identity f) s) = (f, s)++data StoreT s w a = StoreT (w (s -> a)) s++runStoreT :: StoreT s w a -> (w (s -> a), s)+runStoreT (StoreT wf s) = (wf, s)++instance Functor w => Functor (StoreT s w) where+  fmap f (StoreT wf s) = StoreT (fmap (f .) wf) s++instance (ComonadApply w, Semigroup s) => ComonadApply (StoreT s w) where+  StoreT ff m <@> StoreT fa n = StoreT ((<*>) <$> ff <@> fa) (m <> n)++instance (Applicative w, Monoid s) => Applicative (StoreT s w) where+  pure a = StoreT (pure (const a)) mempty+  StoreT ff m <*> StoreT fa n = StoreT ((<*>) <$> ff <*> fa) (mappend m n)++instance Comonad w => Comonad (StoreT s w) where+  duplicate (StoreT wf s) = StoreT (extend StoreT wf) s+  extend f (StoreT wf s) = StoreT (extend (\wf' s' -> f (StoreT wf' s')) wf) s+  extract (StoreT wf s) = extract wf s++instance ComonadTrans (StoreT s) where+  lower (StoreT f s) = fmap ($ s) f++instance ComonadHoist (StoreT s) where+  cohoist l (StoreT f s) = StoreT (l f) s++-- | Read the stored value+--+-- >>> pos $ store fst (1,5)+-- (1,5)+--+pos :: StoreT s w a -> s+pos (StoreT _ s) = s++-- | Set the stored value+--+-- >>> pos . seek (3,7) $ store fst (1,5)+-- (3,7)+--+-- Seek satisfies the law+--+-- > seek s = peek s . duplicate+seek :: s -> StoreT s w a -> StoreT s w a+seek s ~(StoreT f _) = StoreT f s++-- | Modify the stored value+--+-- >>> pos . seeks swap $ store fst (1,5)+-- (5,1)+--+-- Seeks satisfies the law+--+-- > seeks f = peeks f . duplicate+seeks :: (s -> s) -> StoreT s w a -> StoreT s w a+seeks f ~(StoreT g s) = StoreT g (f s)++-- | Peek at what the current focus would be for a different stored value+--+-- Peek satisfies the law+--+-- > peek x . extend (peek y) = peek y+peek :: Comonad w => s -> StoreT s w a -> a+peek s (StoreT g _) = extract g s+++-- | Peek at what the current focus would be if the stored value was+--   modified by some function+peeks :: Comonad w => (s -> s) -> StoreT s w a -> a+peeks f ~(StoreT g s) = extract g (f s)++-- | Applies a functor-valued function to the stored value, and then uses the+--   new accessor to read the resulting focus.+--+--   >>> let f x = if x > 0 then Just (x^2) else Nothing+--   >>> experiment f $ store (+1) 2+--   Just 5+--   >>> experiment f $ store (+1) (-2)+--   Nothing+experiment :: (Comonad w, Functor f) => (s -> f s) -> StoreT s w a -> f a+experiment f (StoreT wf s) = extract wf <$> f s
+ src/Control/Comonad/Trans/Traced.hs view
@@ -0,0 +1,106 @@+{-# LANGUAGE CPP #-}+{-# LANGUAGE Safe #-}+{-# LANGUAGE StandaloneDeriving #-}+#ifdef MIN_VERSION_indexed_traversable+{-# LANGUAGE MultiParamTypeClasses, UndecidableInstances #-}+#endif+-----------------------------------------------------------------------------+-- |+-- Module      :  Control.Comonad.Trans.Traced+-- Copyright   :  (C) 2008-2014 Edward Kmett+-- License     :  BSD-style (see the file LICENSE)+--+-- Maintainer  :  Edward Kmett <ekmett@gmail.com>+-- Stability   :  provisional+-- Portability :  portable+--+-- The trace comonad builds up a result by prepending monoidal values to each+-- other.+--+-- This module specifies the traced comonad transformer (aka the cowriter or+-- exponential comonad transformer).+--+----------------------------------------------------------------------------+module Control.Comonad.Trans.Traced+  (+  -- * Traced comonad+    Traced+  , traced+  , runTraced+  -- * Traced comonad transformer+  , TracedT(..)+  -- * Operations+  , trace+  , listen+  , listens+  , censor+  ) where++import Control.Monad (ap)+import Control.Comonad+import Control.Comonad.Hoist.Class+import Control.Comonad.Trans.Class++#ifdef MIN_VERSION_distributive+import Data.Distributive+#endif++#ifdef MIN_VERSION_indexed_traversable+import Data.Functor.WithIndex+#endif++import Data.Functor.Identity+++type Traced m = TracedT m Identity++traced :: (m -> a) -> Traced m a+traced f = TracedT (Identity f)++runTraced :: Traced m a -> m -> a+runTraced (TracedT (Identity f)) = f++newtype TracedT m w a = TracedT { runTracedT :: w (m -> a) }++instance Functor w => Functor (TracedT m w) where+  fmap g = TracedT . fmap (g .) . runTracedT++instance (ComonadApply w, Monoid m) => ComonadApply (TracedT m w) where+  TracedT wf <@> TracedT wa = TracedT (ap <$> wf <@> wa)++instance Applicative w => Applicative (TracedT m w) where+  pure = TracedT . pure . const+  TracedT wf <*> TracedT wa = TracedT (ap <$> wf <*> wa)++instance (Comonad w, Monoid m) => Comonad (TracedT m w) where+  extend f = TracedT . extend (\wf m -> f (TracedT (fmap (. mappend m) wf))) . runTracedT+  extract (TracedT wf) = extract wf mempty++instance Monoid m => ComonadTrans (TracedT m) where+  lower = fmap ($ mempty) . runTracedT++instance ComonadHoist (TracedT m) where+  cohoist l = TracedT . l . runTracedT++#ifdef MIN_VERSION_distributive+instance Distributive w => Distributive (TracedT m w) where+  distribute = TracedT . fmap (\tma m -> fmap ($ m) tma) . collect runTracedT+#endif++#ifdef MIN_VERSION_indexed_traversable+instance FunctorWithIndex i w => FunctorWithIndex (s, i) (TracedT s w) where+  imap f (TracedT w) = TracedT $ imap (\k' g k -> f (k, k') (g k)) w+  {-# INLINE imap #-}+#endif++trace :: Comonad w => m -> TracedT m w a -> a+trace m (TracedT wf) = extract wf m++listen :: Functor w => TracedT m w a -> TracedT m w (a, m)+listen = TracedT . fmap (\f m -> (f m, m)) . runTracedT++listens :: Functor w => (m -> b) -> TracedT m w a -> TracedT m w (a, b)+listens g = TracedT . fmap (\f m -> (f m, g m)) . runTracedT++censor :: Functor w => (m -> m) -> TracedT m w a -> TracedT m w a+censor g = TracedT . fmap (. g) . runTracedT
+ src/Data/Functor/Composition.hs view
@@ -0,0 +1,15 @@+{-# LANGUAGE Safe #-}+module Data.Functor.Composition+  ( Composition(..) ) where++import Data.Functor.Compose++-- | We often need to distinguish between various forms of Functor-like composition in Haskell in order to please the type system.+-- This lets us work with these representations uniformly.+class Composition o where+  decompose :: o f g x -> f (g x)+  compose :: f (g x) -> o f g x++instance Composition Compose where+  decompose = getCompose+  compose = Compose
− tests/doctests.hsc 
@@ -1,74 +0,0 @@-{-# LANGUAGE CPP #-}-{-# LANGUAGE ForeignFunctionInterface #-}--------------------------------------------------------------------------------- |--- Module      :  Main (doctests)--- Copyright   :  (C) 2012-13 Edward Kmett--- License     :  BSD-style (see the file LICENSE)--- Maintainer  :  Edward Kmett <ekmett@gmail.com>--- Stability   :  provisional--- Portability :  portable------ This module provides doctests for a project based on the actual versions--- of the packages it was built with. It requires a corresponding Setup.lhs--- to be added to the project-------------------------------------------------------------------------------module Main where--import Build_doctests (deps)-import Control.Applicative-import Control.Monad-import Data.List-import System.Directory-import System.FilePath-import Test.DocTest--##if defined(mingw32_HOST_OS)-##if defined(i386_HOST_ARCH)-##define USE_CP-import Control.Applicative-import Control.Exception-import Foreign.C.Types-foreign import stdcall "windows.h SetConsoleCP" c_SetConsoleCP :: CUInt -> IO Bool-foreign import stdcall "windows.h GetConsoleCP" c_GetConsoleCP :: IO CUInt-##elif defined(x86_64_HOST_ARCH)-##define USE_CP-import Control.Applicative-import Control.Exception-import Foreign.C.Types-foreign import ccall "windows.h SetConsoleCP" c_SetConsoleCP :: CUInt -> IO Bool-foreign import ccall "windows.h GetConsoleCP" c_GetConsoleCP :: IO CUInt-##endif-##endif---- | Run in a modified codepage where we can print UTF-8 values on Windows.-withUnicode :: IO a -> IO a-##ifdef USE_CP-withUnicode m = do-  cp <- c_GetConsoleCP-  (c_SetConsoleCP 65001 >> m) `finally` c_SetConsoleCP cp-##else-withUnicode m = m-##endif--main :: IO ()-main = withUnicode $ getSources >>= \sources -> doctest $-    "-isrc"-  : "-idist/build/autogen"-  : "-optP-include"-  : "-optPdist/build/autogen/cabal_macros.h"-  : "-hide-all-packages"-  : "-Iincludes"-  : map ("-package="++) deps ++ sources--getSources :: IO [FilePath]-getSources = filter (isSuffixOf ".hs") <$> go "src"-  where-    go dir = do-      (dirs, files) <- getFilesAndDirectories dir-      (files ++) . concat <$> mapM go dirs--getFilesAndDirectories :: FilePath -> IO ([FilePath], [FilePath])-getFilesAndDirectories dir = do-  c <- map (dir </>) . filter (`notElem` ["..", "."]) <$> getDirectoryContents dir-  (,) <$> filterM doesDirectoryExist c <*> filterM doesFileExist c