Hello community, here is the log from the commit of package ghc-nats for openSUSE:Factory checked in at 2015-05-21 08:11:42 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/ghc-nats (Old) and /work/SRC/openSUSE:Factory/.ghc-nats.new (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "ghc-nats" Changes: -------- --- /work/SRC/openSUSE:Factory/ghc-nats/ghc-nats.changes 2014-11-26 20:55:35.000000000 +0100 +++ /work/SRC/openSUSE:Factory/.ghc-nats.new/ghc-nats.changes 2015-05-21 08:11:44.000000000 +0200 @@ -1,0 +2,14 @@ +Tue Apr 21 20:11:08 UTC 2015 - [email protected] + +- update to version 1 +* Make `nats` a compat-package since `Numeric.Natural` moved to `base-4.8.0.0`. +* Better `readsPrec` handling when you try to feed it a negative number. Not it is a failed parse rather than an error. +* Added `Hashable` and `Data` support. +* Will build as full-fledged `Safe` Haskell if you configure with -f-hashable, merely `Trustworthy` otherwise. +* Allow for manual removal of the `hashable` dependency to support advanced sandbox users who explicitly want to avoid compiling certain dependencies + they know they aren't using. + We will fix bugs caused by any combination of these package flags, but the API of the package should be considered the default build + configuration with all of the package dependency flags enabled. +* Added support for GHC 7.8's `bitSizeMaybe` + +------------------------------------------------------------------- Old: ---- _service nats-0.1.2.tar.gz New: ---- nats-1.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ ghc-nats.spec ++++++ --- /var/tmp/diff_new_pack.QOKRBr/_old 2015-05-21 08:11:45.000000000 +0200 +++ /var/tmp/diff_new_pack.QOKRBr/_new 2015-05-21 08:11:45.000000000 +0200 @@ -1,7 +1,7 @@ # # spec file for package ghc-nats # -# Copyright (c) 2013 SUSE LINUX Products GmbH, Nuernberg, Germany. +# Copyright (c) 2015 SUSE LINUX GmbH, Nuernberg, Germany. # # All modifications and additions to the file contributed by third parties # remain the property of their copyright owners, unless otherwise agreed @@ -19,9 +19,9 @@ %global pkg_name nats Name: ghc-nats -Version: 0.1.2 +Version: 1 Release: 0 -Summary: Haskell 98 natural numbers +Summary: Natural numbers License: BSD-3-Clause Group: System/Libraries @@ -30,10 +30,11 @@ BuildRoot: %{_tmppath}/%{name}-%{version}-build BuildRequires: ghc-Cabal-devel +BuildRequires: ghc-hashable-devel BuildRequires: ghc-rpm-macros %description -Haskell 98 natural numbers. +Haskell natural numbers. %package devel ++++++ nats-0.1.2.tar.gz -> nats-1.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/nats-0.1.2/.travis.yml new/nats-1/.travis.yml --- old/nats-0.1.2/.travis.yml 2013-09-17 19:53:48.000000000 +0200 +++ new/nats-1/.travis.yml 2014-12-02 09:22:55.000000000 +0100 @@ -1,4 +1,63 @@ -language: haskell +# NB: don't set `language: haskell` here + +# See also https://github.com/hvr/multi-ghc-travis for more information +env: + - GHCVER=7.0.4 CABALVER=1.16 + # we have to use CABALVER=1.16 for GHC<7.6 as well, as there's + # no package for earlier cabal versions in the PPA + - GHCVER=7.4.2 CABALVER=1.16 + - GHCVER=7.6.3 CABALVER=1.16 OPTS="--constraint=hashable>=1.2" + - GHCVER=7.6.3 CABALVER=1.16 OPTS="--constraint=hashable<1.2" + - GHCVER=7.6.3 CABALVER=1.16 OPTS=-f-hashable + - GHCVER=7.8.3 CABALVER=1.18 OPTS="--constraint=hashable>=1.2" + - GHCVER=7.8.3 CABALVER=1.18 OPTS="--constraint=hashable<1.2" + - GHCVER=7.8.3 CABALVER=1.18 OPTS=-f-hashable + # NOTE: we can't use Cabal 1.20 yet due to + # https://github.com/haskell/cabal/issues/1806 + - GHCVER=head CABALVER=head + +matrix: + allow_failures: + - env: GHCVER=head CABALVER=head + +# Note: the distinction between `before_install` and `install` is not +# important. +before_install: + - travis_retry sudo add-apt-repository -y ppa:hvr/ghc + - travis_retry sudo apt-get update + - travis_retry sudo apt-get install cabal-install-$CABALVER ghc-$GHCVER + - export PATH=/opt/ghc/$GHCVER/bin:/opt/cabal/$CABALVER/bin:$PATH + - cabal --version + - echo "$(ghc --version) [$(ghc --print-project-git-commit-id 2> /dev/null || echo '?')]" + +install: + - travis_retry cabal update + - cabal install --only-dependencies + +# Here starts the actual work to be performed for the package under +# test; any command which exits with a non-zero exit code causes the +# build to fail. +script: + # -v2 provides useful information for debugging + - cabal configure -v2 $OPTS + + # this builds all libraries and executables + # (including tests/benchmarks) + - cabal build + + # tests that a source-distribution can be generated + - cabal sdist + + # check that the generated source-distribution can be built & installed + - export SRC_TGZ=$(cabal info . | awk '{print $2 ".tar.gz";exit}') ; + cd dist/; + if [ -f "$SRC_TGZ" ]; then + cabal install --force-reinstalls "$SRC_TGZ"; + else + echo "expected '$SRC_TGZ' not found"; + exit 1; + fi + notifications: irc: channels: diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/nats-0.1.2/CHANGELOG.markdown new/nats-1/CHANGELOG.markdown --- old/nats-0.1.2/CHANGELOG.markdown 2013-09-17 19:53:48.000000000 +0200 +++ new/nats-1/CHANGELOG.markdown 2014-12-02 09:22:55.000000000 +0100 @@ -1,3 +1,25 @@ +1.0 +--- +* Make `nats` a compat-package since `Numeric.Natural` moved to `base-4.8.0.0`. + +0.2.1 +----- +* Better `readsPrec` handling when you try to feed it a negative number. Not it is a failed parse rather than an error. + +0.2 +--- +* Added `Hashable` and `Data` support. +* Will build as full-fledged `Safe` Haskell if you configure with -f-hashable, merely `Trustworthy` otherwise. +* Allow for manual removal of the `hashable` dependency to support advanced sandbox users who explicitly want to avoid compiling certain dependencies + they know they aren't using. + + We will fix bugs caused by any combination of these package flags, but the API of the package should be considered the default build + configuration with all of the package dependency flags enabled. + +0.1.3 +----- +* Added support for GHC 7.8's `bitSizeMaybe` + 0.1 --- * Repository Initialized moving `Numeric.Natural` from `semigroups` 0.8.6 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/nats-0.1.2/LICENSE new/nats-1/LICENSE --- old/nats-0.1.2/LICENSE 2013-09-17 19:53:48.000000000 +0200 +++ new/nats-1/LICENSE 2014-12-02 09:22:55.000000000 +0100 @@ -1,4 +1,4 @@ -Copyright 2011 Edward Kmett +Copyright 2011-2014 Edward Kmett All rights reserved. diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/nats-0.1.2/README.markdown new/nats-1/README.markdown --- old/nats-0.1.2/README.markdown 2013-09-17 19:53:48.000000000 +0200 +++ new/nats-1/README.markdown 2014-12-02 09:22:55.000000000 +0100 @@ -1,7 +1,8 @@ nats ==== -[](http://travis-ci.org/ekmett/nats) +[](https://hackage.haskell.org/package/nats) +[](http://travis-ci.org/ekmett/nats) Haskell 98 natural numbers diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/nats-0.1.2/nats.cabal new/nats-1/nats.cabal --- old/nats-0.1.2/nats.cabal 2013-09-17 19:53:48.000000000 +0200 +++ new/nats-1/nats.cabal 2014-12-02 09:22:55.000000000 +0100 @@ -1,18 +1,17 @@ name: nats category: Numeric, Algebra -version: 0.1.2 +version: 1 license: BSD3 -cabal-version: >= 1.8 +cabal-version: >= 1.10 license-file: LICENSE author: Edward A. Kmett maintainer: Edward A. Kmett <[email protected]> stability: provisional homepage: http://github.com/ekmett/nats/ bug-reports: http://github.com/ekmett/nats/issues -copyright: Copyright (C) 2011-2013 Edward A. Kmett -synopsis: Haskell 98 natural numbers -description: - Haskell 98 natural numbers +copyright: Copyright (C) 2011-2014 Edward A. Kmett +synopsis: Natural numbers +description: Natural numbers build-type: Simple extra-source-files: .ghci @@ -26,15 +25,27 @@ type: git location: git://github.com/ekmett/nats.git -library - hs-source-dirs: src - - if !impl(hugs) - cpp-options: -DLANGUAGE_DeriveDataTypeable +flag hashable + description: + You can disable the use of the `hashable` package using `-f-hashable`. + . + Disabling this is an unsupported configuration, but it may be useful for accelerating builds in sandboxes for expert users. + . + If disabled we will not supply an instance of `Hashable` + default: True + manual: True - build-depends: base >= 2 && < 10 - ghc-options: -Wall +library + default-language: Haskell98 + if impl(ghc<7) + -- {-# LANGUAGE DeriveDataTypeable #-} is only understood starting w/ GHC-7.0 + default-extensions: DeriveDataTypeable - exposed-modules: - Numeric.Natural - Numeric.Natural.Internal + if !impl(ghc>=7.9) + -- Starting with GHC 7.10/base-4.8, "Numeric.Natural" lives in `base` + hs-source-dirs: src + exposed-modules: Numeric.Natural + ghc-options: -Wall + build-depends: base >= 2 && < 4.8 + if flag(hashable) + build-depends: hashable >= 1.1 && < 1.3 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/nats-0.1.2/src/Numeric/Natural/Internal.hs new/nats-1/src/Numeric/Natural/Internal.hs --- old/nats-0.1.2/src/Numeric/Natural/Internal.hs 2013-09-17 19:53:48.000000000 +0200 +++ new/nats-1/src/Numeric/Natural/Internal.hs 1970-01-01 01:00:00.000000000 +0100 @@ -1,186 +0,0 @@ -{-# LANGUAGE CPP #-} -#ifdef LANGUAGE_DeriveDataTypeable -{-# LANGUAGE DeriveDataTypeable #-} -#endif - -#ifndef MIN_VERSION_base -#define MIN_VERSION_base(x,y,z) 1 -#endif ------------------------------------------------------------------------------ --- | --- Module : Numeric.Natural.Internal --- Copyright : (C) 2011 Edward Kmett, --- License : BSD-style (see the file LICENSE) --- --- Maintainer : Edward Kmett <[email protected]> --- Stability : provisional --- Portability : portable --- --- This module exposes the potentially unsafe operations that are sometimes --- needed for efficiency: The Natural data constructor and unsafePred. --- ----------------------------------------------------------------------------- -module Numeric.Natural.Internal - ( Natural(..) - , Whole(..) - , natural - ) where - -import Data.Word -import Data.Bits -import Data.Ix -#ifdef LANGUAGE_DeriveDataTypeable -import Data.Typeable -#endif - -newtype Natural = Natural { runNatural :: Integer } deriving - ( Eq - , Ord - , Ix -#ifdef LANGUAGE_DeriveDataTypeable - , Typeable -#endif - ) - --- | Church decoding -natural :: a -> (a -> a) -> Natural -> a -natural a _ 0 = a -natural a f n = natural (f a) f (unsafePred n) -{-# INLINEABLE natural #-} - -instance Show Natural where - showsPrec d (Natural n) = showsPrec d n - -instance Read Natural where - readsPrec d = map (\(n, s) -> (Natural n, s)) . readsPrec d - -instance Num Natural where - Natural n + Natural m = Natural (n + m) - {-# INLINE (+) #-} - Natural n * Natural m = Natural (n * m) - {-# INLINE (*) #-} - Natural n - Natural m | result < 0 = error "Natural.(-): negative result" - | otherwise = Natural result - where result = n - m - {-# INLINE (-) #-} - abs (Natural n) = Natural n - {-# INLINE abs #-} - signum (Natural n) = Natural (signum n) - {-# INLINE signum #-} - fromInteger n - | n >= 0 = Natural n - | otherwise = error "Natural.fromInteger: negative" - {-# INLINE fromInteger #-} - -instance Bits Natural where - Natural n .&. Natural m = Natural (n .&. m) - {-# INLINE (.&.) #-} - Natural n .|. Natural m = Natural (n .|. m) - {-# INLINE (.|.) #-} - xor (Natural n) (Natural m) = Natural (xor n m) - {-# INLINE xor #-} - complement _ = error "Bits.complement: Natural complement undefined" - {-# INLINE complement #-} - shift (Natural n) = Natural . shift n - {-# INLINE shift #-} - rotate (Natural n) = Natural . rotate n - {-# INLINE rotate #-} - bit = Natural . bit - {-# INLINE bit #-} - setBit (Natural n) = Natural . setBit n - {-# INLINE setBit #-} - clearBit (Natural n) = Natural . clearBit n - {-# INLINE clearBit #-} - complementBit (Natural n) = Natural . complementBit n - {-# INLINE complementBit #-} - testBit = testBit . runNatural - {-# INLINE testBit #-} - bitSize = bitSize . runNatural - {-# INLINE bitSize #-} - isSigned _ = False - {-# INLINE isSigned #-} - shiftL (Natural n) = Natural . shiftL n - {-# INLINE shiftL #-} - shiftR (Natural n) = Natural . shiftR n - {-# INLINE shiftR #-} - rotateL (Natural n) = Natural . rotateL n - {-# INLINE rotateL #-} - rotateR (Natural n) = Natural . rotateR n - {-# INLINE rotateR #-} -#if MIN_VERSION_base(4,6,0) - popCount = popCountDefault - {-# INLINE popCount #-} -#endif - -instance Real Natural where - toRational (Natural a) = toRational a - {-# INLINE toRational #-} - -instance Enum Natural where - pred (Natural 0) = error "Natural.pred: 0" - pred (Natural n) = Natural (pred n) - {-# INLINE pred #-} - succ (Natural n) = Natural (succ n) - {-# INLINE succ #-} - fromEnum (Natural n) = fromEnum n - {-# INLINE fromEnum #-} - toEnum n | n < 0 = error "Natural.toEnum: negative" - | otherwise = Natural (toEnum n) - {-# INLINE toEnum #-} - -instance Integral Natural where - quot (Natural a) (Natural b) = Natural (quot a b) - {-# INLINE quot #-} - rem (Natural a) (Natural b) = Natural (rem a b) - {-# INLINE rem #-} - div (Natural a) (Natural b) = Natural (div a b) - {-# INLINE div #-} - mod (Natural a) (Natural b) = Natural (mod a b) - {-# INLINE mod #-} - divMod (Natural a) (Natural b) = (Natural q, Natural r) where (q,r) = divMod a b - {-# INLINE divMod #-} - quotRem (Natural a) (Natural b) = (Natural q, Natural r) where (q,r) = quotRem a b - {-# INLINE quotRem #-} - toInteger = runNatural - {-# INLINE toInteger #-} - --- | A refinement of 'Integral' to represent types that do not contain negative numbers. -class Integral n => Whole n where - toNatural :: n -> Natural - unsafePred :: n -> n - -instance Whole Word where - toNatural = Natural . toInteger - unsafePred n = n - 1 - {-# INLINE toNatural #-} - {-# INLINE unsafePred #-} - -instance Whole Word8 where - toNatural = Natural . toInteger - unsafePred n = n - 1 - {-# INLINE toNatural #-} - {-# INLINE unsafePred #-} - -instance Whole Word16 where - toNatural = Natural . toInteger - unsafePred n = n - 1 - {-# INLINE toNatural #-} - {-# INLINE unsafePred #-} - -instance Whole Word32 where - toNatural = Natural . toInteger - unsafePred n = n - 1 - {-# INLINE toNatural #-} - {-# INLINE unsafePred #-} - -instance Whole Word64 where - toNatural = Natural . toInteger - unsafePred n = n - 1 - {-# INLINE toNatural #-} - {-# INLINE unsafePred #-} - -instance Whole Natural where - toNatural = id - unsafePred (Natural n) = Natural (n - 1) - {-# INLINE toNatural #-} - {-# INLINE unsafePred #-} diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/nats-0.1.2/src/Numeric/Natural.hs new/nats-1/src/Numeric/Natural.hs --- old/nats-0.1.2/src/Numeric/Natural.hs 2013-09-17 19:53:48.000000000 +0200 +++ new/nats-1/src/Numeric/Natural.hs 2014-12-02 09:22:55.000000000 +0100 @@ -1,7 +1,26 @@ +{-# LANGUAGE CPP #-} + +#ifdef __GLASGOW_HASKELL__ +#define LANGUAGE_DeriveDataTypeable +{-# LANGUAGE DeriveDataTypeable #-} +#endif + +#ifndef MIN_VERSION_base +#define MIN_VERSION_base(x,y,z) 1 +#endif + +#if defined(__GLASGOW_HASKELL__) && __GLASGOW_HASKELL__ >= 702 +#ifdef MIN_VERSION_hashable +{-# LANGUAGE Trustworthy #-} +#else +{-# LANGUAGE Safe #-} +#endif +#endif + ----------------------------------------------------------------------------- -- | -- Module : Numeric.Natural --- Copyright : (C) 2011 Edward Kmett, +-- Copyright : (C) 2011-2014 Edward Kmett, -- License : BSD-style (see the file LICENSE) -- -- Maintainer : Edward Kmett <[email protected]> @@ -10,11 +29,180 @@ -- -- Natural numbers. -- +-- The "Numeric.Natural" module has become part of `base` starting +-- with `base-4.8.0.0`. ---------------------------------------------------------------------------- -module Numeric.Natural - ( Natural - , Whole(toNatural) - , natural - ) where +module Numeric.Natural ( Natural ) where + +import Control.Exception ( throw, ArithException(Underflow) ) +import Data.Bits +import Data.Ix +#ifdef LANGUAGE_DeriveDataTypeable +import Data.Data +#endif +#ifdef MIN_VERSION_hashable +import Data.Hashable +#endif + +-- | Type representing arbitrary-precision non-negative integers. +-- +-- Operations whose result would be negative +-- @'throw' ('Underflow' :: 'ArithException')@. +-- +-- The 'Natural' type has become part of `base` starting with +-- `base-4.8.0.0`. +newtype Natural = Natural { runNatural :: Integer } deriving + ( Eq + , Ord + , Ix +#ifdef LANGUAGE_DeriveDataTypeable + , Typeable +#endif + ) + +#ifdef MIN_VERSION_hashable +instance Hashable Natural where +#if MIN_VERSION_hashable(1,2,0) + hashWithSalt p (Natural a) = hashWithSalt p a +#else + hash (Natural a) = hash a +#endif +#endif + +#ifdef LANGUAGE_DeriveDataTypeable +-- This follows the same style as the other integral 'Data' instances +-- defined in "Data.Data" +naturalType :: DataType +naturalType = mkIntType "Numeric.Natural.Natural" + +instance Data Natural where + toConstr x = mkIntegralConstr naturalType x + gunfold _ z c = case constrRep c of + (IntConstr x) -> z (fromIntegral x) + _ -> error $ "Data.Data.gunfold: Constructor " ++ show c + ++ " is not of type Natural" + dataTypeOf _ = naturalType +#endif + +instance Show Natural where + showsPrec d (Natural n) = showsPrec d n + +instance Read Natural where + readsPrec d = map (\(n, s) -> (Natural n, s)) . filter ((>= 0) . fst) . readsPrec d + +instance Num Natural where + Natural n + Natural m = Natural (n + m) + {-# INLINE (+) #-} + Natural n * Natural m = Natural (n * m) + {-# INLINE (*) #-} + Natural n - Natural m | result < 0 = throw Underflow + | otherwise = Natural result + where result = n - m + {-# INLINE (-) #-} + abs (Natural n) = Natural n + {-# INLINE abs #-} + signum (Natural n) = Natural (signum n) + {-# INLINE signum #-} + fromInteger n + | n >= 0 = Natural n + | otherwise = throw Underflow + {-# INLINE fromInteger #-} + +instance Bits Natural where + Natural n .&. Natural m = Natural (n .&. m) + {-# INLINE (.&.) #-} + Natural n .|. Natural m = Natural (n .|. m) + {-# INLINE (.|.) #-} + xor (Natural n) (Natural m) = Natural (xor n m) + {-# INLINE xor #-} + complement _ = error "Bits.complement: Natural complement undefined" + {-# INLINE complement #-} + shift (Natural n) = Natural . shift n + {-# INLINE shift #-} + rotate (Natural n) = Natural . rotate n + {-# INLINE rotate #-} + bit = Natural . bit + {-# INLINE bit #-} + setBit (Natural n) = Natural . setBit n + {-# INLINE setBit #-} + clearBit (Natural n) = Natural . clearBit n + {-# INLINE clearBit #-} + complementBit (Natural n) = Natural . complementBit n + {-# INLINE complementBit #-} + testBit = testBit . runNatural + {-# INLINE testBit #-} +#if defined(__GLASGOW_HASKELL__) && __GLASGOW_HASKELL__ >= 707 + bitSizeMaybe _ = Nothing + {-# INLINE bitSizeMaybe #-} +#endif + bitSize = error "Natural: bitSize" + {-# INLINE bitSize #-} + isSigned _ = False + {-# INLINE isSigned #-} + shiftL (Natural n) = Natural . shiftL n + {-# INLINE shiftL #-} + shiftR (Natural n) = Natural . shiftR n + {-# INLINE shiftR #-} + rotateL (Natural n) = Natural . rotateL n + {-# INLINE rotateL #-} + rotateR (Natural n) = Natural . rotateR n + {-# INLINE rotateR #-} +#if MIN_VERSION_base(4,6,0) + popCount = popCountDefault + {-# INLINE popCount #-} +#endif + +instance Real Natural where + toRational (Natural a) = toRational a + {-# INLINE toRational #-} + +instance Enum Natural where + pred (Natural 0) = throw Underflow + pred (Natural n) = Natural (pred n) + {-# INLINE pred #-} + succ (Natural n) = Natural (succ n) + {-# INLINE succ #-} + fromEnum (Natural n) = fromEnum n + {-# INLINE fromEnum #-} + toEnum n | n < 0 = error "Natural.toEnum: negative" + | otherwise = Natural (toEnum n) + {-# INLINE toEnum #-} + + enumFrom = map Natural . enumFrom . runNatural + + enumFromThen x y + | x <= y = map Natural (enumFromThen (runNatural x) (runNatural y)) + | otherwise = map Natural (enumFromThenTo (runNatural x) (runNatural y) 0) + + enumFromTo x y = map Natural (enumFromTo (runNatural x) (runNatural y)) + + enumFromThenTo x x1 y + = map Natural (enumFromThenTo (runNatural x) (runNatural x1) (runNatural y)) + +{- NOTE: Using "Data.Coerce", we could instead say: + + enumFrom = coerce (enumFrom :: Integer -> [Integer]) + enumFromThen x y + | x <= y = coerce (enumFromThen :: Integer -> Integer -> [Integer]) x y + | otherwise = enumFromThenTo x y 0 + + enumFromTo = coerce (enumFromTo :: Integer -> Integer -> [Integer]) + enumFromThenTo + = coerce (enumFromThenTo :: Integer -> Integer -> Integer -> [Integer]) +-} -import Numeric.Natural.Internal +instance Integral Natural where + quot (Natural a) (Natural b) = Natural (quot a b) + {-# INLINE quot #-} + rem (Natural a) (Natural b) = Natural (rem a b) + {-# INLINE rem #-} + div (Natural a) (Natural b) = Natural (div a b) + {-# INLINE div #-} + mod (Natural a) (Natural b) = Natural (mod a b) + {-# INLINE mod #-} + divMod (Natural a) (Natural b) = (Natural q, Natural r) where (q,r) = divMod a b + {-# INLINE divMod #-} + quotRem (Natural a) (Natural b) = (Natural q, Natural r) where (q,r) = quotRem a b + {-# INLINE quotRem #-} + toInteger = runNatural + {-# INLINE toInteger #-}
