Script 'mail_helper' called by obssrc Hello community, here is the log from the commit of package ghc-strict for openSUSE:Factory checked in at 2024-07-22 17:16:43 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/ghc-strict (Old) and /work/SRC/openSUSE:Factory/.ghc-strict.new.17339 (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Package is "ghc-strict" Mon Jul 22 17:16:43 2024 rev:11 rq:1188657 version:0.5.1 Changes: -------- --- /work/SRC/openSUSE:Factory/ghc-strict/ghc-strict.changes 2023-10-13 23:16:01.593965170 +0200 +++ /work/SRC/openSUSE:Factory/.ghc-strict.new.17339/ghc-strict.changes 2024-07-22 17:17:46.984748977 +0200 @@ -1,0 +2,8 @@ +Wed Jul 3 09:43:41 UTC 2024 - Peter Simons <psimons@suse.com> + +- Update strict to version 0.5.1. + # 0.5.1 + + - Support GHC-8.6.5...GHC-9.10.1 + +------------------------------------------------------------------- Old: ---- strict-0.5.tar.gz strict.cabal New: ---- strict-0.5.1.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ ghc-strict.spec ++++++ --- /var/tmp/diff_new_pack.BPwAWm/_old 2024-07-22 17:17:49.548852085 +0200 +++ /var/tmp/diff_new_pack.BPwAWm/_new 2024-07-22 17:17:49.548852085 +0200 @@ -1,7 +1,7 @@ # # spec file for package ghc-strict # -# Copyright (c) 2023 SUSE LLC +# Copyright (c) 2024 SUSE LLC # # All modifications and additions to the file contributed by third parties # remain the property of their copyright owners, unless otherwise agreed @@ -19,13 +19,12 @@ %global pkg_name strict %global pkgver %{pkg_name}-%{version} Name: ghc-%{pkg_name} -Version: 0.5 +Version: 0.5.1 Release: 0 Summary: Strict data types and String IO License: BSD-3-Clause URL: https://hackage.haskell.org/package/%{pkg_name} Source0: https://hackage.haskell.org/package/%{pkg_name}-%{version}/%{pkg_name}-%{version}.tar.gz -Source1: https://hackage.haskell.org/package/%{pkg_name}-%{version}/revision/1.cabal#/%{pkg_name}.cabal BuildRequires: ghc-Cabal-devel BuildRequires: ghc-assoc-devel BuildRequires: ghc-assoc-prof @@ -112,7 +111,6 @@ %prep %autosetup -n %{pkg_name}-%{version} -cp -p %{SOURCE1} %{pkg_name}.cabal %build %ghc_lib_build ++++++ strict-0.5.tar.gz -> strict-0.5.1.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/strict-0.5/CHANGELOG.md new/strict-0.5.1/CHANGELOG.md --- old/strict-0.5/CHANGELOG.md 2001-09-09 03:46:40.000000000 +0200 +++ new/strict-0.5.1/CHANGELOG.md 2001-09-09 03:46:40.000000000 +0200 @@ -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` diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/strict-0.5/src/Data/Strict/Classes.hs new/strict-0.5.1/src/Data/Strict/Classes.hs --- old/strict-0.5/src/Data/Strict/Classes.hs 2001-09-09 03:46:40.000000000 +0200 +++ new/strict-0.5.1/src/Data/Strict/Classes.hs 2001-09-09 03:46:40.000000000 +0200 @@ -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 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/strict-0.5/src/Data/Strict/Either.hs new/strict-0.5.1/src/Data/Strict/Either.hs --- old/strict-0.5/src/Data/Strict/Either.hs 2001-09-09 03:46:40.000000000 +0200 +++ new/strict-0.5.1/src/Data/Strict/Either.hs 2001-09-09 03:46:40.000000000 +0200 @@ -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 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/strict-0.5/src/Data/Strict/Maybe.hs new/strict-0.5.1/src/Data/Strict/Maybe.hs --- old/strict-0.5/src/Data/Strict/Maybe.hs 2001-09-09 03:46:40.000000000 +0200 +++ new/strict-0.5.1/src/Data/Strict/Maybe.hs 2001-09-09 03:46:40.000000000 +0200 @@ -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 +import GHC.Generics (Generic, Generic1) -#if MIN_VERSION_deepseq(1,4,3) -import Control.DeepSeq (NFData1 (..)) -#endif - -#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,17 +127,8 @@ 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 @@ -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 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/strict-0.5/src/Data/Strict/These.hs new/strict-0.5.1/src/Data/Strict/These.hs --- old/strict-0.5/src/Data/Strict/These.hs 2001-09-09 03:46:40.000000000 +0200 +++ new/strict-0.5.1/src/Data/Strict/These.hs 2001-09-09 03:46:40.000000000 +0200 @@ -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 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/strict-0.5/src/Data/Strict/Tuple.hs new/strict-0.5.1/src/Data/Strict/Tuple.hs --- old/strict-0.5/src/Data/Strict/Tuple.hs 2001-09-09 03:46:40.000000000 +0200 +++ new/strict-0.5.1/src/Data/Strict/Tuple.hs 2001-09-09 03:46:40.000000000 +0200 @@ -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,41 +38,22 @@ -- 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) @@ -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 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/strict-0.5/strict.cabal new/strict-0.5.1/strict.cabal --- old/strict-0.5/strict.cabal 2001-09-09 03:46:40.000000000 +0200 +++ new/strict-0.5.1/strict.cabal 2001-09-09 03:46:40.000000000 +0200 @@ -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