- Haskell-Cafe - Haskell.org

[ANN] aeson 0.11.0.0
by Adam Bergmark 09 Feb '16

09 Feb '16

Hi haskellers, As a new co-maintainer of aeson I'm happy to announce aeson 0.11.0.0[1]. v0.10 had a number of issues and v0.11 aims to fix all of these. I'm happy to see that all known regressions have been fixed, and I didn't have to write any code myself! ;) Going 0.9 to 0.11 should be no work for most users. I've built all packages in stackage nightly[2] and out of 222 only one needs a non-trivial change (sorry pagerduty maintainers!) Please help out by letting us know if we missed something, including if something should be added to the CHANGELOG[3]. A big thanks to everyone who contributed code to this release: Bryan O'Sullivan Bas van Dijk Oleg Grenrus Herbert Valerio Riedel Ben Weitzman Daniel Díaz RyanGlScott David Johnson Artyom Cale Gibbard Mikhail Glushenkov Ondrej Palkovsky Tim Bodeit mrkkrp And a thank you to everyone else who helped in other ways! All the best, Adam [1] https://hackage.haskell.org/package/aeson-0.11.0.0 [2] https://github.com/bos/aeson/issues/355 [3] https://github.com/bos/aeson/blob/master/changelog.md

2 1

Pulling an applicative/apply out of a record
by Tyson Whitehead 08 Feb '16

08 Feb '16

Quick question for the experts out there. I need to process some records. The records come in in an unordered stream of record fields. From each stream of fields I want to produce a Record entry containing the fields I need to do my calculation. > data Record = { field1 :: Type1, field2 :: Type2, ... } I was thinking this setup might work nice with something like > data RecordF d = RecordF { field1 :: f Type1, field2 :: f Type2, ... } as I could then have (1) a monoid version I could accumulate use as an accumulator over the stream > type RecordM = RecordF [] and (2) a final version. > type Record = RecordF Identity This final version seems like it should easily come from the later by pulling the [] (or anything else that has the Apply/Applicative structure) to the outside and then taking the head of the resulting list. While I could write the boilerplate to do this, it seems like something I should be able to do more elegantly. The best I have come up with so far is to use the lens package to give me an isomorphism to a tuple. Then I need a uncurried zip for arbitrarily large tuples. Follow this by an isomorphism back. RecordF (f Type1) (f Type2) ... -> (f Type1, f Type2, ....) -> f (Type1, Type2, ...) -> f (Record Type1 Type2 ...) I can't seem to find any uncurried zip implementations for arbitrarily large tuples (or any other way to do this without writing the boilerplate). Am I missing something? Is there a better way to do this? Thanks! -Tyson PS: It seems the Data.Vinyl package has something along these lines with the rtraverse function https://hackage.haskell.org/package/vinyl-0.5.1/docs/Data-Vinyl-Core.html

3 3

Incredibly slow type-level Nub
by Nickolay Kudasov 08 Feb '16

08 Feb '16

Dear Cafe, I have faced a type-level performance problem (with GHC 7.10.3). I am trying to implement type-level Nub which removes duplicates from a type-level list. My implementation [1] with an example of a list of length 20 takes forever to compile. If you reduce the size of the example list (e.g. to 15 items), it will compile faster. Also, if you remove the Nub application from exampleVals, it compiles instantly (this is how I know the problem is in Nub). My question is how can I speed up type-level Nub? And less importantly why exactly is it this slow? The practical application for this is building automatic tests [2] for servant-swagger. There I am interested in generating exactly one test for each distinct type. Kind regards, Nick [1] https://gist.github.com/fizruk/06458fe8b62a1e562af1 [2] http://hackage.haskell.org/package/servant-swagger-1.0.2/docs/Servant-Swagg…

4 6

RebindableSyntax, ifThenElse, and pattern matching
by Chris Smith 08 Feb '16

08 Feb '16

In a custom prelude, I have written the following definitions: data Truth = True | False ifThenElse :: Truth -> a -> a -> a ifThenElse True x _ = x ifThenElse False _ x = x (==) :: a -> a -> Truth (==) = ... I'm replacing Bool with my own Truth type. Clients will be built with RebindableSyntax, so that they will use these definitions for desugaring. However, if I write this: f :: Text -> Text f "r" = "rrr" f other = other I get a build error indicating that GHC expected the (==) operator to return a value of type Bool, rather than Truth. Shouldn't pattern matching desugar to use overloaded ifThenElse in these situations? Or is it expected that use of GHC.Types.Bool is hard-coded even with RebindableSyntax enabled? Thanks, Chris

3 3

Re: [Haskell-cafe] Language complexity & beginners
by Gregory Guthrie 07 Feb '16

07 Feb '16

I liked this description, and isn't the term for this a "leaky abstraction"? Where one should not have to know the underlying details of an implementation of an abstraction, but.. due to limitations in the ability to actually abstract out these details, they do have to see down a level into the virtual machine (implementation). It seems like a theme of the discussion here is if users should need (want) to know the boxed/unboxed issues because it is part of the intended programming model (=good), or if they need to know it because of "details" of the underlying implementation and resulting usage effects (=baggage/complexity). IMHO the Java need to understand this early on is just an unfortunate by-product of it being a mixed paradigm language. I could see later having more advanced introduction of a feature that allows one to utilize some specific underlying unboxed/primitive representations for performance reasons, but even then seems like it is just an apology for a language weakness, that might go away with future implementations, an abstraction that didn't quite work, "so let me explain the underlying reason and how to get around it..." to optimize your code. ------------------------------------------- > It also feels like the same class of problem as what the segmentation registers in the x86 > architecture try to address. Does anyone here know how the 8086 processor addresses more > than 64k of memory with only 16-bit address registers? I sure wish I didn?t. As a budding > young programmer, reading about these details was a way to learn how computers operate, but > it?s not information I would inflict on any of my current students. > > With Int/Int#, public/private and x86 segmentation, the abstraction never really worked in > the first place. However, because there weren?t any other obvious solutions at the time, these > ?features? were grandfathered into the culture of the technology. For the disciples of a > particular technology, the recognition of problems in the fundamental design of that > technology tends to result in extensions to what they already have -- rather than backing up > and reconsidering WTF they were thinking in the first place.

1 0

generating object file for ARM
by Fabien R 07 Feb '16

07 Feb '16

Hello, I would like to link my Haskell module with existing object files for armv7-m. I use ghc 7.4.1 on debian/amd64. This command seems incorrect or incomplete: ghc -pgmcarm-none-eabi-gcc -pgmParm-none-eabi-cpp -pgmaarm-none-eabi-as -pgmlarm-none-eabi-ld -keep-tmp-files HaskellModule.hs A lot of errors appeared: [1 of 1] Compiling HaskellModule ( HaskellModule.hs, HaskellModule.o ) /tmp/ghc13654_0/ghc13654_0.s: Assembler messages: /tmp/ghc13654_0/ghc13654_0.s:5:0: Error: unrecognized symbol type "" /tmp/ghc13654_0/ghc13654_0.s:17:0: Error: unrecognized symbol type "" /tmp/ghc13654_0/ghc13654_0.s:29:0: Error: bad instruction `leaq -40(%rbp),%rax' /tmp/ghc13654_0/ghc13654_0.s:30:0: Error: bad instruction `cmpq %r15,%rax' Any hints ? -- Fabien ______________________________

2 2

ANN: servant-swagger and swagger2
by Nickolay Kudasov 06 Feb '16

06 Feb '16

Dear Cafe, I am pleased to announce servant-swagger [1] and swagger2 [2] packages! Swagger [3] is a project used to describe and document RESTful APIs. Here's a servant blog post, introducing both packages: https://haskell-servant.github.io/posts/2016-02-06-servant-swagger.html servant-swagger allows you to generate a Swagger specification from your Servant API. swagger2 is a standalone package for Swagger 2.0. This package introduces lenses and generic-based derivation to minimize the effort of constructing a Swagger specification for your API. Both packages are supposed to be easy to use and have great documentation! So if you have any troubles using/understanding them — feel free to report an issue or contact me directly! Kind regards, Nick [1] http://hackage.haskell.org/package/servant-swagger [2] http://hackage.haskell.org/package/swagger2 [3] http://swagger.io

1 0

How to handle recoverable errors in multi-step computation?
by Lian Hung Hon 06 Feb '16

06 Feb '16

Dear haskellers, I have a multi-step computation. The steps are predefined, but users can choose which steps to execute (something like a recipe). Here is an example recipe: Step 1 - Get data from network (multiple HTTP calls) and put into a list Step 2 - Process the data (e.g. average, sum, median, etc.) Step 3 - Persist result to database Sometimes, Step 1 can fail for some of the HTTP calls. When this happens, Step 2 should continue as much as possible using whatever data that has been retrieved, but somehow indicate that an error has occurred and the result is partial. Q1: What is the idiomatic way of achieving this? Using throwError in Control.Monad.Except aborts the computation, which isn't what I want. Q2: (General software design) Furthermore, where should the error be logged? Logging it in both Step 1 and 2 preserves modularity for each of the steps, unfortunately it would result in duplicate error messages. What is the best practice for this? Regards, Hon

4 3

Combining Pipes with Callbacks
by Alex 06 Feb '16

06 Feb '16

Is it possible to shoehorn a function which uses send/receive callbacks in to the definition of a Pipe?: http://lpaste.net/3654837866896293888#line23 If so, how would I define `cb' here? -- Alex

1 0

Can we improve Show instance for non-ascii charcters?
by Takayuki Muranushi 06 Feb '16

06 Feb '16

