1. 11 Feb, 2014 2 commits
  2. 10 Feb, 2014 3 commits
    • Joachim Breitner's avatar
      Update test cases due to call arity · 393ea739
      Joachim Breitner authored
      Some nice improvements on already succeeding test cases (#876, #7954
      and #4267)
      
      Test #149 needed a little change, lest call arity causes a allocation
      change that we do not want to test here.
      393ea739
    • Joachim Breitner's avatar
      Add a unit test for CallArity · 9bc82656
      Joachim Breitner authored
      This also sets precedence for testing internals of GHC directly, i.e.
      without trying to come up with Haskell code and observable effects.
      Let's see how that goes.
      
      I put all the tests (including those where the analysis could do better)
      in one file because starting the GHC API is quite slow.
      9bc82656
    • eir@cis.upenn.edu's avatar
      8e303d72
  3. 09 Feb, 2014 9 commits
  4. 08 Feb, 2014 1 commit
  5. 07 Feb, 2014 3 commits
  6. 02 Feb, 2014 1 commit
  7. 28 Jan, 2014 1 commit
    • Austin Seipp's avatar
      Update some mingw32 perf numbers. · db9baf08
      Austin Seipp authored
      
      
      I forgot to push these from my win32 machine. A lot of them actually
      look like a result of Herbert doing his GMP work, which might slightly
      affect allocations on platforms like Windows (where we always use
      in-tree GMP - but presumably Windows allocations could fluxuate slightly
      due to minute details in the GMP implementation, too.)
      Signed-off-by: default avatarAustin Seipp <austin@well-typed.com>
      db9baf08
  8. 23 Jan, 2014 5 commits
  9. 22 Jan, 2014 3 commits
  10. 20 Jan, 2014 3 commits
    • Gergő Érdi's avatar
    • Gergő Érdi's avatar
      Implement pattern synonyms · 4f8369bf
      Gergő Érdi authored
      This patch implements Pattern Synonyms (enabled by -XPatternSynonyms),
      allowing y ou to assign names to a pattern and abstract over it.
      
      The rundown is this:
      
        * Named patterns are introduced by the new 'pattern' keyword, and can
          be either *unidirectional* or *bidirectional*. A unidirectional
          pattern is, in the simplest sense, simply an 'alias' for a pattern,
          where the LHS may mention variables to occur in the RHS. A
          bidirectional pattern synonym occurs when a pattern may also be used
          in expression context.
      
        * Unidirectional patterns are declared like thus:
      
              pattern P x <- x:_
      
          The synonym 'P' may only occur in a pattern context:
      
              foo :: [Int] -> Maybe Int
              foo (P x) = Just x
              foo _     = Nothing
      
        * Bidirectional patterns are declared like thus:
      
              pattern P x y = [x, y]
      
          Here, P may not only occur as a pattern, but also as an expression
          when given values for 'x' and 'y', i.e.
      
              bar :: Int -> [Int]
              bar x = P x 10
      
        * Patterns can't yet have their own type signatures; signatures are inferred.
      
        * Pattern synonyms may not be recursive, c.f. type synonyms.
      
        * Pattern synonyms are also exported/imported using the 'pattern'
          keyword in an import/export decl, i.e.
      
              module Foo (pattern Bar) where ...
      
          Note that pattern synonyms share the namespace of constructors, so
          this disambiguation is required as a there may also be a 'Bar'
          type in scope as well as the 'Bar' pattern.
      
        * The semantics of a pattern synonym differ slightly from a typical
          pattern: when using a synonym, the pattern itself is matched,
          followed by all the arguments. This means that the strictness
          differs slightly:
      
              pattern P x y <- [x, y]
      
              f (P True True) = True
              f _             = False
      
              g [True, True] = True
              g _            = False
      
          In the example, while `g (False:undefined)` evaluates to False,
          `f (False:undefined)` results in undefined as both `x` and `y`
          arguments are matched to `True`.
      
      For more information, see the wiki:
      
          https://ghc.haskell.org/trac/ghc/wiki/PatternSynonyms
          https://ghc.haskell.org/trac/ghc/wiki/PatternSynonyms/Implementation
      
      Reviewed-by: default avatarSimon Peyton Jones <simonpj@microsoft.com>
      Signed-off-by: default avatarAustin Seipp <austin@well-typed.com>
      4f8369bf
    • Joachim Breitner's avatar
      Test case for #T7619 · da66a8df
      Joachim Breitner authored
      (artificial test cases are so nice: 90.7% improvement!)
      da66a8df
  11. 17 Jan, 2014 6 commits
  12. 16 Jan, 2014 3 commits