- Haskell-Cafe - Haskell.org

HDBC, postgresql, bytestrings and embedded NULLs
by Iustin Pop 18 Jan '11

18 Jan '11

Hi all, It seems that (at least) the postgresql bindings do not allow pure binary data. I have a simple table: debug=# create table test (name bytea); byteas seems to be the backing type on the DB side for bytestrings. and then I run this: import Database.HDBC.PostgreSQL import Database.HDBC import Data.ByteString main = do db <- connectPostgreSQL "dbname=debug" stmt <- prepare db "INSERT INTO test (name) VALUES($1)" execute stmt [toSql $ pack [0]] execute stmt [toSql $ pack [65, 0, 66]] commit db What happens is that the inserted string is cut-off at the first NULL value: the first row is empty, and the second row contains just "A". http://www.postgresql.org/docs/8.4/static/datatype-binary.html says: “When entering bytea values, octets of certain values must be escaped (but all octet values can be escaped) when used as part of a string literal in an SQL statement. In general, to escape an octet, convert it into its three-digit octal value and precede it by two backslashes”, and continues to list that NULL should be quoted as E'\\000'. However, I find no such quoting in the HDCB.Postgresql sources. Anyone else stumbled on this? thanks, iustin

4 11

Denotational semantics for the lay man.
by David Sankel 18 Jan '11

18 Jan '11

Hello All, I've recently had the opportunity to explain in prose what denotational semantics are to a person unfamiliar with it. I was trying to get across the concept of distilling the essence out of some problem domain. I wasn't able to get the idea across so I'm looking for some simple ways to explain it. Does anyone know of a way to explain what's the meaning and objective of "distilling the essence" without introducing more jargon. One thing that comes to mind is how Newton's equations for gravity were a distillation of the essence of the way things fall. Thanks in advance, David -- David Sankel Sankel Software www.sankelsoftware.com

5 4

Mailing lists on projects.haskell.org?
by Erik de Castro Lopo 17 Jan '11

17 Jan '11

Hi all, I tried sending mail to the haskell-llvm mailing list (xxxx AT projects.haskell.org) several days ago and today I received a bounce message. Looking into the issue a little further, I find that DNS has no MX record for projects.haskell.org and projects.haskell.org doesn't seem to be listening on port 25. I would email the administrator, but that is also an @projects.h.o address and I doubt it would get through. Posting here in the hope that someone who sees this can fix it. Cheers, Erik -- ---------------------------------------------------------------------- Erik de Castro Lopo http://www.mega-nerd.com/

1 1

is datetime actively maintained?
by Carter Schonwald 17 Jan '11

17 Jan '11

Hey All, I can't tell if datetime is actively maintained, and its version constraints need to be adjusted to allow base4 (which would then allow a whole mess of other packages including gitit build under ghc7). I've been sucessful building gitit with ghc7 64 on OS X and using it if that one constraint on datetime is modified. any thoughts? cheers, -Carter

4 3

Zipper with two focii for concurrent fun
by Yaakov M. Nemoy 17 Jan '11

17 Jan '11

Hey List, So i've been pondering zippers in a concurrent situation, where more than one thread has access to the same data structure, but with different focal points. I've gotten a bit stuck though trying to figure out how to do this using a zipper. The use case i'm thinking of is slightly more complex, but using a basic example below should suffice for an explanation. Say we have a list of characters in a text file which we're using in the form of a zipper to show the current user's cursor position in the text file. This means a data type such as: data ZipperList a = ZL [a] a [a] where the second element is the current position of the cursor. Now as long as one user is editing the text file, we're fine. Now let's say we're working on a newfangled multipointer desktop where two users have a keyboard and mouse each and want to work on the same open file. We could have a list like this: data ZipperList a = ZL [a] a [a] a [a] which leaves us with a number of limitations. We're now limited to two cursors rather than one, but once we start assuming multipointer, two seems like a bigger limitation than just one cursor. Also, we can't tell which user is at which focal point of the zipper easily. We could replace the user with: data User a = User String a data ZipperList a = ZL [a] (User a) [a] (User a) [a] but that gets into some ugly pattern matching. It still leaves us stuck with a two user limit. Say we create a zipper that can contain other zippers. Such as: data ZipperList a = ZL (ZipperList a) a (ZipperList a) | L [a] which lets us include as many users as we want. Now this creates a very different problem. Each cursor in our fictional text editor has a totally different data structure. This is how any calculation at any cursor knows where in the text file it is. If one user edits the character at the cursor, every other zipper-like data structure has to be updated for each other users. Thus a huge concurrency issue. This is where i hit a block. Am i totally crazy in thinking i can solve this problem using a zipper? Or has someone thought about this problem already and perhaps there's even a paper on it? Please advise. -Yaakov

2 2

ANNOUNCE: Haskell binding to the ANTLR parser generator C runtime library
by Mark Wright 17 Jan '11

17 Jan '11

