- Haskell-Cafe - Haskell.org

Sharing on equality
by Johan Brinch 20 Dec '11

20 Dec '11

Hey all, Can GHC eliminate one of two equal ByteStrings, when they are compared and turns out to be equal? Say i have a map, ByteString -> Int. I now do a lookup on a ByteString and if it exists, I insert this ByteString into a list. Is it possible to avoid using more memory, than used by the keys in the map + the list structure? I.e. is it possible to eliminate the redundant ByteStrings somehow? I guess, this could be done by having lookup return the key as well, and then insert this key into the list, however, that's a bit ugly and somewhat anti-intuitive. Here's an example program, to illustrate the idea: https://gist.github.com/1472418 -- Johan Brinch

3 2

Idiomatic Aeson
by Rune Harder Bak 20 Dec '11

20 Dec '11

Hi I'm trying to parse a nested structure using Aeson (from Facebook) It looks something like this: { "education": [ { "school": { "name": "A" }, }, { "concentration": [ { "name": "B" } } ]} And besides this there is a lot of fields I don't need. (And a lot of other fields I do need) What is the idiomatic aeson way of doing this? I'm using Aeson because it's fast, and it seams to have all the relevant combinators, just can't get them to play nicely together. I was thinking something like getInfo (Object m) = (,) <$> m .: "school" .: "name" <*> mapM (.: "name") (m .: "concentracion") but of cause the types don't add up. the verbose style like getInfo (Object m) = do school <- m .: "school" schoolName <- case school of Object m' -> m' .: "name" l -> typeMismatch "schoolName" l concentration <- m .: "concentration" concentrationName <- case concentration of Array l -> forM (V.toList l) $ \m' -> case m' of Object m' -> m' .: "name" l -> typeMismatch "concentrationName" l ) o -> typeMismatch "parseList" o return (schoolName,concentrationName) quickly explodes. So I wrote my own functions of the following sort parseName name _ (Object m) = m .: name parseName _ err l = typeMismatch err l parseList p (Array l) = mapM p $ V.toList l parseList _ o = typeMismatch "parseList" o so I can do something like getInfo (Object m) = (,) <$> parseName "school "school" m >>= parseName "name" "schoolName" <*> parseName "concentration" "concentration" m >>= parseList (parseName "name" "concentrationName") And then variants for for .:?, but then it gets messy with >>= and maybe. Getting rid of the m in the above I moved to arrows, and.. it seems I'm not understanding the standard combinators. So.. what is the idiomatic way of doing this in Aeson? It shouldn't be necessary to move to template-haskell/generics to do this! Thanks!

2 1

compare lengths of lists lazily
by Henning Thielemann 20 Dec '11

20 Dec '11

Shortest and most obfuscating solution I found is: import Data.Ord (comparing) import Control.Applicative ((<$)) compareLength :: [a] -> [a] -> Ordering compareLength = comparing (()<$) :-)

3 2

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 19 Dec '11

19 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 19 Dec '11

19 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 19 Dec '11

19 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 19 Dec '11

19 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