- Haskell-Cafe - Haskell.org

Re: [Haskell-cafe] Relational Algebra post
by Graham Klyne 25 Oct '04

25 Oct '04

Cool! That goes on my list for further study. (I have a work-in-progress of something similar for description logics.) #g -- At 15:01 22/10/04 -0700, Brian Beckman wrote: >Content-class: urn:content-classes:message >Content-Type: multipart/alternative; > boundary="----_=_NextPart_001_01C4B882.A1CF3A2A" > >on my blog >(<http://weblogs.asp.net/brianbec>http://weblogs.asp.net/brianbec) , i've >posted a couple of Haskell gadgets. One is a simulator for the "relational >algebra" of database theory. The other is just an expansion of one of Paul >Hudak's derivations of State monads. > >_______________________________________________ >Haskell-Cafe mailing list >Haskell-Cafe(a)haskell.org >http://www.haskell.org/mailman/listinfo/haskell-cafe ------------ Graham Klyne For email: http://www.ninebynine.org/#Contact

1 0

fst and snd as record selectors
by Lemming 24 Oct '04

24 Oct '04

The pair data type is quite a regular data type, where (x,y) is syntactic sugar for (,) x y, right? So, why aren't 'fst' and 'snd' record selectors of the pair data type? The definition of pair could be like data (,) a b = (,) {fst :: a, snd :: b} Then the following would work: Prelude> let a = (1,2) Prelude> a {fst = 3} (3,2)

1 0

executable scripts?
by John Velman 24 Oct '04

24 Oct '04

One of the nice things about perl (for example) is that you can put together a script with #!/usr/local/perl (in bash for example) as the first line of a file and run it immediately. I've used perl a lot this way with simple 'throw away' scripts to do special filtering on a file, or some other processing that I want to do one or a few times. occasionally, a script like this will have a more permanant value to me, and I keep it around. Is there some way to do something similar in with Haskell? I've tried the most obvious (to me) test with Hugs and it doesn't work. Surely there is a way to do this! Thanks, John Velman

4 4

existential type problem
by Andrew Pimlott 23 Oct '04

23 Oct '04

I'm having trouble using an existential type, becasue of what seem to be limitations in how I can express the type. I want values in my existential type to denote, for some monad, a monadic operation and a way to run the monad. Except, I want it mix the operation with operations in another monad, so it use a monad transformer. Specifically: data Foo = forall t. (MonadTrans t) => Foo ((Monad m, Monad (t m)) => t m a -> m a) -- run ((Monad m, Monad (t m)) => t m Int) -- op prog :: Foo -> IO Int prog (Foo run op) = run $ do lift $ putStrLn "Running prog" op ghci gives the error Could not deduce (Monad (t IO)) from the context (MonadTrans t) arising from use of `op' at try.hs:22 Hmm.... I see that my constraints did not mean what I expected. As the "Probable fix" suggests, I can add Monad (t IO) to the existential context to make this code type check, but I want it to work for all monads, not just IO. Something like data Foo = forall t. (MonadTrans t, (forall m. Monad m => Monad (t m))) => Foo ... But I haven't found anything like that. I would also welcome other approaches to this problem. Andrew

3 6

Relational Algebra post
by Brian Beckman 22 Oct '04

22 Oct '04

