- Haskell-Cafe - Haskell.org

template haskell overly conservative during splicing?
by Nicolas Frisby 26 Nov '08

26 Nov '08

When using template haskell (via Derive) to generate this (exact) instance: instance Foldable ((->) Int) => Foldable Data.Derivable.InterpreterLib.Test.List where foldMap f (Cons x0 x1) = (const mempty Cons `mappend` foldMap f x0) `mappend` foldMap f x1 foldMap f (Nil) = const mempty Nil I realize the context is insatisfiable. My issue, is that I can't even reach that "challenge". I get this error instead: Malformed type AppT ArrowT (ConT GHC.Base.Int) When splicing generated code into the program I couldn't find an existing ticket or discussion for this issue relying on the phrase "malformed type". I couldn't even find the source that generates that string in haskell-src, template-haskell, or ghc-6.8.2. Can anybody help? Thanks for your time.

3 2

IRC question
by Galchin, Vasili 26 Nov '08

26 Nov '08

Hello, I am using Ubuntu Linux and I want to get the Haskell IRC feed. What IRC client can I use and how to configure? Thanks, Vasili

6 5

Password hashing
by Bit Connor 26 Nov '08

26 Nov '08

Hello, What library can be used to securely hash passwords? From what I understand, the "bcrypt" algorithm is what the experts recommend. It is described in the paper: http://www.openbsd.org/papers/bcrypt-paper.ps I couldn't find a haskell library for this. There is a BSD licensed C implementation that looks very simple here: http://www.mindrot.org/projects/py-bcrypt/ A translation to haskell should be straight forward. Alternatively, a haskell bcrypt library could directly use this implementation and provide a very light FFI wrapper. Any thoughts?

17 31

Interactive
by Andrew Coppin 26 Nov '08

26 Nov '08

I have a small question... Given that interactivity is Really Hard to do in Haskell, and that mutable state is to be strongly avoided, how come Frag exists? (I.e., how did they successfully solve these problems?)

5 5

Hackage/Cabal/Haddock question
by Robert Greayer 26 Nov '08

26 Nov '08

How does Hackage run 'haddock' on uploaded packages? I had assumed it directly runs the cabal 'haddock' target, e.g. runhaskell Setup.hs haddock but it appears to perhaps be more complex than that. Some backrgound -- haddock doesn't seem to like quasiquotation - running haddock on a source tree that includes quasiquotations eventually results in: haddock: internal Haddock or GHC error: Maybe.fromJust: Nothing (eliminating the code that contains [$xxx|....] constructs gets rid of the error.) so "runhaskell Setup.hs haddock" ends up not generating any documentation. I worked around this problem by using a 'UserHook' and adding in an extra path element to the source path prior to running haddock via Cabal: > main = defaultMainWithHooks (simpleUserHooks { > preHaddock = \_ _ -> return (Just $ emptyBuildInfo { hsSourceDirs = ["noqqsrc"]},[]) }) The additional directory contains an alternate version of modules that don't contain quasiquotation (just types and stubs), which seems to hide the versions that do. This works fine locally, but not on hackage (still get the same behavior in the build failure log). Of course, I'd prefer not to have to do this at all, so if anyone knows a way around the problem (or if its purely my problem -- I'm doing something wrong), I'd appreciate hearing about it. I'm using GHC 6.10.1, and have tried setup haddock with both the shipped-with-ghc version of haddock and the latest version. Thanks, rcg

4 5

Unique functor instance
by Luke Palmer 25 Nov '08

25 Nov '08

I've been wondering, is it ever possible to have two (extensionally) different Functor instances for the same type? I do mean in Haskell; i.e. (,) doesn't count. I've failed to either come up with any examples or prove that they all must be the same using the laws. Thanks, Luke

4 10

(no subject)
by apostolos flessas 25 Nov '08

25 Nov '08

hi, i am looking for someone to help me with an assignment! can anyone help me? i am looking forward to your reply. sincerely, Tolis _________________________________________________________________ BigSnapSearch.com - 24 prizes a day, every day - Search Now! http://clk.atdmt.com/UKM/go/117442309/direct/01/

2 1

re: monads with take-out options
by Greg Meredith 25 Nov '08

25 Nov '08

John, You write: > Yes, you are describing 'co-monads'. > Good catch, but actually, that's too weak. i'm requesting something that is both a monad and a co-monad. That makes it something like a bi-algebra, or a Hopf algebra. This, however, is not the full story. i'm looking for a reference to the full story. Surely, someone has already developed this theory. Best wishes, --greg From: John Meacham <john(a)repetae.net> Subject: Re: [Haskell-cafe] monads with take-out options To: haskell-cafe(a)haskell.org Message-ID: <20081124231451.GG32430(a)sliver.repetae.net> Content-Type: text/plain; charset=utf-8 On Mon, Nov 24, 2008 at 02:06:33PM -0800, Greg Meredith wrote: > Now, are there references for a theory of monads and take-out options? For > example, it seems that all sensible notions of containers have take-out. Can > we make the leap and define a container as a monad with a notion of > take-out? Has this been done? Are there reasons for not doing? Can we say > what conditions are necessary to ensure a notion of take-out? Yes, you are describing 'co-monads'. here is an example that a quick web search brought up, and there was a paper on them and their properties published a while ago http://www.eyrie.org/~zednenem/2004/hsce/Control.Comonad.html the duals in that version are extract - return duplicate - join extend - flip (>>=) (more or less) John -- John Meacham - ⑆repetae.net⑆john⑈ -- L.G. Meredith Managing Partner Biosimilarity LLC 806 55th St NE Seattle, WA 98105 +1 206.650.3740 http://biosimilarity.blogspot.com

1 0

Request for code review: slice-1.0.0, TestSupport
by Owen Smith 25 Nov '08

25 Nov '08

Hi all, Thanks for your welcome and helpful comments. I've banged out a first attempt at a Haskell library and was curious if anybody would have time or interest in looking it over it for style, design, stuff that's just wrong, or (most likely) stuff that's been done better elsewhere. I'm willing to trade some labor in kind, if there's any odd jobs that can be done by a relative newbie (e.g. maybe setting up a Windows box for OpenGL build testing with GHC 6.10??). The library, slice, is an emulation of Python's list slicing mechanism: http://www.owendsmith.com/slice-1.0.0.tar.gz It uses a triple of Maybes to specify the range, so it's unwieldly in terms of syntax, but the functionality should be there. Mostly, besides gaining experience with writing a library, I wanted to have functionality that skips through a list the way Python slices can, and didn't see a particularly clean way of doing that particular kind of list dicing in Data.List or elsewhere. (In particular, looking towards an application where I'll need to split a list into odd-positioned elements and even-positioned-elements.) I'm doubtful if this is worth publishing as a real package, but maybe someone besides myself will see something in it worth keeping. One thing I did play with was hooking my unit tests into the Cabal build system for my package; if I've read earlier posts correctly this has not been done frequently or systematically, so if that's the case, maybe this can be a contribution towards better testing support. The scripts in the TestSupport module follow a pattern I've used elsewhere in other languages: stomp through the Test directory hierarchy, find all source files that start with Test, and run them on the fly using runhaskell. This works beautifully if you happen to have runhaskell installed and on your system path, but woe to you if you don't--and I'm not sure how to properly capture that as a dependency in Cabal. I'm also wondering if there's any existing Cabal support to configure a proper location for this (I couldn't find it). And if that weren't enough--if similar mechanisms to runhaskell exist for other compilers that I should try to build into this somehow. Thanks! -- O

2 1

cabal install HaXml installs wrong version unless I specify the version number
by Thomas Hartman 25 Nov '08

25 Nov '08

