- Haskell-Cafe - Haskell.org

unexpected compile error with wrapped HList
by Zoran Bošnjak 22 Oct '21

22 Oct '21

Hello members, I am struggling to compile the snippet below. GHC version is 8.10.4. If I try to construct the 'Variation' (with the type signature), I am getting an unexpected error. (see the comments in the code below). The error is only present if the HList is empty. I would appreciate a suggestion how to fix it. regards, Zoran --- {-# LANGUAGE DataKinds #-} {-# LANGUAGE GADTs #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE TypeOperators #-} {-# LANGUAGE PolyKinds #-} module Test where import Data.Kind data (a::k1) :<< (b::k2) infixr 5 :<< data HList (ts :: [Type]) where HNil :: HList '[] HCons :: x -> HList xs -> HList (x ': xs) data TVariation = TVariation1 | TVariation2 data Variation vt where Variation1 :: HList ts -> Variation ('TVariation1 :<< ts) Variation2 :: HList ts -> Variation ('TVariation2 :<< ts) -- This works as expected, including the explicit type signature. x1 :: Variation ('TVariation1 :<< '[()]) x1 = Variation1 (HCons () HNil) -- But the following 2 cases do not work as expected. -- 1. problem: -- This 'x0' type is inferred by GHC, -- but when specified as such, it won't compile. {- • Couldn't match type ‘k’ with ‘*’ ‘k’ is a rigid type variable bound by the type signature for: x0 :: forall k. Variation ('TVariation1 :<< '[]) at adhoc/test.hs:39:1-38 Expected type: Variation ((:<<) @TVariation @[k] 'TVariation1 ('[] @k)) Actual type: Variation ((:<<) @TVariation @[*] 'TVariation1 ('[] @*)) • In the expression: Variation1 HNil In an equation for ‘x0’: x0 = Variation1 HNil • Relevant bindings include x0 :: Variation ('TVariation1 :<< '[]) (bound at adhoc/test.hs:40:1) -} x0 :: Variation ('TVariation1 :<< '[]) x0 = Variation1 HNil class Empty t where mkEmpty :: t -- 2. problem: -- This instance declaration reports the same problem (as in x0 above). instance Empty (Variation ('TVariation1 :<< '[])) where mkEmpty = Variation1 HNil

2 1

Downsides to disabling unticked-promoted-constructor warning?
by Markus Läll 21 Oct '21

21 Oct '21

Hi! Is there any consensus on unticked promoted constructors -- are they generally safe to use? Currently the warning is part of -Wall, but having promoted constructors unticked is just aesthetically nicer. Thanks, -- Markus Läll

4 5

You're invited to the October virtual Haskell CoHack
by Chris Smith 19 Oct '21

19 Oct '21

Hi everyone, This Saturday, I’m once again hosting a virtual Haskell CoHack. In the past, we’ve had a great time with groups here working on various projects, whether it’s learning Haskell, hacking on GHC, writing documentation, making progress on personal projects, or just hanging out to chat with like-minded folk. You should consider coming if you would be excited to meet fellow Haskell programmers and work or learn together with them. There are details, including times, on the meetup page: https://www.meetup.com/NY-Haskell/events/280998863

1 0

GDB and ticks
by Henning Thielemann 18 Oct '21

18 Oct '21

I am stepping through a Haskell program using the GNU debugger GDB and see function calls to handle_tick, handleProfTick, stopTicker all over the place. It sounds like they would manage profiling, but I compiled the executable without profiling.

5 8

Looking for ESOP'22 AEC members
by Andreea Costea 18 Oct '21

18 Oct '21

For the first time since its foundation, ESOP will carry out an Artifact Evaluation process. The goal is to share with the community the research artefacts of papers accepted to its research track, acknowledging those works which have been rigorously implemented, tested and documented. To this purpose, we are looking for motivated students and postdocs to be members of the ESOP 2022 Artifact Evaluation Committee (AEC). The primary responsibility of an AEC member is to run the associated tools and confirm the results reported in the papers. If you know someone suitable for this role, please nominate them in the following form (or share the form with them for self-nomination): https://t.co/Jqa7edDqTg?amp=1 Come join us in this effort! Kind Regards, Andreea Costea and KC Sivaramakrishnan, AEC Co-Chairs of ESOP 2022

1 0

Bug in Data.Bits.shift?
by Keith 17 Oct '21

17 Oct '21

As currently defined, `shift x minBound` calls `shiftR` with a negative displacement. This would avoid that: ``` shift x n | n >= 0 = shiftL x n | n == minBound = shiftR (shiftR x maxBound) 1 | otherwise = shiftR x (-n) ``` P.S. Philosophically, `rotate` on a negative `Integer` should do sign extension in the least significant bits (though by the description of `rotate` it should not...). — Sent from my phone with K-9 Mail.

3 3

Resources on how to implement (Haskell 98) kind-checking?
by Benjamin Redelings 16 Oct '21

16 Oct '21

Hi, 1. I'm looking for resources that describe how to implement kind Haskell 98 checking. Does anyone have any suggestions? * I've looked at the PolyKinds paper, but it doesn't cover type classes. * I've looked at the source code to GHC, but it is hard to follow for a variety of reasons. It isn't laid out like an algorithm description, and the complexity to handle options like PolyKinds and DataKinds makes the code harder to follow. 2. One question that came up is how to handle type variables that are present in class methods, but are not type class parameters. If there are multiple types/classes in a single recursive group, the kind of such type variables might not be fully resolved until a later type-or-class is processed. Is there a recommended approach? I can see two ways to proceed: i) First determine the kinds of all the data types, classes, and type synonyms. Then perform a second pass over each type or class to determine the kinds of type variables (in class methods) that are not type class parameters. ii) Alternatively, record the kind of each type variable as it is encountered -- even though such kinds may contain unification kind variables. After visiting all types-or-classes in the recursive group, replace any kind variables with their definition, or with a * if there is no definition. I've currently implement approach i), which requires doing kind inference on class methods twice. Is this the recommended approach? 3. Also, is Haskell 98 kind checking the same as Haskell 2010 kind checking? -BenRI

