September 2017 - Haskell-Cafe

Archival of community.haskell.org
by Mario Rogic 19 May '18

19 May '18

Hi all As announced back in 2015 <http://blog.haskell.org/post/7/the_future_of_community.haskell.org/> we have started archiving community.haskell.org services. We've created https://archives.haskell.org/, and the old projects mailing lists have been the first to be archived. Next on the list is the remainder of projects.haskell.org, and the code.haskell.org site. As always, you can email admin(a)h.o or hop on the #haskell-infrastructure freenode channel to provide feedback / concerns. Thanks - Mario

1 2

Join a transformer
by Michael Snoyman 11 Apr '18

11 Apr '18

I'm wondering if this pattern exists and has a name. We have the concept of joining a Monad: join :: Monad m => m (m a) -> ma How about joining a monad transformer? joinT :: (Monad m, MonadTrans t) => t (t m) a -> t m a I believe implementing this in terms of MonadTransControl[1] might be possible, but I was wondering if there's an already existing idiom for this. Michael [1] http://haddocks.fpcomplete.com/fp/7.4.2/20130301-40/monad-control/Control-M…

5 5

PatternSignatures (rant)
by Johannes Waldmann 06 Apr '18

06 Apr '18

Dear all, (this is a rant - please ignore) why has "PatternSignatures" been renamed to "ScopedTypeVariables" (in ghc-6.10)? show me the alleged "type variable" in this code: do x :: Int <- [ 1 .. 10 ] ; return $ x^2 and why on earth do I need to use a language extension at all to get to the most basic thing of declarative programming: to declare the type of an identifier? This seriously hurts (me, at least) when teaching Haskell. Thanks - J.W.

4 4

Why is Haskell so slow (comparing to Java/Scala)?
by Станислав Черничкин 23 Oct '17

23 Oct '17

I've wrote simple Haskell benchmark program, which populated primitive vector from vector package: import Data.Vector.Primitive.Mutable as P vectorBench :: Benchmark vectorBench = bgroup "vector" [ primitive ] where primitive = bgroup "primitive" [ write1M ] where write1M = bench "write1M" $ nfIO $ do v <- P.unsafeNew 1000000 void $ for [0..1000000 - 1] $ flip (P.unsafeWrite v) (1 :: Int) return () I use `unsafeNew` to skip memory initialization and `unsafeWrite` to skip boundary checks, I guess it's fastest possible way to write something to vector. My result was about 40 ms. I wrote similar program in Scala: for (_ <- 1 to 5) { val start = System.currentTimeMillis() val a = new Array[Long](1000000) for (i <- 0 until 1000000) { a(i) = 1L } val end = System.currentTimeMillis() println(s"${end - start} ms") } I skip neither boundary checks nor memory initialization, I also used generic array here (suitable for any types of objects, not just for primitive types), so I expected longer run time. But what I got was shocking: 7 ms 3 ms 2 ms 1 ms 2 ms This program runs 20-40 times faster than Haskell after warm-up. 20-40 times, Carl! Why is Haskell soo slooooow? How can it be? -- Sincerely, Stanislav Chernichkin.

6 6

Determine instance method from class method callsite
by Robin Palotai 06 Oct '17

06 Oct '17

Sorry, I messed up subject and mailing list. Copying to both list now after the mistake (wanted only ghc-devs for specificity). Thanks! 2017-09-19 7:36 GMT+02:00 Robin Palotai <palotai.robin(a)gmail.com>: > Hello GHC devs, > > Before inventing the wheel, want to check if there is a GHC API way to > look up the (fully) resolved instance method from a class method. > > For example, given a code > > data Foo Int deriving Show > > bar = show (Foo 3) > > when inspecting the Typechecked AST for bar's show call, I would like to > get to the Name / Id of 'show' of the 'Show' typeclass. > > I believe I could use splitHsSigmaTy on the HsType of the function call to > get the context, and then evaluate the HsWrapper somehow to find out what > instance dictionary is applied to the class restriction in the context, and > then look up the instance method from the dictionary.. > > Two questions: > > 1) Is there maybe functionality for this? > > 2) If not, is there any guarantee about the constraint order in the > context, at the method call? So I could more easily determine which > constraint's application to look for.. > > Any hints welcome && Thank you! > Robin >

2 5

EduHaskell
by erwig 02 Oct '17

02 Oct '17

Dear Haskell aficionados, We will be using Haskell in an introductory course to computer science for college freshmen. From my past experience in using Haskell for students, the biggest hurdle and source of frustration is the type checker, or more precisely, the error messages generated. I see three major kinds of errors that get in the way of a smoother programming experience: * Errors resulting from overloading * Errors due to undefined type class instances (specifically, Eq and Show) * Errors in the context of parametric polymorphism While these problems are not unsurmountable, having to talk about these errors is a distraction from the major goal of explaining basics of (functional) programming. It would be great to have a Haskell compiler that offers the following features (and maybe others): * Type classes and overloading could be turned off * Eq and Show (and maybe Ord) instances would be automatically defined for any data type definition (when type classes are enabled) My questions are: (1) Does there exist a good solution to this problem already? Should one use Helium? I haven't checked lately, but it used to avoid type classes. This might have the disadvantage of having to switch to GHC in case one wants to use overloading. (I have used Helium in the past, and while I admire the effort, I am not sure it's the best option.) Are there versions of the Prelude available that accomplish some of this? (2) Are there other Haskellers out there who also want a simpler, more educationally suited version of GHCi? (3) If the answer to (1) is NO and to (2) is YES, is there any interest in forming a group for creating something like "EduHaskell"? I'd be grateful for any comments or suggestions! Thanks, Martin

