May 2011 - Haskell-Cafe

Decimal type-level arithmetic.
by Serguey Zefirov 31 May '11

31 May '11

I would like to present my version of type arithmetic with decimal encoding: http://thesz.mskhug.ru/svn/hhdl/TyleA.hs It is not worth Cabal package in its current state, but I hope it would be useful for someone. It is easy to use, just say Plus (D1 :. D2 :. D0) D8 to get a type of 128. Or you can say $(tySize 128) if you're not afraid to use Template Haskell. I tested it on my current project, it works quite well with numbers around 128..512, about 10-20 times faster than Peano numbers. As operations over this representation are not lazy (Peano numbers oeprations are lazy for one argument of Plus and for part of one argument of Max), it is not well suited for big number of operations done at once. I encountered it when I autogenerated a big arithmetic expression for big polymorphic data type. I think it is quite rare situation.

2 2

Thoughts about currying and optimisations
by Yves Parès 31 May '11

31 May '11

Hello Café, An idea came to me: unless the compiler notices that stuffA and stuffB are equivalent, would it be correct to suppose that A is better than B? stuffA x = if someComputationallyExpensiveTest x then doSomething else doSomethingElse stuffB x y = if someComputationallyExpensiveTest x then doSomething y else doSomethingElse y I explain: in stuffA, the function only depends on x, so when doing: a = stuffA xxx runs the expensive test once and for all, and a can directly be bound to doSomething or doSomethingElse so calling after: a foo a bar won't run the test Whereas: b = stuffB xxx is valid due to curryfication, but: b foo b bar will both run the expensive test

2 2

Can't figure out cmap in hmatrix
by Mats Klingberg 31 May '11

31 May '11

Hello, I'm playing around a bit with the hmatrix package (http://hackage.haskell.org/package/hmatrix) but can't quite figure out how to make the cmap function in Numeric.Container work. An example: ghci> import Numeric.LinearAlgebra ghci> let v = fromList [1.0,2.0,3.0] ghci> v fromList [1.0,2.0,3.0] :: Data.Vector.Storable.Vector ghci> :t v v :: Vector Double ghci> cmap sqrt v <interactive>:1:1: No instance for (Container Vector e0) arising from a use of `cmap' Possible fix: add an instance declaration for (Container Vector e0) In the expression: cmap sqrt v In an equation for `it': it = cmap sqrt v ghci> :t cmap cmap :: (Container c e, Element b, Element a) => (a -> b) -> c a -> c b There is an instance for (Container Vector Double) but I assume that since the signature of cmap doesn't mention the type variable 'e' GHCi can't infer it. Googling hasn't helped me so far, except for digging up another post to this list with the same (?) problem, but no answer: http://www.haskell.org/pipermail/haskell-cafe/2011-April/091390.html Is there a way to tell GHC what instance to use, or how should cmap be used? Thanks! Mats

3 3

Sub class and model expansion
by Patrick Browne 31 May '11

31 May '11

Hi, I'm not sure if this is possible but I am trying to use Haskell’s type class to specify *model expansion*. Model expansion allows the specification of new symbols (known as enrichment) or the specification further properties that should hold on old symbols. I am trying to enrich simplified Monoids to Groups. The code below is not intended to do anything other than to specify simplified Groups as a subclass of Monoid. The main problem is that I cannot use ! on the LHS of equations in Group. Is it possible to expand the specification of Monoid to Group using Haskell type classes? Pat data M = M deriving Show -- Monoid with one operation (!) and identity e (no associativity) class Monoid a where (!) :: a -> a -> a e :: a a ! e = a -- A Group is a Monoid with an inverse, every Group is a Monoid -- (a necessary condition in logic: Group implies Monoid) -- The inverse property could be expressed as: -- 1) forAll a thereExists b such that a ! b = e -- 2) (inv a) ! a = e class Monoid a => Group a where inverse :: a -> a -- Haskell does not like ! on the LHS of equation for inverse in Group. -- (inverse a) ! a = e This message has been scanned for content and viruses by the DIT Information Services E-Mail Scanning Service, and is believed to be clean. http://www.dit.ie

