[GHC] #11350: Allow visible type application in patterns
#11350: Allow visible type application in patterns -------------------------------------+------------------------------------- Reporter: Iceland_jack | Owner: Type: feature | Status: new request | Priority: normal | Milestone: Component: Compiler | Version: 8.1 Keywords: | Operating System: Unknown/Multiple TypeApplications PatternSynonyms | Architecture: | Type of failure: None/Unknown Unknown/Multiple | Test Case: | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- Constructors (and pattern synonyms) when treated as expressions may be applied to types: {{{#!hs {-# LANGUAGE TypeApplications #-} Nothing :: Maybe a Nothing @() :: Maybe () pattern Pair :: a -> a -> (a, a) pattern Pair x y = (x, y) Pair :: a -> a -> (a, a) Pair @Int :: Int -> Int -> (Int, Int) }}} But using them in patterns won't parse: {{{#!hs -- parse error in pattern: @Int maybeToList :: Maybe Int -> [Int] maybeToList (Nothing @Int) = [] maybeToList (Just @Int x) = [x] -- parse error in pattern: @Int add :: (Int, Int) -> Int add (Pair @Int x y) = x + y }}} -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/11350 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler
#11350: Allow visible type application in patterns -------------------------------------+------------------------------------- Reporter: Iceland_jack | Owner: Type: feature request | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.1 Resolution: | Keywords: | TypeApplications PatternSynonyms Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Comment (by Iceland_jack): Relevant note on [https://github.com/ghc/ghc/commit/2db18b8135335da2da9918b722699df684097be9 #diff-b0c0b2c93d6cc4f591c913d42daa7b2eR518 ⟦Lexing type applications⟧] -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/11350#comment:1 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler
#11350: Allow visible type application in patterns -------------------------------------+------------------------------------- Reporter: Iceland_jack | Owner: Type: feature request | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.1 Resolution: | Keywords: | TypeApplications PatternSynonyms Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Comment (by Iceland_jack): This ''should'' make the code in [https://ghc.haskell.org/trac/ghc/ticket/8583#comment:7 Richard's comment] compile: {{{#!hs headOfList :: forall a. [a] -> Maybe a headOfList (Nil @[] @a) = Nothing @a headOfList (Cons @[] @a x _) = Just x }}} The rest of his comment applies to, this is not for dynamically branching on types although that could certainly be added as a feature! {{{#!hs doubleWhenInt :: forall a. Typeable a => a -> a doubleWhenInt a = case eqT @Int @a of Just Refl -> a + a Nothing -> a -- Becomes… doubleWhenInt :: forall a. Typeable a => a -> a doubleWhenInt @Int n = n + n doubleWhenInt @_ a = a }}} -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/11350#comment:2 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler
#11350: Allow visible type application in patterns -------------------------------------+------------------------------------- Reporter: Iceland_jack | Owner: Type: feature request | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.1 Resolution: | Keywords: | TypeApplications PatternSynonyms Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Changes (by adamgundry): * cc: adamgundry (added) Comment: Yes, this is a good idea. It would give a much nicer way to bind (particularly existential) type variables than the current `ScopedTypeVariables` hack. I think typecase should be treated separately though, and with lower priority (cf. #11387). -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/11350#comment:3 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler
#11350: Allow visible type application in patterns -------------------------------------+------------------------------------- Reporter: Iceland_jack | Owner: Type: feature request | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.1 Resolution: | Keywords: | TypeApplications PatternSynonyms Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Comment (by Iceland_jack): While commenting on #11441, what about lambdas? {{{#!hs -- Should work, given proposal. id :: forall a. a -> a id @a x = x -- Also. id :: forall a. a -> a id (@ a) (x :: a) = x -- What about this? id :: forall a. a -> a id = \ (@ a) (x :: a) -> x -- Or this id :: b -> b id = \ (@ a) (x :: a) -> x }}} Same question extends to `LambdaCase`. -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/11350#comment:4 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler
#11350: Allow visible type application in patterns -------------------------------------+------------------------------------- Reporter: Iceland_jack | Owner: Type: feature request | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.1 Resolution: | Keywords: | TypeApplications PatternSynonyms Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Comment (by goldfire): Yes. I think all of these should work, modulo parsing. (I'm worried about `(@ a)` instead of `@a`. Would need to test to be sure.) -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/11350#comment:5 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler
#11350: Allow visible type application in patterns -------------------------------------+------------------------------------- Reporter: Iceland_jack | Owner: Type: feature request | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.1 Resolution: | Keywords: | TypeApplications PatternSynonyms Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Changes (by RyanGlScott): * cc: RyanGlScott (added) -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/11350#comment:6 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler
#11350: Allow visible type application in patterns -------------------------------------+------------------------------------- Reporter: Iceland_jack | Owner: Type: feature request | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.1 Resolution: | Keywords: | TypeApplications PatternSynonyms Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Comment (by goldfire): See comment:1:ticket:11638 for some detailed thoughts about design challenges here. -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/11350#comment:7 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler
#11350: Allow visible type application in patterns -------------------------------------+------------------------------------- Reporter: Iceland_jack | Owner: Type: feature request | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.1 Resolution: | Keywords: | TypeApplications PatternSynonyms Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Comment (by Iceland_jack): Notes, similar to [https://hackage.haskell.org/package/base-4.9.0.0/docs /GHC-OverloadedLabels.html GHC.OverloadedLabels.IsLabel]: {{{#!hs class IsLeibel (str::Symbol) a where fromLeibel :: a }}} would the following work {{{#!hs instance forall x r a. HasField x r a => IsLeibel x (r -> a) where fromLeibel :: r -> a fromLeibel @x = getField @x }}} Does `fromLeibel @x` bring `x` into scope, shadowing `instance forall x r a.`? -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/11350#comment:8 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler
#11350: Allow visible type application in patterns -------------------------------------+------------------------------------- Reporter: Iceland_jack | Owner: Type: feature request | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.1 Resolution: | Keywords: | TypeApplications PatternSynonyms Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Comment (by goldfire): That's a great question. It would have to be addressed in the design. I lean toward "no", because this seems useless other than for renaming. -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/11350#comment:9 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler
#11350: Allow visible type application in patterns -------------------------------------+------------------------------------- Reporter: Iceland_jack | Owner: Type: feature request | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.1 Resolution: | Keywords: | TypeApplications PatternSynonyms Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: #11385 | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Changes (by Iceland_jack): * related: => #11385 Comment: An additional comment on -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/11350#comment:10 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler
#11350: Allow visible type application in patterns -------------------------------------+------------------------------------- Reporter: Iceland_jack | Owner: Type: feature request | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.1 Resolution: | Keywords: | TypeApplications PatternSynonyms Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: #11385 | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Comment (by Iceland_jack): Use case: with [https://hackage.haskell.org/package/array-0.5.1.1/docs /Data-Array-MArray.html#v:newListArray newListArray] {{{#!hs newListArray :: (MArray a e m, Ix i) => (i, i) -> [e] -> m (a i e) }}} we want to pick an instance of `MArray` many of whom have this form {{{#!hs instance MArray (STUArray s) Word (ST s) instance MArray (STUArray s) Int (ST s) instance MArray (STUArray s) Float (ST s) instance MArray (STUArray s) Bool (ST s) }}} so you try {{{#!hs newListArray @(STArray _s1) @Bool @(ST _s2) @Int :: MArray (STArray t) Bool (ST t1) => (Int, Int) -> [Bool] -> ST t1 (STArray t Int Bool) }}} but we need to unify `_s1` and `_s2` if we want to discharge the constraint, using syntax from ticket:11385#comment:2 {{{#!hs \ @s -> newListArray @(STArray s) @Bool @(ST s) @Int }}} the alternative being `newListArray @(STArray s) @Bool @(ST s) @Int :: forall s. _` (which isn't that bad because there are no additional constraints: if we had left `@Int` off it would not work and we would have to write {{{#!hs newListArray @(STArray s) @Bool @(ST s) :: forall s i. Ix i => (i, i) -> _ }}} instead) -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/11350#comment:11 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler
#11350: Allow visible type application in patterns -------------------------------------+------------------------------------- Reporter: Iceland_jack | Owner: Type: feature request | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.1 Resolution: | Keywords: | TypeApplications PatternSynonyms Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: #11385 | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Comment (by Iceland_jack): Have only referenced this in passing: Allow type application for methods {{{#!hs class Semigroup a where (<>) @a :: a -> a -> a class Semigroup a => Monoid a where mempty @a :: a }}} and their instances with some #12363 {{{#!hs instance (Semigroup a, Semigroup b) => Semigroup (a, b) where (<>) @(a, b) :: (a, b) -> (a, b) -> (a, b) (a1, b1) <> @(a, b) (a2, b2) = (a1 <> @a a2, b1 <> @b b2) instance (Monoid a, Monoid b) => Monoid (a, b) where mempty @(a, b) :: (a, b) mempty @(a, b) = (mempty @a, mempty @b) instance Semigroup b => Semigroup (a -> b) where (<>) @(a -> b) :: (a -> b) -> (a -> b) -> (a -> b) (f <> @(a -> b) g) x = f x <> @b g x -- ^ not recommended style class Monoid b => Monoid (a -> b) where mempty @(a -> b) :: a -> b mempty @(a -> b) _ = mempty @b }}} The type variables should probably match the order of application a regular expression context. -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/11350#comment:12 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler
#11350: Allow visible type application in patterns -------------------------------------+------------------------------------- Reporter: Iceland_jack | Owner: Type: feature request | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.1 Resolution: | Keywords: | TypeApplications PatternSynonyms Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: #11385 | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Comment (by Iceland_jack): [https://github.com/ghc-proposals/ghc- proposals/pull/16#issuecomment-253612659 comment] {{{#!hs dynHead :: Dynamic -> Maybe Dynamic dynHead (Dyn (rxs :: TypeRep txs) (xs :: txs)) = do App rl rx <- splitApp rxs Refl <- rl `eqT` (typeRep :: TypeRep []) return (Dyn rx (head xs)) }}} can be written as (I'm not sure about the `Con` definition) {{{#!hs pattern (:<->:) :: () => fa ~ f a => TypeRep f -> TypeRep a -> TypeRep fa pattern f :<->: a <- (splitApp -> Just (App f a)) where f :<->: a = TypeApp f a pattern Con :: forall (u :: k1) (b :: k2). TypeRep u => u ~~ b => TypeRep b pattern Con <- (eqT (typeRep @k1 @u) -> Just HRefl) where Con = typeRep @k1 @u pattern :: () => [Int] ~~ t => TypeRep t pattern ListInt = Con @_ @[] :<->: Con @_ @Int }}} that should work the same as {{{#!hs pattern Int :: () => Int ~~ int => T int pattern Int <- (eqT (ty @Type @Int) -> Just HRefl) where Int = typeRep pattern List :: () => [] ~~ list => T list pattern List <- (eqT (ty @(Type -> Type) @[]) -> Just HRefl) where List = typeRep pattern :: () => [Int] ~~ t => TypeRep t pattern ListInt = List :<->: Int }}} Should also be able to be defined (?) {{{#!hs pattern Int :: () => Int ~~ int => T int pattern Int = Con @Type @Int pattern List :: () => [] ~~ list => T list pattern List = Con @(Type -> Type) @[] }}} -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/11350#comment:13 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler
#11350: Allow visible type application in patterns -------------------------------------+------------------------------------- Reporter: Iceland_jack | Owner: Type: feature request | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.1 Resolution: | Keywords: | TypeApplications PatternSynonyms Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: #11385, #13159 | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Changes (by goldfire): * related: #11385 => #11385, #13159 Comment: #13159 discusses this idea w.r.t. pattern synonyms. -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/11350#comment:14 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler
#11350: Allow visible type application in patterns -------------------------------------+------------------------------------- Reporter: Iceland_jack | Owner: Type: feature request | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.1 Resolution: | Keywords: | TypeApplications PatternSynonyms Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: #11385, #13159, | Differential Rev(s): #13158 | Wiki Page: | -------------------------------------+------------------------------------- Changes (by simonpj): * related: #11385, #13159 => #11385, #13159, #13158 -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/11350#comment:15 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler
#11350: Allow visible type application in patterns -------------------------------------+------------------------------------- Reporter: Iceland_jack | Owner: (none) Type: feature request | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.1 Resolution: | Keywords: | TypeApplications PatternSynonyms Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: #11385, #13159, | Differential Rev(s): #13158 | Wiki Page: | -------------------------------------+------------------------------------- Comment (by simonpj): #13430 points to a case from Stack Overflow where this was needed in the wild. -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/11350#comment:16 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler
#11350: Allow visible type application in patterns -------------------------------------+------------------------------------- Reporter: Iceland_jack | Owner: (none) Type: feature request | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.1 Resolution: | Keywords: | TypeApplications PatternSynonyms Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: #11385, #13159, | Differential Rev(s): #13158 | Wiki Page: | -------------------------------------+------------------------------------- Comment (by Iceland_jack): Using the types from [https://github.com/goldfirere/glambda/blob/master/src/Language/Glambda/Type.... Glambda], can we use this to implement {{{#!hs refineTy_ :: Ty -> (forall ty. ITy ty => Proxy ty -> r) -> r refineTy_ IntTy k = k @Int Proxy refineTy_ BoolTy k = k @Bool Proxy refineTy_ (Arr a b) k = refineTy a $ \(Proxy :: Proxy a_ty) -> refineTy a $ \(Proxy :: Proxy b_ty) -> k @(a_ty -> b_ty) Proxy }}} without `Proxy ty`? {{{#!hs refineTy_ :: Ty -> (forall ty. ITy ty => r) -> r refineTy_ IntTy k = k @Int refineTy_ BoolTy k = k @Bool refineTy_ (Arr a b) k = refineTy a $ \@a_ty -> refineTy a $ \@b_ty -> k @(a_ty -> b_ty) }}} -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/11350#comment:17 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler
#11350: Allow visible type application in patterns -------------------------------------+------------------------------------- Reporter: Iceland_jack | Owner: (none) Type: feature request | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.1 Resolution: | Keywords: | TypeApplications PatternSynonyms Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: #11385, #13159, | Differential Rev(s): #13158 | Wiki Page: | -------------------------------------+------------------------------------- Changes (by jeltsch): * cc: jeltsch (added) Comment: Visible type application in patterns would be ''extremely'' useful for implementing core transformations in the new version of the `incremental- computing` package. -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/11350#comment:18 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler
#11350: Allow visible type application in patterns -------------------------------------+------------------------------------- Reporter: Iceland_jack | Owner: (none) Type: feature request | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.1 Resolution: | Keywords: | TypeApplications PatternSynonyms Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: #11385, #13159, | Differential Rev(s): #13158 | Wiki Page: | -------------------------------------+------------------------------------- Comment (by simonpj):
Visible type application in patterns would be extremely useful for implementing core transformations in the new version of the incremental- computing package.
Could you distil some motivating examples from your package? It's good to know it'd be useful, but better to be able to see the usefulness. Thanks! -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/11350#comment:19 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler
#11350: Allow visible type application in patterns -------------------------------------+------------------------------------- Reporter: Iceland_jack | Owner: (none) Type: feature request | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.1 Resolution: | Keywords: | TypeApplications PatternSynonyms Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: #11385, #13159, | Differential Rev(s): #13158 | Wiki Page: | -------------------------------------+------------------------------------- Changes (by vagarenko): * cc: vagarenko (added) -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/11350#comment:20 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler
#11350: Allow visible type application in patterns -------------------------------------+------------------------------------- Reporter: Iceland_jack | Owner: (none) Type: feature request | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.1 Resolution: | Keywords: | TypeApplications PatternSynonyms Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: #11385, #13159, | Differential Rev(s): #13158 | Wiki Page: | -------------------------------------+------------------------------------- Comment (by Iceland_jack): = Paper 'Type variables in patterns' references this * [https://arxiv.org/pdf/1806.03476.pdf pdf] * [https://arxiv.org/abs/1806.03476 arXiv.org] -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/11350#comment:21 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler
#11350: Allow visible type application in patterns -------------------------------------+------------------------------------- Reporter: Iceland_jack | Owner: (none) Type: feature request | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.1 Resolution: | Keywords: | TypeApplications PatternSynonyms Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: #11385, #13159, | Differential Rev(s): #13158 | Wiki Page: | -------------------------------------+------------------------------------- Changes (by jpbernardy): * cc: jpbernardy (added) -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/11350#comment:22 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler
#11350: Allow visible type application in patterns -------------------------------------+------------------------------------- Reporter: Iceland_jack | Owner: (none) Type: feature request | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.1 Resolution: | Keywords: | TypeApplications PatternSynonyms Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: #11385, #13159, | Differential Rev(s): #13158 | Wiki Page: | -------------------------------------+------------------------------------- Comment (by goldfire): Is there any daylight between this ticket and #15530? -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/11350#comment:23 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler
participants (1)
-
GHC