strict 0.5 → 0.5.1
raw patch · 7 files changed
+112/−321 lines, 7 filesdep −bifunctor-classes-compatdep −semigroupsdep −transformers-compatdep ~assocdep ~basedep ~binary
Dependencies removed: bifunctor-classes-compat, semigroups, transformers-compat
Dependency ranges changed: assoc, base, binary, bytestring, deepseq, hashable, text, these, transformers
Files
- CHANGELOG.md +4/−0
- src/Data/Strict/Classes.hs +0/−10
- src/Data/Strict/Either.hs +10/−53
- src/Data/Strict/Maybe.hs +6/−56
- src/Data/Strict/These.hs +1/−42
- src/Data/Strict/Tuple.hs +12/−70
- strict.cabal +79/−90
CHANGELOG.md view
@@ -1,3 +1,7 @@+# 0.5.1++- Support GHC-8.6.5...GHC-9.10.1+ # 0.5 - Depend on `bifunctor-classes-compat` instead of `bifunctors`
src/Data/Strict/Classes.hs view
@@ -1,10 +1,5 @@-{-# LANGUAGE CPP #-} {-# LANGUAGE FunctionalDependencies #-}-#if MIN_VERSION_base(4,8,0) {-# LANGUAGE Safe #-}-#else-{-# LANGUAGE Trustworthy #-}-#endif module Data.Strict.Classes ( Strict (..),@@ -70,13 +65,8 @@ toLazy (These x y) = L.These x y instance Strict LBS.ByteString BS.ByteString where-#if MIN_VERSION_bytestring(0,10,0) toStrict = LBS.toStrict toLazy = LBS.fromStrict-#else- toStrict = BS.concat . LBS.toChunks- toLazy = LBS.fromChunks . L.return {- singleton -}-#endif instance Strict LT.Text T.Text where toStrict = LT.toStrict
src/Data/Strict/Either.hs view
@@ -1,20 +1,7 @@-{-# LANGUAGE CPP #-} {-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE Safe #-} {-# LANGUAGE DeriveGeneric #-} -#if MIN_VERSION_base(4,9,0)-#define LIFTED_FUNCTOR_CLASSES 1-#else-#if MIN_VERSION_transformers(0,5,0)-#define LIFTED_FUNCTOR_CLASSES 1-#else-#if MIN_VERSION_transformers_compat(0,5,0) && !MIN_VERSION_transformers(0,4,0)-#define LIFTED_FUNCTOR_CLASSES 1-#endif-#endif-#endif- ----------------------------------------------------------------------------- -- | --@@ -47,44 +34,25 @@ -- Lazy variants import qualified Prelude as L -import Control.DeepSeq (NFData (..))-import Data.Bifoldable (Bifoldable (..))-import Data.Bifunctor (Bifunctor (..))-import Data.Binary (Binary (..))-import Data.Bitraversable (Bitraversable (..))-import Data.Hashable (Hashable(..))-import Data.Hashable.Lifted (Hashable1 (..), Hashable2 (..))-import GHC.Generics (Generic)-import Data.Data (Data (..), Typeable)--#if __GLASGOW_HASKELL__ >= 706-import GHC.Generics (Generic1)-#endif--#if MIN_VERSION_deepseq(1,4,3)-import Control.DeepSeq (NFData1 (..), NFData2 (..))-#endif--#ifdef MIN_VERSION_assoc+import Control.DeepSeq (NFData (..), NFData1 (..), NFData2 (..))+import Data.Bifoldable (Bifoldable (..))+import Data.Bifunctor (Bifunctor (..)) import Data.Bifunctor.Assoc (Assoc (..)) import Data.Bifunctor.Swap (Swap (..))-#endif+import Data.Binary (Binary (..))+import Data.Bitraversable (Bitraversable (..))+import Data.Data (Data (..), Typeable)+import Data.Hashable (Hashable(..))+import Data.Hashable.Lifted (Hashable1 (..), Hashable2 (..))+import GHC.Generics (Generic, Generic1) -#ifdef LIFTED_FUNCTOR_CLASSES import Data.Functor.Classes (Eq1 (..), Eq2 (..), Ord1 (..), Ord2 (..), Read1 (..), Read2 (..), Show1 (..), Show2 (..))-#else-import Data.Functor.Classes (Eq1 (..), Ord1 (..), Read1 (..), Show1 (..))-#endif -- | The strict choice type. data Either a b = Left !a | Right !b- deriving (Eq, Ord, Read, Show, Typeable, Data, Generic-#if __GLASGOW_HASKELL__ >= 706- , Generic1-#endif- )+ deriving (Eq, Ord, Read, Show, Typeable, Data, Generic, Generic1) toStrict :: L.Either a b -> Either a b toStrict (L.Left x) = Left x@@ -166,13 +134,11 @@ instance (NFData a, NFData b) => NFData (Either a b) where rnf = rnf . toLazy -#if MIN_VERSION_deepseq(1,4,3) instance (NFData a) => NFData1 (Either a) where liftRnf rnfA = liftRnf rnfA . toLazy instance NFData2 Either where liftRnf2 rnfA rnfB = liftRnf2 rnfA rnfB . toLazy-#endif -- binary instance (Binary a, Binary b) => Binary (Either a b) where@@ -210,7 +176,6 @@ liftHashWithSalt2 hashA hashB salt = liftHashWithSalt2 hashA hashB salt . toLazy -- assoc-#ifdef MIN_VERSION_assoc instance Assoc Either where assoc (Left (Left a)) = Left a assoc (Left (Right b)) = Right (Left b)@@ -223,10 +188,8 @@ instance Swap Either where swap (Left x) = Right x swap (Right x) = Left x-#endif -- Data.Functor.Classes-#ifdef LIFTED_FUNCTOR_CLASSES instance Eq2 Either where liftEq2 f _ (Left a) (Left a') = f a a' liftEq2 _ g (Right b) (Right b') = g b b'@@ -271,9 +234,3 @@ instance Read a => Read1 (Either a) where liftReadsPrec = liftReadsPrec2 readsPrec readList-#else-instance Eq a => Eq1 (Either a) where eq1 = (==)-instance Ord a => Ord1 (Either a) where compare1 = compare-instance Show a => Show1 (Either a) where showsPrec1 = showsPrec-instance Read a => Read1 (Either a) where readsPrec1 = readsPrec-#endif
src/Data/Strict/Maybe.hs view
@@ -1,20 +1,7 @@-{-# LANGUAGE CPP #-} {-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE Safe #-} {-# LANGUAGE DeriveGeneric #-} -#if MIN_VERSION_base(4,9,0)-#define LIFTED_FUNCTOR_CLASSES 1-#else-#if MIN_VERSION_transformers(0,5,0)-#define LIFTED_FUNCTOR_CLASSES 1-#else-#if MIN_VERSION_transformers_compat(0,5,0) && !MIN_VERSION_transformers(0,4,0)-#define LIFTED_FUNCTOR_CLASSES 1-#endif-#endif-#endif- ----------------------------------------------------------------------------- -- | --@@ -58,35 +45,18 @@ -- Lazy variants import qualified Prelude as L -import Control.DeepSeq (NFData (..))-import Data.Binary (Binary (..))-import Data.Hashable (Hashable(..))+import Control.DeepSeq (NFData (..), NFData1 (..))+import Data.Binary (Binary (..))+import Data.Data (Data (..), Typeable)+import Data.Hashable (Hashable(..)) import Data.Hashable.Lifted (Hashable1 (..))-import GHC.Generics (Generic)-import Data.Data (Data (..), Typeable)---#if __GLASGOW_HASKELL__ >= 706-import GHC.Generics (Generic1)-#endif--#if MIN_VERSION_deepseq(1,4,3)-import Control.DeepSeq (NFData1 (..))-#endif+import GHC.Generics (Generic, Generic1) -#ifdef LIFTED_FUNCTOR_CLASSES import Data.Functor.Classes (Eq1 (..), Ord1 (..), Read1 (..), Show1 (..))-#else-import Data.Functor.Classes (Eq1 (..), Ord1 (..), Read1 (..), Show1 (..))-#endif -- | The type of strict optional values. data Maybe a = Nothing | Just !a- deriving (Eq, Ord, Read, Show, Typeable, Data, Generic-#if __GLASGOW_HASKELL__ >= 706- , Generic1-#endif- )+ deriving (Eq, Ord, Read, Show, Typeable, Data, Generic, Generic1) toStrict :: L.Maybe a -> Maybe a toStrict L.Nothing = Nothing@@ -157,18 +127,9 @@ m <> Nothing = m Just x1 <> Just x2 = Just (x1 <> x2) -#if MIN_VERSION_base(4,11,0) instance Semigroup a => Monoid (Maybe a) where mempty = Nothing-#else-instance Monoid a => Monoid (Maybe a) where- mempty = Nothing - Nothing `mappend` m = m- m `mappend` Nothing = m- Just x1 `mappend` Just x2 = Just (x1 `mappend` x2)-#endif- instance Functor Maybe where fmap _ Nothing = Nothing fmap f (Just x) = Just (f x)@@ -185,10 +146,8 @@ instance NFData a => NFData (Maybe a) where rnf = rnf . toLazy -#if MIN_VERSION_deepseq(1,4,3) instance NFData1 Maybe where liftRnf rnfA = liftRnf rnfA . toLazy-#endif -- binary instance Binary a => Binary (Maybe a) where@@ -203,8 +162,6 @@ liftHashWithSalt hashA salt = liftHashWithSalt hashA salt . toLazy -- Data.Functor.Classes-#ifdef LIFTED_FUNCTOR_CLASSES- instance Eq1 Maybe where liftEq f (Just a) (Just a') = f a a' liftEq _ Nothing Nothing = True@@ -232,10 +189,3 @@ (a, s2) <- ra 11 s1 return (Just a, s2) _ -> []--#else-instance Eq1 Maybe where eq1 = (==)-instance Ord1 Maybe where compare1 = compare-instance Show1 Maybe where showsPrec1 = showsPrec-instance Read1 Maybe where readsPrec1 = readsPrec-#endif
src/Data/Strict/These.hs view
@@ -1,21 +1,8 @@-{-# LANGUAGE CPP #-} {-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE DeriveGeneric #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE Safe #-} -#if MIN_VERSION_base(4,9,0)-#define LIFTED_FUNCTOR_CLASSES 1-#else-#if MIN_VERSION_transformers(0,5,0)-#define LIFTED_FUNCTOR_CLASSES 1-#else-#if MIN_VERSION_transformers_compat(0,5,0) && !MIN_VERSION_transformers(0,4,0)-#define LIFTED_FUNCTOR_CLASSES 1-#endif-#endif-#endif- module Data.Strict.These ( These(..) @@ -62,37 +49,21 @@ import qualified Data.These as L -#if MIN_VERSION_deepseq(1,4,3) import Control.DeepSeq (NFData1 (..), NFData2 (..))-#endif--#if __GLASGOW_HASKELL__ >= 706 import GHC.Generics (Generic1)-#endif--#ifdef MIN_VERSION_assoc import Data.Bifunctor.Assoc (Assoc (..)) import Data.Bifunctor.Swap (Swap (..))-#endif -#ifdef LIFTED_FUNCTOR_CLASSES import Data.Functor.Classes (Eq1 (..), Eq2 (..), Ord1 (..), Ord2 (..), Read1 (..), Read2 (..), Show1 (..), Show2 (..))-#else-import Data.Functor.Classes (Eq1 (..), Ord1 (..), Read1 (..), Show1 (..))-#endif -- $setup -- >>> import Prelude (map) -- | The strict these type. data These a b = This !a | That !b | These !a !b- deriving (Eq, Ord, Read, Show, Typeable, Data, Generic-#if __GLASGOW_HASKELL__ >= 706- , Generic1-#endif- )+ deriving (Eq, Ord, Read, Show, Typeable, Data, Generic, Generic1) toStrict :: L.These a b -> These a b toStrict (L.This x) = This x@@ -282,7 +253,6 @@ -- Data.Functor.Classes ------------------------------------------------------------------------------- -#ifdef LIFTED_FUNCTOR_CLASSES instance Eq2 These where liftEq2 f _ (This a) (This a') = f a a' liftEq2 _ g (That b) (That b') = g b b'@@ -341,18 +311,10 @@ instance Read a => Read1 (These a) where liftReadsPrec = liftReadsPrec2 readsPrec readList -#else-instance Eq a => Eq1 (These a) where eq1 = (==)-instance Ord a => Ord1 (These a) where compare1 = compare-instance Show a => Show1 (These a) where showsPrec1 = showsPrec-instance Read a => Read1 (These a) where readsPrec1 = readsPrec-#endif- ------------------------------------------------------------------------------- -- assoc ------------------------------------------------------------------------------- -#ifdef MIN_VERSION_assoc instance Swap These where swap (This a) = That a swap (That b) = This b@@ -374,7 +336,6 @@ unassoc (These a (This b)) = This (These a b) unassoc (These a (That c)) = These (This a) c unassoc (These a (These b c)) = These (These a b) c-#endif ------------------------------------------------------------------------------- -- deepseq@@ -385,7 +346,6 @@ rnf (That b) = rnf b rnf (These a b) = rnf a `seq` rnf b -#if MIN_VERSION_deepseq(1,4,3) instance NFData a => NFData1 (These a) where liftRnf _rnfB (This a) = rnf a liftRnf rnfB (That b) = rnfB b@@ -395,7 +355,6 @@ liftRnf2 rnfA _rnfB (This a) = rnfA a liftRnf2 _rnfA rnfB (That b) = rnfB b liftRnf2 rnfA rnfB (These a b) = rnfA a `seq` rnfB b-#endif ------------------------------------------------------------------------------- -- binary
src/Data/Strict/Tuple.hs view
@@ -1,24 +1,8 @@-{-# LANGUAGE CPP #-} {-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE Safe #-} {-# LANGUAGE DeriveGeneric #-}-#ifndef __HADDOCK__-#ifdef __GLASGOW_HASKELL__ {-# LANGUAGE TypeOperators #-}-#endif-#endif -#if MIN_VERSION_base(4,9,0)-#define LIFTED_FUNCTOR_CLASSES 1-#else-#if MIN_VERSION_transformers(0,5,0)-#define LIFTED_FUNCTOR_CLASSES 1-#else-#if MIN_VERSION_transformers_compat(0,5,0) && !MIN_VERSION_transformers(0,4,0)-#define LIFTED_FUNCTOR_CLASSES 1-#endif-#endif-#endif ----------------------------------------------------------------------------- -- |@@ -32,11 +16,7 @@ module Data.Strict.Tuple ( Pair(..)-#ifndef __HADDOCK__-#ifdef __GLASGOW_HASKELL__- , (:!:)-#endif-#endif+ , type (:!:) , fst , snd , curry@@ -58,42 +38,23 @@ -- Lazy variants import qualified Prelude as L -import Control.DeepSeq (NFData (..))-import Data.Bifoldable (Bifoldable (..))-import Data.Bifunctor (Bifunctor (..))-import Data.Binary (Binary (..))-import Data.Bitraversable (Bitraversable (..))-import Data.Hashable (Hashable(..))-import Data.Hashable.Lifted (Hashable1 (..), Hashable2 (..))-import Data.Ix (Ix (..))-import GHC.Generics (Generic)-import Data.Data (Data (..), Typeable)--#if __GLASGOW_HASKELL__ >= 706-import GHC.Generics (Generic1)-#endif--#if MIN_VERSION_deepseq(1,4,3)-import Control.DeepSeq (NFData1 (..), NFData2 (..))-#endif--#ifdef MIN_VERSION_assoc+import Control.DeepSeq (NFData (..), NFData1 (..), NFData2 (..))+import Data.Bifoldable (Bifoldable (..))+import Data.Bifunctor (Bifunctor (..)) import Data.Bifunctor.Assoc (Assoc (..)) import Data.Bifunctor.Swap (Swap (..))-#endif+import Data.Binary (Binary (..))+import Data.Bitraversable (Bitraversable (..))+import Data.Data (Data (..), Typeable)+import Data.Hashable (Hashable(..))+import Data.Hashable.Lifted (Hashable1 (..), Hashable2 (..))+import Data.Ix (Ix (..))+import GHC.Generics (Generic, Generic1) -#ifdef LIFTED_FUNCTOR_CLASSES import Data.Functor.Classes (Eq1 (..), Eq2 (..), Ord1 (..), Ord2 (..), Read1 (..), Read2 (..), Show1 (..), Show2 (..))-#else-import Data.Functor.Classes (Eq1 (..), Ord1 (..), Read1 (..), Show1 (..))-#endif -#if __HADDOCK__-import Data.Tuple ()-#endif- -- $setup -- >>> import Prelude (Char, String) -- >>> import Data.Functor.Classes (readsPrec2)@@ -102,18 +63,10 @@ -- | The type of strict pairs. data Pair a b = !a :!: !b- deriving (Eq, Ord, Read, Show, Typeable, Data, Generic, Bounded, Ix-#if __GLASGOW_HASKELL__ >= 706- , Generic1-#endif- )+ deriving (Eq, Ord, Read, Show, Typeable, Data, Generic, Bounded, Ix, Generic1) -#ifndef __HADDOCK__-#ifdef __GLASGOW_HASKELL__ -- This gives a nicer syntax for the type but only works in GHC for now. type (:!:) = Pair-#endif-#endif toStrict :: (a, b) -> Pair a b toStrict (a, b) = a :!: b@@ -174,13 +127,11 @@ instance (NFData a, NFData b) => NFData (Pair a b) where rnf = rnf . toLazy -#if MIN_VERSION_deepseq(1,4,3) instance (NFData a) => NFData1 (Pair a) where liftRnf rnfA = liftRnf rnfA . toLazy instance NFData2 Pair where liftRnf2 rnfA rnfB = liftRnf2 rnfA rnfB . toLazy-#endif -- binary instance (Binary a, Binary b) => Binary (Pair a b) where@@ -213,17 +164,14 @@ liftHashWithSalt2 hashA hashB salt = liftHashWithSalt2 hashA hashB salt . toLazy -- assoc-#ifdef MIN_VERSION_assoc instance Assoc Pair where assoc ((a :!: b) :!: c) = (a :!: (b :!: c)) unassoc (a :!: (b :!: c)) = ((a :!: b) :!: c) instance Swap Pair where swap = Data.Strict.Tuple.swap-#endif -- Data.Functor.Classes-#ifdef LIFTED_FUNCTOR_CLASSES instance Eq2 Pair where liftEq2 f g (a :!: b) (a' :!: b') = f a a' && g b b' @@ -265,9 +213,3 @@ instance Read a => Read1 (Pair a) where liftReadsPrec = liftReadsPrec2 readsPrec readList-#else-instance Eq a => Eq1 (Pair a) where eq1 = (==)-instance Ord a => Ord1 (Pair a) where compare1 = compare-instance Show a => Show1 (Pair a) where showsPrec1 = showsPrec-instance Read a => Read1 (Pair a) where readsPrec1 = readsPrec-#endif
strict.cabal view
@@ -1,109 +1,98 @@-Name: strict-Version: 0.5-Synopsis: Strict data types and String IO.-Category: Data, System-Description:- This package provides strict versions of some standard Haskell data- types (pairs, Maybe and Either). It also contains strict IO operations.- .- It is common knowledge that lazy datastructures can lead to space-leaks.- This problem is particularly prominent, when using lazy datastructures to- store the state of a long-running application in memory. One common- solution to this problem is to use @seq@ and its variants in every piece of- code that updates your state. However a much easier solution is to use- fully strict types to store such state values. By \"fully strict types\" we- mean types for whose values it holds that, if they are in weak-head normal- form, then they are also in normal form. Intuitively, this means that- values of fully strict types cannot contain unevaluated thunks.- .- To define a fully strict datatype, one typically uses the following recipe.- .- 1. Make all fields of every constructor strict; i.e., add a bang to- all fields.- .- 2. Use only strict types for the fields of the constructors.- .- The second requirement is problematic as it rules out the use of- the standard Haskell 'Maybe', 'Either', and pair types. This library- solves this problem by providing strict variants of these types and their- corresponding standard support functions and type-class instances.- .- Note that this library does currently not provide fully strict lists.- They can be added if they are really required. However, in many cases one- probably wants to use unboxed or strict boxed vectors from the 'vector'- library (<http://hackage.haskell.org/package/vector>) instead of strict- lists. Moreover, instead of @String@s one probably wants to use strict- @Text@ values from the @text@ library- (<http://hackage.haskell.org/package/text>).- .- This library comes with batteries included; i.e., mirror functions and- instances of the lazy versions in @base@. It also includes instances for- type-classes from the @deepseq@, @binary@, and @hashable@ packages.-License: BSD3-License-File: LICENSE-Author: Roman Leshchinskiy <rl@cse.unsw.edu.au>- Simon Meier <iridcode@gmail.com>-Maintainer: Don Stewart <dons@galois.com>,- Bas van Dijk <v.dijk.bas@gmail.com>,- Oleg Grenrus <oleg.grenrus@iki.fi>,- Simon Meier <iridcode@gmail.com>,- Ximin Luo <infinity0@pwned.gg>-Copyright: (c) 2006-2008 by Roman Leshchinskiy- (c) 2013-2014 by Simon Meier-Homepage: https://github.com/haskell-strict/strict-Cabal-Version: >= 1.10-Build-type: Simple+name: strict+version: 0.5.1+synopsis: Strict data types and String IO.+category: Data, System+description:+ This package provides strict versions of some standard Haskell data+ types (pairs, Maybe and Either). It also contains strict IO operations.+ .+ It is common knowledge that lazy datastructures can lead to space-leaks.+ This problem is particularly prominent, when using lazy datastructures to+ store the state of a long-running application in memory. One common+ solution to this problem is to use @seq@ and its variants in every piece of+ code that updates your state. However a much easier solution is to use+ fully strict types to store such state values. By \"fully strict types\" we+ mean types for whose values it holds that, if they are in weak-head normal+ form, then they are also in normal form. Intuitively, this means that+ values of fully strict types cannot contain unevaluated thunks.+ .+ To define a fully strict datatype, one typically uses the following recipe.+ .+ 1. Make all fields of every constructor strict; i.e., add a bang to+ all fields.+ .+ 2. Use only strict types for the fields of the constructors.+ .+ The second requirement is problematic as it rules out the use of+ the standard Haskell 'Maybe', 'Either', and pair types. This library+ solves this problem by providing strict variants of these types and their+ corresponding standard support functions and type-class instances.+ .+ Note that this library does currently not provide fully strict lists.+ They can be added if they are really required. However, in many cases one+ probably wants to use unboxed or strict boxed vectors from the 'vector'+ library (<http://hackage.haskell.org/package/vector>) instead of strict+ lists. Moreover, instead of @String@s one probably wants to use strict+ @Text@ values from the @text@ library+ (<http://hackage.haskell.org/package/text>).+ .+ This library comes with batteries included; i.e., mirror functions and+ instances of the lazy versions in @base@. It also includes instances for+ type-classes from the @deepseq@, @binary@, and @hashable@ packages.++license: BSD3+license-file: LICENSE+author:+ Roman Leshchinskiy <rl@cse.unsw.edu.au>+ Simon Meier <iridcode@gmail.com>++maintainer:+ Don Stewart <dons@galois.com>,+ Bas van Dijk <v.dijk.bas@gmail.com>,+ Oleg Grenrus <oleg.grenrus@iki.fi>,+ Simon Meier <iridcode@gmail.com>,+ Ximin Luo <infinity0@pwned.gg>++copyright:+ (c) 2006-2008 by Roman Leshchinskiy+ (c) 2013-2014 by Simon Meier++homepage: https://github.com/haskell-strict/strict+cabal-version: >=1.10+build-type: Simple extra-source-files: CHANGELOG.md tested-with:- GHC ==7.4.2- || ==7.6.3- || ==7.8.4- || ==7.10.3- || ==8.0.2- || ==8.2.2- || ==8.4.4- || ==8.6.5+ GHC ==8.6.5 || ==8.8.4 || ==8.10.7 || ==9.0.2- || ==9.2.4- || ==9.4.2+ || ==9.2.8+ || ==9.4.8+ || ==9.6.6+ || ==9.8.2+ || ==9.10.1 library default-language: Haskell2010 hs-source-dirs: src ghc-options: -Wall- build-depends:- base >= 4.5.0.0 && < 5- , assoc >= 1.1 && < 1.2- , binary >= 0.5.1.0 && < 0.9- , bytestring >= 0.9.2.1 && < 0.12- , deepseq >= 1.3.0.0 && < 1.5- , hashable >= 1.2.7.0 && < 1.5- , text >= 1.2.3.0 && < 1.3 || >=2.0 && <2.1- , these >= 1.2 && < 1.3- , transformers >= 0.3.0.0 && < 0.7+ assoc >=1.1.1 && <1.2+ , base >=4.12.0.0 && <5+ , binary >=0.8.6.0 && <0.9+ , bytestring >=0.10.8.2 && <0.13+ , deepseq >=1.4.4.0 && <1.6 , ghc-prim-- if !impl(ghc >= 8.0)- build-depends:- semigroups >= 0.18.5 && < 0.21- , transformers-compat >= 0.6.5 && < 0.8-- -- Ensure Data.Functor.Classes is always available- if impl(ghc >= 7.10)- build-depends: transformers >= 0.4.2.0-- if !impl(ghc >= 8.2)- build-depends:- bifunctor-classes-compat >= 0.1 && < 0.2+ , hashable >=1.4.7.0 && <1.5+ , text >=1.2.3.1 && <1.3 || >=2.0 && <2.2+ , these >=1.2.1 && <1.3+ , transformers >=0.5.6.2 && <0.7 exposed-modules: Data.Strict Data.Strict.Classes+ Data.Strict.Either+ Data.Strict.Maybe Data.Strict.These Data.Strict.Tuple- Data.Strict.Maybe- Data.Strict.Either System.IO.Strict