- Haskell-Cafe - Haskell.org

On to applicative
by michael rice 04 Sep '10

04 Sep '10

The two myAction functions below seem to be equivalent and, for this small case, show an interesting economy of code, but being far from a Haskell expert, I have to ask, is the first function as small (code wise) as it could be? Michael import Control.Applicative data Color = Red | Blue | Green | Yellow | Orange | Brown | Black | White deriving (Show, Read, Eq, Enum, Ord, Bounded) -- myAction :: IO Color -- myAction = getLine -- >>= \str -> return (read str :: Color) myAction :: IO Color myAction = read <$> getLine

2 2

Regular expressions on Windows 7
by John Sampson 04 Sep '10

04 Sep '10

Hello - I am following the book "Real World Haskell". I am looking at the chapter on regular expressions and trying examples on WinGHCi. However, it cannot load regex-posix-0.94.2 - apparently a file regex.h is missing. I think this has been known for some time. Are there plans to have working regexes on the Windows platform? I am not enough of a hacker to be able to understand material on the Web on this subject - the problem may have been solved somewhere. Regards _John Sampson_

2 1

Restricted type classes
by Ivan Lazar Miljenovic 04 Sep '10

04 Sep '10

When I released the first version of container-classes (which I hacked on during AusHac), some people said I should split out the various folding, etc. into duplicates of the current Foldable class, etc. rather than having large monolithic classes. I've been working on this (see my more recent email with the subject along the lines of "fighting the type system"), and I think I've worked out how to do this: * Have one version of the class (when this makes sense) for values of kind * * Have another version that's closer to the original class for kind * -> * but allowing restrictions (e.g. allowing Set to be an instance of Functor). This is based upon Ganesh Sittampalam's rmonad package (http://hackage.haskell.org/package/rmonad) Rather than my original goal of forcing all kind * -> * values to be instances of the kind * classes, my new approach is to write instances that automatically make all instances of a * -> * class to also be an instance of the kind * class, and to use a newtype wrapper with a phantom type value to allow lifting/promotion of a kind * value to a kind * -> * value (e.g. "foo :: (Word8 -> Word8) -> ByteString -> ByteString; foo f = unpromote . fmap f . Promote" is a valid usage, rather than using the kind * function of rigidMap). My goal with this is that if I have duplicated a class Foo to allow restricted values, then it should be a drop-in replacement for the original in terms of _usage_ (i.e. the class and method/function names are the same, but the type signatures are not). However, I would appreciate the communities advice on a few matters: 1) How should I name the kind * versions? For example, the kind * version of Functor is currently called Mappable with a class method of rigidMap. What should I call the kind * version of Foldable and its corresponding methods? Is there a valid system I can use for these? 2) How far should I go? Should I restrict myself to the "data-oriented" classes such as Functor, Traversable, etc. or should I try to make restricted versions of Applicative and Monad? Assuming I should: 2a) Which namespace to use? Should Monad go in Data.Restricted.Monad to keep it in the same namespace as the other classes, or should I make it closer to base with Control.Restricted.Monad? 2b) Is it OK to promote functions that use a class to being class methods? When I was discussing this in #haskell several people mentioned that defining something like liftA2 for the Set instance of (restricted) Applicative would make more sense than the default <*> (since (a -> b) isnt' an instance of Ord). 2c) Should I keep the classes as-is, or should I explicitly put in the constraints mentioned in the Typeclassopedia (e.g. make Applicative an explicit superclass of Monad, and define return = pure for compatability reasons)? If so, should I bring over Pointed, etc. from category-extras to round out the set or just stick with classes that are already in base? 3) Am I wasting my time with this? -- Ivan Lazar Miljenovic Ivan.Miljenovic(a)gmail.com IvanMiljenovic.wordpress.com

5 9

Haddock: Documentation of instances with un-documentable type arguments
by Alexander McPhail 04 Sep '10

04 Sep '10

Hi, Here, http://hackage.haskell.org/packages/archive/graphviz/2999.10.0.1/doc/html/D…, there is an example of the internal implementation leaking. I was taught to separate interface from implementation. For example, header versus c/cc/cpp files. The privacy of typeclasses of GeneralNewTypedDeriving'ed variety, such as MonadReader and MonadState, should be hidable. I may want the programmer to know my operations, as provided in the interface, are monadic (and thus sequencable, temporally deterministic operations) but not allow them to set/get, ask, tell, fetch, push, throw, or pass my implementational details. Perhaps Haddock could exclude class instance reporting when it cannot find a documentable link to a parameter? Vivian -- --- yolar et elver. --- DISCLAIMER This transmission contains information that may be confidential. It is intended for the named addressee only. Unless you are the named addressee you may not copy or use it or disclose it to anyone else.

5 10

TryHaskell in the classroom!
by Fritz Ruehr 04 Sep '10

04 Sep '10

I just wanted to send out a more public "Thanks!" to Chris Done for the tryhaskell.org website and to everyone else (including Chris) who was on the #haskell channel of IRC this afternoon when I "tried haskell", along with the chat feature, during my introductory functional programming class. And I want to recommend the use of tryhaskell and its tutorial to anyone else teaching Haskell in the classroom: it makes for an an especially friendly and approachable introduction to the language for students like mine, some of whom are seeing programming for the first time. I'll be using Hugs and GHC(i) for the day-to-day work through the semester, but I imagine my students will be showing their friends tryhaskell and poking around in it at odd moments from the local cafe. I had just begun my second lecture with a little introduction to the Haskell community and how friendly it was, etc., when I realized the opportunity that the chat feature represented. Sure enough, #haskellers came through for me with some fun & friendly interaction as the class and I bounced back and forth between the tutorial and their comments. It was very gratifying to have my abstract proposition about the character of the community backed up by a concrete existential witness, live in the classroom :) . Thanks again to Chris, Gwern Branwen, _why (of TryRuby) and everyone else for their efforts and interactions. -- Fritz Ruehr

4 3

holumbus error message -- unexpected package db stack
by Roderick Ford 04 Sep '10

04 Sep '10

Hello all, I want to try out Holumbus packages, but found that they don't build when left to cabal-install. So I went to the holumbus site and did the git of the latest source...but it still wouldn't build. Surprisingly, one of the errors was that there System.IO did not export a method utf8, but alas, utf8-prelude and utf8-string are both installed. So I went into this source code tree and attempted to make minor alterations. First, of the script is the distribution package (of the three packages), and cabal wanted less than the most recent hxt package as a maximum, so I dropped that limit. This gave me a buildable make of the code (make just calls Setup for each step) but in the "make install" I get: localhost:/home/roderick/Source/hs/src/distribution # make install Installing library in /usr/local/lib/Holumbus-Distribution-0.0.2.0/ghc-6.10.4 Installing executable(s) in /usr/local/bin Registering Holumbus-Distribution-0.0.2.0... Setup.hs: internal error: unexpected package db stack make: *** [install] Error 1 So, my question is "What is the 'unexpected package db stack' caused by?" Does this give me any hints about the actual problem? Roderick

2 4

HDBC-postgresql and safe/unsafe FFI calls
by David Powell 04 Sep '10

04 Sep '10

Greetings, I'm having an issue with the HDBC-postgresql package that requires me to manually patch it before installation for most of my use cases. All the FFI calls in this package are marked "unsafe". Unfortunately, this means that whenever I issue a slow sql query, all other processing stops. In most places that I want to use this module, I've had to manually patch it to at least mark the PQexec and PQexecParams calls as "safe". Is there any reason these calls should not be marked as "safe"? I understand that there a little extra runtime overhead with this, but I'd have thought that negligible given all the other processing that goes on with these particular calls under the hood. Cheers, -- David Powell

4 7

Announce: lhae
by abau 03 Sep '10

03 Sep '10

lhae is a spreadsheet program. It features a simple formula language and some basic statistical methods, like descriptive statistics and pivot tables. Other features: - Import from csv files - Export to image files - Export to gnuplot diagrams (currently bar charts and box plots) - Multilingual (english, german) Here [1] is some documentation about how to build lhae and how to use the formula language. Regards, Alex [1] http://www.imn.htwk-leipzig.de/~abau/lhae/

6 5

Missing documentation in Haskell Platform on Windows
by Arnaud Bailly 03 Sep '10

03 Sep '10

Hello, I installed (succesfully) HAskell Platform 2010.2 on windows and have a small but annoying issue: Some links in HTML documentation lead to broken links. I did not investigate all the links, but I have seen that all doc under Control.Monad.XXX is missing. What am I doing wrong ? Arnaud

6 7

Confused about ByteString, UTF8, Data.Text and sockets, still.
by JP Moresmau 03 Sep '10

03 Sep '10

Hello all After reading the modules docs and some other discussions, I'm still not sure what's the best choice of tools for my problem. I'm looking at the scion server code base. At the moment, it's reading and writing on sockets using Lazy ByteStrings, then converting them to Haskell Strings using utf8-string. The Haskell Strings are then parsed as JSON using the JSon package. the response is in JSON, translated back with utf8-string to ByteStrings. This is efficient for small strings, but as I'm extending the API I have calls with much more data, and performance degrades significantly. Timings seem to point to the encoding of the String to UTF8. I have replaced JSon by AttoJson (there was also JSONb, which seems quite similar), which allows me to work solely with ByteStrings, bypassing the calls to utf8-string completely. Performance has improved noticeably. I'm worried that I've lost full UTF8 compatibility, though, haven't I? No double byte characters will work in that setup? Is Data.Text an alternative? Can I use that everywhere, including for dealing with sockets (the API only mentions Handle). Should I use Data.ByteString.UTF8 everywhere, rewriting the JSON parser to deal with this instead of the Word8 ByteStrings? In short, what's the fastest way to implement receiving/sending UTF8 text across sockets? Thanks for any pointer, -- JP Moresmau http://jpmoresmau.blogspot.com/

3 2

Unnecessarily strict implementations
by Jan Christiansen 03 Sep '10

03 Sep '10

Hi, there is a new ticket that Data.List.intersperse is not as non-strict as possible (http://hackage.haskell.org/trac/ghc/ticket/4282) I have observed some other functions which are unnecessarily strict and it might be advantageous to change their definitions as well. I think it is known that the current implementations of inits and tails are too strict. At least I think I have once read a post to haskell-cafe about this topic. Furthermore intersect is too strict. We have intersect _|_ [] = _|_ and the current implementation is linear in the size of xs if we evaluate intersect xs []. I think simply adding a rule intersect _ [] = [] to the current implementation solves this issue. The implication (<=) :: Bool -> Bool -> Bool is too strict as well. We have False <= _|_ = _|_ as well as _|_ <= True = _|_ while one of these cases could yield True. The problem is that (<=) is defined by means of compare. This effect shows up for all data types with a least element if the default implementation of (<=) by means of compare is used. Furthermore there are a couple of functions which are too strict but whose minimally strict implementations do not provide benefits. For example, reverse is too strict as has already been observed by Olaf Chitil (http://www.cs.kent.ac.uk/people/staff/oc/Talks/ifl2006NonStrictProgramming.… ). Cheers, Jan

10 15

Ord instance of Bool (Was: Unnecessarily strict implementations)
by Henning Thielemann 03 Sep '10

03 Sep '10

Ivan Lazar Miljenovic schrieb: > On 3 September 2010 16:49, Henning Thielemann > <schlepptop(a)henning-thielemann.de> wrote: >> You might object, that it is seldom, that someone intentionally writes >> (a<b) if 'a' and 'b' are complex numbers. However imagine someone >> rewrites an algorithm for real numbers to complex numbers and he relies >> on the type system to catch all inconsistencies. The field operations >> can remain the same, but (<) has to be applied to results of 'abs', >> 'realPart' or other functions that yield a real. > > Fair enough, but on the other hand I don't think we should make a > fetish about enforcing _everything_ in the type system (non-empty > lists, etc.). I would like to express even more in type system. For instance I have recently invested several weeks for hunting space leaks in my code and I'm still not sure, I catched them all. A way to express absence of space leaks in the type system would save me a lot of time and would give me confidence. Regarding True=1 and False=0: Once I programmed in a language where True was represented by -1, because this is represented by bit pattern 1....1. The CPU has an instruction to fill a byte with the content of a flag and you can use this bit pattern for bitwise AND and OR operations. This makes this representation very efficient. This programming language also allowed comparison and conversion of True and False to their numeric representations. I used this intensively. Now imagine I port such programs to Haskell or C, I get lots of bugs for free.

1 0

Ord instance of Bool (Was: Unnecessarily strict implementations)
by Henning Thielemann 03 Sep '10

03 Sep '10

Henning Thielemann schrieb: > Ivan Lazar Miljenovic schrieb: >> On 3 September 2010 04:57, Arie Peterson <ariep(a)xs4all.nl> wrote: >>> On Thu, 2 Sep 2010 19:30:17 +0200, Daniel Fischer >>> <daniel.is.fischer(a)web.de> wrote: >>>> Why would one consider using Ord for Map an abuse? >>>> A kludge, for performance reasons, but an abuse? >>> Because it forces one to declare Ord instances for types which have no >>> natural ordering. It is useful to *not* have such instances, in order to >>> catch programming errors. >> What precisely do you mean by natural ordering? > > E.g. I wanted to have a Set of Gaussian (complex) integers, but I did > not want to define an Ord instance for them, because writing > a < (b :: Gaussian) > is a bug with high probability. I like to answer in advance to the objections that might come. :-) You might object, that it is seldom, that someone intentionally writes (a<b) if 'a' and 'b' are complex numbers. However imagine someone rewrites an algorithm for real numbers to complex numbers and he relies on the type system to catch all inconsistencies. The field operations can remain the same, but (<) has to be applied to results of 'abs', 'realPart' or other functions that yield a real.

1 0

Re: [Haskell-cafe] Unnecessarily strict implementations
by Alexander Solla 03 Sep '10

03 Sep '10

On Sep 2, 2010, at 11:35 PM, Henning Thielemann wrote: > But in the lattice example the roles of 0 and 1 are interchangeable, > aren't they? Sort of. If you try to interchange the roles of 0 and 1, you are interchanging the roles of the meet and join operations. In short, you are constructing the dual lattice. A mirror image is a good analogy for this construction. So, 0 and 1 are interchangeable. In the same way that "True" and "False" are. And "Top" and "Bottom". And "Left" and "Right". Arbitrary structurally, but with a history of consistency across domains.

1 0

On to applicative
by michael rice 03 Sep '10

03 Sep '10

This may be a dumb question, but here goes. Types Maybe, Either, List, are types and also instances of Functor (and Monad). Assuming (->) is also a type, where can I find its type definition? Michael

2 2

creating a type based on a string
by Andrew U. Frank 03 Sep '10

03 Sep '10

I have a user input (string) and need to select one of two types. depending what the input is. is this possible? data A data B data X n = X String op :: String -> X n op "a" = X "a" :: X A op "b" = X "b" :: X B this does obviously not compile. is there a way to achieve that the type X A is produced when the input is "a" and X B when the input is "b"? thank you for help! andrew

5 4

On to applicative
by michael rice 03 Sep '10

03 Sep '10

"Learn You a Haskell ..." says that (->) is a type just like Either. Where can I find its type definition? Michael

8 24

Re: [Haskell-cafe] ANNOUNCE: Haddock version 2.8.0
by David Waern 03 Sep '10

03 Sep '10

2010/9/2 Daniel Peebles <pumpkingod(a)gmail.com>: > Mmm, delicious! Thanks to all involved! Any idea how long it'll take for > this to make it to hackage and regenerate all the documentation up there? > It'd be wonderful to do the same to the GHC documentation too. I don't actually know yet if it's possible to regenerate the documentation on hackage. We're looking into the matter. David

1 0

Multicore speedup and spark conversion with ghc HEAD
by Eric Rannaud 02 Sep '10

02 Sep '10

Follows three runs of a stupid program that should see a speedup (I believe). 1. Compiled with ghc-6.12.3. Run on 1 thread, 4.0 s (real). 2. Compiled with ghc-6.12.3. Run on 2 threads, spark converted, 5.4 s (real), 7.7 s (user). 3. Compiled with ghc-6.13.20100831. Run on 2 threads, but spark *not* converted 4.1 s (real). All runs with disabled parallel GC, which negatively impacts -N2 runs (whether the spark is converted or not). Two questions: A. Why is run (2) slower than (1)? GC is a bit more expensive, as one would expect, but not enough to explain the difference (only explains 0.3 s). B. ghc HEAD doesn't convert the spark. Why is that? Thanks. ---- module Main where import Control.Parallel fac :: Integer -> Integer fac n = aux n 1 where aux 0 _ = 0 aux 1 m = m aux n m = let p = n * m in p `pseq` aux (n - 1) p main = do let x = fac 100000 y = fac 100001 in print (x `par` y `pseq` (x + y)) ---- $ ghc-6.12.3 -O2 -threaded -rtsopts Test.hs --make $ time ./Test +RTS -N1 -qg -sstderr > /dev/null ./Test +RTS -N1 -qg -sstderr 20,460,660,928 bytes allocated in the heap 2,492,368 bytes copied during GC 462,128 bytes maximum residency (3 sample(s)) 76,576 bytes maximum slop 4 MB total memory in use (1 MB lost due to fragmentation) Generation 0: 35093 collections, 0 parallel, 0.14s, 0.17s elapsed Generation 1: 3 collections, 0 parallel, 0.00s, 0.00s elapsed MUT time (elapsed) GC time (elapsed) Task 0 (worker) : 0.00s ( 0.00s) 0.00s ( 0.00s) Task 1 (worker) : 0.00s ( 3.84s) 0.00s ( 0.00s) Task 2 (bound) : 3.87s ( 3.84s) 0.14s ( 0.17s) SPARKS: 1 (0 converted, 1 pruned) INIT time 0.00s ( 0.00s elapsed) MUT time 3.83s ( 3.84s elapsed) GC time 0.14s ( 0.17s elapsed) EXIT time 0.00s ( 0.00s elapsed) Total time 3.97s ( 4.02s elapsed) %GC time 3.6% (4.3% elapsed) Alloc rate 5,345,814,403 bytes per MUT second Productivity 96.4% of total user, 95.2% of total elapsed gc_alloc_block_sync: 0 whitehole_spin: 0 gen[0].steps[0].sync_large_objects: 0 gen[0].steps[1].sync_large_objects: 0 gen[1].steps[0].sync_large_objects: 0 real 0m4.022s user 0m3.970s sys 0m0.051s $ time ./Test +RTS -N2 -qg -sstderr > /dev/null ./Test +RTS -N2 -qg -sstderr 20,600,461,512 bytes allocated in the heap 3,585,432 bytes copied during GC 458,480 bytes maximum residency (14 sample(s)) 76,576 bytes maximum slop 5 MB total memory in use (1 MB lost due to fragmentation) Generation 0: 34803 collections, 0 parallel, 0.43s, 0.48s elapsed Generation 1: 14 collections, 0 parallel, 0.00s, 0.00s elapsed MUT time (elapsed) GC time (elapsed) Task 0 (worker) : 0.00s ( 0.00s) 0.00s ( 0.00s) Task 1 (worker) : 3.72s ( 4.91s) 0.24s ( 0.25s) Task 2 (bound) : 3.91s ( 4.91s) 0.19s ( 0.23s) Task 3 (worker) : 0.00s ( 4.91s) 0.00s ( 0.00s) SPARKS: 1 (1 converted, 0 pruned) INIT time 0.00s ( 0.00s elapsed) MUT time 7.29s ( 4.91s elapsed) GC time 0.43s ( 0.48s elapsed) EXIT time 0.00s ( 0.00s elapsed) Total time 7.72s ( 5.39s elapsed) %GC time 5.6% (8.9% elapsed) Alloc rate 2,824,733,790 bytes per MUT second Productivity 94.4% of total user, 135.2% of total elapsed gc_alloc_block_sync: 0 whitehole_spin: 0 gen[0].steps[0].sync_large_objects: 0 gen[0].steps[1].sync_large_objects: 0 gen[1].steps[0].sync_large_objects: 0 real 0m5.397s user 0m7.724s sys 0m0.443s $ ghc-6.13.20100831 -O2 -threaded -rtsopts Test.hs $ time ./Test +RTS -N2 -qg -sstderr > /dev/null ./Test +RTS -N2 -qg -sstderr 20,458,286,584 bytes allocated in the heap 2,705,816 bytes copied during GC 463,520 bytes maximum residency (3 sample(s)) 73,032 bytes maximum slop 5 MB total memory in use (1 MB lost due to fragmentation) Generation 0: 35088 collections, 0 parallel, 0.19s, 0.22s elapsed Generation 1: 3 collections, 0 parallel, 0.00s, 0.00s elapsed MUT time (elapsed) GC time (elapsed) Task 0 (worker) : 0.00s ( 0.00s) 0.00s ( 0.00s) Task 1 (worker) : 0.00s ( 3.92s) 0.00s ( 0.00s) Task 2 (bound) : 3.90s ( 3.92s) 0.19s ( 0.22s) Task 3 (worker) : 0.00s ( 3.92s) 0.00s ( 0.00s) SPARKS: 1 (0 converted, 1 pruned) INIT time 0.00s ( 0.00s elapsed) MUT time 3.84s ( 3.92s elapsed) GC time 0.19s ( 0.22s elapsed) EXIT time 0.00s ( 0.00s elapsed) Total time 4.03s ( 4.14s elapsed) %GC time 4.7% (5.2% elapsed) Alloc rate 5,329,874,595 bytes per MUT second Productivity 95.3% of total user, 92.7% of total elapsed gc_alloc_block_sync: 0 whitehole_spin: 0 gen[0].sync_large_objects: 0 gen[1].sync_large_objects: 0 real 0m4.144s user 0m4.027s sys 0m0.059s

1 0

First questions!
by Eoin C. Bairéad 02 Sep '10

02 Sep '10

Example 2 Prelude> let fac n = if n == 0 then 1 else n * fac (n-1) How does it know to stop ? and why does fac 2.5 hang? thanks Eoin -- -- Eoin C. Bairéad Dublin, Ireland Áth Cliath, Éire

5 4

ANNOUNCE: stringsearch 0.3.1, fast searching, splitting and replacing of ByteStrings
by Daniel Fischer 02 Sep '10

02 Sep '10

Changes vs. 0.3.0: - fixed a space leak in the splitting of lazy ByteStrings Changes of the 0.3 series vs. 0.2.*: - improved performance of the searching functions - new functionality: - breaking of ByteStrings at the first occurrence of a substring - splitting a ByteString at each occurrence of a substring - replacing all occurrences of a substring with another string Where bytestring provides the same functionality (Data.ByteString.breakSubstring, Data.ByteString.findSubstrings), the implementations in stringsearch are typically much faster. By default, stringsearch uses an enhanced Boyer-Moore algorithm to locate a pattern, but it also provides other algorithms which may be better in special cases (Knuth-Morris-Pratt; DFA).

1 0

Linking issues with HaskellDB/HDBC/ODBC
by Neil Davies 02 Sep '10

02 Sep '10

Hi Anyone got any hints as to why this linkage error is occurring (GHC 6.12.3, Mac OSX 10.6 (and 10.5 has same issue)): cabal install haskelldb-hdbc-odbc --enable-documentation --root-cmd=sudo --global Resolving dependencies... Configuring haskelldb-hdbc-odbc-0.13... Preprocessing library haskelldb-hdbc-odbc-0.13... Preprocessing executables for haskelldb-hdbc-odbc-0.13... Building haskelldb-hdbc-odbc-0.13... [1 of 1] Compiling Database.HaskellDB.HDBC.ODBC ( Database/HaskellDB/HDBC/ODBC.hs, dist/build/Database/HaskellDB/HDBC/ODBC.o ) Registering haskelldb-hdbc-odbc-0.13... [1 of 2] Compiling Database.HaskellDB.HDBC.ODBC ( Database/HaskellDB/HDBC/ODBC.hs, dist/build/DBDirect-hdbc-odbc/DBDirect-hdbc-odbc-tmp/Database/HaskellDB/HDBC/ODBC.o ) [2 of 2] Compiling Main ( DBDirect.hs, dist/build/DBDirect-hdbc-odbc/DBDirect-hdbc-odbc-tmp/Main.o ) Linking dist/build/DBDirect-hdbc-odbc/DBDirect-hdbc-odbc ... Undefined symbols: "_CFBundleCopyResourceURL", referenced from: _SQLDriverConnect_Internal in libodbc.a(connect.o) "___CFConstantStringClassReference", referenced from: cfstring=org.iodbc.core in libodbc.a(connect.o) cfstring=iODBCadm.bundle in libodbc.a(connect.o) "_CFURLCopyFileSystemPath", referenced from: _SQLDriverConnect_Internal in libodbc.a(connect.o) "_CFRelease", referenced from: _SQLDriverConnect_Internal in libodbc.a(connect.o) _SQLDriverConnect_Internal in libodbc.a(connect.o) "_CFStringGetCString", referenced from: _SQLDriverConnect_Internal in libodbc.a(connect.o) "_CFBundleGetBundleWithIdentifier", referenced from: _SQLDriverConnect_Internal in libodbc.a(connect.o) ld: symbol(s) not found collect2: ld returned 1 exit status cabal: Error: some packages failed to install: haskelldb-hdbc-odbc-0.13 failed during the building phase. The exception was: ExitFailure 1 Hints gratefully received!... Cheers Neil

1 0

ArrowCircuit, delay and space leaks
by Ben 02 Sep '10

02 Sep '10

Hello Arrow-theorists -- In a previous email Maciej Piechotka showed me how to construct a recursive function I wanted via ArrowCircuits. This computes the running sum of a stream of Ints. rSum :: ArrowCircuit a => a Int Int rSum = proc x -> do rec let next = out + x out <- delay 0 -< next returnA -< next Although this arrow runs in linear time, it exhausts the stack (I've compiled with ghc -02.) The obvious strict non-arrow version runs in linear time and constant space : rSum :: [Int] -> [Int] rSum = rSum' 0 where rSum' _ [] = [] rSum' n (x:xs) = let n' = x+n in n' `seq` n' : rSum n' xs It is ironic because arrows were used in the past to plug space leaks. It seems that using delay here introduces a growing stack of thunks. I have tried decorating everything I could think of with `seq` in the pointfree and pointed versions, to no avail. Is there a (pointed or point-free) version which runs in linear time and constant space? Best regards, Ben PS I tried manually translating the ArrowCircuit into a length-preserving stream function (SF in Hughes's paper) to try to understand what was going on. I ended up with rSum :: [Int] -> [Int] rSum xs = zipWith (+) xs $ 0 : rSum xs which is not quite right as it is quadratic. But I think it captures the basic idea of the translation.

1 1

Statically tracking "validity" - suggestions?
by strejon 02 Sep '10

02 Sep '10

Hello. I'm using Haskell to write a specification for some software. The software uses certificates (standard X.509 certificates) and stores user name information in the Subject's CommonName field. The X.509 standard doesn't actually require the presence of a CommonName field so the contents of the Subject section (with the rest of the fields omitted) are just represented by a Maybe User_Name. > import Data.List (find, concat) > import Data.Maybe (fromJust, isJust) > > type User_Name = String > type Public_Key = Integer > data Subject_Name = Subject_Name (Maybe User_Name) deriving (Show, Eq) > > data Certificate = Certificate { > certificate_subject :: Subject_Name, > certificate_key :: Public_Key, > certificate_issuer :: String, > certificate_serial :: Integer > } deriving (Show, Eq) This is all well and good, but the problem is that the validity of certificates isn't tracked statically and I have to use the following as guards on all functions that only expect valid certificates (and inevitably handle cases that I know can't actually happen but have to be handled in pattern matching and the like, bloating the specification): > user_name :: Subject_Name -> Maybe User_Name > user_name (Subject_Name name) = name > > is_valid :: Certificate -> Bool > is_valid = isJust . user_name . certificate_subject I'm aware of phantom types and the like, but I've been unable to work out how to use them (or another type system extension) to properly track "validity" on the type level. I'd want something like: validate :: Certificate Possibly_Valid -> Maybe (Certificate Valid) With later functions only accepting values of type "Certificate Valid". Is there a simple way to do this? -- View this message in context: http://old.nabble.com/Statically-tracking-%22validity%22---suggestions--tp2… Sent from the Haskell - Haskell-Cafe mailing list archive at Nabble.com.

8 8

questions about Arrows
by Ben 01 Sep '10

01 Sep '10

Hello -- Three related questions, going from most specific to most general : 1 ) Consider the stream processing arrow which computes a running sum, with two implementations : first using generic ArrowCircuits (rSum); second using Automaton (rSum2) : module Foo where import Control.Arrow import Control.Arrow.Operations import Control.Arrow.Transformer import Control.Arrow.Transformer.All rSum :: ArrowCircuit a => a Int Int rSum = proc x -> do rec out <- delay 0 -< out + x returnA -< out rSum2 = Automaton (f 0) where f s n = let s' = s + n in (s', Automaton (f s')) runAuto _ [] = [] runAuto (Automaton f) (x:xs) = let (y, a) = f x in y : runAuto a xs take 10 $ runAuto rSum [1..] [0,1,3,6,10,15,21,28,36,45] take 10 $ runAuto rSum2 [1..] [1,3,6,10,15,21,28,36,45,55] Note that the circuit version starts with the initial value zero. Is there a way to write rSum2 in the general ArrowCircuit form, or using ArrowLoop? 2) Are the ArrowLoop instances for (->), Kleisli Identity, and Kleisli ((->) r) all morally equivalent? (e.g., up to tagging and untagging?) 3) One can define fix in terms of trace and trace in terms of fix. trace f x = fst $ fix (\(m, z) -> f (x, z)) fix f = trace (\(x, y) -> (f y, f y)) undefined Does this mean we can translate arbitrary recursive functions into ArrowLoop equivalents? Best regards, Ben

2 3

open and closed
by Gábor Lehel 01 Sep '10

01 Sep '10

This is pure speculation, inspired in part by Brent Yorgey's blog post[1] from a few weeks ago. I'm wondering if it might be possible, in theory, to have both open and closed variants for each of value-level functions, type functions, and classes, in a fairly analogous way. (Maybe you could even have open (G)ADTs, which you would then need open functions to match on; or maybe a closed one with a case for _ to ensure exhaustiveness.) In each case you'd have the closed variant requiring you to keep all the definitions in the same module, permitting overlap, and trying to match definitions in the order they're listed; whereas the open variant would let you have definitions across modules, would forbid overlap (or would require definitions to be equivalent where they overlap, as with type families), and would always select the uniquely matching definition. Open value-level functions with this scheme would be inherently partial, which is bad. (It's not a problem at the type level because you just get a compile error if nothing matches, but an exception at runtime isn't so nice.) As a solution, perhaps it might be possible to allow a limited form of overlap (or don't even call it overlap) for the open variants: a default "use this is if nothing else matches" definition (which would need to be in the same module as the original class / type family declaration, or whatever ends up being analogous for open value-level functions, maybe the type signature). That way you could use Maybe for open value-level functions and make the default Nothing, among other options. Overlap in type functions allegedly makes typechecking unsound; I don't know if that would also hold in this more limited case. This would definitely break the property where adding or removing an import can't change the behaviour of a program other than whether it compiles, which is considered very important by many [2], so maybe it's not a good solution. (Possibly you could add explicit import/export control for instances/other-open-things to alleviate this, in a way so that definitions for open thingies with default definitions (at least) would always have to imported explicitly, thereby acknowledging that it might change behaviour... or maybe that would be a bandaid too far, I dunno.) (I think this would also cover most (if not all?) of the use cases for OverlappingInstances, which permits overlap and selects the most specific instance in a more general fashion; but maybe that doesn't matter if the two are equally bad, I don't know. I'm not 100% clear on peoples' opinion of OverlappingInstances, but I as far as I know the problems are twofold: both import-unsafeness, and the matter of how you would actually define "most specific" in a way that's both rigorous and intuitive; this would remove at least the latter.) Anyway, thoughts? Is this all completely crazy and way out there? [1] http://byorgey.wordpress.com/2010/08/05/typed-type-level-programming-in-has… [2] http://hackage.haskell.org/trac/haskell-prime/wiki/LanguageQualities -- Work is punishment for failing to procrastinate effectively.

3 5

ICFP Hotel Room
by Michael D. Adams 01 Sep '10

01 Sep '10

Hi all, I'm a graduate student (male) and am looking for a (male) roommate to split the cost of a hotel room at ICFP. If anyone is interested in splitting a room, please drop me a line. I will be attending the workshops collocated with ICFP so I currently have a reservation at the conference hotel (at the conference rate) with check-in on September 24 (the day before the first workshop) and check-out on October 3 (the day after the last workshop). Michael D. Adams Ph.D. Student, Indiana University

2 2

ANN: Hayoo! 2.1
by "Timo B. Hübel" 01 Sep '10

01 Sep '10

Hi, We are pleased to announce the next major release 2.1 of Hayoo!, the Haskell API search engine with find-as-you-type and suggestions. Visit Hayoo! here: http://holumbus.fh-wedel.de/hayoo What's new? Thanks to Uwe Schmidt, we have completely revamped the indexer, which now also crawls package information from Hackage. Hence, Hayoo! now searches package names, package categories, package descriptions etc., too, and shows you some package results along with the functions found (some of you may have noticed this already, since this is live for testing purposes since a few months). For example, this will find you all packages in the category "Algorithms" that will do something with "sat": category:algorithms sat This will find you some strict datastructures (i.e. synopsis contains "strict" and category contains "data"): synopsis:strict category:data As we now have package information present in the search index, the algorithm for ranking the results has been adjusted to mainly depend on reverse package dependencies. Nevertheless, we are still trying to optimize this. The new indexer also supports incremental index updates, which made a rebuild of the whole infrastructure around it possible. This way, we are now able to provide daily index updates. Useful figures about the current index are shown below the query input field. Additionally, we have made some optimizations and performance improvements. This allowed us to leverage the restrictions on the query length and hence it is now possible to search for any single character (try searching for "s"). In the result display, the whole function description is now included and its formatting is preserved. Internally, the HTML rendering part has been completely rewritten, which hopefully allows for faster adoption of new features. Please let us know about any issues or suggestions. Especially some opinions about how to integrate the package information in the result display would be appreciated. Thanks, Timo

1 0

Announce: Significant performance improvements for Data.Map
by Don Stewart 01 Sep '10

01 Sep '10

http://hackage.haskell.org/trac/ghc/ticket/4277 Proposal: Significant performance improvements for Data.Map Description Milan Straka's recent [52] Haskell Symposium paper (PDF) shed light on the containers:Data.Map library, indicating there were both algorithmic and stylistic performance improvements to be made. 52. http://research.microsoft.com/~simonpj/papers/containers/containers.pdf This proposal provides a patch that [53] dramatically improves performance across the API. Three standard techniques are applied to the code: * [54] Worker/Wrapper transformations of recursive functions with constant arguments (aka. the [55] static argument transformation). * Explicit inlining of wrapper functions. * Explicit strictness of keys to functions. 53. http://is.gd/eJHIE 54. http://www.workerwrapper.com/ 55. http://hackage.haskell.org/trac/ghc/ticket/888 Three complementary, but orthogonal patches are provided. 1. Add a testsuite, [56] with coverage data (currently 91% of top level functions, and all core functions). 2. Add a micro-benchmark suite based on [57] Criterion, for empirical evidence of improvements to each function. 3. The optimization patch itself. All 3 patches should be applied, under this proposal. 56. http://code.haskell.org/~dons/tests/containers/hpc_index.html 57. http://hackage.haskell.org/package/criterion The [58] benchmark results are very strong: * An average speedup across the core api of 47% (on intel i7 / linux 64 bit), and; * 36% on Mac / intel core 2 duo 32 bit). http://i.imgur.com/05BWe.png 58. http://is.gd/eJHIE No bugs were identified in the development of the comprehensive testsuite, which includes a large set of unit tests from [60] Kazu Yamamoto 60. http://twitter.com/kazu_yamamoto/status/22351727559 A fork of the containers package, with the 3 patches (and a version bump to make it easier to test out) is available: darcs get http://code.haskell.org/~dons/code/containers/ Separately, the patches are attached to this ticket. The consideration period is 3 weeks (before ICFP). __________________________________________________________________ Work carried out over 28/29th August, 2010 in Utrecht, NL, by Johan Tibell and Don Stewart.

4 5

:Trace has no history
by Steve 01 Sep '10

01 Sep '10

I am trying to debug a problem in GHCI. I invoke my method with trace but when it breaks on exception i can't get this history. Output is below. Thanks. relude Symbols> :set -fbreak-on-exception Prelude Symbols> :trace myMethod Loading package HUnit-1.2.2.1 ... linking ... done. Loading package syb-0.1.0.2 ... linking ... done. Loading package base-3.0.3.2 ... linking ... done. Loading package old-locale-1.0.0.2 ... linking ... done. Loading package time-1.1.4 ... linking ... done. Loading package random-1.0.0.2 ... linking ... done. Loading package QuickCheck-1.2.0.0 ... linking ... done. Loading package Decimal-0.1.0 ... linking ... done. Loading package array-0.3.0.0 ... linking ... done. Loading package Diff-0.1.2 ... linking ... done. Loading package bytestring-0.9.1.5 ... linking ... done. Loading package containers-0.3.0.0 ... linking ... done. Loading package mtl-1.1.0.2 ... linking ... done. Loading package old-time-1.0.0.3 ... linking ... done. Loading package convertible-1.0.9 ... linking ... done. Loading package utf8-string-0.3.4 ... linking ... done. Loading package HDBC-2.2.6 ... linking ... done. Loading package HDBC-mysql-0.6.3 ... linking ... done. Loading package parsec-2.1.0.1 ... linking ... done. Loading package network-2.2.1.7 ... linking ... done. Loading package HTTP-4000.0.9 ... linking ... done. Loading package binary-0.5.0.2 ... linking ... done. Loading package digest-0.0.0.8 ... linking ... done. Loading package filepath-1.1.0.3 ... linking ... done. Loading package unix-2.4.0.0 ... linking ... done. Loading package directory-1.0.1.0 ... linking ... done. Loading package pretty-1.0.1.1 ... linking ... done. Loading package zlib-0.5.2.0 ... linking ... done. Loading package zip-archive-0.1.1.6 ... linking ... done. Loading package Core-0.0.1 ... linking ... done. Beginning Update Stopped at <exception thrown> _exception :: e = GHC.Exception.SomeException (GHC.Exception.D:Exception _ (GHC.Show.D:Show ...) ....) (GHC.IO.Exception.IOError Nothing GHC.IO.Exception.UserError ....) [<exception thrown>] Prelude Symbols> :history Empty history. Perhaps you forgot to use :trace?

3 3

Three new implementations of multi-prompt delimited control
by oleg＠okmij.org 01 Sep '10

01 Sep '10

The monadic framework for delimited continuations described in the paper by Dybvig, Peyton Jones and Sabry (JFP 2007) has found many applications, for example, fair backtracking search, final zippers, direct-style web programming, direct-style code generation, and probabilistic programming. The extensive experience suggested improvements in efficiency and, mainly, programmer's convenience. The three new libraries are novel implementations of the enhanced framework. Prompts, for instance, can now be bound to top-level identifiers and do not have to be passed around explicitly or through the extra Reader monad. The new libraries benefited from the experience of implementing delimited control on several platforms. All three libraries provide monad transformers, with basic operations to capture and reinstall delimited continuations: pushPrompt, shift, shift0, control, takeSubCont/pushSubCont. All three libraries support multiple, typed prompts. All three libraries are quite distinct from the original implementation in Dybvig, Peyton Jones, Sabry's paper. For instance, none of the new libraries use unsafeCoerce. All three implementations are derived from the specification of delimited control: from the reduction semantics or from the definitional interpreter. The new libraries differ in -- performance -- ease of understanding -- constraints on the base monad or the prompt types -- flavors of prompts and support for global prompts The libraries are named CCRef, CCExc and CCCxe. The complete code of the libraries along with the regression test suite are publicly available at http://okmij.org/ftp/continuations/CCmonad/ The directory includes sample code (Generator1.hs and Generator2.hs), implementing generators like those of Python. A more extensive example is the porting of the LogicT library (of fair backtracking monad transformers), from the old CC implementation to CCExc/CCCxe: http://okmij.org/ftp/Haskell/LogicT.tar.gz One of the sample applications of LogicT, of a computer playing 5x5 tic-tac-toe against itself, was used as a macro-benchmark of the libraries. The end of the file TicTacToe.hs summarizes the results. The new libraries are faster (so the reader who may wish to play will have less time to think). The library CCRef is closest to the interface of Dybvig, Peyton Jones and Sabry. CCRef is derived from the definitional interpreter using the implementation techniques described and justified in the FLOPS 2010 paper. The monad transformer CC implemented by CCRef requires the base monad to support reference cells. In other words, the base monad must be a member of the type class Mutable: that is, must be IO, ST, STM or their transformer. CCRef adds to the original interface the frequently used function abortP as a primitive. As one may notice from their names, the libraries CCExc and CCCxe are closely related. CCCxe is derived as a CPS version of CCExc. CCCxe is sometimes more efficient; it is always less perspicuous. Both libraries provide the identical interface and are interchangeable. It seems that CCExc is faster at delimited control but imposes more overhead on the conventional code; CCCxe is dual. It pays to use CCCxe in code with long stretches of determinism punctuated by fits and restarts. We now explain new features of CCExc. It is the most direct implementation of the bubble-up (bottom-up) reduction semantics of multi-prompt delimited control, described on PDF page 57 of http://okmij.org/ftp/gengo/CAG-talk.pdf Unlike all other implementations of delimited control in Haskell, CCExc is _not_ based on the continuation monad. Rather, the monad of CCExc is an extension of the Error monad: a monad for restartable exceptions. CCExc offers not one monad transformer but a family (CC p), parameterized by the prompt flavor p. The library defines several prompt flavors; the users are welcome to define their own. Prompt flavors are inherently like exception flavors (the FLOPS 2010 paper even calls prompts `exception types' or `exception envelopes'). Control.Exception defines singular global exceptions such as BlockedOnDeadMVar. There are global exceptions like ErrorCall, parameterized by the error string. There are closed global variants, such as ArithException, with the fixed number of alternatives. There are also open variants, SomeException, with any number of potential alternatives. Users may define their own exception types, whose visibility may be restricted to a module or a package. Finally, one may even generate distinct expression types dynamically, although that is seldom needed. The libraries CCExc and CCCxe support all these flavors. On one end is the prompt flavor (PS w). There is only one prompt of that flavor, which is globally defined and does not have to be passed around. The monad transformer (CC (PS w)) then is the monad transformer for regular, single-prompt delimited continuations, for the answer-type w. Danvy/Filinski test, which looks in Scheme as > (display (+ 10 (reset (+ 2 (shift k (+ 100 (k (k 3)))))))) appears as follows in Haskell: > test5 = (print =<<) . runCC $ > incr 10 . pushPrompt ps $ > incr 2 . shiftP ps $ \sk -> incr 100 $ sk =<< (sk 3) where > incr :: Monad m => Int -> m Int -> m Int > incr n = ((return . (n +)) =<<) [A reader might wish to try to predict the result of test5.] The global identifier ps is defined in CCExc. One should read the operator (=<<), the flipped bind, as a ``call-by-value application'', akin to the application in CBV languages such as Scheme. That is, "f =<< e" is the application that first evaluates the argument e, performing its effects. The value is passed to f, which is evaluated in turn. The application "sk 3" is an optimized version of "sk =<< (return 3)". The appearance of print tells us that test5 is the IO computation. If we rather had the result of test5 as a pure value (an integer), we merely need to pass the result of the runCC expression to runST. The file Generator1.hs shows one example of using PS; the file SRReifT.hs of the LogicT is a larger example. The file Generator2.hs demonstrates why we may need more than one prompt (perhaps with different types). The library offers several flavors of multiple prompts: closed unions (P2) and open unions (PP, PM, PD). The open unions are like SomeException. The prompt flavor PD carries an extra integer identifier to further distinguish prompts of the same type. It becomes possible therefore to dynamically generate an arbitrary number of PD prompts, which was required in Dybvig, Peyton Jones and Sabry's framework. We close by juxtaposing the Python code that uses generators to traverse a binary tree in-order >>> def inorder(t): ... if t: ... for x in inorder(t.left): ... yield x ... yield t.label ... for x in inorder(t.right): ... yield x with the corresponding Haskell code (excerpted from Generator1.hs) > in_order :: (Monad m) => Tree -> CC (P m Label) m () > in_order Leaf = return () > in_order (Node label left right) = do > in_order left > yield label > in_order right In Python, 'yield' is a keyword and generators are built-in. In Haskell, yield is a regular, small, user-defined function, and generators are programmed-in.

1 0

Quick Question for QuickCheck2
by Sebastian Höhn 01 Sep '10

01 Sep '10

Hello, perhaps I am just blind or is it a difficult issue: I would like to generate Char values in a given Range for QuickCheck2. There is this simple example from the haskell book: instance Arbitrary Char where arbitrary = elements (['A'..'Z'] ++ ['a' .. 'z'] ++ " ~!@#$%^&*()") This does not work in QuickCheck2 since the instance is already defined. How do I achieve this behaviour in QC2? Thanks for helping. Sebastian

6 13

Fourth (and Fifth) GhentFPG Meeting: Date and Call for Talks
by Jeroen Janssen 31 Aug '10

31 Aug '10

(apologies if you receive multiple copies) Dear all, We would like to announce that the fourth meeting of the Ghent Functional Programming Group will be held on Thursday, October 7th at 19h. The location will again be the Technicum building of Ghent University (Sint-Pietersnieuwstraat 41, 9000 Gent). Anyone is free to give a talk, so if you feel like giving one, just contact jejansse(a)gmail.com. The final program will be announced in a few weeks. Finally, we would also like to remind you that GhentFPG is organizing BelHac, a Haskell hackathon on 5-7 November 2010. More details can be found at http://www.haskell.org/haskellwiki/Ghent_Functional_Programming_Group/BelHac The fifth GhentFPG meeting will take place at this hackathon, so if you plan on going, and feel like giving a talk at this fifth meeting, just contact me. We would be more than happy to have some international speakers at our meeting! Hope to see you then, The GhentFPG Organizing Committee.

1 0

ANNOUNCE: iteratee-compress 0.1
by Maciej Piechotka 31 Aug '10

31 Aug '10

Iteratee-compress provides compressing and decompressing enumerators. Currently only gzip is provided but at least bzip is planned. Additionally more fine-control over stream (i.e. flushing) is planned. ---- Library currently depends on zlib haskell library only for sharing parameters data. However no zlib function is called (the needed functions are not exported) and the symbols it uses from necessity are deprecated. Would it be better to copy the parameters from zlib and drop the dependency? Please note also that the library do not bundle zlib (C) as zlib (Haskell) do.

2 1

Arrow transformers: how to make them wright?
by Permjacov Evgeniy 31 Aug '10

31 Aug '10

A Control.Arrow in base package introduces an arrow type, and ghc have good support for arrow notation. Many things, avaible in monads, are avaible in arrows as well. There is an arrows package, that introduces some arrow classes : state, reader, writer and so on. However, it does not introduce systematic lifting of arrow classes operations. Arrows are generalisation of monads. There are libraries, that introduces systematic lifting of operations from monad classes. So, the quesions are: what operations should be in arrow transformer class? Captain Obvious says, it should look at least like: class ArrowTrans t where lift :: ( Arrow a, Arrow (t a) ) => a b c -> t a b c what laws arrow transformers must obey? C.O. says, at least lift a b c >>> lift a c d == lift ( a b c >> a c d ) how to perform lifting of actions for classes like this: class Arrow a => ArrowError a e| a-> e where raise :: a e () handle :: a e c -> a b c -> a b c class Arrow a => ArrowReader a e | a -> e where look :: a () e local :: a b c -> a (b,e) c The answers lies somewhere in category theory, C.O. says. Of course, such answer is not satisfactory.

3 2

ANNOUNCE: Darcs hacking sprint (15-17 Oct, Orleans)
by Eric Kow 31 Aug '10

31 Aug '10

Hello Haskellers! The Darcs Team will soon be hosting its fifth hacking sprint this October. We would be delighted if you could join us. http://wiki.darcs.net/Sprints/2010-10 Details ------- When: 15-17 October 2010 Where: Orleans, France Who Anybody who wants to hack on Darcs (or Camp, Focal, etc) Beginners especially welcome! Why: Darcs aims to have bi-annual hacking sprints so that we can get together on a regular basis, hold design discussions, hack up a storm and have a lot fun. What: We'll be starting work on the next release after the upcoming Darcs 2.5. Could we see a much fast darcs over networks? Friendlier darcs annotate? Exciting times ahead... We intend to set aside at least one Darcs hacker for mentoring beginners, so if you're new to Haskell or to Darcs hacking, here's a good chance to plunge in and start working on a real world project. How: Email me <kowey(a)darcs.net> to let me know you're interested! Keep in mind that we do have funds to help pay for travel expenses; just let me know if you'd like to come :-) Thanks ------ Thanks to team Florent Becker and University of Orleans for generously offering to host this event! Thanks also to donors from the fundraising drive this year. We'll be using that money to help Darcs hackers get to Orleans Supporting Darcs ---------------- Darcs is a very happy member of the Software Freedom Conservancy. Among other things, the Software Freedom Conservancy makes it easy for open source projects to raise funds and hold assets (as part of a legal entity). For more information on supporting Darcs, see http://darcs.net/donations.html See you there! -- Eric Kow <http://www.nltg.brighton.ac.uk/home/Eric.Kow> For a faster response, please try +44 (0)1273 64 2905.

17 21

Searching for Haskell (was: [Haskell-cafe] Slightly humorous: Headhunters toolbox (example for Germany))
by Henk-Jan van Tuyl 31 Aug '10

31 Aug '10

On Tue, 31 Aug 2010 13:57:42 +0200, Alberto G. Corona <agocorona(a)gmail.com> wrote: > Entering "haskell language" instead of "haskell" the ambiguity > dissapears. Then, Jamaica no longer appears in the crude reality . The > weigth of USA is hides all other country here. > > I think that a more appropriate term to look for haskell interest is > "monad" although it may catch some crazy philosophers too. The result is > interesting, > You can still get things like a page titled "Ben Haskell - Language Technologies Institute - Carnegie Mellon", and of course, not all pages about the programming language contain the word "language". To get proper results you would need a good semantic search engine, but these search engines seem to be in early research stage. Regards, Henk-Jan van Tuyl -- http://Van.Tuyl.eu/ http://members.chello.nl/hjgtuyl/tourdemonad.html --

1 0

combinators in the syb lib -- or generic heterogeneous traversals that fold
by Carter Schonwald 31 Aug '10

31 Aug '10

Hello All, In the course of some code I've been working on, I found I needed generic foldl / foldr over heterogeneous data structures, where I can easily pick whether I want top down left right, botom up left right, and ___ right left traversals, and to in tandem sensibly approach if a parent node should be included altogether What i'm wondering is if i'm somehow overlooking some simpler ways of writing such or if my attached code for the foldl case (the foldr analogue is easy to see from the example code). code with example follows --- my "foldl" that is abstracted from traversal order travL :: (b -> a -> b)-> GenericQ (Maybe a) -> (Maybe a -> b ->(b -> a -> b)->(b->b)-> b) -> GenericQ (b ->b) travL f qry merge x nil = merge (qry x) nil f (\nl-> foldl (flip ($)) nl $ gmapQ (travL f qry merge) x ) --travR could be written as --- travR f qry merge x nil = foldl (flip f) nil $ travL (flip (:)) qry merge x [] -- example usage -- takes the integers in some datastructure, and puts them in a list -- example: flipList :: Data a => a -> [Integer] flipList x = travL (flip (:) ) (mkQ Nothing (Just :: Integer -> Maybe Integer) ) (\ v nl f k -> maybe (k nl) (\y -> k $! f nl y) v ) x [] I suppose that i could simplify it to travL :: GenericQ (Maybe a) -> (Maybe a -> b ->(b->b)-> b) -> GenericQ (b ->b) and have the operand *f* of the fold work within the *merge* parameter, but that doesn't address the important bit in my mind, namely that while its pretty clear to me that I can write the *synthesize*and *everything* combinators using my "travL/R" stuff, its not clear to me that the converse or something close to it is the case. Anyways, what're everyone's thoughts? thanks! -Carter

1 1

Ed Lambda: Functional programming meetup in Edinburgh
by Ollie Saunders 31 Aug '10

31 Aug '10

Hi guys, I'm running a meetup for functional programming in Edinburgh. The first one will be on the 13th of September at Malone's Irish Bar (14 Forrest Road) and will continue every 2nd monday of each month. For the first meetup I think we'll just be having a chat and getting to know each other but I hope to be able to expand it to talks and coding dojos once we have some regular numbers. For more details: http://meetup.com/ed-lambda/ And we're on Twitter: http://twitter.com/ed_lambda

2 1

Support for lock-free/wait-free programming?
by Gregory Collins 30 Aug '10

30 Aug '10

Hello all, Does GHC expose any primitives for things like atomic compare-and-swap? I can't seem to find anything in the docs. I'm wondering if it's possible, for example, to implement things like the wait-free concurrent queue from [1] or a lock-free wait-free hash table like the Azul people are doing [2]. In network servers, we often have a large number of clients fighting over shared resources -- even simple stuff like "which threads are scheduled to timeout?" and "which threads are currently active, so I can kill them if I need to?". Shared mutable collections seem to be a fact of life here. Under load, pure data structures behind MVars don't perform well because of lock contention, and in my experience atomicModifyIORef is marginally better but still suffers from contention issues (probably related to thunk blackholing). Recently I got a ~35% speedup on a benchmark by switching one of these tables from a Map behind an IORef to a hashmap using a striped-locking scheme (see [3] if you're interested.) I think there's a need for high-concurrency data structures like this, and I don't see much on Hackage that addresses it. As much as we like to say that we have a handle on concurrency issues, from what I can see java.util.concurrent.* has us soundly thrashed in this department, especially as it relates to exposing atomic wait-free CPU primitives like the ones in java.util.concurrent.atomic.* [4]. Speaking as a partisan, this cannot be allowed to stand, can it? Cheers, G. ------------------------------------------------------------------------------ [1] Maged M. Michael and Michael L. Scott, "Simple, Fast, and Practical Non-Blocking and Blocking Concurrent Queue Algorithms": http://www.cs.rochester.edu/u/michael/PODC96.html [2] http://www.stanford.edu/class/ee380/Abstracts/070221_LockFreeHash.pdf [3] http://github.com/snapframework/snap-server/blob/master/src/Data/HashMap/Co… [4] http://download.oracle.com/javase/6/docs/api/java/util/concurrent/atomic/At… -- Gregory Collins <greg(a)gregorycollins.net>

4 11

Hackage on Linux
by Andrew Coppin 30 Aug '10

30 Aug '10

Browsing around Hackage, I notice that a seemingly random subset of packages are available for something called "arch linux". Presumably some sort of automatic conversion system is involved, but does anyone know why only certain packages appear? I've noticed that both Debian and OpenSUSE have a very tiny selection of binary Haskell packages too. I'm guessing that these packages are also auto-generated, but presumably selected by hand. (I also don't recall seeing them listed on Hackage.) Anybody know about that? In general, is there an advantage to having native packages for Haskell things? I guess it means you can have binary packages, so you don't need to build from source. And for executables, it means the native package manager can track all the dependencies and install them all for you, potentially without needing a Haskell build environment at all. Is that it, or have I missed something?

21 67

Partial Signatures with Implicit Parameters
by Alex Rozenshteyn 30 Aug '10

30 Aug '10

I would like to specify that a function takes implicit parameters, without specifying its full return type. My main motivation for this is my xmonad config file and the attempt to remove the need for NoMonomorphismRestriction and some of the code smell associated with global variables that wafts in with implicit parameters. I have read this: http://okmij.org/ftp/Haskell/partial-signatures.lhs and even somewhat understood it; however, I tried to apply it to my config file with an implicit parameter in the signature, and I couldn't get it to compile. Is there something inherently different about using this approach with implicit parameters, or am I probably just doing something wrong? P.S. I decided to ask this here instead of in the xmonad mailing list because I feel like this is a question about haskell that was only slightly inspired by my use of xmonad. -- Alex R

2 1

getting started with HJscript?
by Günther Schmidt 30 Aug '10

30 Aug '10

Hi all, I'll probably have to be doing web stuff soon. And I think I would like to be using JavaScript far more than I have in the past. So I'm thinking about using Haskell (HJscript) to generate it for me. How does on go about learning how to use HJscript? Are there any examples / tutorials? Günther

1 0

Contibution to Haskell world
by Николай Кудасов 30 Aug '10

30 Aug '10

Hi all, I am very interested in haskell and most of related things and as I know there are a lot of things to do for haskell world. I have rather small, as I think, expirience with haskell: I've worked with Language.C, alex, happy, parsec and some other stuff that I haven't looked though attentively. Most of haskell code I've seen was highly readable and most of code I wrote was very easy to write. So I liked to write in haskell and I want to make some contribution to its world. As I am rather new to haskell world I ask you for a problem that can be interesting for me and useful for haskell world. Today I am student at Moscow State University and have at least 2 years for some kind of scientific work. P.S. Some interesting topics for me are transparent parallelization, parallel and distibuted computing and computational models. However, many other topics are also interesting for me =) Thanks in advance, Nick

2 1

Higher-order algorithms
by Eugene Kirpichov 30 Aug '10

30 Aug '10

Most of the well-known algorithms are first-order, in the sense that their input and output are "plain" data. Some are second-order in a trivial way, for example sorting, hashtables or the map and fold functions: they are parameterized by a function, but they don't really do anything interesting with it except invoke it on pieces of other input data. Some are also second-order but somewhat more interesting: * Fingertrees parameterized by monoids * Splitting a fingertree on a monotonous predicate * Prefix sum algorithms, again usually parameterized by a monoid or a predicate etc. Finally, some are "truly" higher-order in the sense that is most interesting to me: * The Y combinator * Difference lists Do there exist other nontrivial higher-order algorithms and datastructures? Is the field of higher-order algorithms indeed as unexplored as it seems? I mean that not only higher-order facilities are used, but the essence of the algorithm is some non-trivial higher-order manipulation. For example, parser combinators are not so interesting: they are a bunch of relatively orthogonal (by their purpose) combinators, each of which is by itself quite trivial, plus not-quite-higher-order backtracking at the core. For example, for the Y combinator and difference lists are interesting: the Y combinator builds a function from a function in a highly non-trivial way; difference lists are a data structure built entirely from functions and manipulated using higher-order mechanisms. -- Eugene Kirpichov Senior Software Engineer, Grid Dynamics http://www.griddynamics.com/

9 11

On to applicative
by michael rice 30 Aug '10

30 Aug '10

I'm looking at a discussion of Either (as functor) here: http://learnyouahaskell.com/making-our-own-types-and-typeclasses#the-functo… instance Functor (Either a) where fmap f (Right x) = Right (f x) fmap f (Left x) = Left x And this line in Data.Either Functor (Either a) but no fmap defined here. How come? Michael

4 11

Using GHC Api to affect compilation of a module
by Matias Hernandez 30 Aug '10

30 Aug '10

Hello people, I'm evaluating the use of the GHC API (6.12.3) to piggyback into the compilation process (in order, for example, to implement a custom optimization) and I'm having a lot of trouble doing so. In particular, I tried to modify a program being compiled, by working on its Core representation. The idea is that the skeleton of the program would be something like: runGhc (Just libdir) $ do ... c <- compileToCoreModule targetFile compileCoreToObj False (modify c) ... with modify :: CoreModule -> CoreModule being, for now, a rather trivial (identity) function. The first issue I've found is that compileCoreToObj fails (the error is "expectJust mkStubPaths"). However, I've also found that when compileToCoreModule ends, the .hi and .o files have already been produced, which kind of defeats any attempt to change the core code and then proceeding with the rest of the compilation. Am I doing this right? By scanning over the GHC API documentation those functions seemed to be the appropriate ones to start testing with, but I guess there's something trivial (or not) I'm missing. I'd be really thankful for any input. Best regards, - Matias H.

1 0

Looking for a course using Haskell in the Tokyo area
by DekuDekuplex＠Yahoo.com 30 Aug '10

30 Aug '10

Does anybody know where I can find a course (preferably at the graduate level) using Haskell in the Tokyo area? I searched through "Haskell in education - HaskellWiki" (see http://www.haskell.org/haskellwiki/Haskell_in_education) but was unable to find anything. In particular, if anybody is aware of any courses using Haskell at either the Tokyo Institute of Technology (see http://www.titech.ac.jp/english/) or the University of Tsukuba (see http://www.tsukuba.ac.jp/english/) I would be especially interested. The closest I was able to find was a graduate course in Logic in Computer Software at the University of Tsukuba using OCaml, but I am not especially fond of the syntax of OCaml after having become familiar with Haskell. -- Benjamin L. Russell -- Benjamin L. Russell / DekuDekuplex at Yahoo dot com http://dekudekuplex.wordpress.com/ Translator/Interpreter / Mobile: +011 81 80-3603-6725 "Furuike ya, kawazu tobikomu mizu no oto." -- Matsuo Basho^

1 0

Re: [Haskell-cafe] Unicode pretty-printing
by Peter Gromov 29 Aug '10

29 Aug '10

Thanks for getting back to me. I was imprecise, by UTF8 characters I mean Unicode. My source files are UTF8-encoded, and Haskell reads them fine, it only has problems outputting them in a readable way. At this point I'm not talking of any I/O besides plain console output. Not using Show is not that of a choice, since I'm using HUnit which uses Show and prints the test results via the standard output functions. I've tried to wrap my strings and redefine Show so that it doesn't escape anything, but the standard output functions don't accept that, and HUnit doesn't know anything about System.IO.UTF8: ---- import System.IO.UTF8 import qualified System.IO import Test.HUnit newtype UString = UString String instance Show UString where show (UString s) = s instance Eq UString where (==) (UString s1) (UString s2) = s1 == s2 test1 = TestCase (assertEqual "fail" (UString "абв") (UString "где")) main = System.IO.hSetBinaryMode System.IO.stdout True >> System.IO.UTF8.putStrLn "это тест" --------- Prelude> :load utest.hs [1 of 1] Compiling Main ( utest.hs, interpreted ) Ok, modules loaded: Main. *Main> main это тест *Main> runTestTT test1 ### Failure: fail expected: *** Exception: <stderr>: hPutChar: invalid argument (Illegal byte sequence) --------- I've tried replacing UString X in the test with Data.Text.pack X and even desperately with Data.Text.Encoding.encodeUtf8 (Data.Text.pack X), but no dice. Though this time instead of crashes I get the good old escapes. On 29 August 2010 00:09, Yitzchak Gale <gale(a)sefer.org> wrote: > Peter Gromov wrote: >> Unfortunately, Haskell escapes UTF8 characters. > > What do you mean by "UTF8 characters"? > > Each element of the Char type represents a single Unicode > character, not encoded in UTF-8 or any other encoding. > > When you read a text file using the traditional IO functions, > recent versions of GHC will use the encoding of the > "current locale" (whatever that means on your system) > to decode the input into Unicode, unless you specify > otherwise. The same is true for writing to the console or > to a file. > > As Don pointed out, you may be interested in > using the newer Data.Text instead, especially when > encodings matter to you. It will usually be faster than > traditional IO, and it is designed to be the new standard > for representing text in Haskell. > > A third option would be to read the data as raw binary > bytes, without any decoding, using Data.ByteString. > Then it is totally up to you to do any decoding or > encoding. > > In any case, the standard Show instances will not be > able to do a very good job of displaying non-ASCII > characters; Show cannot make very many assumptions > about your data or your environment. As Don suggested, > you may want to define your own type class similar to > Show that does what you want. > > Regards, > Yitz >

3 4

Unicode pretty-printing
by Peter Gromov 29 Aug '10

29 Aug '10

Hi all, I've been considering using Haskell for my natural language processing project. Due to its nature, it has much to do with Unicode. Unfortunately, Haskell escapes UTF8 characters. I've been able to output these strings via System.IO.UTF8.putStrLn (though I wish it was less painful), but still there are two problems. First, I want to pretty-print not only strings, but any structures made of lists and algebraic data types. Their 'show' calls string's 'show' which escapes all UTF8 symbols. The second problem is that I'm not the only one who wants to output the structures. For example, I want to have tests which check that certain operations produce certain natural language strings. So, I considered using HUnit for that. When its assertEqual fails, it displays the expected versus actual data, which is fine. But, of course, it doesn't know anything about Unicode, and I can't read escaped strings very well to understand what exactly has failed. I really don't want to write yet another unit test framework only for the sake of UTF8. Is there any way to make Haskell display values containing Unicode strings in a readable way? Peter

2 1