- Haskell-Cafe - Haskell.org

compilation related questions
by minh thu 10 Apr '09

10 Apr '09

Hi, There was a 'I want to write a compiler' thread recently. I wonder if there is such kind of pointers for compilation of strict functional languages (perhaps with lazy evaluation annotations) . Although GRIN is designed for lazy languages, would it be ok to use it for a strict one (and leverage its thunk representation for the lazy part of the language)? The 'whole program' optimization aspect is a plus. On a related note, I have another question. Say we have some data structure, for instance a list, some functions on this data structure (probably defined with some well known functions, such as map or fold), and a program using them. Is there any research trying to rewrite the program, and the data structure, to optimize them ? A contrived example is the length of a list : instead of traversing a list to know its length, the list can have an additional field which is incremented at each cons. Thanks, Thu

4 5

Ann: Yogurt-0.4
by Martijn van Steenbergen 10 Apr '09

10 Apr '09

Bonsoir café, It is my pleasure to announce version 0.4 of Yogurt, a functional MUD client. Version 0.4 makes Yogurt available as a standalone executable that is able to dynamically load and reload Yogurt scripts. Here is a small example of such a script: > module Minimal where > > import Network.Yogurt > > newmoon :: Session > newmoon = session > { hostName = "eclipse.cs.pdx.edu" > , portNumber = 7680 > , mudProgram = \reload -> do > mkCommand "reload" reload > } Valid scripts define at least one session which is used to connect to the MUD. mudProgram fields are provided with a reload action that when invoked reloads the script without interrupting the MUD connection. Of course, Yogurt also still offers hooks, timers, logging, variables and more. The executable is released as a separate package so that developers wishing to use just the "pure" machinery can do that without inheriting dependencies on the GHC API or readline library. To install the executable, run: $ cabal update $ cabal install Yogurt -freadline $ cabal install Yogurt-Standalone Yogurt's new home page can be found at: http://code.google.com/p/yogurt-mud/ And on hackage: http://hackage.haskell.org/cgi-bin/hackage-scripts/package/Yogurt http://hackage.haskell.org/cgi-bin/hackage-scripts/package/Yogurt-Standalone I would love to hear your feedback! Suggestions, complaints, comments, bug reports, experiences et cetera are all welcome. Kind regards, Martijn.

1 0

[Haskell-cafe] Paper: Translating donotation to SQL, Leijden, Meijer
by Günther Schmidt 10 Apr '09

10 Apr '09

Hi all, is the paper "Translating donotation to SQL, Leijden, Meijer (1999)" available anywhere? Günther

3 3

Re: [Haskell-cafe] Sequence differences
by michael rice 10 Apr '09

10 Apr '09

Clearly, I have some reading to do. Thanks, Michael --- On Fri, 4/10/09, Ketil Malde <ketil(a)malde.org> wrote: From: Ketil Malde <ketil(a)malde.org> Subject: Re: [Haskell-cafe] Sequence differences To: "michael rice" <nowgate(a)yahoo.com> Cc: "haskell Cafe mailing list" <haskell-cafe(a)haskell.org>, "Joe Fredette" <jfredett(a)gmail.com> Date: Friday, April 10, 2009, 3:52 PM michael rice <nowgate(a)yahoo.com> writes: > map :: (a -> b) -> [a] -> [b] <== I'm assuming this is correct This is the type of 'map', yes. Btw, ou can check types in GHCi with the :i command. > s f ls > > seems much like > > map f ls > > but instead looks like > > s :: (a -> a -> a) -> [a] -> [a] If you look at the definition: >> s f [] = [] >> s f [x] = [x] >> s f l = [ a f b | (a,b) <- zip (init l) (tail l)] You'll notice that the second clause, namely s f [x] = [x] produces the second parameter [x] (of type [a]) as its output, and thus the types must be the same as well. Also (assuming it is 'f a b' and not 'a f b' in the list comprehension), f is applied to two parameters, so it'll have to be of type (x -> y -> z), and since the two input parameters come from the originating list, x and y must be the same as a, and since we have seen the result list also has the same type, z must be the same as a, too. Thus f must have type (a -> a -> a). Unclear? Clear? Operating thetan? -k -- If I haven't seen further, it is by standing in the footprints of giants

1 0

Re: [Haskell-cafe] Re: Sequence differences
by michael rice 10 Apr '09

10 Apr '09

