- Haskell-Cafe - Haskell.org

how implement a UArray with a ForeignPtr?
by David Roundy 19 Jul '03

19 Jul '03

Hello. I was wondering if there might be any relatively simple way to implement a type equivalent to UArray, but with the memory stored in a ForeignPtr? It seems like this would be a commonly useful situation, where you have a C function that returns a pointer to an array of data, and it would be nice to be able to access that data without making a copy of it. In case you're wondering, the reason for not allocating the memory within haskell itself and passing it to the C side is that I want to use mmap, which really needs its own finalizer. >From browsing the ghc base libraries, it looks like I'll pretty much just need peekElemOff and unsafePerformIO (which should be safe as long as I don't give a copy of the ForeignPtr to anyone else who might try to write to it--and provided the file isn't opened for write while I'm trying to read it). Does this sound like the right idea, or is there some problem? Might this actually turn out to be slow, which would defeat the whole purpose? -- David Roundy http://www.abridgegame.org

2 1

PARCELAS PUNTA DE CHOROS O $2.000.000 SOLO JULIO Consulte Facilidades
by Tu Tierra 18 Jul '03

18 Jul '03

OFERTA DE INVIERNO PARCELAS PUNTA DE CHOROS CHILE VALOR PARCELA $2.000.000 CHILE CHILE A solo 120 km al norte de La Serena Parcelas de 5075 m2 Fono 09-7979918 -51-311479 Un Entorno Privilegiado de Flora y Fauna A Minutos de la Caleta de Punta de Choros Escritura Inmediata www.tutierra.cl A 2500 Metros de la Playa Grande www.tutierra.cl PROMOCIÓN VENTA DE INVIERNO VALOR PARCELA $2.000.000 USTED DEFINE EL PIE DIFERENCIA 15 CHEQUES TOME SU CUPO OFERTA HASTA EL 31 DE JULIO FORMULARIO DE CONSULTAS AL CONSULTAR RECIBIRÁ TODA LA INFORMACIÓN DEL LOTEO, FOTOGRAFÍAS ANTECEDENTES LEGALES, EMPLAZAMIENTO, UBICACIÓN Y ANTECEDENTES GENERALES PARCELAS DE AGRADO PUNTA DE CHOROS WWW.TUTIERRA.CL VENTA(a)TUTIERRA.CL 09-7979918 SI NO DESEA RECIBIR MAS INFORMACIÓN COMUNIQUESE A ESTE MAIL no deseo recibir mas información (Nota: la legislación chilena no contempla el envío de publicidad por correo electrónico. Respetamos la normativa internacional que establece que ningún e-mail puede considerarse SPAM si se le estipula a las personas instrucciones precisas de como removerse de esta lista

1 0

Case expressions, matching, and "constants"
by Bayley, Alistair 18 Jul '03

18 Jul '03

I've just debugged a program that used a case expression, but where I was trying to match on constants rather than literals. Here's a contrived example: > module Main where > one = 1 > two = 2 > > test n = > case n of > one -> "one" > two -> "two" > _ -> "three" > > main = putStrLn (test 2) This initial version seems to me to be the "natural" way to write the case expression, but it doesn't work because the first alternative always succeeds. This is what I've turned it into to get it to work. It seems a bit clumsy; is there a better way to write this? > test n = > case True of > _ | n == one -> "one" > | n == two -> "two" > | otherwise -> "three" ***************************************************************** The information in this email and in any attachments is confidential and intended solely for the attention and use of the named addressee(s). This information may be subject to legal professional or other privilege or may otherwise be protected by work product immunity or other legal rules. It must not be disclosed to any person without our authority. If you are not the intended recipient, or a person responsible for delivering it to the intended recipient, you are not authorised to and must not disclose, copy, distribute, or retain this message or any part of it. *****************************************************************

5 4

new debian packages and archive: haskell experimental
by Isaac Jones 18 Jul '03

18 Jul '03

Greetings, I've set up a Debian archive (apt source) for experimental Haskell packages and backports. For instance, in the "unstable" section, you might find bleeding edge packages which will eventually be uploaded to Debian if they work (like the arrow preprocessor). In the "stable" section, you'll find ghc6 and newer versions of ghc5 than what you'll find in the official Debian archives (thank Ian Lynagh for the ghc work). See the last section of the Debian Haskell User's Wiki Page for more info including information about how you can contribute packages: http://www.haskell.org/hawiki/DebianUsers People using Debian Stable (woody) can install ghc6 by adding this line to your /etc/apt/sources.list file: deb http://www.syntaxpolice.org/haskell-experimental/ stable/ then run "apt-get update && apt-get install ghc6" (perhaps these instructions can be included on ghc6's web page?) If you're running anything besides stable, you know what to do :) peace, isaac

4 3

Re: infinite types
by blaat blaat 17 Jul '03

17 Jul '03

Oh yeah, and the person who _guesses_ what ex6 does in the supplied code wins a chocolate bar supplied by me ;-) Cheers, l4t3r _________________________________________________________________ Add photos to your messages with MSN 8. Get 2 months FREE*. http://join.msn.com/?page=features/featuredemail

1 0

Re: infinite types
by blaat blaat 17 Jul '03

17 Jul '03

Uhm, of to my holliday in France. But, ah, oh, the joy of programming ;-). I thought I would humor this list by showing where the infinite types (is it?) discussion ended. I found it quite nice and the code is short so here goes ;-) To test: save the mail after the marker and run it in Hugs. There are some examples at the end of the file. ------- cut from here, save as "Reactive.hs" --------------------------------- -- A reactive system is modelled by the type -- -- R m = m -> (Nottaken | Taken (R m) [m]) -- -- It is _not_ a coalgebraic definition, it is _not_ an arrow, it is -- a recursive type in this case used to model asynchronous message -- passing systems. -- -- A system may be thought of as collection of (UML) -- transitions: s0 - event[guard]/action* -> s1 where states are -- hidden in the transitions, and a next-state is a transition, -- or something, I guess. Uhm, huh? ;-) -- -- Note that no explicit distinction between in- and output messages -- is made. This allows liberal, although slightly odd ;-), structural -- composition operators a la Broy, Bird-Meertens, Arrows, Fudgets, -- whatever. In a nutshell: stream processing functions. -- -- After reading the following oddball operators, you, uhm, might -- really want to define your own. Really ;-) -- -- This formalization has weak algebraic rules on the composition -- operators. -- -- Load this code in hugs and test the examples by typing ex0 to -- ex6. module Reactive where type R m = m -> Response m data Response m = Nottaken | Taken (R m) [m] ---------------------------------------------------------------------- -- -- onTaken: helper function onTaken::Response m -> (R m -> [m] -> a) -> a -> a onTaken Nottaken f g = g onTaken (Taken s oo) f g = f s oo ---------------------------------------------------------------------- -- -- The behavior of a system is, of course, a mapping from an input -- stream of messages to an output stream of messages. behavior::R m->[m]->[m] behavior s [] = [] behavior s (i:ii) = onTaken (s i) (\s0 oo-> oo ++ behavior s0 ii) (i:behavior s ii) ---------------------------------------------------------------------- -- Copy is a simple system which copies all input to its output. -- -- +++++ -- + + -- +++++ ---------------------------------------------------------------------- copy::R m copy m = Taken copy [m] ---------------------------------------------------------------------- -- Lift is a simple system which is the lifting of a function from -- messages to messages to a reactive system. -- -- +++++++++ -- + ^ + -- + f + -- + + -- +++++++++ ---------------------------------------------------------------------- lift::(m->m) -> R m lift f m = Taken (lift f) [f m] ---------------------------------------------------------------------- -- -- If we have a system on messages of type b, and translator functions -- between another type a, we can change the interface to a system -- on messages of type a. (This is a solution for not -- making an explicit distinction between input and output messages; -- now we can partition the messages of subsystems) -- -- +++++++++ -- + + -- + s:R a +:R b -- + + -- +++++++++ interface::(a->b)->(b->a)->R b->R a interface t f s i = onTaken (s (t i)) (\s1 oo->Taken (interface t f s1) (map f oo)) (Nottaken) ---------------------------------------------------------------------- -- -- The parallel composition of two systems s and r is the system which -- if s takes an input then makes s process it, otherwise if r takes an -- input then makes r process it, otherwise does not process it. -- -- Supposed to model the parallel composition of a collection of -- event handlers (like: sound subsystem, graphics subsystem, etc). -- -- +++++ -- + s + -- + + + -- + r + -- +++++ -- -- ( (a <+> b) <+> c = a <+> (b <+> c) ) parallel::R m->R m->R m parallel s0 s1 i = onTaken (s0 i) (\s2 oo->Taken (parallel s2 s1) oo) (onTaken (s1 i) (\s2 oo->Taken (parallel s0 s2) oo) (Nottaken)) infixr 5 <+> (<+>) = parallel ---------------------------------------------------------------------- -- -- The sequential composition of systems s and r takes an input if -- s accepts the input and then makes r process all output of s. -- All output by s which is not taken by r _passes through_ r. -- -- Supposed to model pipes (where exceptions or messages to the -- outside world leak through). -- -- -- +++++++ -- + s.r + -- +++++++ -- -- ( (a <.> b) <.> c = a <.> (b <.> c) ) -- sequential::R m->R m->R m sequential s0 s1 i = onTaken (s0 i) (\s2 oo-> onTaken (seqloop s1 oo) (\s3 oo1-> (Taken (sequential s2 s3) oo1)) (Nottaken)) (Nottaken) seqloop::R m->[m]->Response m seqloop s [] = Taken s [] seqloop s (i:ii) = onTaken (s i) (\s1 oo0-> onTaken (seqloop s1 ii) (\s2 oo1 -> Taken s2 (oo0++oo1)) (Nottaken)) (onTaken (seqloop s ii) (\s1 oo -> Taken s1 (i:oo)) (Nottaken)) infix 6 <.> (<.>) = sequential ---------------------------------------------------------------------- -- -- Feedback on a system s feeds _all_ output of s back to s. All -- output which is not accepted by s _passes through_ s (and the -- loop). -- -- Feedback folds all the transitions taken over fed back output -- into _one_ big transition... -- -- +++++ -- -+-++ s +-+-- -- | +++++ ^ -- +--------+ ---------------------------------------------------------------------- feedback::R m->R m feedback s i = onTaken (s i) (\s0 oo0-> onTaken (feedloop s0 oo0) (\s1 oo1-> Taken (feedback s1) (oo1)) (Nottaken)) (Nottaken) feedloop::R m->[m]->Response m feedloop s [] = Taken s [] feedloop s (i:ii) = onTaken (s i) (\s0 oo-> feedloop s0 (ii++oo)) (onTaken (feedloop s ii) (\s0 oo -> Taken s0 (i:oo)) (Nottaken)) feed = feedback ---------------------------------------------------------------------- -- small examples: ---------------------------------------------------------------------- test s = take 40 (behavior s (repeat 1)) ex0 = test copy ex1 = test (lift (*2) <.> lift ((-)1)) ex2 = test (lift (+1) <+> lift (*2)) ex3 = test (lift (+2) <+> copy <.> lift (+3)) ex4 = test (feed copy) -- infinite computation ex5 = test (interface (\i->'a') (\a->5) copy) ---------------------------------------------------------------------- -- bigger example: ---------------------------------------------------------------------- data Msg = Tick | Out Int | Add Int | AddResult Int | Write Int Int | Fetch Int | Read Int Int deriving (Show) add::Maybe Int -> R Msg add Nothing (Add j) = Taken (add (Just j)) [] add (Just i) (Add j) = Taken (add Nothing ) [AddResult (i+j)] add _ _ = Nottaken register::Int->Int->R Msg register i _ (Write j r) | i == j = Taken (register i r) [] register i r (Fetch j) | i == j = Taken (register i r) [Read i r] register _ _ _ = Nottaken controller::R Msg controller Tick = Taken controller [Fetch 0, Fetch 1] controller (Read i j) = Taken controller [Add j, Write (1-i) j] controller (AddResult i) = Taken controller [Out i, Write 1 i] controller _ = Nottaken ex6 = test (interface (\_->Tick) (\(Out i)-> i) (feed (register 0 0<+>register 1 1<+>add Nothing<+>controller))) ---------------------------------------------------------------------- -- This code is licensed under the Big-Kazooba-Ritual license: -- -- You may copy, modify or distribute this software provided that -- you first perform the ritual described in section a. -- -- If you ever meet one of the authors of this work you can be asked, -- and must comply, to perform the ritual as described in section a. -- -- You must add this license to any derivatives of this work. -- -- a. Lift your left leg, close your eyes and jump in the air. -- Now tap the point of your nose exactly two times with your -- right index finger. To complete: say the words -- "thank you Big Kazooba" -- -- You may open your eyes now. -- -- The disabled may opt not to perform this ritual but have a -- volunteer perform the ritual on their behalf. -- -- Anyone, of suited position, may opt to command any number of -- subordinates to perform the ritual instead. -- -- Thank you, -- l4t3r ---------------------------------------------------------------------- _________________________________________________________________ MSN 8 helps eliminate e-mail viruses. Get 2 months FREE*. http://join.msn.com/?page=features/virus

