1. 19 Apr, 2018 1 commit
  2. 15 Sep, 2017 1 commit
    • Ryan Scott's avatar
      Fix #14228 by marking SumPats as non-irrefutable · f4d50a0e
      Ryan Scott authored
      `isIrrefutableHsPat` should always return `False` for unboxed sum
      patterns (`SumPat`s), since they always have at least one other
      corresponding pattern of the same arity (since the minimum arity for a
      `SumPat` is 2). Failure to do so causes incorrect code to be generated
      for pattern synonyms that use unboxed sums, as shown in #14228.
      Test Plan: make test TEST=T14228
      Reviewers: austin, bgamari, simonpj
      Reviewed By: simonpj
      Subscribers: simonpj, rwbarton, thomie
      GHC Trac Issues: #14228
      Differential Revision: https://phabricator.haskell.org/D3951
  3. 11 May, 2017 1 commit
  4. 01 May, 2016 1 commit
  5. 22 Dec, 2015 2 commits
    • Ben Gamari's avatar
      Remove duplicate T11224 test definition · 51d83302
      Ben Gamari authored
    • Simon Peyton Jones's avatar
      Fix typechecking for pattern synonym signatures · f40e122b
      Simon Peyton Jones authored
      Various tickets have revealed bad shortcomings in the typechecking of
      pattern type synonyms.  Discussed a lot in (the latter part of)
      Trac #11224.
      This patch fixes the most complex issues:
      - Both parser and renamer now treat pattern synonyms as an
        ordinary LHsSigType.  Nothing special.  Hooray.
      - tcPatSynSig (now in TcPatSyn) typechecks the signature, and
        decomposes it into its pieces.
        See Note [Pattern synonym signatures]
      - tcCheckPatSyn has had a lot of refactoring.
        See Note [Checking against a pattern signature]
      The result is a lot tidier and more comprehensible.
      Plus, it actually works!
      NB: this patch doesn't actually address the precise
          target of #11224, namely "inlining pattern synonym
          does not preserve semantics".  That's an unrelated
          bug, with a separate patch.
      ToDo: better documentation in the user manual
      Test Plan: Validate
      Reviewers: austin, hvr, goldfire
      Subscribers: goldfire, mpickering, thomie, simonpj
      Differential Revision: https://phabricator.haskell.org/D1685
      GHC Trac Issues: #11224
  6. 15 Dec, 2015 1 commit
  7. 29 Oct, 2015 1 commit
    • Matthew Pickering's avatar
      Record pattern synonyms · 2a74a64e
      Matthew Pickering authored
      This patch implements an extension to pattern synonyms which allows user
      to specify pattern synonyms using record syntax. Doing so generates
      appropriate selectors and update functions.
      === Interaction with Duplicate Record Fields ===
      The implementation given here isn't quite as general as it could be with
      respect to the recently-introduced `DuplicateRecordFields` extension.
      Consider the following module:
          {-# LANGUAGE DuplicateRecordFields #-}
          {-# LANGUAGE PatternSynonyms #-}
          module Main where
          pattern S{a, b} = (a, b)
          pattern T{a}    = Just a
          main = do
            print S{ a = "fst", b = "snd" }
            print T{ a = "a" }
      In principle, this ought to work, because there is no ambiguity. But at
      the moment it leads to a "multiple declarations of a" error. The problem
      is that pattern synonym record selectors don't do the same name mangling
      as normal datatypes when DuplicateRecordFields is enabled. They could,
      but this would require some work to track the field label and selector
      name separately.
      In particular, we currently represent datatype selectors in the third
      component of AvailTC, but pattern synonym selectors are just represented
      as Avails (because they don't have a corresponding type constructor).
      Moreover, the GlobalRdrElt for a selector currently requires it to have
      a parent tycon.
      (example due to Adam Gundry)
      === Updating Explicitly Bidirectional Pattern Synonyms ===
      Consider the following
      pattern Silly{a} <- [a] where
        Silly a = [a, a]
      f1 = a [5] -- 5
      f2 = [5] {a = 6} -- currently [6,6]
      === Fixing Polymorphic Updates ===
      They were fixed by adding these two lines in `dsExpr`. This might break
      record updates but will be easy to fix.
      + ; let req_wrap = mkWpTyApps (mkTyVarTys univ_tvs)
      - , pat_wrap = idHsWrapper }
      +, pat_wrap = req_wrap }
      === Mixed selectors error ===
      Note [Mixed Record Field Updates]
      Consider the following pattern synonym.
          data MyRec = MyRec { foo :: Int, qux :: String }
          pattern HisRec{f1, f2} = MyRec{foo = f1, qux=f2}
      This allows updates such as the following
          updater :: MyRec -> MyRec
          updater a = a {f1 = 1 }
      It would also make sense to allow the following update (which we
          updater a = a {f1 = 1, qux = "two" } ==? MyRec 1 "two"
      This leads to confusing behaviour when the selectors in fact refer the
      same field.
          updater a = a {f1 = 1, foo = 2} ==? ???
      For this reason, we reject a mixture of pattern synonym and normal
      record selectors in the same update block. Although of course we still
      allow the following.
          updater a = (a {f1 = 1}) {foo = 2}
          > updater (MyRec 0 "str")
          MyRec 2 "str"
  8. 28 Dec, 2014 1 commit
    • cactus's avatar
      Support pattern synonyms in GHCi (fixes #9900) · 0cc0cc86
      cactus authored
      This involves recognizing lines starting with `"pattern "` as declarations,
      keeping non-exported pattern synonyms in `deSugar`, and including
      pattern synonyms in the result of `hscDeclsWithLocation`.
  9. 13 Nov, 2014 1 commit
  10. 08 Nov, 2014 1 commit
    • cactus's avatar
      In pattern synonym matchers, support unboxed continuation results (fixes #9783). · 474e535b
      cactus authored
      This requires ensuring the continuations have arguments by adding a dummy
      Void# argument when needed. This is so that matching on a pattern synonym
      is lazy even when the result is unboxed, e.g.
          pattern P = ()
          f P = 0#
      In this case, without dummy arguments, the generated matcher's type would be
         $mP :: forall (r :: ?). () -> r -> r -> r
      which is called in `f` at type `() -> Int# -> Int# -> Int#`,
      so it would be strict, in particular, in the failure continuation
      of `patError`.
      We work around this by making sure both continuations have arguments:
        $mP :: forall (r :: ?). () -> (Void# -> r) -> (Void# -> r) -> r
      Of course, if `P` (and thus, the success continuation) has any arguments,
      we are only adding the extra dummy argument to the failure continuation.
  11. 29 Jul, 2014 1 commit
  12. 20 Jan, 2014 1 commit
    • cactus's avatar
      Implement pattern synonyms · 4f8369bf
      cactus 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/ImplementationReviewed-by: Simon Peyton Jones's avatarSimon Peyton Jones <simonpj@microsoft.com>
      Signed-off-by: default avatarAustin Seipp <austin@well-typed.com>