- Haskell-Cafe - Haskell.org

Re[6]: [Haskell-cafe] Re: Wikipedia on first-class object
by Bulat Ziganshin 29 Dec '07

29 Dec '07

Hello Miguel, (i returned to cafe) >> as i've said in other letter, >> both computers and humans may be described using mathematics > Erm... What do you really mean by "may"? "can" > I'm pretty sure you can't > give such description right now - otherwise you should already have > several Nobel prizes. for description of computer? :) i mean that if humans are *physical* creatures then their behavior should obey physic laws which is described in mathematical language. so we should either recognize that mathematics can't be used to describe physical world (i.e. so-called Nature Laws are not exist) or that human, as any other physical object, obeys to these mathematical equations but according to your logic, anyone who says that Nature obeys to the laws, should publish all these laws immediately? > It seems reasonable that even if such > description is theoretically possible, no human would ever read it - > despite that it can be dropped to the Earth from UFO. it's true for whole Science - we can't read so-called Nature Laws from original, we can just believe in their existence and make assumptions about them based on experiments. but all our experiments (facts) are just finite of points - how we can draw whole function by several points? assumptions, assumptions... and we already know beautiful examples of scientists being wrong in their assumptions. to be exact, the whole history of science is history of replacing old wrong assumptions with new ones. even most well-known "laws" of Newtonian physics become obsolete just 300 years later so... my opponents use double-thinking at 100% - they believe in Nature Laws and free will, they love Science but sure that it cannot describe human. i don't mean personalities - it's just set of beliefs that society gives to each of us. moreover, every man should believe that he is thinking, but he should never really think and draw his own conclusion different from orthodox ones. it's double-thinking again. but society learn us that double-thinking is "inferior" (noone knows that is "inferiority" but we should avoid it). here set of beliefs obviously makes self-contradict and because we are teached to not be self-contradict, this at last end requires some personal selection. are you prefer to be self-contradict or not think, or something else - fortunately, society doesn't programmed us ho to make this choice. it's up to every one of us :) -- Best regards, Bulat mailto:Bulat.Ziganshin@gmail.com

2 1

Sending bottom to his room
by Cristian Baboi 29 Dec '07

29 Dec '07

In The Implementation of Functional Programming Languages by S.P. Jones, section 2.5.3, page 32 it is written: Eval [[*]] a b = a x b Eval [[*]] _|_ b = _|_ Eval [[*]] a _|_ = _|_ but in section 2.5.2 it is said that _|_ is an element of the value domain. What business does it have on the left side of the '=' ? Can you help me send him to his room ?

5 8

FFI question -- was: [Haskell-cafe] New slogan for haskell.org
by Steve Lihn 29 Dec '07

29 Dec '07

On Dec 11, 2007 11:16 PM, Don Stewart <dons(a)galois.com> wrote: > > 2. It offers strong support for integration with other languages and tools > > (FFI? Is the support strong?) > > 2. The FFI in Haskell is perhaps the most powerful out there. > You can import C or export Haskell to C with a single line FFI decl. > Don, I am a newbie on FFI, but have been interested in looking into it. If I google on "haskell FFI", what I find is typically: 1. The official Haskell 98 FFI 1.0 2. The FFI preprocessor -- greencard on haskell.org, where several other preprocessors are listed (in the Link section): HaskellDirect, C to Haskell, hsc2hs (included in GHC distributions), QForeign, KDirect. The FFI 1.0 API is certainly the most robust tool. However, the existence of preprocessors seem to suggest (at least very enticing) that the use of a preprocessor would make life easier. But when I dig deeper, several of them have not had any release in (more than) 3 years. The only exception seem to be "C to Haskell", which is part of gtk2hs, and hsc2hs, being part of GHC. It immediately becomes confusing which tool I should use if I were to work on a FFI project... Can you shed some light on this? Thanks, Steve

4 4

Interesting data structure
by Tim Docker 29 Dec '07

