contravariant-extras 0.3.5 → 0.3.5.1

raw patch · 8 files changed

+163/−88 lines, 8 filesdep +template-haskell-compat-v0208dep −base-preludedep −semigroupsdep −tuple-thdep ~basePVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependencies added: template-haskell-compat-v0208

Dependencies removed: base-prelude, semigroups, tuple-th

Dependency ranges changed: base

API changes (from Hackage documentation)

Files

• contravariant-extras.cabal +26/−49
• library/Contravariant/Extras.hs +10/−6
• library/Contravariant/Extras/Contrazip.hs +1/−1
• library/Contravariant/Extras/ContrazipLifting.hs +34/−0
• library/Contravariant/Extras/Eliminate.hs +0/−25
• library/Contravariant/Extras/Op/Contrazip.hs +1/−1
• library/Contravariant/Extras/Prelude.hs +80/−0
• library/Contravariant/Extras/TH.hs +11/−6

@@ -1,59 +1,36 @@-name:-  contravariant-extras-version:-  0.3.5-category:-  Control-synopsis:-  Extras for the "contravariant" package-homepage:-  https://github.com/nikita-volkov/contravariant-extras -bug-reports:-  https://github.com/nikita-volkov/contravariant-extras/issues -author:-  Nikita Volkov <nikita.y.volkov@mail.ru>-maintainer:-  Nikita Volkov <nikita.y.volkov@mail.ru>-copyright:-  (c) 2015, Nikita Volkov-license:-  MIT-license-file:-  LICENSE-build-type:-  Simple-cabal-version:-  >=1.10-+name: contravariant-extras+version: 0.3.5.1+category: Control+synopsis: Extras for the "contravariant" package+homepage: https://github.com/nikita-volkov/contravariant-extras+bug-reports: https://github.com/nikita-volkov/contravariant-extras/issues+author: Nikita Volkov <nikita.y.volkov@mail.ru>+maintainer: Nikita Volkov <nikita.y.volkov@mail.ru>+copyright: (c) 2015, Nikita Volkov+license: MIT+license-file: LICENSE+build-type: Simple+cabal-version: >=1.10  source-repository head-  type:-    git-  location:-    git://github.com/nikita-volkov/contravariant-extras.git-+  type: git+  location: git://github.com/nikita-volkov/contravariant-extras.git  library-  hs-source-dirs:-    library-  ghc-options:-  default-extensions:-    Arrows, BangPatterns, ConstraintKinds, DataKinds, DefaultSignatures, DeriveDataTypeable, DeriveFoldable, DeriveFunctor, DeriveGeneric, DeriveTraversable, EmptyDataDecls, FlexibleContexts, FlexibleInstances, FunctionalDependencies, GADTs, GeneralizedNewtypeDeriving, LambdaCase, LiberalTypeSynonyms, MagicHash, MultiParamTypeClasses, MultiWayIf, NoImplicitPrelude, NoMonomorphismRestriction, OverloadedStrings, PatternGuards, ParallelListComp, QuasiQuotes, RankNTypes, RecordWildCards, ScopedTypeVariables, StandaloneDeriving, TemplateHaskell, TupleSections, TypeFamilies, TypeOperators, UnboxedTuples-  default-language:-    Haskell2010-  other-modules:-    Contravariant.Extras.TH+  hs-source-dirs: library+  default-extensions: Arrows, BangPatterns, ConstraintKinds, DataKinds, DefaultSignatures, DeriveDataTypeable, DeriveFoldable, DeriveFunctor, DeriveGeneric, DeriveTraversable, EmptyDataDecls, FlexibleContexts, FlexibleInstances, FunctionalDependencies, GADTs, GeneralizedNewtypeDeriving, LambdaCase, LiberalTypeSynonyms, MagicHash, MultiParamTypeClasses, MultiWayIf, NoImplicitPrelude, NoMonomorphismRestriction, OverloadedStrings, PatternGuards, ParallelListComp, QuasiQuotes, RankNTypes, RecordWildCards, ScopedTypeVariables, StandaloneDeriving, TemplateHaskell, TupleSections, TypeFamilies, TypeOperators, UnboxedTuples+  default-language: Haskell2010   exposed-modules:     Contravariant.Extras     Contravariant.Extras.Contrazip-    Contravariant.Extras.Eliminate+    Contravariant.Extras.ContrazipLifting     Contravariant.Extras.Op     Contravariant.Extras.Op.Contrazip+  other-modules:+    Contravariant.Extras.TH+    Contravariant.Extras.Prelude   build-depends:-    base >= 4 && < 5,-    tuple-th >= 0.2.5 && < 0.3,-    template-haskell >= 2.8 && < 3,-    contravariant >= 1.3 && < 2,-    base-prelude >= 0.1.19 && < 2,-    semigroups >= 0.8.4 && < 1-+    base >=4.10 && <5,+    contravariant >=1.3 && <2,+    template-haskell >=2.8 && <3,+    template-haskell-compat-v0208 >=0.1.2 && <2