Show instance for non-ascii characters prints their character codes. This is sad for Haskell users that speaks language other than English. > 'A' 'A' > 'Ä' '\196' > '漢' '\28450' > print $ [(++"'s dad"), (++"'s mom")] <*> ["Simon", "John"] ["Simon's dad","John's dad","Simon's mom","John's mom"] > print $ [(++"の父"), (++"の母")] <*> ["田中", "山田"] ["\30000\20013\12398\29238","\23665\30000\12398\29238","\30000\20013\12398\27597","\23665\30000\12398\27597"] The function that needs improvement is showLitChar in GHC.Show, which currently prints any character larger than ASCII code 127 by its character code: http://haddock.stackage.org/lts-5.1/base-4.8.2.0/src/GHC-Show.html showLitChar :: Char -> ShowS showLitChar c s | c > '\DEL' = showChar '\\' (protectEsc isDec (shows (ord c)) s) On the other hand, there is GHC.Unicode.isPrint, the predicate for printable Unicode characters, that is calling on a foreign function u_iswprint for the knowledge. https://hackage.haskell.org/package/base-4.8.2.0/docs/src/GHC.Unicode.html#… I think one of the solution is to import and call u_iswprint from GHC.Show, too, but I don't know it's against any design choices. Yesterday, I had a chance to teach Haskell (in Japanese,) and I had to use English in some of the most exciting examples, like the Applicative List example above. I would heartedly like to see GHC improve in these directions, so that we can make more happy learning materials on Haskell. Let me ask your opinions on what is the best way to do this (or is better not to do this), before I submit something to GHC Trac. Best, -------------------------------- -- Takayuki MURANUSHI -- RIKEN Advanced Institute for Computational Science -- http://nushio3.github.io/ -- http://www.geocities.jp/takascience/ --------------------------------

17 24

New type of ($) operator in GHC 8.0 is problematic
by Theodore Lief Gannon 06 Feb '16

06 Feb '16

(Sorry you got this twice, Kyle!) I agree wholeheartedly with this: > Its extremely important to not lose touch with the people that make the community; the newcomers. Sacrificing the 99% of beginner and intermediate haskellers for the 1%, I believe is a step in the wrong direction. But also with this: > There's a real drawback to flags like -fdefault-levity: they hide things from unsuspecting users. We already get a steady trickle of bug reports stemming from confusion around hidden kinds. Users diligently try to make a minimal test case and then someone has to point out that the user is wrong. It's a waste of time and, I'm sure, is frustrating for users. I'm worried about this problem getting worse. I've been learning Haskell for about a year and a half, and using it in production for roughly a third of that. More than once I've run into a language construct which struck me as odd, asked about it, and was told it was that way for pedagogical reasons. I consider this a poor state of affairs on all sides, including pedagogy! I had a correct intuition that something was amiss, but here's the language itself sewing unjustified doubt about my understanding. It was discouraging. Lowering the garden wall is good, but not at the expense of hiding a hedge maze just inside the gate. The advantage of an alternate prelude is that the hedge maze is no longer hidden, and maps are handed out on entry; the disadvantage is that from the outside it just looks like a second, higher wall. This is a very hard problem and I have no idea how to solve it in the long term. For now though, why not cause -fdefault-levity to produce prominent warnings that it's simplifying types? Possibly even annotate simplified output, e.g.: ($) ::# (a -> b) -> a -> b On Fri, Feb 5, 2016 at 11:46 AM, Kyle Hanson <me(a)khanson.io> wrote: > Richard, > > I appreciate your response and have some genuine questions about how you > see the Language growing in the future. As much as I am a principled > developer in terms of adhering closely to the truth as possible, I also > view code as a product that needs to "customers" to be successful. In order > for that to happen, it needs to easily accessible and easy to understand. > > I learned Haskell almost entirely by looking at existing projects and > exploring the very awesome Hackage documentation. What would be the hackage > definition for ($)? Would it be `($) :: forall (r :: RuntimeRep) (a :: *) > (b :: TYPE r). (a -> b) -> a -> b` with an asterisk that says "*For > beginners: ($) :: (a -> b) -> a -> b" > > Would there be a "Simple Hackage"? > > It would be interesting for me to see how the skill levels of Haskell are > distributed. In most languages it would look like a pyramid with a small > group advanced developers on top and a mountain of people underneath. > Haskell seems to be pushing towards the inverse, in which to code and > understand standard, non beginners mode haskell you have to be "advanced". > The barrier to entry looks to be increasing. > > I agree with Christopher Allen and also do not agree with your assessment > and comparison to the unnecessary syntax in Java. You can explain that > program using simple english. That is why it was used for so many years as > an introductory language. > How do you explain `forall (r :: RuntimeRep) (a :: *) (b :: TYPE r).` > using simple english? > > I think its important to identify who you want your "customers" to be. If > you only want the most advanced type theorists to use the language, that is > perfectly fine, but what you lose are thousands of developers that can > benefit the Haskell community without having to know advanced Typing. > > Needing a "Beginners" mode in a language is *not* a feature, its a > fundamental design flaw. It shows that the language was not sufficiently > thought out and designed for everyone. > > Its extremely important to not lose touch with the people that make the > community; the newcomers. Sacrificing the 99% of beginner and intermediate > haskellers for the 1%, I believe is a step in the wrong direction. > > -- > Kyle > > On Fri, Feb 5, 2016 at 10:13 AM, Richard Eisenberg <eir(a)cis.upenn.edu> > wrote: > >> Perhaps it will aid the discussion to see that the type of ($) will, for >> better or worse, be changing again before 8.0. >> >> The problem is described in GHC ticket #11471. The details of "why" >> aren't all that important for this discussion, but the resolution might be. >> The new (hopefully final!) type of ($) will be: >> >> > ($) :: forall (r :: RuntimeRep) (a :: *) (b :: TYPE r). (a -> b) -> a >> -> b >> >> Once again, it's easy enough to tweak the pretty-printer to hide the >> complexity. But perhaps it's not necessary. The difference as far as this >> conversation is concerned is that Levity has been renamed to RuntimeRep. I >> think this is an improvement, because now it's not terribly hard to explain: >> >> --- >> 1. Types of kind * have values represented by pointers. This is the vast >> majority of data in Haskell, because almost everything in Haskell is boxed. >> 2. But sometimes, we don't care how a value is represented. In this case, >> we can be polymorphic in the choice of representation, just like `length` >> is polymorphic in the choice of list element type. >> 3. ($) works with functions whose result can have any representation, as >> succinctly stated in the type. Note that the argument to the function must >> be boxed, however, because the implementation of ($) must store and pass >> the argument. It doesn't care at all about the result, though, allowing for >> representation-polymorphism. >> >> In aid of this explanation, we can relate this all to Java. The reference >> types in Java (e.g., Object, int[], Boolean) are all like types of kind *. >> The primitive types in Java (int, boolean, char) do not have kind *. Java >> allows type abstraction (that is, generics) only over the types of kind *. >> Haskell is more general, allowing abstraction over primitive types via >> representation polymorphism. >> --- >> >> Could this all be explained to a novice programmer? That would be a >> struggle. But it could indeed be explained to an intermediate programmer in >> another language just learning Haskell. >> >> For point of comparison, Java is widely used as a teaching language. And >> yet one of the simplest programs is >> >> public class HelloWorld >> { >> public static void main(String[] args) >> { >> System.out.println("Hello, world!"); >> } >> } >> >> When I taught Java (I taught high-school full time for 8 years), I would >> start with something similar to this and have to tell everyone to ignore >> 90% of what was written. My course never even got to arrays and `static`! >> That was painful, but everyone survived. This is just to point out that >> Haskell isn't the only language with this problem. Not to say we shouldn't >> try to improve! >> >> We're in a bit of a bind in all this. We really need the fancy type for >> ($) so that it can be used in all situations where it is used currently. >> The old type for ($) was just a plain old lie. Now, at least, we're not >> lying. So, do we 1) lie, 2) allow the language to grow, or 3) avoid certain >> growth because it affects how easy the language is to learn? I don't really >> think anyone is advocating for (3) exactly, but it's hard to have (2) and >> not make things more complicated -- unless we have a beginners' mode or >> other features in, say, GHCi that aid learning. As I've said, I'm in full >> favor of adding these features. >> >> Richard >> >> On Feb 5, 2016, at 12:55 PM, Kyle Hanson <me(a)khanson.io> wrote: >> >> I am also happy the discussion was posted here. Although I don't teach >> Haskell professionally, one of the things I loved to do was show people how >> simple Haskell really was by inspecting types and slowly putting the puzzle >> pieces together. >> >> Summary of the problem for others: >> >> From *Takenobu Tani* >> >> Before ghc7.8: >> >> Prelude> :t foldr >> foldr :: (a -> b -> b) -> b -> [a] -> b >> >> Prelude> :t ($) >> ($) :: (a -> b) -> a -> b >> >> Beginners should only understand about following: >> >> * type variable (polymorphism) >> >> >> After ghc8.0: >> >> Prelude> :t foldr >> foldr :: Foldable t => (a -> b -> b) -> b -> t a -> b >> >> Prelude> :t ($) >> ($) >> :: forall (w :: GHC.Types.Levity) a (b :: TYPE w). >> (a -> b) -> a -> b >> >> >> >> With this change it looks like I will no longer be able to keep `$` in my >> toolbox since telling a beginner its "magic" goes against what I believe >> Haskell is good at, being well defined and easy to understand (Not well >> defined in terms of Types but well defined in terms of ability to precisely >> and concisely explain and define whats going on). >> >> It looks like where the discussion is going is to have these types show >> by default but eventually have an Alternative prelude for beginners. >> >> From *Richard Eisenberg:* >> >> - It's interesting that the solution to the two problems Takenobu pulls out below (but others have hinted at in this thread) is by having an alternate Prelude for beginners. I believe that having an alternate beginners' Prelude is becoming essential. I know I'm not the first one to suggest this, but a great many issues that teachers of Haskell have raised with me and posts on this and other lists would be solved by an alternate Prelude for beginners. >> >> I don't like the idea of fragmenting Haskell into "beginners" and >> "advanced" versions. Its hard enough to get people to believe Haskell is >> easy. If they see that they aren't using the "real" prelude, Haskell will >> still be this magic black box that is too abstract and difficult to >> understand. If they have to use a "dumbed down" version of Haskell to >> learn, its not as compelling. >> >> There is something powerful about using the same idiomatic tools as the >> "big boys" and have the tools still be able to be easy to understand.... by >> default. Adding complexity to the default Haskell runs the risk of further >> alienating newcomers to the language who have a misconception that its too >> hard. >> >> Admittedly, I am not well informed of the state of GHC 8.0 development >> and haven't had time to fully look into the situation. I am very interested >> to see where this conversation and the default complexity of Haskell goes. >> >> -- >> Kyle >> >> >> On Fri, Feb 5, 2016 at 8:26 AM, Tom Ellis < >> tom-lists-haskell-cafe-2013(a)jaguarpaw.co.uk> wrote: >> >>> On Fri, Feb 05, 2016 at 05:25:15PM +0100, Johannes Waldmann wrote: >>> > > What's changed? >>> > >>> > I was referring to a discussion on ghc-devs, see >>> > https://mail.haskell.org/pipermail/ghc-devs/2016-February/011268.html >>> > and mixed up addresses when replying. >>> >>> I'm glad you did, because this is the first I've heard of it! >>> _______________________________________________ >>> Haskell-Cafe mailing list >>> Haskell-Cafe(a)haskell.org >>> http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe >>> >> >> _______________________________________________ >> Haskell-Cafe mailing list >> Haskell-Cafe(a)haskell.org >> http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe >> >> >> > > _______________________________________________ > Haskell-Cafe mailing list > Haskell-Cafe(a)haskell.org > http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe > >

3 3

Month in haskell-ide-engine January 2016
by Alan & Kim Zimmerman 05 Feb '16

05 Feb '16

Welcome Haskell IDE Engine users, Haskell IDE Engine progress report for January 2016 [1] What is Haskell IDE Engine? Not an IDE. It is a common point for people in the Haskell community to pool their efforts with respect to tooling. For tool writers, provide tools as a HIE plugin, so it can be available on supported IDEs For IDE developers, integrate to HIE, and all the Haskell tools supported as plugins become available For users, it means the overall Haskell experience should improve. Important developments A new ghc-dump-tree plugin based on https://github.com/edsko/ghc-dump-tree Current project focus The current focus is to get the initial version working well enough for an alpha release. To this end, there are some hardy developers using it in their daily work in emacs. Issues closed in January Querying a graph database instead of using GHC-API? #10 Decide how haskell-ide project is run #13 Rework the Console #20 Use an error handler in the dispatcher #50 Protocol definition #66 (emacs) "Selecting deleted buffer" after hie buffer killed #121 emacs : process HieDiff result #132 Create a doc entry describing how to run hie with leksah #142 Create --one-shot flag to run one cmd and exit #154 Update to ghc-mod 5.5 #156 Fix warnings #159 HIE and current working directory #161 Improve error message for badly-formatted json #166 ghc-mod not properly detecting project #175 thread blocked indefinitely in an STM transaction -- Running tests #178 Create Report-2015-12.md #151 [POC] Move plugin and command names to the typelevel #152 Pull requests merged in January Just some textual improvements #153 Starting to bring in async streaming command #155 One shot invocation #158 leksah instructions #160 Bump deps and adapt to new apis #162 Improve error messages in JSON parsing #167 Add ide-backend plugin #168 Refactor ExtensibleState #169 Ghc-dump-tree plugin #170 Fix warnings #171 Emacs: log parse error even if there is no handler #172 Add an error handler in the dispatcher (fixes #50) #173 Recreate buffers if they have been killed #174 ghc-mod 5.5 #176 Remove ide-backend #179 Move emacs tests to buttercup #180 Increase timeout for cash upload #181 Update stack.yaml for ghc-mod-5.5 and HaRe-0.8.2.3 #182 Support multiple sessions in emacs #183 Fix warnings #165 Harmonise nightly versions, install ide-backend-server #177 Contributors active in January Alan Zimmerman, Alexey Shmalko, Cies Breijs, Griffin Smith, JP Moresmau, Justin Wood, Moritz Kiefer Contributing Haskell IDE Engine needs volunteers like any other open source project. For more information see: https://github.com/haskell/haskell-ide-engine Also drop by our IRC channel: #haskell-ide-engine at irc.freenode.net. Thanks! Alan [1] https://github.com/haskell/haskell-ide-engine/blob/master/docs/Report-2016-…

1 0

Is there a way to generate instances from the GHCi REPL?
by Christopher Done 05 Feb '16

05 Feb '16

Good evening, Is there a way with TH to generate instances for a class in GHCi? I want to generate instances for a serialization class. I tried to write some TH to do it, but $(foo) in GHCi’s REPL says that it can only be Q Exp, not Q [Dec]. Sadness. I found qAddTopDecls. I tried to add the class declarations via $(foo >>= qAddTopDecls; stringE "OK!") and it says “Only function, value, and foreign import declarations may be added with addTopDecl". Woe. I could create a file and then load in that file, but loading modules loses all GHCi's state, which would defeat the purpose of using a REPL in the first place. Any hope? Ciao!

3 2

Re: [Haskell-cafe] Can we improve Show instance for non-ascii charcters?
by Miguel Mitrofanov 04 Feb '16

04 Feb '16

1 0

Re: [Haskell-cafe] Can we improve Show instance for non-ascii charcters?
by Miguel Mitrofanov 04 Feb '16

04 Feb '16

2 1

Haskell game to translate
by Sergey Mironov 04 Feb '16

04 Feb '16

Hi, Cafe. My friend wants to improve her collaboration skills in the area of game development. She is a Translator and the plan is to learn Git by contributing some Russian/English/French (and maybe simple Korean) translations to a GitHub project. Could you recommend me (and my friend) some game project wich needs translation? Note, that It should support multylang features in some form, understandable for non-programmer. I'll help with required workplace setup. Haskell, Linux, etc. is OK. Regards, Sergey

1 0

Hackage Docs
by Geraldus 03 Feb '16

03 Feb '16

Hi friends! Apologize, a lot of Hackage docs issues discussed here already, but I'll decided to bring this question one more time. I'm facing missing docs during last few weeks, both Hoogle and Hayoo links to Hackage and usual response I see is "Not found". Stackage helps a lot, but most of the time I have to manually search same term on Stackage again. Can we improve this sad situation finally?

2 1

Month in Haskell Mode January 2016
by Gracjan Polak 03 Feb '16

03 Feb '16

