September 2010 - Haskell-Cafe

Inverse of HaskellDB
by Jonathan Geddes 02 Oct '10

02 Oct '10

Cafe, HaskellDB takes a database schema and produces Haskell data structures (plus some other query-related stuff for its EDSL query language). What I'm looking for is the inverse of this functionality. I want to create tables based on a Haskell data structure with a few simple rules. These rules include: if a field is not of the form `Maybe a' then it can't be nullable in the database. If a field is not a primitive (in the database) then it is actually stored in another table and a reference id is stored in the table. Tables are produced recursively, unless they already exist, etc. The HaskellDB approach is great for interfacing with existing tables, but in my case I already have data structures and now I would like a quick way to create tables to persist them. Does such a thing exist? If not, would you find it useful? I may take this up as a side project if it does not already exist and others would find it useful. Thanks, --Jonathan

10 17

Coding conventions for Haskell?
by Petr Pudlak 01 Oct '10

01 Oct '10

Hi, sometimes I have doubts how to structure my Haskell code - where to break lines, how much to indent, how to name functions and variables etc. Are there any suggested/recommended coding conventions? I searched a bit and I found a few articles and discussions: - Good Haskell coding standards from Stackoverflow http://stackoverflow.com/questions/1983047/good-haskell-coding-standards - Programming guidelines from Haskellwiki http://www.haskell.org/haskellwiki/Programming_guidelines - How to read Haskell from Haskellwiki (this is actually about reading, not composing code, but still worth reading) http://www.haskell.org/haskellwiki/How_to_read_Haskell - Good Haskell Style http://urchin.earth.li/~ian/style/haskell.html but they usually address only a few specifics. I was looking for something more complete and comprehensive. Perhaps something like Java has [1]. Any suggestions? Best regards, Petr [1] http://www.oracle.com/technetwork/java/codeconv-138413.html

25 47

record update
by Jonathan Geddes 01 Oct '10

01 Oct '10

I know that record updates is a topic that has become a bit of a dead horse, but here I go anyway: I find that most of the record updates I read and write take the form >someUpdate :: MyRecord -> MyRecord >someUpdate myRecord = myRecord > { field1 = f $ field1 myRecord > , field2 = g $ field2 myRecord > , field3 = h $ filed3 myRecord > } I find myself wishing I could write something more like >someUpdate :: MyRecord -> MyRecord >someUpdate myRecord = myRecord > { field1 => f > , field2 => g > , field3 => h > } with equivalent semantics. Here => reads "is transformed by". Operator = could still be used for assignment as in current record updates. The best part about such an extension, in my opinion, is that it would open the door for anonymous lambda record updates. Something like: >someUpdate :: MyRecord -> MyRecord >someUpdate = \{field1 => f, field2 => g, field3 => h} again, with the same semantics. This becomes possible because you no longer need to refer to the record within the {} part of the update. This would be useful, for example, in the State monad. We could write: >someStateTransform :: State MyRecord () >someStateTransform = do > modify $ \{field1 => (++"!")} > ... where currently we see code like >someStateTransform :: State MyRecord () >someStateTransform = do > modify $ \record->record{field1 = (++"!") $ field1 record} > ... which repeats the record name 3 times and the field name twice. The repetition just feels out of place next to all the other terse, readable Haskell code in the program. So what do my fellow haskellers think? Is this idea worth writing up a proposal for? Alternatively, can you offer me some advice on writing code in Haskell 2010 that avoids the ugly, repetitive style of record update? --Jonathan

9 13

ANN: contstuff: CPS-based monad transformers
by Ertugrul Soeylemez 01 Oct '10

01 Oct '10

Hello fellow Haskellers, (after failing (again) to send to the haskell list, I'm posting this here. I've contacted the mailing list owner about this.) I'm announcing the 0.4.0 release of the 'contstuff' monad transformer library, an alternative to libraries like 'mtl', 'transformers' and 'monadLib': http://hackage.haskell.org/package/contstuff The difference is that contstuff makes heavy use of continuation passing style both to increase performance and to make certain control flow patterns more accessible, including abortion, accumulation of multiple results, etc. On the wiki there is a quickstart introduction to those of you, who are familiar with monad transformers in general: http://haskell.org/haskellwiki/Contstuff Feedback, positive as well as negative, is highly appreciated. Thank you. Greets, Ertugrul -- nightmare = unsafePerformIO (getWrongWife >>= sex) http://ertes.de/

