- Haskell-Cafe - Haskell.org

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

GHC: compile using multiple cores?
by Peter Verswyvelen 09 Apr '09

09 Apr '09

Is it possible to use all CPU cores when compiling with GHC and/or Cabal?

5 5

ANN: network-bytestring 0.1.2
by Johan Tibell 09 Apr '09

09 Apr '09

I am pleased to announce a new release of network-bytestring, a Haskell library for fast socket I/O using ByteStrings. New in this release is support for scatter/gather I/O (also known as vectored I/O). Scatter/gather I/O provides more efficient I/O by using one system call to send several separate pieces of data and by avoiding unnecessary copying. I would like to thank Brian Lewis, Bryan O'Sullivan, and Thomas Schilling for contributing patches for this release. Get it: cabal install network-bytestring And on Hackage: http://hackage.haskell.org/cgi-bin/hackage-scripts/package/network-bytestri… Windows hackers needed: I've made sure that the library builds on Windows but since I don't use Windows myself I haven't implemented scatter/gather I/O support for Windows. It should be straightforward to add and I'd be happy to review the patches. Cheers, Johan

2 1

ghci *.hs
by Paul Keir 09 Apr '09

09 Apr '09

Hi all, I like to use ghci *.hs to start my session, but I then have to type :m +Main to bring the Main module into scope. Is there a command-line switch to control which modules are initially in scope with ghci? Thanks, Paul

2 1

Re: [Haskell-cafe] Referential Transparency and Monads
by Luke Palmer 09 Apr '09

09 Apr '09

2009/4/9 Mark Spezzano <mark.spezzano(a)chariot.net.au> > Or does RT ignore the encapsulated data and just view the “action” > performed by the monad as the “value” of the monad? > If I understand you right, this is more-or-less correct. You may as well think of IO as some sort of algebraic type that you are building and returning. A value of type "IO Integer" is not, itself, an integer. Thus: main = let r = print "hello" in return () Prints nothing. RT steps in in a similar scenario: main = let r = print "hello" in do { r; r } Replacing "r" with its definition: main = do { print "hello"; print "hello" } As expected. Luke > > Just curious as to the rationale behind referential transparency and how it > applies to monads. > > > > Cheers, > > > > Mark Spezzano > > > > No virus found in this outgoing message. > Checked by AVG. > Version: 7.5.557 / Virus Database: 270.11.48/2048 - Release Date: 8/04/2009 > 7:02 PM > > _______________________________________________ > Haskell-Cafe mailing list > Haskell-Cafe(a)haskell.org > http://www.haskell.org/mailman/listinfo/haskell-cafe > >

1 0

Re: [Haskell-cafe] Referential Transparency and Monads
by Paul Keir 09 Apr '09

09 Apr '09

I think this topic is covered in Andrew Gordon's dissertation/book: Functional programming and input/output by Andrew D. Gordon You can read it online. Cheers, Paul

1 0