29 Dec '07

I'm using a control structure that's a variation of a monad and I'm interested in whether - it's got a name - it deserves a name (!) - anything else similar is used elsewhere Please excuse the longer post... I have two programs that need to interact with the outside world, and I want to constrain the nature of these interactions. I don't want to just sprinkle IO throughout the code. In the first program, I am reading on-demand from a database - just reading, not making any changes. In the second, I am requesting computations to be evaluated externally, in order to take advantage of a grid of machines. In both of these cases, the external requests don't change the state of the world, and the programs can be consided "pure" as long as the world isn't being changed by some other means. Hence the requests can be reordered, performed in parallel, and optimised in various ways without affecting the result. To make this concrete, if an external request has a type like: a -> m b where a is the input to the request, b is the response, and m is some monad, probably IO. Then a data structure capturing calculations over these requests, with result type c can be: data SCalc a b c = SCResult c | SCStage { sc_req :: a, sc_calc :: b -> SCalc a b c } The idea is that we either have a result, or we need to make a external request, whose response is used to generate a new calculation. "Running" such a calculation is straightforward: runSC :: (Monad m ) => SCalc a b c -> (a -> m b) -> m c runSC (SCResult v) _ = return v runSC (SCStage a cf) reqf = do b <- reqf a runSC (cf b) reqf and calculations can be sequence by making a monad instance: instance Monad (SCalc a b) where return = SCResult (>>=) (SCResult v) cf = cf v (>>=) (SCStage a cf1) cf = SCStage a (\b -> cf1 b >>= cf) Where it gets interesting, however, is that when they don't depend on each other, we can run these calculations in parallel. We need the ability to merge requests, and split responses. Hence, class Req a where merge :: a -> a -> a class Resp b where split :: b -> (b,b) par :: (Req a, Resp b) => SCalc a b c -> SCalc a b d -> SCalc a b (c,d) The par primitive above can be used to define other parallel operations, such as parList :: (Req a, Resp b) => [SCalc a b c] -> SCalc a b [c] I found it worthwhile to try and visualise what's going on here. Let's say I have 4 calculations that I want to run in parallel. The first doesn't need a request; the second needs to make a single request (A1); the third needs to make two requests where the second (B2) depends on the result of the first (B1), etc. The resulting parallel operations will be done in 3 batches, looking like: batch1 batch2 batch3 result calc1 ------------------------> V0 calc2 A1 ----------------> V1 calc3 B1 B2 -------> V2 calc4 C1 C2 C3 --> V3 (excuse the ascii art). batch1 will consist of A1,B1,C1 merged together; batch2 of B2,C3 merged; etc. In practice, I've used the above data types to abstract out database access in some reporting code. It works quite well, as use of the parallel primitive above means that the haskell code talking to the database sees all of the information in each batch simultaneously, so it can optimise the queries, remove redundant requests etc. It also makes the reporting code pure despite the fact that information is being loaded on demand from the db (without any unsafe calls behind the scene). I guess the use of the term "pure" here should be qualified: the impure code has been factored out to a single function in a different module that has a limited and well defined interface. I haven't implemented the grid calculation example described above, though I see that it ought to be able to work similarly, potentially removing duplicate calculation requests, etc. So my questions are: does this sort of "monad allowing parallel evaluation" structure have a name? Is it an existing design pattern in fp somewhere that I haven't seen? thanks, Tim

5 4

Doing some things right
by Don Stewart 29 Dec '07

29 Dec '07

"A Wake Up Call for the Logic Programming Community" Or what the logic programming community can learn from the Haskell community (in particular): http://www.cs.kuleuven.ac.be/%7Edtai/projects/ALP//newsletter/dec07/content… Interesting read! -- Don

13 23

Haskell-cafe reply-to etiquette
by Justin Bailey 29 Dec '07

29 Dec '07