@@ -1,18 +1,22 @@ module Contravariant.Extras (-  -- |-  -- A berserk collection of @contrazip@ functions with arities of up to 42.+  {-|+  @contrazip@ functions of multiple arities.+  -}   module Contravariant.Extras.Contrazip,-  module Contravariant.Extras.Eliminate,+  {-|+  @contrazipLifting@ functions of multiple arities.+  -}+  module Contravariant.Extras.ContrazipLifting,   (>*<),   contramany,   Supplied(..), ) where -import BasePrelude hiding ((<>))+import Contravariant.Extras.Prelude hiding ((<>)) import Contravariant.Extras.Contrazip-import Contravariant.Extras.Eliminate+import Contravariant.Extras.ContrazipLifting import Data.Functor.Contravariant.Divisible import Data.Semigroup (Semigroup ((<>))) @@ -46,7 +50,7 @@ -- A combination of a divisible functor with some input for it. -- Allows to use the 'Monoid' API for composition. data Supplied divisible =-  forall input. Supplied !(divisible input) !input+  forall input. Supplied (divisible input) input  instance Divisible divisible => Semigroup (Supplied divisible) where   Supplied divisible1 input1 <> Supplied divisible2 input2 =

@@ -12,7 +12,7 @@ --  module Contravariant.Extras.Contrazip where -import BasePrelude+import Contravariant.Extras.Prelude import qualified Contravariant.Extras.TH as TH  

@@ -0,0 +1,34 @@+module Contravariant.Extras.ContrazipLifting where++import Contravariant.Extras.Prelude+import Contravariant.Extras.Contrazip+import Data.Functor.Contravariant.Divisible+import qualified Contravariant.Extras.TH as TH+++contrazipLifting2 :: Divisible f => (forall x. g x -> f x) -> g a1 -> g a2 -> f (a1, a2)+contrazipLifting2 fn a b = contrazip2 (fn a) (fn b)++contrazipLifting3 :: Divisible f => (forall x. g x -> f x) -> g a1 -> g a2 -> g a3 -> f (a1, a2, a3)+contrazipLifting3 fn a b c = contrazip3 (fn a) (fn b) (fn c)++contrazipLifting4 :: Divisible f => (forall x. g x -> f x) -> g a1 -> g a2 -> g a3 -> g a4 -> f (a1, a2, a3, a4)+contrazipLifting4 fn a b c d = contrazip4 (fn a) (fn b) (fn c) (fn d)++contrazipLifting5 :: Divisible f => (forall x. g x -> f x) -> g a1 -> g a2 -> g a3 -> g a4 -> g a5 -> f (a1, a2, a3, a4, a5)+contrazipLifting5 fn a b c d e = contrazip5 (fn a) (fn b) (fn c) (fn d) (fn e)++contrazipLifting6 :: Divisible f => (forall x. g x -> f x) -> g a1 -> g a2 -> g a3 -> g a4 -> g a5 -> g a6 -> f (a1, a2, a3, a4, a5, a6)+contrazipLifting6 fn a b c d e f = contrazip6 (fn a) (fn b) (fn c) (fn d) (fn e) (fn f)++contrazipLifting7 :: Divisible f => (forall x. g x -> f x) -> g a1 -> g a2 -> g a3 -> g a4 -> g a5 -> g a6 -> g a7 -> f (a1, a2, a3, a4, a5, a6, a7)+contrazipLifting7 fn a b c d e f g = contrazip7 (fn a) (fn b) (fn c) (fn d) (fn e) (fn f) (fn g)++contrazipLifting8 :: Divisible f => (forall x. g x -> f x) -> g a1 -> g a2 -> g a3 -> g a4 -> g a5 -> g a6 -> g a7 -> g a8 -> f (a1, a2, a3, a4, a5, a6, a7, a8)+contrazipLifting8 fn a b c d e f g h = contrazip8 (fn a) (fn b) (fn c) (fn d) (fn e) (fn f) (fn g) (fn h)++contrazipLifting9 :: Divisible f => (forall x. g x -> f x) -> g a1 -> g a2 -> g a3 -> g a4 -> g a5 -> g a6 -> g a7 -> g a8 -> g a9 -> f (a1, a2, a3, a4, a5, a6, a7, a8, a9)+contrazipLifting9 fn a b c d e f g h i = contrazip9 (fn a) (fn b) (fn c) (fn d) (fn e) (fn f) (fn g) (fn h) (fn i)++contrazipLifting10 :: Divisible f => (forall x. g x -> f x) -> g a1 -> g a2 -> g a3 -> g a4 -> g a5 -> g a6 -> g a7 -> g a8 -> g a9 -> g a10 -> f (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)+contrazipLifting10 fn a b c d e f g h i j = contrazip10 (fn a) (fn b) (fn c) (fn d) (fn e) (fn f) (fn g) (fn h) (fn i) (fn j)