Welcome Haskell Mode users, Haskell Mode progress report for January 2016. For previous issue see December 2015 <https://github.com/haskell/haskell-mode/wiki/Month-in-Haskell-Mode-December…>. Reddit discussion <https://www.reddit.com/r/haskell/comments/441ukg/month_in_haskell_mode_janu…> . <https://github.com/haskell/haskell-mode/wiki/Month-in-Haskell-Mode-January-…>What is Haskell Mode? Haskell Mode is an umbrella project for multiple Emacs tools for efficient Haskell development. Haskell Mode is an open source project developed by a group of volunteers constantly looking for contributions. For more information how to help see https://github.com/haskell/haskell-mode. <https://github.com/haskell/haskell-mode/wiki/Month-in-Haskell-Mode-January-…>Important developments Haskell Mode 2015 retrospective <https://github.com/haskell/haskell-mode/wiki/Haskell-Mode-2015-retrospective> was published. Emacs 23 support was dropped. Last stable haskell-mode release that supports Emacs 23 is haskell-mode version 13.18 <https://github.com/haskell/haskell-mode/releases/tag/v13.18>. We have added code coverage reporting and it already helped to nail down some missing cases in our test suite for indentation and font locking. We are currently at 30% coverage. <https://github.com/haskell/haskell-mode/wiki/Month-in-Haskell-Mode-January-…> Request Haskell Mode web presence is none at this point. I'd like to ask a volunteer to create a static web page deployed on github pages that will serve as Haskell Mode home page. Any takers? <https://github.com/haskell/haskell-mode/wiki/Month-in-Haskell-Mode-January-…>Current project focus Current project focus is to lower entry barrier for newcomers by defining bite-sized tasks. Get 50 'well-defined-tasks' done as by the metric: https://github.com/haskell/haskell-mode/issues?q=is%3Aissue+label%3Awell-de… A 'well-defined-task' is a category of tasks that have the field cleared for them, questions already sorted out and detailed information how to get them done. So you can just sit, search for 'well-defined-task' label and enjoy the coding! The point is to lower the entry barrier for new users, new issue reporters and advanced programmers but Emacs lisp beginners to contribute to the project. Current status: 14 well-defined-tasks closed <https://github.com/haskell/haskell-mode/issues?q=is%3Aissue+label%3Awell-de…> plus 13 more open <https://github.com/haskell/haskell-mode/issues?q=is%3Aissue+label%3Awell-de…> . If only you can help with reaching our targets please do so! <https://github.com/haskell/haskell-mode/wiki/Month-in-Haskell-Mode-January-…>Issues closed in January - [Discussion] Character class for apostrophe #549 <https://github.com/haskell/haskell-mode/issues/549> - Debugger triggered on "match c of", a typo for "case c of" #599 <https://github.com/haskell/haskell-mode/issues/599> - Interactive mode recognizes some lines as compiler errors incorrectly #635 <https://github.com/haskell/haskell-mode/issues/635> - make check should recompile files properly #709 <https://github.com/haskell/haskell-mode/issues/709> - haskell-process-suggest-pragma hangs emacs #754 <https://github.com/haskell/haskell-mode/issues/754> - ghc-mod / stack / dist dir #801 <https://github.com/haskell/haskell-mode/issues/801> - [Discussion] REPL vs IDE #809 <https://github.com/haskell/haskell-mode/issues/809> - haskell-mode becomes unresponsive when adding a language pragma #820 <https://github.com/haskell/haskell-mode/issues/820> - Drop Emacs 23 support #847 <https://github.com/haskell/haskell-mode/issues/847> - Can't press enter in haskell interactive mode #876 <https://github.com/haskell/haskell-mode/issues/876> - Mac OS X El Capitan: no such file or directory, ghci #908 <https://github.com/haskell/haskell-mode/issues/908> - Emacs hangs when typing behind whitespace #980 <https://github.com/haskell/haskell-mode/issues/980> - haskell-process-load-file error (wrong-type-argument number-or-marker-p nil) when code has an error #1004 <https://github.com/haskell/haskell-mode/issues/1004> - Regression quasi-quotes are not highlighted anymore #1041 <https://github.com/haskell/haskell-mode/issues/1041> - Custom Haskell variables don't retain their customization #1043 <https://github.com/haskell/haskell-mode/issues/1043> - Indentation point missing for record data declarations #1044 <https://github.com/haskell/haskell-mode/issues/1044> - Font lock Role annotations #1057 <https://github.com/haskell/haskell-mode/issues/1057> - Use undercover.el and https://coveralls.io/ #1062 <https://github.com/haskell/haskell-mode/issues/1062> - haskell-cabal-strip-list and haskell-cabal-listify #1076 <https://github.com/haskell/haskell-mode/issues/1076> - Indentation of guards does not work sensibly with haskell-indentation #1079 <https://github.com/haskell/haskell-mode/issues/1079> - Indentation of first data constructor does not work with haskell-indent #1080 <https://github.com/haskell/haskell-mode/issues/1080> - Annoying indentation behaviour when declaring data types #1081 <https://github.com/haskell/haskell-mode/issues/1081> - Can't indent, gets error. #1082 <https://github.com/haskell/haskell-mode/issues/1082> - [Discussion] Make haskell-indentation external, editor agnostic project #1086 <https://github.com/haskell/haskell-mode/issues/1086> - haskell-cabal-subsection-arrange-lines inserts superfluous commas #1094 <https://github.com/haskell/haskell-mode/issues/1094> - haskell-indentation misbehaves for comments #1101 <https://github.com/haskell/haskell-mode/issues/1101> - haskell-process-path-* now allowed to be lists #1112 <https://github.com/haskell/haskell-mode/issues/1112> - Wrong completion-at-point in Haskell interpreter with helm #1113 <https://github.com/haskell/haskell-mode/issues/1113> <https://github.com/haskell/haskell-mode/wiki/Month-in-Haskell-Mode-January-…>Pull requests merged in January - Record indentation should follow tibell style #1047 <https://github.com/haskell/haskell-mode/pull/1047> - Defcustoms should not be autoloaded #1048 <https://github.com/haskell/haskell-mode/pull/1048> - Define url and some keywords/tags for haskell-mode #1049 <https://github.com/haskell/haskell-mode/pull/1049> - Make quasi quote more visible #1051 <https://github.com/haskell/haskell-mode/pull/1051> - Lexeme parsing improvements #1052 <https://github.com/haskell/haskell-mode/pull/1052> - Skip an indentation test for Emacs 25 #1053 <https://github.com/haskell/haskell-mode/pull/1053> - Require at least Emacs 24.1 #1055 <https://github.com/haskell/haskell-mode/pull/1055> - Add font lock type/data family declarations #1056 <https://github.com/haskell/haskell-mode/pull/1056> - User manual updates #1058 <https://github.com/haskell/haskell-mode/pull/1058> - Add literate font lock tests, remove unused parts #1059 <https://github.com/haskell/haskell-mode/pull/1059> - Fix typos in documentation strings #1060 <https://github.com/haskell/haskell-mode/pull/1060> - Use plain string face for quasi quotes #1061 <https://github.com/haskell/haskell-mode/pull/1061> - Add code coverage #1063 <https://github.com/haskell/haskell-mode/pull/1063> - Add keybinding for haskell-cabal-visit-file #1064 <https://github.com/haskell/haskell-mode/pull/1064> - Add type role to font lock #1066 <https://github.com/haskell/haskell-mode/pull/1066> - Add test for SQL font-lock #1067 <https://github.com/haskell/haskell-mode/pull/1067> - Add test for 'type role' font-lock #1068 <https://github.com/haskell/haskell-mode/pull/1068> - Remove turn-on/off-haskell-font-lock #1069 <https://github.com/haskell/haskell-mode/pull/1069> - More font lock tests #1070 <https://github.com/haskell/haskell-mode/pull/1070> - Add tests and fix for classify by first char #1071 <https://github.com/haskell/haskell-mode/pull/1071> - Disallow leading spaces in error regexp in interactive mode #1072 <https://github.com/haskell/haskell-mode/pull/1072> - Add some tests for indentation #1073 <https://github.com/haskell/haskell-mode/pull/1073> - Inline haskell-mode-jump-to-loc #1075 <https://github.com/haskell/haskell-mode/pull/1075> - Increase haskell-cabal.el coverage #1077 <https://github.com/haskell/haskell-mode/pull/1077> - Define haskell-package struct's slots #1083 <https://github.com/haskell/haskell-mode/pull/1083> - Utils coverage #1089 <https://github.com/haskell/haskell-mode/pull/1089> - Utils coverage #1090 <https://github.com/haskell/haskell-mode/pull/1090> - Improve haskell-utils-reduce-string. Add tests #1092 <https://github.com/haskell/haskell-mode/pull/1092> - Add post-command-hook related tests #1093 <https://github.com/haskell/haskell-mode/pull/1093> - Test utils #1095 <https://github.com/haskell/haskell-mode/pull/1095> - Add string tests #1096 <https://github.com/haskell/haskell-mode/pull/1096> - Follow comma style when arranging a Cabal section #1098 <https://github.com/haskell/haskell-mode/pull/1098> - Detect comma style #1099 <https://github.com/haskell/haskell-mode/pull/1099> - Implement haskell-goto-first-error #1100 <https://github.com/haskell/haskell-mode/pull/1100> - Bump version to 16.1-git #1102 <https://github.com/haskell/haskell-mode/pull/1102> - Honor equals on its own line in data decl #1105 <https://github.com/haskell/haskell-mode/pull/1105> - Honor equals on separate line after guards #1106 <https://github.com/haskell/haskell-mode/pull/1106> - Remove a stray parenthesis #1108 <https://github.com/haskell/haskell-mode/pull/1108> - Tidy up haskell-load.el: untabify, reindent. Fix some warnings. #1111 <https://github.com/haskell/haskell-mode/pull/1111> - Allow haskell-process-path-* to be lists. #1114 <https://github.com/haskell/haskell-mode/pull/1114> - Add haskell-indent tests #1115 <https://github.com/haskell/haskell-mode/pull/1115> - Prevent haskell-doc-mode to hang Emacs during user input waiting #1116 <https://github.com/haskell/haskell-mode/pull/1116> - Remove haskell-interactive-mode-completion-cache #1119 <https://github.com/haskell/haskell-mode/pull/1119> <https://github.com/haskell/haskell-mode/wiki/Month-in-Haskell-Mode-January-…>Contributors active in January Arthur Fayzrakhmanov (Артур Файзрахманов), Bozhidar Batsov, Dan Aloni, Daniel Bergey, Fice-T, Gracjan Polak, Herbert Valerio Riedel, Kirill Ignatiev, Mike Sperber, Thomas Winant, U-Yuriy-PCYuriy, issue-dispenser, mrBliss <https://github.com/haskell/haskell-mode/wiki/Month-in-Haskell-Mode-January-…> Contributing Haskell Mode needs volunteers like any other open source project. For more information see: https://github.com/haskell/haskell-mode/wiki Also drop by our IRC channel: #haskell-emacs at irc.freenode.net. Thanks!

1 0

Building / cross compile GHC for OpenBSD/macppc.
by Christoph R. Murauer 03 Feb '16

03 Feb '16

Hello ! I am new here - sorry, if I ask something what was asked before. OpenBSD provides for amd64 and other platforms GHC and, also the haskell-platform which works very good. I try to get one of the old PowerMac's with a G5 CPU and saw, that there is no GHC (yes, there is a very old version - something like 3.x) for OpenBSD/macppc. I got some informations about to cross compile and saw also the wiki at https://ghc.haskell.org/trac/ghc/wiki/Building/CrossCompiling now my main question is, are there more informations about it ? Available for cross compile is GHC and haskell-platform 7.10.3, gcc 4.2.1 20070719, llvm 3.5.20140228 all on amd64. The planned target platforms are Mac's / PowerMac's with G3, G4 and G5 CPU's. All versions of OpenBSD/macppc are 32 bit only (including the G5). A cross compile from Mac OS X is no option because the OpenBSD project should be able to cross build on their machines (security reasons). Thanks for informations and tips. Regards, Christoph

1 0

Problems with cabal and stackage
by David Turner 03 Feb '16

03 Feb '16

Hi, Overnight there seems to have been a change to stackage where it's now issuing redirects from http to https URLs: ~$ cabal update Downloading the latest package list from stackage-lts-2.22 Warning: http error: Unable to handle redirect, unsupported scheme: https://www.stackage.org/snapshot/lts-2.22/00-index.tar.gz cabal: Failed to download http://www.stackage.org/snapshot/lts-2.22/00-index.tar.gz : ErrorMisc "Error HTTP code: 301" My cabal doesn't seem to like https and I think it's a recentish version: $ cabal --version cabal-install version 1.22.0.0 using version 1.22.0.0 of the Cabal library I'm probably using a bit of an old workflow (and I know that LTS-2 is pretty old too) but is there any simple way of getting this working again? Cheers,

2 2

Accessing and Inspecting StgBindings in Ghci
by Michael Christensen 03 Feb '16

03 Feb '16

