- Haskell-Cafe - Haskell.org

Design your modules for qualified import
by Johan Tibell 16 Jun '08

16 Jun '08

Hi! The last two weeks I've seen two new packages that add suffixes to identifiers instead of relying on them being imported qualified to distinguish them from identifiers in other modules. This is not a new thing in Haskell community and there are examples of this practice in libraries shipped with GHC. It is also common in papers (for good reasons as we will see later). Atomic channels and variables under Control.Concurrent.* are examples of using a prefix as a namespacing tool. Let me reiterate the arguments [1,2] against this practice and also speculate why this practice is more common in Haskell than in e.g. Python, Java or Ruby. * Cons of including a namespace prefix/suffix in identifiers 1. From experience these prefixes/suffixes tend to be short and non-descriptive, typically just one letter e.g. foldU or elemB. Very frequently used functions that every Haskell programmer is likely to use often can have shorter name as the cost of memorizing them is amortized over all their uses. Examples of short names that most Haskell programmers know by heart is map, fold*, etc. Given that your library won't see the same use as these functions your functions need more descriptive names (or in this case use a qualified import that makes them more descriptive e.g. Array.fold). 2. If your modules are imported qualified the suffix is redundant and thus wastes space. Consider for example foldU imported qualified from the module Data.Array as Array.foldU. Array.fold would have been better in this case. * Pros of using qualified imports 1. Your code will be more robust against additions to modules you depend on. Consider this snippet: import Some.Module -- An utility function that the author of the above module forgot to include. foo = ... Now the author of Some.Module releases a new version of his or her package which include `foo' and your code no longer compiles. If you have no imports on the form import Some.Module your package can specify more relaxed version dependencies on other packages [3]. 2. It's easier to see from where an identifier is imported. Just check the functions module prefix (e.g. Array in Array.foo). If you renamed the import using import Foo as F you might have to check the import list. * Explicit, unqualified imports An alternative to qualified imports that shares some of benefits is to import names unqualified but explicitly enumerate the function names e.g. import Some.Module (foo, bar) It is still not immediately obvious what module a name refers too when using this style (point 2 under pros above) but it is at least easier to find than when implicitly importing all names from a module. This is my current preference for infix operators as they look quite ugly qualified with a module name. It might also make sense if a few functions (e.g. parser combinators) are used a lot in the same module (e.g. an HTTP parser). * Why is this practice common in Haskell Here are some guesses: 1. It's common in papers. However, papers and libraries are quite different. The former usually build up a small vocabulary and having short names is a big win. Papers rarely make use of the module system at all. The latter are included as pieces of large programs and their names need to be adjusted accordingly. 2. It's the default. You have to add "qualified" to all your imports to make them qualified. In most language imports are qualified by default. I think the latter would have been a better choice but we have to live with the current design so bite the bullet and add those qualified keywords to your imports. 3. Lack of common interfaces. An example would be two different set implementations that essentially have the same interface but since there is no explicitly shared interface, defined using a type class, you sometimes end up with different names. The lack of type families might explain why e.g. collection classes don't share interfaces. 4. Haskell is a very expressive language. You can often write a whole function definition on one line! Adding those module qualifications makes your code slightly longer and it might just break your beautiful one liner into two lines. * Summary Whenever you write a library design it so it works well with qualified imports. That means leaving namespacing issues to the module system. Try to think of how code using your functions will look like if it uses them qualified. * References 1. http://www.haskell.org/haskellwiki/Import_modules_properly 2. http://www.haskell.org/haskellwiki/Qualified_names 3. See section 2 Version numbers - http://www.haskell.org/haskellwiki/Library_versioning_policy Cheers, Johan

22 40

Memory profiling
by Pieter Laeremans 16 Jun '08

16 Jun '08

Hi, Which tools do you recommand for memory profiling haskell programs on a *nix system. I'm using haskell to develop a CGI program/script. The application has to be deployed on shared hosting infrastructure. Since I would like to be a good citizen , I would need to meassure the maximum amount of memory allocated to the program during execution. The best I can do now is look at top but that 's not satisfactory. thanks, Pieter -- Pieter Laeremans <pieter(a)laeremans.org>

2 1

Documenting the impossible
by Andrew Coppin 16 Jun '08

16 Jun '08

I have a small idea. I'm curios if anybody else thinks it's a good idea... How about a {-# IMPOSSIBLE #-} pragma that documents the fact that a particular point in the program *should* be unreachable? For example, you look up a key in a Map. You know the key is there, because you just put it there yourself two seconds ago. But, theoretically, lookup returns a Maybe x so - theoretically - it's possible it might return Nothing. No matter what you do, GHC will insert code to check whether we have Just x or Nothing, and in the Nothing case throw an exception. Obviously there is no way in hell this code path can ever be executed. At least, assuming your code isn't broken... This is where the pragma comes in. The idea is that you write something like case lookup k m of Just v -> process v Nothing -> {-# IMPOSSIBLE "lookup in step 3" #-} When compiled without optimisations, the pragma just causes an exception to be thrown, rather like "error" does. When compiled with optimisations, the whole case alternative is removed, and no code is generated for it. (And if the impossible somehow happens... behaviour is undefined.) So you test your program with your code compiled unoptimised, and when you're "sure" the impossible can't happen, you tell the compiler to remove the check for it. (Actually, it would possibly be a good idea to have a switch to turn this on and off seperately if needed...) Does anybody think this is a useful idea? If so I'll add a feature request ticket to the GHC Trac. But I want to see if folks like the idea first... (I was thinking the message in the pragma would be what gets displayed on screen, along with some auto-generated location info. Just a module name and line number ought to be sufficient...)

12 16

External query interface to HackageDB?
by Dimitry Golubovsky 15 Jun '08

15 Jun '08

Hi, Is there any way to query the latest version of a particular package stored on Hackage, that was successfully built? I mean, not _how_ to do that (I have some ideas that I have to download directory listings, looking for failure logs, etc.), but is there any tool or interface already available that does similar things? Unfortunately, tarfiles provided on Hackage (like 00-index.tar.gz) do not help, e. g. BerkeleyDB failed to build in all three versions, yet its all cabal files are included in the tarball: tar tvf 00-index.tar.gz ... -rw-r--r-- www-data/www-data 1055 2007-04-06 13:03 ./BerkeleyDB/0.1/BerkeleyDB.cabal -rw-r--r-- www-data/www-data 1061 2007-04-06 16:59 ./BerkeleyDB/0.2/BerkeleyDB.cabal -rw-rw-r-- www-data/www-data 1236 2008-01-11 14:42 ./BerkeleyDB/0.3/BerkeleyDB.cabal I remember, in the past, HackageDB was expected to become a database of some sort: is there any database-like backend that would accept queries, other than just parsing Apache dir listings? My final goal, given some master-list of package names, to be able to retrieve latest succesfully built (not just uploaded) releases from Hackage Thanks. -- Dimitry Golubovsky Anywhere on the Web

2 1

(no subject)
by Adrian Neumann 15 Jun '08

15 Jun '08

{- I downloaded the source and put my file in the same directory You may need to adjust the imports -} module Main where import Picture import Draw -- change xWin to 1000 and yWin to 700 for this to work import EnableGUI -- I use a Mac import SOE hiding (Region) import qualified SOE as G (Region) import Data.List import Random -- lines are not Shapes unfortunately linie = ((Shape $ Polygon [(-0.1,-0.01),(-0.1,0.01),(0.1,0.01), (0.1,-0.01)]), (-0.1,0), (0.1,0)) main = enableGUI >> do w <- openWindow "Lindenmayer System" (xWin, yWin) newStdGen g <- getStdGen drawPic w (aufgabe2 g) k <- getKey w if (k=='q') then do closeWindow w return () else do clearWindow w main -- one big ugly line of code, not that interesting though aufgabe2 g= dasBild where r = rotateRegion (pi/2) $ Translate (-2.5,0) $ renderLSystem linie (lSystem 20 g) dasBild = Region White r `Over` Region Black ( Translate (0,-1.8) $ Scale (1,0.3)$ Translate (0,-2.6) $ rotateRegion (pi/2+pi/ 3) $ Translate (0,2.6) $ r) `Over` Region Green (Shape $ Polygon [(-5,-3.5),(-5,-1.5),(5,-1.5),(5,-3.5)]) `Over` Region Yellow (Translate (4,1.5) (Shape $ circle (0.5))) `Over` Region Blue (Shape $ Rectangle 14 7) -- start of the interesting part: -- A - Axiom, the base shape we use for rendering later --F - Forward --Branch - what it says data LSys = A LSys | F LSys | Branch StdGen [LSys] LSys | Done deriving Show -- a Axiom is a region with two connector points type Axiom = (Region, Vertex, Vertex) -- this seems not to be used anymore? scaleAxiom :: Float -> Axiom -> Axiom scaleAxiom f (r,u,v) = (Scale (f,f) r, f .*. u, f .*. v) -- just for testing purposes testLSys = A (Branch (mkStdGen 5) [A (F ((Branch (mkStdGen 5) [A (Branch (mkStdGen 5) [A (F ((Branch (mkStdGen 5) [A (F Done), A (F Done)] Done))), A (F Done)] Done), A (F Done)] Done))), A (F Done)] Done) -- a 2D rotation matrix drehM :: Float -> (Float, Float, Float, Float) drehM w = (cos w, -sin w, sin w, cos w) -- matrix vector multiplication (.**.) :: (Float, Float, Float, Float) -> Vertex -> Vertex (.**.) (a,b,c,d) (px,py) = (a*px+b*py, c* px+d*py) -- other vector stuff (.-.) (a,b) (c,d) = (a-c,b-d) (.+.) (a,b) (c,d) = (a+c,b+d) (.*.) l (c,d) = (c*l,d*l) abs' (a,b) = (abs a, abs b) betr (a,b) = sqrt (a*a+b*b) -- SOE doesn't come with a way to rotate Regions, so I wrote my own rotateRegion :: Float -> Region -> Region rotateRegion f (Shape s) = Shape (rotateS f s) rotateRegion f (Translate v r) = Translate ((drehM f).**.v) (rotateRegion f r) -- the scaling part is not right I think. Everything seems to break if I try to incorporate scaling -- into the rendering rotateRegion f (Scale v r) = Scale ((betr v/ betr nv) .*. nv) (rotateRegion f r) where x = ((drehM f).**. (fst v,0)) y = ((drehM f) .**. (0,snd v)) nv = (abs' x) .+. (abs' y) rotateRegion f (Complement r) =Complement (rotateRegion f r) rotateRegion f (Union r1 r2) = Union (rotateRegion f r1) (rotateRegion f r2) rotateRegion f (Intersect r1 r2) = Intersect (rotateRegion f r1) (rotateRegion f r2) rotateRegion f (Xor r1 r2) = Xor (rotateRegion f r1) (rotateRegion f r2) rotateRegion _ s=s rotateS f (Polygon pts) = Polygon (map ((drehM f) .**.) pts) rotateS f x = x -- nondeterministically generate a word in our LSys language -- lots of copy&paste here, any way to do this better? lSystem :: Int -> StdGen -> LSys lSystem n g = f n g (A undefined) where f :: Int -> StdGen -> LSys -> LSys f 0 _ _ = Done f (n+1) g (A _) | choose >= 1 = A (f n ng (F undefined)) | choose == 0 = A (f n ng (Branch ng [f n ng' (A undefined), f n ng'' (A undefined)] undefined)) where (choose, ng) = randomR (0::Int,3::Int) g (ng', ng'') = split ng f (n+1) g (F _) | choose >= 1 = F (f n ng (F undefined)) | choose == 0 = F (f n ng (Branch ng [f n ng' (A undefined), f n ng'' (A undefined)] undefined)) where (choose, ng) = randomR (0::Int,3::Int) g (ng', ng'') = split ng f (n+1) g (Branch h lSys _) | choose >= 1 = Branch h lSys (f n ng (F undefined)) | choose == 0 = Branch h lSys (f n ng (Branch ng [f n ng' (A undefined), f n ng'' (A undefined)] undefined)) where (choose, ng) = randomR (0::Int,5::Int) g (ng', ng'') = split ng -- recursivly render a LSys renderLSystem :: Axiom -> LSys -> Region renderLSystem _ Done = Empty renderLSystem (r,u,v) (A lSys) = r `Union` renderLSystem (r,u,v) lSys renderLSystem (r,u,v) (F lSys) = r'' `Union` renderLSystem (r'', u . +. o , v .+.o) lSys where r'' = Translate o $ r o = (v .-. u) renderLSystem (r,u,v) (Branch g lSys rest) = theBranches `Union` renderLSystem (r,u,v) rest where theBranches = Translate o $ foldr Union Empty $ -- we need to rotate around the u-Connector, not around (0,0) -- thus translation map (Translate u) $ zipWith ($) rotations (map ((Translate ((0,0).-.u)).(renderLSystem (r,u,v))) lSys) rotations = map rotateRegion (randomRs (-pi/4,pi/3) g) -- branches are rotated randomly o = (v .-. u)

2 2

OT: Paper on increasing entropy in software systems
by Magnus Therning 15 Jun '08

15 Jun '08

This is wildly off topic, but since the Haskell community is a rather academic one I thought there might be a good chance to find someone who can point me in the right direction. I was just listening to Brooks' talk at OOPSLA 2007 and in the Q&A part at the end he mentions a paper on increasing entropy in software systems. He mentions the authors' names but I can't quite make it out and Google hasn't been very helpful either. He says the paper “must be 30 years old” and it sounds like he says it's by Les Bellati and Manny Leimann (Lehmann?). As I said, I can't quite make out the names, and the names ring no bells for me. Does anyone on the list know what paper he's referring to? /M -- Magnus Therning (OpenPGP: 0xAB4DFBA4) magnus＠therning．org Jabber: magnus．therning＠gmail．com http://therning.org/magnus What if I don't want to obey the laws? Do they throw me in jail with the other bad monads? -- Daveman

3 2

ANN: Topkata
by Brent Yorgey 15 Jun '08

15 Jun '08

On Sat, Jun 14, 2008 at 10:53 AM, Christoph Bauer < c-bauer-olsbruecken(a)t-online.de> wrote: > Hello Neil, > > > Looks cool! Could you upload it to hackage? > > Thank you. Ok, I uploaded the current version. At the moment you have > to run topkata in the topkata-0.0 directory with > ./dist/build/topkata/topkata, because it has to find its texture/sound > files. There's a way to put something in the .cabal file about extra data files, and have it install them in a certain location that you can then find programmatically. I forget the details, but I think it's pretty easy to set up. Maybe take a look through the Cabal documentation. Or maybe Duncan will jump in and explain. =) -Brent

3 2

Template Haskell sugar / spliceing in automatically ?
by Marc Weber 14 Jun '08

14 Jun '08

Hi, I've been thinking about template haskell sugar lately. Some cool libraries are there such as metaHDBC or the template haskell printf library. However they all have one thing in common: $(printf "...") a b c $(runStmt "INSERT INTO ( ) VALUES ( ?, ?, ? )" ) 2 3 4 Would it make sense to automatically splice those functions? {-# auto-splice: runStmt, printf #-} So that you can just use printf "..." a b c and runStmt "INSERT INTO ( ) VALUES ( ?, ?, ? )" 2 3 4 without $() ? Would this be convinient? Marc Weber

2 1

ANN: Printf-TH
by Marc Weber 14 Jun '08

14 Jun '08

Igloo (Ian Lynagh) allowed me kindly taking over maintainance on his printf library using template haskell written in 2003. I've updated it so that it compiles with ghc-6.8.2. You can get it from hackage: http://hackage.haskell.org/cgi-bin/hackage-scripts/package/Printf-TH usage looks like this: {-# OPTIONS_GHC -XTemplateHaskell #-} ... import Language.Haskell.TH.Syntax import Text.Printf.TH (printf) ... putStrLn $ $(printf "Foo %H bar") (Just 5) putStrLn $ $(printf "%6d") 1 putStrLn $ $(printf "%6d") (-1) Short Explanation: $(printf "%d") will be replaced by a auto generated function taking an int etc Benefit: Wrong arg types or wrong printf arg count will result in compile time errors. Enjoy Marc Weber

1 0

const is question
by odtaa48 14 Jun '08

14 Jun '08

hello could someone explain the following differing results const id 0 5 -> 5 -- ie. 'takes' the 'last' one const (id 0) 5 -> 0 -- ie. 'takes' the 'first' one Thanks

3 2