2 2

Monad instance for partially applied type constructor?
by DavidA 30 Sep '10

30 Sep '10

Hi, I have the following code: {-# LANGUAGE TypeSynonymInstances #-} data Vect k b = V [(k,b)] -- vector space over field k with basis b -- for example, V [(5, E 1), (7, E 2)] would represent the vector 5 e1 + 7 e2 data Monomial v = M [(v,Int)] -- monomials over variables v -- for example, M [(A,3), (B,5)] would represent the monomial a^3 b^5 type Poly k v = Vect k (Monomial v) -- multivariate polynomials over field k and variables v instance Monad (Poly k) where return v = V [(1, M [(v,1)])] p >>= f = ... -- variable substitution So my thinking is: 1. The Monad type class is for one parameter type constructors (eg [], IO) 2. Poly is a two-parameter type constructor 3. So Poly k is a one-parameter type constructor 4. What I'm trying to express, that polynomials over field k are a monad, is true. However, GHC 6.12.2 complains: Type synonym `Poly' should have 2 arguments, but has been given 1 In the instance declaration for `Monad (Poly k)' What is going wrong?

8 12

Spell-checking lhs files
by Petr Pudlak 30 Sep '10

30 Sep '10

Hi, recently I was spell-checking a literate Haskell source file (within the vim editor). The spell checker correctly ignored LaTeX commands, but I had to manually skip over code blocks inside |...|. This was really annoying and I couldn't figure out how to configure the spell checker to skip over code. Does anybody have a solution for that? Thanks a lot, Petr

1 0

Fourth Ghent Functional Programming Group Meeting on Thursday, Oct 7th: Program, Final Details and BelHac Commercial
by Jeroen Janssen 30 Sep '10

30 Sep '10

(apologies if you receive multiple copies) Dear All, We are pleased to announce that the fourth Ghent Functional Programming Group (GhentFPG) meeting will take place on Thursday, October 7th, at 19h in the Technicum building of Ghent University (Sint-Pietersnieuwstraat 41, 9000 Gent). As before, you should enter through the electronic sliding doors on the left. The doors will be locked, but there will be a sign with a number that you can call to get in. The final program for our fourth meeting is as follows: 1. Stijn Timbermont - Mapping Interpreters onto Runtime Support When constructing an interpreter, it is hard to achieve a concise and abstract definition of the language semantics and at the same time have sufficient control over how the underlying runtime support is implemented. We illustrate with a number of examples that gaining more control over runtime support implementation forces us to adopt a more machine-like interpreter structure. This is problematic for reuse and evolution of interpreters. We present a solution to this problem that automates this restructuring of interpreters. The solution is based on three cornerstones: the theory of defunctionalized interpreters, effect-driven transformations and generic programming. It allows us to start from a concise and abstract definition of the language features and automatically transform it into a more machine-like form that allows for a customized runtime support implementation to be integrated. 2. Tom Schrijvers - Dictionaries: Eager or Lazy Type Class Witnesses? Type classes are Haskell’s acclaimed solution to ad-hoc overloading. This talk gives an introductory overview of type classes and their runtime witnesses, dictionaries. It asks the questions whether dictionaries should abide by Haskell’s default lazy evaluation strategy. Conceptually, a type class is a type-level predicate: a type is an instance of a type class iff it provides an implementation for overloaded functions. For instance, `Eq a’ declares that type `a’ implements a function `(==) :: a → a → Bool’ for checking equality. Type classes are used as constraints on type variables, in so-called constrained polymorphic functions. E.g. `sort :: Ord a => [a] → [a]’ sorts a list with any type of elements `a’ that are an instance of the Ord type class, i.e. provide implementations for comparison. Witnesses for type class constraints are necessary to select the appropriate implementation for the overloaded functions at runtime. For instance, if `sort’ is called with Int elements, the Int comparison must be used, versus say Float comparison for Float elements. Two forms of witnesses have been considered in the literature, runtime type representations and so-called dictionaries, of which the latter are the most most commonly implementation, e.g., in GHC . Haskell implementations treat dictionaries just like all other data, as lazy values that may potentially consists of non-terminating computations. This way part of the type checker’s work, who has made sure that the dictionaries do exist, is simply forgotten. Is this really necessary? 3. Dominique Devriese - Grammar Combinators - A new model for shallow parser DSL's Parser combinator libraries are a well-known alternative to parser generators in the functional programming community. However, their power is currently fundamentally limited by their representation of recursion in context-free grammars. We present the grammar-combinators Haskell library which removes these limitations, and brings some other advantages (semantic value family polymorphism, natural concepts). In this talk, I will briefly explain the motivation for the library, and then present our approach and some of its most important aspects in a live demonstration and finish with a discussion. Last, note that GhentFPG is organizing the first Belgian Haskell Hackathon, called BelHac, on 5-7 November 2010. The fifth GhentFPG meeting will take place at BelHac and will focus on talks concerning the use of functional programming in industry. More info will be provided soon. As usual, if you want get all the latest info on GhentFPG, you can subscribe to our google group (http://groups.google.com/group/ghent-fpg) or follow us on twitter (@ghentfpg). Hope to see you at both of these events! The GhentFPG Organizing committee.

1 0

Distribution needs
by Joachim Breitner 30 Sep '10

30 Sep '10

Hi, on planet.debian.org, there is some ill-tempered discussion about the seemingly bad relationship between the Ruby community and Debian maintainers. The following blog post summarizes the issues quite well and calmly: http://gwolf.org/blog/ruby-dissonance-debian-again With the Haskell community, luckily the relationship is much better. But since the technical situation is similar, i.e. a custom distribution channel via hackage/cabal-install, the possibility to install multiple versions of a package at once, I thought this might still be an interesting read. I hope this improves the understanding of a distribution’s needs and why we don’t like multiple versions of one package or a splitting in too many single small packages. But let me stress that I’m very happy with the interaction of the communities, Greetings, Joachim -- Joachim "nomeata" Breitner mail: mail(a)joachim-breitner.de | ICQ# 74513189 | GPG-Key: 4743206C JID: nomeata(a)joachim-breitner.de | http://www.joachim-breitner.de/ Debian Developer: nomeata(a)debian.org

4 4

Problem with a sample from RWH
by C K Kashyap 30 Sep '10

30 Sep '10

Hi, I was going over the Error Handling chapter in RWH and tried out this sample - Prelude> :m Control.Exception Prelude Control.Exception> let x=5 `div` 0 Prelude Control.Exception> let y=5 `div` 1 Prelude Control.Exception> handle (\_ -> putStrLn "Text") (print x) <interactive>:1:0: Ambiguous type variable `e' in the constraint: `Exception e' arising from a use of `handle' at <interactive>:1:0-39 Probable fix: add a type signature that fixes these type variable(s) Prelude Control.Exception> Could someone please tell me what the problem is and how to resolve it? -- Regards, Kashyap

2 4

Parsec question (new user): unexpected end of input
by Peter Schmitz 29 Sep '10

29 Sep '10

I am a new Parsec user, and having some trouble with a relatively simple parser. The grammar I want to parse contains tags (not html) marked by angle brackets (e.g., "<some tag>"), with arbitrary text (no angle brackets allowed) optionally in between tags. Tags may not nest, but the input must begin and end with a tag. Whitespace may occur anywhere (beginning/end of input, inside/between tags, etc.), and is optional. I think my problem may be a lack of using "try", but I'm not sure where. At runtime I get: Error parsing file: "...\sampleTaggedContent.txt" (line 4, column 1): unexpected end of input expecting "<" The input was: <tag1>stuff<tag 2> more stuff < tag 3 > even more <lastTag> The code is below. (I'm using Parsec-2.1.0.1.) I don't really want to return anything meaningful yet; just parse okay. Any advice about the error (or how to simplify or improve the code) would be appreciated. Thanks much, -- Peter > -- Parsers: > taggedContent = do > optionalWhiteSpace > aTag > many tagOrContent > aTag > eof > return "Parse complete." > > tagOrContent = aTag <|> someContent <?> "tagOrContent" > > aTag = do > tagBegin > xs <- many (noneOf [tagEndChar]) > tagEnd > optionalWhiteSpace > return () > > someContent = do > manyTill anyChar tagBegin > return () > > optionalWhiteSpace = spaces -- i.e., any of " \v\f\t\r\n" > tagBegin = char tagBeginChar > tagEnd = char tagEndChar > > -- Etc: > tagBeginChar = '<' > tagEndChar = '>' --------

3 5