- Haskell-Cafe - Haskell.org

Haskell meta-programming
by John Lato 28 Dec '11

28 Dec '11

> From: Heinrich Apfelmus <apfelmus(a)quantentunnel.de> > > * Meta-programming / partial evaluation. When designing a DSL, it is > often the case that you know how to write an optimizing compiler for > your DSL because it's usually a first-order language. However, trying to > squeeze that into GHC rules is hopeless. Having some way of compiling > code at run-time would solve that. Examples: > ** Conal Elliott's image description language Pan > ** Henning Thielemann's synthesizer-llvm I've been thinking about this, and I suspect that meta-programming in Haskell may not be that far off. Suppose you have a Meta monad data Meta a = Meta { runMeta :: a} with the magical property that the compiler will optimize/recompile expressions of type `Meta a` when they are run via `runMeta`. That would provide usable metaprogramming, and I think it would have all the desired type properties etc. Of course no compiler currently has that facility, but we could use a different monad, perhaps something like this: data ThMeta a = ThMeta { runThMeta :: Language.Haskell.TH.ExpQ } now we just need to get the compiler to run an arbitrary TH splice and check that the types match after `runThMeta` is called. I think this is already possible via the GHC api. It would have the undesirable property that some expressions could be ill-typed, and this wouldn't be known until run-time, but it's a start. That's about as far as I got before I discovered a much more worked-out version on Oleg's site (with Chung-chieh Shan and Yukiyoshi Kameyama). Of course they've tackled a lot of the awkward typing issues that my simple construct rudely pushes onto the user. I'm probably showing my naivety here, and I haven't fully digested their papers yet, but I wouldn't be surprised to see applications using Haskell metaprogramming within a relatively short time. John L.

2 1

Re: [Haskell-cafe] If you'd design a Haskell-like language, what would you do different?
by AUGER Cédric 28 Dec '11

28 Dec '11

Le Mon, 26 Dec 2011 19:30:20 -0800, Alexander Solla <alex.solla(a)gmail.com> a écrit : > So we give meaning to syntax through our semantics. That is what this > whole conversation is all about. I am proposing we give Haskell > bottoms semantics that bring it in line with the bottoms from various > theories including lattice theory, the theory of sets, the theory of > logic, as opposed to using denotational semantics' bottom semantic, > which is unrealistic for a variety of reasons. Haskell bottoms can't > be compared, due to Rice's theorem. Haskell bottoms cannot be given > an interpretation as a Haskell value. There is no problem with Rice Theorem, you can perfectly "compare" bottoms between them, all you cannot do is to make this "compare" function both "correct" and "complete" in Haskell. By correct, I mean "(⊥==⊥)≠False", and by complete, I mean "(⊥==⊥)≠⊥". But incompleteness is very common in Haskell, and correctness is the only "real worry" when computing (comparing two non terminating values, and expecting the comparison to terminate is a mistake from the programmer). On purely theoretical side (so not in Haskell), there is no problem either. For instance, the "halting-problem" can be turned into a mathematical function φ (ie., φ ∈ ⅋(TM×{true,false}) satisfying the criteria of functionnal total relation); the only thing is that this set is not "computable". > as opposed to using denotational semantics' bottom semantic, > which is unrealistic for a variety of reasons. Indeed, it is realistic, since in real world, things are not always expected to terminate, so we have to take this into account into the semantics. Don't forget that semantics is something "upper" Haskell evaluation, it is in the purely mathematical world and can rely on non computable things as far as they are consistent with the theory. That is you cannot define a complete and correct function in pure Haskell which takes a String which can be interpreted as a Haskell function, and return a String which can be interpreted as the semantics of the Haskell function. (Of course the following function would be correct: semantics :: String -> String semantics s = semantics s and this one would be complete semantics :: String -> String semantics s = [] and there is many possible functions which are complete and correct for many inputs and many possible functions which are correct and terminate for many inputs) > Haskell bottoms cannot be given an interpretation as a Haskell > value. As a lot of others said, Haskell bottoms ARE values, so they have an interpretation as a Haskell value (itself). If a whole community doesn't agree with you, either you are right and know it and should probably run away from this community or publish a well argumented book (you won't solve in 2 lines, what the community believes in for years) either the other case (you are right but not sure, or simply you are wrong) and in this case don't try to impose your point of view, rather ask questions on the points you don't understand. For me your actual behaviour can be considered as trolling. Note that I don't say the semantics you have in mind is "wrong", I only say that the semantics of ⊥ as described in the community's paper is not "wrong"; but two different "formal" semantics can exist which give the same "observationnal" semantics.

1 0

MIDI-controlled application
by Tim Baumgartner 28 Dec '11

28 Dec '11

Hi Haskellers! I'm writing my first non-trivial Haskell application. I have an electronic drum set that generates MIDI events that I process with Haskell. A simple application of this kind might have fixed drums associated with fixed commands (I've done that). The next step would be to display menus (with very large font...) that show commands and the associated drums. The menu structure should be derived from the commands active in each context. Up to this point, I implemented this already in Java. But now after some successful attempts in Haskell, I plan for more features: the user should ultimately be able to record his own "triggers", i.e. short drum rhythms, and associate them with actions. Since I'm still a beginner with only some basic experience in Monads, Arrows and their transformers, there is infinite knowledge to be gained by working on this problem (both library and concrete apps). Currently I'm using a monad that combines Parsec (with MIDI event stream) and a Writer (that writes commands that should result in IO). It's done in a way that during running the monad, many parses can be done and failing parses roll back the parser state so that a new parse can be tried. Now my questions: I have read about Yampa, but I have not mastered it yet. E.g. I don't understand switches. Could my "triggers" be realized with Yampa's events and switches? Would you recommend any other approach? Is there something similar somewhere? Regards Tim

