May 2007 - Haskell - Haskell.org

Announcing Djinn, version 2004-12-11, a coding wizard
by Lennart Augustsson 07 Apr '11

07 Apr '11

Howdy, y'all! I've written a small program that takes a (Haskell) type and gives you back a function of that type if one exists. It's kind of fun, so I thought I'd share it. It's probably best explained with a sample session. calvin% djinn Welcome to Djinn version 2005-12-11. Type :h to get help. # Djinn is interactive if not given any arguments. # Let's see if it can find the identity function. Djinn> f ? a->a f :: a -> a f x1 = x1 # Yes, that was easy. Let's try some tuple munging. Djinn> sel ? ((a,b),(c,d)) -> (b,c) sel :: ((a, b), (c, d)) -> (b, c) sel ((_, v5), (v6, _)) = (v5, v6) # We can ask for the impossible, but then we get what we # deserve. Djinn> cast ? a->b -- cast cannot be realized. # OK, let's be bold and try some functions that are tricky to write: # return, bind, and callCC in the continuation monad Djinn> type C a = (a -> r) -> r Djinn> returnC ? a -> C a returnC :: a -> C a returnC x1 x2 = x2 x1 Djinn> bindC ? C a -> (a -> C b) -> C b bindC :: C a -> (a -> C b) -> C b bindC x1 x2 x3 = x1 (\ c15 -> x2 c15 (\ c17 -> x3 c17)) Djinn> callCC ? ((a -> C b) -> C a) -> C a callCC :: ((a -> C b) -> C a) -> C a callCC x1 x2 = x1 (\ c15 _ -> x2 c15) (\ c11 -> x2 c11) # Well, poor Djinn has a sweaty brow after deducing the code # for callCC so we had better quit. Djinn> :q Bye. To play with Djinn do a darcs get http://darcs.augustsson.net/Darcs/Djinn or get http://darcs.augustsson.net/Darcs/Djinn/Djinn.tar.gz Then just type make. (You need a Haskell 98 implementation and some libraries.) And then start djinn. For the curious, Djinn uses a decision procedure for intuitionistic propositional calculus due to Roy Dyckhoff. It's a variation of Gentzen's LJ system. This means that (in theory) Djinn will always find a function if one exists, and if one doesn't exist Djinn will terminate telling you so. This is the very first version, so expect bugs. :) Share and enjoy. -- Lennart

8 13

Haskell-mode 2.0
by Stefan Monnier 02 Feb '09

02 Feb '09

I have recently taken over maintainership of Haskell-mode, and after making a bunch of changes, I figured it would be a good idea to make a new release. You can find this new release at: http://www-perso.iro.umontreal.ca/~monnier/elisp/ If you think it should also be found at http://www.haskell.org/haskell-mode/, then please tell John Peterson to get back to me (my email to him seem to go straight to the bitbucket. John?). This release has several changes that have all been only lightly tested, especially w.r.t compatibility with various Emacsen. See appended the NEWS file that describes some of the notewirthy changes. Stefan Changes since 1.45: * keybindings C-c <char> have been replaced by C-c C-<char> so as not to collide with minor modes. * The following modules are now automatically activated without having to add anything to haskell-mode-hook: haskell-font-lock (just turn on global-font-lock-mode). haskell-decl-scan (just bind `imenu' to some key). * In recent Emacsen, haskell-doc hooks into eldoc-mode. * haskell-hugs and haskell-ghci are superceded by inf-haskell. * Indentation rules have been improved when using layout inside parens/braces. * Symbols like -> and \ can be displayed as actual arrows and lambdas. See haskell-font-lock-symbols. * Tweaks to the font-lock settings. Among other things paren-matching with things like \(x,y) should work correctly now. * New maintainer <monnier(a)gnu.org>.

3 6

The real Monad Transformer
by Henning Thielemann 13 Nov '08

13 Nov '08

It was argued that people avoid Haskell because of terms from Category theory like 'Monad'. This problem can now be solved by a wrapper which presents all the WWW without monads! Start e.g. at http://saxophone.jpberlin.de/MonadTransformer?source=http%3A%2F%2Fwww%2Ehas… Of course the tool is written in Haskell, that is, Haskell helps solving problems which only exist because of Haskell. Bug reports and feature requests can be tracked at https://sourceforge.net/projects/parallelweb

8 10

ANNOUNCE: Harpy -- run-time code generation library
by Dirk Kleeblatt 12 Jun '07

12 Jun '07

Hi everybody, we're pleased to announce the first release of Harpy. Harpy is a library for run-time code generation of x86 machine code. It provides not only a low level interface to code generation operations, but also a convenient domain specific language for machine code fragments, a collection of code generation combinators and a disassembler. Harpy homepage: http://uebb.cs.tu-berlin.de/harpy/ Kind regards, Martin Grabmüller and Dirk Kleeblatt

9 12

CfP: 2nd CEFP Functional Programming School, June 23-30, 2007
by HORVATH Zoltan 11 Jun '07

11 Jun '07