Hi, I'm pleased to announce the release of a Haskell binding to the ANTLR LL(*) parser generator C runtime library. The book on ANTLR is "The Definitive ANTLR Reference: Building Domain-Specific Languages" by Terence Parr: http://www.pragprog.com/titles/tpantlr/the-definitive-antlr-reference ANTLR is a very powerful parser generator. It has support for predicated parsing, where dis-ambiguating semantic predicates can be used to look up information in the symbol table to handle context sensitive programming languages. The lexing and parsing handled in C. The C parser actions call Haskell code to do things such as: - enter data into the symbol table - look up data in the symbol table to implement dis-ambiguating semantic predicates for parsing context sensitive programming languages. - create Abstract Symbol Table entries. The ANTLR parser generator site is at: http://antlr.org/ The Haskell binding to the ANTLR parser generator C runtime library is at: http://hackage.haskell.org/package/antlrc An example based on the implementation of arithmetic expressions example from "Types and Programming Languages" by Benjamin Pierce, chapter 4, is on github: https://github.com/markwright/antlrc-examples/tree/master/src/tapl/arith Building the example is somewhat challenging. I provide a Makefile, however it is specific to my system and will need to be customised. Documentation for the ANTLR C runtime library is at: http://www.antlr.org/wiki/display/ANTLR3/ANTLR3+Code+Generation+-+C Documentation for the ANTLR parser generator is at: http://www.antlr.org/wiki/display/ANTLR3/ANTLR+v3+documentation Thanks, Mark

1 0

Haskell, C and Matrix Multiplication
by Blake Rain 17 Jan '11

17 Jan '11

Dear Haskellers, I thought I'd take some time to share something of my weekend with you all. Not because of anything new, but because it is a feel-good example of Haskell being win. A good read for Monday morning, perhaps. What feels like decades ago, I used to work in computer graphics. Mostly my work was on software for the amateur/semi-professional film industry - developing various filters and effects for the likes of Adobe AfterEffects and so on. I have not touched computer graphics from a programming perspective for quite a long time now, and I thought it was about time that I flexed those old muscles. So, I have taken it upon myself to write an SVG renderer for Blender. To cut what is going to be a very long and humdrum story short, I needed to write some matrix arithmetic code. Having not done this in a long time, I thought I'd see if I can still actually remember what matrix multiplication is by writing a function to multiply two 4x4 matrices. I thought I'd write one in C and then one in Haskell, and see how long they took and how easy they were to write. Here is the one in C: void multiplyM4 (float m1[4][4], float m2[4][4], float m3[4][4]) { m1[0][0] = m2[0][0] * m3[0][0] + m2[0][1] * m3[1][0] + m2[0][2] * m3[2][0] + m2[0][3] * m3[3][0]; m1[0][1] = m2[0][0] * m3[0][1] + m2[0][1] * m3[1][1] + m2[0][2] * m3[2][1] + m2[0][3] * m3[3][1]; m1[0][2] = m2[0][0] * m3[0][2] + m2[0][1] * m3[1][2] + m2[0][2] * m3[2][2] + m2[0][3] * m3[3][2]; m1[0][3] = m2[0][0] * m3[0][3] + m2[0][1] * m3[1][3] + m2[0][2] * m3[2][3] + m2[0][3] * m3[3][3]; m1[1][0] = m2[1][0] * m3[0][0] + m2[1][1] * m3[1][0] + m2[1][2] * m3[2][0] + m2[1][3] * m3[3][0]; m1[1][1] = m2[1][0] * m3[0][1] + m2[1][1] * m3[1][1] + m2[1][2] * m3[2][1] + m2[1][3] * m3[3][1]; m1[1][2] = m2[1][0] * m3[0][2] + m2[1][1] * m3[1][2] + m2[1][2] * m3[2][2] + m2[1][3] * m3[3][2]; m1[1][3] = m2[1][0] * m3[0][3] + m2[1][1] * m3[1][3] + m2[1][2] * m3[2][3] + m2[1][3] * m3[3][3]; m1[2][0] = m2[2][0] * m3[0][0] + m2[2][1] * m3[1][0] + m2[2][2] * m3[2][0] + m2[2][3] * m3[3][0]; m1[2][1] = m2[2][0] * m3[0][1] + m2[2][1] * m3[1][1] + m2[2][2] * m3[2][1] + m2[2][3] * m3[3][1]; m1[2][2] = m2[2][0] * m3[0][2] + m2[2][1] * m3[1][2] + m2[2][2] * m3[2][2] + m2[2][3] * m3[3][2]; m1[2][3] = m2[2][0] * m3[0][3] + m2[2][1] * m3[1][3] + m2[2][2] * m3[2][3] + m2[2][3] * m3[3][3]; m1[3][0] = m2[3][0] * m3[0][0] + m2[3][1] * m3[1][0] + m2[3][2] * m3[2][0] + m2[3][3] * m3[3][0]; m1[3][1] = m2[3][0] * m3[0][1] + m2[3][1] * m3[1][1] + m2[3][2] * m3[2][1] + m2[3][3] * m3[3][1]; m1[3][2] = m2[3][0] * m3[0][2] + m2[3][1] * m3[1][2] + m2[3][2] * m3[2][2] + m2[3][3] * m3[3][2]; m1[3][3] = m2[3][0] * m3[0][3] + m2[3][1] * m3[1][3] + m2[3][2] * m3[2][3] + m2[3][3] * m3[3][3]; } Urgh! This took me over 20 minutes to write out, and a further 34 minutes of debugging. That's 54 minutes to write a simple function! This included 23 invocations of the compiler and 18 invocations of the test program. I was disgusted with myself! I should have automated the writing of it with Haskell! The reason for this was mostly that I kept pressing the wrong buttons when writing those many, many array indices. I became blind to the numbers in the end, and it became one of those nightmare debugging sessions where you check your printMatrix function and other stupid things. I'd like to say that I was a bit tired, but that's just an excuse. Some points about the C version: 1. It's only 21 lines of code. 2. It took me 54 minutes to write and debug. Therefore I can write eight of these in a standard working day. Hmm. 3. It's written in C, so everybody and their dog understands it completely. Honest. 4. It's written in C, so it can just be pasted into nearly any other language (because they're all just augmented C). Therefore no one needs to understand it. 5. It does not consume much space (in terms of memory). 6. It's pretty fast (being written in C): Performing 100,000,000 matrix multiples takes on average 6.117s (with gcc -O2). 7. Passing a NULL pointer anywhere will cause it to explode. 8. If the pointers are not to arrays of 16 floats, it will trash memory (being as it destructively updates one of it's arguments). 9. It will only operate on 4x4 float matrices. 10. How am I storing matrices again...? Column major? So, after drinking some coffee and having a smoke, I started the Haskell version: [foldl (+) 0 $ zipWith (*) x y | x <- m1, y <- transpose m2] Ah. So... anyway, some points about the Haskell version: 1 It's only one line of code - that's 20 less than the C version. 2. It took me just over five minutes to think about and to code. That's a saving of 49 minutes (1180% or something). It compiled straight away and worked first time. I can write too many of these in a day. 3. It's laughably clear and concise. Anyone can easily tell what I'm doing. 4. It does *not* operate in constant space. I think. I can't tell. I don't know how to tell. Maybe it does. 5. It's very fast (being written in Haskell): Performing 100,000,000 matrix multiples takes on average 1.435s (with ghc -O2). 6. Passing in empty lists will not crash it. 7. It will operate on square matrices of any size (3x3, 4x4...). 8. It will operate on a matrix of any type that is of class Num. The Haskell version seems to win on all counts. Interestingly enough (to some at least), other matrix operations also become trivial when expressed in Haskell: Determinant is a bit fiddly, but quite trivial. However it is woefully slow at O(n!). I need to make use of LU decomposition (in which the determinant is the sum of the diagonal values in U). Adjoint is even more of a fiddle, but actually a one-liner after reusing bits of the determinant function (including the determinant function). Matrix inversion is easy in one line, but dependent on the determinant and the adjoint, therefore also woefully slow. Just another example of Haskell being awesome :) Now over to you guys! What experiences have you had which make you glad you use Haskell? Anything make you smile recently? - Blake