on my blog (http://weblogs.asp.net/brianbec <http://weblogs.asp.net/brianbec> ) , i've posted a couple of Haskell gadgets. One is a simulator for the "relational algebra" of database theory. The other is just an expansion of one of Paul Hudak's derivations of State monads.

1 0

Stream processors
by Peter Simons 21 Oct '04

21 Oct '04

Hi, I have run across the following idiom several times in the last few weeks: Some part of my program reads input from a 'Handle' and repeatedly calls a "stream processor" to incrementally compute some result, say an SHA1 hash, for example. All my stream processors can be reduced to the following interface: import Foreign ( Ptr, Word8 ) type Buffer = (Ptr Word8, Int) data StreamProc ctx a = SP { start :: IO ctx , feed :: ctx -> Buffer -> IO ctx , commit :: ctx -> IO a } I have to initialize some SP-specific context, then I can feed the data into a stateful computation as it comes in, and after receiving EOF I finalize the SP to obtain the result I wanted. The StreamProc interface works nicely for all kind of things, be it message digests, encryption, encoding, or parsers. And obviously, it's a rather generic concept. One that doesn't have to be re-invented every time ... Which leads to my question: Is there any generic module available that implements such a SP? Or something similar? I know the stream processors as described in Hughes' paper about Arrows, but those are pure stream processors -- they don't allow for I/O, which I need to handle the Ptr. Does anyone have a recommendation for me? Peter

4 11

Re: [Haskell-cafe] Re: Stream processors
by MR K P SCHUPKE 21 Oct '04

21 Oct '04

>No, my stream processors currently have the API I described My point was... using the IO library I posted which abstracts the buffer management, you can treat the IO as a simple list... so you don't need to manage the buffers as such and you can use a simple stream processor like: > process :: [a] -> [a] But of course you have to use the List class operators so that would become: process:: List l a => l a -> l a Keean.

2 1

Re: [Haskell-cafe] Re: Stream processors
by MR K P SCHUPKE 21 Oct '04

21 Oct '04

Okay, maybe I misunderstood, I thought by stream processors you meant functions of the type: process :: [a] -> [a] where both the input and the output are lazy lists (streams) I would assume if you want to have a stateful filter you need to maintain the state by using either: process :: [a] -> IO [a] process :: <state> -> [a] -> [a] process :: [a] -> ST s [a] Keean.

2 1

Re: [Haskell-cafe] Stream processors
by MR K P SCHUPKE 21 Oct '04

21 Oct '04

This is the interface I came up with (and its fairly efficient): data IList a i e = ICons i i (a i e) (IList a i e) | INil class List l e where nil :: l e null :: l e -> Bool head :: l e -> e tail :: l e -> l e (+:) :: e -> l e -> l e class List (l a i) e => ListPlus l a i e where (++:) :: a i e -> l a i e -> l a i e part :: a i e -> i -> l a i e -> l a i e Here's the instance for a normal list: instance List [] e where nil = [] null (_:_) = False null _ = True head (a:_) = a head _ = error "head: empty list" tail (_:l) = l tail _ = error "tail: empty list" a +: l = a:l Here's the instance for a list made of UArray buffers: instance (IArray a e,Ix i,Num i) => List (IList a i) e where nil = INil null INil = True null _ = False head (ICons i _ a _) = a!i head _ = error "head: empty list" tail (ICons i j a l) | i < j = ICons (i+1) j a l | otherwise = l tail _ = error "tail: empty list" a +: l = ICons 0 0 (array (0,0) [(0,a)]) l instance (IArray a e,Ix i,Num i) => ListPlus IList a i e where a ++: l | e >= s = ICons s e a l | otherwise = l where ~(s,e) = bounds a part a i l | e >= i = ICons s i a l | otherwise = l where ~(s,e) = bounds a Here's a feeder reading from a file: hGetIList :: ListPlus l UArray Int Word8 => Int -> Handle -> IO (l UArray Int Word8) hGetIList bufSize h = do mt <- newArray_ (0,bufSize-1) ioLoop mt where ioLoop mt = unsafeInterleaveIO $ do sz <- hGetArray h mt bufSize hd <- freeze mt case sz of 0 -> return nil n | n < bufSize -> do return (part hd (n-1) nil) | otherwise -> do tl <- ioLoop mt return (hd ++: tl) And here's an example consumer: wc :: List l Word8 => l Word8 -> Char -> Int -> Int -> Int -> (Int,Int,Int) wc l p i j k | p `seq` i `seq` j `seq` k `seq` False = undefined | not $ Main.null l, h <- (toEnum . fromEnum . Main.head) l, t <- Main.tail l = case isSpace h of False -> wc t h (i + 1) (j + if isSpace p then 1 else 0) k _ -> wc t h (i + 1) j (k + if h == '\n' then 1 else 0) | otherwise = (i,j,k) Keean.

2 1

Re: Top level mutable data structures problem
by MR K P SCHUPKE 20 Oct '04

20 Oct '04

A slight tangent, (and not GHC specific) so I have put this reply in the cafe. a way to get mutable data outside the IO monad occurs to me. If a file is a mutable data type outside of Haskell, we have hGetContents... which can be implemented with unsafeInterleaveIO, rather than unsafePerformIO. hGetContents lets you read a file from outside the IO Monad. The same applies to hGetChannel. What if there was a way to write in the same way? Say you write a function that reads lazily from a list ... you could then have: main :: IO () ... a <- hGetChannel channel hPutChannel (f a) -- this lazily puts the list to the channel. At the other end of the channel we have a state storage thread, which obeys commands sent over the output channel (read x, write y etc...) You can then write a function, which prepends the next instruction to the output list, and reads data from the input list hence manipulates the state. (the sequence of IO operations is preserved by the lists) Keean.

1 0