- Haskell-Cafe - Haskell.org

Composition, delegation and interfaces -- a 20K ft critique of Noop
by Greg Meredith 17 Sep '09

17 Sep '09

Dear Programmers, Someone just asked me to give my opinion on Noop's composition proposal<http://code.google.com/p/noop/wiki/ProposalForComposition>. It reminds me a little bit of Self<http://en.wikipedia.org/wiki/Self_%28programming_language%29>which found its way into JavaScript. It also reminds me a little of Haskell's type classes <http://en.wikipedia.org/wiki/Type_class>. In general, movement away from inheritance is good. The proposal, however, feels a bit like looking for the lost quarter where the light is good, rather than where you lost it. Before considering delegation machinery, let's consider the *value*of an interface. How many interfaces are there? One way to see that is just to consider all the sub interfaces of a single interface with n methods on it. Hmmm... that's 2^n interfaces. That's a lot. Does that give us any confidence that any one way of carving up functionality via interfaces is going to be sane? Further, in practice, do we see random distribution through this very large space? What we see over and over again in practice is that the answer to these questions is 'no!'. That means that there is *something* that binds a collection of methods together. What might that something be? One place to look is mathematics. Which maths should we look at? The maths of category has been very fruitful both in explaining existing functional programming techniques and -- perhaps more importantly -- suggesting ways to improve them as well as wholly new techniques. What we find in category theory is that it is natural to collect maps (read functions) together. A good example of such a beast is a monad. A monad -- viewed categorically -- is - a map, T, taking types to new types and functions on those types to new functions. Let's call the universe of types and functions expressible in our model of computation (as proscribed by our programming language), C. Then T : C -> C. - a higher order map, unit. Just like T takes C to C, we can understand a "noop" like map that takes C to C, call it Id. Then unit : Id -> T. We intuitively think about it as putting basic types inside the container T, but it's really a higher order map. - another higher order map, mult : T^2 -> T. We talk about it as a kind of flattening (and in Scala it's called flatMap), but it's a higher order map. Now, one is not finished spelling out a monad when giving this collection of maps. One must also show that they satisfy certain constraints. - T is functorial, meaning T g f = T(g) T(f) - unit and mult are natural transformations, look up the meaning because unpacking it here would take to long - mult( mult T ) = mult( T mult ) - mult( unit T ) = mult( T unit ) This set of constraints must go with the monad. This example provides a little more detail in terms of what binds a group of maps together, and hence of what *might* replace the notion of interface and *explain* what we see in practice. Good programmers invariably pick out just a few factorizations of possible interfaces -- from the giant sea of factorizations (read different ways to carve up the functionality). The reason -- i submit -- is because in their minds there are some constraints they know or at least intuit must hold -- but they have no good way at the language level to express those constraints. A really practical language should help the programmer by providing a way express and check the constraints that hold amongst the maps in an interface. i submit that this idea is not the same as "design by contract". i am not proposing an Eiffel-like mechanism. Again, taking a functional approach to computation via category theory leads one towards modeling interfaces as categorical "situations" like monads, comonads, distribution laws, etc. This means that a large number of the constraints come down to - functoriality - naturality - coherence Language support for this approach might include *keywords for these kinds of assertions*. It is a gnarly beast to offer automatic and/or compiler support for checking general constraints. Even this limited family of constraints that i'm proposing can generate some very difficult computations, with very bad complexity. However, for those situations where a general purpose solution to check assertions of functoriality, naturality and coherence are infeasible, one can use these hints to generate tests to probe for possible failures. This idea follows the in the same spirit of replacing proof with proof-checking. Of course, this is not the only way to go. i've yet to be convinced that category theory offers a good account of concurrency. Specifically, categorical composition does not line up well with concurrent composition. So, interfaces organized around types for concurrency is also something to consider. In this case, one might find a natural beginning in interfaces in which -- roughly speaking -- the methods constitute the tokens of a formal language the constructors of which are given by the types for concurrency paradigm. Best wishes, --greg On Thu, Sep 17, 2009 at 11:14 AM, Charles F. Munat <charles(a)munat.com>wrote: > http://code.google.com/p/noop/wiki/ProposalForComposition > -- L.G. Meredith Managing Partner Biosimilarity LLC 1219 NW 83rd St Seattle, WA 98117 +1 206.650.3740 http://biosimilarity.blogspot.com

1 0

Trouble installing leksah
by Gregory Propf 17 Sep '09

