April 2009 - Beginners

a better way to do this
by Michael P Mossey 09 Apr '09

09 Apr '09

This is an early attempt to create some kind of parser, for text that is xml-like but not actually xml. This is probably a disaster by Haskell standards... If someone could point me in the direction of a better way of doing things, that would be great. I don't want to use the existing parser library, not at first, because I want to learn more from first principles (for now). The input looks something like: <entry> <field1> thingy </field1> <field2> other thingy </field2> </entry> <entry> ... </entry> ... where there are any number of entries. Each entry consists of a varied number of named fields. For now, the named fields can be anything--any names, in any order. Later I'll do sanity checking to ensure the right fields are there, to provide default values, etc. This uses Data.Bytestring.Char8 for efficiency processing large files. The output types are as follows: type Bs = B.ByteString -- alias type Component = ( Bs, Bs ) -- one named field type Entry = [ Component ] -- all named fields in one entry type Doc = [ Entry ] -- all entries in the input document The basic strategy is to create parsing functions, which take in a string (actually ByteString), and return an object, the remainder of the string, and an index. (The index indicates the position of the first character in the remainder of the string, which is useful for giving error messages.) Top level function is called parseReqs ( "parse requirements" -- this is actually going to be used for a software requirements management project). Here's the rest of the code: -- types for regular expression matching type Re3 = ( Bs, Bs, Bs ) type Re4 = ( Bs, Bs, Bs, [ Bs ] ) parseReqs :: Bs -> ( Doc, Bs, Int ) parseReqs buf = parseReqs' buf 0 parseReqs' :: Bs -> Int -> ( Doc, Bs, Int ) parseReqs' buf idx | B.null buf = ( [], buf, idx ) | otherwise = case parseEntry buf idx of (Just e, rem, remIdx) -> let ( doc, rem', remIdx' ) = parseReqs' rem remIdx in ( e : doc, rem', remIdx' ) (Nothing, rem, remIdx ) -> ( [], rem, remIdx ) parseEntry :: Bs -> Int -> ( Maybe Entry, Bs, Int ) parseEntry buf idx = let ( before, match, after ) = buf =~ "<entry>" :: Re3 idx' = idx + B.length before + B.length match in if B.null match then ( Nothing, after, idx' ) else let ( e, after', idx'' ) = parseEntryBody after idx' in ( Just e, after', idx'' ) parseEntryBody :: Bs -> Int -> ( Entry, Bs, Int ) parseEntryBody buf idx = let ( before, match, after ) = buf =~ "</entry>" :: Re3 idx' = idx + B.length before + B.length match in if B.null match then error "Missing </entry>" else -- Note: index passed to parseEntryComponents is same as one passed -- into this function, because we pass 'before' to -- parseEntryComponents. Index returned from from this function is -- the one calculated above to occur at the start of 'after' ( parseEntryComponents before idx, after, idx' ) parseEntryComponents :: Bs -> Int -> Entry parseEntryComponents buf idx = let ( before, match, after, groups ) = buf =~ B.pack "<([^>]+)>" :: Re4 idx' = idx + B.length before + B.length match in if B.null match then [] else let ( component, buf', idx'' ) = parseCompBody (head groups) after idx' components = parseEntryComponents buf' idx'' in component : components parseCompBody :: Bs -> Bs -> Int -> ( Component, Bs, Int ) parseCompBody compName buf idx = let ( before, match, after ) = buf =~ (B.pack "</" `mappend` compName `mappend` B.pack ">") :: Re3 idx' = idx + B.length before + B.length match in if B.null match then error ("No ending to component " ++ B.unpack compName) else ( ( compName, before ), after, idx' )

2 2

Re: Re: [Haskell-beginners] STM and IO
by emmanuel.delaborde 09 Apr '09

09 Apr '09

