- Haskell-Cafe - Haskell.org

HAL-10 (preliminary announcement)
by Johannes Waldmann 22 Aug '15

22 Aug '15

Dear all, > ... this year's Haskell in Leipzig I have been busy with many other things, so there are no concrete plans right now. But I think we should do it, and I am willing to host it at my institution. So - how about December 4/5 (Friday noon - Saturday noon)? (it is easier to get lecture rooms on the week-end) If you have comments or suggestions for HAL this year, then please email me, or stammtisch at haskell.iba-cg.de , or someone could set up a wiki page somewhere. Let's say we start collecting opinions now, and make a decision and a formal announcement end of September. http://www.imn.htwk-leipzig.de/~waldmann/HAL2015/ - Johannes Waldmann.

1 0

Haskell Weekly News
by Kim-Ee Yeoh 21 Aug '15

21 Aug '15

*Top picks:* - Gabriel Gonzalez evaluates Haskell <https://github.com/Gabriel439/post-rfc/blob/master/sotu.md> in the style of a State-of-the-Union address. He rates Haskell from Immature to Mature to Best-in-class under 28 headings, the first four being *Compilers,* *Server-side web programming,* *Scripting / Command-line applications,* and *Numerical programming.* He also recommends libraries and tutorials under each heading. Reverberations on Hacker News <https://news.ycombinator.com/item?id=10071535> and /r/haskell <https://www.reddit.com/r/haskell/comments/3haulk/state_of_the_haskell_ecosy…> . - Challenged over claims of FP productivity improvement, Douglas M. Auclair rattles off success stories from his previous work <http://logicaltypes.blogspot.com/2015/08/pure-functional-programming-claims…> at various subsidiaries of the US Federal Gov fending for the taxpayer to the tune of billions of dollars. Nibbles of interest on Hacker News <https://news.ycombinator.com/item?id=10057661>. - Aaron Wolf goes from zero programming directly to Haskell and writes of his experience. <https://snowdrift.coop/p/snowdrift/blog/technical-history> His favorite learning resource is the Haskell Wikibook <https://en.wikibooks.org/wiki/Haskell>, which he can improve as he reads. He is co-founder of Snowdrift.coop, a crowdfunding platform for freely-licensed works <https://snowdrift.coop/p/snowdrift/w/en/about>. The Haskell Reddit <https://www.reddit.com/r/haskell/comments/3hbrom/learning_haskell_from_noth…> finds Aaron's testimony a change from the "Haskell is too hard for me" meme. - The season of introspection continues. On the heels of Hu, Hughes, and Wang on "How Functional Programming Mattered" (see previous HWN <http://haskell.1045720.n5.nabble.com/Fwd-Haskell-Weekly-News-tp5815292.html>); Michael Green, Kathleen Fisher, and David Walker <http://tmpl.weaselhat.com/> track the ebb and flow of research topics in the conference proceedings of the Big Four: Principles of PL (POPL), PL Design and Implementation (PLDI), International Conference on FP (ICFP); and OOP, Systems, Languages, Apps (OOPSLA). No mention of Haskell but if you're looking for a brief history of PL research -- the slides are even more succinct <http://www.cs.ox.ac.uk/ralf.hinze/WG2.8/33/slides/Kathleen.pdf> -- this is the only data-driven survey you'll find. - Doug Beardsley <http://softwaresimply.blogspot.com/2015/08/why-version-bounds-cannot-be-inf…> reminds us that date-based version inference cannot replace the role of explicit version upper bounds. The reason? The package developer might not be using the latest version of its dependencies on the day they publish the work. Also, among the 72 comments of the /r/haskell convo <https://www.reddit.com/r/haskell/comments/3h83jl/why_version_bounds_cannot_…>, Doug observes that Stackage over-conservatively locks to a single version, whereas community-wide adherence to the Package Versioning Policy (PVP) of original hackage <https://wiki.haskell.org/Package_versioning_policy> yields seamless delivery of bugfixes and improvements. - In less than a week, Xmonad will lose its issue tracking system. On Aug 24, Google Code goes read-only <http://google-opensource.blogspot.sg/2015/03/farewell-to-google-code.html>. Community heroes Brandon Allbery and Daniel Wagner <http://haskell.1045720.n5.nabble.com/google-code-issues-td5815183.html> work at grabbing a backup of the issues. Still no consensus over what and where to migrate to. - Mark Dominus <http://blog.plover.com/aliens/dd/> delves into the bits and bytes of the 1999 Cosmic Call <http://en.wikipedia.org/wiki/Cosmic_Call> attempt by astrophysicists to contact aliens. He shows the visual bitmaps transmitted into space. Brent Yorgey <http://mathlesstraveled.com/2015/08/19/cosmic-call-at-the-universe-of-disco…> writes to say he enjoys the 23-part series interspersed with little puzzles. *Quotes of the Week:* - Doug McIlroy <http://ircbrowse.net/browse/haskell?id=20962286&timestamp=1435683815#t14356…>: Conditional compilation is admitting defeat. - /u/kamatsu <https://www.reddit.com/r/haskell/comments/3h5og6/i_now_tend_to_think_that_t…>: I feel like the reason people find Haskell an eye-opening experience is because their CS education was deficient. - @wfaler <https://twitter.com/wfaler/status/631815511949615104>: Is there a club to join when you silently sob at having to give your Monad Transformers Monad Transformers? Sounds a lot like #EnterpriseFP -- Kim-Ee

1 0

Re: [Haskell-cafe] List of nitpicks
by Johannes Waldmann 21 Aug '15

21 Aug '15

> Should there be a similar place for tooling and libraries? a Gargantuan task > QuickCheck fails by letting all tests pass > when you mistakenly provide polymorphic type signatures. No! Prelude Test.QuickCheck> quickCheck $ ( (\ x -> 1 > 9) :: a -> Bool) *** Failed! Falsifiable (after 1 test): () I think you mean "defaults everything to () and thus runs polymorphic tests at unexpected types" Prelude Test.QuickCheck> quickCheck $ ( (\ xs -> xs == reverse xs ) :: Eq a => [a] -> Bool) +++ OK, passed 100 tests. - J.W.

3 2

Reactive config file generation
by David Turner 20 Aug '15

20 Aug '15

Hi all, I am using Apache Zookeeper as a service directory: I have a bunch of services which announce their presence by making nodes in Zookeeper, so that dependent services can update their configuration to make use of the available services, and stop trying to use services that have died. Zookeeper is a pretty nice fit for this because it supports watching a node for changes, so in theory there is no need to poll Zookeeper periodically. The services that I control work with this just fine, but there are some (e.g. an Nginx reverse-proxy) that are reconfigured using the rather more common approach of updating a file (or files) and then sending the process a signal. I am currently pondering how to make this work without polling, or manually triggering a refresh script, which is how it is currently done. I've never used FRP, but am at least vaguely aware of it and from my high-level understanding it seems like this could be a very good fit. The Zookeeper state is a time-varying value which I want to convert into a time-varying set of files, ideally as declaratively as possible. So, two questions to the FRP congnoscenti out there. Firstly, is it worthwhile to attempt this using FRP at all? I'm sure I could do it by hand too. Secondly, which of the many FRP libraries would you recommend for it? There are loads on the Wiki, seemingly in various states of repair and documentation. Any pointers on how to choose one that's featureful enough, performant enough, and being actively maintained? Thanks in advance, David

3 3

ANN: cabal-bounds 1.0.0
by Daniel Trstenjak 20 Aug '15

20 Aug '15

cabal-bounds[1] is a command line programm for managing the bounds/versions of the dependencies in a cabal file. Changes for 1.0.0 ================= * automatically find the cabal and setup-config files * ignore the base library by default Perhaps the two most relevant use cases: Initialize Bounds ================= If you have started a new project, created a cabal file, added dependencies to it, build it, and now want to set the lower and upper bounds of the dependencies according to the currently used versions of the build, then you can just call: $> cabal-bounds update This call will update the bounds of the dependencies of the cabal file in the working directory. Raise the Upper Bounds ====================== If you have several cabalized projects, then it can be quite time consuming to keep the bounds of your dependencies up to date. Especially if you're following the [package versioning policy](<http://www.haskell.org/haskellwiki/Package_versioning_policy>), then you want to raise your upper bounds from time to time, to allow the building with newer versions of the dependencies. `cabal-bounds` tries to automate this update process to some degree. So a typical update process might look like: # update the version infos of all libraries $> cabal update # drops the upper bound of all dependencies of the cabal file in the working directory $> cabal-bounds drop --upper # create a cabal sandbox for building your project, this ensures that you're really using # the newest available versions of the dependencies, otherwise you would be constraint # to the already installed versions $> cabal sandbox init # build your project $> cabal install # update the upper bound of all dependencies of the cabal file in the working directory $> cabal-bounds update --upper Please consult the README for further informations. [1] https://github.com/dan-t/cabal-bounds

1 0

octree implementation - followup to "How to model outer space for a MUD"
by Michael Litchard 20 Aug '15

20 Aug '15

It looks like Octree is what I want if I can solve a particular problem. First let me articulate what I am looking for. (1) Objects in 3-d space with no spatial extent. Collision is determined by two objects occupying the same point.' (2) Efficient insert-delete-update #2 seems to be the problem. I found this library, thankfully. I believe it's exactly what I am looking for, but for quadtrees. https://github.com/AshleyMoni/QuadTree I'm a little overwhelmed as this is a new data structure for me. I believe if I can grok what is going on in this library, I can take these ideas and extend them to the octree. I'm referring specifically to this module https://github.com/AshleyMoni/QuadTree/blob/master/Data/QuadTree/Internal.hs And these functions setLocation :: Eq a => Location -> a -> QuadTree a -> QuadTree a setLocation = set . atLocation atLocation (Having difficulty cutting and pasting this to mail.) I'd like to be able to visualize how the tree is being compressed, it may help to be able to see what happens to the tree when it's not compressed. Does anyone have a pointer or advice in how to break this library down in parts to help me grok, in a way that will help me extend to octree?

3 3

List of nitpicks
by William Yager 20 Aug '15

20 Aug '15

Hello all, Inspired by the recent thread re. modifying data/type/newtype syntax, I've made a wiki article dedicated to Haskell-related nitpicks. I've added a few entries; one from the thread I just mentioned, and a classic from way back in the 90s (map vs fmap). https://wiki.haskell.org/Nitpicks Hopefully, this page will help us keep track of what people are annoyed about (especially people who aren't already inured to the quirks of Haskell) as well as give us inspiration for future proposals. Cheers, Will

7 7

Problem parallelising simple algorithm
by Jens Blanck 20 Aug '15

20 Aug '15