@@ -1,25 +0,0 @@-module Contravariant.Extras.Eliminate where--import BasePrelude-import Contravariant.Extras.Contrazip-import Data.Functor.Contravariant.Divisible-import qualified Contravariant.Extras.TH as TH---eliminate2 :: Divisible f => (forall x. g x -> f x) -> g a1 -> g a2 -> f (a1, a2)-eliminate2 fn a b = contrazip2 (fn a) (fn b)--eliminate3 :: Divisible f => (forall x. g x -> f x) -> g a1 -> g a2 -> g a3 -> f (a1, a2, a3)-eliminate3 fn a b c = contrazip3 (fn a) (fn b) (fn c)--eliminate4 :: Divisible f => (forall x. g x -> f x) -> g a1 -> g a2 -> g a3 -> g a4 -> f (a1, a2, a3, a4)-eliminate4 fn a b c d = contrazip4 (fn a) (fn b) (fn c) (fn d)--eliminate5 :: Divisible f => (forall x. g x -> f x) -> g a1 -> g a2 -> g a3 -> g a4 -> g a5 -> f (a1, a2, a3, a4, a5)-eliminate5 fn a b c d e = contrazip5 (fn a) (fn b) (fn c) (fn d) (fn e)--eliminate6 :: Divisible f => (forall x. g x -> f x) -> g a1 -> g a2 -> g a3 -> g a4 -> g a5 -> g a6 -> f (a1, a2, a3, a4, a5, a6)-eliminate6 fn a b c d e f = contrazip6 (fn a) (fn b) (fn c) (fn d) (fn e) (fn f)--eliminate7 :: Divisible f => (forall x. g x -> f x) -> g a1 -> g a2 -> g a3 -> g a4 -> g a5 -> g a6 -> g a7 -> f (a1, a2, a3, a4, a5, a6, a7)-eliminate7 fn a b c d e f g = contrazip7 (fn a) (fn b) (fn c) (fn d) (fn e) (fn f) (fn g)

@@ -14,7 +14,7 @@ --  module Contravariant.Extras.Op.Contrazip where -import BasePrelude+import Contravariant.Extras.Prelude import qualified Contravariant.Extras.TH as TH  