When I joined the haskell-cafe mailing list, I was surprised to see the "reply-to" header on each message was set to the sender of a given message to the list, rather than the list itself. That seemed counter to other mailing lists I had been subscribed to, but I didn't think too much about it. Well, the comment below prompted me to ask the question - do people care? Personally, I like to respond to the "list", keeping discussions open by default and reducing (potential) spam on someone's inbox. As impersonal as email can be, it also seems a bit intrusive to write someone directly who I don't have a prior relationship with except for responding to some message they happened to post. Thoughts? ---------- Forwarded message ---------- From: Claus Reinke <claus.reinke(a)talk21.com> Date: Dec 26, 2007 2:07 PM Subject: Re: [Haskell] Re: ANNOUNCE: GHC version 6.8.2 To: "Benjamin L. Russell" <dekudekuplex(a)yahoo.com>, haskell(a)haskell.org [if this thread has to keep running, could you please drop me of the cc? and how did it manage to end up on haskell@ - that is the wrong list ] ....

6 5

Re: [Haskell-cafe] Doing some things right
by Miguel Mitrofanov 29 Dec '07

29 Dec '07

> > ? Kay's definition of OOP necessarily implies imperative behaviour. > OCaml has purely functional object update IIRC. That's OK, but it doesn't seem to agree with Kay's definition. Erlang definitely does.

1 0

Unbuffered character IO under Windows XP?
by Peter Schmitz 29 Dec '07

29 Dec '07

module Main(main) where import System.IO main = do b1 <- hGetBuffering stdin print b1 b2 <- hGetBuffering stdout print b2 -- not sure if these help, or are needed hSetBuffering stdin NoBuffering hSetBuffering stdout NoBuffering b1 <- hGetBuffering stdin print b1 b2 <- hGetBuffering stdout print b2 putStr "0" c <- getChar -- echoes during input by default putStr "1" -- want this output w/o hitting Enter hFlush stdout -- adding this does not help putStrLn [c] {------------------- Output: E:\ghcTest>ghc --version The Glorious Glasgow Haskell Compilation System, version 6.8.1 E:\ghcTest>ghc --make main [1 of 1] Compiling Main ( main.hs, main.o ) Linking main.exe ... E:\ghcTest>main LineBuffering LineBuffering NoBuffering NoBuffering 0a 1a E:\ghcTest> ----------------- Question: Is it possible to have unbuffered character IO under Windows XP? I would like to be able to type a single character and have the processing and IO continue without having to hit Enter. I.e., rather than this (had to hit Enter after typing the 'a' in '0a'): 0a 1a I would like to have this (without having to hit Enter after typing the char): 0a1a I have tried a few combinations of hSetBuffering and put/get Str/Char functions, without success. NOTE: I need to run under Windows XP, non-administrator account. This test was run using the normal XP shell cmd.exe. Thanks much in advance. -- Peter --------}

3 2

Re: [Haskell-cafe] Re: Wikipedia on first-class object
by Miguel Mitrofanov 29 Dec '07

29 Dec '07

> It sounds like a limit. xn --> x for n --> :-) Yeah, that's right. > How can I get that maximal value when I start from a non maximal one ? Not a problem. For example, "const 1" maps each value (even (_|_)) to the maximal value "1". > [1 .. ] and x=1:x are maximal ? Yes.

3 6

Re: [Haskell-cafe] Re: Wikipedia on first-class object
by Miguel Mitrofanov 28 Dec '07

28 Dec '07

> How can I test that partial order in Haskell ? You can't. It's kinda internal. More specifically, if you try to compute a value, which is not maximal in this order, you'll get an error or loop forever. But you still can use such values in your programs if you don't try to compute them. The point is, maximal values are the only interesting ones, and all others are just approximations. In fact, you only have to worry about non-maximal values when you use recursion. The fundamental property of Haskell is that it computes the least fixed point. For example, if f maps (_|_) to (_|_), then "let x = f x in x" will evaluate to (_|_) - and you loop forever, see above.

4 3