data-default-0.8.0.1/0000755000000000000000000000000007346545000012402 5ustar0000000000000000data-default-0.8.0.1/Changes.md0000644000000000000000000000564407346545000014305 0ustar0000000000000000Version history for `data-default` ================================== ## 0.8.0.1 -- 2025-03-16 - Add a changelog file. - Add an official bug tracker. - Switch upstream to codeberg.org. ## 0.8.0.0 -- 2024-10-23 - The split into multiple packages (`data-default-class`, `data-default-instances-*`) is gone. There is only `data-default` now (with no dependencies on `data-default-class` or anything). - `data-default` only depends on `containers` and `base` now (but requires `base >= 4.8`). - The `Default` instances for `Data.DList` and `System.Locale` are gone (but could be revived with updated versions of `data-default-instances-dlist` and `data-default-instances-old-locale` in the future?). - The `Default` instances for `e -> a` and `IO a` have been removed. - The "generic" default `Default` instance now supports sum types as well (by always choosing the left constructor). - The internal `GDefault` type is now semi-public (in the `Data.Default.Internal` module) and has stub documentation. - New instances: - Tuples of size up to 31 (previously 7) - `Identity` - `Const` - `Proxy` - `Solo` - `Bool` - `CBool` - `Ptr` - `ConstPtr` - `FunPtr` - `IntPtr` - `WordPtr` ## 0.7.1.3 -- 2024-10-17 - Add upper version bounds on all dependencies. - Add cabal description. ## 0.7.1.2 -- 2024-10-13 - Add proper haddock module headers in each module. - Update `.cabal` file to `cabal-version: 3.0` format. - No changes to the license itself, but keep the wording/formatting consistent in all license files/headers/tags. - Make the (rudimentary) test runnable by cabal and add it to the `.cabal` file. ## 0.7.1.1 -- 2016-06-25 - Remove `data-default-instances-base` dependency. ## 0.7.1 -- 2016-06-12 - Support `GHC.Generics` in ghc 7.4 (previously: 7.6+). ## 0.7.0 -- 2016-05-21 - Add instances for the numeric types from `Foreign.C.Types`. ## 0.6.0 -- 2016-04-17 - Add support for `GHC.Generics` in ghc 7.6+. ## 0.5.2 -- 2016-04-02 - Split code into several packages (`data-default-class`, `data-default-instances-*`), which `data-default` simply re-exports. ## 0.5.1 -- 2013-03-07 - Add instances for tuples of length 6 and 7. ## 0.5.0 -- 2012-06-18 - Add instances for types in `Data.Int` and `Data.Word`. ## 0.4.0 -- 2012-03-30 - Add `Complex` instance. - Add `TimeLocale` instance (from `old-locale`). ## 0.3.0 -- 2011-08-08 - Add instances for `IntMap`, `IntSet`, `Seq`, and `Tree` (from `containers`). - Add internal basic tests. - Track changes in git. - Add instances for `Ordering`, `All`, `Any`, `Dual`, `Endo`, `Sum`, `Product`. `First`, `Last`, `DList`. - Add instances for tuples of length 2 to 5. ## 0.2.0.1 -- 2011-01-02 - Add `LICENSE` file. - Add version bounds on `base` dependency. ## 0.2 -- 2008-05-21 - Initial upload. - Instances provided: `Double`, `Float`, `Int`, `Integer`, `()`, `[a]`, `Ratio`, `IO`, `Maybe`, `Set`, `e -> a`, `Map`. data-default-0.8.0.1/Data/0000755000000000000000000000000007346545000013253 5ustar0000000000000000data-default-0.8.0.1/Data/Default.hs0000644000000000000000000000353107346545000015175 0ustar0000000000000000{- Copyright (c) 2013, Lukas Mai 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 Lukas Mai 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.Default Description : A class for types with a default value. This module defines a class for types with a default value. Instances are provided for @()@, 'Data.Set.Set', 'Data.Map.Map', 'Int', 'Integer', 'Float', 'Double', and many others (see below). -} module Data.Default ( Default(..) ) where import Data.Default.Internal data-default-0.8.0.1/Data/Default/0000755000000000000000000000000007346545000014637 5ustar0000000000000000data-default-0.8.0.1/Data/Default/Internal.hs0000644000000000000000000004443307346545000016757 0ustar0000000000000000{- Copyright (c) 2013, Lukas Mai 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 Lukas Mai 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. -} {-# LANGUAGE CPP #-} {-# LANGUAGE DefaultSignatures, TypeOperators, FlexibleContexts #-} {-| Module : Data.Default.Internal Description : Implementation details. Nothing to see here. -} module Data.Default.Internal (Default(..), GDefault(..)) where import Data.Int import Data.Word import Data.Monoid import Data.Ratio import Data.Complex import Data.Fixed import Foreign.C.Types #if MIN_VERSION_base(4, 18, 0) import Foreign.C.ConstPtr #endif import Foreign.Ptr import Data.Proxy import Data.Functor.Identity import Control.Applicative (Const(..)) #if MIN_VERSION_base(4, 16, 0) import Data.Tuple #endif import qualified Data.Set as S import qualified Data.Map as M import Data.IntMap (IntMap) import Data.IntSet (IntSet) import Data.Sequence (Seq) import Data.Tree (Tree(..)) import GHC.Generics -- | Defaults, generically. class GDefault f where gdef :: f a -- | A nullary constructor is its own default. instance GDefault U1 where gdef = U1 -- | A unary constructor wraps the default value of the argument type. instance (Default a) => GDefault (K1 i a) where gdef = K1 def -- | Default of products = product of defaults. instance (GDefault a, GDefault b) => GDefault (a :*: b) where gdef = gdef :*: gdef -- | For sums, we arbitrarily choose the left side. instance (GDefault a) => GDefault (a :+: b) where gdef = L1 gdef -- | Default of wrapper = wrapper of default. instance (GDefault a) => GDefault (M1 i c a) where gdef = M1 gdef -- | A class for types with a default value. class Default a where -- | The default value for this type. def :: a default def :: (Generic a, GDefault (Rep a)) => a def = to gdef instance Default Bool where def = False instance Default Int where def = 0 instance Default Int8 where def = 0 instance Default Int16 where def = 0 instance Default Int32 where def = 0 instance Default Int64 where def = 0 instance Default Word where def = 0 instance Default Word8 where def = 0 instance Default Word16 where def = 0 instance Default Word32 where def = 0 instance Default Word64 where def = 0 instance Default Integer where def = 0 instance Default Float where def = 0 instance Default Double where def = 0 instance (Integral a) => Default (Ratio a) where def = 0 instance (Default a, RealFloat a) => Default (Complex a) where def = def :+ def instance (HasResolution a) => Default (Fixed a) where def = 0 #if MIN_VERSION_base(4, 10, 0) instance Default CBool where def = 0 #endif instance Default CShort where def = 0 instance Default CUShort where def = 0 instance Default CInt where def = 0 instance Default CUInt where def = 0 instance Default CLong where def = 0 instance Default CULong where def = 0 instance Default CLLong where def = 0 instance Default CULLong where def = 0 instance Default CPtrdiff where def = 0 instance Default CSize where def = 0 instance Default CSigAtomic where def = 0 instance Default CIntPtr where def = 0 instance Default CUIntPtr where def = 0 instance Default CIntMax where def = 0 instance Default CUIntMax where def = 0 instance Default CClock where def = 0 instance Default CTime where def = 0 instance Default CUSeconds where def = 0 instance Default CSUSeconds where def = 0 instance Default CFloat where def = 0 instance Default CDouble where def = 0 instance Default (Ptr a) where def = nullPtr instance Default (FunPtr a) where def = nullFunPtr instance Default IntPtr where def = ptrToIntPtr def instance Default WordPtr where def = ptrToWordPtr def #if MIN_VERSION_base(4, 18, 0) instance Default (ConstPtr a) where def = ConstPtr def #endif instance Default (Maybe a) where def = Nothing instance (Default a) => Default (Identity a) where def = Identity def instance (Default a) => Default (Const a b) where def = Const def instance Default () where def = mempty instance Default [a] where def = mempty instance Default Ordering where def = mempty instance Default Any where def = mempty instance Default All where def = mempty instance Default (Last a) where def = mempty instance Default (First a) where def = mempty instance (Num a) => Default (Sum a) where def = mempty instance (Num a) => Default (Product a) where def = mempty instance Default (Endo a) where def = mempty instance Default (Proxy a) where def = mempty #if MIN_VERSION_base(4, 16, 0) instance (Default a) => Default (Solo a) where def = pure def #endif instance (Default a) => Default (Dual a) where def = Dual def instance Default (S.Set v) where def = S.empty instance Default (M.Map k v) where def = M.empty instance Default (IntMap v) where def = mempty instance Default IntSet where def = mempty instance Default (Seq a) where def = mempty instance (Default a) => Default (Tree a) where def = Node def [] instance (Default a1, Default a2) => Default (a1, a2) where def = (def, def) instance (Default a1, Default a2, Default a3) => Default (a1, a2, a3) where def = (def, def, def) instance (Default a1, Default a2, Default a3, Default a4) => Default (a1, a2, a3, a4) where def = (def, def, def, def) instance (Default a1, Default a2, Default a3, Default a4, Default a5) => Default (a1, a2, a3, a4, a5) where def = (def, def, def, def, def) instance (Default a1, Default a2, Default a3, Default a4, Default a5, Default a6) => Default (a1, a2, a3, a4, a5, a6) where def = (def, def, def, def, def, def) instance (Default a1, Default a2, Default a3, Default a4, Default a5, Default a6, Default a7) => Default (a1, a2, a3, a4, a5, a6, a7) where def = (def, def, def, def, def, def, def) instance (Default a1, Default a2, Default a3, Default a4, Default a5, Default a6, Default a7, Default a8) => Default (a1, a2, a3, a4, a5, a6, a7, a8) where def = (def, def, def, def, def, def, def, def) instance (Default a1, Default a2, Default a3, Default a4, Default a5, Default a6, Default a7, Default a8, Default a9) => Default (a1, a2, a3, a4, a5, a6, a7, a8, a9) where def = (def, def, def, def, def, def, def, def, def) instance (Default a1, Default a2, Default a3, Default a4, Default a5, Default a6, Default a7, Default a8, Default a9, Default a10) => Default (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) where def = (def, def, def, def, def, def, def, def, def, def) instance (Default a1, Default a2, Default a3, Default a4, Default a5, Default a6, Default a7, Default a8, Default a9, Default a10, Default a11) => Default (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) where def = (def, def, def, def, def, def, def, def, def, def, def) instance (Default a1, Default a2, Default a3, Default a4, Default a5, Default a6, Default a7, Default a8, Default a9, Default a10, Default a11, Default a12) => Default (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) where def = (def, def, def, def, def, def, def, def, def, def, def, def) instance (Default a1, Default a2, Default a3, Default a4, Default a5, Default a6, Default a7, Default a8, Default a9, Default a10, Default a11, Default a12, Default a13) => Default (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13) where def = (def, def, def, def, def, def, def, def, def, def, def, def, def) instance (Default a1, Default a2, Default a3, Default a4, Default a5, Default a6, Default a7, Default a8, Default a9, Default a10, Default a11, Default a12, Default a13, Default a14) => Default (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14) where def = (def, def, def, def, def, def, def, def, def, def, def, def, def, def) instance (Default a1, Default a2, Default a3, Default a4, Default a5, Default a6, Default a7, Default a8, Default a9, Default a10, Default a11, Default a12, Default a13, Default a14, Default a15) => Default (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15) where def = (def, def, def, def, def, def, def, def, def, def, def, def, def, def, def) instance (Default a1, Default a2, Default a3, Default a4, Default a5, Default a6, Default a7, Default a8, Default a9, Default a10, Default a11, Default a12, Default a13, Default a14, Default a15, Default a16) => Default (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16) where def = (def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def) instance (Default a1, Default a2, Default a3, Default a4, Default a5, Default a6, Default a7, Default a8, Default a9, Default a10, Default a11, Default a12, Default a13, Default a14, Default a15, Default a16, Default a17) => Default (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17) where def = (def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def) instance (Default a1, Default a2, Default a3, Default a4, Default a5, Default a6, Default a7, Default a8, Default a9, Default a10, Default a11, Default a12, Default a13, Default a14, Default a15, Default a16, Default a17, Default a18) => Default (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18) where def = (def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def) instance (Default a1, Default a2, Default a3, Default a4, Default a5, Default a6, Default a7, Default a8, Default a9, Default a10, Default a11, Default a12, Default a13, Default a14, Default a15, Default a16, Default a17, Default a18, Default a19) => Default (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19) where def = (def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def) instance (Default a1, Default a2, Default a3, Default a4, Default a5, Default a6, Default a7, Default a8, Default a9, Default a10, Default a11, Default a12, Default a13, Default a14, Default a15, Default a16, Default a17, Default a18, Default a19, Default a20) => Default (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20) where def = (def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def) instance (Default a1, Default a2, Default a3, Default a4, Default a5, Default a6, Default a7, Default a8, Default a9, Default a10, Default a11, Default a12, Default a13, Default a14, Default a15, Default a16, Default a17, Default a18, Default a19, Default a20, Default a21) => Default (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21) where def = (def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def) instance (Default a1, Default a2, Default a3, Default a4, Default a5, Default a6, Default a7, Default a8, Default a9, Default a10, Default a11, Default a12, Default a13, Default a14, Default a15, Default a16, Default a17, Default a18, Default a19, Default a20, Default a21, Default a22) => Default (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22) where def = (def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def) instance (Default a1, Default a2, Default a3, Default a4, Default a5, Default a6, Default a7, Default a8, Default a9, Default a10, Default a11, Default a12, Default a13, Default a14, Default a15, Default a16, Default a17, Default a18, Default a19, Default a20, Default a21, Default a22, Default a23) => Default (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23) where def = (def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def) instance (Default a1, Default a2, Default a3, Default a4, Default a5, Default a6, Default a7, Default a8, Default a9, Default a10, Default a11, Default a12, Default a13, Default a14, Default a15, Default a16, Default a17, Default a18, Default a19, Default a20, Default a21, Default a22, Default a23, Default a24) => Default (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24) where def = (def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def) instance (Default a1, Default a2, Default a3, Default a4, Default a5, Default a6, Default a7, Default a8, Default a9, Default a10, Default a11, Default a12, Default a13, Default a14, Default a15, Default a16, Default a17, Default a18, Default a19, Default a20, Default a21, Default a22, Default a23, Default a24, Default a25) => Default (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25) where def = (def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def) instance (Default a1, Default a2, Default a3, Default a4, Default a5, Default a6, Default a7, Default a8, Default a9, Default a10, Default a11, Default a12, Default a13, Default a14, Default a15, Default a16, Default a17, Default a18, Default a19, Default a20, Default a21, Default a22, Default a23, Default a24, Default a25, Default a26) => Default (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26) where def = (def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def) instance (Default a1, Default a2, Default a3, Default a4, Default a5, Default a6, Default a7, Default a8, Default a9, Default a10, Default a11, Default a12, Default a13, Default a14, Default a15, Default a16, Default a17, Default a18, Default a19, Default a20, Default a21, Default a22, Default a23, Default a24, Default a25, Default a26, Default a27) => Default (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27) where def = (def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def) instance (Default a1, Default a2, Default a3, Default a4, Default a5, Default a6, Default a7, Default a8, Default a9, Default a10, Default a11, Default a12, Default a13, Default a14, Default a15, Default a16, Default a17, Default a18, Default a19, Default a20, Default a21, Default a22, Default a23, Default a24, Default a25, Default a26, Default a27, Default a28) => Default (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28) where def = (def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def) instance (Default a1, Default a2, Default a3, Default a4, Default a5, Default a6, Default a7, Default a8, Default a9, Default a10, Default a11, Default a12, Default a13, Default a14, Default a15, Default a16, Default a17, Default a18, Default a19, Default a20, Default a21, Default a22, Default a23, Default a24, Default a25, Default a26, Default a27, Default a28, Default a29) => Default (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29) where def = (def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def) instance (Default a1, Default a2, Default a3, Default a4, Default a5, Default a6, Default a7, Default a8, Default a9, Default a10, Default a11, Default a12, Default a13, Default a14, Default a15, Default a16, Default a17, Default a18, Default a19, Default a20, Default a21, Default a22, Default a23, Default a24, Default a25, Default a26, Default a27, Default a28, Default a29, Default a30) => Default (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30) where def = (def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def) instance (Default a1, Default a2, Default a3, Default a4, Default a5, Default a6, Default a7, Default a8, Default a9, Default a10, Default a11, Default a12, Default a13, Default a14, Default a15, Default a16, Default a17, Default a18, Default a19, Default a20, Default a21, Default a22, Default a23, Default a24, Default a25, Default a26, Default a27, Default a28, Default a29, Default a30, Default a31) => Default (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31) where def = (def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def, def) data-default-0.8.0.1/LICENSE0000644000000000000000000000275407346545000013417 0ustar0000000000000000Copyright (c) 2013, Lukas Mai 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 Lukas Mai 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. data-default-0.8.0.1/Setup.lhs0000644000000000000000000000013407346545000014210 0ustar0000000000000000#!/usr/bin/env runhaskell > import Distribution.Simple > main :: IO () > main = defaultMain data-default-0.8.0.1/data-default.cabal0000644000000000000000000000212607346545000015722 0ustar0000000000000000cabal-version: 3.0 name: data-default version: 0.8.0.1 category: Data synopsis: A class for types with a default value description: This module defines a class for types with a default value. Instances are provided for @()@, 'Data.Set.Set', 'Data.Map.Map', 'Int', 'Integer', 'Float', 'Double', and many others. build-type: Simple license: BSD-3-Clause license-file: LICENSE copyright: (c) 2013 Lukas Mai author: Lukas Mai maintainer: bug-reports: https://codeberg.org/mauke/data-default/issues extra-doc-files: Changes.md source-repository head type: git location: https://codeberg.org/mauke/data-default library build-depends: base >=4.8 && <5, containers >=0.1 && <0.8 exposed-modules: Data.Default, Data.Default.Internal default-language: Haskell98 test-suite test type: exitcode-stdio-1.0 main-is: basics.hs build-depends: base, containers, data-default, mtl hs-source-dirs: t default-language: Haskell98 data-default-0.8.0.1/t/0000755000000000000000000000000007346545000012645 5ustar0000000000000000data-default-0.8.0.1/t/basics.hs0000644000000000000000000001033107346545000014443 0ustar0000000000000000{-# LANGUAGE CPP #-} {-# LANGUAGE GeneralizedNewtypeDeriving #-} {-# LANGUAGE DeriveGeneric #-} import Data.Default import Data.Int import Data.Word import Data.Monoid import Data.Complex import qualified Data.Sequence as Seq import qualified Data.Map as M import qualified Data.Set as S import qualified Data.IntMap as IM import qualified Data.IntSet as IS import Data.Tree (Tree(..)) import Data.Functor.Identity import Control.Applicative import Data.Proxy #if MIN_VERSION_base(4, 16, 0) import Data.Tuple #endif import GHC.Generics import Foreign.C.Types import Foreign.Ptr #if MIN_VERSION_base(4, 18, 0) import Foreign.C.ConstPtr #endif import Control.Monad (when, join) import Control.Monad.Reader import Data.IORef import System.Exit (exitFailure) import System.IO data TestState = TestState { testState_count :: !(IORef Int) , testState_ok :: !(IORef Bool) } newtype Test a = Test{ unTest :: ReaderT TestState IO a } deriving (Functor, Applicative, Monad, MonadIO, MonadReader TestState) runTest :: (MonadIO m) => Test a -> m a runTest t = liftIO $ do hSetBuffering stdout LineBuffering rc <- newIORef 0 rk <- newIORef True x <- runReaderT (unTest t) TestState{ testState_count = rc, testState_ok = rk } c <- readIORef rc putStrLn $ "1.." ++ show c k <- readIORef rk when (not k) exitFailure pure x instance (Default a) => Default (Test a) where def = return def withRef :: (IORef Int -> IO () -> IO a) -> Test a withRef f = do TestState rc rk <- ask liftIO (f rc (atomicWriteIORef rk False)) ok :: Bool -> String -> Test () ok b s = withRef $ \ref lose -> do c <- atomicModifyIORef' ref (join (,) . succ) putStrLn $ (if b then "" else "not ") ++ "ok " ++ show c ++ " - " ++ s when (not b) lose is {-, isNot-} :: (Show a, Eq a) => a -> a -> Test () is x y = ok (x == y) (show x ++ " == " ++ show y) -- isNot x y = ok (x /= y) (show x ++ " /= " ++ show y) -- diag :: String -> Test () -- diag s = liftIO $ do -- putStrLn $ "# " ++ s data T0 a b = C0 a a | C1 | C2 b deriving (Eq, Show, Generic) instance (Default a) => Default (T0 a b) main :: IO () main = runTest $ do is def () is def (Nothing :: Maybe (Int, Ordering, [Float])) is def "" is def (S.empty :: S.Set ()) is def (M.empty :: M.Map () ()) is def IS.empty is def (IM.empty :: IM.IntMap ()) is def (Seq.empty :: Seq.Seq ()) is def (Node (0 :: Complex Float) []) is def EQ is def (Any False) is def (All True) is def (Last Nothing :: Last ()) is def (First Nothing :: First ()) is def (Sum (0 :: Integer)) is def (Product (1 :: Rational)) is def (Identity ()) is def (Const 0 :: Const Int Char) is def (Proxy :: Proxy Char) #if MIN_VERSION_base(4, 16, 0) is def (pure () :: Solo ()) #endif is def False is def (0 :: Int) is def (0 :: Integer) is def (0 :: Float) is def (0 :: Double) is def (0 :: Rational) is def (0 :: Complex Double) is def (0 :: Int8) is def (0 :: Int16) is def (0 :: Int32) is def (0 :: Int64) is def (0 :: Word) is def (0 :: Word8) is def (0 :: Word16) is def (0 :: Word32) is def (0 :: Word64) is def (0 :: CShort) is def (0 :: CUShort) is def (0 :: CInt) is def (0 :: CUInt) is def (0 :: CLong) is def (0 :: CULong) is def (0 :: CLLong) is def (0 :: CULLong) is def (0 :: CPtrdiff) is def (0 :: CSize) is def (0 :: CSigAtomic) is def (0 :: CIntPtr) is def (0 :: CUIntPtr) is def (0 :: CIntMax) is def (0 :: CUIntMax) is def (0 :: CClock) is def (0 :: CTime) is def (0 :: CUSeconds) is def (0 :: CSUSeconds) is def (0 :: CFloat) is def (0 :: CDouble) is def (0 :: IntPtr) is def (0 :: WordPtr) #if MIN_VERSION_base(4, 10, 0) is def (0 :: CBool) #endif is def nullPtr is def nullFunPtr #if MIN_VERSION_base(4, 18, 0) is def (ConstPtr nullPtr) #endif is def ((def, def) :: ((), Maybe ((), ()))) is def ((def, def, def) :: ((), Maybe ((), ()), [Ordering])) is def ((def, def, def, def) :: ((), Maybe ((), ()), [Ordering], Float)) is def ((def, def, def, def, def, def, def) :: ((), (), (), (), (), (), ())) is def (C0 0 0 :: T0 Int Char)