- ghc-tickets - Haskell.org

[GHC] #12510: GHC.Prim.~# shows up unexpectedly in a pattern synonym type
by GHC 22 Aug '16

22 Aug '16

#12510: GHC.Prim.~# shows up unexpectedly in a pattern synonym type -------------------------------------+------------------------------------- Reporter: goldfire | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.0.1 Keywords: | Operating System: Unknown/Multiple Architecture: | Type of failure: None/Unknown Unknown/Multiple | Test Case: | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- When I load {{{ data T a where MkT :: Bool -> T Bool pattern P x <- MkT x }}} into GHCi and ask `:info P`, I get {{{ pattern P :: () => t GHC.Prim.~# Bool => Bool -> T t }}} That should say `t ~ Bool` without `-fprint-equality-relations`. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/12510> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 2

[GHC] #12465: Evil idea: Allow empty record field update syntax for types.
by GHC 21 Aug '16

21 Aug '16

#12465: Evil idea: Allow empty record field update syntax for types. -------------------------------------+------------------------------------- Reporter: Iceland_jack | Owner: Type: feature | Status: new request | Priority: normal | Milestone: Component: Compiler | Version: 8.0.1 Keywords: | Operating System: Unknown/Multiple Architecture: | Type of failure: None/Unknown Unknown/Multiple | Test Case: | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- Use case: Visible type application. I often work with constructors with many arguments, then I want to instantiate type variables with them: {{{#!hs show @(Vector _ _) :: Show a => Vector n a -> String -- Type arguments reversed, see https://github.com/ekmett/distributive/pull/18 cotraverse @_ @(Vector _) :: (NATTY n, Functor f) => (f a -> b) -> (f (Vector n a) -> Vector n a') fmap @(Bazaar _ _ _) :: (t -> t') -> (Bazaar p a b t -> Bazaar p a b t') show @(Magma _ _ _ _) :: (Show a, Show i) => Magma i t b a -> String }}} This makes no sense since types have nothing to do with record or updates thereof but that syntax is often used to avoid parentheses and unneeded wildcard arguments: {{{#!hs isBar (Bar _ _ _ _ _) = True -- ===> isBar Bar{} = True }}} This also means you don't need to worry about the kind of your constructor wrt the type (class) variable it instantiates. ---- Thus the proposal is to allow: {{{#!hs show @Vector{} :: Show a => Vector n a -> String cotraverse @_ @Vector{} :: (NATTY n, Functor f) => (f a -> b) -> (f (Vector n a) -> Vector n a') fmap @Bazaar{} :: (t -> t') -> (Bazaar p a b t -> Bazaar p a b t') show @Magma{} :: (Show a, Show i) => Magma i t b a -> String }}} ---- This would save quite a few keystrokes in my daily coding but more importantly it saves cognitive load but I expect skepticism, especially since GHC would have to determine whether to interpret `show @Vector{}` to `show @Vector`, `show @(Vector _n)` or `show @(Vector _n _a)`. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/12465> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 4

[GHC] #12508: Show evaluation step-by-step in GHCi
by GHC 21 Aug '16

21 Aug '16

#12508: Show evaluation step-by-step in GHCi -------------------------------------+------------------------------------- Reporter: Hi-Angel | Owner: Type: feature | Status: new request | Priority: normal | Milestone: Component: GHCi | Version: 8.0.1 Keywords: interactive | Operating System: Unknown/Multiple evaluation debugging | Architecture: | Type of failure: None/Unknown Unknown/Multiple | Test Case: | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- The ability see every evaluation step for executing a particular code in ghci is needed. Earlier that could have [[http://stackoverflow.com/a/554391/2388257|done in HAT]], or ghc-vis. But as of today, HAT doesn't compile even with stack. And, at least personally for me, neither ghc-vis could be installed. I want to point out that the funcionality is **very** important for the language. Without that ''(i.e. as it is now)'' it is impossible for newcomers to see how a particular construction going to be evaluated, how much memory it going to take. Nowadays newcomers have to deal with memory issues post-mortem: an app takes all system memory, dies, then one build everything for profiling, and start playing a Battleship with the allocation graph; which going to be a hard game, unless you're experienced enough to not even allow that to happen most of the times. However, if there was a way to execute functions in GHCI, looking the evaluation step-by-step, days of hard debugging would turn into a few hours of executing a couple of functions in ghci. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/12508> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 0

Re: [GHC] #2893: Implement "Quantified contexts" proposal
by GHC 20 Aug '16

20 Aug '16