17 Sep '09

I now have the Haskell platform install problem solved but I'm now trying to get the leksah IDE installed and I'm getting this. runhaskell Setup configure Configuring leksah-0.6.1... Setup: At least the following dependencies are missing: glib >=0.10, gtk >=0.10, gtksourceview2 >=0.10.0 I am aware that these are actually C development libraries, not Haskell modules. The thing is that they are all installed, using the Ubuntu synaptic tool. This is Ubuntu 9.04. Is there something I need to tell cabal about where these libraries are?

3 3

ANNOUNCE: graphviz-2999.5.1.0
by Ivan Lazar Miljenovic 17 Sep '09

17 Sep '09

I'm pleased to announce version 2999.5.1.0 [1] of the graphviz library, which provides bindings to the GraphViz [2] suite of tools for drawing graphs. [1] http://hackage.haskell.org/package/graphviz-2999.5.1.0 [2] http://www.graphviz.org/ This is mainly a bug-fix release; as such, there is no API change (though if you use the graphvizWithHandle function in Data.GraphViz.Commands, you should ensure that your Handle -> IO a function closes the Handle when done). Changes in this release are: * Potentially fixed the graphvizWithHandle bug where warnings would be emitted about Handles not being closed correctly or too early; correct approach spotted by Nikolas Mayr. * Fixed up Parsing of various Attribute sub-values, especially Point and Spline (and hence Pos, which uses them). * Pre-process out comments and join together multi-line strings before parsing. * Properly parse Doubles like ".2". -- Ivan Lazar Miljenovic Ivan.Miljenovic(a)gmail.com IvanMiljenovic.wordpress.com

1 0

Re: Question about haskell.cs.yale.edu/
by Magnus Therning 17 Sep '09

17 Sep '09

Today I received the request below. At first the URL confused me, but apparently www.haskell.org is known under two names :-) The request should probably be handled by someone involved in ICFP. /M On Wed, Sep 16, 2009 at 11:53 PM, Peter Green <peter.green(a)frixo.com> wrote: > Hi, > > I was wondering whether you would be interested in linking to my website http://www.frixo.com from your page? > > http://haskell.cs.yale.edu/haskellwiki/icfp_2009_local_arrangements > > Frixo is a road traffic reporting site and think it may be a useful resource for your readers. It provides users with live traffic information and gets updated every 3 minutes using various road sensors. > > Thank you for your consideration. > > Kind Regards, > Peter > http://www.frixo.com > > -- Magnus Therning (OpenPGP: 0xAB4DFBA4) magnus＠therning．org Jabber: magnus＠therning．org http://therning.org/magnus identi.ca|twitter: magthe

1 0

GHC threaded runtimes and pure functions
by Gregory Propf 17 Sep '09

17 Sep '09

