- Haskell-Cafe - Haskell.org

PEPM'12 - second call for participation
by Simon Thompson 19 Dec '11

19 Dec '11

ACM SIGPLAN 2012 Workshop on Partial Evaluation and Program Manipulation http://www.program-transformation.org/PEPM12 January 23-24, 2012. Philadelphia, PA, USA (co-located with POPL'12) Second Call For Participation Online registration is open at https://regmaster3.com/2012conf/POPL12/register.php Early registration deadline is December 24, 2011 Program is now available http://www.program-transformation.org/PEPM12/Program The PEPM Symposium/Workshop series brings together researchers and practitioners working in the broad area of program transformation, which spans from refactoring, partial evaluation, supercompilation, fusion and other metaprogramming to model-driven development, program analyses including termination, inductive programming, program generation and applications of machine learning and probabilistic search. PEPM focuses on techniques, supporting theory, tools, and applications of the analysis and manipulation of programs. In addition to the presentations of regular research papers, the PEPM program includes tool demonstrations and `short paper' presentations of exciting if not fully polished research. PEPM has established a Best Paper award. The winner will be announced at the workshop. INVITED TALKS Compiling Math to High Performance Code Markus Pueschel (ETH Zuerich, Switzerland) http://www.inf.ethz.ch/~markusp/index.html Specification and verification of meta-programs Martin Berger (University of Sussex, UK) http://www.informatics.sussex.ac.uk/users/mfb21/ VENUE The conference is co-located with POPL and will be held at the Sheraton Society Hill Hotel in Philadelphia's historic district. For hotel rate details and booking please see the POPL webpage: http://www.cse.psu.edu/popl/12/ Simon Thompson | Professor of Logic and Computation School of Computing | University of Kent | Canterbury, CT2 7NF, UK s.j.thompson(a)kent.ac.uk | M +44 7986 085754 | W www.cs.kent.ac.uk/~sjt

1 0

[Alternative] summary of my understanding so far
by Gregory Crosswhite 19 Dec '11

19 Dec '11

Hey everyone! First of all, it sounds like we all agree that the documentation for Alternative needs to be improved; that alone would clear a lot of the confusion up. I think that a fairly convincing case has also been made that removing many/some from the typeclass doesn't help too much since they are generically defined in terms of the other methods. Put another way, arguing that removing many/some makes Alternative more safe would be like arguing that removing "forever" from the definition of Monad (assuming it were currently a method rather than a function) made Monad more safe. (On the other hand, it might be nice if many/some were not featured so prominently above other functions/combinators in the module.) As a corollary to the above paragraph, if the many/some methods *were* moved to a subclass --- call it, "Parser" --- then essentially this subclass would be redundant. Nonetheless, such a subclass could still be useful because it supplies more information to the user about how the type behaves. That is, while any user of an instance of Alternative can always theoretically use something like many/some, in practice a user might want to add the Parser constraint to their type just to get an extra guarantee that many/some not only exist but are well-behaved. Although many/some cause infinite loops for the current instance of Maybe and [], forever also causes loops for (return (undefined)) for any Monad. Thus, even in the likely event that we decide to keep many/some in Alternative, it still makes sense to have Alternative instances for Maybe and [], despite the fact that they don't play well with many/some for non-empty values. In fact, if anything the existence of the Maybe and [] instances provides a strong reason *to* have the many/some methods inside Alternative, precisely because it gives us a customization point that allows us to make many and some provide well-defined answers for all values of these types. To quote Ross Paterson's proposals: instance Alternative Maybe where ... some Nothing = Nothing some (Just x) = Just (repeat x) many Nothing = Just [] many (Just x) = Just (repeat x) instance Alternative [] where ... some [] = [] some (x:xs) = repeat (repeat x) many [] = [[]] many (x:xs) = repeat (repeat x) The only price that we pay for these instances is that, while some and many are still solutions of • some v = (:) <$> v <*> many v • many v = some v <|> pure [] they no longer the *least* solutions of these equations. In my opinion this is a relatively small price to pay since they nonetheless *are* solutions to these questions, and they have the nice property that they converge sensibly. In fact, in a sense they are the least solutions to the equations that out of all the solutions that converge, though I don't know enough about the theory involved to use the proper technical terminology to express what I really mean, or even if what I just wrote was true. :-) Anyway, as the above discussion illustrates, the existence of pure types that are instances of Alternative actually *adds* to the case of keeping some and maybe in Alternative. So in conclusion: 1) Documentation really needs to be improved 2) some/many cannot be physically separated from Alternative, but there *might* be an advantage to creating a subclass for them anyway purely for the sake of conveying more information about a type to users 3) Maybe and [] are sensible instances of Alternative, even if many/some often enters an infinite loop. 4) It is possible to provide special instance of many/some that satisfy the equations of many/some, with the slight disadvantage that these solutions are no longer the "least" solutions. Based on all of this, at this moment in time it seems to me that the most sensible way forward is to fix the documentation, tweak the definition of Alternative to no longer require the least solutions of the equations, and then to adopt the new instances for Maybe and []. Thoughts? Cheers, Greg