Hi all, I'm currently trying to understand how STG works, and my goal right now is to be able to inspect StgBinding values. I've written a short program, based on the wiki article GHC/As a library <https://wiki.haskell.org/GHC/As_a_library>, like below: -- Code.hs -- module Lib (printSTG, dumpSTG) where import Control.Monad.Ghc (lift, runGhcT) import CorePrep (corePrepPgm) import CoreToStg (coreToStg) import DynFlags (defaultFatalMessager, defaultFlushOut) import GHC hiding (runGhcT) import GHC.Paths (libdir) import HscMain (newHscEnv) import HscTypes (hsc_dflags, typeEnvTyCons) import Outputable (interppSP, showSDoc) import System.Environment (getArgs) import StgSyn (StgBinding) dumpSTG :: String -> IO [StgBinding] dumpSTG fileName = defaultErrorHandler defaultFatalMessager defaultFlushOut $ runGhcT (Just libdir) $ do sess <- getSession let dflags = hsc_dflags sess setSessionDynFlags dflags cm <- compileToCoreModule fileName let md = cm_module cm ml <- fmap ms_location $ getModSummary $ moduleName md lift $ do cp <- corePrepPgm sess ml <$> cm_binds <*> (typeEnvTyCons . cm_types) $ cm coreToStg dflags md cp printSTG = getArgs >>= \x -> case x of [] -> putStrLn "usage: Main <file.hs>" (fileName:_) -> do bindings <- dumpSTG fileName str <- runGhcT (Just libdir) $ do dflags <- getSessionDynFlags return $ showSDoc dflags $ interppSP bindings putStrLn str This works when I compile it to print out a Haskell file in STG format. However, *my question is*, is there a way so that I can call dumpSTG to get back that list of StgBindings, *from within Ghci*? Whenever I do so within Ghci, i.e. ghci> :l code.hs ghci> bindings <- dumpSTG "fileToTest.hs" <interactive>: panic! (the 'impossible' happened) (GHC version 7.10.3 for x86_64-unknown-linux): no package state yet: call GHC.setSessionDynFlags I know that it's saying I need to set the session dyn flags, but I'm not sure how that can get done from within Ghci, especially because that needs to get done within the GhcMonad. Part of my problem may stem from having a inadequate understanding of monads. Any help or pointers would be greatly appreciated! Thank you very much, Mike

1 1

Is there a type class for boring types?
by David Feuer 02 Feb '16

02 Feb '16

Or, alternatively, some common class that lets me express that a type is boring (i.e., inhabited by precisely one fully-defined value)? lens has Settable, whose law ensures the type involved has a boring representation (in the sense of representable functor), but is there a more fundamental way? class Boring x where inhabitant :: x instance Boring () where inhabitant = () instance Boring (Proxy a) where inhabitant = Proxy instance Boring y => Boring (x -> y) where inhabitant = const inhabitant instance (Boring x, Boring y) => Boring (x, y) where inhabitant = (inhabitant, inhabitant) instance Boring x => Boring (Const x y) where inhabitant = Const inhabitant instance Boring x => Boring (Identity x) where inhabitant = Identity inhabitant ...

4 5

[TFP 2016] 1st call for papers
by Peter Achten 02 Feb '16

02 Feb '16

----------------------------- C A L L F O R P A P E R S ----------------------------- ======== TFP 2016 =========== 17th Symposium on Trends in Functional Programming June 8-10, 2016 University of Maryland, College Park Near Washington, DC http://tfp2016.org/ The symposium on Trends in Functional Programming (TFP) is an international forum for researchers with interests in all aspects of functional programming, taking a broad view of current and future trends in the area. It aspires to be a lively environment for presenting the latest research results, and other contributions (see below). Authors of draft papers will be invited to submit revised papers based on the feedback receive at the symposium. A post-symposium refereeing process will then select a subset of these articles for formal publication. TFP 2016 will be the main event of a pair of functional programming events. TFP 2016 will be accompanied by the International Workshop on Trends in Functional Programming in Education (TFPIE), which will take place on June 7nd. The TFP symposium is the heir of the successful series of Scottish Functional Programming Workshops. Previous TFP symposia were held in * Edinburgh (Scotland) in 2003; * Munich (Germany) in 2004; * Tallinn (Estonia) in 2005; * Nottingham (UK) in 2006; * New York (USA) in 2007; * Nijmegen (The Netherlands) in 2008; * Komarno (Slovakia) in 2009; * Oklahoma (USA) in 2010; * Madrid (Spain) in 2011; * St. Andrews (UK) in 2012; * Provo (Utah, USA) in 2013; * Soesterberg (The Netherlands) in 2014; * and Inria Sophia-Antipolis (France) in 2015. For further general information about TFP please see the TFP homepage. (http://www.tifp.org/) == SCOPE == The symposium recognizes that new trends may arise through various routes. As part of the Symposium's focus on trends we therefore identify the following five article categories. High-quality articles are solicited in any of these categories: Research Articles: leading-edge, previously unpublished research work Position Articles: on what new trends should or should not be Project Articles: descriptions of recently started new projects Evaluation Articles: what lessons can be drawn from a finished project Overview Articles: summarizing work with respect to a trendy subject Articles must be original and not simultaneously submitted for publication to any other forum. They may consider any aspect of functional programming: theoretical, implementation-oriented, or experience-oriented. Applications of functional programming techniques to other languages are also within the scope of the symposium. Topics suitable for the symposium include, but are not limited to: Functional programming and multicore/manycore computing Functional programming in the cloud High performance functional computing Extra-functional (behavioural) properties of functional programs Dependently typed functional programming Validation and verification of functional programs Debugging and profiling for functional languages Functional programming in different application areas: security, mobility, telecommunications applications, embedded systems, global computing, grids, etc. Interoperability with imperative programming languages Novel memory management techniques Program analysis and transformation techniques Empirical performance studies Abstract/virtual machines and compilers for functional languages (Embedded) domain specific languages New implementation strategies Any new emerging trend in the functional programming area If you are in doubt on whether your article is within the scope of TFP, please contact the TFP 2016 program chair, David Van Horn. == BEST PAPER AWARDS == To reward excellent contributions, TFP awards a prize for the best paper accepted for the formal proceedings. TFP traditionally pays special attention to research students, acknowledging that students are almost by definition part of new subject trends. A student paper is one for which the authors state that the paper is mainly the work of students, the students are listed as first authors, and a student would present the paper. A prize for the best student paper is awarded each year. In both cases, it is the PC of TFP that awards the prize. In case the best paper happens to be a student paper, that paper will then receive both prizes. == SPONSORS == TFP is financially supported by CyberPoint, Galois, Trail of Bits, and the University of Maryland Computer Science Department. == PAPER SUBMISSIONS == Acceptance of articles for presentation at the symposium is based on a lightweight peer review process of extended abstracts (4 to 10 pages in length) or full papers (20 pages). The submission must clearly indicate which category it belongs to: research, position, project, evaluation, or overview paper. It should also indicate which authors are research students, and whether the main author(s) are students. A draft paper for which ALL authors are students will receive additional feedback by one of the PC members shortly after the symposium has taken place. We use EasyChair for the refereeing process. Papers must be submitted at: https://easychair.org/conferences/?conf=tfp2016 Papers must be written in English, and written using the LNCS style. For more information about formatting please consult the Springer LNCS web site: http://www.springer.com/computer/lncs?SGWID=0-164-6-793341-0 == IMPORTANT DATES == Submission of draft papers: April 8, 2016 Notification: April 15, 2016 Registration: May 13, 2016 TFP Symposium: June 8-10, 2016 Student papers feedback: June 14, 2016 Submission for formal review: July 14, 2016 Notification of acceptance: September 14, 2016 Camera ready paper: October 14, 2016 == PROGRAM COMMITTEE == Amal Ahmed Northeastern University (US) Nada Amin École Polytechnique Fédérale de Lausanne (CH) Kenichi Asai Ochanomizu University (JP) Małgorzata Biernacka University of Wroclaw (PL) Laura Castro University of A Coruña (ES) Ravi Chugh University of Chicago (US) Silvia Ghilezan University of Novi Sad (SR) Clemens Grelck University of Amsterdam (NL) John Hughes Chalmers University of Technology (SE) Suresh Jagannathan Purdue University (US) Pieter Koopman Radboud University Nijmegen (NL) Geoffrey Mainland Drexel University (US) Chris Martens University of California, Santa Cruz (US) Jay McCarthy University of Massachusetts, Lowell (US) Heather Miller École Polytechnique Fédérale de Lausanne (CH) Manuel Serrano INRIA, Sophia-Antipolis (FR) Scott Smith Johns Hopkins University (US) Éric Tanter University of Chile (CL) David Van Horn (Chair) University of Maryland (US) Niki Vazou University of California, San Diego (US)

1 0

Instance match surprise
by Wojtek Narczyński 02 Feb '16

02 Feb '16

