- Haskell-Cafe - Haskell.org

Re: [Haskell-cafe] Haskell-cafe] Preventing sharing
by Doug McIlroy 09 Jan '16

09 Jan '16

Oleg rewrote my power-series one-liners to illustrate the fact that lazy lists defined in a strict language need not be very clumsy to use. I had implemented those funstions in many strict languages, one of which was ML using a lazy-list implementation from Dave MacQueen. But after I finally did it in Haskell, I never looked back. Though ML was the best of the strict bunch. Haskell's overloading and cleaner notation made for more perspicuous code. It also enabled elegant code like this for the exponential series: exps = 1 + integral exps As Oleg pointed out, this won't work in a strict language, and must be replaced with something much less vivid: exps = fix (\s 1 + integral s) In slightly more involved cases, such as sins = integral coss coss = 1 - integral sins the strict equivalent becomes murky: sins = fix (\s -> integral (1 - integral s)) coss = derivative sins or (sins, cosx) = fix (\sc -> (integral $ snd sc, 1 - integral $ fst sc) Further, because lazy lists are a new type, they can't be manipulated directly with the standard list vocabulary (map, take, filter, etc.). All such functions must be lifted to the new type. Thus, while lazy lists can be *programmed* in a strict language, they *play* somewhat awkwardly in it. In fairness, I must admit that the beauty of representation by naked lists may not survive when power series are embedded in a more comprehensive algebraic system. For example, if both matrices and power series were defined as list instances of Num, matrices might be confusEd with nested power series. Combinations--matrices of power series and vice versa--could be similarly ambiguous. But it could also turn out to cause no more difficulty than the already extensive degree of polymorphism in arithmetic expressions. Doug

3 3

error while setting it up
by Abhijit Patel 08 Jan '16

08 Jan '16

for the below command I am getting errror !! please suggest me a solution $make ===--- building phase 0 make --no-print-directory -f ghc.mk phase=0 phase_0_builds ghc.mk:159: *** dyn is not in $(GhcLibWays), but $(DYNAMIC_GHC_PROGRAMS) is YES. Stop. make: *** [all] Error 2

3 2

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

08 Jan '16

Folks: Recall the quote from the May Day 2015 issue: <http://haskell.1045720.n5.nabble.com/Haskell-Weekly-News-td5808226.html> The MLs and Haskell remind me of Brian Eno's line about how the first Velvet Underground album only sold 30,000 copies, but "everyone who bought one of those 30,000 copies started a band". This issue spotlights Elm and Idris, two languages implemented in Haskell. Enjoy! *Top Picks:* - Evan Czaplicki of the Elm web-front-end language leaves Prezi for NoRedInk <http://elm-lang.org/blog/new-adventures-for-elm>. A startup dedicated to improving high-school English grammar, NoRedInk already employs 5 engineers writing Elm full-time. A HN comment hyperbolizes that Elm <https://news.ycombinator.com/item?id=10837278#up_10838052> "is Clojure without parens, it's Haskell without academy, it's Redux without facebook, it's duck-typing without quacks, it's MVC without objects, and last but not least Evan Czaplicki (the creator) is the new Aaron Patterson (bright and fun!)." [Ed. Aaron is a Ruby and also Rails core dev.] - Janos Dobronszki, a self-described "Haskell addict, latent Idris fan", introduces Idris <http://crufter.com/2015/01/01/idris-a-language-which-will-change-the-way-yo…> as "a language that will change the way you think about programming <https://news.ycombinator.com/from?site=crufter.com>." He motivates dependent types using the classic list vector example. The Hacker News community enthuses over the article <https://news.ycombinator.com/item?id=10850205> with healthy signs of grassroots static-typing evangelism. Elsewhere, a haskell redditor obtains valuable answers about the tradeoffs that dependently typed programming incurs <https://www.reddit.com/r/haskell/comments/3zc81v/tradeoffs_of_dependent_typ…> . - In "Monads to Machine Code (Part 1)" <http://www.stephendiehl.com/posts/monads_machine_code.html>, Stephen Diehl walks his readers through an LLVM-like runtime machine code generation while introducing the x86 architecture all at the same time. No mean feat, what more x86 as opposed to a RISC architecture. Much-loved on HN <https://news.ycombinator.com/item?id=10842988>. Also on haskell reddit <https://www.reddit.com/r/haskell/comments/3zfca3/monads_to_machine_code_par…>. Compare to Lennart Augustsson's older series on code generation <http://augustss.blogspot.com/search/Label/Code%20generation>. Quality packages on hackage for runtime code generation include harpy <https://hackage.haskell.org/package/harpy> and llvm-general <https://hackage.haskell.org/package/llvm-general>. - A redditor wonders whether 3 nested loops written as a list comprehension <https://www.reddit.com/r/haskell/comments/3zcjn7/optimizing_list_comprehens…> compiles into the tight machine code version of 3 nested loops. Conspicuously absent in the discussion is mention of the Vector package <https://hackage.haskell.org/package/vector> and Don Stewart's 2010 achievements of tight loop optimization <https://donsbot.wordpress.com/2010/02/21/smoking-fast-haskell-code-using-gh…> . *Quotes of the Week:* - ReinH: thanks puregreen for Lens over Tea series puregreen: is grinning all around ReinH: also thanks for not titling it "You could have written lens" johnw: <http://ircbrowse.net/day/haskell/today?id=22057773&timestamp=1451949277#t14…> ReinH, just skip to, "You could have been edwardk", it answer all other questions (Thanks to Gesh for the link.) - From HN: <https://news.ycombinator.com/item?id=10832576#up_10836690> One thing I've learned from using immutable, functional languages (Elixir) is: "Don't tell your computer what to do, tell it how to transform data." While it may seem obvious, it's been a revelation for me and it has totally transformed how I write code, and especially how I test it. - From HN: <https://news.ycombinator.com/item?id=10833240#up_10837893> FP people are nailing composability and reusability to never seen levels just in front of your eyes. You just have to keep them open to see. OOP did it at its time too, it just hit a ceiling; but there's one reason every imperative language is OOP nowadays. - From HN: <https://news.ycombinator.com/item?id=10850205#up_10855934> As someone who learned Haskell and subsequently have been writing a lot of Python, I keep a mental tally of how many of my bugs (some of which took ages to track down) would have been caught immediately by a type system like Haskell's or Idris'. I'd say it's well over half. - From HN: <https://news.ycombinator.com/item?id=10850205#up_10856141> Haskell syntax is the lingua franca when discussing anything related to data types and functional programming these days. *Videos of the Week:* - Watch LambdaConf 2015 <https://www.youtube.com/playlist?list=PLE7tQUdRKcybh21_zOg8_y4f2oMKDHpUS>, organized by John A. De Goes and professionally recorded by Confreaks <http://www.confreaks.com/>. Richard Eisenberg presented on "A practical Introduction to GADTs" <https://www.youtube.com/watch?v=6snteFntvjM>. The video recording gets love over at haskell reddit <https://www.reddit.com/r/haskell/comments/3yw2mg/lambdaconf_2015_videos/> and even a talk summary. -- Kim-Ee

1 0

wrong GHC source files
by Hong Yang 07 Jan '16

07 Jan '16

https://www.haskell.org/ghc/download_ghc_7_10_3#sources reads Source Distribution ----------------------------------------------------------------------------- The source tarballs provide everything necessary to build the compiler, interactive system, and a minimal set of libraries. For more information on building, see the building guide. ghc-7.10.3b-windows-extra-src.tar.bz2 (92 MB) ghc-7.10.3b-windows-extra-src.tar.xz (91 MB) Shouldn't the two files be as follows? ghc-7.10.3b-src.tar.bz2 ghc-7.10.3b-src.tar.xz

2 1

Pattern Matching for record syntax
by Jeon-Young Kang 07 Jan '16

07 Jan '16

Dear All. Hope your 2016 is off to a great start. I would like to get results from pattern matching or something. Here is the my code. data Person = Person {name :: String, age :: Int} names = ["tom", "sara"] -- list of names, String persons = [Person {name = "tom", age = 10}, Person {name="sara", age=9}, Person {name = "susan", age = 8}]. Is there any solution to get the age of "tom" and "sara"? I have no idea of pattern matching for this one. I've tried to use recursion, but I couldn't find any solution for list of records. Sincerely, Young

2 1

LambdaConf 2016: Call for Proposals (May 26 - 29)
by John A. De Goes 07 Jan '16

07 Jan '16

Hi all, We have officially opened the call for proposals for LambdaConf 2016 <http://lambdaconf.us/>LambdaConf 2016 <http://lambdaconf.us/>! LambdaConf is the one of the largest and most respected conferences on functional programming in the world. With more than a hundred hours of high-quality content from leading practitioners and researchers, LambdaConf is designed to take attendees' skills to the next level, whether they are just beginning or are highly experienced in the art of functional programming. Last year, Haskell content truly dominated the conference, with many workshops and well more than a full track of Haskell presentations. This year, we'd like to repeat that, as well as see strong submissions from related languages such as PureScript (PureScript Conf 2016 is co-located with and will immediately precede LambdaConf). We are looking for speakers who want to share their knowledge of the Haskell language (past, present, and future), Haskell libraries, Haskell tools, real-world Haskell use cases, and theory relevant to functional programming (such as type theory, programming language theory, dependent-types, program derivation, category theory). We welcome first-time speakers, experienced presenters, and presentations at all levels. For more information or to submit your proposal, please visit the conference home page <http://lambdaconf.us/> (http://lambdaconf.us <http://lambdaconf.us/>), or the submission form <https://www.surveymonkey.com/r/lambdaconf-2016-cfp>. Please share this CFP with anyone you think might be interested! Regards, John

1 0

Fwd: Fwd: Re: the state of Yarr?
by Dominic Steinitz 07 Jan '16

07 Jan '16

A problem with my email prevented this making it on to the mailing list. Hi Petr, I am not actively developing Yarr but I would very much like to. I keep it from bit-rotting. The problem as always is finding time. On the other hand I don't think repa is very active e.g. upgrading to vector-0.11 took a while to happen although clearly more active than me on Yarr! What I'd like is something like Python's numpy but safer and faster. If you look at the static module in the hmatrix package (https://hackage.haskell.org/package/hmatrix-0.17.0.1/docs/Numeric-LinearAlg…) you can see how type level literals can be used to prevent e.g. multiplying two inconsistent matrices together at compile time. I am sure we could do something better with either Yarr or repa (repa will currently give out of bounds errors at runtime). For reasons I don't understand (I think a bug in Haddock) the documentation does not get generated. There are examples of its use here: https://github.com/leventov/yarr/tree/master/tests. I wrote a blog using repa and Yarr here: https://idontgetoutmuch.wordpress.com/2013/08/06/planetary-simulation-with-… and compare performance. You can safely ignore the theory and need only look at "Repa Implementation", "Yarr Implementation" and "Performance". I think performance will depend on your application. I believe (but haven't confirmed) that repa will outperform Yarr on e.g grid based problems such as numerical methods for diffusions and Poisson. In the case of planets (or stars or particles) where everything is influenced by everything else then repa is a bad fit and Yarr outperforms. If your application is linear algebra, I would think that hmatrix would have what you want or could be extended to give what you want since it is LAPACK under the covers. I am very excited that you are interested in this area; it often feels very lonely. Best wishes, Dominic. On 06/01/2016 09:10, Petr Pudlák wrote: > Hi Dominic, > > what is the current state of Yarr? Is it being actively developed? Is > there some tutorial or documentation available? > > I'm deciding between repa and yarr for some linear algebra > computations. I found some references that yarr is more performant, > but I couldn't find much documentation and the hackage page [1] hasn't > indexed most modules for some reason, so there seems to be no good > place to start from. And the last commit was 9 months ago. > > [1]https://hackage.haskell.org/package/yarr > > Thank you, > Petr

4 4

long-range performance comparisons (GHC over the years)
by Johannes Waldmann 07 Jan '16

07 Jan '16

Dear Cafe, I recently noticed a performance problem due to a fusion rule not firing for a straightforward piece of code. In fact it turned out this was already fixed in HEAD, see https://ghc.haskell.org/trac/ghc/ticket/11344 https://ghc.haskell.org/trac/ghc/ticket/9848 What worries me is that such a regression had been sitting there for over a year (and did not make it to 7.10.3) and I got to thinking: What long-range performance metering do we have? So I tried to made nofib runs for some ghc-{6,7} versions http://www.imn.htwk-leipzig.de/~waldmann/etc/nofib/comparison-k.text This is slightly broken (not all tests can be built for all compilers, and I don't known how to fix this) but there are some interesting numbers already. It seems nofib programs are self-contained (not using any libraries) so they are mainly using numbers, lists, tuples, and user-defined data. This is the heart of (traditional) Haskell, so this is supposed to work really well. The table shows that there are a lot of benchmarks where performance has been increasing. That's good. But not for all! We should certainly ignore all runtimes that are absolutely small. I think it is most interesting to look allocation numbers. A few examples from this list: * exp3_8 (allocation goes up 50 % from 6.* to 7.*) this is addition of Peano numbers. * gcd (allocation goes up 20 % from 7.8 to 7.10) using Integers, tuples (for extended Euclid), lists (for control) * tak (runtime goes up 20 % from 7.6 to 7.8) the plain Takeuchi function, just Int and recursion (it should not allocate at all?) (and I confirmed these by manually running them for more inputs, all measurements done on debian on x86_64 X5365, ghc-6.* installed from binary packages, ghc-7.* built from source) So, can this be explained? Improved? I think we should resist the temptation to change these benchmarks (using seq and ! and Int# and whatnot) Assuming nofib contains typical code, it is the task of the compiler to handle it well. In case you're wondering about my motivation - this was prompted by teaching, I wanted to show that ghc creates efficient code (by fusion) - but it's not just for the show, I generally try to believe in what I teach and I do rely on this for my real code. (Well, by definition, "real" for me might still be "academic" for others...) - Johannes.

3 3

ideas for extending 'tensor'
by Petr Pudlák 06 Jan '16

06 Jan '16

Hi Nicola, I was very excited to see your type-safe tensor package. Are the sources available somewhere for contributing? I'd be interested in trying to extend it to use unboxed vectors, or perhaps even repa or yarr. Are there any future plans like that? Also it'd be interesting to add the distinction between covariant and contravariant indices, although this would be most likely a major change. Or perhaps it'd be possible to add it just as some kind of a wrapper. All the best, Petr

1 1

Regarding GSoC 2016
by Abhijit Patel 06 Jan '16

06 Jan '16

I am Abhijit Patel, B.Tech second year student from Dhirubhai Ambani Institute of Information and Communication Technology (DA-IICT) . I have learnt haskell from the learnyouahaskell.com and I was informed that the tasks for GSoC .I need some guidance and someone who can give me some tasks to raise my level to start contributing to the haskell community.

2 1