2nd Central-European Functional Programming School CEFP 2007 Cluj-Napoca, June 23-30, 2007 http://cs.ubbcluj.ro/cefp2007/ First Announcement - Call for participation - Call for PhD student presentation Aims and Scopes: The Central-European Functional Programming School (CEFP) is an intensive summer school series in the field of functional programming. The main goal is to bring together computer scientists, researchers, graduate and especially PhD students. The school would like to promote the research and the education of the functional programming languages, software technologies and programming methodologies. The second CEFP school will be organized by the Babeş-Bolyai University (Cluj-Napoca / Kolozsvár / Klausenburg) between 23-30 June, 2007. The previous school was held in Budapest, Hungary, July, 2005. The invited lecturers are prominent researchers in the field, and they will present state-of-the-art functional programming techniques. Beside the lectures practical courses will be held. The school includes a workshop for PhD students to present their work and get feed-back from the lecturers. Invited Lecturers: Rinus Plasmeijer (Radboud University Nijmegen, The Netherlands): iTasks: Defining Interactive Workflows for the Web Werner Kluge (Christian-Albrechts-Universität zu Kiel, Germany): Abstract Lambda Calculus Machines Marko van Eekelen (Radboud University Nijmegen, The Netherlands): Proving Properties of Lazy Functional Programs Tim Sheard (Portland State University, USA): The Omega Programming Language Ralf Hinze (Universität Bonn, Germany): Generics Three additional short courses will be given: Zoltán Horváth (Eötvös Loránd University, Budapest, Hungary): Refactoring Erlang Programs Zoltán Csörnyei (Eötvös Loránd University, Budapest, Hungary): Lambda-Calculus Horia F. Pop (Babeş-Bolyai University, Cluj-Napoca, Romania): A Tutorial on Object Orientedness in Functional Programming Submissions: PhD students are invited to submit the abstract of their presentations to be included in the workshop programme. Each presentation can be of max. 25 minutes. The full paper version can be submitted after the summer school. It is under negotiation to publish the revised lectures and the selected and reviewed papers in LNCS Volume. Venue: Cluj-Napoca / Kolozsvár / Klausenburg, formerly the capital of Transylvania, is one of the most beautiful medieval cities with a huge multicultural and historical inheritance. Surrounded by marvelous hills and mountains, the city provides fascinating environment for experiencing the unique ambience of a diversified culture, society and nature. Registration and costs: The registration fee (260 Euro) includes the course materials distributed during the school, the post-school volume, lunches, the excursion and the summer school banquet. For further information, accommodation possibilities and registration please visit the web-page of the event: http://www.cs.ubbcluj.ro/cefp2007. The deadline for registration and submissions is 1 June 2007.

1 2

ST vs State
by Federico Squartini 31 May '07

31 May '07

Hello dear Haskellers, Could someone be kind and explain with some detail what are the differences between the two monads: Control.Monad.ST And Control.Monad.State ? They are both meant to model stateful computation but they are not the same monad. The first one represents state with in place update? Regards, Federico

8 9

ANNOUNCE: Haskell Communities & Activities Report (12th ed., May 2007)
by Andres Loeh 31 May '07

31 May '07

On behalf of the many, many contributors, I am pleased to announce that the Haskell Communities and Activities Report (12th edition, May 2007) http://www.haskell.org/communities/ is now available from the Haskell Communities home page in several PDF and HTML formats. Many thanks go to all the people that contributed to this report, both directly, by sending in descriptions, and indirectly, by doing all the interesting things that are reported. I hope you will find it as interesting a read as we did. If you haven't encountered the Haskell Communities and Activities Reports before, you may like to know that the first of these reports was published in November 2001. Their goal is to improve the communication between the increasingly diverse groups, projects and individuals working on, with, or inspired by Haskell. The idea behind these reports is simple: Every six months, a call goes out to all of you enjoying Haskell to contribute brief summaries of your own area of work. Many of you respond (eagerly, unprompted, and well in time for the actual deadline ;) ) to the call. The editor collects all the contributions into a single report and feeds that back to the community. When we try for the next update, six months from now, you might want to report on your own work, project, research area or group as well. So, please put the following into your diaries now: ---------------------------------------- End of October 2007: target deadline for contributions to the November 2007 edition of the HC&A Report ---------------------------------------- Unfortunately, many Haskellers working on interesting projects are so busy with their work that they seem to have lost the time to follow the Haskell related mailing lists and newsgroups, and have trouble even finding time to report on their work. If you are a member, user or friend of a project so burdened, please find someone willing to make time to report and ask them to `register' with the editor for a simple e-mail reminder in the middle of April (you could point me to them as well, and we can then politely ask if they want to contribute, but it might work better if you do the initial asking). Of course, they will still have to find the ten to fifteen minutes to draw up their report, but maybe we can increase our coverage of all that is going on in the community. Feel free to circulate this announcement further in order to reach people who might otherwise not see it. Enjoy! Andres Loeh <hcar at haskell.org> -- Haskell Communities and Activities Report (http://haskell.org/communities)

3 2

ANNOUNCE: xmonad 0.2
by Spencer Janssen 31 May '07

31 May '07

