packages feed

extensible 0.4.9 → 0.4.10

raw patch · 6 files changed

+36/−9 lines, 6 filesdep +exceptionsdep +resourcetPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependencies added: exceptions, resourcet

API changes (from Hackage documentation)

- Data.Extensible.Dictionary: instance Data.Text.Prettyprint.Doc.Internal.Pretty a => Data.Text.Prettyprint.Doc.Internal.Pretty (Data.Functor.Identity.Identity a)
- Data.Extensible.Dictionary: instance Language.Haskell.TH.Syntax.Lift a => Language.Haskell.TH.Syntax.Lift (Data.Functor.Identity.Identity a)
- Data.Extensible.Dictionary: instance forall k (h :: k -> *) (xs :: [k]). (Data.Extensible.Dictionary.WrapForall Data.Semigroup.Semigroup h xs, Data.Extensible.Dictionary.WrapForall GHC.Base.Monoid h xs) => GHC.Base.Monoid (h Data.Extensible.Struct.:* xs)
- Data.Extensible.Dictionary: instance forall k (h :: k -> *) (xs :: [k]). Data.Extensible.Dictionary.WrapForall Data.Semigroup.Semigroup h xs => Data.Semigroup.Semigroup (h Data.Extensible.Struct.:* xs)
- Data.Extensible.Dictionary: instance forall k a (b :: k). Data.Text.Prettyprint.Doc.Internal.Pretty a => Data.Text.Prettyprint.Doc.Internal.Pretty (Data.Functor.Const.Const a b)
- Data.Extensible.Dictionary: instance forall k a (b :: k). Language.Haskell.TH.Syntax.Lift a => Language.Haskell.TH.Syntax.Lift (Data.Functor.Const.Const a b)
- Data.Extensible.Field: instance forall k v (h :: v -> *) (kv :: Data.Extensible.Internal.Assoc k v). Data.Semigroup.Semigroup (h (Data.Extensible.Field.AssocValue kv)) => Data.Semigroup.Semigroup (Data.Extensible.Field.Field h kv)
- Data.Extensible.Internal: instance forall k (xs :: [k]) (x :: k). Data.Semigroup.Semigroup (Data.Extensible.Internal.Membership xs x)
- Data.Extensible.Label: instance k ~ l => GHC.OverloadedLabels.IsLabel k (Data.Proxy.Proxy l)
- Data.Extensible.Match: instance forall k (h :: k -> *) r (x :: k). Data.Semigroup.Semigroup r => Data.Semigroup.Semigroup (Data.Extensible.Match.Match h r x)
- Data.Extensible.Nullable: instance forall k (h :: k -> *) (x :: k). Data.Semigroup.Semigroup (h x) => Data.Semigroup.Semigroup (Data.Extensible.Nullable.Nullable h x)
- Data.Extensible.Nullable: instance forall k (h :: k -> *) (x :: k). Data.Semigroup.Semigroup (h x) => GHC.Base.Monoid (Data.Extensible.Nullable.Nullable h x)
- Data.Extensible.Tangle: instance forall k (m :: * -> *) a (h :: k -> *) (xs :: [k]). (GHC.Base.Monad m, Data.Semigroup.Semigroup a) => Data.Semigroup.Semigroup (Data.Extensible.Tangle.TangleT h xs m a)
- Data.Extensible.Wrapper: instance (Data.Foldable.Foldable g, Data.Foldable.Foldable f) => Data.Foldable.Foldable (Data.Extensible.Wrapper.Prod f g)
- Data.Extensible.Wrapper: instance (Data.Traversable.Traversable g, Data.Traversable.Traversable f) => Data.Traversable.Traversable (Data.Extensible.Wrapper.Prod f g)
- Data.Extensible.Wrapper: instance (GHC.Base.Functor g, GHC.Base.Functor f) => GHC.Base.Functor (Data.Extensible.Wrapper.Prod f g)
- Data.Extensible.Wrapper: instance forall a k (x :: k). Data.Semigroup.Semigroup a => Data.Semigroup.Semigroup (Data.Extensible.Wrapper.Const' a x)
- Data.Extensible.Wrapper: instance forall j (f :: j -> *) i (g :: i -> j) (a :: i). Data.Semigroup.Semigroup (f (g a)) => Data.Semigroup.Semigroup (Data.Extensible.Wrapper.Comp f g a)
- Data.Extensible.Wrapper: instance forall k (f :: k -> *) (a :: k) (g :: k -> *). (Data.Semigroup.Semigroup (f a), Data.Semigroup.Semigroup (g a)) => Data.Semigroup.Semigroup (Data.Extensible.Wrapper.Prod f g a)
- Data.Extensible.Wrapper: instance forall k (f :: k -> *) (g :: k -> *) (a :: k). (GHC.Classes.Eq (g a), GHC.Classes.Eq (f a)) => GHC.Classes.Eq (Data.Extensible.Wrapper.Prod f g a)
- Data.Extensible.Wrapper: instance forall k (f :: k -> *) (g :: k -> *) (a :: k). (GHC.Classes.Ord (g a), GHC.Classes.Ord (f a)) => GHC.Classes.Ord (Data.Extensible.Wrapper.Prod f g a)
- Data.Extensible.Wrapper: instance forall k (f :: k -> *) (g :: k -> *) (a :: k). (GHC.Show.Show (g a), GHC.Show.Show (f a)) => GHC.Show.Show (Data.Extensible.Wrapper.Prod f g a)
+ Data.Extensible: Proxy :: Proxy
+ Data.Extensible: class KnownSymbol (n :: Symbol)
+ Data.Extensible: data Proxy (t :: k) :: forall k. () => k -> *
+ Data.Extensible.Dictionary: instance forall k (h :: k -> *) (xs :: [k]). (Data.Extensible.Dictionary.WrapForall GHC.Base.Semigroup h xs, Data.Extensible.Dictionary.WrapForall GHC.Base.Monoid h xs) => GHC.Base.Monoid (h Data.Extensible.Struct.:* xs)
+ Data.Extensible.Dictionary: instance forall k (h :: k -> *) (xs :: [k]). Data.Extensible.Dictionary.WrapForall GHC.Base.Semigroup h xs => GHC.Base.Semigroup (h Data.Extensible.Struct.:* xs)
+ Data.Extensible.Effect.Default: instance (Control.Monad.Catch.MonadCatch m, Data.Extensible.Internal.Associate "IO" m xs) => Control.Monad.Catch.MonadCatch (Data.Extensible.Effect.Eff xs)
+ Data.Extensible.Effect.Default: instance (Control.Monad.Catch.MonadThrow m, Data.Extensible.Internal.Associate "IO" m xs) => Control.Monad.Catch.MonadThrow (Data.Extensible.Effect.Eff xs)
+ Data.Extensible.Effect.Default: instance (Control.Monad.Trans.Resource.Internal.MonadResource m, Data.Extensible.Internal.Associate "IO" m xs) => Control.Monad.Trans.Resource.Internal.MonadResource (Data.Extensible.Effect.Eff xs)
+ Data.Extensible.Field: instance forall k v (h :: v -> *) (kv :: Data.Extensible.Internal.Assoc k v). GHC.Base.Semigroup (h (Data.Extensible.Field.AssocValue kv)) => GHC.Base.Semigroup (Data.Extensible.Field.Field h kv)
+ Data.Extensible.Internal: instance forall k (xs :: [k]) (x :: k). GHC.Base.Semigroup (Data.Extensible.Internal.Membership xs x)
+ Data.Extensible.Label: instance (k ~ l) => GHC.OverloadedLabels.IsLabel k (Data.Proxy.Proxy l)
+ Data.Extensible.Match: instance forall k (h :: k -> *) r (x :: k). GHC.Base.Semigroup r => GHC.Base.Semigroup (Data.Extensible.Match.Match h r x)
+ Data.Extensible.Nullable: instance forall k (h :: k -> *) (x :: k). GHC.Base.Semigroup (h x) => GHC.Base.Monoid (Data.Extensible.Nullable.Nullable h x)
+ Data.Extensible.Nullable: instance forall k (h :: k -> *) (x :: k). GHC.Base.Semigroup (h x) => GHC.Base.Semigroup (Data.Extensible.Nullable.Nullable h x)
+ Data.Extensible.Tangle: instance forall k (m :: * -> *) a (h :: k -> *) (xs :: [k]). (GHC.Base.Monad m, GHC.Base.Semigroup a) => GHC.Base.Semigroup (Data.Extensible.Tangle.TangleT h xs m a)
+ Data.Extensible.Wrapper: instance (Data.Foldable.Foldable f, Data.Foldable.Foldable g) => Data.Foldable.Foldable (Data.Extensible.Wrapper.Prod f g)
+ Data.Extensible.Wrapper: instance (Data.Traversable.Traversable f, Data.Traversable.Traversable g) => Data.Traversable.Traversable (Data.Extensible.Wrapper.Prod f g)
+ Data.Extensible.Wrapper: instance (GHC.Base.Functor f, GHC.Base.Functor g) => GHC.Base.Functor (Data.Extensible.Wrapper.Prod f g)
+ Data.Extensible.Wrapper: instance forall a k (x :: k). GHC.Base.Semigroup a => GHC.Base.Semigroup (Data.Extensible.Wrapper.Const' a x)
+ Data.Extensible.Wrapper: instance forall j (f :: j -> *) i (g :: i -> j) (a :: i). GHC.Base.Semigroup (f (g a)) => GHC.Base.Semigroup (Data.Extensible.Wrapper.Comp f g a)
+ Data.Extensible.Wrapper: instance forall k (f :: k -> *) (a :: k) (g :: k -> *). (GHC.Base.Semigroup (f a), GHC.Base.Semigroup (g a)) => GHC.Base.Semigroup (Data.Extensible.Wrapper.Prod f g a)
+ Data.Extensible.Wrapper: instance forall k (f :: k -> *) (g :: k -> *) (a :: k). (GHC.Classes.Eq (f a), GHC.Classes.Eq (g a)) => GHC.Classes.Eq (Data.Extensible.Wrapper.Prod f g a)
+ Data.Extensible.Wrapper: instance forall k (f :: k -> *) (g :: k -> *) (a :: k). (GHC.Classes.Ord (f a), GHC.Classes.Ord (g a)) => GHC.Classes.Ord (Data.Extensible.Wrapper.Prod f g a)
+ Data.Extensible.Wrapper: instance forall k (f :: k -> *) (g :: k -> *) (a :: k). (GHC.Show.Show (f a), GHC.Show.Show (g a)) => GHC.Show.Show (Data.Extensible.Wrapper.Prod f g a)
- Data.Extensible.Effect: Interpreter :: (forall a. g a -> f a) -> Interpreter f g
+ Data.Extensible.Effect: Interpreter :: forall a. g a -> f a -> Interpreter f g
- Data.Extensible.Effect: data Identity a :: * -> *
+ Data.Extensible.Effect: data Identity a
- Data.Extensible.Effect: data ContT k (r :: k) (m :: k -> *) a :: forall k. () => k -> (k -> *) -> * -> *
+ Data.Extensible.Effect: data ContT (r :: k) (m :: k -> *) a :: forall k. () => k -> k -> * -> * -> *
- Data.Extensible.Effect: evalStateEff :: forall k s xs a. Eff ((k >: State s) : xs) a -> s -> Eff xs a
+ Data.Extensible.Effect: evalStateEff :: forall k s xs a. Eff (k >: State s : xs) a -> s -> Eff xs a
- Data.Extensible.Effect: execStateEff :: forall k s xs a. Eff ((k >: State s) : xs) a -> s -> Eff xs s
+ Data.Extensible.Effect: execStateEff :: forall k s xs a. Eff (k >: State s : xs) a -> s -> Eff xs s
- Data.Extensible.Effect: execWriterEff :: forall k w xs a. Monoid w => Eff ((k >: WriterEff w) : xs) a -> Eff xs w
+ Data.Extensible.Effect: execWriterEff :: forall k w xs a. Monoid w => Eff (k >: WriterEff w : xs) a -> Eff xs w
- Data.Extensible.Effect: peelAction :: forall k ps q xs a r. (forall x. Instruction xs x -> (x -> r) -> r) -> (a -> r) -> Function ps ((q -> r) -> r) -> Eff ((k >: Action ps q) : xs) a -> r
+ Data.Extensible.Effect: peelAction :: forall k ps q xs a r. (forall x. Instruction xs x -> (x -> r) -> r) -> (a -> r) -> Function ps ((q -> r) -> r) -> Eff (k >: Action ps q : xs) a -> r
- Data.Extensible.Effect: peelAction0 :: forall k ps q xs a. Function ps (Eff xs q) -> Eff ((k >: Action ps q) : xs) a -> Eff xs a
+ Data.Extensible.Effect: peelAction0 :: forall k ps q xs a. Function ps (Eff xs q) -> Eff (k >: Action ps q : xs) a -> Eff xs a
- Data.Extensible.Effect: peelEff :: forall k t xs a r. Rebinder xs r -> (a -> r) -> (forall x. t x -> (x -> r) -> r) -> Eff ((k >: t) : xs) a -> r
+ Data.Extensible.Effect: peelEff :: forall k t xs a r. Rebinder xs r -> (a -> r) -> (forall x. t x -> (x -> r) -> r) -> Eff (k >: t : xs) a -> r
- Data.Extensible.Effect: peelEff0 :: forall k t xs a r. (a -> Eff xs r) -> (forall x. t x -> (x -> Eff xs r) -> Eff xs r) -> Eff ((k >: t) : xs) a -> Eff xs r
+ Data.Extensible.Effect: peelEff0 :: forall k t xs a r. (a -> Eff xs r) -> (forall x. t x -> (x -> Eff xs r) -> Eff xs r) -> Eff (k >: t : xs) a -> Eff xs r
- Data.Extensible.Effect: peelEff1 :: forall k t xs a b r. (a -> b -> Eff xs r) -> (forall x. t x -> (x -> b -> Eff xs r) -> b -> Eff xs r) -> Eff ((k >: t) : xs) a -> b -> Eff xs r
+ Data.Extensible.Effect: peelEff1 :: forall k t xs a b r. (a -> b -> Eff xs r) -> (forall x. t x -> (x -> b -> Eff xs r) -> b -> Eff xs r) -> Eff (k >: t : xs) a -> b -> Eff xs r
- Data.Extensible.Effect: runContEff :: forall k r xs a. Eff ((k >: ContT r (Eff xs)) : xs) a -> (a -> Eff xs r) -> Eff xs r
+ Data.Extensible.Effect: runContEff :: forall k r xs a. Eff (k >: ContT r (Eff xs) : xs) a -> (a -> Eff xs r) -> Eff xs r
- Data.Extensible.Effect: runEitherEff :: forall k e xs a. Eff ((k >: EitherEff e) : xs) a -> Eff xs (Either e a)
+ Data.Extensible.Effect: runEitherEff :: forall k e xs a. Eff (k >: EitherEff e : xs) a -> Eff xs (Either e a)
- Data.Extensible.Effect: runIterEff :: Eff ((k >: Identity) : xs) a -> Eff xs (Either a (Eff ((k >: Identity) : xs) a))
+ Data.Extensible.Effect: runIterEff :: Eff (k >: Identity : xs) a -> Eff xs (Either a (Eff (k >: Identity : xs) a))
- Data.Extensible.Effect: runMaybeEff :: forall k xs a. Eff ((k >: MaybeEff) : xs) a -> Eff xs (Maybe a)
+ Data.Extensible.Effect: runMaybeEff :: forall k xs a. Eff (k >: MaybeEff : xs) a -> Eff xs (Maybe a)
- Data.Extensible.Effect: runReaderEff :: forall k r xs a. Eff ((k >: ReaderEff r) : xs) a -> r -> Eff xs a
+ Data.Extensible.Effect: runReaderEff :: forall k r xs a. Eff (k >: ReaderEff r : xs) a -> r -> Eff xs a
- Data.Extensible.Effect: runStateEff :: forall k s xs a. Eff ((k >: State s) : xs) a -> s -> Eff xs (a, s)
+ Data.Extensible.Effect: runStateEff :: forall k s xs a. Eff (k >: State s : xs) a -> s -> Eff xs (a, s)
- Data.Extensible.Effect: runWriterEff :: forall k w xs a. Monoid w => Eff ((k >: WriterEff w) : xs) a -> Eff xs (a, w)
+ Data.Extensible.Effect: runWriterEff :: forall k w xs a. Monoid w => Eff (k >: WriterEff w : xs) a -> Eff xs (a, w)
- Data.Extensible.Match: Match :: (h x -> r) -> Match h r x
+ Data.Extensible.Match: Match :: h x -> r -> Match h r x

Files

extensible.cabal view
@@ -1,5 +1,5 @@ name:                extensible-version:             0.4.9+version:             0.4.10 synopsis:            Extensible, efficient, optics-friendly data types and effects homepage:            https://github.com/fumieval/extensible bug-reports:         http://github.com/fumieval/extensible/issues@@ -74,6 +74,7 @@     , comonad     , constraints     , deepseq+    , exceptions     , ghc-prim     , hashable     , monad-skeleton >= 0.1.2@@ -81,6 +82,7 @@     , prettyprinter     , primitive     , profunctors+    , resourcet     , QuickCheck     , semigroups     , StateVar
src/Data/Extensible.hs view
@@ -43,6 +43,8 @@   , module Data.Extensible.Tangle   , module Data.Extensible.TH   , module Data.Extensible.Wrapper+  , Proxy(..)+  , KnownSymbol   ) where  import Data.Extensible.Class@@ -60,3 +62,5 @@ import Data.Extensible.Tangle import Data.Extensible.TH import Data.Extensible.Wrapper+import Data.Proxy+import GHC.TypeLits
src/Data/Extensible/Effect/Default.hs view
@@ -32,12 +32,29 @@ import Data.Extensible.Effect import Data.Extensible.Internal import Control.Monad.Except+import Control.Monad.Catch import Control.Monad.Reader.Class+import Control.Monad.Skeleton import Control.Monad.State.Strict+import Control.Monad.Trans.Resource import Control.Monad.Writer.Class  instance (MonadIO m, Associate "IO" m xs) => MonadIO (Eff xs) where   liftIO = liftEff (Proxy :: Proxy "IO") . liftIO++instance (MonadResource m, Associate "IO" m xs) => MonadResource (Eff xs) where+  liftResourceT = liftEff (Proxy :: Proxy "IO") . liftResourceT++instance (MonadThrow m, Associate "IO" m xs) => MonadThrow (Eff xs) where+  throwM = liftEff (Proxy :: Proxy "IO") . throwM++instance (MonadCatch m, Associate "IO" m xs) => MonadCatch (Eff xs) where+  catch m0 h = go m0 where+    go m = case debone m of+      Return a -> return a+      Instruction i t :>>= k -> case compareMembership (association :: Membership xs ("IO" ':> m)) i of+        Left _ -> boned $ Instruction i t :>>= go . k+        Right Refl -> boned $ Instruction i (try t) :>>= go . either h k   pReader :: Proxy "Reader" pReader = Proxy
src/Data/Extensible/Field.hs view
@@ -324,8 +324,8 @@ -- -- @ -- foo :: 'Record' '["num" >: Int, "str" >: String]--- foo = #num @= 42---   <: #str @= "foo"+-- foo = #num \@= 42+--   <: #str \@= "foo" --   <: nil -- @ (@=) :: Wrapper h => FieldName k -> Repr h v -> Field h (k ':> v)@@ -334,11 +334,12 @@ infix 1 @=  -- | Lifted ('@=')+-- -- @ -- foo :: IO ('Record' '["num" >: Int, "str" >: String]) -- foo = hsequence---   $ #num <@=> readLn---   <: #str <@=> getLine+--   $ #num \<\@=\> readLn+--   <: #str \<\@=\> getLine --   <: nil -- @ (<@=>) :: (Functor f, Wrapper h) => FieldName k -> f (Repr h v) -> Comp f (Field h) (k ':> v)@@ -351,7 +352,7 @@ (@:>) _ = Field infix 1 @:> --- | Kind-monomorphic, unwrapped version of @('@=')@+-- | Kind-monomorphic, unwrapped version of '@=' (@==) :: FieldName (k :: Symbol) -> v -> Field Identity (k ':> v) (@==) = (@=) {-# INLINE (@==) #-}
src/Data/Extensible/Internal.hs view
@@ -2,8 +2,11 @@ {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE LambdaCase #-} {-# LANGUAGE OverloadedStrings #-}-{-# LANGUAGE MultiParamTypeClasses, UndecidableInstances, FunctionalDependencies #-}-{-# LANGUAGE ScopedTypeVariables, BangPatterns #-}+{-# LANGUAGE MultiParamTypeClasses #-}+{-# LANGUAGE UndecidableInstances #-}+{-# LANGUAGE FunctionalDependencies #-}+{-# LANGUAGE BangPatterns #-}+{-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE StandaloneDeriving #-} {-# LANGUAGE TemplateHaskell #-} -----------------------------------------------------------------------------
src/Data/Extensible/Product.hs view
@@ -89,7 +89,7 @@ {-# NOINLINE nil #-} {-# RULES "toHList/nil" toHList nil = HList.HNil #-} --- | Convert 'L.HList' into a product.+-- | Convert 'HList.HList' into a product. fromHList :: HList.HList h xs -> h :* xs fromHList xs = hfrozen (newFromHList xs) {-# INLINE fromHList #-}