@@ -0,0 +1,80 @@+module Contravariant.Extras.Prelude+( +  module Exports,+)+where++-- base+-------------------------+import Control.Applicative as Exports+import Control.Arrow as Exports hiding (first, second)+import Control.Category as Exports+import Control.Concurrent as Exports+import Control.Exception as Exports+import Control.Monad as Exports hiding (fail, mapM_, sequence_, forM_, msum, mapM, sequence, forM)+import Control.Monad.IO.Class as Exports+import Control.Monad.Fail as Exports+import Control.Monad.Fix as Exports hiding (fix)+import Control.Monad.ST as Exports+import Data.Bifunctor as Exports+import Data.Bits as Exports+import Data.Bool as Exports+import Data.Char as Exports+import Data.Coerce as Exports+import Data.Complex as Exports+import Data.Data as Exports+import Data.Dynamic as Exports+import Data.Either as Exports+import Data.Fixed as Exports+import Data.Foldable as Exports hiding (toList)+import Data.Function as Exports hiding (id, (.))+import Data.Functor as Exports+import Data.Functor.Contravariant as Exports+import Data.Functor.Identity as Exports+import Data.Int as Exports+import Data.IORef as Exports+import Data.Ix as Exports+import Data.List as Exports hiding (sortOn, isSubsequenceOf, uncons, concat, foldr, foldl1, maximum, minimum, product, sum, all, and, any, concatMap, elem, foldl, foldr1, notElem, or, find, maximumBy, minimumBy, mapAccumL, mapAccumR, foldl')+import Data.Maybe as Exports+import Data.Monoid as Exports hiding (Last(..), First(..), (<>))+import Data.Ord as Exports+import Data.Proxy as Exports+import Data.Ratio as Exports+import Data.Semigroup as Exports+import Data.STRef as Exports+import Data.String as Exports+import Data.Traversable as Exports+import Data.Tuple as Exports+import Data.Unique as Exports+import Data.Version as Exports+import Data.Void as Exports+import Data.Word as Exports+import Debug.Trace as Exports+import Foreign.ForeignPtr as Exports+import Foreign.Ptr as Exports+import Foreign.StablePtr as Exports+import Foreign.Storable as Exports hiding (sizeOf, alignment)+import GHC.Conc as Exports hiding (withMVar, threadWaitWriteSTM, threadWaitWrite, threadWaitReadSTM, threadWaitRead)+import GHC.Exts as Exports (lazy, inline, sortWith, groupWith, IsList(..))+import GHC.Generics as Exports (Generic, Generic1)+import GHC.IO.Exception as Exports+import Numeric as Exports+import Prelude as Exports hiding (fail, concat, foldr, mapM_, sequence_, foldl1, maximum, minimum, product, sum, all, and, any, concatMap, elem, foldl, foldr1, notElem, or, mapM, sequence, id, (.))+import System.Environment as Exports+import System.Exit as Exports+import System.IO as Exports+import System.IO.Error as Exports+import System.IO.Unsafe as Exports+import System.Mem as Exports+import System.Mem.StableName as Exports+import System.Timeout as Exports+import Text.ParserCombinators.ReadP as Exports (ReadP, ReadS, readP_to_S, readS_to_P)+import Text.ParserCombinators.ReadPrec as Exports (ReadPrec, readPrec_to_P, readP_to_Prec, readPrec_to_S, readS_to_Prec)+import Text.Printf as Exports (printf, hPrintf)+import Text.Read as Exports (Read(..), readMaybe, readEither)+import Unsafe.Coerce as Exports++-- contravariant+-------------------------+import Data.Functor.Contravariant as Exports+import Data.Functor.Contravariant.Divisible as Exports

@@ -1,11 +1,11 @@ {-# LANGUAGE CPP #-} module Contravariant.Extras.TH where -import BasePrelude+import Contravariant.Extras.Prelude import Data.Functor.Contravariant import Data.Functor.Contravariant.Divisible-import Language.Haskell.TH hiding (classP)-import qualified TupleTH+import Language.Haskell.TH.Syntax hiding (classP)+import qualified TemplateHaskell.Compat.V0208 as Compat   -- |@@ -208,9 +208,14 @@  splitTupleAtE :: Int -> Int -> Exp splitTupleAtE arity position =-  unsafePerformIO $-  runQ $-  TupleTH.splitTupleAt arity position+  let+    nameByIndex index = Name (OccName ('_' : show index)) NameS+    names = enumFromTo 0 (pred arity) & map nameByIndex+    pats = names & map VarP+    pat = TupP pats+    exps = names & map VarE+    body = splitAt position exps & \ (a, b) -> Compat.tupE [Compat.tupE a, Compat.tupE b]+    in LamE [pat] body  classP :: Name -> [Type] -> Pred #if MIN_VERSION_template_haskell(2,10,0)