April 2017 - Haskell-Cafe

What does the "S" in "ShowS" signify?
by Chris Martin 21 Apr '17

21 Apr '17

The name "ShowS" in Text.Show always been mysterious to me. Can anyone explain why it's called that?

3 2

Vacancy: Functional Software Engineer
by Damian Nadales 21 Apr '17

21 Apr '17

Hello Cafe, I'm forwarding a job opening in Eindhoven, The Netherlands. """ We are looking for an experienced software developer with good GUI development skills. Proven knowledge on the principles and working of build, test and release management through experience with several tools is required. Part of the work will be in choosing an appropriate GUI build framework catering for the different partner environments. The Model Driven Development Tool is implemented in Haskell. However, no specific Haskell knowledge is required, but hands on experience with a modern functional language is. Please contact Koen.Schilders(a)enter-group.nl """ Best regards, Damian.

1 0

Wow Monads!
by David McClain 21 Apr '17

21 Apr '17

It’s been about 15 years on/off since I first looked at Monads. This weekend I finally sat down and really learned what they are, how they work. I found what looks like the seminal paper on them by Phil Wadler: https://page.mi.fu-berlin.de/scravy/realworldhaskell/materialien/the-essenc… <https://page.mi.fu-berlin.de/scravy/realworldhaskell/materialien/the-essenc…> I’m a pretty heavy Common Lisp guy, going on 30 years with it. I also did tons of SML and OCaml programming. But I only dipped my toe into Haskell a few times. What I was looking for was a more in-depth understanding of Monads and how they work. I remember reading that Wadler paper many years ago, and I was intrigued by the conciseness of changing the interpreter to do different instrumentation. I was hoping to find a magic bullet like that for my Lisp code. And I noticed that Lisp almost never makes any mention of Monads. Surely there is a benefit that could be had… Anyone else have Lisp experience using Monads? Did it offer some major enhancements for you? - DM

12 50

Why does `mzip /= liftM2 (,)`
by Mateusz Kowalczyk 20 Apr '17

20 Apr '17

Hi, Today after half a decade I have found `MonadZip` in `base`. The laws state: ``` liftM (f *** g) (mzip ma mb) = mzip (liftM f ma) (liftM g mb) liftM (const ()) ma = liftM (const ()) mb ==> munzip (mzip ma mb) = (ma, mb) ``` The question is why does ``` mzip /= liftM2 (,) ``` in plain words. Notably we can see lack of IO instance which I'm guessing has something to do asynchronous exceptions but I'm probably wrong…. Rather than investigating for next 30 minutes, I thought I'd just sample existing knowledge (that I could not find out from Google). In what circumstances can we not replace `liftM2 (,)` with `mzip`? -- Mateusz K.

4 4

Problem with tuple with one element constrained
by Tyson Whitehead 20 Apr '17

20 Apr '17

I've been unable to get the following (simplified) code to be accepted by GHCi (8.0.1 and 8.0.2) Prelude> let (x, y) = (1, return 2) <interactive>:1:5: error: • Could not deduce (Monad m0) from the context: Num t bound by the inferred type for ‘x’: Num t => t at <interactive>:1:5-24 The type variable ‘m0’ is ambiguous • When checking that the inferred type x :: forall a (m :: * -> *) t. (Num a, Num t, Monad m) => t is as general as its inferred signature x :: forall t. Num t => t and I don't seem to be able to provide a type signatures that GHCi is okay with Prelude> let { x :: Int; y :: Monad m => m Int; (x, y) = (1, return 2) } <interactive>:5:40: error: • Ambiguous type variable ‘m0’ prevents the constraint ‘(Monad m0)’ from being solved. • When checking that the inferred type x :: forall a (m :: * -> *) t (m1 :: * -> *). (Num a, Num t, Monad m) => t is as general as its signature x :: Int Prelude> let (x, y) = (1, return 2) :: (Int, Monad m => m Int) <interactive>:4:31: error: • Illegal qualified type: Monad m => m Int GHC doesn't yet support impredicative polymorphism • In an expression type signature: (Int, Monad m => m Int) In the expression: (1, return 2) :: (Int, Monad m => m Int) In a pattern binding: (x, y) = (1, return 2) :: (Int, Monad m => m Int) Prelude> let (x,y) = (1,return 2) :: Monad m => (Int, m Int) <interactive>:7:5: error: • Ambiguous type variable ‘m0’ prevents the constraint ‘(Monad m0)’ from being solved. • When checking that the inferred type x :: forall (m :: * -> *). Monad m => Int is as general as its inferred signature x :: Int It seems the constraint on y leaks to x where it isn't well formed? Any help and/or explanations would be greatly appreciated. In my actual code the assignment is from the return value of a function so I can't just split it into two separate statements. Thanks! -Tyson