Dear List, Why does the first instance match? ANY is neither Eq nor Typeable. I thought I had some basic understanding of type classes, and now this... wojtek@biuro:~/src/he$ cat minimatch.hs {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE MultiParamTypeClasses #-} module MiniMatch where import Data.Typeable data A130 = A130 deriving (Eq) data ANY = ANY class AtmAcct a class Against q class (AtmAcct a, Against q) => Match a q where match :: a -> q -> Bool instance AtmAcct A130 instance Against ANY instance (Eq a, Eq q, Typeable a, Typeable q, AtmAcct a, Against q) => Match a q where match _ _ = False instance (AtmAcct a) => Match a ANY where match _ _ = True m1 = match A130 ANY -- offending line wojtek@biuro:~/src/he$ ghc minimatch.hs [1 of 1] Compiling MiniMatch ( minimatch.hs, minimatch.o ) minimatch.hs:21:6: error: • Overlapping instances for Match A130 ANY arising from a use of ‘match’ Matching instances: instance (Eq a, Eq q, Typeable a, Typeable q, AtmAcct a, Against q) => Match a q -- Defined at minimatch.hs:18:10 instance AtmAcct a => Match a ANY -- Defined at minimatch.hs:19:10 • In the expression: match A130 ANY In an equation for ‘m1’: m1 = match A130 ANY -- Thanks, Wojtek Narczyński

4 10

why is rpar/rpar always faster (book Simon Marlow)?
by Kees Bleijenberg 01 Feb '16

01 Feb '16

I'am reading the book Parallel and Concurrent Programming in Haskell. The book has an explanation of the Eval monad. It compares rpar/rpar (example 2-1), rpar/rseq (example 2-2), rpar/rseq/rpar (example 2-3) and rpar/rpar/rseq/rseq in rpar.hs The examples run all in the total time 0.82 s. When I run rpar/rpar (example2-1) on my computer total time is 1.34 s. All other examples have total time 2.22 s. I'am running the examples exactly as written in the book. I tried the examples in opposite order, but the rpar/rpar example remains a lot faster. I wonder why the other examples are so much slower and why is it so different from the book? I run the examples on a computer with 4 cores. I'am using ghc version 7.10.1 on Win64. The Haskell version is 32 bits. If I run the examples with +RTS -N1 all examples use the same time (2.20 sec). Kees

1 0

Question, re: failed attempt at constraining a Traversable instance.
by David Banas 01 Feb '16

01 Feb '16

Hi all, I’m trying to do this: data Tree a = Empty | Leaf a | Node (Tree a) a (Tree a) instance Functor Tree where fmap g Empty = Empty fmap g (Leaf x) = Leaf (g x) fmap g (Node t1 x t2) = Node (fmap g t1) (g x) (fmap g t2) instance Foldable Tree where foldMap f Empty = mempty foldMap f (Leaf x) = f x foldMap f (Node l k r) = foldMap f l `mappend` f k `mappend` foldMap f r instance (Monoid (f (Tree a))) => Traversable (Tree (f a)) where sequenceA Empty = pure Empty sequenceA (Leaf f) = Leaf <$> f sequenceA (Node t1 f t2) = (sequenceA t1) `mappend` (Leaf <$> f) `mappend` (sequenceA t2) And I’m being told this: The first argument of ‘Traversable’ should have kind ‘* -> *’, but ‘Tree (f a)’ has kind ‘*’ In the instance declaration for ‘Traversable (Tree (f a))’ And I don’t quite understand what I’m asking for that’s forbidden. Is it that I’m trying to declare that only a certain subset of Trees are Traversable, and that’s not okay? It’s got to be all Trees or no Trees are Traversable? Thanks, -db

2 1

Share a variable across GHCI sessions: Possible?
by Jeffrey Brown 01 Feb '16

01 Feb '16

Suppose v is a view onto some data in a graph[1]. You ask GHCI to (show $ nodes v). You would like to ask GHCI in another window to (show $ disambiguations v), referring to the same v. Is it possible? My motivation is to show disambiguations that are about the nodes. Examples of disambiguations would be "a ! character adjacent to the left of a word means it requires money", or "CAP stands for Coastal Alliance of Pharoahs", or "a(/n)b means a needs b". [1] Using the Functional Graph Library, I am writing a graph database editor, Digraphs With Text: https://github.com/JeffreyBenjaminBrown/digraphs-with-text DWT is exceptionally flexible. Relationships can be of any arity, and can involve other relationships. For instance, in DWT the relationship "_ needs _ in order to _" has a natural representation; I am unaware of any other system in which it does. I would *love* help! And I take job offers seriously! -- Jeffrey Benjamin Brown

1 0

How stable is the typerep fingerprint value?
by Anatoly Yakovenko 31 Jan '16

31 Jan '16

How stable is the typerep fingerprint value? Is it going to change between builds based on the same sources? Thanks, Anatoly

1 0

ANNOUNCE: call-haskell-from-anything 1.0
by Niklas Hambüchen 31 Jan '16

31 Jan '16

Heya, I'm happy to announce a new release of call-haskell-from-anything [1], my library for FFI-via-serialisation that allows to easily call Haskell functions from any other language that can open shared object files (`.so` via `dlopen()`) and has a MessagePack library available. This is almost all programming languages; for examples for Python and Ruby see [2]. The FFI-via-serialisation approach makes it possible to export most functions to other languages "for free": no FFI type unpacking boilerplate, everything that has a MessagePack instance (much easier to write than `Storable` instances) will do. For example if you have a function chooseMax :: [Int] -> Int all you have do to make it callable is foreign export ccall chooseMax_export :: CString -> IO CString chooseMax_export = export chooseMax Version 1.0 uses closed type families to remove the restriction that so far, pure functions has to be wrapped into the Identity monad to be exported: a -> b -> ... -> Identity r With 1.0, this is no longer necessary. You can now export any function of type a -> b -> ... -> r to be called from your favourite Haskell contender languages (of course those have no chance ...). Cheers, Niklas [1]: https://hackage.haskell.org/package/call-haskell-from-anything-1.0.0.0 [2]: https://github.com/nh2/call-haskell-from-anything

1 0

setup-Simple-Cabal-1.22.5.0-x86_64-windows-ghc-7.10.3.exe: : does not exist
by Henk-Jan van Tuyl 31 Jan '16

31 Jan '16

L.S., Why do I get the message: setup-Simple-Cabal-1.22.5.0-x86_64-windows-ghc-7.10.3.exe: : does not exist after command "cabal install", and what can I do about it ? Regards, Henk-Jan van Tuyl -- Folding@home What if you could share your unused computer power to help find a cure? In just 5 minutes you can join the world's biggest networked computer and get us closer sooner. Watch the video. http://folding.stanford.edu/ http://Van.Tuyl.eu/ http://members.chello.nl/hjgtuyl/tourdemonad.html Haskell programming --

5 8

Type introduction illustrated for casual haskellers
by Takenobu Tani 30 Jan '16

30 Jan '16

Dear Haskellers, I'm enjoying Haskell. After FTP(Foldable/Traversable in Prelude proposal), newcomers encounter Foldable signatures in their early stage. So I drew a few simple illustrations about a type introduction for newcomers/casual haskellers. Type introduction illustrated for casual haskellers http://takenobu-hs.github.io/downloads/type_introduction_illustrated.pdf https://github.com/takenobu-hs/type-introduction-illustrated If I have misunderstood, please teach me. I'll correct them. Thank you =), Takenobu

1 0

[ANN] Aivika: Branching Discrete Event Simulation in Haskell
by David Sorokin 29 Jan '16

29 Jan '16

Hi Cafe, I’m glad to announce the release of three my simulation libraries [1, 2, 3]. I would like to tell more about the third library especially. The aivika-brances package [3] is new. It allows creating branches to run nested simulations within simulation so that the source simulation remains intact. It allows us to forecast the behavior looking into the future of the model. There is a similar method in the financial modeling, when estimating the option instrument. We build a tree of future possible changes to estimate the present value. The present depends on the future. My library allows building the same tree of nested simulations. At the same time, this is a general purpose discrete event simulation library with such things as random streams of orders (transacts), limited resources, queues, discontinuous processes, the global event queue, event-based activities and so on. I think that we can create very sophisticated simulation models with elements of prediction and forecasting. Probably, the library can be useful for financial modeling. Initially, a few years ago I created the aivika simulation package [1] trying to repeat what other simulation libraries and software vendors provided in the field. Then an year or two ago I generalized my simulation library and created package aivika-transformers [2] with wide use of monad transformers and type families. I actually had plans to use that second package for the distributed and parallel discrete event simulation, but the package was so general that I could use it for what I would call a «branching discrete event simulation». Today I finished my third package aivika-branches, which is a very small additional package that introduces a new computation and a couple of new functions, where the main function is as follows: futureEvent :: Double -> Event BrIO a -> Event BrIO a It creates a new independent branch of the current simulation and then returns the result of the specified event-based computation in the desired time point, leaving the current computation intact. All pending events will be processed in the derived branch as if it were the current simulation. The very important thing is that the futureEvent function is relatively cheap. It was possible thanks to wide using the functional programming approach in my libraries. We can clone the simulation world as many times as we need for running nested simulations within simulation and it works. Frankly speaking, I don’t know of other general purpose simulation libraries that would offer the same functionality. I’m looking forward to hearing of your comments. Especially, I would be interested to participate in the projects related to simulation and modeling. I think that Haskell allows doing fantastic things here! Best regards, David Sorokin [1] http://hackage.haskell.org/package/aivika [2] http://hackage.haskell.org/package/aivika-transformers [3] http://hackage.haskell.org/package/aivika-branches

1 0

Re: [Haskell-cafe] FICS client in Haskell
by Tilmann 29 Jan '16

29 Jan '16

