pointed-5.0.4/0000755000000000000000000000000007346545000011353 5ustar0000000000000000pointed-5.0.4/CHANGELOG.markdown0000644000000000000000000000231507346545000014407 0ustar00000000000000005.0.4 [2022.05.07] ------------------ * Allow building with `transformers-0.6.*`. 5.0.3 [2021.11.01] ------------------ * Allow building with `base-4.16` (GHC 9.2). 5.0.2 [2020.09.30] ------------------ * Drop unused `generic-deriving` dependency. 5.0.1 ----- * Add `Pointed` and `Copointed` instances for various types from `GHC.Generics`. * Do not attempt to support Safe Haskell anymore. 5 - * Require `kan-extensions-5`. 4.2.1 ----- * Added (largely unsupported) options to build without almost all of the dependencies for advanced users 4.2.0.2 ------- * Added the `CHANGELOG.markdown` to `extra-source-files`, so that `hackage` can display it. 4.2.0.1 ------- * Allow `semigroupoids` 5. 4.2 --- * Add dependency on kan-extensions for instances 4.1.1 --- * Added transformers-compat dependency to loosen transformers dependency 4.1 --- * Added missing instances for `transformers` 0.4 types 4.0 --- * Updated to use the 4.0 versions of `comonad` and `semigroupoids` packages * Updated to use just `data-default-class`. Beware of orphans. 3.1 --- * Added `Tagged` and `Proxy` instances. 3.0.3 ----- * Claim to be Trustworthy 3.0.2 ----- * Removed upper bounds on my other packages * Refactored directory layout pointed-5.0.4/LICENSE0000644000000000000000000000236407346545000012365 0ustar0000000000000000Copyright 2008-2011 Edward Kmett All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 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. THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. pointed-5.0.4/README.markdown0000644000000000000000000000101107346545000014045 0ustar0000000000000000pointed ======= [![Hackage](https://img.shields.io/hackage/v/pointed.svg)](https://hackage.haskell.org/package/pointed) [![Build Status](https://github.com/ekmett/pointed/workflows/Haskell-CI/badge.svg)](https://github.com/ekmett/pointed/actions?query=workflow%3AHaskell-CI) Haskell 98 pointed and copointed data types. Contact Information ------------------- Contributions and bug reports are welcome! Please feel free to contact me through github or on the #haskell IRC channel on irc.freenode.net. -Edward Kmett pointed-5.0.4/Setup.lhs0000644000000000000000000000016507346545000013165 0ustar0000000000000000#!/usr/bin/runhaskell > module Main (main) where > import Distribution.Simple > main :: IO () > main = defaultMain pointed-5.0.4/pointed.cabal0000644000000000000000000000621707346545000014007 0ustar0000000000000000name: pointed category: Data version: 5.0.4 license: BSD3 cabal-version: >= 1.10 license-file: LICENSE author: Edward A. Kmett maintainer: Edward A. Kmett stability: provisional homepage: http://github.com/ekmett/pointed/ bug-reports: http://github.com/ekmett/pointed/issues copyright: Copyright (C) 2008-2016 Edward A. Kmett synopsis: Pointed and copointed data description: Pointed and copointed data. build-type: Simple tested-with: GHC == 7.4.2 , GHC == 7.6.3 , GHC == 7.8.4 , GHC == 7.10.3 , 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.1 , GHC == 9.2.1 extra-source-files: README.markdown CHANGELOG.markdown source-repository head type: git location: git://github.com/ekmett/pointed.git flag comonad description: You can disable the use of the `comonad` package using `-f-transformers`. default: True manual: True flag containers description: You can disable the use of the `containers` package using `-f-containers`. default: True manual: True flag kan-extensions description: You can disable the use of the `kan-extensions` package using `-f-kan-extensions`. default: True manual: True flag semigroupoids description: You can disable the use of the `semigroupoids` package using `-f-semigroupoids`. default: True manual: True flag semigroups description: You can disable the use of the `semigroups` package using `-f-semigroups`. default: True manual: True flag stm description: You can disable the use of the `stm` package using `-f-stm`. default: True manual: True flag tagged description: You can disable the use of the `tagged` package using `-f-tagged`. default: True manual: True flag transformers description: You can disable the use of the `transformers` package using `-f-transformers`. default: True manual: True flag unordered-containers description: You can disable the use of the `unordered-containers` package using `-f-unordered-containers`. default: True manual: True library build-depends: base >= 4.5 && < 5, data-default-class >= 0.0.1 && < 0.2 if impl(ghc >= 7.2 && < 7.6) build-depends: ghc-prim if flag(comonad) build-depends: comonad >= 5 && < 6 if flag(containers) build-depends: containers >= 0.4 && < 0.7 if flag(kan-extensions) build-depends: kan-extensions >= 5 && < 6 if flag(semigroupoids) build-depends: semigroupoids >= 4 && < 6 if flag(semigroups) build-depends: semigroups >= 0.8.3.1 && < 1 if flag(stm) build-depends: stm >= 2.1.2.1 && < 2.6 if flag(tagged) build-depends: tagged >= 0.5 && < 1 if flag(transformers) build-depends: transformers >= 0.2 && < 0.7, transformers-compat >= 0.3 && < 1 if flag(unordered-containers) build-depends: hashable >= 1.1 && < 1.5, unordered-containers >= 0.2 && < 0.3 exposed-modules: Data.Pointed Data.Copointed default-language: Haskell2010 ghc-options: -Wall hs-source-dirs: src pointed-5.0.4/src/Data/0000755000000000000000000000000007346545000013013 5ustar0000000000000000pointed-5.0.4/src/Data/Copointed.hs0000644000000000000000000001223507346545000015276 0ustar0000000000000000{-# LANGUAGE CPP #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE TypeOperators #-} #ifndef MIN_VERSION_base #define MIN_VERSION_base(x,y,z) 0 #endif module Data.Copointed where import Control.Applicative import Data.Default.Class import GHC.Generics #ifdef MIN_VERSION_comonad import Control.Comonad.Trans.Env import Control.Comonad.Trans.Store import Control.Comonad.Trans.Traced #if !(MIN_VERSION_comonad(4,3,0)) import Data.Functor.Coproduct #endif #endif #ifdef MIN_VERSION_containers import Data.Tree #endif #ifdef MIN_VERSION_semigroupoids import Data.Functor.Bind #endif #if defined(MIN_VERSION_semigroups) || (MIN_VERSION_base(4,9,0)) import Data.Semigroup as Semigroup import Data.List.NonEmpty (NonEmpty(..)) #endif import qualified Data.Monoid as Monoid #ifdef MIN_VERSION_tagged import Data.Tagged #endif #if defined(MIN_VERSION_transformers) || (MIN_VERSION_base(4,8,0)) import Data.Functor.Identity #endif #if defined(MIN_VERSION_transformers) || (MIN_VERSION_base(4,9,0)) import Data.Functor.Sum as F import Data.Functor.Compose #endif #ifdef MIN_VERSION_transformers import Data.Functor.Reverse import Control.Applicative.Backwards import Control.Applicative.Lift as Applicative import Control.Monad.Trans.Identity import qualified Control.Monad.Trans.Writer.Lazy as Lazy import qualified Control.Monad.Trans.Writer.Strict as Strict #endif -- | 'Copointed' does not require a 'Functor', as the only relationship -- between 'copoint' and 'fmap' is given by a free theorem. class Copointed p where copoint :: p a -> a instance Copointed ((,) a) where copoint = snd instance Copointed ((,,) a b) where copoint (_,_,a) = a instance Copointed ((,,,) a b c) where copoint (_,_,_,a) = a instance Default m => Copointed ((->)m) where copoint f = f def instance Copointed m => Copointed (WrappedMonad m) where copoint = copoint . unwrapMonad #ifdef MIN_VERSION_comonad instance (Default m, Copointed w) => Copointed (TracedT m w) where copoint (TracedT w) = copoint w def instance Copointed w => Copointed (EnvT e w) where copoint = copoint . lowerEnvT instance Copointed w => Copointed (StoreT s w) where copoint (StoreT wf s) = copoint wf s #endif #ifdef MIN_VERSION_comonad #if !(MIN_VERSION_comonad(4,3,0)) instance (Copointed p, Copointed q) => Copointed (Coproduct p q) where copoint = coproduct copoint copoint #endif #endif #ifdef MIN_VERSION_containers instance Copointed Tree where copoint = rootLabel #endif #ifdef MIN_VERSION_tagged instance Copointed (Tagged a) where copoint = unTagged #endif #if defined(MIN_VERSION_transformers) || (MIN_VERSION_base(4,8,0)) instance Copointed Identity where copoint = runIdentity #endif #if defined(MIN_VERSION_transformers) || (MIN_VERSION_base(4,9,0)) instance (Copointed p, Copointed q) => Copointed (Compose p q) where copoint = copoint . copoint . getCompose instance (Copointed f, Copointed g) => Copointed (F.Sum f g) where copoint (F.InL m) = copoint m copoint (F.InR m) = copoint m #endif #ifdef MIN_VERSION_transformers instance Copointed f => Copointed (Backwards f) where copoint = copoint . forwards instance Copointed f => Copointed (Applicative.Lift f) where copoint (Pure a) = a copoint (Other fa) = copoint fa instance Copointed f => Copointed (Reverse f) where copoint = copoint . getReverse instance Copointed m => Copointed (IdentityT m) where copoint = copoint . runIdentityT instance Copointed m => Copointed (Lazy.WriterT w m) where copoint = fst . copoint . Lazy.runWriterT instance Copointed m => Copointed (Strict.WriterT w m) where copoint = fst . copoint . Strict.runWriterT #endif instance Copointed Monoid.Dual where copoint = Monoid.getDual instance Copointed Monoid.Sum where copoint = Monoid.getSum instance Copointed Monoid.Product where copoint = Monoid.getProduct #if defined(MIN_VERSION_semigroups) || (MIN_VERSION_base(4,9,0)) instance Copointed NonEmpty where copoint ~(a :| _) = a instance Copointed Semigroup.First where copoint = Semigroup.getFirst instance Copointed Semigroup.Last where copoint = Semigroup.getLast instance Copointed Semigroup.Max where copoint = Semigroup.getMax instance Copointed Semigroup.Min where copoint = Semigroup.getMin instance Copointed WrappedMonoid where copoint = unwrapMonoid #endif #ifdef MIN_VERSION_semigroups #if MIN_VERSION_semigroups(0,16,2) #define HAVE_ARG 1 #endif #elif MIN_VERSION_base(4,9,0) #define HAVE_ARG 1 #endif #ifdef HAVE_ARG instance Copointed (Arg a) where copoint (Arg _ b) = b #endif #ifdef MIN_VERSION_semigroupoids instance Copointed f => Copointed (WrappedApplicative f) where copoint = copoint . unwrapApplicative instance Copointed f => Copointed (MaybeApply f) where copoint (MaybeApply (Left fa)) = copoint fa copoint (MaybeApply (Right a)) = a #endif instance Copointed Par1 where copoint = unPar1 instance Copointed f => Copointed (M1 i c f) where copoint = copoint . unM1 instance Copointed f => Copointed (Rec1 f) where copoint = copoint . unRec1 instance (Copointed f, Copointed g) => Copointed (f :+: g) where copoint (L1 a) = copoint a copoint (R1 a) = copoint a instance (Copointed f, Copointed g) => Copointed (f :.: g) where copoint = copoint . copoint . unComp1 pointed-5.0.4/src/Data/Pointed.hs0000644000000000000000000001745507346545000014765 0ustar0000000000000000{-# LANGUAGE CPP #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE TypeOperators #-} {-# OPTIONS_GHC -fno-warn-deprecations #-} #ifndef MIN_VERSION_base #define MIN_VERSION_base(x,y,z) 0 #endif module Data.Pointed where import Control.Arrow import Control.Applicative import qualified Data.Monoid as Monoid import Data.Default.Class import GHC.Generics #ifdef MIN_VERSION_comonad import Control.Comonad #endif #ifdef MIN_VERSION_containers import Data.Map (Map) import qualified Data.Map as Map import Data.Set (Set) import qualified Data.Set as Set import Data.Sequence (Seq, ViewL(..), ViewR(..)) import qualified Data.Sequence as Seq import Data.Tree (Tree(..)) #endif #ifdef MIN_VERSION_kan_extensions import Data.Functor.Day.Curried #endif #if defined(MIN_VERSION_semigroups) || (MIN_VERSION_base(4,9,0)) import Data.Semigroup as Semigroup import Data.List.NonEmpty (NonEmpty(..)) #endif #ifdef MIN_VERSION_semigroupoids import Data.Functor.Bind import Data.Semigroupoid.Static #endif #ifdef MIN_VERSION_stm import Control.Concurrent.STM #endif #if defined(MIN_VERSION_transformers) || (MIN_VERSION_base(4,8,0)) import Data.Functor.Identity #endif #if defined(MIN_VERSION_transformers) || (MIN_VERSION_base(4,9,0)) import Data.Functor.Compose import qualified Data.Functor.Product as Functor #endif #ifdef MIN_VERSION_transformers import Data.Functor.Constant import Data.Functor.Reverse import qualified Control.Monad.Trans.RWS.Lazy as Lazy import qualified Control.Monad.Trans.RWS.Strict as Strict import qualified Control.Monad.Trans.Writer.Lazy as Lazy import qualified Control.Monad.Trans.Writer.Strict as Strict import qualified Control.Monad.Trans.State.Lazy as Lazy import qualified Control.Monad.Trans.State.Strict as Strict import Control.Applicative.Backwards import Control.Applicative.Lift import Control.Monad.Trans.Cont import Control.Monad.Trans.Except import Control.Monad.Trans.Maybe import Control.Monad.Trans.Identity import Control.Monad.Trans.Reader # if !(MIN_VERSION_transformers(0,6,0)) import Control.Monad.Trans.Error import Control.Monad.Trans.List # endif #endif #if defined(MIN_VERSION_tagged) || (MIN_VERSION_base(4,7,0)) import Data.Proxy #endif #ifdef MIN_VERSION_tagged import Data.Tagged #endif #if defined(MIN_VERSION_unordered_containers) import Data.Hashable import Data.HashMap.Lazy (HashMap) import qualified Data.HashMap.Lazy as HashMap #endif class Pointed p where point :: a -> p a instance Pointed [] where point a = [a] instance Pointed Maybe where point = Just instance Pointed (Either a) where point = Right instance Pointed IO where point = return instance Pointed ZipList where point = pure #if MIN_VERSION_base(4,8,0) || defined(MIN_VERSION_transformers) instance Pointed Identity where point = Identity #endif instance Pointed ((->)e) where point = const instance Default e => Pointed ((,)e) where point = (,) def instance Default m => Pointed (Const m) where point _ = Const def instance Monad m => Pointed (WrappedMonad m) where point = WrapMonad . return instance Arrow a => Pointed (WrappedArrow a b) where point = pure instance Pointed Monoid.Dual where point = Monoid.Dual instance Pointed Monoid.Endo where point = Monoid.Endo . const instance Pointed Monoid.Sum where point = Monoid.Sum instance Pointed Monoid.Product where point = Monoid.Product instance Pointed Monoid.First where point = Monoid.First . Just instance Pointed Monoid.Last where point = Monoid.Last . Just #ifdef MIN_VERSION_comonad instance Pointed (Cokleisli w a) where point = Cokleisli . const #endif #ifdef MIN_VERSION_containers instance Pointed Tree where point a = Node a [] instance Default k => Pointed (Map k) where point = Map.singleton def instance Pointed Seq where point = Seq.singleton instance Pointed ViewL where point a = a :< Seq.empty instance Pointed ViewR where point a = Seq.empty :> a instance Pointed Set where point = Set.singleton #endif #ifdef MIN_VERSION_kan_extensions instance (Functor g, g ~ h) => Pointed (Curried g h) where point a = Curried (fmap ($ a)) {-# INLINE point #-} #endif #ifdef MIN_VERSION_semigroupoids instance Pointed m => Pointed (Static m a) where point = Static . point . const instance Pointed f => Pointed (WrappedApplicative f) where point = WrapApplicative . point instance Pointed (MaybeApply f) where point = MaybeApply . Right #endif #if defined(MIN_VERSION_semigroups) || (MIN_VERSION_base(4,9,0)) instance Pointed NonEmpty where point a = a :| [] instance Pointed Semigroup.First where point = Semigroup.First instance Pointed Semigroup.Last where point = Semigroup.Last instance Pointed Semigroup.Max where point = Semigroup.Max instance Pointed Semigroup.Min where point = Semigroup.Min # if !(MIN_VERSION_base(4,16,0)) instance Pointed Option where point = Option . Just # endif instance Pointed WrappedMonoid where point = WrapMonoid #endif #ifdef MIN_VERSION_semigroups #if MIN_VERSION_semigroups(0,16,2) #define HAVE_ARG 1 #endif #elif MIN_VERSION_base(4,9,0) #define HAVE_ARG 1 #endif #ifdef HAVE_ARG instance Default a => Pointed (Arg a) where point = Arg def #endif #ifdef MIN_VERSION_stm instance Pointed STM where point = return #endif #if defined(MIN_VERSION_tagged) || (MIN_VERSION_base(4,7,0)) instance Pointed Proxy where point _ = Proxy #endif #ifdef MIN_VERSION_tagged instance Pointed (Tagged a) where point = Tagged #endif #if defined(MIN_VERSION_transformers) || (MIN_VERSION_base(4,9,0)) instance (Pointed p, Pointed q) => Pointed (Compose p q) where point = Compose . point . point #endif #if defined(MIN_VERSION_transformers) || (MIN_VERSION_base(4,9,0)) instance (Pointed p, Pointed q) => Pointed (Functor.Product p q) where point a = Functor.Pair (point a) (point a) #endif #ifdef MIN_VERSION_transformers instance Pointed (ContT r m) where point a = ContT ($ a) instance Pointed m => Pointed (ExceptT e m) where point = ExceptT . point . Right instance Pointed m => Pointed (IdentityT m) where point = IdentityT . point instance Pointed m => Pointed (MaybeT m) where point = MaybeT . point . point instance Pointed m => Pointed (ReaderT r m) where point = ReaderT . const . point instance Default m => Pointed (Constant m) where point _ = Constant def instance Pointed m => Pointed (Lazy.StateT s m) where point a = Lazy.StateT $ \s -> point (a, s) instance Pointed m => Pointed (Strict.StateT s m) where point a = Strict.StateT $ \s -> point (a, s) instance (Default w, Pointed m) => Pointed (Lazy.RWST r w s m) where point a = Lazy.RWST $ \_ s -> point (a, s, def) instance (Default w, Pointed m) => Pointed (Strict.RWST r w s m) where point a = Strict.RWST $ \_ s -> point (a, s, def) instance (Default w, Pointed m) => Pointed (Lazy.WriterT w m) where point a = Lazy.WriterT $ point (a, def) instance (Default w, Pointed m) => Pointed (Strict.WriterT w m) where point a = Strict.WriterT $ point (a, def) instance Pointed f => Pointed (Reverse f) where point = Reverse . point instance Pointed f => Pointed (Backwards f) where point = Backwards . point instance Pointed (Lift f) where point = Pure # if !(MIN_VERSION_transformers(0,6,0)) instance Pointed m => Pointed (ErrorT e m) where point = ErrorT . point . Right instance Pointed m => Pointed (ListT m) where point = ListT . point . point # endif #endif #if defined(MIN_VERSION_unordered_containers) instance (Default k, Hashable k) => Pointed (HashMap k) where point = HashMap.singleton def #endif instance Pointed U1 where point _ = U1 instance Pointed Par1 where point = Par1 instance Pointed f => Pointed (Rec1 f) where point = Rec1 . point instance Pointed f => Pointed (M1 i c f) where point = M1 . point instance (Pointed f, Pointed g) => Pointed (f :*: g) where point a = point a :*: point a instance (Pointed f, Pointed g) => Pointed (f :.: g) where point = Comp1 . point . point