May 2005 - Haskell-Cafe

Tables in Haskell (data model /business app prototyping)
by Rene de Visser 11 May '05

11 May '05

Hello, I have been thinking about using Haskell for prototyping of business apps. I would rather use Haskell also for the persistency, global constraint maintanence, etc... rather than using an external database. The only thing I have found so far is HApps, but I haven't figure out how that works. Is there anything else? I guess I could just use lists for the relations, and the state monad. I would extend the record types witha deleted flag and a transaction number (i.e. simple multi version control). Then updates would just consist of pushing a new record onto the front of the list, and rollbacks and commits come for free. The only disadvantage I see that I always need to scan through the whole list all the time, which will get long, and might even be too slow for prototyping. The lists might also get too large memory wise. Any suggestions? Any libraries? Any experiences with HApps or prototyping business apps with haskell in general? Rene.

1 0

Re: [Haskell-cafe] Python?
by Donn Cave 11 May '05

11 May '05

Quoth Daniel Carrera <dcarrera(a)digitaldistribution.com>: ... | I have a lady friend who wants to learn how to program. I just decided | to teach her Python for practical reasons: I think when you factor in practical reasons, it makes a lot of sense. Python's simplicity and suitability for beginners is vastly overrated, but it's no worse than any of its competition and better than many. It has good exception handling and the top level handler prints out a traceback, I think that's very instructive. As for Objective CAML, it is as someone suggested somewhere in the more practical direction (I haven't checked, but likely enough it does build just fine on Solaris.) And it's a bona fide FPL, plus an interesting OOP layer. Has a lot going for it, but for me it's just no fun. The syntax has something to do with that. | So I'm thinking that perhaps I can use Python, but try to teach her | functional principles, like not changing the value of a variable and not | letting her functions have side-effects. You'll teach her to resent these restrictions. Haskell is built to make the most of that style of programming, Python isn't. It does have some of that, though -- e.g., you can't modify a string. But the first principle of FP might be "use functions", and that you can impart. Python programmers often could stand to break their code out into functions. You won't get to compose functions as you would in Haskell (though it isn't clear to me that it's a big win with beginners anyway), but Python does have the basics for functional usage inasmuch as it can return multiple values, GC storage etc. In the end though it's a classic OOPL and a rather feeble FPL, and it seems to me kind of like teaching horsemanship with an oxe. Donn

1 0

Specify array or list size?
by Daniel Carrera 10 May '05

10 May '05

Hello, Right now I'm using type declarations like: f :: Int -> [Int] So f returns a list of Ints. Is there a way to tell Haskell that a list or array must have exactly (say) 256 elements? I'd love to have Haskell make sure that the array I build is the correct size. Cheers, Daniel.

20 50

hackage, cabal-get, and security
by Isaac Jones 10 May '05

10 May '05

Followups to libraries(a)haskell.org, please. I'm working with Lemmih on the designs for Hackage and Cabal-Get. He's a real trooper, since I'm a total "customer" and have hardly written a line of code for these tools, but keep coming up with new requirements. The basic interaction we would like is this: 1) upload a tarball of a cabal-ized tool to the web site 2) the tarball gets unpacked, the .cabal file is read and added to the database 3) Now, an end user can say "cabal-get pkgname" and it'll download pkgname and all of its build-depends, compile and install them. Use the --user flag if you want to install it all locally. Yay! This actually already works :) The big problem actually is that this is in no way secure, and just begging to be exploited. Boo. I was assuming that we'd add some kind of package signing similar to what Debian does in its apt-secure tool (since I was one of the authors on that tool, I have a good idea about what we need), but I figured we could do that later. But now I'm thinking that this is a stupid idea, and it needs to be secure from the get-go. So here's the new sequence of steps: 1) Generate a gnupg key. preferably get it signed by someone in my web of trust (I'll try to organize a keysigning party at ICFP). We have a core group already by virtue of Debian's web of trust. 2) use cabal-put to sign and upload a package (or get someone with a key to upload your package) 2.a) if you try to upload a new version of a package that's signed by someone else's key, you're out of luck. You'll have to get me to over-ride it or get the original uploader to upload the new version. 3) cabal-get can then be used to download and install as before, but first it checks the signatures of all the packages. If any of them are untrusted signatures (as defined by the cabal-get keyring), then warn the end user. It'll be harder to upload packages, but at least now exploits won't be trivial, and for signed packages, we have something approaching Real Security! What do folks think of that? peace, isaac

1 0

FW: GHC.Prim.realWorld
by Simon Peyton-Jones 09 May '05

09 May '05

