Hello community,

here is the log from the commit of package ghc-scientific for openSUSE:Factory 
checked in at 2017-07-12 19:35:28
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Comparing /work/SRC/openSUSE:Factory/ghc-scientific (Old)
 and      /work/SRC/openSUSE:Factory/.ghc-scientific.new (New)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Package is "ghc-scientific"

Wed Jul 12 19:35:28 2017 rev:16 rq:509318 version:0.3.4.15

Changes:
--------
--- /work/SRC/openSUSE:Factory/ghc-scientific/ghc-scientific.changes    
2017-06-21 13:55:53.574362033 +0200
+++ /work/SRC/openSUSE:Factory/.ghc-scientific.new/ghc-scientific.changes       
2017-07-12 19:35:29.820662404 +0200
@@ -1,0 +2,5 @@
+Mon Jul  3 03:01:36 UTC 2017 - [email protected]
+
+- Update to version 0.3.4.15 revision 2.
+
+-------------------------------------------------------------------

New:
----
  scientific.cabal

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Other differences:
------------------
++++++ ghc-scientific.spec ++++++
--- /var/tmp/diff_new_pack.z7sceP/_old  2017-07-12 19:35:30.416578225 +0200
+++ /var/tmp/diff_new_pack.z7sceP/_new  2017-07-12 19:35:30.420577660 +0200
@@ -26,6 +26,7 @@
 Group:          Development/Languages/Other
 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/2.cabal#/%{pkg_name}.cabal
 BuildRequires:  ghc-Cabal-devel
 BuildRequires:  ghc-binary-devel
 BuildRequires:  ghc-bytestring-devel
@@ -90,6 +91,7 @@
 
 %prep
 %setup -q -n %{pkg_name}-%{version}
+cp -p %{SOURCE1} %{pkg_name}.cabal
 
 %build
 %ghc_lib_build

++++++ scientific.cabal ++++++
name:                scientific
version:             0.3.4.15
x-revision: 2
synopsis:            Numbers represented using scientific notation
description:
  @Data.Scientific@ provides the number type 'Scientific'. Scientific numbers 
are
  arbitrary precision and space efficient. They are represented using
  <http://en.wikipedia.org/wiki/Scientific_notation scientific notation>.
  The implementation uses a coefficient @c :: 'Integer'@ and a base-10 exponent
  @e :: 'Int'@. A scientific number corresponds to the
  'Fractional' number: @'fromInteger' c * 10 '^^' e@.
  .
  Note that since we're using an 'Int' to represent the exponent these numbers
  aren't truly arbitrary precision. I intend to change the type of the exponent
  to 'Integer' in a future release.
  .
  The main application of 'Scientific' is to be used as the target of parsing
  arbitrary precision numbers coming from an untrusted source. The advantages
  over using 'Rational' for this are that:
  .
  * A 'Scientific' is more efficient to construct. Rational numbers need to be
  constructed using '%' which has to compute the 'gcd' of the 'numerator' and
  'denominator'.
  .
  * 'Scientific' is safe against numbers with huge exponents. For example:
  @1e1000000000 :: 'Rational'@ will fill up all space and crash your
  program. Scientific works as expected:
  .
   > > read "1e1000000000" :: Scientific
   > 1.0e1000000000
  .
  * Also, the space usage of converting scientific numbers with huge exponents 
to
  @'Integral's@ (like: 'Int') or @'RealFloat's@ (like: 'Double' or 'Float')
  will always be bounded by the target type.

homepage:            https://github.com/basvandijk/scientific
bug-reports:         https://github.com/basvandijk/scientific/issues
license:             BSD3
license-file:        LICENSE
author:              Bas van Dijk
maintainer:          Bas van Dijk <[email protected]>
category:            Data
build-type:          Simple
cabal-version:       >=1.10

extra-source-files:
  changelog

source-repository head
  type:     git
  location: git://github.com/basvandijk/scientific.git

flag bytestring-builder
  description: Depend on the bytestring-builder package for backwards 
compatibility.
  default:     False
  manual:      False

flag integer-simple
  description: Use the integer-simple package instead of integer-gmp
  default:     False

library
  exposed-modules:     Data.ByteString.Builder.Scientific
                       Data.Scientific
                       Data.Text.Lazy.Builder.Scientific
  other-modules:       GHC.Integer.Compat
                       Utils
  other-extensions:    DeriveDataTypeable, BangPatterns
  ghc-options:         -Wall
  build-depends:       base        >= 4.3   && < 4.11
                     , ghc-prim
                     , integer-logarithms >= 1 && <1.1
                     , deepseq     >= 1.3   && < 1.5
                     , text        >= 0.8   && < 1.3
                     , hashable    >= 1.1.2 && < 1.3
                     , vector      >= 0.7   && < 0.13
                     , containers  >= 0.1   && < 0.6
                     , binary      >= 0.4.1 && < 0.9

  if flag(bytestring-builder)
      build-depends: bytestring         >= 0.9    && < 0.10.4
                   , bytestring-builder >= 0.10.4 && < 0.11
  else
      build-depends: bytestring         >= 0.10.4 && < 0.11

  if flag(integer-simple)
      build-depends: integer-simple
  else
      build-depends: integer-gmp

  hs-source-dirs:      src
  default-language:    Haskell2010

test-suite test-scientific
  type:             exitcode-stdio-1.0
  hs-source-dirs:   test
  main-is:          test.hs
  default-language: Haskell2010
  ghc-options:      -Wall

  build-depends: scientific
               , base             >= 4.3   && < 4.11
               , binary           >= 0.4.1 && < 0.9
               , tasty            >= 0.5   && < 0.12
               , tasty-ant-xml    >= 1.0   && < 1.2
               , tasty-hunit      >= 0.8   && < 0.10
               , tasty-smallcheck >= 0.2   && < 0.9
               , tasty-quickcheck >= 0.8   && < 0.10
               , smallcheck       >= 1.0   && < 1.2
               , QuickCheck       >= 2.5   && < 2.11
               , text             >= 0.8   && < 1.3

  if flag(bytestring-builder)
      build-depends: bytestring         >= 0.9    && < 0.10.4
                   , bytestring-builder >= 0.10.4 && < 0.11
  else
      build-depends: bytestring         >= 0.10.4 && < 0.11

benchmark bench-scientific
  type:             exitcode-stdio-1.0
  hs-source-dirs:   bench
  main-is:          bench.hs
  default-language: Haskell2010
  ghc-options:      -O2
  build-depends:    scientific
                  , base        >= 4.3   && < 4.11
                  , criterion   >= 0.5   && < 1.3

Reply via email to