Hi Tony, thank you for having a look! I haven't given putting it on hackage much thought yet. But I would certainly do it if it's helping someone. Macbeth probably runs on other platforms as well. It's just that I developed it with OSX in mind (I was using babaschess on windows before) and provide an OSX binary only. Am 29.01.16 um 03:35 schrieb Tony Morris: > Hi Tilmann, > I'll give it a crack, though I haven't used FICS in a while. > > Couple of questions: > * have you put it on hackage? > * is it specific to Mac OSX? (if so, why?) > > > On 29/01/16 02:37, Tilmann wrote: >> Hi, >> I've been working on a FICS (Free Internet Chess Server) Client for a >> bit over a year now and it is finally in a presentable state. It would >> be great if you would like to have a look at the source code and let me >> know what you think! >> >> When I started with this project I was just starting to learn Haskell >> and I would like to know if the code is accessible/readable/idiomatic, >> if the overall organization seems reasonable as well or if you might >> have any other suggestion about what I could improve. (ie: I haven't >> decided on what logging framework to use.) >> >> The code is on github: https://github.com/tgass/macbeth >> >> I thank you all very much in advance! >> Tilmann >> >> >> >> https://github.com/tgass/macbeth/blob/master/src/Macbeth/Fics/FicsConnectio… >> >> Opens a telnet connection to freechess.org. Using conduit and attoparsec >> messages from the server are parsed to FicsMessages and put into a Chan. >> >> https://github.com/tgass/macbeth/blob/master/src/Macbeth/Fics/FicsMessage.hs >> >> The domain model >> >> The UI is using wx widgets (wxHaskell). Each wx-frame gets a copy of >> Chan FicsMessage and updates the UI when new Messages are available, ie >> here: >> https://github.com/tgass/macbeth/blob/master/src/Macbeth/Wx/ToolBox.hs >> https://github.com/tgass/macbeth/blob/master/src/Macbeth/Wx/Game.hs >> >> _______________________________________________ >> Haskell-Cafe mailing list >> Haskell-Cafe(a)haskell.org >> http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe

1 0

Re: [Haskell-cafe] Hide the data constructor for type family instance
by David Sorokin 29 Jan '16

29 Jan '16

Hi Imants, I fogot to add that the mentioned data constructor becomes visible in the haddoc section Instances for the exported BarIO monad. I would like to see that there is such an instance but without details about data constructor. Probably, the issue is more related to that how the BarIO type is shown in the documenation. On level of the module, where the QueueStrategy instance is defined, I can regulate the export list somehow. Thanks David 29.01.2016 1:22 пользователь "Imants Cekusins" <imantc(a)gmail.com> написал: Hello David, > FCFSQueue data constructor is visible together with all its contents > I would like it would be hidden completely Did you try to export all public symbols but not the constructor? _______________________________________________ Haskell-Cafe mailing list Haskell-Cafe(a)haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe

1 0

Hide the data constructor for type family instance
by David Sorokin 28 Jan '16

28 Jan '16

Hi Cafe, When instantiating a type class with type family, I see that haddock shows the data constructor for the type family as visible. This is what I would like to avoid. I would like to hide the details of the data constructor in the documentation. An example is stated below: -- | An implementation of the 'FCFS' queue strategy. instance QueueStrategy BrIO FCFS where -- | A queue used by the 'FCFS' strategy. newtype StrategyQueue BrIO FCFS a = FCFSQueue (LL.DoubleLinkedList BrIO a) newStrategyQueue s = fmap FCFSQueue LL.newList strategyQueueNull (FCFSQueue q) = LL.listNull q Here the FCFSQueue data constructor is visible together with all its contents in the documentation! I would like it would be hidden completely. At least, I would like to hide the contents. Is it possible to do? Thanks, David

2 1

How does -N allot cores?
by Hong Yang 28 Jan '16

28 Jan '16

Hi Cafe, On an 1P system, there are 8 cores. Does -N8 send one thread to each core no matter how loaded each core is? Assuming 6 cores are busy, will -N8 send threads only to the two idle cores? If -N8 sends threads to eight cores no matter what, is there any function that detects number of idle (or usage less than certain percentage) cores? Suppose a 4P system has 32 cores (4 processors with each processor having 8 cores). Assuming the whole system is idle, how will -N32 work? Thanks, Hong

2 1

FICS client in Haskell
by Tilmann 28 Jan '16

28 Jan '16

Hi, I've been working on a FICS (Free Internet Chess Server) Client for a bit over a year now and it is finally in a presentable state. It would be great if you would like to have a look at the source code and let me know what you think! When I started with this project I was just starting to learn Haskell and I would like to know if the code is accessible/readable/idiomatic, if the overall organization seems reasonable as well or if you might have any other suggestion about what I could improve. (ie: I haven't decided on what logging framework to use.) The code is on github: https://github.com/tgass/macbeth I thank you all very much in advance! Tilmann https://github.com/tgass/macbeth/blob/master/src/Macbeth/Fics/FicsConnectio… Opens a telnet connection to freechess.org. Using conduit and attoparsec messages from the server are parsed to FicsMessages and put into a Chan. https://github.com/tgass/macbeth/blob/master/src/Macbeth/Fics/FicsMessage.hs The domain model The UI is using wx widgets (wxHaskell). Each wx-frame gets a copy of Chan FicsMessage and updates the UI when new Messages are available, ie here: https://github.com/tgass/macbeth/blob/master/src/Macbeth/Wx/ToolBox.hs https://github.com/tgass/macbeth/blob/master/src/Macbeth/Wx/Game.hs

1 0

When are MVars better than STM?
by Thomas Koster 28 Jan '16

28 Jan '16

Hi friends, Using Criterion, I have been running benchmarks to measure the relative performance of STM and MVars for some simple transactions that I expect will be typical in my application. I am using GHC 7.10.2 and libraries as at Stackage LTS 3.2. I have found that STM is faster than MVars in all my benchmarks, without exception. This seems to go against accepted wisdom [1][2][3]. I have not included my source code here to save space, but if you suspect that I am using MVars incorrectly, just say so and I will post my source code separately. I have two questions: 1. When are MVars faster than STM? If the answer is "never", then when are MVars "better" than STM? (Choose your own definition of "better".) 2. When given two capabilities (+RTS -N2), MVars are suddenly an order of magnitude slower than with just one capability. Why? For those who want details: My benchmark forks four Haskell threads. Each thread repeats a transaction that increments a shared counter many, many times. These transactions must be serialized. The counter is therefore highly contended. One version uses an MVar to store the counter in the obvious way. The other version uses a TVar instead. By the way, simply using "atomic-primops" to increment the counter won't do because the increment operation is actually a mock substitute for a more complex operation. I use the counter for my benchmarks because the real operation needs much more memory and I don't want the additional, unpredictable GC cost to affect my measurements. Typical measurements are: 1 capability, using MVar: 37.30 ms 1 capability, using TVar: 24.88 ms 2 capabilities, using MVar: 1.564 s 2 capabilities, using TVar: 80.09 ms 4 capabilities, using MVar: 2.890 s 4 capabilities, using TVar: 207.8 ms Notice that the MVar version suddenly slows by an order of magnitude when run with more than one capability. Why is this so? (This is question 2.) Despite the absolute time elapsed, I realize that the CPU usage characteristics of the two versions are also quite different. I realize that the MVar version interlocks the four threads so that only one capability is ever busy at a time, irrespective of the number of capabilities available, whereas the STM version allows up to four capabilities to be busy at once. However, I believe that the additional parallel transactions in the STM version would be mostly wasted, destined to be retried. Unless I am mistaken, this assumption appears to be consistent with the observation that the STM version with -N1 is the fastest of all. Despite all this wasted work by the thundering herd, the total CPU time (i.e. my power bill) for the STM version is still less than for the MVar version, because the MVar version so dramatically slow. Paradoxically, MVars seem to be the wrong tool for this job. So when are MVars faster than STM? (This is question 1.) [1] https://stackoverflow.com/questions/15439966/when-why-use-an-mvar-over-a-tv… [2] https://www.reddit.com/r/haskell/comments/39ef3y/ioref_vs_mvar_vs_tvar_vs_t… [3] https://mail.haskell.org/pipermail/haskell-cafe/2014-January/112158.html Thanks, Thomas Koster

5 9

Hackage hoq?
by Vasili I. Galchin 27 Jan '16

27 Jan '16

Hello, I successfully built hoq. When I run th hoq executable, I get ">" prompts but am not sure what to do. I read some of the code and I tried putting .hoq on the command line, That didn't work. Has anyone tried hoq?? Vasily

1 0

[Ann] A new, fun, easy book/tute on Haskell
by Julian Leviston 27 Jan '16

27 Jan '16

[Ann] A new, fun, easy book/tute on Haskell http://www.happylearnhaskelltutorial.com Just released this two days ago, roughly. We've released 7 out of 20 sections on the site so far, and the book is up on leanpub ($8 or $4 - $20 set your own price), at about 95% done. We don't want to put it to 100% until we've had at least 20 or more technical people read it and give us feedback, and until we've done a thorough revision for corrections. We felt like there's a need for an updated education resource that's both fun and for super beginners who have never programmed before. Essentially a slightly less drawing-focussed and slightly more technically advanced version of the 1980's Usborne Computer Guides http://www.usborne.com/catalogue/feature-page/computer-and-coding-books.aspx something that appeals to people who are more visually focussed as we are. Our plan is to keep expanding it into more volumes if there's enough interest and paid support. We're also very interested in hearing critical criticism and or praise! :) Here is a rough breakdown of our take on approaching education: 1. Tackling reading first, then slowly introducing writing when enough examples have been seen to increase confidence, because reading & writing are separate skills 2. Many small, fun examples for each thing to keep interest high: fun examples helps with motivation 3. Gradual, partial introduction of topics, in context at first: graded, less to take in at once, using the writing phase to soldify understanding, will possibly add a revision phase later 4. Not so much theory introduced before the practical has been introduced (examples-first), which gives a concrete context for the theory 5. Pictures. Some of these are visual aides, which are useful as explanations: a picture tells 1000 words, so they say 6. No assumption of previous programming experience. Almost every other guide available assume some programming 7. Smaller sections because completing small things gives a real sense of achievement, which increases motivation 8. Will be tackling how to deconstruct problems using both top down and bottom up approaches: most guides don't tackle this in a simple or basics-first way 9. It's free to read and online, so able to be discussed in public - some guides are, others aren't 10. Not so math focussed including "mathy jargon". We keep away from terms like catamorphism, lambda calculus, monad, until we need them, and these are/will be only introduced when appropriate amounts of concrete practical knowledge are present through repeated exposure to examples, so that it's obvious what is meant Thanks all! Julian - (of GetContented)

1 0

.cabal: API-compatible library versions
by Imants Cekusins 26 Jan '16

26 Jan '16

Stack may already do something like this, I don't know. Anyway, here is an idea. Currently .cabal lists version or version range. What if package info included lists of API-compatible versions of this package? Let's say one library requires v10 of packageA. Another library requires v15 of the same packageA. This is a hypothetical scenario :-P However v10, v15 are API-compatible as far as package maintainer knows. Package info specifies v10 and v15 as API-compatible too. What if it were possible to issue: cabal install packageA .. and then if v10, v15 are compatible, v15 is returned without warnings. If v10 and v15 are not compatible, cabal would warn. Basically instead of library clients needing to test multiple library versions or requiring 1 exact version, deps could be specified as 1 version (with which development took place) and cabal (with hints from package maintainers) would figure this out. It might even be possible to fine-tune it to check modules & symbols actually used by library consumer app. ?

3 6

Local types
by M Farkas-Dyck 26 Jan '16

26 Jan '16

