diff --git a/ChangeLog.md b/ChangeLog.md --- a/ChangeLog.md +++ b/ChangeLog.md @@ -1,5 +1,9 @@ # Revision history for vec +## 0.5 + +- Remove PigeonHole module. It didn't work well. + ## 0.4.1 - Add `boring` instances diff --git a/src/Data/Functor/Confusing.hs b/src/Data/Functor/Confusing.hs deleted file mode 100644 --- a/src/Data/Functor/Confusing.hs +++ /dev/null @@ -1,136 +0,0 @@ -{-# LANGUAGE RankNTypes #-} -{-# LANGUAGE Safe #-} --- | --- Csongor Kiss, Matthew Pickering, and Nicolas Wu. 2018. Generic deriving of generic traversals. --- Proc. ACM Program. Lang. 2, ICFP, Article 85 (July 2018), 30 pages. DOI: https://doi.org/10.1145/3236780 --- --- https://arxiv.org/abs/1805.06798 --- --- This is modified version of part of @generic-lens@ library --- --- Copyright (c) 2018, Csongor Kiss --- --- All rights reserved. --- --- Redistribution and use in source and binary forms, with or without --- modification, are permitted provided that the following conditions are met: --- --- * Redistributions of source code must retain the above copyright --- notice, this list of conditions and the following disclaimer. --- --- * 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. --- --- * Neither the name of Csongor Kiss nor the names of other --- contributors may be used to endorse or promote products derived --- from this software without specific prior written permission. --- --- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS --- "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 COPYRIGHT --- OWNER 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. --- -module Data.Functor.Confusing ( - fusing, confusing, LensLike, - ifusing, iconfusing, IxLensLike, - ffusing, fconfusing, FLensLike, - liftCurriedYoneda, yap, - Curried (..), liftCurried, lowerCurried, - Yoneda (..), liftYoneda, lowerYoneda, - ) where - -import Control.Applicative - -------------------------------------------------------------------------------- --- Confusing -------------------------------------------------------------------------------- - -type LensLike f s t a b = (a -> f b) -> s -> f t - --- note: qualified name to justify import even with newer GHCs - -fusing :: Functor f => LensLike (Yoneda f) s t a b -> LensLike f s t a b -fusing t = \f -> lowerYoneda . t (liftYoneda . f) -{-# INLINE fusing #-} - -confusing :: Control.Applicative.Applicative f => LensLike (Curried (Yoneda f)) s t a b -> LensLike f s t a b -confusing t = \f -> lowerYoneda . lowerCurried . t (liftCurriedYoneda . f) -{-# INLINE confusing #-} - -liftCurriedYoneda :: Applicative f => f a -> Curried (Yoneda f) a -liftCurriedYoneda fa = Curried (`yap` fa) -{-# INLINE liftCurriedYoneda #-} - -yap :: Applicative f => Yoneda f (a -> b) -> f a -> Yoneda f b -yap (Yoneda k) fa = Yoneda (\ab_r -> k (ab_r .) <*> fa) -{-# INLINE yap #-} - -type IxLensLike f i s t a b = (i -> a -> f b) -> s -> f t - -ifusing :: Functor f => IxLensLike (Yoneda f) i s t a b -> IxLensLike f i s t a b -ifusing t = \f -> lowerYoneda . t (\i a -> liftYoneda (f i a)) -{-# INLINE ifusing #-} - -iconfusing :: Applicative f => IxLensLike (Curried (Yoneda f)) i s t a b -> IxLensLike f i s t a b -iconfusing t = \f -> lowerYoneda . lowerCurried . t (\i a -> liftCurriedYoneda (f i a)) -{-# INLINE iconfusing #-} - -type FLensLike f s t a b = (forall x. a x -> f (b x)) -> s -> f t - -ffusing :: Functor f => FLensLike (Yoneda f) s t a b -> FLensLike f s t a b -ffusing t = \f -> lowerYoneda . t (liftYoneda . f) -{-# INLINE ffusing #-} - -fconfusing :: Applicative f => FLensLike (Curried (Yoneda f)) s t a b -> FLensLike f s t a b -fconfusing t = \f -> lowerYoneda . lowerCurried . t (liftCurriedYoneda . f) -{-# INLINE fconfusing #-} - -------------------------------------------------------------------------------- --- Curried -------------------------------------------------------------------------------- - -newtype Curried f a = Curried { runCurried :: forall r. f (a -> r) -> f r } - -instance Functor f => Functor (Curried f) where - fmap f (Curried g) = Curried (g . fmap (.f)) - {-# INLINE fmap #-} - -instance Functor f => Applicative (Curried f) where - pure a = Curried (fmap ($ a)) - {-# INLINE pure #-} - Curried mf <*> Curried ma = Curried (ma . mf . fmap (.)) - {-# INLINE (<*>) #-} - -liftCurried :: Applicative f => f a -> Curried f a -liftCurried fa = Curried (<*> fa) - -lowerCurried :: Applicative f => Curried f a -> f a -lowerCurried (Curried f) = f (pure id) - -------------------------------------------------------------------------------- --- Yoneda -------------------------------------------------------------------------------- - -newtype Yoneda f a = Yoneda { runYoneda :: forall b. (a -> b) -> f b } - -liftYoneda :: Functor f => f a -> Yoneda f a -liftYoneda a = Yoneda (\f -> fmap f a) - -lowerYoneda :: Yoneda f a -> f a -lowerYoneda (Yoneda f) = f id - -instance Functor (Yoneda f) where - fmap f m = Yoneda (\k -> runYoneda m (k . f)) - -instance Applicative f => Applicative (Yoneda f) where - pure a = Yoneda (\f -> pure (f a)) - Yoneda m <*> Yoneda n = Yoneda (\f -> m (f .) <*> n id) diff --git a/src/Data/Vec/DataFamily/SpineStrict/Pigeonhole.hs b/src/Data/Vec/DataFamily/SpineStrict/Pigeonhole.hs deleted file mode 100644 --- a/src/Data/Vec/DataFamily/SpineStrict/Pigeonhole.hs +++ /dev/null @@ -1,295 +0,0 @@ -{-# LANGUAGE CPP #-} -{-# LANGUAGE ConstraintKinds #-} -{-# LANGUAGE DataKinds #-} -{-# LANGUAGE DefaultSignatures #-} -{-# LANGUAGE FlexibleContexts #-} -{-# LANGUAGE FlexibleInstances #-} -{-# LANGUAGE MultiParamTypeClasses #-} -{-# LANGUAGE PolyKinds #-} -{-# LANGUAGE Safe #-} -{-# LANGUAGE ScopedTypeVariables #-} -{-# LANGUAGE TypeFamilies #-} -{-# LANGUAGE TypeOperators #-} -{-# LANGUAGE UndecidableInstances #-} -module Data.Vec.DataFamily.SpineStrict.Pigeonhole ( - Pigeonhole (..), - -- * Representable - gindex, - gtabulate, - gix, - -- ** Traversable with index - gtraverse, - gitraverse, - -- * Generic implementation - gfrom, GFrom, - gto, GTo, - GPigeonholeSize, - ) where - -import Prelude (Functor (..), fst, uncurry, ($), (.)) - -import Control.Applicative (Applicative (..), (<$>)) -import Control.Arrow (first) -import Data.Fin (Fin (..)) -import Data.Functor.Confusing (confusing, fusing, iconfusing) -import Data.Functor.Identity (Identity (..)) -import Data.Functor.Product (Product (..)) -import Data.Nat (Nat (..)) -import Data.Proxy (Proxy (..)) -import Data.Vec.DataFamily.SpineStrict (Vec (..), tabulate) -import GHC.Generics (M1 (..), Par1 (..), U1 (..), (:*:) (..)) - -import qualified Control.Lens.Yocto as YLens -import qualified Data.Fin as F -import qualified Data.Fin.Enum as F -import qualified Data.Type.Nat as N -import qualified Data.Vec.DataFamily.SpineStrict as V -import qualified GHC.Generics as G - -#ifdef MIN_VERSION_transformers_compat -import Control.Monad.Trans.Instances () -#endif - --- $setup --- >>> :set -XDeriveGeneric --- >>> import Control.Applicative (Const (..)) --- >>> import Data.Char (toUpper) --- >>> import Data.Functor.Identity (Identity (..)) --- >>> import Data.Void (absurd) --- >>> import GHC.Generics (Generic, Generic1) --- >>> import Prelude (Int, Show, Char, Integer) --- >>> import Data.Proxy (Proxy (..)) --- >>> import qualified Control.Lens as Lens --- >>> import Data.Fin (Fin (..)) --- >>> import Data.Vec.DataFamily.SpineStrict (Vec (..)) - -------------------------------------------------------------------------------- --- Class -------------------------------------------------------------------------------- - --- | Generic pigeonholes. --- --- /Examples:/ --- --- >>> from (Identity 'a') --- 'a' ::: VNil --- --- >>> data Values a = Values a a a deriving (Generic1) --- >>> instance Pigeonhole Values --- >>> from (Values 1 2 3) --- 1 ::: 2 ::: 3 ::: VNil --- -class Pigeonhole f where - -- | The size of a pigeonhole - type PigeonholeSize f :: Nat - type PigeonholeSize f = GPigeonholeSize f - - -- | Converts a value to vector - from :: f x -> Vec (PigeonholeSize f) x - default from :: (G.Generic1 f, GFrom f, PigeonholeSize f ~ GPigeonholeSize f) => f x -> Vec (PigeonholeSize f) x - from = gfrom - - -- | Converts back from vector. - to :: Vec (PigeonholeSize f) x -> f x - default to :: (G.Generic1 f, GTo f, PigeonholeSize f ~ GPigeonholeSize f) => Vec (PigeonholeSize f) x -> f x - to = gto - --- | @'Identity' x@ ~ @x ^ 1@ -instance Pigeonhole Identity --- --- | @'Proxy' x@ ~ @x ^ 0@ -instance Pigeonhole Proxy where - type PigeonholeSize Proxy = 'Z - from _ = VNil - to _ = Proxy - --- | @'Product' f g x@ ~ @x ^ (size f + size g)@ -instance (Pigeonhole f, Pigeonhole g, N.SNatI (PigeonholeSize f)) => Pigeonhole (Product f g) where - type PigeonholeSize (Product f g) = N.Plus (PigeonholeSize f) (PigeonholeSize g) - - to = f . V.split where f (a, b) = Pair (to a) (to b) - from = uncurry (V.++) . g where g (Pair a b) = (from a, from b) - -------------------------------------------------------------------------------- --- Generic representable -------------------------------------------------------------------------------- - --- | Index. --- --- >>> gindex (Identity 'y') (Proxy :: Proxy Int) --- 'y' --- --- >>> data Key = Key1 | Key2 | Key3 deriving (Generic) --- >>> data Values a = Values a a a deriving (Generic1) --- --- >>> gindex (Values 'a' 'b' 'c') Key2 --- 'b' --- -gindex - :: ( G.Generic i, F.GFrom i, G.Generic1 f, GFrom f - , F.GEnumSize i ~ GPigeonholeSize f, N.SNatI (GPigeonholeSize f) - ) - => f a -> i -> a -gindex fa i = gfrom fa V.! F.gfrom i - --- | Tabulate. --- --- >>> gtabulate (\() -> 'x') :: Identity Char --- Identity 'x' --- --- >>> gtabulate absurd :: Proxy Integer --- Proxy --- --- >>> gtabulate absurd :: Proxy Integer --- Proxy --- -gtabulate - :: ( G.Generic i, F.GTo i, G.Generic1 f, GTo f - , F.GEnumSize i ~ GPigeonholeSize f, N.SNatI (GPigeonholeSize f) - ) - => (i -> a) -> f a -gtabulate idx = gto $ tabulate (idx . F.gto) - --- | A lens. @i -> Lens' (t a) a@ --- --- >>> Lens.view (gix ()) (Identity 'x') --- 'x' --- --- >>> Lens.over (gix ()) toUpper (Identity 'x') --- Identity 'X' --- -gix :: ( G.Generic i, F.GFrom i, G.Generic1 t, GTo t, GFrom t - , F.GEnumSize i ~ GPigeonholeSize t, N.SNatI (GPigeonholeSize t) - , Functor f - ) - => i -> (a -> f a) -> t a -> f (t a) -gix i = fusing $ \ab ta -> gto <$> ix (F.gfrom i) ab (gfrom ta) - -------------------------------------------------------------------------------- --- Vendored in ix -------------------------------------------------------------------------------- - --- | Index lens. --- -ix :: forall n f a. (N.SNatI n, Functor f) => Fin n -> YLens.LensLike' f (Vec n a) a -ix = getIxLens $ N.induction1 start step where - start :: IxLens f 'Z a - start = IxLens F.absurd - - step :: IxLens f m a -> IxLens f ('S m) a - step (IxLens l) = IxLens $ \i -> case i of - FZ -> _head - FS j -> _tail . l j - -newtype IxLens f n a = IxLens { getIxLens :: Fin n -> YLens.LensLike' f (Vec n a) a } - -_head :: YLens.Lens' (Vec ('S n) a) a -_head f (x ::: xs) = (::: xs) <$> f x -{-# INLINE _head #-} - --- | Head lens. /Note:/ @lens@ 'Lens._head' is a 'Lens.Traversal''. -_tail :: YLens.Lens' (Vec ('S n) a) (Vec n a) -_tail f (x ::: xs) = (x :::) <$> f xs -{-# INLINE _tail #-} - -------------------------------------------------------------------------------- --- Generic traversable with index -------------------------------------------------------------------------------- - --- | Generic traverse. --- --- __Don't use__, rather use @DeriveTraversable@ -gtraverse - :: ( G.Generic1 t, GFrom t, GTo t - , N.SNatI (GPigeonholeSize t) - , Applicative f - ) - => (a -> f b) -> t a -> f (t b) -gtraverse = confusing $ \afb ta -> gto <$> V.traverse afb (gfrom ta) -{-# INLINE gtraverse #-} - --- | Traverse with index. --- --- >>> data Key = Key1 | Key2 | Key3 deriving (Show, Generic) --- >>> data Values a = Values a a a deriving (Generic1) --- --- >>> gitraverse (\i a -> Const [(i :: Key, a)]) (Values 'a' 'b' 'c') --- Const [(Key1,'a'),(Key2,'b'),(Key3,'c')] --- -gitraverse - :: ( G.Generic i, F.GTo i - , G.Generic1 t, GFrom t, GTo t - , F.GEnumSize i ~ GPigeonholeSize t, N.SNatI (GPigeonholeSize t) - , Applicative f - ) - => (i -> a -> f b) -> t a -> f (t b) -gitraverse = iconfusing $ \iafb ta -> gto <$> V.itraverse (\i a -> iafb (F.gto i) a) (gfrom ta) -{-# INLINE gitraverse #-} - -------------------------------------------------------------------------------- --- PigeonholeSize -------------------------------------------------------------------------------- - --- | Compute the size from the type. -type GPigeonholeSize c = PigeonholeSizeRep (G.Rep1 c) N.Nat0 - -type family PigeonholeSizeRep (c :: * -> *) (n :: Nat) :: Nat where - PigeonholeSizeRep (a :*: b ) n = PigeonholeSizeRep a (PigeonholeSizeRep b n) - PigeonholeSizeRep (M1 _d _c a) n = PigeonholeSizeRep a n - PigeonholeSizeRep Par1 n = 'N.S n - PigeonholeSizeRep U1 n = n - -------------------------------------------------------------------------------- --- From -------------------------------------------------------------------------------- - --- | Generic version of 'from'. -gfrom :: (G.Generic1 c, GFrom c) => c a -> Vec (GPigeonholeSize c) a -gfrom = \x -> gfromRep1 (G.from1 x) VNil - --- | Constraint for the class that computes 'gfrom'. -type GFrom c = GFromRep1 (G.Rep1 c) - -class GFromRep1 (c :: * -> *) where - gfromRep1 :: c x -> Vec n x -> Vec (PigeonholeSizeRep c n) x - -instance (GFromRep1 a, GFromRep1 b) => GFromRep1 (a :*: b) where - gfromRep1 (x :*: y) z = gfromRep1 x (gfromRep1 y z) - -instance GFromRep1 a => GFromRep1 (M1 d c a) where - gfromRep1 (M1 a) z = gfromRep1 a z - -instance GFromRep1 Par1 where - gfromRep1 (Par1 x) z = x ::: z - -instance GFromRep1 U1 where - gfromRep1 _U1 z = z - -------------------------------------------------------------------------------- --- To -------------------------------------------------------------------------------- - --- | Generic version of 'to'. -gto :: forall c a. (G.Generic1 c, GTo c) => Vec (GPigeonholeSize c) a -> c a -gto = \xs -> G.to1 $ fst (gtoRep1 xs :: (G.Rep1 c a, Vec 'N.Z a)) - --- | Constraint for the class that computes 'gto'. -type GTo c = GToRep1 (G.Rep1 c) - -class GToRep1 (c :: * -> *) where - gtoRep1 :: Vec (PigeonholeSizeRep c n) x -> (c x, Vec n x) - -instance GToRep1 a => GToRep1 (M1 d c a) where - gtoRep1 = first M1 . gtoRep1 - -instance (GToRep1 a, GToRep1 b) => GToRep1 (a :*: b) where - gtoRep1 xs = - let (a, ys) = gtoRep1 xs - (b, zs) = gtoRep1 ys - in (a :*: b, zs) - -instance GToRep1 Par1 where - gtoRep1 (x ::: xs) = (Par1 x, xs) - -instance GToRep1 U1 where - gtoRep1 xs = (U1, xs) diff --git a/test/Inspection/DataFamily/SpineStrict/Pigeonhole.hs b/test/Inspection/DataFamily/SpineStrict/Pigeonhole.hs deleted file mode 100644 --- a/test/Inspection/DataFamily/SpineStrict/Pigeonhole.hs +++ /dev/null @@ -1,119 +0,0 @@ -{-# LANGUAGE DeriveGeneric #-} -{-# LANGUAGE TemplateHaskell #-} -{-# OPTIONS_GHC -O -fplugin Test.Inspection.Plugin #-} --- {-# OPTIONS_GHC -dsuppress-all #-} -{-# OPTIONS_GHC -dsuppress-idinfo #-} -{-# OPTIONS_GHC -dsuppress-coercions #-} -{-# OPTIONS_GHC -dsuppress-type-applications #-} -{-# OPTIONS_GHC -dsuppress-module-prefixes #-} -{-# OPTIONS_GHC -dsuppress-type-signatures #-} --- {-# OPTIONS_GHC -dsuppress-uniques #-} --- This makes gix tests pass, default is 60 -{-# OPTIONS_GHC -funfolding-use-threshold=240 #-} -module Inspection.DataFamily.SpineStrict.Pigeonhole where - -import Data.Functor.Compat ((<&>)) -import Data.Vec.DataFamily.SpineStrict.Pigeonhole - (gindex, gitraverse, gix, gtabulate, gtraverse) -import GHC.Generics (Generic, Generic1) -import Test.Inspection - -------------------------------------------------------------------------------- --- Simple type -------------------------------------------------------------------------------- - -data Key = Key1 | Key2 | Key3 | Key4 | Key5 deriving (Show, Generic) -data Values a = Values a a a a a deriving (Show, Generic1) - -------------------------------------------------------------------------------- --- Simple -------------------------------------------------------------------------------- - -lhsSimple :: Char -lhsSimple = gindex (Values 'a' 'b' 'c' 'd' 'e' ) Key2 - -rhsSimple :: Char -rhsSimple = 'b' - -inspect $ 'lhsSimple === 'rhsSimple - -------------------------------------------------------------------------------- --- Index -------------------------------------------------------------------------------- - -lhsIndex :: Values a -> Key -> a -lhsIndex = gindex - -rhsIndex :: Values a -> Key -> a -rhsIndex (Values x _ _ _ _) Key1 = x -rhsIndex (Values _ x _ _ _) Key2 = x -rhsIndex (Values _ _ x _ _) Key3 = x -rhsIndex (Values _ _ _ x _) Key4 = x -rhsIndex (Values _ _ _ _ x) Key5 = x - -inspect $ hasNoGenerics 'lhsIndex -inspect $ 'lhsIndex === 'rhsIndex - -------------------------------------------------------------------------------- --- Tabulate -------------------------------------------------------------------------------- - -lhsTabulate :: (Key -> a) -> Values a -lhsTabulate = gtabulate - -rhsTabulate :: (Key -> a) -> Values a -rhsTabulate f = Values (f Key1) (f Key2) (f Key3) (f Key4) (f Key5) - -inspect $ hasNoGenerics 'lhsTabulate -inspect $ 'lhsTabulate === 'rhsTabulate - -------------------------------------------------------------------------------- --- Ix -------------------------------------------------------------------------------- - -type LensLike' f s a = (a -> f a) -> s -> f s - -lhsIx :: Functor f => Key -> LensLike' f (Values a) a -lhsIx = gix - -rhsIx :: Functor f => Key -> LensLike' f (Values a) a -rhsIx Key1 f (Values x1 x2 x3 x4 x5) = f x1 <&> \x1' -> Values x1' x2 x3 x4 x5 -rhsIx Key2 f (Values x1 x2 x3 x4 x5) = f x2 <&> \x2' -> Values x1 x2' x3 x4 x5 -rhsIx Key3 f (Values x1 x2 x3 x4 x5) = f x3 <&> \x3' -> Values x1 x2 x3' x4 x5 -rhsIx Key4 f (Values x1 x2 x3 x4 x5) = f x4 <&> \x4' -> Values x1 x2 x3 x4' x5 -rhsIx Key5 f (Values x1 x2 x3 x4 x5) = f x5 <&> \x5' -> Values x1 x2 x3 x4 x5' - -inspect $ hasNoGenerics 'lhsIx -inspect $ 'lhsIx === 'rhsIx - -------------------------------------------------------------------------------- --- Indexed traverse -------------------------------------------------------------------------------- - -lhsTraverse :: Applicative f => (a -> f b) -> Values a -> f (Values b) -lhsTraverse f xs = gtraverse f xs - -rhsTraverse :: Applicative f => (a -> f b) -> Values a -> f (Values b) -rhsTraverse f (Values x y z u v) = pure Values - <*> f x - <*> f y - <*> f z - <*> f u - <*> f v - -inspect $ hasNoGenerics 'lhsTraverse -inspect $ 'lhsTraverse === 'rhsTraverse - -lhsITraverse :: Applicative f => (Key -> a -> f b) -> Values a -> f (Values b) -lhsITraverse f xs = gitraverse f xs - -rhsITraverse :: Applicative f => (Key -> a -> f b) -> Values a -> f (Values b) -rhsITraverse f (Values x y z u v) = pure Values - <*> f Key1 x - <*> f Key2 y - <*> f Key3 z - <*> f Key4 u - <*> f Key5 v - -inspect $ hasNoGenerics 'lhsITraverse -inspect $ 'lhsITraverse === 'rhsITraverse diff --git a/vec.cabal b/vec.cabal --- a/vec.cabal +++ b/vec.cabal @@ -1,6 +1,6 @@ cabal-version: 2.2 name: vec -version: 0.4.1 +version: 0.5 synopsis: Vec: length-indexed (sized) list category: Data, Dependent Types description: @@ -77,9 +77,11 @@ || ==8.4.4 || ==8.6.5 || ==8.8.4 - || ==8.10.4 - || ==9.0.1 - || ==9.2.1 + || ==8.10.7 + || ==9.0.2 + || ==9.2.7 + || ==9.4.4 + || ==9.6.1 source-repository head type: git @@ -111,19 +113,17 @@ hs-source-dirs: src exposed-modules: Data.Vec.DataFamily.SpineStrict - Data.Vec.DataFamily.SpineStrict.Pigeonhole Data.Vec.Lazy Data.Vec.Lazy.Inline Data.Vec.Pull other-modules: Control.Lens.Yocto - Data.Functor.Confusing SafeCompat -- GHC boot libs build-depends: - , base >=4.7 && <4.17 + , base >=4.7 && <4.19 , deepseq >=1.3.0.1 && <1.5 , transformers >=0.3.0.0 && <0.7 @@ -138,7 +138,7 @@ build-depends: transformers-compat ^>=0.6.5 || ^>=0.7.1 -- siblings - build-depends: fin ^>=0.2.1 + build-depends: fin ^>=0.3 -- other dependencies build-depends: @@ -154,7 +154,7 @@ build-depends: adjunctions ^>=4.4 if flag(semigroupoids) - build-depends: semigroupoids ^>=5.3.5 + build-depends: semigroupoids ^>=5.3.5 || ^>=6 other-extensions: CPP @@ -176,7 +176,6 @@ other-modules: Inspection Inspection.DataFamily.SpineStrict - Inspection.DataFamily.SpineStrict.Pigeonhole ghc-options: -Wall -fprint-explicit-kinds hs-source-dirs: test @@ -185,7 +184,7 @@ , base , base-compat , fin - , inspection-testing ^>=0.4.2.2 + , inspection-testing ^>=0.4.2.2 || ^>=0.5.0.1 , tagged , vec @@ -201,7 +200,7 @@ other-modules: DotProduct build-depends: , base - , criterion >=1.4.0.0 && <1.6 + , criterion >=1.4.0.0 && <1.7 , fin , vec , vector