> > From: Quentin Moser <quentin.moser(a)unifr.ch> > Subject: Re: [Haskell-beginners] STM and IO > > Your problem has nothing to do with lazyness; Haskell simply kills all > other threads when the main thread returns from main. You have to > somehow wait for them to complete in main or they won't have time to > run. Doh! I've been bitten before... > Now onto the second problem: ignore me if I'm wrong, but it seems your > intent is to spawn 10 threads that will each try to run (writeTo > store) > once. What your current code does is spawn one thread that > sequentially > runs writeTo 10 times. yes you are right of course > Note: I haven't tried running any of this code, but it seems simple > enough to be confident in. I had to make a change to myFork to get it to compile, here's what I have now: module Main where import Control.Monad import Control.Concurrent import Control.Concurrent.STM import System.IO import Control.Exception (finally) myFork :: IO () -> IO (MVar ()) myFork a = do v <- newEmptyMVar a `finally` (putMVar v ()) return v -- to honor the return type myWait :: MVar () -> IO () myWait = readMVar main = do let fname = "store.txt" fh <- openFile fname ReadWriteMode store <- atomically $ newTMVar fh waitMes <- 10 `replicateM` (myFork $ writeTo store) mapM_ myWait waitMes writeTo :: TMVar (Handle) -> IO () writeTo store = do fh <- atomically $ takeTMVar store text <- hGetContents fh hPutStr fh (text ++ " some text ") atomically $ putTMVar store fh Now I get the following error : test3: store.txt: hPutStr: illegal operation (handle is closed) reading the doc about hGetContents, I found that : "Computation hGetContents hdl returns the list of characters corresponding to the unread portion of the channel or file managed by hdl, which is put into an intermediate state, semi-closed. In this state, hdl is effectively closed" Intuitively I'd want to write something like : writeTo filename = atomically (do { s <- readFile filename ; writeFile filename (s ++ "blah") }) but the type system prevents me from doing IO within STM I do not know how to go about sharing access to a file between multiple threads using STM... any pointers ? Thanks E. -- Emmanuel Delaborde Web Technologist Cimex 53-55 Scrutton Street, London UK, EC2A 4PJ T: +44 (0)20 7324 7780 F: +44 (0)20 7324 7781 http://www.cimex.com ----------------------------------------------------------------------------------------------- This e-mail (and any attachments) is confidential and may contain personal views which are not the views of Cimex Media Ltd and any affiliated companies, unless specifically stated. It is intended for the use of the individual or group to whom it is addressed. If you have received it in error, please delete it from your system, do not use, copy or disclose the information in any way nor act in reliance on it and please notify postmaster(a)cimex.com A company registered in England Wales. Company Number 03765711 Registered Office : The Olde Bakehouse, 156 Watling Street East, Towcester, Northants NN12 6DB This email was scanned by Postini, the leading provider in Managed Email Security.

2 1

Inferred type is less polymorphic than e
by Marco Túlio Gontijo e Silva 09 Apr '09

09 Apr '09

Hello, I'm getting this error message from GHC in the following code: > type M a = Monad m => m a > class A a b where > f :: Monad m => a -> m b > instance A String Char where > f string = return $ head string > instance A Char Int where > f int = return $ fromEnum int I thought at first to write h like this, but it gives me the error. If I write it like the other h uncommented, there's no error. I can't see why they aren't equivalent. h :: IO () h = f "abc" >>= (f :: Char -> M Int) >>= print > h :: IO () > h = (f "abc" :: M Char) >>= f >>= (print :: Int -> IO ()) Can someone clarify this to me? Greetings. -- marcot http://marcot.iaaeee.org/

2 3

STM and IO
by emmanuel.delaborde 09 Apr '09

09 Apr '09

Hello list I am trying to use STM for shared access to a file I first used a TVar to to accumulate the text returned by the threads and write TVar's content to a file after a delay (how do you ensure all threads have terminated by the way, that would be more robust than using an arbitrary delay) -- this works main = do let fname = "store.txt" store <- atomically $ newTVar "" forkIO $ 10 `replicateM_` (thread store) threadDelay 800000 txt <- atomically (readTVar store) writeFile fname txt thread :: TVar (String) -> IO () thread store = atomically ( readTVar store >>= writeTVar store . (++ " some text ")) But when I try to concurrently write to the file, I get into troubles. I keep the file handle in a TMVar, hoping than just one thread at a time will be able to use that handle but nothing gets written to "store.txt" ? Is my IO too lazy ? -- this does not work main = do let fname = "store.txt" fh <- openFile fname ReadWriteMode store <- atomically $ newTMVar fh forkIO $ 10 `replicateM_` (writeTo store) writeTo :: TMVar (Handle) -> IO () writeTo store = do fh <- atomically $ takeTMVar store text <- hGetContents fh hPutStr fh (text ++ " some text ") atomically $ putTMVar store fh Thank you -- Emmanuel Delaborde ----------------------------------------------------------------------------------------------- This e-mail (and any attachments) is confidential and may contain personal views which are not the views of Cimex Media Ltd and any affiliated companies, unless specifically stated. It is intended for the use of the individual or group to whom it is addressed. If you have received it in error, please delete it from your system, do not use, copy or disclose the information in any way nor act in reliance on it and please notify postmaster(a)cimex.com A company registered in England Wales. Company Number 03765711 Registered Office : The Olde Bakehouse, 156 Watling Street East, Towcester, Northants NN12 6DB This email was scanned by Postini, the leading provider in Managed Email Security.