I often wish to be able to define local types and instances, so, for example: import Data.Set as Set ordNubBy :: (a -> a -> Ordering) -> [a] -> [a] ordNubBy cmp = go Set.empty where newtype T = T a instance Ord T where T x `compare` T y = cmp x y go _ [] = [] go ys (x:xs) = bool (x:) id (T x ∈ ys) $ go (Set.insert (T x) ys) xs The notion is that type and instance declarations would become legal in `let` or `where` bonds; they would effectively declare new types and instances in that scope for each use of that term; and such local types and instances could never leave the scope they were defined in, by enforcement, so consistency of instances would be preserved. I know some related work which proposes local instances [0] but none i know proposes also local types. I'm seeking some feedback here before i formalize further and potentially start making implements. Thoughts? Questions? Better ideas? Critical flaws? [0] http://okmij.org/ftp/Haskell/TypeClass.html#local

4 8

[Template Haskell]
by Dominik Bollmann 25 Jan '16

25 Jan '16

Hi all, I'm just getting my feet wet with template haskell, and I tried to write a tmap function which maps a function over the ith component of an n-tuple (which uses a slightly different approach than the given version on the TH wiki): -- | Selects the ith component of an n-tuple tsel :: Int -> Int -> ExpQ -- n-tuple a -> a tsel i n = [| \t -> $(caseE [| t |] [alt]) |] where alt = match (tupP pats) body [] pats = map varP xs xs = [ mkName ("x" ++ show k) | k <- [1..n] ] body = normalB . varE $ xs !! (i-1) -- | Maps a function over the ith component of an n-tuple tmap :: Int -> Int -> ExpQ -- :: (a -> b) -> n-tuple -> n-tuple tmap i n = do f <- newName "f" t <- newName "t" lamE [varP f, varP t] $ [| let prefix = map extract [1..(i-1)] new = $f ($(tsel i n) $t) suffix = map extract [(i+1)..n] extract k = $(tsel k n) t in tupE $ prefix ++ [new] ++ suffix |] However, this code results in the following error: Sandbox.hs:26:29: Stage error: ‘k’ is bound at stage 2 but used at stage 1 … In the splice: $(tsel k n) In the Template Haskell quotation [| let prefix = map extract [1 .. (i - 1)] new = $f ($(tsel i n) ($t)) suffix = map extract [(i + 1) .. n] extract k = $(tsel k n) $t in tupE $ prefix ++ [new] ++ suffix |] Compilation failed. Could anyone explain to me what stage 2 and stage 1 refer to, and further, what the logical flaw in the above snippet is? What exactly is wrong with line `extract k = $(tsel k n) $t' ? Thanks! Dominik.

2 1

Re: [Haskell-cafe] Local types
by Johannes Waldmann 25 Jan '16

25 Jan '16

> I often wish to be able to define local types and instances ... https://mail.haskell.org/pipermail/haskell-cafe/2014-October/116291.html

3 2

ANN: toysolver 0.4.0 released
by Masahiro Sakai 25 Jan '16

25 Jan '16

I'm announcing the release of the toysolver package, version 0.4.0. The toysolver provides solver implementations of various problems including SAT, SMT, Max-SAT, PBS (Pseudo Boolean Satisfaction), PBO (Pseudo Boolean Optimization), MILP (Mixed Integer Linear Programming) and non-linear real arithmetic. The highlight of this release is the introduction of SMT (Satisfiablity Modulo Theories) solver 'toysmt'. At the moment, toysmt is very experimental and only supports the theory of uninterpreted functions and the theory of linear real arithmetic. http://hackage.haskell.org/package/toysolver https://github.com/msakai/toysolver/releases/tag/v0.4.0 Thanks, -- Masahiro Sakai

2 2

trying to build Hackage hoq-0.3
by Vasili I. Galchin 25 Jan '16

25 Jan '16

1) ghc version 7.6.3 2) cabal version 1.16.0.2 3) when i run "cabal install", I receive on stdout : Resolving dependencies... Configuring readline-1.0.3.0... checking for gcc... gcc checking for C compiler default output file name... a.out checking whether the C compiler works... yes checking whether we are cross compiling... no checking for suffix of executables... checking for suffix of object files... o checking whether we are using the GNU C compiler... yes checking whether gcc accepts -g... yes checking for gcc option to accept ISO C89... none needed checking for GNUreadline.framework... checking for readline... no checking for tputs in -lncurses... no checking for tputs in -ltermcap... no checking for tputs in -lcurses... no checking for rl_readline_version... no configure: error: readline not found, so this package cannot be built See `config.log' for more details. Failed to install readline-1.0.3.0 cabal: Error: some packages failed to install: hoq-0.3 depends on readline-1.0.3.0 which failed to install. readline-1.0.3.0 failed during the configure step. The exception was: ExitFailure 1 4) I googled Haskell and readline and I found the same error with other Haskell packages like Twitter. How do I resolve my build readline problem? Vasya

2 3

[ANN] nano-erl
by amindfv＠gmail.com 23 Jan '16

23 Jan '16

I've written a tiny library for Erlang-style actor semantics in Haskell: hackage.haskell.org/package/nano-erl It's fast, and meant to be a lightweight abstraction that's easy to integrate with existing code. Enjoy! Tom

1 0

question on the design of protohaskell (in Write You a Haskell)
by Maurizio Vitale 23 Jan '16

23 Jan '16

I know this part has been left incomplete when Stephen got a real job, but I have a question. In http://dev.stephendiehl.com/fun/007_path.html, compiler steps are piped together using the Kleisli (>=>) operator, presumably the one from Control.Monad. they also return some flavour of AST (typically Syn.Module or Core.Module). Assuming that the >=> is the one from Control.Monad, what is the purpose of this returned value (all the steps are in a compilerMonad and presumably would have to update the state w/ the new AST anyhow)? Or is the intention to have a special >=> that also updates the state (but I wouldn't know how to deal w/ Syn.Core vs Core.Module) I would understand some form of phantom type to ensure that compilation steps are in the right order, but as it is I'm puzzled. Anybody has some insight? Thanks, Maurizio

2 1

Haskell Weekly News
by Kim-Ee Yeoh 22 Jan '16

22 Jan '16

Dear Gentle Reader, Many, many beautiful gems in the Haskell Weekly News archives are worth a second look. To give you a taste, I reproduce below excerpts from the quotes section of the Jan 31, 2007 issue -- yes, that's 9 years ago -- under the editorship of Don Stewart. Enjoy. Best, Kim-Ee Yeoh *Top Picks* - Edsko de Vries designs O(1)-amortized and O(1)-worst-case queues <http://www.well-typed.com/blog/2016/01/efficient-queues/> using a technique different from the standard literature by Chris Okasaki. In particular, the O(1)-worst-case queue employs a Progress datatype that could be reused to also optimize data structures other than queues. On the other hand, Lennart Augustsson on /r/haskell was pleased as a plum until he saw the unsafeInterleaveST <https://www.reddit.com/r/haskell/comments/412n6n/new_blog_post_efficient_am…> required to pull off the Progress technique. Elsewhere, Hacker News rates the article highly enough <https://news.ycombinator.com/item?id=10913720> for it to stay on the front page for five hours <http://hnrankings.info/10913720/>. However, the comments there belie that the advanced Haskell goes swoosh over the head of the average HN reader. - Philipp Schuster sketches a FRP implementation based on temporal logic <http://haskellexists.blogspot.com/2016/01/frp-for-free.html>. Neel Krishnaswami explains on /r/haskell why it suffers from space leaks <https://www.reddit.com/r/haskell/comments/40x4wf/frp_for_free/> like most other FRP implementations and ways of fixing it. - Dan Burton reports that the latest version 0.10 of the json parsing package aeson suffers from deal-breaking bugs <https://unknownparallel.wordpress.com/2016/01/14/what-to-do-with-aeson-0-10/>. Aeson author Bryan O'Sullivan, of an older email-centered generation, explains that he has "a life outside of checking github issues" in the /r/haskell discussion <https://www.reddit.com/r/haskell/comments/4101ad/what_to_do_with_aeson010/>. In any case, the next stepping 5 of Stackage LTS rolls it back to version 0.9 <https://www.reddit.com/r/haskell/comments/41gpdk/lts4_with_aeson010_is_bein…> . - A redditor asks, "What's the TypeInType extension planned for the upcoming version 8 of GHC?" The short answer is that it's used for dependent type programming. Detailed answers can be found in the actual /r/haskell Q&A <https://www.reddit.com/r/haskell/comments/4180k3/what_is_typeintype/>. - GHC on ARM used to suffer over 100 failures on the testsuite <https://ghc.haskell.org/trac/ghc/ticket/11206>. Ben Gamari girds his loins and over the last 6 weeks battled against "the villains that plague this poor architecture." Result? Nightly builds now compile clean. Go Ben! *A Blast from the Past (Quotes from #Haskell IRC):* <http://sequence.complete.org/hwn/20070131> - *huschi:* Programing in haskell seems a bit frustrating. i'm missing searching for errors :( - *bakert:* I know all my programs can be reduced to only one tenth the size if only I can learn all these crazy functions *Quote of the Week* - Will Jones: The more I write Haskell, the more it feels like Forth. Where I'm basically just inventing a language for my problem, then writing the program in that instead. (Ed. Dear Will: Remember how Dijkstra once said "Always design your programs as a member of a whole family of programs, including those that are likely to succeed it"? He would have warmly congratulated you on your discovery.) -- Kim-Ee Yeoh

1 0

Munich Haskell Meeting, 2016-01-25 @ 19:30
by Christian Neukirchen 21 Jan '16

21 Jan '16

Dear all, Next week, our monthly Munich Haskell Meeting will take place again on Monday, January 25 at Cafe Puck at 19h30. For details see here: http://chneukirchen.github.io/haskell-munich.de/dates If you plan to join, please add yourself to this dudle so we can reserve enough seats! It is OK to add yourself to the dudle anonymously or pseudonymously. https://dudle.inf.tu-dresden.de/haskell-munich-jan-2016/ Everybody is welcome! cu, -- Christian Neukirchen <chneukirchen(a)gmail.com> http://chneukirchen.org

1 0