5 6

How hard is it to start a web startup using Haskell?
by Gracjan Polak 28 Dec '11

28 Dec '11

Hi all, The question 'How hard is it to start a technical startup with Haskell?' happened a couple of times on this list. Sometimes it was in the form 'How hard is to find Haskell programmers?' or 'Are there any Haskell jobs?'. I'd like to provide one data point as an answer: http://www.reddit.com/r/haskell/comments/ngbbp/haskell_only_esigning_startu… Full disclosure: I'm one of two that founded this startup. How are others doing businesses using Haskell doing these days? -- Gracjan

9 13

GHC 7.4 and binutils-gold
by Michael Snoyman 27 Dec '11

27 Dec '11

Hi all, One other little GHC 7.4 note. When I first tried building code with it, I got the following error message: /usr/bin/ld: --hash-size=31: unknown option Once I uninstalled binutils-gold, everything went just fine. Has anyone else experienced this? I'm running Ubuntu Oneiric. Michael

2 1

GHC 7.4: Expected behavior or bug?
by Michael Snoyman 27 Dec '11

27 Dec '11

Thanks to Mark Wright for pointing this out[1]. We have the equivalent of the following code in persistent: {-# LANGUAGE MultiParamTypeClasses #-} data Key backend entity = Key class Monad (b m) => Foo b m where func :: b m (Key b m) This code works fine with GHC 7.0, but I get the following message from GHC 7.4: Expecting two more arguments to `b' In the type `b m (Key b m)' In the class declaration for `Foo' Is this expected behavior, or a bug? If the former, what would be a possible workaround? Thanks, Michael [1] https://github.com/yesodweb/persistent/issues/31

3 5

Haskell Platform and Windows - where's 2011.4?
by Steve Horne 27 Dec '11

27 Dec '11

On haskell.org, the 2011.4.0.0 version is shown as the current stable release - but the most recent download link is for the 2011.2.0.0 version. This is bugging me a little because the documentation in the 2011.2 Haskell Platform download for Windows is broken - there's at least one bug report about this already. There's online documentation, but it's (1) online, where I need something I can read on an old no-internet laptop, and (2) I assume for the most recent version, and therefore it potentially misleading. I already fixed the "online" side - sorry, I know slurping a whole site is evil but I had little choice. The fact that the docs relate to a version of the platform that I can't access remains. I just have to hope that the changes are few and won't affect me. Extra annoying - there's no mention of why 2011.4 is missing from the Windows download page - no "temporarily delayed" or "skipped due to an awkward technical issue" or "not enough Windows developers volunteering". For all I know, it could just be an oversight updating haskell.org itself, but I think that's unlikely. So... what's the situation with the Haskell Platform on Windows? - both WRT my specific bit of whinging and whining, and in general? Is Windows a low priority niche from the Haskell POV? If I intend to take Haskell more seriously, do I need to make Linux or some other *nix my primary OS? Please say no - I've been an on-and-off Linux user for around 10 years, with the most recent 2 years on ending around May this year. For all the pros, the cons of endless graphics card driver issues, awkward configuration hassles and so on have defeated me yet again.

3 4

[ANNOUNCEMENT] github 0.1.1
by Mike Burns 27 Dec '11

27 Dec '11

The Github API now has a fancy Haskell library for accessing it, and this library is named: github. http://hackage.haskell.org/package/github https://github.com/mike-burns/github The module structure reflects the Github API v3 documentation. It currently only supports the non-authenticated parts of the API. It does not support a few API endpoints which are documented by Github but which don't work under a command-line curl. I love pull requests, so send 'em!

1 0

ANNOUNCE: hxournal-0.5.0.0 - A pen notetaking
by Greg Weber 27 Dec '11

27 Dec '11

I got the program installed after creating the libstdc++.so symlink. No ink shows up from my drawing though. I am on a Thinkpad X201 Tablet and xournal works. I am glad you are experimenting with window splits. I think the worst part of xournal is it constrains you to a notebook-width piece of paper.

2 2

ANNOUNCE: xournal-convert-0.1
by Ian-Woo Kim 27 Dec '11

27 Dec '11

Hi, all, I have uploaded a utility program xournal-convert which is a command-line utility for changing xournal file format to various other formats. Currently, converting xournal file format (xoj) to several SVG files for each page and index.html for navigating all those pages are implemented. I will support more output formats as I implement. I think that SVG/html support must be useful to some people as it is now. This program depends on xournal-types, xournal-render and xournal-parser libraries which are also used for hxournal program ( a notetaking program written in haskell. similar to xournal) Installation should be simple. Just type > cabal update > cabal install xournal-convert In command line, you can run the program like > xournal-convert makesvg --dest=[destination folder] xojfilename Currently, this program only accepts gunzipped xoj file. For xoj file you generated from xournal program, you need to rename the file as xxx.xoj.gz (xxx is some filename) and gunzip xxx.xoj.gz to make gunzipped xoj format file. For files from hxournal, you can just use the file directly. By this program, you can simply generate static webpages for each xournal file. I personally found this useful for reading my notes on the web. Note: As for hxournal, the current version is 0.6.1.0. It currently supports pdf background and has undo/redo and smoother scrolling (not completed yet though). If you are interested, please try the latest version. Thank you for your interest. Happy holidays. best regards, Ian-Woo Kim

1 0