Yes, that is nice, and also useful for calculating moving averages. Thanks. Michael --- On Fri, 4/10/09, Chad Scherrer <chad.scherrer(a)pnl.gov> wrote: From: Chad Scherrer <chad.scherrer(a)pnl.gov> Subject: [Haskell-cafe] Re: Sequence differences To: haskell-cafe(a)haskell.org Date: Friday, April 10, 2009, 12:04 PM Joe Fredette <jfredett <at> gmail.com> writes: > We can write your original function in another, cleaner way though, too, > since zip will "zip" to the smaller of the two lengths, so you don't > need to worry about doing the init and the tail, so `s` is really: > > s _ [] = [] > s _ [x] = [x] > s f ls = [f a b | (a,b) <- zip ls (tail ls)] > > but there is a function which does precisely what the third case does, > called "zipWith" which takes a > binary function and two lists and -- well -- does what that list > comprehension does. In fact, it does > what your whole function does... In fact, it _is_ your function, > specialized a little, eg: > > yourZipWith f ls = zipWith f ls (tail ls) A nice generalization of this that can be really useful is movingWindow :: Int -> [a] -> [[a]] movingWindow 1 xs = map (:[]) xs movingWindow n xs = zipWith (:) xs . tail $ movingWindow (n-1) xs So for example, > movingWindow 3 [1..10] [[1,2,3],[2,3,4],[3,4,5],[4,5,6],[5,6,7],[6,7,8],[7,8,9],[8,9,10]] Then you can write diff :: (Num a) => [a] -> [a] diff = map (\[x,y] -> y - x) . movingWindow 2 Hopefully the intermediate lists are optimized away, but I haven't done any performance testing. Chad _______________________________________________ Haskell-Cafe mailing list Haskell-Cafe(a)haskell.org http://www.haskell.org/mailman/listinfo/haskell-cafe

1 0

Re: [Haskell-cafe] Sequence differences
by michael rice 10 Apr '09

10 Apr '09

