January 2016 - Haskell-Cafe

Regarding Developing my skills with haskell!
by Abhijit Patel 09 Jan '16

09 Jan '16

Hello, I want to learn some practical application using haskell like some projects or developing a game. Can anyone suggest me some link to develop my skills with haskell ? Cheers, Abhijit

3 2

Re: [Haskell-cafe] Lazy series [was : Preventing sharing]
by Tom Ellis 09 Jan '16

09 Jan '16

Sharing a private conversation, with the permission of Jerzy. On Sat, Jan 09, 2016 at 11:45:00AM +0100, Jerzy Karczmarczuk wrote: > Again: *exps = 1 + integral exps* > > I said that if RHS exps is evaluated, it cannot work. > > >>>But if it evaluates to a thunk ... > >>Then, on which premises you call the language "strict"? > > >Why not? > > > >A thunk could either be a delayed function call, or it could be a memoised > >thunk, such as OCaml (a strict language) provides > > > > http://caml.inria.fr/pub/docs/manual-ocaml/libref/Lazy.html [...] > But in the original expression with exps, you don't delay anything. > You don't construct *exps()*, or equivalent. This variable is just > variable, lexical atom, and either you evaluate it or not. If not, > don't call the language strict. If there is a delay form introduced > by the compiler, the language is not strict. > > If you don't agree, I suggest that instead of asking "why this > doesn't work, it should!" , simply implement it. Oleg has already provided most of the solution http://okmij.org/ftp/ML/powser.ml The aim is exps = 1 + integral exps In Oleg's framework the answer is let exps = I.fix (fun e -> int 1 +% integ e) In a hypothetical OCaml with typeclasses, this becomes let exps = I.fix (fun e -> 1 + integ e) The remaining objection is the presence of the fix. The solution here is to allow the language to support recursive bindings of lazy values[1], not just of function values. The we could write let rec exps = 1 + integ exps If you still do not agree I would appreciate it if you could explain why such a language a) could not exist, or b) would not be called "strict" If you're still not convinced, consider a lazy language, Haskell--, which doesn't allow recursive bindings of non-function types. In Haskell-- you *cannot* write exps = 1 + integral exps but you have to write exps = I.fix (\e -> 1 + integral e) So we see that the nice syntax "exps = 1 + integral exps" is not due to laziness (since Haskell-- is lazy, but you cannot write that). Instead the nice syntax is due to lazy recursive bindings, and this sugar can exist as well in a strict language as it can in a lazy one. Tom [1] Note that recursive bindings are anyway just syntactic sugar for a fixed point. The definition sum = \x -> case x of [] -> 0 (x:xs) = x + sum xs is (essentially) sugar for sum = fix (\sum' x -> case x of [] -> 0 (x:xs) = x + sum' xs) so adding additional sugar for binding lazy values can hardly spoil anything.

3 9

async docs not on hackage for some reason?
by Noon Silk 09 Jan '16

09 Jan '16

Hello, Does anyone have any thoughts why the async docs aren't available on hackage yet? - https://hackage.haskell.org/package/async-2.1.0 It says this version was uploaded a few days ago, but no docs are available. I did a `cabal get` locally and build the docs using stack; so it works fine. -- Noon Silk, ن https://silky.github.io/ "Every morning when I wake up, I experience an exquisite joy — the joy of being this signature."

2 1

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