7 16

PEPM12: Second Call For Participation
by oleg＠okmij.org 19 Dec '11

19 Dec '11

ACM SIGPLAN 2012 Workshop on Partial Evaluation and Program Manipulation http://www.program-transformation.org/PEPM12 January 23-24, 2012. Philadelphia, PA, USA (co-located with POPL'12) Second Call For Participation Program is now available http://www.program-transformation.org/PEPM12/Program Online registration is open at https://regmaster3.com/2012conf/POPL12/register.php Early registration deadline is December 24, 2011 The PEPM Symposium/Workshop series brings together researchers and practitioners working in the broad area of program transformation, which spans from refactoring, partial evaluation, supercompilation, fusion and other metaprogramming to model-driven development, program analyses including termination, inductive programming, program generation and applications of machine learning and probabilistic search. PEPM focuses on techniques, supporting theory, tools, and applications of the analysis and manipulation of programs. In addition to the presentations of regular research papers, the PEPM program includes tool demonstrations and `short paper' presentations of exciting if not fully polished research. PEPM has established a Best Paper award. The winner will be announced at the workshop. INVITED TALKS Compiling Math to High Performance Code Markus Pueschel (ETH Zuerich, Switzerland) http://www.inf.ethz.ch/~markusp/index.html Specification and verification of meta-programs Martin Berger (University of Sussex, UK) http://www.informatics.sussex.ac.uk/users/mfb21/ VENUE The conference is co-located with POPL and will be held at the Sheraton Society Hill Hotel in Philadelphia's historic district. For hotel rate details and booking please see the POPL webpage: http://www.cse.psu.edu/popl/12/

1 0

Type checker for haskell-src-exts (was: Typechecking Using GHC API)
by Sean Leather 18 Dec '11

18 Dec '11

On Thu, Dec 15, 2011 at 11:07, Niklas Broberg wrote: > Envisioned: The function you ask for can definitely be written for > haskell-src-exts, which I know you are currently using. I just need to > complete my type checker for haskell-src-exts first. Which is not a small > task, but one that has been started. That's good to know! I presume it's something like Haskell98 to start with? I'd be even more impressed (and possibly also concerned for your health) if you were going to tackle all of the extensions! I've been trying to find a student to write a haskell-src-exts type checker for me. It should use a particular kind of mechanism though, using constraints similar to [1]. Then, I want to adapt that to do transformations. What approach are you using? Maybe I can somehow steal your work... ;) Regards, Sean [1] http://www.staff.science.uu.nl/~heere112/phdthesis/

4 6

Adding state to a library
by Kevin Jardine 18 Dec '11

18 Dec '11

I have a library of functions that all take cfg parameter (and usually others) and return results in the IO monad. It is sometimes useful to drop the config parameter by using a state-like monad.. I have found that I can wrap all my functions like so: withLibrary cfg f = f cfg stateF a b c d =

2 3

ANNOUNCE: Anansi 0.4.2 (literate programming pre-processor)
by John Millikin 18 Dec '11

18 Dec '11