One of the things I liked about Haskell was the notion of pure functions and the fact that they can be, in theory, automatically parallelized on multicore hardware. I think this will become a huge deal in a few years as cores multiply. My question is simply this: under GHC is this what really happens with, say a mapping over a pure function. Yes, I compiled with --threaded and am using the +RTS -N2 options on my dual core machine. Here's the code I wrote as a speed test. It just doesn't seem any faster with -N2. Using the ps command I found that multiple threads are indeed launched (this is Linux) but all but one show as being in a state of waiting for some event to finish (the ps output flags them all 'Sl'. main = do rg <- getStdGen let rs = take 10000000 $ randomRs (1::Int,100000::Int) rg rs'= map (\n -> n*n) rs print rs'

4 6

Can't install Haskell Platform (Ubuntu 9.02)
by Gregory Propf 17 Sep '09

17 Sep '09

I'm trying to install the Haskell Platform. I'm using Ubuntu 9.02 and GHC 6.10.4 on a 64 bit AMD and keep getting this crap when I do 'make install'. The stuff builds OK and the script in question does indeed exist. Anybody know what this is. I've looked online and none of the other people with this issue seem to know the fix. Error: The mtl-1.1.0.2/Setup script does not exist or cannot be run

2 2

Parallel lazy zip
by Henning Thielemann 16 Sep '09

16 Sep '09

When reading http://www.macs.hw.ac.uk/~dsg/gph/papers/html/Strategies/strategies.html I got the impression, that when I want to compute in parallel I have to suppress laziness at all costs, otherwise only a neglible portion of the code is run in parallel. How can I parallelize the computation of two lazily generated lists, where the list generation is expensive, but the combination of the lists is cheap? For example: module Main where expensiveList :: Int -> [Int] expensiveList n = map (\m -> sum [n..m]) [10000000..] sequentialZip :: [Int] sequentialZip = zipWith (+) (expensiveList 1) (expensiveList 2) main :: IO () main = mapM_ print $ take 10 sequentialZip It seems to me that this program must run almost twice as fast when using two cores, because the expensive lists can be computed perfectly in parallel. It requires however, that the zipWith can fetch data lazily across threads. However applying a Parallel strategy to the expensive list, will certainly try to evaluate it completely.

2 1

Using tiny (atomic) mutables between multiple threads
by Belka 16 Sep '09

16 Sep '09

Hello, Haskell Cafe! I used an MVar to signalize to many threads, when it's time to finish their business (I called it a LoopBreaker). Recently I realized, that it might be too expensive (to use MVar) for cases when threads are many and all of them read my LoopBreaker intensively. This assumption appeared in a case, where I widely (in many threads) used my stopableThreadDelay, which checks LoopBreaker every d = 100 milliseconds. So I decided that I don't really need all the great features, that MVar provides, and that a simpler memory usage concept might be applied here. In a most (machinely) reduced view, all I need is a mutable byte. It would be thread safe, since reading and writing are atomic operations. I then wrote a simple experimental module (my first experience with Ptr in Haskell): ----------------- import Control.Monad import Foreign.Marshal.Utils import Foreign.Ptr import Foreign.Storable newtype MyVar a = MyVar { mvPtr :: Ptr a } newMyVar :: Storable a => a -> IO (MyVar a) newMyVar val = MyVar `liftM` new val readMyVar :: Storable a => (MyVar a) -> IO a readMyVar val = peek $ mvPtr val writeMyVar :: Storable a => (MyVar a) -> a -> IO () writeMyVar var val = poke (mvPtr var) val ----------------- Now, please, help me to answer few questions about all it: 1. Might readMVar really be computationally expensive under heavy load, (with all it's wonderful blocking features)? How much (approximately) more expensive, comparing to a assembler's "mov"? 2. Are the above readMyVar and writeMyVar really atomic? Or are they atomic only if I apply them to <MyVar Word8> type? 3. Are the above readMyVar and writeMyVar safe against asynchronous exceptions? Or again, only if I use <MyVar Word8> type? Belka -- View this message in context: http://www.nabble.com/Using-tiny-%28atomic%29-mutables-between-multiple-thr… Sent from the Haskell - Haskell-Cafe mailing list archive at Nabble.com.

11 17

Some question about c2hs.
by Andy Stewart 16 Sep '09

16 Sep '09

Hi all, I try to binding Haskell to VTE library. Below are Vte.chs file i wrote. I use c2hs with below command LANG=C c2hs -d trace -l $(pkg-config --cflags vte | sed 's/-I/-C-I/g') vte/vte.h Vte.chs generate Vte.hs file. When i compile Vte.hs file, i got below error: Vte.chs:67:89: Couldn't match expected type `Widget' against inferred type `()' Expected type: IO (Ptr Widget) Inferred type: IO (Ptr ()) In the second argument of `($)', namely `vte_terminal_new' In the second argument of `($)', namely `liftM (castPtr :: Ptr Widget -> Ptr Terminal) $ vte_terminal_new' for binding code: terminalNew :: IO Terminal terminalNew = makeNewObject mkTerminal $ liftM (castPtr :: Ptr Widget -> Ptr Terminal) $ {#call unsafe terminal_new#} In C code, fucntion `GtkWidget *vte_terminal_new(void);' return `IO (Ptr Widget), then i use castPtr transform (Ptr Widget) to (Ptr Terminal), right? Why GHC report function `vte_terminal_new` return `IO (Ptr ())', I do something wrong? Any help? Thanks! -- Andy

1 0

Haskell -> .NET
by Peter Verswyvelen 16 Sep '09

16 Sep '09

I heard that compiling Haskell to Java is not obvious since tail calls are not supported. .NET's intermediate language (IL) does support tail calls, however it is currently slower than regular calls, and is not always supported by all JITs. But given that F# will soon be officially released, I hope that eventually tail calls will work as expected, and fast See e.g. http://blogs.msdn.com/clrcodegeneration/archive/2009/05/11/tail-call-improv… So, might it be worth considering a .NET backend for a Haskell compiler? Peter Verswyvelen

5 5