ConstraintKinds 0.0.2.0 → 1.1.0.0

raw patch · 6 files changed

+148/−23 lines, 6 filesPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

Files

• ConstraintKinds.cabal +3/−2
• src/Control/ConstraintKinds.hs +9/−3
• src/Control/ConstraintKinds/Applicative.hs +8/−17
• src/Control/ConstraintKinds/Functor.hs +5/−1
• src/Control/ConstraintKinds/Monad.hs +80/−0
• src/Control/ConstraintKinds/Pointed.hs +43/−0

@@ -1,5 +1,5 @@ Name:                ConstraintKinds-Version:             0.0.2.0+Version:             1.1.0.0 Synopsis:            Repackages standard type classes with the ConstraintKinds extension Description:         This module provides more flexible versions of common type classes that use the ConstraintKinds extension.  This allows us to make types that require constraints instances of the popular classes.  For example, we reimplement Functor and Foldable using the ContraintKinds style.  This allows us to manipulate lists and unboxed vectors using the same functions.                      .@@ -30,6 +30,7 @@         Control.ConstraintKinds.Filterable         Control.ConstraintKinds.Foldable         Control.ConstraintKinds.Functor-        -- Control.ConstraintKinds.Monad+        Control.ConstraintKinds.Monad         Control.ConstraintKinds.Partitionable+        Control.ConstraintKinds.Pointed         Control.ConstraintKinds.Traversable