1 0

RE: Hugs Humor
by Simon Marlow 17 Jul '03

17 Jul '03

Jerzy Karczmarczuk writes: > I am abhorred by the fact that adding ... :: Rational > changes the lexical meaning of a literal. It doesn't. A literal with a decimal point always means (fromRational (X%Y)) for some appropriate X and Y. Adding a type signature changes the dynamic meaning of the literal, not the lexical meaning (something we're used to in Haskell, no?). Cheers, Simon

1 0

Re: Case expressions, matching, and "constants"
by Graham Klyne 17 Jul '03

17 Jul '03

At 12:03 17/07/03 +0100, Bayley, Alistair wrote: >This is what I've turned it into to get it to work. It seems a bit clumsy; >is there a better way to write this? > > > test n = > > case True of > > _ | n == one -> "one" > > | n == two -> "two" > > | otherwise -> "three" The 'case' is somewhat redundant. How about: > test n | n == one = "one" > | n == two = "two" > | otherwise = "three" #g ------------------- Graham Klyne <GK(a)NineByNine.org> PGP: 0FAA 69FF C083 000B A2E9 A131 01B9 1C7A DBCA CB5E

1 0

Worldwide Partners program
by The TechNews 17 Jul '03

17 Jul '03

The TechNews, July 2003 Production Mini-plants in mobile containers. Worldwide Partners program Science Network will supply to countries and developing regions the technology and necessary support for production in series of Mini-plants in mobile containers (40-foot). The Mini-plant system is designed in such a way that all the production machinery is fixed on the platform of the container, with all wiring, piping, and installation parts; that is, they are fully equipped... and the mini-plant is ready for production." More than 700 portable production systems: Bakeries, Water purification, Dehydrated food, Steel Nails, Fruit juice preparation, Tire Retreading, Reinforcement Bar Bending for Construction Framework, Sheeting for Roofing, Ceilings and Façades, Plated Drums, Aluminum Buckets, Injected Polypropylene Housewares, Pressed Melamine Items (Glasses, Cups, Plates, Mugs, etc.), Mufflers, Construction Electrically Welded Mesh, Plastic Bags and Packaging, Mobile units of medical assistance, Sanitary Material, Hypodermic Syringes, Hemostatic Clamps, etc. Science Network has started a Co-investment program for the installation of small Assembly plants to manufacture in series the Mini-plants of portable production on site, region or country where required. One of the most relevant features is the fact that these plants will be connected to the World Trade System (WTS) with access to more than 50 million raw materials, products and services and automatic transactions for world trade. Due to financial reasons, involving cost and social impact, the best solution is setting up assembly plants on the same countries and regions, using local resources (labor, some equipment, etc.) Science Network participates at 50% (fifty percent) for investment of each Assembly plant. If you are interested in being a Science Network partner in your country or region, you can send your CV to: Mini-plants <A HREF="mailto:letters@the-tech-news.com">Worldwide Partners program</A> By Robert B. Lethe, The TechNews, Editor ------------------------------------------------------------------------- If you received this in error or would like to be removed from our list, please return us indicating: remove or un-subscribe in subject field, Thanks. <A HREF="mailto:editor@the-tech-news.com"> Editor</A> © 2003 The TechNews. All rights reserved.

1 0

Old alternative syntax for list comprehensions?
by Peter Pudney 17 Jul '03

17 Jul '03

I recently wanted to generate an infinite list of pairs [(i,j) | i <- [1..], j <- [1..]] Of course, this list comprehension never gets around to generating pairs (2,_). The solution I was after is easily done: [(i,s-i) | s <- [2..], i <- [1..s-1]] But I have a vague recollection of an alternative syntax, something like [(i,j) \ i <- [..], j <- [1..]] that generated a list something like [(1,1),(1,2),(2,1),(1,3),(2,2),(3,1),...]. Did I dream this, or was it a feature of Miranda*, Gopher or Hugs many years ago? Peter

4 3