2 2

runghc question
by Ian Duncan 08 Apr '09

08 Apr '09

I'm writing a script for TextMate using Haskell, and I don't know how to get it to work with runghc. Here's the script: #!/usr/local/bin/runghc >module Main >where >import System.Cmd >main = putStrLn "FOO" {- do c <- getContents system ("/Users/ian/.cabal/bin/pointfree \"" ++ c ++ "\"") -} How do I get it to treat this as an lhs file rather than an hs file if there is no extension to the filename? Is there an argument for this? Ian Duncan

2 1

Local Haskell meeting, Halle/Saale, Germany, June 12
by Janis Voigtlaender 08 Apr '09

08 Apr '09

[Apologies for German announcement text...] --------------------------------------------- HaL4 : Haskell - Tutorial + Workshop + Party am Freitag, dem 12. Juni 2009, in Halle/Saale --------------------------------------------- Das traditionsreiche HaL-Treffen bietet eine gute Mischung von Haskell-bezogenen Themen aus Forschung, Anwendung und Lehre mit vielen Möglichkeiten zu Diskussion und Unterhaltung bei der anschließenden Party. Der Workshop wird in diesem Jahr ergänzt durch Tutorien für Haskell-Ein- und Umsteiger. Diesmal findet das Treffen in Halle/Saale im Institut für Informatik der Martin-Luther-Universität Halle-Wittenberg statt. Wir planen: 10 - 13 Uhr: Tutorien 15 - 19 Uhr: Fachvorträge 19 - 22 Uhr: Grillparty Wir freuen uns auf rege Teilnahme sowie spannende Vorträge mit heißen Diskussionen und bitten um Vortragsanmeldungen bis zum 8. Mai. Gedacht sind 4 mal je 30 min Vortrag + 30 min Diskussion. Weitere Informationen auf http://www.iba-cg.de/hal4.html -- Dr. Janis Voigtlaender http://wwwtcs.inf.tu-dresden.de/~voigt/ mailto:voigt@tcs.inf.tu-dresden.de

1 0

CORRECTED: making translation from imperative code]
by Michael Mossey 07 Apr '09

07 Apr '09