8 12

Public floggings
by Michael Turner 13 Oct '21

13 Oct '21

>> Aside: to this day, that sort of ad-hoc syntax makes me gag. K&R should be > publicly flogged on a regular basis. Since I'm to blame for raising the subject that turned into a thread about "the right exposition", I hereby surrender myself to be flogged in lieu of the intended. I've deserved it for years, just for how I've found perversely delightful ways to use the C preprocessor. Especially token-pasting. K&R (the book) was almost indecent exposure -- it left nothing to the imagination. As opposed to most writing on Haskell, where I'm befuddled because it's not at all obvious how it does its thing. It's like you're not /supposed/ to know. But K&R let it all hang out, and for that reason, I loved it. Whip me, beat me, make me write C code. Because that's just the kind of pervert I am. Still, sometimes. Regards, Michael Turner Executive Director Project Persephone 1-25-33 Takadanobaba Shinjuku-ku Tokyo 169-0075 Mobile: +81 (90) 5203-8682 turner(a)projectpersephone.org Understand - http://www.projectpersephone.org/ Join - http://www.facebook.com/groups/ProjectPersephone/ Donate - http://www.patreon.com/ProjectPersephone Volunteer - https://github.com/ProjectPersephone "Love does not consist in gazing at each other, but in looking outward together in the same direction." -- Antoine de Saint-Exupéry

2 1

[ANN] linear-generics
by David Feuer 12 Oct '21

12 Oct '21

I am pleased to announce the release of a new package, linear-generics[*], based on GHC.Generics and the venerable generic-deriving. The killer features: 1. Generic1 representations associate compositions the right way around, which is to say the *left* way around, meaning no more inefficient fmaps or pesky Functor constraints. 2. to, from, to1, and from1 are multiplicity polymorphic, so you can use them in all your fancy new linearly typed code. The package includes Template Haskell-based deriving, based closely on generic-deriving, which is the recommended way to write instances. There is also a limited, somewhat unsafe, and somewhat inefficient way using provided DerivingVia targets. Many thanks to Arnaud Spiwack and Ryan Scott for valuable advice and assistance. [*] https://hackage.haskell.org/package/linear-generics

1 0

Partially applied type synonyms
by Ttt Mmm 09 Oct '21

09 Oct '21

I was surprised to find the below code doesn't typecheck even with -XLiberalTypeSynonyms. Am I missing something or is this really not possible? Thanks, Tom --- {-# LANGUAGE FlexibleInstances, KindSignatures, LiberalTypeSynonyms, StandaloneDeriving #-} -- This works: data Foo s x = Foo (s x) x deriving (Eq) -- This replacement doesn't: {- data Foo' sx x = Foo' sx x deriving (Eq) type Foo (s :: * -> *) (x :: *) = Foo' (s x) x -} data Bar (m :: * -> *) = Bar (m Int) -- Neither of these typecheck: x :: Bar (Foo Maybe) x = undefined deriving instance Eq (Bar (Foo Maybe))

3 6