2 3

Re: [Haskell-cafe] Problem with tuple with one element constrained
by Tyson Whitehead 20 Apr '17

20 Apr '17

On Tue, Apr 18, 2017, 16:02 Joshua Grosso <jgrosso1(a)asu.edu <mailto:jgrosso1@asu.edu>> wrote: /If/ I'm understanding correctly, GHCI's complaining about the fact that `return 2` requires it to create an instance of a `Monad`, but it doesn't know which `Monad` instance it should use... Does `let (x, y) = (1, return 2) :: (Int, Maybe Int)` work (where you can replace `Maybe` with any other monad)? Hi Joshua, Thanks for the input. You are correct that if I choose a particular Monad instance GHCi accepts the code. I believe it should be able to do the assignment without choosing one though. It is, for example, okay with let y = return 2. I'm thinking Sergiu is onto something about this having to do with special GHCi handling. Thanks! -Tyson

1 0

Re: [Haskell-cafe] Haskell 2020: 'let' to be optional and with wider scope of visibility, like other Haskell functions
by Doug McIlroy 19 Apr '17

19 Apr '17

> It's just helping clean up a bit words that doesn't have much meaning. > Currently GHCi in GHC 8 is supporting this, so you could write both: > > x = 10 > x <- return 10 > > Which is great! I trust that "x = 10" above does NOT t mean the same as "let x = 10". If it did, then it wouldn't mean what it does in Haskell. Then code tried successfully in GHCI could fail in GHC. Compare this GHCI session > let x = 10 > :t x x :: Num a => a > x + 0.0 10.0 to this, in which x = 10 has its Haskell meaning > :! cat test.hs x = 10 > :load test.hs > :t x x :: Integer > x + 0.0 No instance for (Fractional Integer) arising from the literal ‘0.0’. Doug

2 1

Re: [Haskell-cafe] Where do I start if I would like help improve GHC compilation times?
by Johannes Waldmann 19 Apr '17

19 Apr '17

> it would be quite helpful if `pretty` > gained a special-case for the infinite band-width case Absolutely +1 this. Not "pretty" but similar: https://github.com/jwaldmann/wl-pprint-text/commit/7843d96db57ab01c0be336a5… - J.W.

2 1

Re: [Haskell-cafe] Wow Monads!
by David McClain 19 Apr '17

19 Apr '17