STOP THE PRESSES--- I noticed some goofs (more late-night programming... ) Corrected below. Read this version. {- A composition consists of several voices or instruments, each indicated by its own *staff*. Visually, a staff is a layout of items such as notes, clef signs, and accidentals arranged horizontally from left to right, representing increasing time. A *system* is a set of staves stacked vertically that represent instruments playing at the same time. Here is a simple representation of a system, in which the pipe character represents items. Note that some of the items are aligned vertically meaning they will play at the same time. At other times, only one staff contains a note. staff 1: | | | | staff 2: | | | | Next we elaborate this model to show that items have visual width. Here they are represented by clusters of x's with a pipe in the middle. The pipe represents the part of the item that needs to be aligned with items on other staves. For example, in the visual representation of a chord, the part of the chord called the notehead needs to be aligned with noteheads on other staves. (A chord includes other symbols, like accidentals and flags, which get drawn to the right or left of the notehead and don't need to be aligned vertically with anything else.) staff 1: x|x xx|xx x|x staff 2: x|x x|x xxxxx|xxxxx a b c d Here you can see that there is an additional constraint on layout, which is that items need to have horizontal space around them so they don't collide. For instance, the very wide item at 'd' (on staff 2) means that the item on staff 1 at 'd' has to be positioned far to the right of its previous item. Note that data exists in two domains: there is data that describes notes; that is, pitches and timbres and volumes and times and duration. We'll call this the 'score'. It's the fundamental data. Then there is the visual *representation* of the score. Here we are concerned only with creating a visual representation. However, we need to refer to data in the score. -} -- LayoutItem is a visual representation of a note. The center of the note -- or chord (specifically the part that needs to be aligned vertically) -- goes at position 'pos', the other variables describe how much the -- note sticks out to the left, right, top, and bottom. We omit other -- details about the note. data LayoutItem = LayoutItem { pos :: ( Int, Int ), leftWidth, rightWidth, topHeight, bottomHeight :: Int, staffId :: String } -- ChunkData is 'score' domain data. It represents all notes that start -- sounding at the same time. It is an association list of staff -- names to notes. Note that a complete score is essentially a list of -- chunks in time order. data ChunkData = ChunkData [ ( String, [ Note ] ) ] -- We'll just say a note is an int giving its pitch. type Note = Int -- A system layout is a set of *staves*. Here, staves are -- lists of LayoutItem, put into an association list by staff name. -- There is also a need to make a memo of chunks for future reference. data SystemLayout = SystemLayout { staves :: [ ( String, [ LayoutItem ] ) ], chunkMemo :: [ ChunkData ] } -- This is the loop state. During the loop, 'time' keeps advancing to -- the time of the next chunk, and 'nextX' keeps advancing to the next -- vetical alignment location. data LoopState = LoopState { time :: Double, nextX :: Int } --- Details of score omitted, but assume it has two key functions. data Score = Score ... scoreGetChunkData :: Score -> Time -> ChunkData scoreNextTime :: Score -> Time -> Maybe Time -- layoutSystem works as follows: it takes a time to start the layout -- at, a score, and a maximum paper width, and returns a tuple with the -- LoopState and SystemLayout at termination. -- -- The looping happens in the helper function layoutSystem' which -- has a simple signature: basically all relevant state goes in, -- and all relevant state comes out. (See signtaure below.) -- -- incororateChunkData does the main work of looking at all notes -- in the next chunk and either finguring out how to add them to -- the staves, or indicating they can't be added without going off -- the right edge of the paper. It returns -- a tuple ( Bool, LoopState, SystemLayout ) where the Bool indicates -- success or failure. layoutSystem Time -> Score -> Int -> ( LoopState, SystemLayout ) layoutSystem firstTime score maxWidth = layoutSystem' initialState initialSystemLayout where initialState = LoopState { time = firstTime, nextX = 0 } initialSystemLayout SystemLayout { staves = [], chunkMem = [] } ) layoutSystem' :: LoopState -> SystemLayout ->( LoopState, SystemLayout ) layoutSystem' state slayout = let chunkData = scoreGetChunkData score (time state) in case incorporateChunkData chunkData state slayout maxWidth of ( False, state', slayout' ) -> ( state, slayout ) ( True, state', slayout') -> case scoreNextTime score (time state') of Just t -> layoutSystem' state' { time = t } slayout' Nothing -> ( state', slayout' ) -- incorporateChunkData is a function that does the work of looking at -- all notes -- in the next chunk and either figuring out how to add them to -- the staves, or indicating they can't be added without going off -- the right edge of the paper. It returns -- a tuple ( Bool, LoopState, SystemLayout ) where the Bool indicates -- success or failure. incorporateChunkData :: LoopState -> SystemLayout -> Int -> ( Bool, LoopState, SystemLayout ) incorporateChunkData chunkData state slayout maxWidth = let items = makeLayoutItems chunkData -- Find new x alignment value, which done by finding how far right -- each item needs to go to avoid collision with previous items. -- For each staff 'staffId' and each item 'i' that needs to be added to -- the staff, the question is: how far right does the staff extend, -- and how far left does the new item stick out from its central -- position? That tells you where the new central position needs to go. -- (the function rightExtent finds how far right a staff extends), -- This process needs to be repeated for all staves, noting the -- needed alignment point for each---and then the final determination -- is the maximum of all those alignment points. alignX = max (map (\i -> let r = rightExtent slayout (staffId i) in r + leftWidth i) items) -- Now see if we've run off the right edge of the paper. -- Then check how far to the right each item will extend and -- compare to maxWidth farRight = max ( map (\i -> alignX + rightWidth i) items) if farRight < maxWidth then let slayout' = addItems slayout items alignX state' = state { nextX = alignX + 1 } in ( True, state', slayout' ) else ( False, state, slayout ) _______________________________________________ Beginners mailing list Beginners(a)haskell.org http://www.haskell.org/mailman/listinfo/beginners

2 3

Re: [Haskell-beginners] accessor function scope
by Daniel Fischer 07 Apr '09

07 Apr '09

