This project is mirrored from https://github.com/haskell/containers. Pull mirroring updated .
  1. 22 Jul, 2022 6 commits
  2. 21 Jul, 2022 1 commit
  3. 19 May, 2022 2 commits
  4. 03 May, 2022 1 commit
  5. 27 Apr, 2022 1 commit
  6. 20 Apr, 2022 2 commits
  7. 17 Mar, 2022 1 commit
  8. 20 Jan, 2022 2 commits
    • David Feuer's avatar
      Add Lift instances for other containers · 7aba44fa
      David Feuer authored
      Add `Lift` instances for `Data.Map.Map`, `Data.Set.Set`,
      `Data.IntSet.IntSet`, `Data.IntMap.IntMap`, `Data.Tree.Tree`,
      and `Data.Graph.SCC`.
      7aba44fa
    • David Feuer's avatar
      Add Lift instances for Data.Sequence · 9efb1de1
      David Feuer authored
      Add `Lift` instances for `Seq`, `ViewL`, and `ViewR`. The `Seq` instance
      tries to be a bit clever about the shape of the resulting tree and the
      size of the splice; everything else is straightforward.
      9efb1de1
  9. 18 Jan, 2022 1 commit
    • David Feuer's avatar
      Bump to GHC 8.0 · f4aec7fe
      David Feuer authored
      * Raise minimum GHC version to 8.0 so we'll be able to define
        `Lift` instances, avoid certain conditional definitions, etc.
      
      * Raise Cabal version for tests to 2.2; use `common` stanzas.
      f4aec7fe
  10. 05 Jan, 2022 1 commit
    • Vladislav Zavialov's avatar
      Enable TypeOperators to use (~) · 5c1ce927
      Vladislav Zavialov authored and David Feuer's avatar David Feuer committed
      GHC Proposal #371 requires TypeOperators to use type equality a~b.
      The following lines are affected:
      
      	containers/src/Data/Sequence/Internal.hs
      	4416:instance a ~ Char => IsString (Seq a) where
      
      The fix is to simply enable the extension.
      5c1ce927
  11. 31 Dec, 2021 1 commit
  12. 20 Nov, 2021 2 commits
  13. 17 Nov, 2021 1 commit
  14. 17 Aug, 2021 1 commit
  15. 05 Aug, 2021 1 commit
  16. 30 Jun, 2021 1 commit
  17. 28 Jun, 2021 6 commits
    • David Feuer's avatar
      Prepare for release · cde5e58b
      David Feuer authored
      cde5e58b
    • David Feuer's avatar
      Partially revert #670 · adfee37f
      David Feuer authored
      Bodigrim found a bug in the new `Ord` instance in #783. Put the
      old one one back.
      
      Fixes #783.
      adfee37f
    • Marcin Szamotulski's avatar
      Make Map's and Set's: foldr' & firends ' more strict · f00aa025
      Marcin Szamotulski authored and David Feuer's avatar David Feuer committed
      * Map.foldr'
      * Map.foldl'
      * Map.foldrWithKey'
      * Map.foldlWithKey'
      * Set.foldr'
      * Set.foldl'
      
      They now evaluate intermediate results of the accumulator before
      appling the folding operator again.
      
      This patch contains tests based on `nothunks` library.
      
      Benchmark summary:
      
      Map old:
      ```
      benchmarking foldlWithKey' ...
      benchmarked foldlWithKey'
      time                 28.57 μs   (28.00 μs .. 29.35 μs)
                           0.991 R²   (0.979 R² .. 0.999 R²)
      mean                 28.43 μs   (28.12 μs .. 28.99 μs)
      std dev              1.358 μs   (729.0 ns .. 2.101 μs)
      variance introduced by outliers: 27% (moderately inflated)
      
      benchmarking foldrWithKey' ...
      benchmarked foldrWithKey'
      time                 80.25 ns   (79.45 ns .. 81.13 ns)
                           0.998 R²   (0.996 R² .. 0.999 R²)
      mean                 79.84 ns   (79.27 ns .. 80.68 ns)
      std dev              2.184 ns   (1.572 ns .. 2.921 ns)
      variance introduced by outliers: 11% (moderately inflated)
      ```
      
      Map new:
      ```
      benchmarking foldlWithKey' ...
      benchmarked foldlWithKey'
      time                 27.76 μs   (27.15 μs .. 28.34 μs)
                           0.996 R²   (0.992 R² .. 0.998 R²)
      mean                 27.08 μs   (26.84 μs .. 27.43 μs)
      std dev              964.2 ns   (720.7 ns .. 1.350 μs)
      variance introduced by outliers: 18% (moderately inflated)
      
      benchmarking foldrWithKey' ...
      benchmarked foldrWithKey'
      time                 74.02 ns   (73.01 ns .. 75.82 ns)
                           0.998 R²   (0.994 R² .. 1.000 R²)
      mean                 73.14 ns   (72.91 ns .. 73.80 ns)
      std dev              1.245 ns   (434.3 ps .. 2.625 ns)
      ```
      
      Set old:
      
      ```benchmarking member ...
      benchmarked member
      time                 237.1 μs   (231.5 μs .. 246.0 μs)
                           0.993 R²   (0.986 R² .. 0.999 R²)
      mean                 234.3 μs   (232.1 μs .. 238.0 μs)
      std dev              9.031 μs   (5.737 μs .. 15.46 μs)
      variance introduced by outliers: 20% (moderately inflated)
      ```
      
      Set new:
      ```
      benchmarking member ...
      benchmarked member
      time                 219.4 μs   (216.3 μs .. 222.6 μs)
                           0.999 R²   (0.997 R² .. 1.000 R²)
      mean                 221.3 μs   (219.3 μs .. 225.3 μs)
      std dev              10.25 μs   (5.408 μs .. 18.71 μs)
      variance introduced by outliers: 28% (moderately inflated)
      ```
      f00aa025
    • infinity0's avatar
      Fix map-strict-properties · 4d50a8dd
      infinity0 authored and David Feuer's avatar David Feuer committed
      It was actually testing the lazy version
      4d50a8dd
    • infinity0's avatar
      test-suite: fix naming consistency between strict vs lazy IntMap · 92f0cebc
      infinity0 authored and David Feuer's avatar David Feuer committed
      92f0cebc
    • konsumlamm's avatar
      Fix formatting · afae4623
      konsumlamm authored and David Feuer's avatar David Feuer committed
      afae4623
  18. 23 Jun, 2021 1 commit
  19. 21 Jun, 2021 1 commit
  20. 02 Jun, 2021 1 commit
  21. 02 Feb, 2021 1 commit
    • John Ericson's avatar
      Fix for `indexInt8OffAddr#` returning sized type in next GHC · 7fb91ca5
      John Ericson authored and David Feuer's avatar David Feuer committed
      Here's how we fix this without CPP:
      
      In old GHC:
      
        I8# :: Int# -> Int8
        indexInt8OffAddr# :: Addr# -> Int# -> Int#
      
      In upcoming GHC 9.2:
      
        I8# :: Int8# -> Int8
        indexInt8OffAddr# :: Addr# -> Int# -> Int8#
      
      So the "GLB" interface is:
      
        exists alpha.
        I8# :: alpha -> Int8
        indexInt8OffAddr# :: Addr# -> Int# -> alpha
      
      We we write a program against that, eliminating the black-box `alpha`
      with `I8#` and then converting to `Int`.
      7fb91ca5
  22. 31 Jan, 2021 1 commit
  23. 24 Jan, 2021 2 commits
  24. 04 Jan, 2021 1 commit
  25. 21 Dec, 2020 1 commit