Permalink
Commits on Aug 1, 2017
  1. Update changelog

    bgamari committed Aug 1, 2017
  2. Bump to 0.13.2.0

    bgamari committed Aug 1, 2017
  3. Merge pull request #132 from hvr/pr/issue-131

    bgamari committed Aug 1, 2017
    Fix test-suite build failures "with GHC 8.2.1"
  4. Fix test-suite build failures "with GHC 8.2.1"

    hvr committed Aug 1, 2017
    The incomplete `other-modules` reported in #131 was a red-herring,
    the actual problem was the missing upper bound on QuickCheck 2.10
    which introduced semantic changes incompatible with the testsuite.
    
    Fixes #131
Commits on Dec 22, 2016
  1. Make pure strict in position

    bgamari committed Dec 22, 2016
    This is inconsistent with the behavior of (>>=) and is consequently a violation
    of the monad laws. Thanks for @dfeuer for noticing this. Fixes #126.
Commits on Sep 15, 2016
  1. Bump to 0.13.1.0

    bgamari committed Sep 15, 2016
  2. Update changelog for 0.13.1.0

    bgamari committed Sep 15, 2016
Commits on Jun 30, 2016
  1. Make code future proof by adding MonadFail/Semigroup instances

    hvr committed with bgamari Mar 2, 2016
    This patch makes the code future proof under the MonadFail and Semigroup
    proposals by adding instances in a CPP-avoiding way.
    
    Moreover, Monad instance definitions are refactored in a canonical form.
    
    With this patch, attoparsec is warning free with GHC 8.0 under
    
      -Wall -Wcompat -Wnoncanonical-monad-instances -Wnoncanonical-monadfail-instances
    
    (Compilation of attorparsec with GHCs back till 7.0.4 is warning-free as well)
Commits on Jun 23, 2016
  1. Add regression test for #105

    wereHamster committed Jun 23, 2016
Commits on May 16, 2016
  1. Merge pull request #120 from RyanGlScott/master

    bgamari committed May 16, 2016
    Make cabal sdist package up the benchmarks correctly
Commits on Apr 21, 2016
  1. Inlined Text.takeWhile and takeWhile1

    bgamari committed Apr 6, 2016
    Inlining these functions can improve code generation significantly when
    the predicate is statically known as it avoids boxing every parsed
    character. Unfortunately, marking `takeWhile` itself as `INLINEABLE`
    isn't sufficient to convince GHC to inline it.
    
    Moreover, we refactor things to avoid the allocations associated with
    the chunk accumulation list unless necessary.
    
    Previously things looked like,
    
        benchmarking takeWhile/T isAlpha
        time                 32.33 μs   (31.70 μs .. 33.25 μs)
                             0.994 R²   (0.988 R² .. 0.998 R²)
        mean                 33.02 μs   (32.36 μs .. 33.92 μs)
        std dev              2.687 μs   (2.086 μs .. 3.476 μs)
        variance introduced by outliers: 78% (severely inflated)
    
        benchmarking takeWhile/TL isAlpha
        time                 71.00 μs   (69.29 μs .. 72.83 μs)
                             0.991 R²   (0.985 R² .. 0.996 R²)
        mean                 71.60 μs   (69.94 μs .. 74.58 μs)
        std dev              7.358 μs   (5.428 μs .. 10.73 μs)
        variance introduced by outliers: 83% (severely inflated)
    
        benchmarking takeWhile1/T isAlpha
        time                 34.64 μs   (33.34 μs .. 36.26 μs)
                             0.989 R²   (0.985 R² .. 0.994 R²)
        mean                 34.93 μs   (34.04 μs .. 35.91 μs)
        std dev              3.249 μs   (2.821 μs .. 3.950 μs)
        variance introduced by outliers: 82% (severely inflated)
    
        benchmarking takeWhile1/TL isAlpha
        time                 68.30 μs   (66.59 μs .. 70.39 μs)
                             0.994 R²   (0.991 R² .. 0.998 R²)
        mean                 67.84 μs   (66.53 μs .. 69.77 μs)
        std dev              5.139 μs   (3.444 μs .. 7.793 μs)
        variance introduced by outliers: 73% (severely inflated)
    
    Now things look like,
    
        benchmarking takeWhile/T isAlpha
        time                 12.22 μs   (12.16 μs .. 12.31 μs)
                             1.000 R²   (1.000 R² .. 1.000 R²)
        mean                 12.29 μs   (12.23 μs .. 12.36 μs)
        std dev              222.0 ns   (180.4 ns .. 280.2 ns)
        variance introduced by outliers: 16% (moderately inflated)
    
        benchmarking takeWhile/TL isAlpha
        time                 43.13 μs   (42.77 μs .. 43.58 μs)
                             0.999 R²   (0.998 R² .. 1.000 R²)
        mean                 43.28 μs   (42.85 μs .. 44.06 μs)
        std dev              1.894 μs   (1.267 μs .. 3.137 μs)
        variance introduced by outliers: 48% (moderately inflated)
    
        benchmarking takeWhile1/T isAlpha
        time                 13.37 μs   (13.22 μs .. 13.57 μs)
                             0.999 R²   (0.998 R² .. 0.999 R²)
        mean                 13.29 μs   (13.14 μs .. 13.44 μs)
        std dev              536.0 ns   (463.2 ns .. 641.2 ns)
        variance introduced by outliers: 48% (moderately inflated)
    
        benchmarking takeWhile1/TL isAlpha
        time                 42.33 μs   (42.18 μs .. 42.59 μs)
                             0.999 R²   (0.998 R² .. 0.999 R²)
        mean                 43.72 μs   (43.22 μs .. 44.45 μs)
        std dev              1.957 μs   (1.491 μs .. 2.486 μs)
        variance introduced by outliers: 50% (moderately inflated)
    
    Moreover, this produces a similar >3x speedup in an HTML5 parser that I
    have.
  2. Force inlining of Buffer mempty and mappend

    bgamari committed Apr 6, 2016
    Just to make sure.
  3. travis: Add testing of GHC 8.0.1

    bgamari committed Apr 21, 2016
  4. travis: Disable cabal check

    bgamari committed Apr 21, 2016
    Apparently it looks for flags like `-Werror` even in disabled flags.
  5. Add travis.yml

    bgamari committed Apr 21, 2016
    Let's see how this goes. Can't build benchmarks, sadly.
  6. cabal: Fix tested-with

    bgamari committed Apr 21, 2016
    These must be full version numbers