| I'd like to know what the function GHC.Prim.realWorld does exactlly | in the STG code below: Think of it as a fixed value. We want the join point $w$j to be a function, with at least one argument, otherwise it'll be evaluated eagerly (since it has a primitive type), which is semantically wrong. It's rather like saying (\().e), only cheaper, because passing () requires you to actually pass a value, whereas the 'realword' token has a type that says "you don't need to pass anything at runtime". GHC.Prim is a built-in module for functions and types that can't be defined in Haskell. The functions in GHC.Prim are enumerated in ghc/compiler/prelude/primops.txt.pp Simon | | PrelBase.divInt# = | \r [x# y#] | let-no-escape { | $w$j = | sat-only \r [w] | case <# [x# 0] of wild { | GHC.Base.False -> quotInt# [x# y#]; | GHC.Base.True -> | case ># [y# 0] of wild1 { | GHC.Base.True -> | case +# [x# 1] of sat_s10t { | __DEFAULT -> | case quotInt# [sat_s10t y#] of sat_s10w { | __DEFAULT -> -# [sat_s10w 1]; | }; | }; | GHC.Base.False -> quotInt# [x# y#]; | }; | }; | } in | case ># [x# 0] of wild { | GHC.Base.False -> $w$j GHC.Prim.realWorld#; | GHC.Base.True -> | case <# [y# 0] of wild1 { | GHC.Base.True -> | case -# [x# 1] of sat_s10I { | __DEFAULT -> | case quotInt# [sat_s10I y#] of sat_s10L { | __DEFAULT -> -# [sat_s10L 1]; | }; | }; | GHC.Base.False -> $w$j GHC.Prim.realWorld#; | }; | }; | | Finally, where is the module GHC.Prim defined ? I've looked for it | in GHC source directories but I haven't found it. Is it part of the | runtime system ? | | Thanks in advance, | | -- | ________________________________ | Monique Louise B.Monteiro | Msc Student in Computer Science | Center of Informatics | Federal University of Pernambuco

1 0

Squashing space leaks
by Greg Buchholz 09 May '05

09 May '05

I've been dabbling with implementing the "n-body" benchmark over at the "Great Computer Language Shootout"... http://shootout.alioth.debian.org/benchmark.php?test=nbody ...and I've stumbled on to a problem with space leaks. The code below works great for low numbers of iterations, but crashes and burns with large numbers. You can temporarily fix it up by specifying larger stack and heap sizes (with the +RTS -K & -H options), but this only gets you so far. I haven't been able to glean much information from the profiling reports. You can see the reports I generated (like the biography report) over at <http://sleepingsquirrel.org/nbody>. I've tried several different variations on the "advance" function, as well as trying "seq" in numerous spots, but I haven't stumbled on to the right combination yet. Any pointers? Thanks, Greg Buchholz >-- n-body simulation >-- compile: ghc -O2 -o nbody nbody.hs >-- run: nbody 100000 > >import System(getArgs) >import Numeric > >data Vec = V !Double !Double !Double deriving Show >instance Num Vec where > (V a b c) + (V x y z) = (V (a+x) (b+y) (c+z)) > (V a b c) - (V x y z) = (V (a-x) (b-y) (c-z)) > fromInteger 0 = V 0.0 0.0 0.0 -- for sum function >instance Eq Vec where (V a b c) == (V x y z) = (a==x) && (b==y) && (c==z) > >dot (V a b c) (V x y z) = a*x + b*y + c*z >scale (V a b c) n = V (n*a) (n*b) (n*c) >mag (V x y z) = sqrt (x*x + y*y + z*z) > >data Planet = Planet Vec Vec Double deriving Show --Position Velocity Mass >dist (Planet p1 _ _) (Planet p2 _ _) = mag $ p1 - p2 >mass (Planet _ _ m) = m >vel (Planet _ v _) = v >pos (Planet p _ _) = p > >main = do > [arg] <- getArgs > let iter = read arg > let n = 5::Int > let bodies = offset_momentum n [sun, jupiter, saturn, neptune, uranus] > let begin = energy n bodies > putStrLn $ showFFloat (Just 9) begin "" > let final = (iterate (advance n 0.01) bodies) > let end = energy n (final !! iter) > putStrLn $ showFFloat (Just 9) end "" > >days_per_year = 365.24 >solar_mass = 4.0 * pi * pi > >advance :: Int -> Double -> [Planet] -> [Planet] >advance n dt (p:ps) = take n ((Planet (pos p + delta_x) > (new_v) (mass p) ) : advance n dt (ps++[p])) > where > delta_v = sum (map (\q -> > (pos p - pos q) `scale` ((mass q)*dt/(dist p q)^3)) ps) > new_v = (vel p) - delta_v > delta_x = new_v `scale` dt > >energy:: Int -> [Planet] -> Double >energy n ps = kinetic - potential > where > kinetic = 0.5 * (sum (map (\q->(mass q)*((vel q) `dot` (vel q))) ps)) > potential = sum [(mass (ps!!i))*(mass (ps!!j))/(dist (ps!!i) (ps!!j)) > | i<-[0..n-1], j<-[i+1..n-1]] > >offset_momentum n ((Planet p v m):ps) = (Planet p new_v m):ps > where new_v = (sum (map (\n->(vel n) `scale` (mass n)) ps)) > `scale` ((-1.0)/solar_mass) > >{- >rotations 0 _ = [] >rotations n xss@(x:xs) = flipped:rotations (n-1) flipped > where flipped = xs++[x] > >advance :: Int -> Double -> [Planet] -> [Planet] >advance n dt pss = map (adv dt) (rotations n pss) > >adv dt (p:ps) = Planet (pos p + delta_x) (new_v) (mass p) > where > delta_v = sum (map (\q -> > (pos p - pos q) `scale` ((mass q)*dt/(dist p q)^3)) ps) > new_v = (vel p) - delta_v > delta_x = new_v `scale` dt >--} >jupiter = (Planet > (V 4.84143144246472090e+00 (-1.16032004402742839e+00) > (-1.03622044471123109e-01)) > (V ( 1.66007664274403694e-03 * days_per_year) > ( 7.69901118419740425e-03 * days_per_year) > ((-6.90460016972063023e-05) * days_per_year)) > (9.54791938424326609e-04 * solar_mass)) > >saturn = (Planet > (V 8.34336671824457987e+00 4.12479856412430479e+00 > (-4.03523417114321381e-01)) > (V (-2.76742510726862411e-03 * days_per_year) > (4.99852801234917238e-03 * days_per_year) > (2.30417297573763929e-05 * days_per_year)) > (2.85885980666130812e-04 * solar_mass)) > >uranus = (Planet > (V 1.28943695621391310e+01 (-1.51111514016986312e+01) > (-2.23307578892655734e-01)) > (V (2.96460137564761618e-03 * days_per_year) > (2.37847173959480950e-03 * days_per_year) > (-2.96589568540237556e-05 * days_per_year)) > (4.36624404335156298e-05 * solar_mass)) > >neptune = (Planet > (V 1.53796971148509165e+01 (-2.59193146099879641e+01) > 1.79258772950371181e-01) > (V (2.68067772490389322e-03 * days_per_year) > (1.62824170038242295e-03 * days_per_year) > (-9.51592254519715870e-05 * days_per_year)) > (5.15138902046611451e-05 * solar_mass)) > >sun = (Planet (V 0.0 0.0 0.0) (V 0.0 0.0 0.0) solar_mass)

