This project is mirrored from https://gitlab.haskell.org/ghc/ghc.git. Pull mirroring failed .
Repository mirroring has been paused due to too many failed attempts. It can be resumed by a project maintainer.
Last successful update .
  1. 03 Oct, 2015 1 commit
    • Ryan Scott's avatar
      Make GHC generics capable of handling unboxed types · 6cde981a
      Ryan Scott authored
      This adds a data family (`URec`) and six data family instances (`UAddr`,
      `UChar`, `UDouble`, `UFloat`, `UInt`, and `UWord`) which a `deriving
      Generic(1)` clause will generate if it sees `Addr#`, `Char#`, `Double#`,
      `Float#`, `Int#`, or `Word#`, respectively. The programmer can then
      provide instances for these data family instances to provide custom
      implementations for unboxed types, similar to how derived `Eq`, `Ord`,
      and `Show` instances currently special-case unboxed types.
      
      Fixes #10868.
      
      Test Plan: ./validate
      
      Reviewers: goldfire, dreixel, bgamari, austin, hvr, kosmikus
      
      Reviewed By: dreixel, kosmikus
      
      Subscribers: simonpj, thomie
      
      Differential Revision: https://phabricator.haskell.org/D1239
      
      GHC Trac Issues: #10868
      6cde981a
  2. 02 Oct, 2015 1 commit
  3. 29 Aug, 2015 1 commit
    • Ryan Scott's avatar
      Make Generic (Proxy t) instance poly-kinded (fixes #10775) · a6826c5d
      Ryan Scott authored
      This amounts to enabling PolyKinds in GHC.Generics. However, explicit
      kind signatures must be applied to the datatypes and typeclasses in
      GHC.Generics to ensure that the Core which TcGenGenerics generates
      is properly kinded.
      
      Several of the typeclasses in GHC.Generics could be poly-kinded, but
      this differential does not attempt to address this, since D493 already
      addresses this.
      
      Test Plan: ./validate
      
      Reviewers: hvr, austin, dreixel, bgamari
      
      Reviewed By: austin, dreixel, bgamari
      
      Subscribers: goldfire, thomie
      
      Differential Revision: https://phabricator.haskell.org/D1166
      
      GHC Trac Issues: #10775
      a6826c5d
  4. 07 Aug, 2015 1 commit
  5. 06 Aug, 2015 1 commit
    • Fumiaki Kinoshita's avatar
      base: Add instances · 97843d0b
      Fumiaki Kinoshita authored
      This patch adds following instances:
      
      * Foldable ZipList
      * Traversable ZipList
      * Functor Complex
      * Applicative Complex
      * Monad Complex
      * Foldable Complex
      * Traversable Complex
      * Generic1 Complex
      * Monoid a => Monoid (Identity a)
      * Storable ()
      
      Reviewers: ekmett, fumieval, hvr, austin
      
      Subscribers: thomie, #core_libraries_committee
      
      Projects: #core_libraries_committee
      
      Differential Revision: https://phabricator.haskell.org/D1049
      
      GHC Trac Issues: #10609
      97843d0b
  6. 05 Aug, 2015 1 commit
  7. 30 Jul, 2015 1 commit
  8. 07 Jul, 2015 2 commits
  9. 03 Jul, 2015 1 commit
  10. 16 Jun, 2015 1 commit
  11. 25 Apr, 2015 2 commits
  12. 14 Apr, 2015 2 commits
  13. 03 Apr, 2015 1 commit
  14. 25 Mar, 2015 1 commit
  15. 23 Mar, 2015 1 commit
  16. 17 Mar, 2015 1 commit
  17. 11 Mar, 2015 1 commit
  18. 07 Mar, 2015 2 commits
  19. 05 Mar, 2015 1 commit
    • Herbert Valerio Riedel's avatar
      Add public rnf/hash operations to TypeRep/TyCon · 56e0ac98
      Herbert Valerio Riedel authored
      Summary:
      `TyCon` and `TypeRep` are supposed to be abstract, by providing these
      additional few public operations the need to import
      `Data.Typeable.Internal` is reduced, and future changes to the internal
      structure of `TypeRep`/`TyCon` shouldn't require changes in packages such as
      `deepseq` or `hashable` anymore (hopefully).
      
      Reviewers: ekmett, simonpj, tibbe, austin
      
      Reviewed By: ekmett, simonpj, austin
      
      Subscribers: thomie
      
      Differential Revision: https://phabricator.haskell.org/D699
      56e0ac98
  20. 23 Jan, 2015 1 commit
  21. 22 Jan, 2015 1 commit
    • Herbert Valerio Riedel's avatar
      Restore invariant in `Data (Ratio a)` instance · 3df429e2
      Herbert Valerio Riedel authored
      (2nd attempt, this time leaving the `Constr` using `":%"`)
      
      The Data instance for `Ratio` just uses the raw `:%` constructor and
      doesn't check that the result is reduced to normal form.
      
      The fix is to add back the `Integral` constraint on the Data
      instance (which was dropped in c409b6f3) and to use `%` rather
      than `:%` in the `gfoldl` and `gunfold` implementation.
      
      This restores the invariant and matches the behavior of "virtual
      constructors" we've used to patch up such problems elsewhere.
      
      This addresses #10011
      
      Reviewed By: ekmett, austin
      
      Differential Revision: https://phabricator.haskell.org/D625
      3df429e2
  22. 21 Jan, 2015 2 commits
    • Herbert Valerio Riedel's avatar
      Revert "Restore invariant in `Data (Ratio a)` instance" · 22c4d60b
      Herbert Valerio Riedel authored
      This reverts commit 79b0d0e6
      due to
      
        Compile failed (status 256) errors were:
        [1 of 2] Compiling A                ( A.hs, A.o )
        [2 of 2] Compiling Main             ( T4491.hs, T4491.o )
        T4491.hs:19:11:
          Illegal data constructor name: ‘%’
          When splicing a TH expression: (GHC.Real.%) 11 2
          In the splice: $(dataToExpQ (const Nothing) (5.5 :: Rational))
        *** unexpected failure for T4491(normal)
      
      Therefore re-opening #10011
      22c4d60b
    • Herbert Valerio Riedel's avatar
      Restore invariant in `Data (Ratio a)` instance · 79b0d0e6
      Herbert Valerio Riedel authored
      The Data instance for `Ratio` just uses the raw `:%` constructor and
      doesn't check that the result is reduced to normal form.
      
      The fix is to add back the `Integral` constraint on the Data
      instance (which was dropped in c409b6f3) and to use `%` rather
      than `:%` in the `gfoldl` and `gunfold` implementation.
      
      This restores the invariant and matches the behavior of "virtual
      constructors" we've used to patch up such problems elsewhere.
      
      This addresses #10011
      
      Reviewed By: ekmett, austin
      
      Differential Revision: https://phabricator.haskell.org/D625
      79b0d0e6
  23. 14 Jan, 2015 1 commit
  24. 19 Dec, 2014 1 commit
  25. 06 Dec, 2014 2 commits
  26. 02 Dec, 2014 1 commit
    • puffnfresh's avatar
      Make `read . show = id` for Data.Fixed (fix #9240) · 7c38e985
      puffnfresh authored
      The QuickCheck property now succeeds:
      
          prop :: Fixed B7 -> Bool
          prop a = read (show a) == a
      
      This changes the Show instance for Fixed to round up, rather than down
      when calculating a digit. This needs to happen because Read also
      rounds down:
      
          data B7
      
          instance HasResolution B7 where
            resolution _ = 128
      
          1 / 128 = 0.0078125
      
          read "0.007" = (0.000 :: Fixed B7)
      
      Here is an example of the change to Show:
      
          showFixed False (0.009 :: Fixed B7)
      
          -- Broken: "0.007"
          -- Fixed:  "0.008"
      
      And now Read can continue to round down:
      
          read "0.008" = (0.0078125 :: Fixed B7)
      
      Reviewed By: hvr, ekmett
      
      Differential Revision: https://phabricator.haskell.org/D547
      7c38e985
  27. 25 Nov, 2014 1 commit
  28. 24 Nov, 2014 2 commits
  29. 23 Nov, 2014 1 commit
  30. 22 Nov, 2014 1 commit
    • Herbert Valerio Riedel's avatar
      Implement `Natural` number type (re #9818) · 8a8cdbbf
      Herbert Valerio Riedel authored
      This implements a `Natural` type for representing unsigned arbitrary
      precision integers.
      
      When available, `integer-gmp>=1.0.0`'s `BigNat` type is used as
      building-block to construct `Natural` as an algebraic data-type.
      Otherwise, `Natural` falls back being a `newtype`-wrapper around
      `Integer` (as is done in Edward Kmett's `nats` package).
      
      The `GHC.Natural` module exposes an internal GHC-specific API, while
      `Numeric.Natural` provides the official & portable API.
      
      Reviewed By: austin, ekmett
      
      Differential Revision: https://phabricator.haskell.org/D473
      8a8cdbbf
  31. 21 Nov, 2014 3 commits