7 7

Mutable data structures and asynchronous exceptions
by Станислав Черничкин 30 Sep '17

30 Sep '17

It's quite hard to implement mutable data structures in presence of asynchronous exceptions. Since exception can arise at any point, it is not possible to guarantee atomicity of operation, hence mutable data structure may remain in incorrect state in case of interruption. One can certainly use maskAsyncExceptions# and friends to protect critical regions, but masking function are living in IO, mutable data structures on other hand trend to be state-polymorphic (to allow it usage in ST). This lead to conflicting requirements: - One should not care about asynchronous exceptions inside ST (it is not possible to catch exception in ST, hence not possible to use something in invalid state). More over, it is not even possible to do write “exception-safe” code, because masking functions not available. - One should provide accurate masking then using same data structures in IO. So I want do discuss several questions topics on this case. 1. Impact. Are async exceptions really common? Would not be easier to say: “ok, things can go bad if you combine async exceptions with mutable data structures, just don't do it”. 2. Documentation. Should library authors explicitly mention async exceptions safety? For example https://hackage.haskell.org/package/hashtables – is it async exceptions safe when used in IO? Or even worse https://hackage.haskell.org/package/ghc-prim-0.5.1.0/docs/GHC-Prim.html#v:r… - what will happened in case of async exception? This functions is sate-polimorphic, will it implicitly mask exceptions if used from IO? 3. Best practices. How should we deal with problem? Is creating separate versions of code for ST and IO is the only way? Probably it is possible to add “mask” to something like https://hackage.haskell.org/package/primitive-0.6.2.0/docs/Control-Monad-Pr… emit mask in IO instance and NOOP in ST version? Or maybe somebody know better patterns for async exeption safe code? -- Sincerely, Stanislav Chernichkin.

5 5

Reinventing the wheel? Does any existing package provide an applicatively lifted (>>) ?
by Viktor Dukhovni 28 Sep '17

28 Sep '17

When generating a report file from a database I found it much more efficient (significantly shorter runtime) to represent each row by an I/O action that prints the row, rather than to construct a Row object that to print and throw away. But the naive way to construct the I/O action can be tedious to maintain once the column count gets appreciably high: newtype Foo = Foo { _foo :: IO () } instance FromRow Foo where fromRow = Foo <$> (rowPrinter <$> field <*> field <*> field <*> ... <*> field) where rowPrinter :: Type1 -> Type2 -> Type3 -> ... -> TypeN -> IO () rowPrinter p1 p2 p3 ... pN = do printP1 printP2 printP3 ... printPN So I decided to applicatively decompose the rowPrinter function (with the actual name of "andthen" to be determined later) as: rowPrinter = (printP1 <$> field) `andthen` (printP2 <$> field) `andthen` (printP3 <$> field) `andthen` ... (printPN <$> field) which avoids the need to package the column printers explicitly into a single function, and may be somewhat more efficient a well. What was not immediately obvious to me was whether there's an "off the shelf" implementation of "andthen" I could just reuse. The necessary operator satisfies: andthen (f (m a)) (f (m b)) = f (ma >> mb) or, equivalently: a `andthen` b = (>>) <$> a <*> b for which http://pointree.io dutifully gives me: andthen = (<*>) . ((>>) <$>) Its type signature is: Prelude> :set prompt "l> " l> :m + Control.Applicative l> :m + Control.Monad l> :t ((<*>) . ((>>) <$>)) ((<*>) . ((>>) <$>)) :: (Monad m, Applicative f) => f (m a) -> f (m b) -> f (m b) l> It seems to me that this would have been done before, and the operator would already be present in some package, but I'm having trouble finding it. (Due to the hidden constructors of FromRow defining a Semigroup does not work out here, so I can't use (<>), which also inconveniently conflicts with Monoid (<>)). So my question is whether the operator in question is already available, under some name in some package, or else suggested names for it if new. -- Viktor.

5 6

[ANN] brittany-0.8.0.3
by lennart spitzner 28 Sep '17

28 Sep '17

- Support for ghc-8.2.1 - Fix quadratic performance bug full changelog at https://hackage.haskell.org/package/brittany-0.8.0.3/changelog -- lennart

1 0

[hs-bibutils] intention to take over package
by Václav Haisman 28 Sep '17

28 Sep '17

Hi. I would like to take over the hs-bibutils Hackage package. It has not been updated since 2014, the listed maintainer is not responsive to emails, and listed home page is 404 page. -- VH

1 1