The xmonad dev team is pleased to announce the 0.2 release of: xmonad: a tiling window manager http://xmonad.org About: Xmonad is a tiling window manager for X. Windows are arranged automatically to tile the screen without gaps or overlap, maximising screen use. All features of the window manager are accessible from the keyboard: a mouse is strictly optional, greatly increasing productivity in X. Xmonad is written and extensible in Haskell, and custom layout algorithms, and other extesions, may be implemented by the user in config files. Layouts may be applied dynamically, and separate layouts can be used on each workspace. A guiding principle of the user interface is predictability: users should know in advance precisely the window arrangement that will result from any action, leading to an intuitive user interface. Features: * Automatic window tiling and management * First class keyboard support: a mouse is unnecessary * Full multihead/Xinerama support * XRandR support to rotate, add or remove monitors * Per-workspace layout algorithms * Per-screen non-built in status bars, with arbitrary geometry * Dynamic restart/reconfigure preserving workspace state * Tiny code base (~500 lines of Haskell) * Fast, small and simple. No interpreters, no heavy extension languages Since 0.1, the following notable features and bug fixes have appeared: New features: * XRandR support, for dynamically adding, removing or rotating monitors * State-preserving dynamic restart * Popup, customisable status bar support * Multiple clients may appear in the master pane * mod-shift-j/k, to swap windows with their neighbours * mod-n, to resize windows * User-specified layout algorithms may be written in config files * All layouts may be 'mirrored' (rotated) * configurable window border size and colour Design changes: * Reimplemented core of xmonad with a 'zipper' data type to track focus by construction. We believe this is a first. * Use of Neil Mitchell's 'catch' program to verify pattern match safety * Use of ReaderT and StateT to partition read-only and modifiable values * Custom layout messages handled with open data type simulation * More QuickCheck properties Bug fixes: * numlock handling is fixed More information, screenshots, documentation and community resources are available from: http://xmonad.org Xmonad is available from hackage, and via darcs. Happy hacking! The Xmonad Team: Spencer Janssen Don Stewart Jason Creighton Xmonad has also received patches from: Alec Berryman Chris Mears Daniel Wagner David Glasser David Lazar David Roundy Joe Thornber Miikka Koskinen Neil Mitchell Nick Burlett Robert Marlow Sam Hughes Shae Erisson

1 0

ANNOUNCE: The Reduceron
by Matthew Naylor 31 May '07

31 May '07

Dear Haskellers, You may be interested in the Reduceron: http://www-users.cs.york.ac.uk/~mfn/reduceron/index.html Here is a flavour: "The Reduceron is a processor for executing Haskell programs on FPGA with the aim of exploring how custom architectural features can improve the speed in which Haskell functions are evaluated. Being described entirely in Haskell (using Lava), the Reduceron also serves as an interesting application of functional languages to the design of complex control circuits such as processors. To program the Reduceron we provide a basic Haskell compiler, called Tred, that translates Yhc.Core programs into codes of the Reduceron's instruction set. The Tred compiler and Reduceron processor are in the early stages of development: they are both fairly naive, inefficient, and lacking in many important features. But they represent a good start, already capable of correctly compiling and executing (on FPGA) a reasonable range of Haskell programs." See webpage for more details. Matthew.

2 1

Re: [Haskell] Doubt about recursive functions
by Jim Burton 29 May '07

29 May '07

Eduardo01 wrote: > > Hi! First, nice to meet you guys. > My name's Eduardo(or call me Edward, easier for you). > Hi Eduardo, > I'm brazilian and computation science student. > I'm at first period and the main language i'm learning is Haskell and i > will learn C 'till the end of this period. > Great! Please use the haskell-cafe mailing list for these kind of questions, this one is used more for announcements and that sort of thing. > So, as the title suggest, my doubt about haskell is on recursive > functions, especifically where you have two arguments. Like this: > > Build a function that sum all the even numbers between the interval of n > and k, where n < k. > > I was doing this: > > somapar :: Int -> Int -> Int > somapar n k = if even n && even k > then somapar (n+1) (k-1) + n + k > else if even n && not(even k) > then somapar (n+1) (k-1) + n > else if not (even n) && even k > then somapar (n+1) (k-1) + k > else somapar (n+1) (k-1) > > I checked this out and think that is allright, but I don't have the stop > condition. So when i execute it, the function falls into an infinite loop. > The other thing is that I think that there are a lot of "ifs" in the > function, tell me if i could remove some of them. > You're right, somapar never returns a value -- at what point do you think it should? Try to work it out on pencil and paper for some small values. How do you keep track of what the current sum is? Also, check out some Haskell list functions, if you're allowed to use them for this -> http://www.haskell.org/ghc/docs/latest/html/libraries/base/Data-List.html . You can do away with the "ifs" with guards like f x | x > 0 = 1 | otherwise = 0 > > Well, that's it. Sorry by the so so english and thank you. > -- View this message in context: http://www.nabble.com/Doubt-about-recursive-functions-tf3831290.html#a10851… Sent from the Haskell - Haskell mailing list archive at Nabble.com.

1 0