Am Dienstag 07 April 2009 11:47:32 schrieb Michael Mossey: > Francesco Bochicchio wrote: > > me too :-) > > > > > > Again, StaffItem and TextItem resemble derived classes in OO. > > > > > > To me, they are more close to C union : a data type than can > > alternatively have different structures, Both analogies capture some aspects of Haskell types. They're useful if you are aware that they take you only so far. > > In your example, LayoutItem is a type name, while StaffItem and TextItem > > are constructor, that is functions. > > Saying that a function specializes a type is a bit of a stretch, I think > > ... > > > > Nevertheless, they can sometime be used to accomplish the same goal : > > where in OO you define an abstact class and then > > specialize with concrete classes to model a classification, in haskell > > you can define a data type with alternate constructors. > > > > I think that data types with alternate constructores are called > > algebraic data types in haskellese, but I'm not sure of that ... Yes, they're called algebraic datatypes, but I'm not sure if a type must have more than one constructor to qualify as such. > > Here's what I've learned from my investigations, but I welcome any > clarifications. > > There are a few ways they don't resemble constructors in OO, or unions in > C. > > They are "constructors", but also "take apart" the item in pattern > matching. myfunc (StaffItem pos dimension) = ... > myfunc (TextItem pos dimension) = ... > > You can also hide the constructors when you export a module. I could export > LayoutItem but not StaffItem and TextItem, meaning that other code would > see LayoutItem as a kind of abstract base class. > > When you name a field in each constructor (the same name), you can access > that field on any LayoutItem without knowing its constructor using the > accessor function for that field. This looks a lot like an abstract base > class. > > data LayoutItem = TextItem { myField :: Int } > > | StaffItem { myField :: Int } > > x1 = TextItem { myField = 3 } > x2 = STaffItem { myField = 4 } > > y1 = myField x1 > y2 = myField x2 > > When I tried to make TextItem and StaffItem instances of a class, I got an > error. They aren't really types. Only LayoutItem is the type. > > instance Eq TextItem where ... > ---> ERROR! > > instance Eq StaffItem where ... > > ---> ERROR! > > instance Eq LayoutItem where... > ---> ok > > Right now I'm just confused by how to translate an exising OO design. I'm > porting a partially complete Python program to Haskell. There are many > options. For instance I could set up a class called LayoutClass, make > TextItem and StaffItem their own classes and make them instances of the "their own types" > class. > > -- Note: Now I can no longer have any overlapping field names > data TextItem = TextItem { tField1, tField2 :: Int } > data StaffItem = StaffItem { sField1, sField3 :: Int } For fields that are generic enough to be interesting, you can have class HasPosition a where pos :: a -> Position class HasDimension a where dim :: a -> Dimension class HasField1 a where field1 :: a -> Int instance HasField1 TextItem where field1 (TextItem f1 _) = f1 > > class LayoutClass a where > access1 :: a -> Int > > instance LayoutClass TextItem where > access1 (TextItem t) = tField1 t > > instance LayoutClass StaffItem where > access1 (StaffItem s ) = sField1 s > > Or put everything in its own module and use qualified names. Probably the > best choice for future considerations. Consider also the "class HasWhatever" approach, sometimes it's better than qualified names.

2 1

accessor function scope
by Michael Mossey 07 Apr '09

07 Apr '09

I'm coming from the OO world and trying to adapt. I've noticed that if I declare two types like this data Thing1 = Thing1 { itemPos :: Int } data Thing2 = Thing2 { itemPos :: Int } then I get the error "Multiple declarations of Main.itemPos" However, I can successfully do this: type Pos = ( Int, Int ) type Dimension = ( Int, Int, Int, Int ) data LayoutItem = StaffItem { itemPos :: Pos, itemDim :: Dimension } | TextItem { itemPos :: Pos, itemDim :: Dimension } d1 = TextItem ... d2 = StaffItem ... i1 = itemPos d i2 = itemPos d2 This seems to define itemPos in a way that can sense whether it's dealing with a StaffItem-type LayoutItem or a TextItem-type LayoutItem. I don't know if this would be considered an overloaded operator. However, it does resemble derived class in OO. For that matter, I don't know what the term is for a "StaffItem-type LayoutItem". The type is clearly LayoutItem. "StaffItem" is the constructor. How do you refer to the concept of a LayoutItem constructed via a StaffItem? Again, StaffItem and TextItem resemble derived classes in OO. Any clarification welcome. -Mike

4 4

combine pattern matching against named fields and tuples
by Michael Mossey 07 Apr '09

07 Apr '09

I'm trying to do something like this: data Thing = Thing { field1, field2 :: ( Int, Int ) } myfunc = Thing { field1 ( _, x ) } = x but it doesn't work. That is, I want to match against the second item of the tuple which is the named field1. I'm not just trying to do this particular thing, but trying to figure out if some kind of general pattern matching can be done like this.

3 2