Anansi is a preprocessor for literate programs, in the model of NoWeb or nuweb. Literate programming allows both computer code and documentation to be generated from a single unified source. Home page: https://john-millikin.com/software/anansi/ Hackage: http://hackage.haskell.org/package/anansi-0.4.2 ----- This release has a couple cool new features, suggested by Dirk Laurie. Markdown loom =============== Markdown, a lightweight markup language similar to ReStructuredText, is used often on web forums. Use [[ :loom anansi.markdown ]] in your documents to enable. User-defined line pragmas ======================== Users can now add, modify, and disable line pragmas in tangled output based on file extension. This makes it much easier to combine code and data in a single source file. By default, line pragmas are enabled for the C, C++, C#, Haskell, Perl, and Go languages. Customizing the pragma format is easy. Use the ${line}, ${path}, and ${quoted-path} substitutions in an :option. This example code will insert comments into tangled Python code: ------------------------------------------- :# Insert comments into any tangled output file with a name ending in ".py" :option anansi.line-pragma-py=# Generated from ${path} line ${line} ------------------------------------------- To disable line pragmas for a particular file type, just set its pragma format to an empty string: ------------------------------------------- :option anansi.line-pragma-pl= -------------------------------------------

2 4

Announce: The Haskell Platform 2011.4
by Don Stewart 18 Dec '11

18 Dec '11

We're pleased to announce the release of the Haskell Platform: a single, standard Haskell distribution for everyone. Download the Haskell Platform 2011.4.0.0: http://haskell.org/platform/ The specification, along with installers (including Windows, Apple and Unix installers for a full Haskell environment) are available. The Haskell Platform is a single, standard Haskell distribution for every system, in the form of a blessed library and tool suite for Haskell distilled from the thousands of libraries on Hackage, along with installers for a wide variety of systems. It saves developers work picking and choosing the best Haskell libraries and tools to use for a task. When you install the Haskell Platform, you get the latest stable compiler, an expanded set of core libraries, additional development tools, and cabal-install – so you can download anything else you need from Hackage. What you get is specified here: http://hackage.haskell.org/platform/contents.html Thanks! -- The Platform Infrastructure Team P.S. Special thanks to Mark Lentczner for his excellent work on this release.

3 2

ANNOUNCE: hxournal-0.5.0.0 - A pen notetaking program written in haskell
by Ian-Woo Kim 18 Dec '11

18 Dec '11

Hi, everyone, I am very pleased to announce a pen notetaking program: hxournal, which is written entirely in haskell using gtk2hs. I uploaded the package on hackage. This program accompanies with two library packages, xournal-parser and xournal-render for parsing and rendering xournal format file. http://hackage.haskell.org/package/hxournal http://hackage.haskell.org/package/xournal-parser http://hackage.haskell.org/package/xournal-render Installing hxournal should be very simple: > cabal update > cabal install hxournal hxournal can be currently regarded as a clone of xournal, which is a notetaking program developed in C. (See http://xournal.sourceforge.net) As xournal, hxournal can take wacom tablet X11 input in subpixel unit so that it can result in very smooth notetaking experience. Currently, basic pen operations and eraser operations, file open/save operations, rectangular selection, cut/copy/paste operations have been implemented. So the application is semi-usable. The file format is the same as xournal but gunzipped. So to view/edit xoj files generated from xournal, just gunzip the xoj files and read them in hxournal. Gunzipped xoj files generated from hxournal are readable in xournal program. One NEW special feature of hxournal compared with xournal: This program can make a split view (horizontal and vertical and arbitrary combination of them) of the same document similarly to emacs buffers and windows. Please try Horizontal/Vertical Split in View menu of the program. This will be convenient when notetaking a long document. The git repository is located at https://www.github.com/wavewave/hxournal The program web page and development web/wiki pages will be announced soon (it will be linked from package webpage on hackage anyway) and the detailed manual will be presented there. Thank you for your interest. Enjoy haskell notetaking! Ian-Woo Kim

7 16

I've just heard of a neat security measure that when you compile the code it generates different object code...
by KC 17 Dec '11

17 Dec '11

... with the same functionality. Thus, your program would be a moving target to hackers. Would this be challenging with ghc? -- -- Regards, KC

4 3

Typechecking Using GHC API
by Sh NJP 17 Dec '11

17 Dec '11

Hi, I do some pre-processing on a normal Haskell code ( -F ). The pre-processor needs to know the type of each expression. What are the possibilities to do so? Can I use GHC API to employ GHC type checker? If yes, any good tutorial? Is it too naive to think of a function, f :: String -> AnnotatedAST , that takes Haskell code and returns its corresponding abstract syntax tree annotated with types? Thanks, /shayan

4 3