3 5

ANN: quickcheck-properties
by Alexey Khudyakov 31 May '11

31 May '11

Hello It always puzzled me why there are no packages for for testing general type classes laws. (Monoid laws, monad laws etc). It looks like ideal case for quickcheck and smallcheck. I'm glad to present package quickcheck-properties[1]. It containt set of generic properties for semiroups, monoids, groups and unsatisfactory imlementatation of functor's properties. Despite its name package do not depend on quickcheck and could be used with smallcheck as well. ==================== Examples ==================== Here are few examples: >>> quickCheck $ eq $ prop_Monoid (T :: T [Int]) +++ OK, passed 100 tests. >>> quickCheck $ eq $ prop_Monoid (T :: T (Maybe [Int])) +++ OK, passed 100 tests. prop_Monoid tests all monoid properties: associativity, left and right identity. T is used to fix type of monoid to test. It could be done with type signature for prop_Monoid but writing signature for three parameter function is just too cumbersome. eq compares expression in properties using == operator. Many (most?) of properties have form > expression = another expression Easiest solution is to compare them with ==. But is's not satisfactory. Data type may not have Eq instance. Eq instance may provide structural equality but some form of equivalince is needed. etc. It's left to library user to decide how to compare values. In this contrived example lists are compared by length. > eqOn length $ prop_Monoid (T :: T [Int]) ==================== Problems ==================== There are unsolved problems. So it's announcement with question. Functor/Applicative/Monads laws involve arbitrary functions. It would be natural to generate them using quickcheck but I don't know how to generate random functions. Any suggestions? [1] http://hackage.haskell.org/package/quickcheck-properties -- Aleksey Khudyakov

4 5

PhD studentship in Nottingham
by Graham Hutton 31 May '11

31 May '11

Dear all, I are currently advertising a PhD studentship in functional programming -- the advert is copied below, and attached. If you know of any good candidates who many be interested in this, or there is a local mailing list for advertising such things, I would be much obliged if you could pass on the advert. Best wishes, Graham +------------------------------------------------------------------+ PhD Studentship in Functional Programming School of Computer Science University of Nottingham, UK Applications are invited for a fully-funded PhD studentship in the Functional Programming Lab in the School of Computer Science at the University of Nottingham, starting on 1st October 2011, under the supervision of Prof Graham Hutton. The suggested topic for the studentship is to develop a practical implementation of the worker/wrapper transformation, a simple but powerful unifying paradigm for program optimisation, but other ideas for possible topics are welcome too. The studentship is for three and a half years, and includes a maintenance grant of 13,590 UK pounds per year, and tuition fees. Applicants for the position will require a first-class Honours degree (or equivalent) in Computer Science and/or Mathematics, some experience in functional programming, and an aptitude for mathematical subjects. Additional desirable attributes include a Masters degree, and/or some experience in programming language semantics, implementation and optimisation. Due to the nature of the funding, the position is only open to UK citizens, or EU citizens who have resided in the UK for the last three years. The successful applicant will work under the supervision of Prof Graham Hutton in the FP Lab in Nottingham, a leading centre for research on functional programming. The group currently comprises 5 academic staff, 1 research fellow, and 10 PhD students. In order to apply, please submit the following to Prof Graham Hutton (graham.hutton(a)nottingham.ac.uk) by 24th June 2011: an up-to-date copy of your CV (including the results of all your University examinations to date) along with a brief covering letter that describes your experience in functional programming, your reasons for wishing to pursue a PhD in this area, and any ideas you have regarding possible research directions. Closing date for applications: 24th June 2011. +------------------------------------------------------------------+ -- Graham Hutton Functional Programming Lab School of Computer Science University of Nottingham, UK http://www.cs.nott.ac.uk/~gmh This message and any attachment are intended solely for the addressee and may contain confidential information. If you have received this message in error, please send it back to me, and immediately delete it. Please do not use, copy or disclose the information contained in this message or in any attachment. Any views or opinions expressed by the author of this email do not necessarily reflect the views of the University of Nottingham. This message has been checked for viruses but the contents of an attachment may still contain software viruses which could damage your computer system: you are advised to perform your own checks. Email communications with the University of Nottingham may be monitored as permitted by UK legislation.