Hi Sergiu, Excellent point you make about type checking versus provably correct code. I probably allowed myself to be lulled by a false equivalence many times in the past, confusing one for the other under pressure to get something working. But then, how many programmers actually produce provably correct code? I can see that happening very easily in the small. But for overall large programs? - DM > On Apr 18, 2017, at 14:36, Sergiu Ivanov <sivanov(a)colimite.fr> wrote: > > > Hello David, > > Thanks a lot for sharing your opinions, I find it very interesting. > > Thus quoth David McClain at 19:26 on Mon, Apr 17 2017: >> >> That’s when I began migrating back over to my old standby Lisp >> system. I live inside of my Lisp all day long, for days on end. It is >> a whole ecosystem. There is not crisp boundary of edit / compile / >> debug. It is all incremental and extensional. I think that kind of >> environment, regardless of language, is the holy grail of computing. > > Just a small question: have you ever tried Smalltalk/Squeak/Pharo? (I'm > in no way affiliated.) > > These guys seem to be quite keen on blending the edit/compile/debug > boundaries. > > -- > Sergiu

2 1

Re: [Haskell-cafe] Problem with tuple with one element constrained
by Justus Adam 18 Apr '17

18 Apr '17

I am not sure really what you are trying to do, but here are a few approaches which I think may solve your problem. 1. Calculate the monadic value outside or fmap over the tuple constructor for instance do x <- functionCall return (y, x) or (y, ) <$> functionCall (uses the TupleSections extension) 2. Use explicit forall and scoped type variables If you really want to return a tuple with that monadic value from a function then the `Monad m` constraint must be on the function itself. Like so Compiled with ExplicitForAll and ScopedTypeVariables myFunction :: forall m. Monad m => m ... myFunction = let x :: m SomeType (y, x) = (..., return ...) in ... Which binds `m` to be of the same type as the outer `m`. This is necessary as there must be some way that even from outside the function we can figure out what concretely `m` actually is. Ergo it must be bound in some way to the functions type signature. 3. ExistentialTypes If you __really__ think you only need a `Monad` constraint on this type (which I doubt) you can use an existential to wrap things into generic monads. (Uses ExistentialTypes) data ExtMonad a = forall m. Monad m => ExtMonad m a The thing I don't quite understand is, if you have a function call, which produces the value, doesn't that call return a concrete monad? Rather than just `Monad m`? It sounds to me like you're actually barking up the wrong tree when you try and do what you are doing here so I suggest using something like approach 1 or 2 and perhaps rethinking if your problem may lay somewhere else. Regards Justus -- Justus Adam dev(a)justus.science On Tue, Apr 18, 2017, at 12:41 PM, Tyson Whitehead wrote: > I've been unable to get the following (simplified) code to be accepted by > GHCi (8.0.1 and 8.0.2) > > Prelude> let (x, y) = (1, return 2) > <interactive>:1:5: error: > • Could not deduce (Monad m0) > from the context: Num t > bound by the inferred type for ‘x’: > Num t => t > at <interactive>:1:5-24 > The type variable ‘m0’ is ambiguous > • When checking that the inferred type > x :: forall a (m :: * -> *) t. (Num a, Num t, Monad m) => t > is as general as its inferred signature > x :: forall t. Num t => t > > and I don't seem to be able to provide a type signatures that GHCi is > okay with > > Prelude> let { x :: Int; y :: Monad m => m Int; (x, y) = (1, return 2) } > <interactive>:5:40: error: > • Ambiguous type variable ‘m0’ > prevents the constraint ‘(Monad m0)’ from being solved. > • When checking that the inferred type > x :: forall a (m :: * -> *) t (m1 :: * -> *). > (Num a, Num t, Monad m) => > t > is as general as its signature > x :: Int > > Prelude> let (x, y) = (1, return 2) :: (Int, Monad m => m Int) > <interactive>:4:31: error: > • Illegal qualified type: Monad m => m Int > GHC doesn't yet support impredicative polymorphism > • In an expression type signature: (Int, Monad m => m Int) > In the expression: (1, return 2) :: (Int, Monad m => m Int) > In a pattern binding: > (x, y) = (1, return 2) :: (Int, Monad m => m Int) > > Prelude> let (x,y) = (1,return 2) :: Monad m => (Int, m Int) > <interactive>:7:5: error: > • Ambiguous type variable ‘m0’ > prevents the constraint ‘(Monad m0)’ from being solved. > • When checking that the inferred type > x :: forall (m :: * -> *). Monad m => Int > is as general as its inferred signature > x :: Int > > It seems the constraint on y leaks to x where it isn't well formed? Any > help and/or explanations would be greatly appreciated. In my actual code > the assignment is from the return value of a function so I can't just > split it into two separate statements. > > Thanks! -Tyson > _______________________________________________ > Haskell-Cafe mailing list > To (un)subscribe, modify options or view archives go to: > http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe > Only members subscribed via the mailman list are allowed to post.

1 0