#2893: Implement "Quantified contexts" proposal -------------------------------------+------------------------------------- Reporter: porges | Owner: Type: feature request | Status: new Priority: normal | Milestone: ⊥ Component: Compiler | Version: 6.10.1 Resolution: | Keywords: proposal 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 RyanGlScott): Iceland_jack, there are two problems with using typeclasses like these to "solve" this problem: 1. They're based on explicit `Dict` values. As a result, using them requires lots of pattern matching and type variable scoping hullabaloo, which gets annoying pretty quickly. 2. What does it mean to automatically generate instances for `(:=>)`? Do we only generate instances that correspond to actual instance contexts? If so, then the following would typecheck, since there is an `instance () :=> Eq ()`: {{{#!hs ins :: () :- Eq () }}} But the following would //not// typecheck! {{{#!hs ins :: Eq () :- Eq () }}} Because there is no `instance Eq () => Eq ()` anywhere (and thus no `instance Eq () :=> Eq ()`), only `instance Eq ()`. But the implication `Eq () => Eq ()` should obviously hold. Does that mean we should also generate an `instance Eq () :=> Eq ()` automatically? But what about `(Eq (), Ord ()) => Eq ()`? `(Eq (), Ord (), Show ()) => Eq ()`? There is an extremely high number of contexts in which `Eq ()` holds, and generating every possible one of them would result in a combinatorial explosion. While those classes are neat tricks that can get you some of the functionality of `QuantifiedConstraints`/`ImplicationConstraints`, they don't go all the way. I really feel that some compiler smarts would make these features manageable. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/2893#comment:20> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 0

Re: [GHC] #2893: Implement "Quantified contexts" proposal
by GHC 20 Aug '16

20 Aug '16

#2893: Implement "Quantified contexts" proposal -------------------------------------+------------------------------------- Reporter: porges | Owner: Type: feature request | Status: new Priority: normal | Milestone: ⊥ Component: Compiler | Version: 6.10.1 Resolution: | Keywords: proposal 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): Has there been any discussion about GHC generating instances of [https://hackage.haskell.org/package/constraints-0.8/docs/Data- Constraint.html#t::-61--62- :=>] and [https://hackage.haskell.org/package/constraints-0.8/docs/Data- Constraint.html#t:Class Class]: {{{#!hs -- Given -- class Foo a => Bar a -- GHC should generate -- instance Class (Foo a) (Bar a) where -- cls :: Bar a :- Foo a -- cls = Sub Dict class Class b h | h -> b where cls :: h :- b }}} or [https://hackage.haskell.org/package/constraints-0.8/docs/Data- Constraint-Lifting.html#t:Lifting Lifting] {{{#!hs class Lifting p f where lifting :: p a :- p (f a) class Lifting2 p f where lifting2 :: p a :- Lifting p (f a) }}} -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/2893#comment:19> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 0

Re: [GHC] #5927: A type-level "implies" constraint on Constraints
by GHC 20 Aug '16

20 Aug '16

#5927: A type-level "implies" constraint on Constraints -------------------------------------+------------------------------------- Reporter: illissius | Owner: Type: feature request | Status: new Priority: normal | Milestone: Component: Compiler (Type | Version: 7.4.1 checker) | Resolution: | Keywords: 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): Would this `Show` instance for [https://www.reddit.com/r/haskell/comments/2ag8h2/recovering_preconditions_f… Fmt] work with `ImplicationConstraints` (`(=>) :: Constraints -> Constraints -> Constraints`): {{{#!hs data Fmt :: (* -> Constraint) -> (* -> *) -> * -> * where Int :: p Int => Fmt p r Int (:&) :: (p a, p b, p (a,b)) => Fmt p r a -> Fmt p r b -> Fmt p r (a,b) Lift :: p (r a) => r a -> Fmt p r a instance (p => Show) => (Show (Fmt ctx r a) where show t = case t of Int -> "Int" l :& r -> show l ++ "&" ++ show r Lift r -> show r }}} A question on `QuantifiedConstraints` on this same example in ticket:2893#comment18. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/5927#comment:19> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 0

Re: [GHC] #2893: Implement "Quantified contexts" proposal
by GHC 20 Aug '16

20 Aug '16

#2893: Implement "Quantified contexts" proposal -------------------------------------+------------------------------------- Reporter: porges | Owner: Type: feature request | Status: new Priority: normal | Milestone: ⊥ Component: Compiler | Version: 6.10.1 Resolution: | Keywords: proposal 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 functionality does my head in so bear with me. In the definition of [https://www.reddit.com/r/haskell/comments/2ag8h2/recovering_preconditions_f… Fmt], constraints of `(p a, p b, p (a, b))` are assumed for `:&` {{{#!hs data Fmt :: (* -> Constraint) -> (* -> *) -> * -> * where Int :: p Int => Fmt p r Int (:&) :: (p a, p b, p (a,b)) => Fmt p r a -> Fmt p r b -> Fmt p r (a,b) Lift :: p (r a) => r a -> Fmt p r a }}} `(p a, p b)` often implies `p (a, b)`, would this be captured by `QuantifiedConstraints`? {{{#!hs (:&) :: (p a, p b, forall xx yy. (p xx, p yy) => p (xx, yy)) => Fmt p r a -> Fmt p r b -> Fmt p r (a,b) }}} Does this even give us any additional power? Is this more or less powerful than the `:=>` class from [https://hackage.haskell.org/package/constraints constraints]? {{{#!hs class b :=> h | h -> b where ins :: b :- h instance (Eq a, Eq b) :=> Eq (a, b) where ins = Sub Dict instance (Ord a, Ord b) :=> Ord (a, b) where ins = Sub Dict instance (Show a, Show b) :=> Show (a, b) where ins = Sub Dict instance (Read a, Read b) :=> Read (a, b) where ins = Sub Dict instance (Bounded a, Bounded b) :=> Bounded (a, b) where ins = Sub Dict instance (Monoid a, Monoid b) :=> Monoid (a, b) where ins = Sub Dict ... }}} What if we assume that GHC generates instances of `:=>`? -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/2893#comment:18> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 0