The following code simply computes the Euler constant by binary splitting. I'm struggling to get any speed-up on multi-core. Why do I get a fair number of fizzled? Why don't I get any real speed-up even if it claims to run tasks in parallel? Could I have exhausted the integer arithmetic unit(s) on my chip (i7-4790)? How would I verify that? The following is the code and typical runs on 1 and 4 cores respectively. --------- import Control.Parallel.Strategies import Control.DeepSeq import Data.Ratio divConq :: (NFData b) => (a -> b) -> a -> (a -> Bool) -> (b -> b -> b) -> (a -> Maybe (a,a)) -> b divConq f arg threshold conquer divide = go arg where go arg = case divide arg of Nothing -> f arg Just (l0,r0) -> conquer l1 r1 `using` strat where l1 = go l0 r1 = go r0 strat x = do r l1; r r1; return x where r | threshold arg = rdeepseq | otherwise = rpar pqCombine :: (Integer, Integer) -> (Integer, Integer) -> (Integer, Integer) pqCombine (pl, ql) (pr, qr) = (pl*qr+pr, ql*qr) pq :: (Integer, Integer) -> (Integer, Integer) pq (a, b) = (\t -> (sum t, last t)) $ scanl1 (*) [b,b-1..a+1] euler :: Integer -> Rational euler n = let (p,q) = divConq pq (0,n) (\(a,b) -> b-a < 10000) pqCombine (\(a,b) -> if b-a > 5 then let m = (a+b+1) `div` 2 in Just ((a,m), (m, b)) else Nothing) in p%q main = print $ euler 320000 `seq` () ---------- > ./BinSplit +RTS -s -N1 () 178,375,880 bytes allocated in the heap 2,452,040 bytes copied during GC 3,222,696 bytes maximum residency (7 sample(s)) 883,040 bytes maximum slop 11 MB total memory in use (2 MB lost due to fragmentation) Tot time (elapsed) Avg pause Max pause Gen 0 333 colls, 0 par 0.004s 0.002s 0.0000s 0.0000s Gen 1 7 colls, 0 par 0.001s 0.001s 0.0001s 0.0003s TASKS: 4 (1 bound, 3 peak workers (3 total), using -N1) SPARKS: 126 (0 converted, 0 overflowed, 0 dud, 0 GC'd, 126 fizzled) INIT time 0.001s ( 0.000s elapsed) MUT time 0.928s ( 0.936s elapsed) GC time 0.005s ( 0.003s elapsed) EXIT time 0.001s ( 0.000s elapsed) Total time 0.935s ( 0.939s elapsed) Alloc rate 192,215,387 bytes per MUT second Productivity 99.4% of total user, 98.9% of total elapsed gc_alloc_block_sync: 0 whitehole_spin: 0 gen[0].sync: 0 gen[1].sync: 0 > ./BinSplit +RTS -s -N4 () 178,727,480 bytes allocated in the heap 3,506,488 bytes copied during GC 3,650,032 bytes maximum residency (7 sample(s)) 934,976 bytes maximum slop 12 MB total memory in use (1 MB lost due to fragmentation) Tot time (elapsed) Avg pause Max pause Gen 0 141 colls, 141 par 0.009s 0.002s 0.0000s 0.0001s Gen 1 7 colls, 6 par 0.003s 0.001s 0.0001s 0.0001s Parallel GC work balance: 38.80% (serial 0%, perfect 100%) TASKS: 10 (1 bound, 9 peak workers (9 total), using -N4) SPARKS: 126 (12 converted, 0 overflowed, 0 dud, 0 GC'd, 114 fizzled) INIT time 0.002s ( 0.002s elapsed) MUT time 2.104s ( 0.946s elapsed) GC time 0.012s ( 0.003s elapsed) EXIT time 0.001s ( 0.000s elapsed) Total time 2.119s ( 0.951s elapsed) Alloc rate 84,946,520 bytes per MUT second Productivity 99.3% of total user, 221.3% of total elapsed gc_alloc_block_sync: 600 whitehole_spin: 0 gen[0].sync: 9 gen[1].sync: 1073

1 1

Haskell developer position in Jerusalem
by Yitzchak Gale 20 Aug '15

20 Aug '15

We have a position open for a Haskell developer. This is an on-site position at our development center in Jerusalem. You will be working on our enterprise customer-tailored content delivery products - see the "Products" tab on our home page - which are implemented (mostly) in Haskell. Search for Haskell on our "Careers" page for a fuller description of the position. Submit your CV to [jobs@suite-sol.com](mailto:jobs@suite-sol.com), but also feel free to contact me if you have any questions. Thanks, Yitz

2 2

haddock complains about unknown symbol in .a file
by Johannes Waldmann 20 Aug '15

20 Aug '15

Dear all, what is happening here? http://hackage.haskell.org/package/satchmo-2.9.9.1/reports/1/log The library is built, but haddock fails with haddock: /home/builder/hackage-server/build-cache/tmp-install/lib/x86_64-linux-ghc-7.8.3/minisat-0.1.2/libHSminisat-0.1.2.a: unknown symbol `_ZGVZN7Minisat6Option13getOptionListEvE7options' Why is haddock complaining, but ghc is not? Any pointers appreciated (to explain and solve the problem - I think there's a work-around of uploading documentation to hackage but that does not feel right) - J.W.

1 0

A type level puzzle
by Tom Ellis 20 Aug '15

20 Aug '15

For the type level gurus: I would like to define types Sum :: [Field] -> * (:::) :: String -> * -> Field used like this Sum '[ "foo" ::: a, "bar" ::: b, "baz" ::: c ] (I hope this makes sense. I'm not quite familiar with the syntax.) such that Sum '[ s1 ::: a1, ... ] unifies with Sum '[ s1 ::: b1, ... ] to give Sum '[ s1 ::: c1, ... ] where c1 is the unification of a1 and b1. If sn is absent from exactly one of the unificands then its type is copied over unchanged. If sn is absent from both then it is absent from the unification. The types should also be invariant under permutation of the list. This is perhaps a bit obscure so I'll explain the application. This is intended for the sumtype equivalent of a record type, so if we have Sum '[ "foo" ::: a, "bar" ::: b ] and Sum '[ "foo" ::: a, "baz" ::: c ] then I take take the sum of these sums and get something of type Sum '[ "foo" ::: a, "bar" ::: b, "baz" ::: c ] If it makes it easier than I am happy for Sum '[ s1 ::: a1, ... ] to unify with forall ak. Sum '[ s1 ::: a1, ..., sk ::: ak ] This is justified by forall b. Either a b being isomorphic to a. Is such a type possible? If so my next question will be about how to type deconstructors of such things, but let's start with a small first step! Thanks, Tom

6 10

Kill forked threads in ghci
by amindfv＠gmail.com 17 Aug '15

17 Aug '15

Is there a way in ghci to kill all running background processes without quitting ghci itself? E.g. if I do > forkIO . forever $ print 5 >> threadDelay 1000000 If I don't have the ThreadId, is there any way for me to stop printing "5"s without killing ghci? tom

2 1

oddsFrom3 function
by Debdut Karmakar 17 Aug '15

17 Aug '15

I am a haskell beginner and wondering how the following function works (in procedure) : oddsFrom3 :: [Integer] oddsFrom3 = 3 : map (+2) oddsFrom3 Thanks for your help. -- A GNU [1] LINUX [2] Patron Links: ------ [1] http://gnu.org [2] http://www.linuxfoundation.org/

3 2

ANN: ghc-mod-5.3.0.0
by Daniel Gröber 17 Aug '15

17 Aug '15

I'm pleased to announce the long awaited release of ghc-mod 5.3.0.0! What is ghc-mod? ================ ghc-mod is both a backend program for enhancing editors and other kinds of development environments with support for Haskell and a library for abstracting the black magic incantations required to use the GHC API in various environments, especially Cabal projects. The library is used by ambitious projects like HaRe[1] and mote[2]. After a period of declining activity, development has been picking up pace again since I have taken over as maintainer. Most changes during versions 5.0.0 through 5.2.1.2 consisted only of fixes and internal cleanup work, but this release brings with it vastly improved Cabal support and support for GHC 7.10. ghc-mod now has intimate knowledge of the components in a Cabal project, this allows it to make much more informed decisions about which options to pass to GHC for any given module than previously possible. The largest complication for this work was the fact that ghc-mod must consult Cabal's internal configuration information (the file that `cabal configure` generates) which is bound to one specific version of Cabal (the library) while surviving users upgrading their cabal-install executables, which will link `cabal` (the executable) against a different version of Cabal (the library) thus breaking ghc-mod's ability to read the configuration information. Out of the frustration with this horrible state of affairs cabal-helper was born (https://github.com/DanielG/cabal-helper) which now isolates ghc-mod against any and all Cabal version related problems. Long story short this all is a major step forward in terms of how well ghc-mod's suggestions reflect what `cabal build` would report, and should also allow ghc-mod to work even in more complicated Cabal setups. How to contribute ================= Right now ghc-mod has only one core developer and only a handful of occasional drive-by contributors even though it's a non-insignificant part of the first-time Haskell experience, we regularly receive bug reports and support requests from people only just starting Haskell hacking. Unfortunately in the last 7 months this experience was not a very good one because we are sorely lacking active contributors willing to actually fix bugs. I think this is a very disappointing state of affairs since we're essentially driving people away to other languages for no good reason. The way forward --------------- Right now I'm working full time on ghc-mod as part of a summer internship at IIJ Innovation Institute in Japan and will continue to do so until the end of September. I would like to invite anyone who is interested in improving ghc-mod to come and talk to me in #ghc-mod on Freenode (I'm "dxld" there) or E-Mail me directly. During my internship I will be working on splitting ghc-mod into a frontend and backend package to make integration with external tools like HaRe and mote easier, rewriting the ghc-mod frontend tools to be based on a server-client architecture and if time allows adding proper interactive code execution to ghc-mod so it can be used as a ghci replacement in frontends. In the meantime my supervisor Kazu Yamamoto will also be hacking on ghc-mod, mostly improving the Emacs frontend and possibly merging it into haskell-mode[3]. The ghc-mod code base can be quite a beast for anyone looking at if for the first time, I've been trying to improve the situation since I joined the project but after a while you just loose this new pair of eyes and become blind to all the things that could be improved. While I'm still at IIJ-II I can offer anyone who wants to work on ghc-mod my support in getting started with the codebase. Getting ghc-mod =============== Github: https://github.com/kazu-yamamoto/ghc-mod Hackage: http://hackage.haskell.org/package/ghc-mod Frontends: - Emacs (native): https://github.com/kazu-yamamoto/ghc-mod https://github.com/iquiw/company-ghc - Vim: https://github.com/eagletmt/ghcmod-vim https://github.com/eagletmt/neco-ghc - Atom: https://github.com/atom-haskell/ide-haskell https://github.com/andyfriesen/Helium Known issues ============ The new and improved Cabal support required heavy use of caching and there seem to still be some cases of cache invalidation of the module graph not working properly. For now these can be fixed by deleting dist/setup-config.ghc-mod.* ghc-mod's `case`, `sig` and `refine` commands do not work properly with GHC 7.10 yet: https://github.com/kazu-yamamoto/ghc-mod/issues/438 If you do notice any other problems please report them: https://github.com/kazu-yamamoto/ghc-mod/issues ---- [1]: https://github.com/alanz/HaRe [2]: https://github.com/imeckler/mote [3]: https://github.com/kazu-yamamoto/ghc-mod/issues/454#issuecomment-127603458 https://github.com/kazu-yamamoto/ghc-mod/issues/544

1 0

How to model outer space for a MUD
by Michael Litchard 17 Aug '15

17 Aug '15

Star Wars MUD has a 3-D coordinate system such that (0,0,0) is some planet. I'm curious as to how one might model this system that could simulate a ship's movement through a 3-D grid. Matrix, 3-D array, graph. None of these? Ideas?

7 10

Swedish spin-off has openings for advanced functional programmers - Haskell, OCaml, Scala, and more, Functor, the Swedish Martin-Löf type theory spinoff, is in the midst of recruiting right now, interviewing beginning already — Is it for you?
by Johan Glimming 16 Aug '15