6 10

Announcement: SiteBridge version 1.0
by Sukit Tretriluxana 17 Jan '11

17 Jan '11

Dear all, I am proudly announcing SiteBridge version 1.0. Briefly about it, SiteBridge is a site bridging system that allows developers to connect his/her locally developed app to an externally accessible site. It's aimed to get rid of the pain of the fact that you are still internally developing an app but want to test how it looks and feels when externally accessible. An obvious example of this is a web app for mobile devices. Usually these devices are on a different network than that used in development. So you won't be able to test it with real devices unless you have a test site, or you have control over everything including providing WIFI network that you mobile devices can get on. However, so many people do not have this luxury especially those working in enterprise environment. This is a pain and even you have a test site it's often still very awkward to incorporate it into the rapid development cycle. Sometimes you just want a quick test to see how things go such as troubleshooting. See this short introduction video. http://www.youtube.com/watch?v=UxhLthKSr_E For more information, check out http://code.google.com/p/sitebridgeserver/ Enjoy! Ed

1 0

Please explain the Lazy type differences
by Roderick Ford 17 Jan '11

17 Jan '11

I wrote this little clip, and haven't been able to figure out why the L.ByteString is different type than Data.ByteString.Internal.ByteString, or if I am just doing everything wrong here. import System.FilePath import System.Environment import qualified Data.ByteString.Lazy as L import qualified Crypto.Hash.SHA1 as SH import Data.Hex (hex) hashFile :: FilePath -> IO L.ByteString hashFile f = do content <- L.readFile f let hasher = SH.init bhsh = SH.update hasher content return (hex (SH.finalize bhsh)) I really just want to get the digest of a file as a [Char], but then of course, SH.update is not very happy about the type I am passing to it either. Can't wait till this becomes easy! Roderick

3 2

Needed: A repeatable process for installing GHC on Windows
by Johan Tibell 16 Jan '11

16 Jan '11

Hi, Earlier today I was trying to set up a Windows build bot for the 'network' package. That turned out to be quite difficult. Too much playing with PATHs, different gcc versions, etc. Does anyone have a repeatable, step-by-step process to install GHC and get a build environment (where I could build network) going? Johan

5 5