1 0

What's the advantage of writing Haskell this way?
by John Ky 31 May '11

31 May '11

Hi all, I'm trying to learn about enumerators by reading this paper<https://john-millikin.com/downloads/enumerator_0.4.10.pdf>and came across some code on page 2 that I found hard to digest, but I think I finally got it: import Data.Monoid data Stream a = Chunks [a] | EOF deriving (Show, Eq) instance Monad Stream where return = Chunks . return Chunks xs >>= f = mconcat (fmap f xs) EOF >>= _ = EOF instance Monoid (Stream a) where mempty = Chunks mempty mappend (Chunks xs) (Chunks ys) = Chunks (xs ++ ys) mappend _ _ = EOF I guess, it shows my lack of experience in Haskell, but my question is, why is writing the code this way preferred over say writing it like this: import Data.Monoid data Stream a = Chunks [a] | EOF deriving (Show, Eq) instance Monad Stream where return x = Chunks [x] Chunks xs >>= f = mconcat (fmap f xs) EOF >>= _ = EOF instance Monoid (Stream a) where mempty = Chunks [] mappend (Chunks xs) (Chunks ys) = Chunks (xs ++ ys) mappend _ _ = EOF Cheers, -John

6 10

Please add a method for optimized concat to the Semigroup class
by Yitzchak Gale 31 May '11

31 May '11

Hi Edward, Thanks much for the very useful semigroups package. When using it in practice, it would be very useful to have an analogue to the mconcat method of Monoid. It has the obvious default implementation, but allows for an optimized implementation for specific instances. That turns out to be something that comes up all the time (at least for me) in real life. Thanks, Yitz

5 13

Erlang's module discussion
by Tom Murphy 31 May '11

31 May '11

Hi All, I sure love Hackage, but there's a very interesting discussion going on, on the Erlang mailing list, about completely restructuring the module-model. Before you dismiss it as crazy, know that the topic was brought up by Joe Armstrong, one of the creators of the language. Here's the archive: http://erlang.org/pipermail/erlang-questions/2011-May/058769.html Food for thought... Tom

9 10

Student Internships for Parallel Haskell Programming at NII, Tokyo
by Sebastian Fischer 31 May '11

31 May '11

As part of my research fellowship at the National Institute of Informatics in Tokyo, I announce the availability of student internships for up to three months between July and September 2011. Qualified applicants are enrolled in a Masters or Phd program, have a firm grasp of the Haskell programming language, and, ideally, know the different approaches to parallel and concurrent programming available in the Glorious Glasgow Haskell Compilation System (GHC). Their task is to support research on combinators for parallel programming by developing and comparing efficient implementations. The available fund covers sojourn costs but no travel expenses. It is meant to foster collaboration between Germany and Japan but qualified students from other countries may also be funded. If you want to spend the summer hacking Haskell in Tokyo please do not hesitate to contact me off list. Feel free to write even if you are unsure whether you are qualified or have any other questions regarding the internship. Best regards, Sebastian http://research.nii.ac.jp/members/fischer/ P.S. Information about the status after the earthquake is available on the Local Information page of ICFP'11: http://www.biglab.org/icfp11local/index.html Additionally, you may want to follow recent news in English by Mainichi Daily News and NHK World: http://mdn.mainichi.jp/ http://www3.nhk.or.jp/daily/english/

1 0