Re: [GHC] #2893: Implement "Quantified contexts" proposal
by GHC 20 Aug '16

20 Aug '16

#2893: Implement "Quantified contexts" proposal -------------------------------------+------------------------------------- Reporter: porges | Owner: Type: feature request | Status: new Priority: normal | Milestone: ⊥ Component: Compiler | Version: 6.10.1 Resolution: | Keywords: proposal 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): Moved from #5927. Use case from [http://ozark.hendrix.edu/~yorgey/pub/twisted.pdf How to Twist Pointers without Breaking Them]: > {{{#!hs > class Monoid m => Action m a where > act :: m -> a -> a > }}} > ''[...]'' > > We first formalise the action of monoids on functors. Intuitively, for a monoid `m` to act on the functor `f`, it should act in a uniform way on all the types `f a`. Therefore, we would like to assert a constraint something like `forall a. Action m (f a)`. Unfortunately, Haskell does not allow the use of universally quantified constraints and hence we need a new type class. > > {{{#!hs > class (Monoid m, Functor f) => ActionF m f where > act' :: m -> f a -> f a > }}} -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/2893#comment:17> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 0

[GHC] #12239: Dependent type family does not reduce
by GHC 20 Aug '16

20 Aug '16

#12239: Dependent type family does not reduce -------------------------------------+------------------------------------- Reporter: int-index | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.0.1 (Type checker) | Keywords: TypeInType, | Operating System: Unknown/Multiple TypeFamilies | Architecture: | Type of failure: GHC rejects Unknown/Multiple | valid program Test Case: | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- When a type family is used in a kind of an argument for another type family, it does not reduce. Here's example code: {{{ {-# LANGUAGE TypeInType, GADTs, TypeFamilies #-} import Data.Kind (Type) data N = Z | S N data Fin :: N -> Type where FZ :: Fin (S n) FS :: Fin n -> Fin (S n) type family FieldCount (t :: Type) :: N type family FieldType (t :: Type) (i :: Fin (FieldCount t)) :: Type data T type instance FieldCount T = S (S (S Z)) type instance FieldType T FZ = Int type instance FieldType T (FS FZ) = Bool type instance FieldType T (FS (FS FZ)) = String }}} Unfortunately, I get these errors during typechecking: {{{ [1 of 1] Compiling Main ( fieldtype.hs, fieldtype.o ) fieldtype.hs:19:27: error: • Expected kind ‘Fin (FieldCount T)’, but ‘'FZ’ has kind ‘Fin ('S n0)’ • In the second argument of ‘FieldType’, namely ‘FZ’ In the type instance declaration for ‘FieldType’ fieldtype.hs:20:28: error: • Expected kind ‘Fin (FieldCount T)’, but ‘'FS 'FZ’ has kind ‘Fin ('S ('S n0))’ • In the second argument of ‘FieldType’, namely ‘FS FZ’ In the type instance declaration for ‘FieldType’ fieldtype.hs:21:28: error: • Expected kind ‘Fin (FieldCount T)’, but ‘'FS ('FS 'FZ)’ has kind ‘Fin ('S ('S ('S n0)))’ • In the second argument of ‘FieldType’, namely ‘FS (FS FZ)’ In the type instance declaration for ‘FieldType’ }}} -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/12239> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 11

[GHC] #12505: Add foldl1' to Data.Foldable
by GHC 20 Aug '16

20 Aug '16

#12505: Add foldl1' to Data.Foldable -------------------------------------+------------------------------------- Reporter: tserduke | Owner: Type: feature | Status: new request | Priority: normal | Milestone: Component: | Version: 8.1 libraries/base | Keywords: | Operating System: Unknown/Multiple Architecture: | Type of failure: None/Unknown Unknown/Multiple | Test Case: | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- With the change strict `Foldable` instances could be written in a simple and performant manner: {{{#!hs maximum = foldl1' max minimum = foldl1' min sum = foldl1' (+) product = foldl1' (*) }}} Also `foldl1'` from `Data.List` gets generalized. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/12505> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 0