I was upgrading happstutorial.com to ghc 6.10.1 when I came across a cabal install issue. Somewhere in day 1 (probably as a HAppS dependency), HaXml 1.13.1 got installed. On day 2, I wanted the latest version of HaXml (1.19.4), a dependency for for xml-parsec. cabal install HaXml gave me: already installed. cabal upgrade HaXml gave me: some installing action, but in the end I wound up with 1.13.1 again. cabal install HaXml-1.19.4 gave me what I want, the latest version. But even then, when I do cabal install xml-parsec I get Text/ParserCombinators/Parsec/XML.hs:18:7: Could not find module `Text.XML.HaXml.Posn': it is a member of package HaXml-1.19.4, which is hidden The cabal file has Build-Depends: base, parsec, HaXml >ghc-pkg latest HaXml says HaXml-1.19.4 Even after ghc-pkg hide HaXml-1.13.3 I get the same result, so I'm not even sure if the problems I'm having are a result of the having two versions of the same package installed. This is a bug right? Any advice on how to get xml-parsec installed? thomas.

4 9

Garbage collection as a dual of laziness?
by Robin Green 25 Nov '08

25 Nov '08

It occurs to me that garbage collection can be seen as some kind of dual of laziness. Laziness means deferring the creation of values until later in the future (or even never). Garbage collection means eagerly destroying data created in the past, and reclaiming the memory used by it, before some other event which would do so (in most garbage-collected languages, I think process destruction is the only other thing that frees memory, leaving aside foreign functions). If you don't have enough laziness (e.g. because of strict pattern matching on tuples) your program might do unnecesssary work (time wastage); if you don't have enough garbage collection (e.g. because a value will never be accessed again but is still referred to from something live), your program might leak memory (space wastage). Of course, space wastage can lead to time wastage, and vice-versa. Can this intuition be made any more formal? Is it merely of pedagogical use, or does anything interesting follow from it? -- Robin

4 3

SOEGraphics in GHC?
by Dmitri O.Kondratiev 25 Nov '08

25 Nov '08

Please help, to locate in GHC distribution SOEGraphics library from Paul Hudak, book "The Haskell School of Expression" (http://www.haskell.org/soe/ ) Thanks!

3 2

Ambiguous type variable woes
by Jacques Carette 24 Nov '08

24 Nov '08

I was trying to create a typeclass for an abstract Stack class, and ran into some problems. The following 'works' fine: {-# OPTIONS_GHC -XEmptyDataDecls -XFlexibleContexts -fno-monomorphism-restriction #-} module Stack where data Void class Stack s where push_ :: s a r -> b -> s b (s a r) empty :: s () Void top :: s a (s b r) -> (a, s b r) first :: s a r -> a instance Stack (,) where push_ s a = (a,s) empty = ((),undefined::Void) top = id first = fst p = flip push_ test0 = top . p 2 . p 3 $ empty -- But the following doesn't - I get an "Ambiguous type variable `s' in the contraint `Stack s' arising from the use of `first': test1 = first . p 2 . p 3 $ empty -- sure, that makes sense, it somehow needs to know what flavour of Stack to use even though (or perhaps because) the answer is independent of it. -- So I listen to the "probable fix" and add a type signature: test1 :: Stack (,) => Integer -- This does not however help at all! The only way I have found of 'fixing' this requires annotating the code itself, which I most definitely do not want to do because I specifically want the code to be polymorphic in that way. But GHC 6.8.2 does not want to let me do this. What are my options? Jacques

3 2

How to use Unicode strings?
by Dmitri O.Kondratiev 24 Nov '08

24 Nov '08

Please advise how to write Unicode string, so this example would work: main = do putStrLn "Les signes orthographiques inclus les accents (aigus, grâve, circonflexe), le tréma, l'apostrophe, la cédille, le trait d'union et la majuscule." I get the following error: hello.hs:4:68: lexical error in string/character literal (UTF-8 decoding error) Failed, modules loaded: none. Prelude> Also, how to read Unicode characters from standard input? Thanks! -- Dmitri O. Kondratiev dokondr(a)gmail.com http://www.geocities.com/dkondr

10 11

ANN: hledger 0.2 released
by Simon Michael 24 Nov '08

24 Nov '08

hledger is a minimal haskell clone of John Wiegley's "ledger" text-based accounting tool (http://newartisans.com/software/ledger.html) hledger generates ledger-compatible register & balance reports from a plain text ledger file, and demonstrates a functional implementation of ledger. For more information, see the hledger home page: http://joyful.com/hledger INSTALLATION ------------ If you have cabal-install, do:: cabal install hledger otherwise, unpack http://hackage.haskell.org/packages/archive/hledger/0.2/hledger-0.2.tar.gz and do:: runhaskell Setup.hs configure runhaskell Setup.hs build sudo runhaskell Setup.hs install (or for the latest code, darcs get http://joyful.com/repos/hledger) NEWS ---- * fixes * fix balance report totals when filtering by account * fix balance report selection of accounts when filtering by account * fix a bug with account name eliding in balance report * if we happen to be showing a not-yet-auto-balanced entry, hide the AUTO marker * fix print command filtering by account * omit transactions with zero amount from register report * Fix bug in parsing of timelogs * rename --showsubs to --subtotal, like ledger * drop --usage flag * don't require quickcheck * features * priced amounts (eg "10h @ $50") and --basis/--cost/-B flag to show them with cost basis * easy --depth option, equivalent to c++ ledger's -d 'l<=N' * smarter y/m/d date parsing for -b and -e (any number of digits, month and day default to 1, separator can be / - or .) * -n flag for balance command * --empty/-E flag * build a library, as well as the exe * new home page url (http://joyful.com/hledger) * publish html and pdf versions of README * detect display preferences for each commodity like c++ ledger * support amounts with multiple currencies/commodities * support --real/-R flag * support -C/--cleared flag to filter by entry status (not transaction status) * support virtual and balanced virtual transactions * parse comment lines beginning with a space, as from M-; in emacs ledger-mode * allow any non-whitespace in account names, perhaps avoiding misleading missing amounts errors * clearer error message when we can't balance an entry * when we fail because of more than one missing amount in an entry, show the full entry * document the built-in test runner in --help * add a --verbose/-v flag, use it to show more test-running detail * includes 43 tests Contributors: * Simon Michael * Tim Docker

1 0

Fixity parsing, Template Haskell
by Reiner Pope 24 Nov '08

24 Nov '08

This post follows on from a discussion about a month ago, called "Haskell Syntax Inside Quasiquote". To summarise, suppose I want to create a Haskell quasiquoter for lists, eg [$list|1,x^2,y,3|] (representing the list [1,x^2,y,3]) Ideally, this would allow arbitrary Haskell expressions for each element of the list (provided, of course, that the types are correct). To write this list quasiquoter, I would need to parse Haskell expressions. This is doable[1], but is necessarily buggy when infix operators are concerned. For instance, a user of the list quasiquoter may define two new operators, (+*) and (+^), and then write [$list|1+*2+^3|] Being able to correctly parse such an expression depends on known the two operator's fixities, which is currently impossible. The problem is that potentially non-local fixity declarations affect parsing. As far as I can see, the correct solution is to change the Template Haskell AST representation of fixity expressions from > data Exp = ... > | InfixE (Maybe Exp) Exp (Maybe Exp) to something like > type Op = Exp --- because TH doesn't distinguish operators from expressions > data Exp = ... > | InfixE [Exp] [Op] --- length [Exp] == 1 + length [Op], always > | LeftSection Exp Op > | RightSection Op Exp Apart from splitting of the sections, the important difference is that the expressions are parsed as a list of expressions separated by operators. So, my example above would be parsed as something like InfixE [parseExp "1", parseExp "2", parseExp "3"] ["+*", "+^"] Then, when Template Haskell performs the splice, it could correctly resolve the fixities. Of course, this would require a change to Template Haskell, so a second-best solution would be to forbid unparenthesised expressions in my quasiquoter. Then, parsing can proceed correctly without knowing the fixities. This would be easiest to do if haskell-src-exts changed its AST in a similar way to described above for Template Haskell. Any thoughts? Cheers, Reiner Pope [1] For instance, see haskell-src-meta, which uses haskell-src-exts as a parser, and then converts the AST into a form that Template Haskell recognises.

3 8

why 'try' not work in parsec
by Changying Li 23 Nov '08

23 Nov '08

Hi. I read 'write yourself a scheme in 48 hours' and try to modify its code. now part of code is : parseList :: Parser LispVal parseList = liftM List $ sepEndBy parseExpr spaces parseDottedList :: Parser LispVal parseDottedList = do head <- endBy parseExpr spaces tail <- char '.' >> spaces >> parseExpr return $ DottedList head tail parseExpr :: Parser LispVal parseExpr = parseAtom <|> parseString <|> parseNumber <|> parseQuoted <|> do char '(' skipMany space x <- (try parseList) <|> parseDottedList char ')' return x but I got an error when parse (1 . 2): Lisp>>> (1 . 2) Parse error at "lisp" (line 1, column 4): unexpected "." expecting space, letter, "\"", digit, "'", "(" or ")" I think it failed in parseList because when I rewrite 7th line in parseExpr as: x <- (try parseDottedList) <|> parseList it work. so my question is: if it is failed in parseList, why didn't 'try' work? why not the parseExpr try parseDottedList ? -- Thanks & Regards Changying Li

2 2

Type question in instance of a class
by Maurício 23 Nov '08

23 Nov '08

Hi, Why is this wrong? ---- class MyClass r where function :: r -> s data MyData u = MyData u instance MyClass (MyData v) where function (MyData a) = a ---- GHC says that the type of the result of 'function' is both determined by the "rigid type" from MyClass and the "rigid type" from MyData. But why can't both be the same? What am I doing wrong? Thanks for your help, Maurício

18 31

implementing python-style dictionary in Haskell
by kenny lu 23 Nov '08

23 Nov '08

Dear all, I am trying to implement the python-style dictionary in Haskell. Python dictionary is a data structure that maps one key to one value. For instance, a python dictionary d = {'a':1, 'b':2 } maps key 'a' to 1, 'b' to 2. Python dictionary allows for update. e.g. the statement d['a'] = 3 changes the value pointed by 'a' from 1 to 3. Internally, python dictionary is implemented using hash table. My first attempt is to use Data.HashTable. However it was immediately abandoned, as I realize the memory usage is unreasonably huge. == SECOND ATTEMPT == My second attempt is to use Data.Map {-# OPTIONS_GHC -fglasgow-exts #-} module Main where import qualified Data.HashTable as HT import qualified Data.IntMap as IM import qualified Data.Map as DM import qualified Data.ByteString.Char8 as S import Data.Char -- the Dict type class class Dict d k v | d -> k v where empty :: d insert :: k -> v -> d -> d lookup :: k -> d -> Maybe v update :: k -> v -> d -> d -- Let's use string as key type Key = String -- insert key-value pairs into a dictionary fromList :: Dict d k a => [(k,a)] -> d fromList l = foldl (\d (key,val) -> insert key val d) empty l instance Dict (DM.Map S.ByteString a) Key a where empty = DM.empty insert key val dm = let packed_key = S.pack key in DM.insert packed_key val dm lookup key dm = let packed_key = S.pack key in DM.lookup packed_key dm update key val dm = let packed_key = S.pack key in DM.update (\x -> Just val) packed_key dm Which kinda works, however since Map is implemented using a balanced tree, therefore, when as the dictionary grows, it takes a long time to insert new key-value pair. == THIRD ATTEMPT == My third attempt is to use Data.IntMap -- an implementation of Dict using IntMap instance Dict (IM.IntMap a) Key a where empty = IM.empty insert key val im = let int_key = fromIntegral (HT.hashString key) in IM.insert int_key val im lookup key im = let int_key = fromIntegral (HT.hashString key) in IM.lookup int_key im update key val im = let int_key = fromIntegral (HT.hashString key) in IM.update (\x -> Just val) int_key im This implementation is faster than the Map approach, however this implementation can't handle collision well, two keys which are hashed into the same integer will overwrite each other. == FOURTH ATTEMPT == My fourth implementation is to use Trie. The idea is to split a string (a key) into a list of 4-character chunks. Each chunk can be mapped into a 32-bit integer without collision. We then insert the value with this list of chunks into the Trie. -- an implementation of Dict using Trie instance Dict (Trie a) Key a where empty = emptyTrie insert key val trie = let key_chain = chain key in insertTrie key_chain val trie lookup key trie = let key_chain = chain key in lookupTrie key_chain trie update key val trie = let key_chain = chain key in updateTrie key_chain val trie -- an auxillary function that "splits" string into small pieces, -- 4 characters per piece, 4 chars = 32 bit chain :: Key -> [Key] chain k | length k > 4 = let (k',ks) = splitAt 4 k in (k':chain ks) | otherwise = [k] -- a collision-free hash function which turns four chars into Int32 safehash :: [Char] -> Int safehash cs | length cs > 4 = error "safehash failed." | otherwise = sum [ (ord c)*(256^i) | (c,i) <- zip cs [0..3] ] -- a trie datatype data Trie a = Trie [a] (IM.IntMap (Trie a)) -- the empty trie emptyTrie = Trie [] (IM.empty) -- insert value into the trie insertTrie :: [String] -> a -> Trie a -> Trie a insertTrie [] i (Trie is maps) = Trie (i:is) maps insertTrie (word:words) i (Trie is maps) = let key = safehash word in case IM.lookup key maps of { Just trie -> let trie' = insertTrie words i trie maps' = IM.update (\x -> Just trie') key maps in Trie is maps' ; Nothing -> let trie = emptyTrie trie' = insertTrie words i trie maps' = IM.insert key trie' maps in Trie is maps' } -- lookup value from the trie lookupTrie :: [String] -> Trie a -> Maybe a lookupTrie [] (Trie vs _) = case vs of [] -> Nothing (x:_) -> Just x lookupTrie (word:words) (Trie is maps) = let key = safehash word in case IM.lookup key maps of Just trie -> lookupTrie words trie Nothing -> Nothing -- update the trie with the given value. updateTrie :: [String] -> a -> Trie a -> Trie a -- we only update the first value and leave the rest unchanged. updateTrie [] y (Trie (x:xs) maps) = Trie (y:xs) maps updateTrie (word:words) v (Trie is maps) = let key = safehash word in case IM.lookup key maps of Just trie -> let trie' = updateTrie words v trie maps' = IM.update (\x -> Just trie') key maps in Trie is maps' Nothing -> Trie is maps == BENCH MARK == I have a main function which builds a dictionary from a text file. Each line of the file is a key-value pair separated by a space. e.g. key1 1 key2 2 ... main :: IO () main = do { content <- readFile "in.txt" ; let -- change this following type annotation -- to change different type of the dictionary -- dict :: DM.Map S.ByteString Int -- dict :: IM.IntMap Int dict :: Trie Int dict = fromList (map parse_a_line (lines content)) ; case Main.lookup "key256" dict of { Just v -> putStrLn (show v) ; Nothing -> putStrLn "Not found" } -- read a line here so that we can pause the program -- and look at the memory usage. ; v <- readLn ; putStrLn v } where parse_a_line :: String -> (Key,Int) parse_a_line line = case words line of [key,val] -> (key,read val) _ -> error " parse error. " I tested all three implementations by building a dictionary of size 1000000. The result shows that the Map and the Trie approaches handle collision well, but the IntMap approach does not. Here is a comparison of memory usage Map : 345 MB IntMap : 146 MB Trie : 282 MB Python : 94 MB Here is a comparison of execution time (on an intel dual core 2.0G) Map: 26 sec IntMap: 9 sec Trie: 12 sec Python: 2.24 sec The above number shows that my implementations of python style dictionary are space/time in-efficient as compared to python. Can some one point out what's wrong with my implementations? I've attached my code in the tgz file. Cheers, Kenny

13 28

Haskell Weekly News: Issue 94 - November 22, 2008
by Brent Yorgey 23 Nov '08

23 Nov '08

--------------------------------------------------------------------------- Haskell Weekly News http://sequence.complete.org/hwn/20081122 Issue 94 - November 22, 2008 --------------------------------------------------------------------------- Welcome to issue 94 of HWN, a newsletter covering developments in the [1]Haskell community. Lots of interesting reading this week! Martin Escardo writes about [2]finite search over infinite search spaces expressed as a monad; Conal Elliott writes about [3]the unambiguous choice operator and [4]merging partial values; Luke Palmer on [5]restricted data types and [6]Udon, his system for universal distributed object management; a post about [7]incremental parsing in Yi; Ryan Ingram on [8]parametric higher-order abstract syntax; Issue #12 of [9]the Monad.Reader; and much more! Announcements The Monad.Reader - Issue 12: Summer of Code Special. Wouter Swierstra [10]announced Issue 12 of [11]the Monad.Reader, featuring articles by Max Bolingbroke, Roman Cheplyaka, and Neil Mitchell describing their Summer of Code projects. Turbinado V0.1. Alson Kemp [12]announced the release of [13]Turbinado, an MVC web framework for Haskell. EEConfig-1.0. Bartosz Wojcik [14]announced the release of [15]EEConfig, a simple library for reading parameters from a configuration file. Discussion Proof of a multi-threaded application. Silviu Andrica [16]asked about the possibility of proving the correctness of a multi-threaded application written in Haskell, leading to a discussion of STM, model checking, and related issues. Monadic bind with associated types + PHOAS?. Ryan Ingram [17]wrote about using parametric higher-order abstract syntax to get the benefits of HOAS (using the embedding language to express binding and substitution) while still being able to inspect or optimize the resulting expressions. Blog noise [18]Haskell news from the [19]blogosphere. * Ashish Hanwadikar: [20]More on Haskell DSL. * Real-World Haskell: [21]Real World Haskell in the Wild!. * Conal Elliott: [22]Merging partial values. * John Goerzen (CosmicRay): [23]If Programming Languages Were Christmas Carols. * Conal Elliott: [24]Functional concurrency with unambiguous choice. * >>> Martin Escardo: [25]A Haskell monad for infinite search in finite time. * The GHC Team: [26]Redesigning GHC's build system. * Luke Palmer: [27]Restricted Data Types. * Yi: [28]Incremental Parsing in Yi. * Roman Cheplyaka: [29]The Monad Reader, SoC special. * Darcs: [30]camp irregular news #1. * Eric Kow (kowey): [31]iterative committing. * >>> Joey Hess: [32]a year of haskell (not really). * FP Lunch: [33]The origin of species. * Luke Palmer: [34]Udon Sketch #2. * John Goerzen (CosmicRay): [35]Real World Haskell Update. * Real-World Haskell: [36]When will you see us on bookstore shelves?. * Paul Potts: [37]Reading Real World Haskell. * Darcs: [38]darcs 2.1.2 released!. * Darcs: [39]darcs weekly news #12. * Russell O'Connor: [40]Haskell Lesson. * Conal Elliott: [41]Enhancing a Zip. * Conal Elliott: [42]Proofs for left fold zipping. * >>> Andrew Birkett: [43]Why do they call it: Referentially transparent. * >>> Andrew Birkett: [44]Why do they call it: Referentially transparent (II). Quotes of the Week * dons: instance Ord OCaml, oh wait. hang on. OCaml can't do that. * BONUS: as you can see, one of the best parts of Haskell is #haskell. * ddarius: head [] :: FlyingMonkeys About the Haskell Weekly News New editions are posted to [45]the Haskell mailing list as well as to [46]the Haskell Sequence and [47]Planet Haskell. [48]RSS is also available, and headlines appear on [49]haskell.org. To help create new editions of this newsletter, please see the information on [50]how to contribute. Send stories to byorgey at cis dot upenn dot edu. The darcs repository is available at darcs get [51]http://code.haskell.org/~byorgey/code/hwn/ . References 1. http://haskell.org/ 2. http://math.andrej.com/2008/11/21/a-haskell-monad-for-infinite-search-in-fi… 3. http://feeds.feedburner.com/~r/conal/~3/461480571/ 4. http://feeds.feedburner.com/~r/conal/~3/461534658/ 5. http://lukepalmer.wordpress.com/2008/11/20/restricted-data-types/ 6. http://lukepalmer.wordpress.com/2008/11/19/udon-sketch-2/ 7. http://yi-editor.blogspot.com/2008/11/incremental-parsing-in-yi.html 8. http://www.haskell.org//pipermail/haskell-cafe/2008-November/050768.html 9. http://www.haskell.org/haskellwiki/The_Monad.Reader 10. http://www.haskell.org//pipermail/haskell-cafe/2008-November/050786.html 11. http://www.haskell.org/haskellwiki/The_Monad.Reader 12. http://www.haskell.org//pipermail/haskell/2008-November/020811.html 13. http://www.turbinado.org/ 14. http://www.haskell.org//pipermail/haskell/2008-November/020810.html 15. http://hackage.haskell.org/cgi-bin/hackage-scripts/package/EEConfig 16. http://thread.gmane.org/gmane.comp.lang.haskell.cafe/47728 17. http://www.haskell.org//pipermail/haskell-cafe/2008-November/050768.html 18. http://planet.haskell.org/ 19. http://haskell.org/haskellwiki/Blog_articles 20. http://feedproxy.google.com/~r/typepad/ahanwadi/ashishs_niti/~3/n41w6S_82SE… 21. http://www.realworldhaskell.org/blog/2008/11/22/real-world-haskell-in-the-w… 22. http://feeds.feedburner.com/~r/conal/~3/461534658/ 23. http://changelog.complete.org/archives/825-if-programming-languages-were-ch… 24. http://feeds.feedburner.com/~r/conal/~3/461480571/ 25. http://math.andrej.com/2008/11/21/a-haskell-monad-for-infinite-search-in-fi… 26. http://ghcmutterings.wordpress.com/2008/11/21/redesigning-ghcs-build-system/ 27. http://lukepalmer.wordpress.com/2008/11/20/restricted-data-types/ 28. http://yi-editor.blogspot.com/2008/11/incremental-parsing-in-yi.html 29. http://physics-dph.blogspot.com/2008/11/monad-reader-soc-special.html 30. http://blog.darcs.net/2008/11/camp-irregular-news-1.html 31. http://koweycode.blogspot.com/2008/11/iterative-commiting.html 32. http://kitenet.net/~joey/blog/entry/a_year_of_haskell___40__not_really__41_… 33. http://sneezy.cs.nott.ac.uk/fplunch/weblog/?p=132 34. http://lukepalmer.wordpress.com/2008/11/19/udon-sketch-2/ 35. http://changelog.complete.org/archives/814-real-world-haskell-update 36. http://www.realworldhaskell.org/blog/2008/11/18/when-will-you-see-us-on-boo… 37. http://praisecurseandrecurse.blogspot.com/2008/11/reading-real-world-haskel… 38. http://blog.darcs.net/2008/11/darcs-212-released.html 39. http://blog.darcs.net/2008/11/darcs-weekly-news-12.html 40. http://r6.ca/blog/20081116T213644Z.html 41. http://feeds.feedburner.com/~r/conal/~3/454447926/ 42. http://feeds.feedburner.com/~r/conal/~3/454297817/ 43. http://www.nobugs.org/blog/archives/2008/11/12/why-do-they-call-it-referent… 44. http://www.nobugs.org/blog/archives/2008/11/12/why-do-they-call-it-referent… 45. http://www.haskell.org/mailman/listinfo/haskell 46. http://sequence.complete.org/ 47. http://planet.haskell.org/ 48. http://sequence.complete.org/node/feed 49. http://haskell.org/ 50. http://haskell.org/haskellwiki/HWN 51. http://code.haskell.org/~byorgey/code/hwn/

1 0

Do I need an account to report build of Hacakge packages?
by Ahn, Ki Yung 23 Nov '08

23 Nov '08

I am just curious about how cabal report works. I recently figured out that there is a report command in cabal and it reports the reports generated by --build-reports option when building a package. Is this because I don't have an account on Hackage yet, or because of some other reasons? And if I make an account, where how I put that information in cabal config file? I've looked into the cabal config file and tried to change this myself before, but it wasn't very self explanatory to me. For instance, I tried to make the build-reports on by default, deleting haskell comment like double dashes "--" and put True flag after the colon, but keep getting parse error from cabal. I looked up the manual but it says that the config file is self explanatory, which isn't to me at all. Are there any documentations on this available anywhere? === error messages when I tried to report the build log === kyagrd@kyagrd:~$ cabal report Sending: POST http://hackage.haskell.org/buildreports HTTP/1.1 Content-Type: text/plain Content-Length: 281 Accept: text/plain Creating new connection to hackage.haskell.org Received: HTTP/1.1 404 Not Found Date: Fri, 21 Nov 2008 23:52:14 GMT Server: Apache/2.2.3 (Debian) Alternates: {"HTTP_NOT_FOUND.html.var" 1 {type text/html} {charset iso-8859-2} {language cs} {length 745}}, {"HTTP_NOT_FOUND.html.var" 1 {type text/html} {charset iso-8859-1} {language de} {length 766}}, {"HTTP_NOT_FOUND.html.var" 1 {type text/html} {charset iso-8859-1} {language en} {length 611}}, {"HTTP_NOT_FOUND.html.var" 1 {type text/html} {charset iso-8859-1} {language es} {length 759}}, {"HTTP_NOT_FOUND.html.var" 1 {type text/html} {charset iso-8859-1} {language fr} {length 771}}, {"HTTP_NOT_FOUND.html.var" 1 {type text/html} {charset iso-8859-1} {language ga} {length 813}}, {"HTTP_NOT_FOUND.html.var" 1 {type text/html} {charset iso-8859-1} {language it} {length 692}}, {"HTTP_NOT_FOUND.html.var" 1 {type text/html} {charset iso-2022-jp} {language ja} {length 749}}, {"HTTP_NOT_FOUND.html.var" 1 {type text/html} {charset euc-kr} {language ko} {length 703}}, {"HTTP_NOT_FOUND.html.var" 1 {type text/html} {charset iso-8859-1} {language nl} {length 688}}, {"HTTP_NOT_FOUND.html.var" 1 {type text/html} {charset iso-8859-2} {language pl} {length 707}}, {"HTTP_NOT_FOUND.html.var" 1 {type text/html} {charset iso-8859-1} {language pt-br} {length 753}}, {"HTTP_NOT_FOUND.html.var" 1 {type text/html} {charset iso-8859-1} {language ro} {length 689}}, {"HTTP_NOT_FOUND.html.var" 1 {type text/html} {charset iso-8859-5} {language sr} {length 716}}, {"HTTP_NOT_FOUND.html.var" 1 {type text/html} {charset iso-8859-1} {language sv} {length 722}}, {"HTTP_NOT_FOUND.html.var" 1 {type text/html} {charset iso-8859-9} {language tr} {length 755}} Vary: accept-language,accept-charset Content-Length: 418 Content-Type: text/html; charset=iso-8859-1 cabal: Unrecognised response from server. kyagrd@kyagrd:~$ cabal --version cabal-install version 0.6.0 using version 1.6.0.1 of the Cabal library

4 5

varargs zip
by Jason Dusek 22 Nov '08

22 Nov '08

It came up on IRC last night that there is no "generic" zip in Haskell. I decided to write one as an example, but it only half works. When the argument lists are all definitely of one type, instance selection works as expected; however, with numeric types, for example, things don't work out. I'm not sure how to express the idea that the result tuple determines the arguments types, with either of functional dependencies or associated types. -- _jsn |...example...| http://github.com/jsnx/haskell-demos/tree/master/generic_zip%2FGenericZip.hs

5 5

Re: [Haskell] Does GHC support the standard CPP functionalities?
by Malcolm Wallace 22 Nov '08

22 Nov '08

[moved to haskell-cafe] > {-# LANGUAGE CPP #-} > > module Packer where > > #define FLASH_APP_START 1 > #define FLASH_APP_END 2 > #define INSERT_SECTION(x) (#x, (FLASH_##x##_START, FLASH_##x##_END)) The CPP stringization operator # and the token-catenation operator ## are ANSI additions over the traditional K+R CPP. Ghc uses the - traditional flag to exclude them, because both # and ## are valid Haskell operators, and most people would not want them to be removed by the CPP preprocessor. There are also some other lexical differences between Haskell and C which make it a good ides for ghc to use cpp -traditional. However, if you really want to use ANSI additions, you can switch to cpphs, which does know about the lexical syntax of Haskell. http://haskell.org/cpphs To use it with ghc, you will need to pass the following extra options: ghc -cpp -pgmPcpphs -optP--cpp -optP-ansi Unfortunately, I'm not certain I can guarantee that the -ansi flag will take effect - it depends on whether ghc internally adds the - traditional argument before or after it. Regards, Malcolm

1 0

Operator cheat sheet, and monadic style q
by Owen Smith 22 Nov '08

22 Nov '08

Greetings, I'm a longtime Haskell-curious programmer who, after a few aborted attempts at getting started and long nights staring at academic papers, finally managed to get the bug. I've been pleased with my progress so far, but a couple of things have bugged me enough to seek advice from the rest of y'all. 1. Contending with the use of frequently unfamiliar non-alphanumeric operators has been an uphill battle for me. I think the main reason for this is that I've had no luck in Googling up their definitions (my primary approach for dealing with every other unknown in the Haskell universe) due to their very non-alphanumeric nature. I'm curious if 1) anyone has compiled a cheat sheet of common operators and their meanings/modules, in some sort of text-search-friendly format (e.g. spelling out the operator characters, listing alternate names), or 2) a better way for searching for these things? 2. There's a lot I need to learn about good Haskell style, especially coming from a C++ background. Even my experience in Lisp seems to result in way more parentheses than Haskell coders are comfortable with. :-) In particular, I'm curious about how people actually use monadic operators. The following simple forms with the Maybe monad, for example, appear to be equivalent (hope I and QuickCheck are right about that!): foo :: Int -> Maybe Int bar :: Int -> Maybe Int baz :: Int -> Maybe Int baz n = (foo n) >>= bar baz n = bar =<< (foo n) baz n = (foo >=> bar) n baz n = (foo <=< bar) n and I'm thinking the latter two are more idiomatically written as: baz = foo >=> bar -- I think this one is my fave, naively speaking baz = bar <=< foo Yeah, so "there's more than one way to do it"--though I would never have known about =<<, >=>, and <=< from looking at the introductory material I've seen on the subject. What do people here prefer using in what circumstances? Or is everyone off using do notation or arrows instead? :-) Thanks for the help! -- O

4 3

Counting beta reductions for a Haskell program...
by kk08 22 Nov '08

22 Nov '08

Does GHC supports/has a command for counting total beta reductions taken by a program? Thanks. -- View this message in context: http://www.nabble.com/Counting-beta-reductions-for-a-Haskell-program...-tp2… Sent from the Haskell - Haskell-Cafe mailing list archive at Nabble.com.

4 4

Re: [Haskell-cafe] varargs zip
by Jason Dusek 22 Nov '08

22 Nov '08

Sean Leather <sean.leather(a)gmail.com> wrote: > > example = zip [1,2::Int] ['a','b'] ["1","b"] :: > > [(Int,Char,String)] > > BTW, I realized that this example also works in yours. You > weren't giving enough type annotations. Yes, exactly. Or in other words, the class definition does not correctly specify the dependencies. That is what I am writing in about -- I don't want clients to 'zip' to be required to put all those type annotations in. -- _jsn

1 0

Begginer question about alignment in Storable
by Maurício 21 Nov '08

21 Nov '08

Hi, I need to make the following structure into an instance of Storable: struct { double w[2]; } Can I assume that its function 'alignment' should return the same as "alignment (1::CDouble)"? Or should it be "2 * alignment (1::CDouble)"? (I've read the wikipedia article about memory alignment, and what I understand is that there's a better alignment for hardware efficiency but compilers and programmers can do almost anything about it. What can I do when writing a library wrapper if I don't know what kind of compiler pragmas were used in all platforms that library was compiled?) Thanks, Maurício

4 7

System Fc in GHC
by Hugo Pacheco 21 Nov '08

21 Nov '08

Since System Fc is implemented in the latest releases of GHC, is it implemented in Haskell so that I can play with the translator? Can I find it in the ghc sources? Thanks, hugo -- www.di.uminho.pt/~hpacheco

2 1

portable arrow instances
by Wolfgang Jeltsch 21 Nov '08

21 Nov '08

Hello, how do I make a library work with both GHC 6.8 and GHC 6.10? According to <http://www.haskell.org/haskellwiki/Upgrading_packages#Arrow_instances>, I should change all my Arrow instances but then they don’t work with GHC 6.8 anymore, do they? Or is the solution to force GHC 6.8 users to use base-4.0.0.0? Best wishes, Wolfgang

4 4

Hackage policy question
by Iavor Diatchki 21 Nov '08

21 Nov '08

Hi, I just noticed that hackage has introduced a new policy to disallow changes to a package without bumping the version. I understand that this is probably a good idea for changes to the source code, but it really would be nice to have a backdoor that allows for other changes. For example, I just uploaded a package, and realized that I forgot to add a home-page entry in the cabal file. I do not plan to increase the version number of my application, only so that I can upload a new version (the source code has not changed after all!). I can imagine similar problems related to fixing typos in the description, and other fixes to the meta-data. So, could we please revert to the old policy? (if we really want to be fancy, the hackage upload script could check that the source code, and other fields, such as LICENSE have not changed, as these should really bump the version... in the mean time though, I think just being responsible members of the community would work just as well!). -Iavor

8 23

Problem with GTK on OS X -- installed from source
by Jeff Heard 21 Nov '08

21 Nov '08

Building my app with gtk2hs, I get the following error when I try to compile a file that uses Template Haskell (I'm not using TH to do anythign with GTK, but it loads the package anyway) Loading package gtk-0.9.13 ... <command line>: can't load .so/.DLL for: gthread-2.0 (dlopen(libgthread-2.0.dylib, 10): image not found)

1 1

Haskell Reddit
by Don Stewart 21 Nov '08

21 Nov '08

I'm not sure if the cafe@ knows this, but there's a bit of a Haskell community (1200+ subscribers) built up around the Haskell subreddit on reddit.com, http://www.reddit.com/r/haskell/ A good source for news other than what appears on Planet Haskell. -- Don P.S. Feel free to submit things you like, so I don't have to :-)

2 2

Re: [Haskell] ANNOUNCE: Haddock version 2.4.0
by David Waern 21 Nov '08

21 Nov '08

2008/11/6 Wolfgang Jeltsch <g9ks157k(a)acme.softbase.org>: > Am Donnerstag, 6. November 2008 00:21 schrieb David Waern: >> * Add framed view of the HTML documentation > > After many years with many people telling us that frames are bad, you add > frame support to Haddock? Hmm. You should discuss this with Simon Marlow, as it was his idea. Thomas Schilling implemented it. Personally, I think the frames are quite handy, although not that pretty in their current form. More importantly, you don't need to use them if you don't want to. Haddock still generates the normal index.html as well as frames.html. David

2 1

GHC 6.10.1 and cabal[-install]
by Wolfgang Jeltsch 20 Nov '08

20 Nov '08

Hello, I installed GHC 6.10.1 today and expected it to contain the cabal command line utility. Unfortunately, this was not the case. Where can I download it? How do I install and configure it so that it is integrated best with GHC 6.10.1? For example, should cabal use some directory in the GHC tree to place compiled packages in? <http://hackage.haskell.org/> still links to cabal-install for a convenient way for installing packages. I thought that cabal-install is outdated. Isn’t it? Generally, Cabal info and documentation ist too hard to find on the web, in my opinion. Best wishes, Wolfgang

6 15

(OT) Has GHC stopped being the "Glorious" Glasgow Haskell Compiler?
by Benjamin L.Russell 20 Nov '08

20 Nov '08

IIRC, until very recently, the home page for GHC (see http://www.haskell.org/ghc/index.html) listed the compiler name as "The Glorious Glasgow Haskell Compiler." I wanted to write a blog entry using this aspect, but now the adjective "Glorious" seems to be missing. Am I missing something, or has the nickname been changed? -- Benjamin L. Russell http://dekudekuplex.wordpress.com/

3 2

streaming translation using monads
by Warren Harris 20 Nov '08

20 Nov '08

I am working on a query language translator, and although I feel that a monadic formulation would work well for this application, I've stumbled on a number of questions and difficulties that I thought the knowledgeable people here might be able to help me with. As a translator, there's a source language and a target language, and both of these are specified as a grammar of nested expressions. My first thought was to formulate the target language as an embedded language where each clause expression is represented as a monad operation, so that the bind operator can join the pieces together, e.g.: (clause1, clause2 ...) could be specified as an embedded language as: clause1 >>= \ v1 -> clause2 >>= \ v2 -> ... However, each of the clauses is actually an output routine to send the expression that it denotes to a remote server, and a parser for receiving the results. Since a clause is really a pair of operations, it doesn't seem possible to formulate a monad that will compose all the output routines together and compose all the input routines together in one shot. (Note that the variables in the above code (v1, v2) represent inputs to be received from the remote server -- all outputs are packaged into the clause expressions themselves and are effectively literals.) A naive formulation of a monad to implement the above as "output -> input v" might appear to work, but has the ill-effect of interleaving the output and input statements for each clause rather than composing something that can send the entire request, and then receive the entire result. This forces me to use "output * input v" as the type of each clause expression, but now it is not possible to write a monad with a bind operation that will compose pieces in terms of input variables. Instead I have had to resort to using a set of combinators that thread a continuation function through each clause and accumulate inputs as they are received: clause1 ==> (\ k v1 -> k (trans1 v1)) ++ clause2 ==> (\ k v2 -> k (trans2 v2)) ++ ... This threading is necessary in that I want to stream the translation back to the client requesting the translation rather than building up the (possibly large) results in memory. This formulation has proven to be quite cumbersome in practice, as the resulting continuation types reflect the depth-first traversal of the nested query expressions, and type errors can be quite unintuitive. (It is quite interesting though that each continuation/transformation function can receive not only receive the input from the immediately preceding clause, but from any of the preceding clauses, and also return more or fewer results. However getting anything wrong can be very problematic in that it can lead to either downstream *or* upstream errors depending on how the clauses are composed into an overall query expression.) An alternative to all this would be to use an algebraic datatype to specify the target language (with separate routines for the output and input operations), but that would appear to require another sum type to express the values to be received. I'd like to avoid that if possible since the projection of those values back into my program could lead to dynamic type errors, and also causes seemingly needless memory allocations. There must be another technique for this sort of streaming translation out there... I welcome any suggestions you might have! Warren Harris

4 7

Fwd: [Haskell-cafe] implementing python-style dictionary in Haskell
by Alberto G. Corona 20 Nov '08

20 Nov '08

sorry, Dons, ---------- Forwarded message ---------- From: Alberto G. Corona <agocorona(a)gmail.com> Date: 2008/11/18 Subject: Re: [Haskell-cafe] implementing python-style dictionary in Haskell To: Don Stewart <dons(a)galois.com> By the way byteStrings are wonderful, but, it isn´t true that byteStrings are not so fast for managing short strings, for example keys ? 2008/11/18 Don Stewart <dons(a)galois.com> dave: > > 2008/11/18 kenny lu <haskellmail(a)gmail.com>: > > > Here is a comparison of memory usage > > > > > > Map : 345 MB > > > IntMap : 146 MB > > > Trie : 282 MB > > > Python : 94 MB > > > > > > Here is a comparison of execution time (on an intel dual core 2.0G) > > > > > > Map: 26 sec > > > IntMap: 9 sec > > > Trie: 12 sec > > > Python: 2.24 sec > > > > > > > > > The above number shows that my implementations of python style > dictionary > > > are space/time in-efficient as compared to python. > > > > > > Can some one point out what's wrong with my implementations? > > > > This isn't really a fair comparison. Map, IntMap, and Trie are > > persistent data structures, and Python dictionaries are ephemeral. > > (That is, when you "add" a key to a Map, you actually create a new one > > that shares structure with the old one, and both can be used in > > subsequent code. In Python, you would have to copy the dictionary.) > > > > Strings, not ByteStrings. that's the difference. > > -- Don > _______________________________________________ > Haskell-Cafe mailing list > Haskell-Cafe(a)haskell.org > http://www.haskell.org/mailman/listinfo/haskell-cafe >

2 1

UArray Word16 Word32 uses twice as much memory as it should?
by Arne Dehli Halvorsen 20 Nov '08

20 Nov '08

Hello, I am having an issue with these unboxed arrays. I have some code that creates this structure:: (Array Word16 (UArray Int Word32), Array Word16 (UArray Int Word8)), and I am finding that it uses about twice as much memory as I had anticipated. This tuple is returned strict, and I think I haven't left much room for other data remaining in memory. It should hold one Word8 and one Word32 for a data set of 100 million records, and it uses around 1 gigabyte. By my calculations, it should be half that. So I was wondering if I might have hit upon a 64-bit vs 32-bit issue. I compile with: ghc --make load05 -O1 -funbox-strict-fields -XBangPatterns -fvia-C (also tried with -O2, and without the -fvia-C) using the packaged version of ghc 6.10.1 on MacOSX 10.5.5 Grateful for any pointers, Arne D Halvorsen

2 2

Monadic bind with associated types + PHOAS?
by Ryan Ingram 20 Nov '08

20 Nov '08

This is an idea that has been bouncing around in my head for a while, having to do with embedded languages. A few of the talks at CUFP this year mentioned using Haskell to embed a DSL that gets compiled into the output of the program; the hydraulic engine talk embedded the code for the real-time safety computation in the trucks, and one of the finance talks embedded a language for designing Excel spreadsheets. One thing that often comes up is a desire to do a pass on the resultant code to optimize it, but it's pretty difficult with the standard monadic formulation because of embedded functions. You can't do introspection on functions in Haskell; they aren't elements of Eq or Show. This has caused, for example, some implementations of FRP to switch to using arrows instead. However, I find the arrow syntax cumbersome and I feel it tends to obfuscate what is actually going on in the code. An earlier talk at ICFP mentioned using PHOAS instead of HOAS to encode expressions. In HOAS, a lambda expression in the target language is represented by a function in the source language: > data ExpE t where > ApE :: ExpE (a -> b) -> ExpE a -> ExpE b > LamE :: (ExpE a -> ExpE b) -> ExpE (a -> b) But without a way to inspect the function inside LamE, you can't get back to the "source code". You end up adding special constructors for "Primitive" or "Variable" to let you do something with the resultant structure, which leads to the expression language containing "unsafe" constructors which need to be hidden. PHOAS makes a small change to make many of these things possible without compromising safety: > data ExpP v t where > VarP :: v t -> ExpP v t > ApP :: ExpP v (a -> b) -> ExpP v a -> ExpP v b > LamP :: (v a -> ExpP v b) -> ExpP v (a -> b) > > newtype Exp t = Exp (forall v. ExpP v t) Now, by parametricity, if you are constructing an Exp t, the only useful thing you can do with the variable passed to LamP is give it to VarP. This means the code using it is basically the same as the HOAS code, except a couple of extra "VarP" constructors inserted, but you gain the ability to inspect inside the lambda and extract the code it generates! An couple of examples, from a PHOAS test I wrote up: 1) An evaluator > eval :: Exp t -> t > eval (Exp e) = evalP e > > newtype Prim a = Prim a > evalP :: ExpP Prim t -> t > evalP (VarP (Prim a)) = a > evalP (ApP e1 e2) = evalPrim e1 $ evalPrim e2 > evalP (LamP f) = evalPrim . f . VarP . Prim 2) using "show" to peek inside functions! ] -- implementation is an exercise for the reader ] -- you'll learn a lot! :) ] ] newtype Var a = Var String ] showExp :: ExpP Var a -> ShowS ghci> let test = Exp $ Lam $ \a -> Lam $ \b -> Var a ghci> :t test test :: Exp (t -> t1 -> t) ghci> print test \x y -> x It seems to me this exact transformation could be useful to express "variable binding" in embedded languages! > type family Primitive m a > type family BoundVar m a > class PMonad m where > preturn :: Primitive m a -> m a > pbind :: m a -> (BoundVar m a -> m b) -> m b Now, this strictly generalizes regular monads: > newtype Wrap m a = Wrap (m a) > unwrap (Wrap m) = m > type instance Primitive (Wrap m) a = a > type instance BoundVar (Wrap m) a = a > instance Monad m => PMonad (Wrap m) where > preturn x = WM (return x) > pbind m f = WM (unwrap m >>= unwrap . f) So, it seems like the do-notation should work on this type, although you lose pattern matching ([x] <- getArgs). And you can use PHOAS techniques to build up a structure that you can introspect and optimize. Does anyone think this is a direction worth pursuing? It seems to me like a point where the current syntax of Haskell could mesh well with the new type-system technology that we keep getting from GHC HQ. -- ryan

3 3

Re: [Haskell-cafe] Re: FFI and returning structs
by Donn Cave 20 Nov '08

20 Nov '08

Quoth Maurcio <briqueabraque(a)yahoo.com>: |> (...) Ironically, that's actually just what the original |> function is doing - cf. "struct return convention", where the |> caller allocates space and passes a pointer as a hidden |> parameter. (...) | | Can I be sure things always goes like that? I remember reading | somewhere that if, for instance, a struct is smaller in size than | a pointer (like a struct made of three chars), the struct could be | returned by itself. I think you can be reasonably sure it doesn't always work that way! But if you're interested, you can see what the compiler does with that smaller struct, looking at the assembly code it generates. I'm no Intel programmer, but if my test function uses a parameter, I can see that the parameter is found at an offset, compared to the same function returning a plain scalar value. So - yes, the struct value is returned in a register - but the convention is also observed, with the hidden parameter. Using gcc for Intel 80386 family CPU. Maybe later I will see how it works on AMD64. | Also, why Haskell FFI do not automate that? As long as it is | Storable data, can't it get the pointer and 'peek' it for me? I can't speak for the FFI authors, and note that I'm not even saying that it can't do this. Your inquiry was rather short on details about what happened, and anyway it's only convenient for me to try it with NHC, which may not be the compiler you're using. But if it were up to me, I doubt that I would support this (struct return), since it's rare, at best it adds to the difficulty of supporting different hardware platforms and compilers, and it's easy to work around. Donn

1 0

The Monad.Reader - Issue 12: SoC Special
by Wouter Swierstra 19 Nov '08

19 Nov '08

I am pleased to announce that a new issue of The Monad.Reader is now available: http://www.haskell.org/haskellwiki/The_Monad.Reader Issue 12 is another Summer of Code special and consists of the following three articles: * Max Bolingbroke Compiler Development Made Easy * Roman Cheplyaka How to Build a Physics Engine * Neil Mitchell Hoogle Overview The Monad.Reader is a quarterly magazine about functional programming. It is less formal than a journal, but more enduring than a wiki page or blog post. If you'd like to write something for the next issue of The Monad.Reader, please get in touch. The deadline for the next issue will be February 13th. Looking forward to your submissions, Wouter This message has been checked for viruses but the contents of an attachment may still contain software viruses, which could damage your computer system: you are advised to perform your own checks. Email communications with the University of Nottingham may be monitored as permitted by UK legislation.

1 0

Automatic parallelism in Haskell, similar to "make -j4"?
by T Willingham 19 Nov '08

19 Nov '08

I was surprised when I read the multi-core section of Real World Haskell which explains the use of par, seq, and force to achieve parallelism. While it's obvious a programmer could provide useful parallelism hints to the compiler, given the nature of the language I would have thought Haskell could do a significant amount of parallelism itself without any hints or code changes at all. I am thinking of our troglodytic friend 'make', which will run (for example) 4 parallel jobs when given the option "make -j4". Even 'rake', the ruby version of make, now has a branch (called drake) which does the parallel -j option. Since much of Haskell code is free of side effects, it would seem that it can be analyzed in similar manner to Makefile dependencies in order to find sections which can be run in parallel. What would it take to implement a -j equivalent for, say, GHC? Or if this is not possible, what is wrong with my reasoning? Thanks, TW

9 12

Can't figure out source of race condition when using System.Process
by Rafal Kolanski 19 Nov '08

19 Nov '08

Greetings Gentlemen (and Ladies), As part of my small and simple framework for making presentations in Haskell I have a module which, given some text, makes a .tex file and then converts it to .svg for loading into a cairo canvas. It features simple caching (performs md5 on the contents of the .tex file and uses that as the file name... if an .svg by that name exists, it'll get loaded rather than regenerated). Unfortunately, it also segfaults once in a while, probably indicating I have some kind of race condition ... but I can't figure out why. This is the only point in my code that I think I'm using any concurrency, although I'm compiling with ghc --make -threaded. Compiling without -threaded results in a deadlock. Ubuntu 8.10, 64-bit, GHC 6.8.2. Any advice? I'm attaching the module in question (79 lines). Sincerely, Rafal Kolanski.

6 7

Re: [Haskell-cafe] FFI and returning structs
by Donn Cave 19 Nov '08

19 Nov '08

Quoth Maurcio <briqueabraque(a)yahoo.com>: | I have not found examples of this in documentation | or hackage packages: how can I deal with funcions | returning not pointers to structs but structs | thenselves? | | struct example {... | | example function_name (... | | My intuition said I could try a data declaration | that is a properly done instance of Storable, and | then use that. | | data Example = ... | | instance Storable Example where ... | | But it seems I was wrong. Eh! probably not wrong - the problem is not how the data looks, but where it is. If it were my problem, I would try a wrapper function that returns the same value as an argument - e.g., if you have struct X f(), then void f_(struct X *x) { *x = f(); } ... so your wrapper will look like ccall "f_" f :: Ptr X -> IO () instead of ccall "f" f :: IO X Ironically, that's actually just what the original function is doing - cf. "struct return convention", where the caller allocates space and passes a pointer as a hidden parameter. But you can't just declare it that way, because the original f bumps the stack pointer on return (you may see "ret $4" in the assembly code, on Intel hardware) Try to compile the wrapper with the same compiler that compiled the original function. I'm really just guessing that your Haskell compiler doesn't understand or perfectly handle this particular C wart. If my suggestion doesn't work, I may have guessed wrong. Donn

2 1

Pattern matching on numbers?
by Ryan Ingram 19 Nov '08

19 Nov '08

How does this work? > fac n = case n of > 0 -> 1 > _ -> n * fac (n-1) ghci> :t fac fac :: (Num t) => t -> t The first line of "fac" pattern matches on 0. So how does this work over any value of the Num typeclass? I know that the "1" on the rhs of fac are replaced with (fromInteger 1), but what about numeric literals in patterns? Does it turn into a call to (==)? Should whatever technique is used be extended to other typeclasses too? -- ryan

4 3

Monadic bind with associated types + PHOAS?
by oleg＠okmij.org 19 Nov '08

19 Nov '08

Ryan Ingram wrote: > One thing that often comes up is a desire to do a pass on the > resultant code to optimize it, but it's pretty difficult with the > standard monadic formulation because of embedded functions. You can't > do introspection on functions in Haskell; they aren't elements of Eq > or Show. This has caused, for example, some implementations of FRP to > switch to using arrows instead. However, I find the arrow syntax > cumbersome and I feel it tends to obfuscate what is actually going on > in the code. > > An earlier talk at ICFP mentioned using PHOAS instead of HOAS to > encode expressions. In HOAS, a lambda expression in the target > language is represented by a function in the source language: If one uses a tagless final representation, one benefits from the conveniences of the higher-order abstract syntax and yet gains the ability to show terms, count the number of constructors and even partially evaluate them (i.e., optimize). For the example, please see http://okmij.org/ftp/tagless-final/Incope.hs (in particular, see Semantics2 for the partial evaluator that does not use GADT). We can easily add an interpreter that does a CPS transform, thus letting us embed a CBV object language in a Haskell without any use of monad or the change of syntax of the object language. We can easily extend the language to add state (as we have done in the OCaml part of the project). http://okmij.org/ftp/tagless-final/README.txt

1 0

Haskell library support
by Galchin, Vasili 19 Nov '08

19 Nov '08

Hello, I am looking for something to work on. Where are there perceived holes in the Haskell library support? Regards, Vasili

3 4

FFI and returning structs
by Maurício 19 Nov '08

19 Nov '08

Hi, I have not found examples of this in documentation or hackage packages: how can I deal with funcions returning not pointers to structs but structs thenselves? struct example {... example function_name (... My intuition said I could try a data declaration that is a properly done instance of Storable, and then use that. data Example = ... instance Storable Example where ... But it seems I was wrong. Do you have any tips on how to proceed? Thanks, Maurício

1 0

How to make interface IO() to IO a in a command-driven tool
by Kyongho Min 19 Nov '08

19 Nov '08

Dear Haskell users, I am working on a command-driven tool (::IO ()). If the system invokes itself again, and the system's returned data type would be 'IO a', say (IO Exp) (Expression). tool:: a -> IO() The nested tool invocation returns (IO Exp) to the previous tool. I am using dynamic error exception handling like (throwDyn exp). If I use 'forkIO', then it works for this situation (e.g. IO Exp) but it is not working for 'quit' command (quit the tool:: thread blocked indefinitely) - quit the subtool and return to the previous tool. Any suggestion would be helpful? tool = {tool1, tool2, tool3, ...} tool1:: (IO ()) invoked tool2:: (IO a) may invoked tool3:: (IO a) tool2 is working basically on IO() and if I got the Exp (proved), then return it to the previous tool (say tool1). Thanks in advance, min

2 1

clojure's data structures (was: Re: [Haskell-cafe] implementing python-style dictionary in Haskell)
by Evan Laforge 19 Nov '08

19 Nov '08

This actually brings up something I was wondering about lately. I recently stumbled across a language called clojure, which is a lisp-like that runs on the JVM. The interesting thing is that mutations go through a transactional mutable reference system, and the other datastructures are all immutable. The author implements an immutable hash map with a trie on each 5 bits of the hash, so each node potentially has 32 children. This means that lookups are effectively O(1) and alterations have to copy a maximum of 7 chunks of 32 pointers. Extendable "vectors" are implemented similarly. The hash tables sound basically like an IntMap on the hash code, except as far as I know, IntMap's patricia tree splits up the bit space adaptively instead of being hardcoded on 5 bit segments. I'm not sure what the performance difference would be. I haven't run any tests, but the clojure author claims his vector and hash map are quite fast. I suppose the extendable vector corresponds to the current crop of ByteString-like variants, so we sort of already have that, though in a kind of chaotic and inchoate way. I'm also curious about how far the generalized trie SoC project got... it should be more accessible now that we have a mainline release with ATs, right?

1 0