Commits on Apr 8, 2016
  1. Text.FastSet: Always add at least one element of padding

    bgamari committed Apr 8, 2016
    Otherwise consider the case of,
    
        let fs = fromList "abcx"
        in '\239' `member` fs
    
    In this case,
    
     * `l == 4`, therefore
    
     * `((5 * l) `div` 4) == 5`, therefore
    
     * `mask' == 7`, therefore
    
     * we ended up with a hashtable array of length 14
    
     * however, during the membership check we start with
       `i = 239 .&. 7 = 7`
    
     * meaning the first entrance into `go` starts with `j = 14`; the first
       `lookupAt` tries to examine elements 14 and 15 of the hashtable
       array, which are out-of-bounds.
    
    The solution taken here is to ensure there is always at least one entry
    of padding at the end of the hashtable array. This now passes the
    quickcheck tests added previously.
    
    `FastSet` carries a quite nice performance improvement in
    microbenchmarks,
    
    ```
    benchmarking sets/Fast
    time                 8.046 ns   (8.011 ns .. 8.115 ns)
                         0.999 R²   (0.999 R² .. 1.000 R²)
    mean                 8.076 ns   (8.042 ns .. 8.130 ns)
    std dev              135.4 ps   (98.67 ps .. 193.0 ps)
    variance introduced by outliers: 24% (moderately inflated)
    
    benchmarking sets/Hash
    time                 15.18 ns   (15.13 ns .. 15.24 ns)
                         1.000 R²   (1.000 R² .. 1.000 R²)
    mean                 15.15 ns   (15.13 ns .. 15.19 ns)
    std dev              94.77 ps   (62.22 ps .. 155.6 ps)
    
    benchmarking sets/Int
    time                 14.11 ns   (14.03 ns .. 14.22 ns)
                         1.000 R²   (1.000 R² .. 1.000 R²)
    mean                 14.22 ns   (14.16 ns .. 14.28 ns)
    std dev              210.7 ps   (184.2 ps .. 250.6 ps)
    variance introduced by outliers: 19% (moderately inflated)
    
    benchmarking sets/TextFast
    time                 8.532 ns   (8.482 ns .. 8.572 ns)
                         1.000 R²   (1.000 R² .. 1.000 R²)
    mean                 8.485 ns   (8.461 ns .. 8.520 ns)
    std dev              101.8 ps   (81.45 ps .. 161.0 ps)
    variance introduced by outliers: 14% (moderately inflated)
    ```
    
    Fixes #103.
  2. Move from test-framework to tasty

    bgamari committed Apr 8, 2016
    It appears that test-framework's --maximum-generated-tests options is
    currently broken; it was easier to just move to tasty than work out what
    was wrong.
  3. Add test for FastSet

    bgamari committed Apr 8, 2016
  4. Revert "Replace Text FastSet implementation with IntSet"

    bgamari committed Apr 8, 2016
    This reverts commit 50fedf9.
Commits on Oct 22, 2015
  1. #105 keep state around with the `Finished` as scanner is applied recu…

    tolysz committed Oct 22, 2015
    …rsively and otherwise shortcutting might fail
Commits on Sep 23, 2015
  1. Add tranformers to benchmarks

    phadej committed Sep 23, 2015
    ..../attoparsec/Data/Attoparsec/Zepto.hs:41:8:
        Could not find module ‘Control.Monad.IO.Class’
        It is a member of the hidden package
    ‘transformers-0.4.2.0@trans_3eG64VdP2vzGjP6wJiCp5X’.
        Perhaps you need to add ‘transformers’ to the build-depends in your
    .cabal file.
        Use -v to see a list of the files searched for.
Commits on Jul 22, 2015
  1. Bump version to 0.13.0.2

    bos committed Jul 22, 2015
Commits on Jul 9, 2015