All very neat, and it works! Thanks. But I copied map :: (a -> b) -> [a] -> [b] <== I'm assuming this is correct from something called "A Tour of the Haskell Prelude" at http://undergraduate.csse.uwa.edu.au/units/CITS3211/lectureNotes/tourofprel… which I was looking at to try and roll my own typing. My next question: My function s f ls seems much like map f ls but instead looks like s :: (a -> a -> a) -> [a] -> [a] Clearly, there's more to the picture than meets the eye. Is there a good tutorial on types? Michael --- On Fri, 4/10/09, Joe Fredette <jfredett(a)gmail.com> wrote: From: Joe Fredette <jfredett(a)gmail.com> Subject: Re: [Haskell-cafe] Sequence differences To: "michael rice" <nowgate(a)yahoo.com>, "haskell Cafe mailing list" <haskell-cafe(a)haskell.org> Date: Friday, April 10, 2009, 2:07 AM So, we can walk through it- > s f [] = [] > s f [x] = [x] > s f l = [ a f b | (a,b) <- zip (init l) (tail l)] First, we can write some of it to be a little more idiomatic, viz: s _ [] = [] s _ [x] = [x] s f ls = [f a b | (a,b) <- zip (init ls) (tail ls)] First, we have a function type, we can tell the variable f is a function because it's applied to arguments in the third case, since it's applied to two arguments, it's binary, so `s :: (a -> b -> c) -> ?` however, from the second case, we know that whatever the type of the second argument (a list of some type `a1`) is also the type of the return argument, since the `s` acts as the identity for lists of length less than 2, so s :: (a -> b -> a1) -> [a1] -> [a1] However, since the arguments for `f` are drawn from the same list, the argument types must _also_ be of type `a1`, leaving us with: s :: (a -> a -> a) -> [a] -> [a] This is, interestingly enough, precisely the type of foldr1. We can write your original function in another, cleaner way though, too, since zip will "zip" to the smaller of the two lengths, so you don't need to worry about doing the init and the tail, so `s` is really: s _ [] = [] s _ [x] = [x] s f ls = [f a b | (a,b) <- zip ls (tail ls)] but there is a function which does precisely what the third case does, called "zipWith" which takes a binary function and two lists and -- well -- does what that list comprehension does. In fact, it does what your whole function does... In fact, it _is_ your function, specialized a little, eg: yourZipWith f ls = zipWith f ls (tail ls) Hope that helps /Joe michael rice wrote: > I have a Scheme function that calculates sequence differences, i.e., it returns a sequence that is the difference between the 2nd and the 1st element, the 3rd and the 2nd, the 4th and the 3rd, etc. > > (define s > (lambda (f l) > (cond ((null? (cdr l)) '()) > (else (cons (f (cadr l) (car l)) > (s f (cdr l))))))) > > where > > (s - '(0,1,3,6,10,15,21,28)) => (1,2,3,4,5,6,7) > > > I'm thinking the same function in Haskell would be something like > > s :: > s f [] = [] > s f [x] = [x] > s f l = [ a f b | (a,b) <- zip (init l) (tail l)] > > > but can't figure out what the function typing would be. > > Michael > > > ------------------------------------------------------------------------ > > _______________________________________________ > Haskell-Cafe mailing list > Haskell-Cafe(a)haskell.org > http://www.haskell.org/mailman/listinfo/haskell-cafe >

5 4

Re: [Haskell-cafe] Sequence differences
by michael rice 10 Apr '09

10 Apr '09

No, I was unaware of this, but it looks good. Thanks. Michael --- On Fri, 4/10/09, Martijn van Steenbergen <martijn(a)van.steenbergen.nl> wrote: From: Martijn van Steenbergen <martijn(a)van.steenbergen.nl> Subject: Re: [Haskell-cafe] Sequence differences To: "michael rice" <nowgate(a)yahoo.com> Cc: "haskell Cafe mailing list" <haskell-cafe(a)haskell.org>, "Joe Fredette" <jfredett(a)gmail.com> Date: Friday, April 10, 2009, 11:38 AM Hi Michael, michael rice wrote: > Clearly, there's more to the picture than meets the eye. Is there a good tutorial on types? Have you seen Real World Haskell? http://book.realworldhaskell.org/read/ Chapter 2 already dives into types. Hope this helps, Martijn.

1 0

Re: [Haskell-cafe] Referential Transparency and Monads
by Jason Dusek 10 Apr '09

10 Apr '09

2009/04/09 Mark Spezzano <mark.spezzano(a)chariot.net.au>: > How exactly do monads “solve” the problem of referential transparency? I > understand RT to be such that a function can be replaced with a actual > value. With referential transparency, an **expression** can be replaced with an evaluated variant of itself. When we choose to do the evaluation is not important. So we have some function: f :: SomeType -> SomeOther -> YetAnother -> SomethingElse One time, when we encounter `f a b c` and evaluate it to get `d`. Now whenever we see `f a b c` again, referential transparency tells us we can just stick the `d` right there and not bother about running the program that is inside `f`. What you have with the IO monad is things that look like the same expression but actually aren't; you also have rules of evaluation that force the reduction strategy to reduce things in order. Consider this: main = do c0 <- getChar c1 <- getChar print c1 At first glance, Pooh (or even Owl) might say, "The first `getChar` is just the same as the second.". Doesn't referential transparency say that we should just evaluate it one time and thus get only the first character in the stream? Well, no. Doesn't laziness say, we only need `c1` so we'll just read the first character off the stream? No again. The do notation is a great convenience; it is syntax transformed to this: main = getChar >>= (\c0 -> (getChar >>= (\c1 -> print c1))) We see right away that, in order to get at the second `getChar`, we need to provide an argument to the first lambda. Likewise, to get at the `print`, we need to provide an argument to the second lambda. The `>>=` is called "bind" and plays an essential role here. Each monad has its own bind -- bind is an integral part of its evaluation strategy. Let us consider a simplified implementation of the IO monad: data World = World ... data IO t = IO (World -> (t, World)) Every value of type `IO t` contains a function that takes us from `World` to a pair of `World` and `t`. The `World` is not important beyond the notion that no two are alike. Our implementation of `>>=` (also simplified compared to a real one): >>= :: IO a -> (a -> IO b) -> IO b IO act1 >>= f = IO (\w1 -> let { (t, w2) = act1 w1 ; IO act2 = f t } in act2 w2) Then we have `getChar` and `print`: getChar = IO charOp {- `charOp` is some unsafe operation that does the getting. -} print something = IO (printOp something) {- `printOp` is some unsafe operation that does the printing. -} Now let's substitute that into the above and see what we get: main = getChar >>= (\c0 -> (getChar >>= (\c1 -> print c1))) main = IO charOp >>= (\c0 -> (getChar >>= (\c1 -> print c1))) main = IO (\w1 -> let (c, w2) = charOp w1 IO act2 = (\c0 -> (getChar >>= (\c1 -> print c1))) c in act2 w2 ) main = IO (\w1 -> let (c, w2) = charOp w1 IO act2 = (getChar >>= (\c1 -> print c1)) in act2 w2 ) Let's work on just `act2`: IO act2 = (getChar >>= (\c1 -> print c1)) IO act2 = (IO charOp >>= (\c1 -> print c1)) IO act2 = IO (\w -> let (c', w3) = charOp w IO act3 = (\c1 -> print c1) c' in act3 w3 ) IO act2 = IO (\w -> let (c', w3) = charOp w IO act3 = print c' in act3 w3 ) IO act2 = IO (\w -> let (c', w3) = charOp w IO act3 = IO (printOp c') in act3 w3 ) IO act2 = IO (\w -> let (c', w3) = charOp w in (printOp c') w3 ) IO act2 = IO (\w -> let (c', w3) = charOp w in (printOp c') w3) Substituting: main = IO (\w1 -> let (c, w2) = charOp w1 IO act2 = IO (\w -> let (c', w3) = charOp w in (printOp c') w3) in act2 w2 ) main = IO (\w1 -> let (c, w2) = charOp w1 in (\w -> let (c', w3) = charOp w in (printOp c') w3) w2 ) main = IO (\w1 -> let (c, w2) = charOp w1 in let (c', w3) = charOp w2 in (printOp c') w3 ) So we let's review. Are the two `getChar`s the same expression? No -- one is called against one world, the other against another. Furthermore, they are ordered -- we need the world from the first one to get the world from the second. We need the second world to `print`. This is guaranteed by the semantics of "bind" in the IO monad. The expressions are not the same so referential transparency does not does not lead to dangerous elision; the data dependencies are explicit and so there is no way to re-order the evaluation of the expressions. Notice that these properties fall out of our rules for evaluation and not any "special sauce" for monads. > Just curious as to the rationale behind referential > transparency and how it applies to monads. That depends on the monad. -- Jason Dusek

1 0

Crashing - First Graphics Program in Haskell School of Expression(HSOE)
by Raja Koduru 10 Apr '09

10 Apr '09

Hi, I am a beginner. Help me. Here is my "main.hs", sample code from the book HSOE. ---------------------------------------------------------------- module Main where import SOE main = runGraphics ( do w <- openWindow "My First Graphics Program" (300, 300) drawInWindow w (text (100, 100) "Hello Graphics World") k <- getKey w closeWindow w ) ------------------------------------------------------------------ When this is run, a window pops up but it immediately crashes. I call "main" function after loading the above src file (main.hs) in ghci I am on XP, using GHC-6.10.2. It crashed on GHC-6.10.1 also. I downloaded the HSOE code from here: http://haskell.org/soe/software1.htm Used cabal to install OpenGL(-2.2.1.1) and GLFW(0.3). ghc-pkg list output: d:/ghc/ghc-6.10.2\package.conf: Cabal-1.6.0.3, GLFW-0.3, HUnit-1.2.0.3, OpenGL-2.2.1.1, QuickCheck-1.2.0.0, Win32-2.2.0.0, array-0.2.0.0, base-3.0.3.1, base-4.1.0.0, bytestring-0.9.1.4, containers-0.2.0.1, directory-1.0.0.3, (dph-base-0.3), (dph-par-0.3), (dph-prim-interface-0.3), (dph-prim-par-0.3), (dph-prim-seq-0.3), (dph-seq-0.3), filepath-1.1.0.2, (ghc-6.10.2), ghc-prim-0.1.0.0, haddock-2.4.2, haskell-src-1.0.1.3, haskell98-1.0.1.0, hpc-0.5.0.3, html-1.0.1.2, integer-0.1.0.1, mtl-1.1.0.2, network-2.2.1, old-locale-1.0.0.1, old-time-1.0.0.2, packedstring-0.1.0.1, parallel-1.1.0.1, parsec-2.1.0.1, pretty-1.0.1.0, process-1.0.1.1, random-1.0.0.1, regex-base-0.72.0.2, regex-compat-0.71.0.1, regex-posix-0.72.0.3, rts-1.0, stm-2.1.1.2, syb-0.1.0.1, template-haskell-2.3.0.1, xhtml-3000.2.0.1 ----------------------------------------------------------------------------------------- regards, raja

2 1

WX: linking to system libraries statically
by FFT 10 Apr '09

10 Apr '09

I noticed that even simple WX demos like "Layout" are linked dynamically against 59 libraries on Linux. This would make distributing the binaries a nightmare. Is there a simple way to make a (mostly) statically linked binary?

3 2