8 14

Monad transformers
by Max Vasin 08 May '05

08 May '05

Hello! Suppose we have functions f :: ReaderT env monad1 rtype g :: Reader env rtype and we need to call g from f. Currently I write something like f = do env <- ask let r = runReader g env doSmth r I don't like doing it this way (I need to get environment and explicitly pass it). Is there another way to get things done? -- WBR, Max Vasin.

2 4

Signature browser
by Henning Thielemann 08 May '05

08 May '05

When searching a function in a library I usually scan manually for suitable types in the Haddock function overview. I wonder whether this can be automated or whether this is even implemented already. I want to enter search requests like "a function which takes a predicate and maybe other inputs and outputs at least a list". But I'm afraid formulating such a request takes more time than manual scan. :-(

2 1

Compiling with NHC98
by Daniel Carrera 08 May '05

08 May '05

Hello, After days of effort, I finally managed to compile and install a Haskell compiler. The one I have is NHC98. So now, with my new toy, I am eager to compile my very first Haskell program (I've been using 'runhugs' so far). But I'm having problems: ---<quote>---- $ nhc98 prng.hs -o prng I/O error (user-defined), call to function `userError': In file ./RC4.hi: 1:1-1:6 Found _module_ but expected a interface ---<quote>---- Okay, so I need to learn what an interface is. It looks like Hugs and NHC98 have idfferent ideas of what's acceptable. The file prng.hs starts with: ---<quote>---- module Main where import RC4 .... ---<quote>---- And the file RC4.hs contains all the interesting code. So that's where I am. I'm not clear what it is NHC98 is complaining about or how to fix it. It looks like it doesn't like modules and it wants an interface instead. Can someone point me to where I can learn what an interface is? and how to turn my module into one? Or else, how to make NHC98 accept the module. Any help would be much appreciated. Cheers, Daniel.

7 11

Re: [Haskell-cafe] explaining currying w/o math
by Donn Cave 07 May '05

07 May '05

Quoth Daniel Carrera <dcarrera(a)digitaldistribution.com>: ... | In your opinion, do you think Haskell is appropriate for someone with | zero math background? I can't imagine how I'd explain something like | currying to someone who doesn't know math. Then she may have to learn it from someone else, but there are resources out there. The first thing that came up for me in a web search: http://www.willamette.edu/~fruehr/haskell/lectures/tutorial4.html Haskell functions of several arguments are actually "curried", i.e., they are higher-order functions of successive arguments > :t take take :: Int -> [a] -> [a] > :t take 10 take 10 :: [a] -> [a] > :t take 10 ['a'..'z'] take 10 (enumFromTo 'a' 'z') :: [Char] I think the key is examples. Donn Cave, donn(a)drizzle.com

1 0