@@ -1,10 +1,14 @@ module Control.ConstraintKinds-    ( module Control.ConstraintKinds.Applicative+    ( +    -- * Modules++      module Control.ConstraintKinds.Applicative     , module Control.ConstraintKinds.Filterable     , module Control.ConstraintKinds.Foldable     , module Control.ConstraintKinds.Functor+    , module Control.ConstraintKinds.Monad     , module Control.ConstraintKinds.Partitionable---     , module Control.ConstraintKinds.Monad+    , module Control.ConstraintKinds.Pointed     , module Control.ConstraintKinds.Traversable     )     where@@ -13,6 +17,8 @@ import Control.ConstraintKinds.Filterable import Control.ConstraintKinds.Foldable import Control.ConstraintKinds.Functor--- import Control.ConstraintKinds.Monad+import Control.ConstraintKinds.Monad import Control.ConstraintKinds.Partitionable+import Control.ConstraintKinds.Pointed import Control.ConstraintKinds.Traversable+

@@ -1,5 +1,6 @@ {-# LANGUAGE ConstraintKinds #-} {-# LANGUAGE TypeFamilies #-}+{-# LANGUAGE UndecidableInstances #-}  module Control.ConstraintKinds.Applicative     where@@ -15,16 +16,15 @@ import qualified Data.Vector.Generic as G  import Control.ConstraintKinds.Functor+import Control.ConstraintKinds.Pointed import Prelude hiding (Functor, fmap, foldl, foldr)  ------------------------------------------------------------------------------- -- class Applicative -class Functor f => Applicative f where+class Pointed f => Applicative f where     type ApplicativeConstraint f x :: Constraint-    type ApplicativeConstraint f x = ()--    pure :: (ApplicativeConstraint f a) => a -> f a+    type ApplicativeConstraint f x = PointedConstraint f x      (<*>) :: (ApplicativeConstraint f a, ApplicativeConstraint f b) => f (a -> b) -> f a -> f b @@ -37,7 +37,7 @@ -- | Lift a function to actions. -- This function may be used as a value for `fmap` in a `Functor` instance. -- liftA :: (ApplicativeConstraint f a, ApplicativeConstraint f (a -> b), ApplicativeConstraint f b, Applicative f) => (a -> b) -> f a -> f b-liftA f a = pure f <*> a+liftA f a = point f <*> a  -- | Lift a binary function to actions. -- liftA2 :: (FunctorConstraint f a, FunctorConstraint f (b -> c), Applicative f) => (a -> b -> c) -> f a -> f b -> f c@@ -51,21 +51,12 @@ -- Instances  instance Applicative [] where-    pure = M.return     (<*>) = M.ap      instance Applicative V.Vector where-    {-# INLINE pure #-}-    pure = V.singleton-     {-# INLINE (<*>) #-}     (<*>) = M.ap   -instance Applicative VU.Vector where-    type ApplicativeConstraint VU.Vector x = VU.Unbox x--    {-# INLINE pure #-}-    pure = VU.singleton--    {-# INLINE (<*>) #-}-    (<*>) = undefined -- M.ap+-- instance Applicative VU.Vector where+--     {-# INLINE (<*>) #-}+--     (<*>) = undefined -- M.ap

@@ -5,6 +5,7 @@     where  import GHC.Prim+import Text.ParserCombinators.ReadPrec  import qualified Data.Foldable as F import qualified Data.List as L@@ -31,9 +32,12 @@ -- Instances  instance Functor [] where-    type FunctorConstraint [] x = ()     {-# INLINE fmap #-}     fmap = P.map++instance Functor ReadPrec where+    {-# INLINE fmap #-}+    fmap = P.fmap  instance Functor V.Vector where     {-# INLINE fmap #-}

@@ -0,0 +1,80 @@+{-# LANGUAGE ConstraintKinds #-}+{-# LANGUAGE TypeFamilies #-}+{-# LANGUAGE UndecidableInstances #-}++module Control.ConstraintKinds.Monad+    where++import GHC.Prim+import qualified Control.Monad as Monad+import Prelude hiding (Functor, fmap, Monad, (>>=), (>>), return)+import qualified Prelude as Prelude+import Text.ParserCombinators.ReadPrec++import qualified Data.Foldable as F+import qualified Data.List as L+import qualified Data.Traversable as T+import qualified Data.Vector as V+import qualified Data.Vector.Unboxed as VU+import qualified Data.Vector.Generic as VG++import Control.ConstraintKinds.Functor+import Control.ConstraintKinds.Pointed+import Control.ConstraintKinds.Applicative++ifThenElse :: Bool -> a -> a -> a+ifThenElse True  x _ = x+ifThenElse False _ y = y++-------------------------------------------------------------------------------+-- class Monad++class (Functor m) => Monad m where++    fail :: String -> m a+    fail = error++    return :: +        ( FunctorConstraint m a+        ) => a -> m a++    join :: +        ( FunctorConstraint m a+        , FunctorConstraint m (m a)+        ) => m (m a) -> m a+    join m = m >>= id++    (>>=) :: +        ( FunctorConstraint m a+        , FunctorConstraint m b+        , FunctorConstraint m (m b)+        ) => m a -> (a -> m b) -> m b+    a >>= b = join $ fmap b a++    (>>) :: +        ( FunctorConstraint m a+        , FunctorConstraint m b+        , FunctorConstraint m (m b)+        ) => m a -> m b -> m b+    m >> k = m >>= \_ -> k+    +-------------------------------------------------------------------------------+-- instances++instance Control.ConstraintKinds.Monad.Monad [] where+    return = Monad.return+    (>>=)  = (Monad.>>=)+    (>>)   = (Monad.>>)++instance Monad ReadPrec where+    return = Monad.return+    (>>=)  = (Monad.>>=)+    (>>)   = (Monad.>>)++instance Monad V.Vector where+    return = Monad.return+    (>>=) = flip V.concatMap+  +instance Monad VU.Vector where+    return = VU.singleton+    (>>=) = flip VU.concatMap

@@ -0,0 +1,43 @@+{-# LANGUAGE ConstraintKinds #-}+{-# LANGUAGE TypeFamilies #-}+{-# LANGUAGE UndecidableInstances #-}++module Control.ConstraintKinds.Pointed+    where++import GHC.Prim++import qualified Data.Foldable as F+import qualified Data.List as L+import qualified Data.Traversable as T+import qualified Data.Vector as V+import qualified Data.Vector.Unboxed as VU+import qualified Data.Vector.Generic as G+import qualified Prelude as P++import Control.ConstraintKinds.Functor++-------------------------------------------------------------------------------+-- class Functor++class (Functor f) => Pointed f where+    type PointedConstraint f x :: Constraint+    type PointedConstraint f x = FunctorConstraint f x+    +    point :: (PointedConstraint f a) => a -> f a++-------------------------------------------------------------------------------+-- Instances++instance Pointed [] where+    {-# INLINE point #-}+    point x = [x]++instance Pointed V.Vector where+    {-# INLINE point #-}+    point = V.singleton++instance Pointed VU.Vector where+    type PointedConstraint VU.Vector x = VU.Unbox x+    {-# INLINE point #-}+    point = VU.singleton