16 Aug '15

Hi, Do you want to be part of the journey as the Functor startup research spin-off innovates the future of software engineering? Do you want to make a difference? Do you want to devote your talents where it can have incredible impact on the entire software industry? Functor, Sweden, is again looking for brilliant minds, essentially co-founders as a generous equity program will after a certain threshold time make sure developers, building the company indeed, also own what they are building. Now, for what follows, hold on to your seats a bit, and remember we are a spinoff startup still, and have no marketing department though we do have expertise in human resources, the most important resource for any company at any given time, to nourish and breed a culture of excellence at any given time at Functor. Remote work initially is not a problem before we move those we can, though probably not all developers will be able to move, to great office space in Sweden. We have to recruit internationally for obvious reasons (read about our technology below). There are openings at Functor Group AB, and Functor AB, Functor Consulting AB, Sweden, including also remote work, except for Scala consultants who must immediately relocate. Feel free to forward this further, and jobs(a)functor.se can also be used according to the final paragraph in this posting, while we favour the LinkedIn job advertisement with as many of the appendices we hope for as possible (see https://goo.gl/4agSy6 <https://goo.gl/4agSy6>). We are in the midst of recruitment, and those who already applied please stay tuned, for others, check the following and the links further below. Note that we use both Haskell and OCaml in our development. Functor Scalor™ heavily uses Haskell in its top layers but the Martin-Löf type theory virtual machine is written in OCaml so we need you to master functional programming at large, since OCaml is at the moment faster and has for our purposes the right libraries for LLVM bindings etcetera. We do static analysis for embedded software with our product Functor Prevent™, and 95% of that software is written in C, just like Erlang/OTP, MySQL, IoT OSes and the Linux kernel, and numerous trending projects at GitHub, and OpenSSL where we have shown we would have prevented the Heartbleed bug and security vulnerability <http://www.bbc.co.uk/search?q=heartbleed> the worst bug in human history in the sense of numerous metrics, whilst damages are impossible to know (you did change all your passwords, we hope), and other bugs such as the sendmail bug whereby virtually all UNIX and Linux servers where open to attack some years ago and hopefully for the most part patched today … Apply to work at Functor as LinkedIn job applications are still accepted now but closing soon and interviews has begun. We might need you at Functor for our success and further growth: ■ Apply from LinkedIn <https://goo.gl/ZkdMQY>, see instructions below, https://goo.gl/ZkdMQY <https://www.facebook.com/l.php?u=https%3A%2F%2Fgoo.gl%2FZkdMQY&h=-AQGfp_6ZA…> ■ For instructions <https://goo.gl/4agSy6> read the last paragraph of the earlier LinkedIn posting: https://goo.gl/4agSy6 <https://www.facebook.com/l.php?u=https%3A%2F%2Fgoo.gl%2F4agSy6&h=NAQE9lGOoA…> <https://www.linkedin.com/pulse/functor-looks-strengthen-leadership-more-tal…> We use Haskell, OCaml, LLVM and our tools are closely tied to the C programming language and indeed to functional programming. Embedded software market is one target market, and skills in compiler design, type systems and operational semantics is key to our teams though we look for optimised teams as a whole, and your particular skill set may or may not include a PhD, but surely industrial experience. We have openings for Research Engineers and have some renown Research Engineers already. Research collaboration is key to our success and projects planned including a large EU project CONSTRUCTOR next year. We have strong industrial partners and some very high-profile customers internationally. The customer-driven journey is still at an early stage, while founded in 2011, and your contributions would be key to our success. Since last year, we use OCaml for key components in both Functor Prevent™ and Functor Scalor™ lower layers, including due to LLVM bindings and for performance (both tools are exceptionally efficient. The Functor Scalor™ with the new Score™ low-level type theory machine uses OCaml. Hence, the lowest lavel is indeed pure Martin-Löf type theory. Functor Scalor™ is amazingly ultimately solid Scandinavian operational semantics adapted for a meta programming language specifically. With this core developed and then in every detail overseen by Per Martin-Löf himself, we have a reliable and state-of-the-art virtual machine. Our research adds to this a defined W-type monad creating a category with the desirable properties. Hence, on top of the solid logic core, Scalor™ has facilities to perform as fast as C in critical components. The benchmarks speak for themselves, and yet Scalor™ is a new kind of meta programming platform, aligned with the domain-driven design movement, though we have aligned it with advances in software engineering, known as domain engineering, which is an emerging new methodology giving DDD a solid foundation, but at the same time not compromising in any way, in any product, the simplicity and elegance. Programmers are not mathematicians, but inside our products you will find some seriously exciting technology to make it all possible. See www.language-driven.org <http://l.facebook.com/l.php?u=http%3A%2F%2Fwww.language-driven.org%2F&h=DAQ…> and www.domain-specific.org. <http://l.facebook.com/l.php?u=http%3A%2F%2Fwww.domain-specific.org%2F&h=CAQ…> For this reason, we need additional brilliant OCaml developers to strengthen our teams, both for Functor Prevent™ and its program analysis with dependent types also based on solid operational semantics, and Functor Scalor™ with full-blown type theory, named the new constructive programming paradigm already back in 2012, unwittingly perhaps a name coined by Per Martin-Löf himself. Recent progress has made all this possible, and industrial productification has made it all usable in real-world applications, despite the advanced technology inside, which can be trusted, implies elegance, coherence, simplicity, and with close to zero-learning curve for Prevent™ and a lean one for Functor Scalor™. Scala consultants will be sent straight from the top down into projects at Ericsson for very challenging work. For these three consultants we require an exceptionally strong background with Scala projects as we team up with Typesafe and secure projects that can only be matched by exceptional Scala developers. Our Functor Scalor™ is oriented somewhat differently than Scala, see www.domainspecific.org <http://l.facebook.com/l.php?u=http%3A%2F%2Fwww.domainspecific.org%2F&h=KAQE…> for some initial information on that products that appeals to very large companies at this stage, while Functor Prevent™ is suitable for just about any software development projects, currently doing static analysis with dependent types and automatic testing for C code, such as the Erlang code base, Twitter’s MySQL branch or embedded software at large, see www.functorprevent.com <http://l.facebook.com/l.php?u=http%3A%2F%2Fwww.functorprevent.com%2F&h=WAQG…> or www.static-analysis.org <http://l.facebook.com/l.php?u=http%3A%2F%2Fwww.static-analysis.org%2F&h=MAQ…>, and also the standalone tool www.functor.se/prevent <http://l.facebook.com/l.php?u=http%3A%2F%2Fwww.functor.se%2Fprevent&h=MAQFr…> which secures systems including a project at a customer with a range of 100 MEUR/each equipment investments, all relying on the VxWorks C code where our Functor Prevent™ delivers its value to prevent up to 50% of the bugs in certain projects, already with its current R1 feature set! For instructions on how to best apply, what we recommend, read our pre-compaign LinkedIn posting: ■ Openings for functional programmers at Swedish startup <https://goo.gl/4agSy6>, https://goo.gl/4agSy6 <https://www.facebook.com/l.php?u=https%3A%2F%2Fgoo.gl%2F4agSy6&h=TAQFTHNkpA…> - see instructions on last paragraph! Read up with links above to our webpages (last link), and postings on LinkedIn and Facebook: ■ The Future of Software Engineering <https://goo.gl/mbd76F>, https://goo.gl/mbd76F <https://www.facebook.com/l.php?u=https%3A%2F%2Fgoo.gl%2Fmbd76F&h=DAQGprr1EA…> ■ Functor looks to strengthen leadership <https://goo.gl/rVtMLx>, https://goo.gl/rVtMLx <https://goo.gl/rVtMLx> See also recent news media coverage of Functor, and other LinkedIn postings: ■ Embedded Conference Scandinavia <https://goo.gl/1vN2Ij>, https://goo.gl/1vN2Ij <https://www.facebook.com/l.php?u=https%3A%2F%2Fgoo.gl%2F1vN2Ij&h=YAQFGOtBEA…> ■ Information for STHML TECH FEST <https://goo.gl/kANCT5>, https://goo.gl/kANCT5 <https://www.facebook.com/l.php?u=https%3A%2F%2Fgoo.gl%2FkANCT5&h=nAQE4-iyVA…> ■ STHML TECH FEST invitation <https://goo.gl/RzEI9H>, https://goo.gl/RzEI9H <https://www.facebook.com/l.php?u=https%3A%2F%2Fgoo.gl%2FRzEI9H&h=rAQHn7PN0A…> Older job campaign provides some useful further information — beware that it is not the current one: ■ Openings globally for Scala & Haskell developers, https://goo.gl/6is0xU <https://goo.gl/6is0xU>, now out-dated but can be good reading just the same for candidates! Some of our Facebook pages, like them and see occasional posts in your own news feed as a result: ■ Functor AB <http://www.facebook.com/functor>, www.facebook.com/functor <https://www.facebook.com/functor> ■ Functor Group AB <http://www.facebook.com/functorgroup>, www.facebook.com/functorgroup <http://www.facebook.com/functorgroup> Join some interesting groups on Facebook and contribute: ■ Software Bugs <https://www.facebook.com/groups/softwarebugs>, https://www.facebook.com/groups/softwarebugs <https://www.facebook.com/groups/softwarebugs> ■ High-Tech Startups in Sweden <https://www.facebook.com/groups/hightechsweden/>igh-Tech Startups in Sweden <https://www.facebook.com/groups/hightechsweden/>, with the allegedly richest woman in Sweden, the acting Wallenberg family are all men, serial entrepreneur in IT already a member in this new group that we manage, https://www.facebook.com/groups/hightechsweden/ <https://www.facebook.com/groups/hightechsweden/> ■ High-Tech Startup Jobs in Sweden <https://www.facebook.com/groups/swedentech>, https://www.facebook.com/groups/swedentech <https://www.facebook.com/groups/swedentech> We host a newly announced event sporting leaders of the largest entrepreneur networks in Sweden although just announced, welcome to join us at Hotellet in Stockholm, which is an amazing place for the kick-off. Special invites and keynote speaker, plus mingle and drinks of course, all professional in the spirit of the group description for High-Tech Startups in Sweden, which organises the event (viz. Functor AB, Functor Group AB), co-hosts to be announced: ■ High-Tech Startup Meetup Launch hosted by Functor Group AB <https://www.facebook.com/events/1631452680449642/?ref=1&action_history=%5B%…>, all welcome within this special interest community, it’s perhaps just an airplane away? <https://www.linkedin.com/pulse/openings-functional-programmers-swedish-star…> APPENDIX FOR SOME TECHNOLOGY INSIGHTS AND OUR VISION FRAMED ACTUALLY BY NO ONE ELSE BUT BJARNE STROUSTRUP IN HIS COMPUTER REVIEW PAPER OF THE YEAR (2012) CONTRIBUTION: Why dependent types then? You probably already understand this, and the reasons are numerous and far from just technical. You have surely read up on many papers such as “Why depdendent types matter?” and more. You might see why the timing is just right now, but let’s hear out what a very influential programming language contributors has to say about the problems we address and how they should be addressed: Stroustrup didn’t quite imagine going outside C++, at least not in his Computing Reviews "Best of 2012" paper (PDF via link below). His paper on Infrastructure Software (, though, makes the case for dependent type theory and our products very strongly. John Mitchell frames his contributions very well by writing " The main goal of C++ is to provide object-oriented features in a C-based language without compromising the efficiency of C … data abstraction and object-oriented features … better static type checking … efficiency of compiled code …” (book reference below). Functor Scalor™ has an object-based object model derived from the Timber projects (which came out of O’Haskell) and a novel component model on top of that for low-level performance with dependently typed interfaces. Added to the domain-driven design movement and augmenting it, meaning methodological advantages of a meta programming language, Functor Scalor™ is a direct solution to the problems pinpointed by Stroustrup in IEEE Computer, January, 2012: ■ Stroustrup’s “Software Development for Infrastructure” paper selected by CR Best of 2012 : Standard C++ <https://isocpp.org/blog/2013/05/stroustrups-software-development-for-infras…>, we advise strongly to skip those pages towards the end involving C++, for obvious reasons when the Constructive Programming Paradigm was coined to be the next programming paradigm in STEW 2012 co-autthored by Thorsten Altenkirch and Patrik Jansson (“What is the next programming paradigm?”, STEW 2012). Let’s also cite Löh, McBride and Swierstra in a paper that is probably familiar to all of you: "Most functional programmers are hesitant to program with dependent types. It is said that type checking becomes undecidable; the type checker will always loop; and that dependent types are just really, really, hard. The same programmers, however, are perfectly happy to program with a ghastly hodgepodge of complex type system extensions. Current Haskell implementations, for instance, support generalized algebraic data types, multi-parameter type classes with functional dependencies, associated types and type families, impredicative higher-ranked types, and there are even more extensions on the way. Programmers seem to be willing to go to great lengths just to avoid dependent types. One of the major barriers preventing the further proliferation of dependent types is a lack of understanding amongst the general functional programming community. While, by now, there are quite a few good experimental tools and programming languages based on dependent types, it is hard to grasp how these tools actually work. A significant part of the literature available on dependent types is written by type theorists for other type theorists to read. As a result, these papers are often not easily accessible to functional programmers.” Löh et al, A tutorial implementation of a dependently typed lambda calculus <http://www.andres-loeh.de/LambdaPi/LambdaPi.pdf> († <http://content.iospress.com/articles/fundamenta-informaticae/fi102-2-03>), Fundamenta Informaticae, no. 2 (vol.102), 2010, pp. 177-207. See also this link <http://www.andres-loeh.de/LambdaPi/> if you wish. As we are developers, bringing cutting-edge technology and a mountain of research right into the industry, standing on the shoulders of giants and work done during four decades, you may enjoy also eg this article: ■ Sheard et al, Language-based verification will change the world <http://dl.acm.org/citation.cfm?id=1882432>, ACM proceedings of the FSE/SDP, Future of software engineering research, SIGSOFT/FSE'10 18th ACM SIGSOFT Symposium on the Foundations of Software Engineering (FSE-18), 2010, ACM Press. (PDF <http://www.seas.upenn.edu/~sweirich/papers/foser10.pdf>) <https://www.linkedin.com/pulse/openings-functional-programmers-swedish-star…> Not to in any way diminish the contributions of Bjarne Stroustrup we include this image courtesy of Google Books, click to read the book about why C++ is not up to the tasks that Functor Scalor™ and Functor Prevent™ are. C++ has had great impact on the software community and is still heavily used. That said, John Mitchell lists numerous shortcomings in the book, but we honour Stroustrup in this manner: <https://books.google.se/books?id=7Uh8XGfJbEIC&pg=PA100&lpg=PA100&dq=mitchel…> John Mitchell writes (Concepts of Programming Languages, Cambridge University Press, 2002): "C++ is an object-oriented extension of the C language. It was originally called C with classes , with the name C++ originating around 1984. A Bell Laboratories researcher interested in simulation, Bjarne Stroustrup began the C++ project in the early 1980s. His goal was to add objects and classes to C, using his experience with Simula as the basis for the design. The design and implementation of C++ was originally a one-person effort, with no apparent intent to produce a commercial product. However, as interest in objects and program structure grew over the course of the 1980s, C++ became popular and widely used. In the 1990s, C++ became the most widely used object-oriented language, with good compilers and development environments available for the Macintosh, PC, and Unix-based workstations." We are not using C++ in any of our products, but honour the historical importance of Stroustrup. You’ll find us easily on Twitter, @functors, @functorgroup, @functortech, etc! PS. Servers are again considerably boosted / upgraded this very night (CET), but subscribe to newsletter.functorgroup.com <http://newsletter.functorgroup.com/> and you’ll receive a message when the server work is completed, and for rare but then important news from us in the future. Our real, non-backup site deserves a careful read through before you apply, we strongly recommend this as you would have to share our vision and believe in it too. Some links in this email may not work until tomorrow as we host everything on our own secure very powerful HP servers, hosting very sensitive customer code from companies you are familiar to should we disclose their name, and therefore have invested in our servers again. Be sure to check back on the links such as domain-specific.org <http://domain-specific.org/> and so on and indeed www.functorgroup.com <http://www.functorgroup.com/> tomorrow CET when we open the firewall again and liberate our work horses, then even stronger. Compile time with Haskell is not as blazingly fast as running Functor Prevent™, for all the good reasons, and therefore you will benefit from 48 processors and more when working on our servers. Yours Sincerely, Johan Glimming — Dr Johan Glimming Chief Executive Officer at Functor AB, Chairman at Functor Group AB LinkedIn: se.linkedin.com/in/glimming <http://se.linkedin.com/in/glimming> Functor AB, Box 7070, 164 07 Kista, SWEDEN <x-apple-data-detectors://3/1>, tel. +46-8-55005500 <tel:+46-8-55005500> Web: www.functorgroup.com <http://www.functorgroup.com/> Twitter: @functors <https://www.twitter.com/functors/> UK tel: +44-1223-911400 <tel:+44-1223-911400> US tel: +1-(415)-513-0090 <skype:+1-(415)-513-0090>

1 0

Packages in haskell and licensing
by Arian van Putten 16 Aug '15

16 Aug '15

Hey there, Is there currently any way to look up what licenses all your packages that you pull in have? For example, if I have a GPLv3 package, I want to make sure to not pull in any MIT dependencies. Is something like that currently possible or on the roadmap? -- Groetjes, Arian

3 2

Cross-compiling fails for package 'directory'
by Arie Peterson 16 Aug '15

16 Aug '15

Following <https://github.com/ku-fpg/raspberry-pi/wiki/GHC-Cross-Compiler-for-Raspberr…>, I have built a cross-compiling ghc for creating programs that run on the raspberry pi. This ghc has built a "hello world" program that runs on the rpi: OK so far. Unfortunately, building the package 'directory-1.2.3.0' with this cross- compiler fails with the following error message: "System/Directory/Internal.hsc:31 directive const_str cannot be handled in cross-compilation mode" The offending function from System.Directory is this one: > -- | Filename extension for executable files (including the dot if any) > -- (usually @\"\"@ on POSIX systems and @\".exe\"@ on Windows or OS\/2). > exeExtension :: String > exeExtension = (#const_str EXE_EXTENSION) Although one can imagine that the meaning of this function is tricky when cross-compiling, I don't think that has actually anything to do with the error. The problem is that hsc2hs cannot handle this 'const_str' directive; see <https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/hsc2hs.html…>. Now my question: how can this be fixed? Is the failure of hsc2hs to support this directive just a matter of "not implemented right now", maybe by lack of importance? Or is there a fundamental problem? If fixing hsc2hs is hard, could the 'directory' package perhaps choose another way to implement this function?

2 2

Redundant entries in .cabal file?
by David Banas 15 Aug '15

15 Aug '15

Hi all, Does anyone know why I’m getting redundant entries in my ‘cabal init’ generated .cabal file: library exposed-modules: Language.Broker, Language.Broker ? Is it because I’m using a *.hsc file, as my source, and cabal is finding both files: Broker.hsc, and Broker.hs in the Language directory? Thanks, -db

2 1

Unregisterised builds
by Jon Schneider 15 Aug '15

15 Aug '15

Good day all, I am still having issues with (the output from) the cross compiler I have built for PowerPC (e500 family). It seems the runtime is vaguely sane in that it's purposefully whirring round schedule() but for some reason for a "Hello World" allocates stack then heap (after ^C) then runs out then locks up but does not exit. I don't (yet) understand the runtime enough to find the boundary between behaving and not. /tmp # ./helloworld +RTS -Ds created capset 0 of type 2 created capset 1 of type 3 cap 0: initialised assigned cap 0 to capset 0 assigned cap 0 to capset 1 new task (taskCount: 1) cap 0: created thread 1 new bound thread (1) cap 0: schedule() cap 0: running thread 1 (ThreadRunGHC) cap 0: thread 1 stopped (yielding) cap 0: running thread 1 (ThreadRunGHC) cap 0: thread 1 stopped (yielding) cap 0: running thread 1 (ThreadRunGHC) cap 0: thread 1 stopped (yielding) cap 0: running thread 1 (ThreadRunGHC) cap 0: thread 1 stopped (stack overflow) cap 0: allocating new stack chunk of size 32768 bytes cap 0: running thread 1 (ThreadRunGHC) cap 0: thread 1 stopped (stack overflow) cap 0: allocating new stack chunk of size 32768 bytes ... I have gone through the various +RTS flags but feel I'm going to have to use gdb some more. When using unregisterised to what extent does the compiler need to know about the target platform ? If I said ./configure --target none-of-your-business --with-gcc=my-whizzy-gcc --with-other-tools=... --enable-unregisterised would I be right in saying it this could not be done because it still needs to know things like the word size, endianness and so on or couldn't it get this information just from header files ? What I'm trying to get at is if I did not think there was anything wrong with my cross-gcc, partially because I have experimented with different versions and platforms, what other PowerPC-sepcific knowledge is employed by the unregisterised ghc ? Jon

2 1

Re: [Haskell-cafe] How to model outer space for a MUD
by Doug McIlroy 15 Aug '15

15 Aug '15

> I would not model space -- there's too much of it This lesson has hit home over and over again when people come to the realization that the "inner loop" of their program is unrelated to what the program is nominally doing, Most of the running time is initialization! doug

1 0

"Could not list sources" warning in sandboxed project with add-source deps
by Eric 15 Aug '15

15 Aug '15

I'm getting a warning > Warning: Could not list sources of the add-source dependency 'xyz'.> Skipping the timestamp check. when building a sandboxed project with add-source dependencies. I tried increasing the verbosity of cabal, but it still won't tell me what's going wrong so I can fix it. Any suggestions on how to debug or fix this? thanks,--Eric

2 4

Library for overloaded indexing (a la (!))
by William Yager 14 Aug '15

14 Aug '15

Hello all, I put together a small library for the purpose of creating overloaded indexing operators. The library is available at https://hackage.haskell.org/package/keyed . I would like to solicit some advice on the design of this library. Q1: The library uses TypeFamilies to determine which types to use for the index type (which is used to look up a value) and the value type (which is returned from a lookup). I originally did this using MultiParamTypeClasses and FunctionalDependencies, but thought this was cleaner; are there any good reasons to go back to using FunDeps? Q2: Data.Keyed provides pure indexing, while Data.MKeyed provides monadic indexing (e.g. for mutable vectors or concurrent STM-based maps). I'm having some trouble with the fact that mutable vectors are keyed on the PrimState of their corresponding PrimMonad. Right now, there is a type in the MKeyed class definition called MContainer. This is the type of the Monad that the lookup operation returns. I.e. (!) :: MKeyed d => d -> MKey d -> MContainer d (MValue d) ~ (!) :: IOVector a -> Int -> IO a or (!) :: STVector s a -> Int -> ST s a Unfortunately, this causes an overlap (because both IOVector and STVector are aliased to MVector). I tried making an instance for MVector, but the problem is that it's difficult to actually go from `IOVector a = MVector RealWorld a` to `IO` or `STVector s a = MVector s a` to `ST`, because neither `IO` nor `ST` appears in the type of the vector. I can't do instance (PrimMonad m, s ~ PrimState m) => MKeyed (MVector s a) where ... type MContainer (MVector (PrimState m) a) = m because you can't have type synonyms on the LHS of the type. I tried bringing `m` into scope using RankNTypes, but that didn't work. Is there some syntax I can use to bring `m` into scope here? Or should I be doing this part entirely differently? Q3: Is there any way to automatically derive all instances of Keyed for all types of Data.Vector (using Data.Vector.Generic)? Using `instance Vector v a => Keyed (v a) where ...` doesn't work, as it overlaps with everything of the form `(d :: * -> *) (a :: *) :: *`, like `[a]`. Thanks, Will

5 9

Folding part of a graph, and FGL's gfold function.
by Jeffrey Brown 14 Aug '15

14 Aug '15

Given a node N and an edge label L, I want to do things like "find N, and all of N's L-children, and all of their L-children ... and add up their values". Ideally the fold would not traverse the whole graph. (Note that in general, the subgraph induced by N and L-succession is not a tree.) Writing the fold myself, I can only imagine a very inefficient solution -- I would find each of N's L-children first, collect them, then find each of theirs, etc. In Data.Graph.Inductive.Basic, FGL provides a function called "gfold". This is its type signature: -- | Directed graph fold. gfold :: (Graph gr) => (Context a b -> [Node]) -- ^ direction of fold -> (Context a b -> c -> d) -- ^ depth aggregation -> (Maybe d -> c -> c, c) -- ^ breadth\/level aggregation -> [Node] -> gr a b -> c Is it what I'm looking for? If so, how does it work?

2 1

FGL: The cost and propoer way of changing the label at a node.
by Jeffrey Brown 13 Aug '15

13 Aug '15

Is changing the label at a node O(N)? The only way I can think of to do it is with a map, like the following -- which works, but seems like its speed must be linear in the number of nodes of the graph: > :m Data.Graph.Inductive.Example Data.Graph.Inductive.Graph > let f c@(adjIn, node, lab, adjOut) = case node of {1 -> (adjIn, node, 'b', adjOut); _ -> c} > loop mkGraph [(1,'a')] [(1,1,())] > gmap f loop mkGraph [(1,'b')] [(1,1,())] > Is that in fact the right way? Am I somehow missing the point of FGL if I have to do a lot of that?

2 4

Internship Opportunity at Galois: Winter/Spring 2016
by Ryan Wright 13 Aug '15

13 Aug '15

Galois has some exciting opportunities for interns in software research and engineering for the Winter/Spring of 2016. Most of our projects use Haskell to some extent, so this is a great chance to get experience applying functional programming to important real-world problems. Please pass along this posting to anyone you think might be interested--even if they don't yet know Haskell! Thank you, Ryan Wright # Galois Software Engineering/Research Intern # Galois is currently seeking software engineering and research interns for Winter/Spring 2016 at all educational levels. We are committed to matching interns with exciting and engaging engineering work that fits their particular interests, creating lasting value for interns, Galois, and our community. A Galois internship is a chance to tackle cutting-edge, meaningful problems in a uniquely collaborative environment with world-leading researchers. Roles may include technology research and development, requirements gathering, implementation, testing, formal verification, and infrastructure development. Past interns have integrated formal methods tools into larger projects, built comprehensive validation suites, synthesized high-performance cryptographic algorithms, written autopilots for quad-copters, designed the syntax and semantics of scripting languages, and researched type system extensions for academic publication. We deeply believe in providing comprehensive support and mentorship to all of our employees, particularly interns. We provide our employees with a steward who regularly checks in to ensure that they feel welcome and safe in the Galois community while gaining real value from their experiences. ## Important Dates ## Applications due: October 1st, 2015 Internship period (flexible): January through April, 2016 ## About Galois ## Our mission is to create trustworthiness in critical systems. We’re in the business of taking blue-sky ideas and turning them into real-world technology solutions. We’ve been developing real-world systems for over ten years using functional programming, language design, and formal methods. Galois values diversity. We believe that differing viewpoints and experiences are essential to the process of innovation. We look broadly, including outside of established communities, to deliver innovation. ## How to Prepare ## An internship is an opportunity for learning and growth as an engineer. To make the most of the opportunity, we ask that candidates have experience reading, writing, and maintaining code in a realistic project. Many university courses involve multi-week collaborative projects that provide this type of experience. Most of our projects use the Haskell programming language and the git version control system. These tools aren’t often taught in computer science classes, but there are many free resources available that we recommend for learning: - [Learn You a Haskell] for Great Good! [1] by Miran Lipovača - [Real World Haskell] [2] by Bryan O’Sullivan, Don Stewart, and John Goerzen - [tryGit] [3] by Code School - [Pro Git] [4] by Scott Chacon [1]: http://learnyouahaskell.com/ [2]: http://book.realworldhaskell.org/ [3]: http://try.github.io [4]: http://git-scm.com/book ## Qualifications ## The ability to be geographically located in Portland during the internship Experience reading, writing, and maintaining code in a project as described above Proficiency in software development practices such as design, documentation, testing, and the use of version control Well-developed verbal and written communication skills; comfort in a collaborative team environment The following skills are not required, but may be relevant to a particular project. - Proficiency in Haskell or other programming languages with rich type systems (eg., OCaml, Standard ML, Scala) - Experience using C and assembly languages for low-level systems programming - Development experience in high assurance systems or security software - Specific experience in an area of Galois’ expertise, such as: - Assured information sharing - Software modeling and formal verification - Cyber-physical systems and control systems - Operating systems, virtualization and secure platforms - Networking and mobile technology - Cyber defense systems - Scientific computing - Program analysis and software evaluation - Web security ## Logistics ## The length and start date of the internship are negotiable: starting any time from the new year through next spring is acceptable, but an intern must be at Galois for at least three continuous months. The internship is paid competitively, and interns are responsible for living arrangements (although we can certainly help you find arrangements). Galois is located in the heart of downtown Portland with multiple public transportation options available and world-class bicycle infrastructure. ## Application Details ## We’re looking for people who can invent, learn, think, and inspire. We reward creativity and thrive on collaboration. If you are interested, please send your cover letter and resume to us via http://galois-inc.hiringthing.com.

1 0

Standards-conform CSS tokenizer
by Tomas Carnecky 13 Aug '15

13 Aug '15

Recently I wrote a CSS tokenizer based on the css-syntax spec (the same standard that Blink now uses to parse CSS). The detailed description of my motivation is in the readme, but if I had to describe it in a sentence: The existing Haskell parsers were too high-level for me needs, they provided too much abstraction. The package does not implement the full parser, at least one token type is not implemented. But it should be able to tokenize most CSS files. I copied the tests from the Blink source. All but one pass (and of course the tests for the token types that are not implemented) While the spec describes the algorithm in a way that pretty much prescribes the implementation, I chose to use attoparsec instead. Not sure about the speed implications, but speed is not that important for me. The spec module also describes a parser. I did not have time to implement it, and am currently not planning to. But it would be nice if that was part of the package as well. I had hoped to be able to write a minimizer as well, but I'm not sure if it's possible to write a minimizer just on the token stream, maybe the full parser is needed for that. However, consecutive whitespace is collapsed so tokenizing and then serializing the file will in most cases lead to a smaller file. Hackage: http://hackage.haskell.org/package/css-syntax GitHub repo: https://github.com/wereHamster/haskell-css-syntax Spec: https://drafts.csswg.org/css-syntax

1 0

[ANN] base91
by Alvaro J. Genial 13 Aug '15

13 Aug '15

Howdy, I'd like to announce a first version of base91 <http://hackage.haskell.org/package/base91>, a Haskell package to enable the encoding and decoding of data in Base91 format, as documented in its specification <http://base91.sourceforge.net>. The main benefits of said scheme are a good reduction in overhead (from 31% up to 58%) when compared to Base64 due to the clever use of two printable ASCII characters (consuming 16 bits) to encode 13 arbitrary bits, as well as neither need for nor ambiguity over padding or alphabets. It includes support for... - Plain Strings (module Codec.Binary.Base91.String) - Data.ByteString (module Codec.Binary.Base91.ByteString) - Data.Text (module Codec.Binary.Base91.Text) - The latter two combined (module Codec.Binary.Base91.Efficient) - Data.ByteString.Lazy (module Codec.Binary.Base91.ByteString.Lazy) - Data.Text.Lazy (module Codec.Binary.Base91.Text.Lazy) - The latter two combined (module Codec.Binary.Base91.Efficient.Lazy) ...which are all just concretely typed versions of the generic implementation in Codec.Binary.Base91. I had fun exploring some of the latest GHC extensions, as evidenced by Codec.Binary.Base91.Control, which relies on a certain amount of type trickery to reconcile the incongruence between monomorphic containers and the standard type classes. Anyway, suggestions are very welcome. In particular, I'm interested in: 1. Whether the generic decode and encode signatures can be simplified or improved elsehow. 2. Whether there already exist classes similar in purpose to Applicative' and Foldable'. 3. Whether it makes sense to offer decode and encode variants that use lazy (left) folds--currently folding is always strict, even with lazy types. (Testing comes nearly free courtesy of QuickCheck and the identity property of decode . encode, plus a couple of concrete examples. Please open an issue or otherwise let me know if you find a bug.) Thank you, Alvaro <http://alva.ro>

4 5

HAL-10
by Pascal Wittmann 13 Aug '15

13 Aug '15

Hi there, I just wanted to ask whether I just missed this years HAL (Haskell in Halle/Leipzig) or if it was canceled this year. Cheers Pascal

2 1

Unique Ordered Types
by Silvio Frischknecht 13 Aug '15

13 Aug '15

Hi I'm experimenting with a unit system in haskell where users can add "base units". I want to reduce units after multiplication and bring it into a canonical form. The problem is what kind of types can the units have. 1) data UnitA data UnitB Problem: They can't be ordered so UnitA * UnitB can be compared to UnitB * UnitA, but I can't make a canonical form, which would make type inference a lot better. 2) type UnitA = Zero type UnitB = Suc Zero Problem: Now they can be ordered. But users can create conflicting "basic units" Silvio

4 6

Location Of Prelude.hs
by debdutk＠gnulinuxed.tk 12 Aug '15

12 Aug '15

Hi, I was reading the book "The Haskell Road to Logic, Math and Programming" and it refers to /usr/lib/hugs/libraries/Hugs/ as the probable location for Prelude.hs. I am currently using Elementary OS Luna (based of Ubuntu 12.04) and could not file the file at the specified location. Can anyone please tell me where to find it? _____________________ Yours Truly, Debdut Karmakar

4 5

ANN: stack-0.1.3.1
by Emanuel Borsboom 12 Aug '15

12 Aug '15

New release of stack, a build tool. This is a patch release to fix a bug in v0.1.3.0 <https://github.com/commercialhaskell/stack/releases/tag/v0.1.3.0>. See README <https://github.com/commercialhaskell/stack#how-to-install> for installation and upgrade instructions. Note: on Windows, this version does some trickery with code pages to work around issues with GHC’s output. If you run into any trouble, please report it (see issue #757 <https://github.com/commercialhaskell/stack/issues/757>). Bug fixes: - Ignore disabled executables #763 <https://github.com/commercialhaskell/stack/issues/763>

1 0

Combine `StateT` and `InputT` to maintain state on Ctrl-C interrupt
by haskell＠stefan-klinger.de 12 Aug '15

12 Aug '15

Hi, I'm stuck with maintaining a State in a Haskeline program that would survive an interrupt with Ctrl-C. The following is a MWE I have distilled out of a bigger project. It revolves around a simple (I guess) read-eval-print loop using Haskeline, and a stacked StateT to maintain a state. This MWE reads a line from the user, calculates its `length`, and adds the length to an Int forming the state. If the user types the special input "sleep" the program sleeps for 5 seconds, simulating a longer computation. Every time the user presses Ctrl-C * a running computation should be interrupted, or * when at the prompt, the current input should be cleared. * In any case, the state must be maintained! Unfortunately, Ctrl-C also clears the state. At first I thought I had stacked the `StateT` and `InputT` in the wrong order. But changing from `InputT (StateT Int IO) ()` to `StateT Int (InputT IO) ()` seems not to change anything (which really gives me the creeps). This message contains both versions (one commented out), they compile with $ ghc --version The Glorious Glasgow Haskell Compilation System, version 7.10.1 $ ghc --make -Wall -outputdir tmp -o mwe StateMwe.lhs Example run, comments (`<--...`) added later: $ ./mwe type> arglschluargl Adding length of "arglschluargl" 13 type> lalala Adding length of "lalala" 19 type> <--no input, state unchanged Adding length of "" 19 type> sleep Sleeping 5 seconds... ^C <--Here I have hit C-c type> <--no input, state unchanged Adding length of "" 0 <--WRONG: that should be 19 Here we go: > import Control.Monad.State.Strict > import Control.Concurrent ( threadDelay ) > import System.Console.Haskeline > {- Version one: `StateT` inside `InputT` > main :: IO () > main = evalStateT (runInputT defaultSettings $ noesc repl) 0 This catches an interrupt via Ctrl-C and restarts the passed operation. > noesc :: MonadException m => InputT m a -> InputT m a > noesc w = withInterrupt $ let loop = handle (\Interrupt -> loop) w in loop The read-eval-print loop: EOF terminates, `sleep` delays, and any other input modifies the integer state. > repl :: InputT (StateT Int IO) () > repl = do x <- getInputLine "\ntype> " > case x of > Nothing -> return () > Just "sleep" > -> do outputStrLn "Sleeping 5 seconds..." > lift . lift . threadDelay $ 5 * 10^(6::Int) > outputStrLn "...not interrupted" > repl > Just t > -> do outputStrLn $ "Adding length of " ++ show t > lift $ modify (+ length t) > v <- lift get > outputStrLn $ show v > repl > -} > {- Version two: `InputT` inside `StateT` > main :: IO () > main = runInputT defaultSettings . noesc $ evalStateT repl 0 This catches an interrupt via Ctrl-C and restarts the passed operation. I suspect that I have to rearrange this to accommodate the modified stacking, but I could not come up with anything that compiles... > noesc :: MonadException m => InputT m a -> InputT m a > noesc w = withInterrupt $ let loop = handle (\Interrupt -> loop) w in loop As above, with `lift` in different places. To get a better understanding of what's going on, I do not want to use mtl's lift-to-the-right-monad magic (yet). > repl :: StateT Int (InputT IO) () > repl = do x <- lift $ getInputLine "\ntype> " > case x of > Nothing -> return () > Just "sleep" > -> do lift $ outputStrLn "Sleeping 5 seconds..." > lift . lift . threadDelay $ 5 * 10^(6::Int) > lift $ outputStrLn "...not interrupted" > repl > Just t > -> do lift . outputStrLn $ "Adding length of " ++ show t > modify (+ length t) > v <- get > lift . outputStrLn $ show v > repl > -} Any help would be welcome... Stefan -- http://stefan-klinger.de o/X /\/ \

3 9

ANN: stack-0.1.3.0
by Emanuel Borsboom 12 Aug '15

12 Aug '15

New release of stack, a build tool. See README <https://github.com/commercialhaskell/stack#how-to-install> for installation and upgrade instructions. Note: on Windows, this version does some trickery with code pages to work around issues with GHC’s output. If you run into any trouble, please report it (see issue #757 <https://github.com/commercialhaskell/stack/issues/757>). Major changes: - Overhauled target parsing, added --test and --bench options #651 <https://github.com/commercialhaskell/stack/issues/651> - For details, see Build commands Wiki page <https://github.com/commercialhaskell/stack/wiki/Build-command> - Detect when a module is compiled but not listed in the cabal file (#32 <https://github.com/commercialhaskell/stack/issues/32>) - A warning is displayed for any modules that should be added to other-modules in the .cabal file - These modules are taken into account when determining whether a package needs to be built - Respect TemplateHaskell addDependentFile dependency changes (#105 <https://github.com/commercialhaskell/stack/issues/105>) - TH dependent files are taken into account when determining whether a package needs to be built. Other enhancements: - Set the HASKELL_DIST_DIR environment variable #524 <https://github.com/commercialhaskell/stack/pull/524> - Track build status of tests and benchmarks #525 <https://github.com/commercialhaskell/stack/issues/525> - --no-run-tests #517 <https://github.com/commercialhaskell/stack/pull/517> - Targets outside of root dir don’t build #366 <https://github.com/commercialhaskell/stack/issues/366> - Upper limit on number of flag combinations to test #543 <https://github.com/commercialhaskell/stack/issues/543> - Fuzzy matching support to give better error messages for close version numbers #504 <https://github.com/commercialhaskell/stack/issues/504> - --local-bin-path global option. Use to change where binaries get placed on a --copy-bins #342 <https://github.com/commercialhaskell/stack/issues/342> - Custom snapshots #111 <https://github.com/commercialhaskell/stack/issues/111> - —force-dirty flag: Force treating all local packages as having dirty files (useful for cases where stack can’t detect a file change) - GHC error messages: display file paths as absolute instead of relative for better editor integration - Add the --copy-bins option #569 <https://github.com/commercialhaskell/stack/issues/569> - Give warnings on unexpected config keys #48 <https://github.com/commercialhaskell/stack/issues/48> - Remove Docker pass-host option - Don’t require cabal-install to upload #313 <https://github.com/commercialhaskell/stack/issues/313> - Generate indexes for all deps and all installed snapshot packages #143 <https://github.com/commercialhaskell/stack/issues/143> - Provide --resolver global option #645 <https://github.com/commercialhaskell/stack/issues/645> - Also supports --resolver nightly, --resolver lts, and --resolver lts-X - Make stack build --flag error when flag or package is unknown #617 <https://github.com/commercialhaskell/stack/issues/617> - Preserve file permissions when unpacking sources #666 <https://github.com/commercialhaskell/stack/pull/666> - stack build etc work outside of a project - list-dependencies command #638 <https://github.com/commercialhaskell/stack/issues/638> - --upgrade-cabal option to stack setup #174 <https://github.com/commercialhaskell/stack/issues/174> - --exec option #651 <https://github.com/commercialhaskell/stack/issues/651> - --only-dependencies implemented correctly #387 <https://github.com/commercialhaskell/stack/issues/387> Bug fixes: - Extensions from the other-extensions field no longer enabled by default #449 <https://github.com/commercialhaskell/stack/issues/449> - Fix: haddock forces rebuild of empty packages #452 <https://github.com/commercialhaskell/stack/issues/452> - Don’t copy over executables excluded by component selection #605 <https://github.com/commercialhaskell/stack/issues/605> - Fix: stack fails on Windows with git package in stack.yaml and no git binary on path #712 <https://github.com/commercialhaskell/stack/issues/712> - Fixed GHCi issue: Specifying explicit package versions (#678) - Fixed GHCi issue: Specifying -odir and -hidir as .stack-work/odir (#529) - Fixed GHCi issue: Specifying A instead of A.ext for modules (#498)

1 0

Final call for papers for IFL 2015
by Jurriaan Hage 11 Aug '15

11 Aug '15

Hello, Please, find below the final call for papers for IFL 2015. Note that the draft submission date has been extended until August 15. Please forward these to anyone you think may be interested. Apologies for any duplicates you may receive. best regards, Jurriaan Hage Publicity Chair of IFL —— IFL 2015 - Call for papers 27th SYMPOSIUM ON IMPLEMENTATION AND APPLICATION OF FUNCTIONAL LANGUAGES - IFL 2015 University of Koblenz-Landau, Koblenz, Germany In cooperation with ACM SIGPLAN September 14-16, 2015 http://ifl2015.wikidot.com/ Scope The goal of the IFL symposia is to bring together researchers actively engaged in the implementation and application of functional and function-based programming languages. IFL 2015 will be a venue for researchers to present and discuss new ideas and concepts, work in progress, and publication-ripe results related to the implementation and application of functional languages and function-based programming. Peer-review Following the IFL tradition, IFL 2015 will use a post-symposium review process to produce the formal proceedings. All participants of IFL2015 are invited to submit either a draft paper or an extended abstract describing work to be presented at the symposium. At no time may work submitted to IFL be simultaneously submitted to other venues; submissions must adhere to ACM SIGPLAN's republication policy: http://www.sigplan.org/Resources/Policies/Republication The submissions will be screened by the program committee chair to make sure they are within the scope of IFL, and will appear in the draft proceedings distributed at the symposium. Submissions appearing in the draft proceedings are not peer-reviewed publications. Hence, publications that appear only in the draft proceedings do not count as publication for the ACM SIGPLAN republication policy. After the symposium, authors will be given the opportunity to incorporate the feedback from discussions at the symposium and will be invited to submit a revised full article for the formal review process. From the revised submissions, the program committee will select papers for the formal proceedings considering their correctness, novelty, originality, relevance, significance, and clarity. Important dates August 15: Submission deadline draft papers August 17: Notification of acceptance for presentation August 19: Early registration deadline August 26: Late registration deadline September 7: Submission deadline for pre-symposium proceedings September 14-16: IFL Symposium December 1: Submission deadline for post-symposium proceedings January 15, 2016: Notification of acceptance for post-symposium proceedings March 1, 2016: Camera-ready version for post-symposium proceedings Submission details Prospective authors are encouraged to submit papers or extended abstracts to be published in the draft proceedings and to present them at the symposium. All contributions must be written in English. Papers must adhere to the standard ACM two columns conference format. For the pre-symposium proceedings we adopt a 'weak' page limit of 12 pages. For the post-symposium proceedings the page limit of 12 pages is firm. A suitable document template for LaTeX can be found at: http://www.acm.org/sigs/sigplan/authorInformation.htm Authors submit through EasyChair: https://easychair.org/conferences/?conf=ifl2015 Topics IFL welcomes submissions describing practical and theoretical work as well as submissions describing applications and tools in the context of functional programming. If you are not sure whether your work is appropriate for IFL 2015, please contact the PC chair at rlaemmel(a)acm.org. Topics of interest include, but are not limited to: - language concepts - type systems, type checking, type inferencing - compilation techniques - staged compilation - run-time function specialization - run-time code generation - partial evaluation - (abstract) interpretation - metaprogramming - generic programming - automatic program generation - array processing - concurrent/parallel programming - concurrent/parallel program execution - embedded systems - web applications - (embedded) domain specific languages - security - novel memory management techniques - run-time profiling performance measurements - debugging and tracing - virtual/abstract machine architectures - validation, verification of functional programs - tools and programming techniques - (industrial) applications Peter Landin Prize The Peter Landin Prize is awarded to the best paper presented at the symposium every year. The honored article is selected by the program committee based on the submissions received for the formal review process. The prize carries a cash award equivalent to 150 Euros. Programme committee Chair: Ralf Lämmel, University of Koblenz-Landau, Germany - Malgorzata Biernacka, University of Wroclaw, Poland - Laura M. Castro, University of A Coruña, Spain - Martin Erwig, Oregon State University, USA - Dan Ghica, University of Birmingham, UK - Andrew Gill, University of Kansas, USA - Stephan Herhut, Google, USA - Zhenjiang Hu, National Institute of Informatics (NII), Japan - Mauro Jaskelioff, CIFASIS/Universidad Nacional de Rosario, Argentina - Frédéric Jouault, ESEO, France - Oleg Kiselyov, Tohoku University, Japan - Lindsey Kuper, Indiana University, USA - Rita Loogen, Philipps-Universität Marburg, Germany - Akimasa Morihata, University of Tokyo, Japan - Atsushi Ohori, Tohoku University, Japan - Bruno C. D. S. Oliveira, The University of Hong Kong, Hong Kong - Frank Piessens, Katholieke Universiteit Leuven, Belgium - Norman Ramsey, Tufts University, USA - Matthew Roberts, Macquarie University, Australia - Manfred Schmidt-Schauss, Goethe-University Frankfurt, Germany - Simon Thompson, University of Kent, UK - Stephanie Weirich, University of Pennsylvania, USA - Steve Zdancewic, University of Pennsylvania , USA Venue The 27th IFL will be held in association with the Faculty of Computer Science, University of Koblenz-Landau, Campus Koblenz. Koblenz is well connected by train to several international airports. For instance, Koblenz can be reached from Frankfurt by high-speed train ICE within an hour. The modern Koblenz campus is close to the city center and can be reached by foot, bus, or cab. See the website for more information on the venue. Social events The conference attendees are welcome at „Kaffeewirtschaft“ in the historical center of Koblenz on the evening of arrival (Sunday, 13 September). A special reception takes places on Monday in the form of a wine tasting and guided tour at „Weingut Lunnebach“. The conference banquet on Tuesday is held at the historical site „Festung Ehrenbreitstein“ at Restaurant Casino with a wonderful view over the city and the two rivers Rhine and Moselle. - http://www.kaffeewirtschaft.de/ - http://www.weingut-lunnebach.de/ - https://www.cafehahn.de/impressionen_189.html

1 0

Constraints on <$> vs <$!>
by Alexey Egorov 11 Aug '15

11 Aug '15

Hello haskellers, I wonder why <$> and <$!> have different typeclass constraints? (<$>) :: Functor f => (a -> b) -> f a -> f b (<$!>) :: Monad m => (a -> b) -> m a -> m b

6 5

Re: [Haskell-cafe] an idea for modifiyng data/newtype syntax: use `::=` instead of `=`
by Alexey Muranov 11 Aug '15

11 Aug '15

On 9 août 2015, at 15:00, haskell-cafe-request(a)haskell.org wrote: > From: Will Yager <will.yager(a)gmail.com> > Subject: Re: [Haskell-cafe] an idea for modifiyng data/newtype syntax: use `::=` instead of `=` > Date: 9 août 2015 02:30:50 UTC+3 > To: Hilco Wijbenga <hilco.wijbenga(a)gmail.com> > Cc: Haskell Cafe <haskell-cafe(a)haskell.org>, MigMit <miguelimo38(a)yandex.ru> > It is worth asking, then, if we should record these small aesthetic suggestions somewhere for consideration while designing the next major compatibility-breaking release of the Haskell specification (Haskell 2020 or what have you). +1 Alexey.

5 8

Pattern guards in comprehensions
by M Farkas-Dyck 11 Aug '15

11 Aug '15

I propose we add pattern guards in comprehensions, but I'm not sure what syntax would work. Consider this function: allMinus :: [Natural] -> [Natural] allMinus m = mapMaybe (-? m) where n -? m | m > n = Nothing | True = Just (n-m) One may wish to write such as a list comprehension, but it is cumbersome: allMinus m ns = [n' | n@((-? m) -> Just n') <- ns] This would be clearer with pattern guards, fictitious syntax here: allMinus m ns = [n' | n <- ns, Just n' <- n -? m] Alas, this conflicts with the other part of list comprehension syntax. Try we this, actual syntax now: allMinus m ns = [n' | n <- ns, let Just n' = n -? m] Nope, that's an error if (any (< m) ns). I recognize in this case the one in terms of mapMaybe is quite clear, but in the case of some other code I'm writing it's much more complicated. Ideas: 1. Modify semantics of let in comprehension to skip that element on pattern mismatch 2. Use another keyword, e.g. [n' | n <- ns where Just n' <- n -? m] Thoughts?

4 7

New Functional Programming Job Opportunities
by Functional Jobs 10 Aug '15

10 Aug '15

Here are some functional programming job opportunities that were posted recently: Software Engineer / Researcher at Galois Inc. http://functionaljobs.com/jobs/8856-software-engineer-researcher-at-galois-… Cheers, Sean Murphy FunctionalJobs.com

1 0

Appropriate location for list of language suggestions
by Will Yager 10 Aug '15

10 Aug '15

This email is in response to the (ongoing) Haskell-cafe discussion about type declaration syntax. There are a number of hypothetical changes to Haskell that could be aesthetically pleasing or convenient if implemented, but not to such a degree that the added convenience outweighs the added complexity of a pragma-gated feature or the cost of breaking existing code. (Case in point: renaming type/newtype/data to be less confusing to first-time users) However, there may be better opportunities to implement such changes in the future, and it would be a shame if every good (but perhaps somewhat trivial) idea was lost to the annals of the mailing list. Therefore, I proposed that we might maintain a list of nitpicks, which could be used to inform future decisions about breaking changes to the Haskell specification. I'm not sure what the most appropriate forum is for such a list. The mailing list is sub-optimal, because we might end up with a huge email chain littered with bikeshedding reply-alls. I would be willing to host and maintain such a list on Github, but that seems somewhat antithetical to the Haskell community's generally more distributed style of discussion. The wiki might be appropriate, but I don't know if it's conducive to proper moderation; we may have to filter out suggestions like "add for loops". --Will

3 2

monads, memoization etc
by Ilya Razenshteyn 10 Aug '15

10 Aug '15

Hi everyone, I'm new to Haskell and decided to learn a bit about monads and their utility. Actually, what worked nicely for me was: to read first several pages from "Computational lambda-calculus and monads", then do exercises from https://tonymorris.github.io/blog/posts/20-intermediate-haskell-exercises/, and then map these exercises to actual functions in the standard library. Then, I decided to implement memoization to practice a bit with ST, HashTable's and such. Here is what I managed to get: http://pastebin.com/79pwjLPL . This code computes Fibonacci numbers while caching the intermediate values in a hash table. I tried to make the code as fast as possible (it runs in under 15 seconds, when computing 1M'th Fibonacci number modulo 999983). It uses the package hashtables. I have several question about all this. First, is there a cheap way to speed this code up? Note that I'm interested in a universal memoization strategy, that is I don't want to use arrays instead of hash tables etc. Second, is this code the right way of doing what it does (assuming that I really care about the performance)? Third question. Currently, the code passes "cache" everywhere. It would be natural to combine ST with something like ReaderT to store it there. What is a way to do it? I tried something like "ReaderT (HashTable s) (ST s) Int", but I have not managed to get it work.

3 5

Re: [Haskell-cafe] Serialize to Haskell
by Corentin Dupont 08 Aug '15

08 Aug '15

Hi Matthew, yes that's exactly that. I want to do exactly what you would do with a JSON file (read, write), but with a data format that would be valid Haskell (instead of valid javascript). On Fri, Aug 7, 2015 at 8:06 PM, Matthew Pickering < matthewtpickering(a)gmail.com> wrote: > Hi Corentin, > > I don't quite understand your question please can you explain a bit > more. Do you want to read a valid haskell source file, perform some > changes to the file and then print out a valid source file? > > I am a bit confused about the bit about turing-completeness. > > Matt > > On Fri, Aug 7, 2015 at 7:55 PM, Corentin Dupont > <corentin.dupont(a)gmail.com> wrote: > > Hello! > > I'm wondering if it's possible to serialize some data to a format that is > > valid Haskell. > > In practice I would read a file like this: > > > > module Foo where > > > > myData :: MyData > > myData = MyData {name = "foo", > > descr = "test" > > ... > > } > > > > Reading this into a program is easily feasible with Hint, for example. > Then > > the program would modify some data and serialize it back to: > > > > module Foo where > > > > myData :: MyData > > myData = MyData {name = "bar", > > descr = "test2" > > ... > > } > > > > In practice I think that the format should be a subset of Haskell that is > > not Turing-complete. > > A bit like JSON, which is a subset of Javascript but not Turing complete. > > Is it possible? > > > > Thanks, > > Corentin > > > > _______________________________________________ > > Haskell-Cafe mailing list > > Haskell-Cafe(a)haskell.org > > http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe > > >

4 5

Waiting for async exception (and nothing else)
by David Turner 08 Aug '15

08 Aug '15

Hi, Is there an elegant way to have a thread wait for an async exception but nothing else? I tend to do something like forever $ threadDelay 1000000000 but this seems like a bit of a hack. Waiting on an otherwise-unused MVar or doing 'atomically retry' don't work because GHC kills them off straight away. The context is when using an API that only has a 'withMyThingy' wrapper and no explicit openMyThingy and closeMyThingy alternatives. Perhaps that's an API problem and the only way to work around this is with something a bit hacky? Cheers,

3 4

More concise code using phantom types
by Nikita Kartashov 08 Aug '15

08 Aug '15

Hello! Consider the following code: module Units where data Units a = U Double deriving Eq units :: Double -> a -> Units a units value _ = U value data Meters data Yards meters = undefined :: Meters yards = undefined :: Yards instance Show Meters where show _ = "meters" instance Show Yards where show _ = "yards" extractA :: Units a -> a extractA = undefined instance Show a => Show (Units a) where show u@(U value) = show value ++ " " ++ show $ extractA u main = (print $ units 5 yards) >> (print $ units 5 meters) Is it possible to use something instead extractA function here? For example, substitute "extractA u” with “undefined :: a”? GHC disallows it, so is there a way to explain that I only need a token with type a? Also, with highlighting on lpaste: http://lpaste.net/138219. With regards, Nikita Kartashov

2 1

ANN: happstack-server-tls-cryptonite
by Andrey Sverdlichenko 07 Aug '15

07 Aug '15

Hi, I'd like to announce happstack-server-tls-cryptonite, package adding native TLS support to happstack, utilizing hs-tls and cryptonite packages by Vincent Hanquez. You can now run secure web server without using OpenSSL or other foreign libraries. This package is almost drop-in replacement for happstack-server-tls, just change Happstack.Server.SimpleHTTPS to Happstack.Server.SimpleTLS in imports. Regards, Andrey

1 0

Fwd: Haskell Weekly News
by Kim-Ee Yeoh 07 Aug '15

07 Aug '15

*Editorial:*Over a month has elapsed since the last issue. Is the Weekly News turning into the Monthly News? No. I've been working on getting full-length articles into the News. Imagine articles that investigate, analyze, and give the low-down on hoary issues like cabal hell that cannot be telegrammed in a two-sentence paragraph. But my time isn't quantum mechanical. When I do A, I can't at the same time do B. I know that there are fine haskellers who'd gladly write for pay. However, HWN has never had a foundation in place for paid articles. Building that foundation takes time. Now that much of it is in place, let me duly announce that HWN hereby solicits reviews, reports, criticism pieces, and personal essays. - Flexible word count: anywhere between 250 and 750 is fine. - Send me an outline first. - Published articles pay at 68 bitcents, under 200 euros / dollars right now. - You can count on extensive editing for the requisite polish and also to conform to 'house' style. Interested? Email me with a subject line that starts with "[HWN pitch]" followed by the title of your piece. In the body, outline the main points you'll hit and explain how they engage the HWN readership. So on with the News : *Top picks:* - Galois organizes this year's ICFP contest. The 72-hour countdown has just started! After tantalizing us with whisperings of more computational archaelogy (see 2006 ICFP contest <http://www.boundvariable.org/>) centering on honey bees, national food security, and the Hebrew alphabet; Portland, Oregon reveals a classic offline AI game programming challenge <http://icfpcontest.org/spec.html>. According to redditor skatenerd <https://www.reddit.com/r/haskell/comments/3g1n8f/this_years_icfp_contest_st…>, "it's a lot like Tetris, except you know what pieces are coming." - Rick Dzekman <http://rickdzekman.com/thoughts/the-haskell-user-experience/> offers constructive criticism based on his "poor UX (User Experience) of a great language (Haskell)". Among the low-lying fruit he identifies: a web search doesn't always link to the latest version on the Hackage website, something easily fixed. Not so low-lying are Cabal, a modern IDE, and Haskell wiki documentation. In sympathy with the sentiments are HN readers <https://news.ycombinator.com/item?id=10008169> and /r/haskell <https://www.reddit.com/r/haskell/comments/3ftsh0/the_haskell_user_experienc…> . - Christoffer Stjernlöf brings attention to how only in imperative land does one encounter the awfulness of the same boolean expression getting tested twice in a nested if-inside-if. He uses it to make "the case for controlled side effects", the title of his blog post. Discussions on /r/haskell <http://www.reddit.com/r/haskell/comments/3fzmt6/the_case_for_controlled_sid…> and Hacker News <https://news.ycombinator.com/item?id=10017613>. - Alexey Shmalko introduces Haskell IO as "the command pattern" <http://www.alexeyshmalko.com/2015/io-is-your-command-pattern/> to object-oriented programmers. His article resists mentioning monads or do-notation. Appreciated on /r/haskell <http://www.reddit.com/r/haskell/comments/3fzmt6/the_case_for_controlled_sid…> . - The latest issue of the Functional Works monthly newsletter <http://us10.campaign-archive2.com/?u=30f19e2c5b9f15cfb95906716&id=cee1ab0dc6> reminds us about Chakravarty and Keller's "An Introduction to Computing (with Haskell)", a textbook written from multiple years teaching first-year CS. At 150 pages, the book dodges monads -- nary a single mention -- and zooms into I/O actions. It's out-of-print but readily downloadable <https://www.cse.unsw.edu.au/~chak/papers/#sec:books>. - The program for this year's Haskell Symposium <https://www.haskell.org/haskell-symposium/2015/> is out. PC chaired by Ben Lippmeier, it's truly a smorgasbord. If you can't find a preprint, indefatigable redditors <http://www.reddit.com/r/haskell/comments/3dxxj3/haskell_symposium_2015_acce…> might just have got you covered. - Zhenjiang Hu, John Hughes, and Meng Wang publish "How Functional Programming Mattered" <http://nsr.oxfordjournals.org/content/early/2015/07/13/nsr.nwv042>, a survey of FP's impact outside its academic domain in recent years. It is written in the mold of and complements A History of Haskell: Being Lazy with Class (2007) <http://research.microsoft.com/en-us/um/people/simonpj/papers/history-of-has…>. Comprising 17.5 pages of 2-column ACM-proceedings-style 9-point text, it houses the bibliographical treasure of 122 references, itself a contribution to any debate over priority. /r/haskell <https://www.reddit.com/r/haskell/comments/3f5yew/how_functional_programming…> - Victor Maia writes a lambda calculus evaluator in javascript <https://github.com/SrVictorMaia/optlam> that computes 200^200 mod 31 without breaking a sweat. No mean feat, since all numbers are church numerals. How did he pull it off? His javascript implements a fragment of Lamping's optimal algorithm, which is based on interaction nets. (Optimality here is in the sense of Levy-optimality: keeping the number of beta reductions down to an absolute minimum. By itself, this count is generally an inaccurate measure of efficiency.) He wonders on stackoverflow <http://stackoverflow.com/questions/31707614/why-are-%CE%BB-calculus-optimal…> why optimal evaluation has such magical superpowers. The convo at /r/haskell <http://www.reddit.com/r/haskell/comments/3f21wv/why_are_%CE%BBcalculus_opti…> has yet to crack the mystery. - Philippe Desjardins Proulx <http://phdp.github.io/posts/2015-04-05-automated-reasoning.html> codes and compares a basic arithmetic expression evaluator in all 5 languages of F#, Scala, Haskell, C++, and Julia. The evaluator acts on a given tree: Philippe doesn't touch parsing. Go, Erlang, and Elixir versions are in HN comments <https://news.ycombinator.com/item?id=9995896>. - Redditor gilmi starts a discussion on /r/haskell about the various FRP systems <https://www.reddit.com/r/haskell/comments/3fr5ij/frp_systems_discussion/> out there and whether they're ready for real-world use. Ollie Charles glosses classic vs arrowized systems, Doug Beardsley at Soostone testifies that "reflex is the first thing I've used that makes building web UIs enjoyable for me, which is very exciting", and Joseph Abrahamson channels Conal Elliott in staking out the acronym to mean exclusively those systems that admit continuous time. *Quotes of the Week:* - Andrew Cowie <https://twitter.com/afcowie/status/612764291863703552>: The highlight of my day is "cd ~/src/haskell/stack ; git pull ; stack install". What goodies have they landed this time? - Cale Gibbard <http://ircbrowse.net/browse/haskell?id=20873306&timestamp=1434453345#t14344…>: I basically never turn on IncoherentInstances because it basically means "I don't want anything to work, and I'd like to be confused about why." - Redditor fegu <https://www.reddit.com/r/haskell/comments/3fqiff/dont_give_up_on_haskell/ct…>: Haskell is like a mental drug, after a few initial hits you absolutely crave it. You will forego lucrative .Net career moves just to keep it, hence your long-term career will take a hit. But the days will be brighter, more enjoyable and there is just that glimmer of hope that in the end you will be able to practice Haskell full time in a well-paid position. I wish I was joking. - On ageism in the software industry <https://news.ycombinator.com/item?id=9710936#up_9711829>: Maybe I've been lucky, but this doesn't mesh with my experience at all. The oldest guys at my company are the ones teaching the classes about Haskell or Scalaz. They're the ones trying out Elixir. They're the ones building frameworks for everyone else to build on top of. The youngest people are banging out feature #4,501 for the website. *Real World Haskell of the Week:* - Fed up with the laggy Netflix UI? Check out the snappy Haskell-powered instantwatcher.com. H/T erichmond on HN <https://news.ycombinator.com/item?id=10013434#up_10016932>. -- Kim-Ee

1 0

Serialize to Haskell
by Corentin Dupont 07 Aug '15

07 Aug '15

Hello! I'm wondering if it's possible to serialize some data to a format that is valid Haskell. In practice I would read a file like this: module Foo where myData :: MyData myData = MyData {name = "foo", descr = "test" ... } Reading this into a program is easily feasible with Hint, for example. Then the program would modify some data and serialize it back to: module Foo where myData :: MyData myData = MyData {name = "bar", descr = "test2" ... } In practice I think that the format should be a subset of Haskell that is not Turing-complete. A bit like JSON, which is a subset of Javascript but not Turing complete. Is it possible? Thanks, Corentin

1 0

"cabal sdist" oddity
by Sven Panne 07 Aug '15

07 Aug '15

Cabal from HEAD started to issue the warning "Warning: Cannot run preprocessors. Run 'configure' command first." when running "cabal sdist" after a "cabal install", see e.g. https://travis-ci.org/haskell-opengl/OpenGL/jobs/74581138#L264. Previous versions didn't do this, see e.g. https://travis-ci.org/haskell-opengl/OpenGL/jobs/74581137#L264. Somehow the warning doesn't make sense, because the package has obviously been built before, so configuration must have happened, too. Is this a new bug in Cabal? Cheers, S.

2 2

Syntax extension - adding import support to let/where bindings
by Oliver Charles 07 Aug '15

07 Aug '15

Hi all, I'm sure this has come up before, but a quick bit of Googling didn't reveal any prior discussions (if you known any, let me know), so I'm kicking off a new discussion. I find myself wanting to be able to say something like: foo = ... where import Something.Specific The result would be to import the contents of Something.Specific into the scope of foo and its other where bindings, but not import into the rest of the module that foo is defined in. As a motivating example, I'm currently working on building some HTML in Haskell, and the amount of symbols that come into scope is huge, when you have a DSL for both CSS and HTML - the real pain point being that you get symbols that often conflict. Here's an example of something that doesn't type-check currently image = img [ width 50, style [ width (px 50) ] ] width here is both a symbol in the HTML DSL and the CSS DSL, but to get this to type check I need to write something like image = img [ HTML.width 50, style [ CSS.width (CSS.px 50) ] ] That's not particularly bad here, the really pain is repeatedly having to do this for every single symbol I'm using. I'd prefer to be able to write image = let css = let import CSS in [ width (px 50) ] in let import HTML in img [ width 50, style css ] This is a little bit of a contrived rewrite, but hopefully it shows you what I'd like to be able to do. Please don't fixate too much on this example, it's only intended to illustrate the idea. When defining a large amount of inline styles I think this pays off - I import once to bring all the symbols I need into scope, rather than having to qualify every symbol. In reality, it will lead to me writing code like: myDocument = html where html = div [ style containerStyle ] [ div [ style rowStyle ] "Hello" , div [ style rowStyle ] "World!" ] where import HTML containerStyle = [ backgroundColor ..., padding ..., margin ... ] where import CSS rowStyle = [ backgroundColor ..., padding ..., margin ... ] where import CSS At present the suggestion is a syntax error, so I'm hoping that part won't be too controversial. Thoughts? *ocharles*

16 25

Library for package preprocessing
by Carlo Nucera 06 Aug '15

06 Aug '15

Hi all, I'm writing a tool to analyze source code of a package, which uses haskell-src-extra. As copied from hackage, libraries may contain some extra stuff (for example, cpp directives). What is the modern way to preprocess the package (configuring for the environment, running the cpp ecc) to obtain code which is guaranteed to be parsed by haskell-src-extra? Ideally I'd like to leave most of the logic for this part outside of the package. Could you point me towards some libraries doing a similar thing? Best regards

2 1