June 2007 - Haskell-Cafe

RE: [Haskell-cafe] FFI and Excel VBA
by Lewis-Sandy, Darrell 21 Jun '07

21 Jun '07

Whoops - I posted the wrong version of the exports list. Compilation with that adder.def will fail (since it the Haskell code doesn't export either suber or hello). Below is the revised example: KEYWORDS: Foreign, Export, Win32, DLL, VBA, Excel, GCH, Example The contents of adder.hs are as follows: -------------------------------------------- module Adder(adder) where import Foreign adder :: Int -> Int -> IO Int adder x y = return (id$!(x+y)) foreign export stdcall adder :: Int -> Int -> IO Int -------------------------------------------- The contents of the dllMain.c file are below: -------------------------------------------- #include <windows.h> #include <Rts.h> extern void __stginit_Adder(void); static char* args[] = { "ghcDll", NULL }; BOOL STDCALL DllMain ( HANDLE hModule, DWORD reason, void* reserved ) { if (reason == DLL_PROCESS_ATTACH) { startupHaskell(1, args, __stginit_Adder); return TRUE; } if (reason == DLL_PROCESS_DETACH) { shutdownHaskell(); return TRUE; } return TRUE; } -------------------------------------------- Note that the GHC manual omits the space between the "void" and the __stgint_Adder(void) which causes a compile error. The second case (if (reason == DLL_PROCESS_DETACH) is essential for garbage collection, and shuts down the Haskell runtime when the DLL is unloaded. To execute the Haskell code, I created a VBA module in an Excel workbook with the following code snippet: -------------------------------------------- Private Declare Function adder Lib "adder.dll" _ (ByVal x As Integer, ByVal y As Integer) As Integer Private Sub test() Debug.Print adder(1, 2) End Sub -------------------------------------------- NOTE: If the dll is not ultimately placed in your environments' PATH, then you may have to modify the library name to include the actual path information (or else you will get an error indicating that the library can't be found). Example: ... adder Lib "c:\myDlls\adder\adder.dll" ... Finally, you need to explicitly define an exports file to keep the c compiler from mangling the names too badly. The contents of adder.def are as follows: -------------------------------------------- EXPORTS adder -------------------------------------------- With these preliminaries out of the way, you can compile this to a dll using the following sequence of commands: -------------------------------------------- ghc -c adder.hs -fglasgow-exts ghc -c dllMain.c ghc --mk-dll -optdll--def=adder.def -o adder.dll adder.o adder_stub.o dllMain.o -------------------------------------------- When this is all done, open the XLProject and press F5 to run, or simply type "=adder(1,2)" in any cell of the workbook. My apologies for any confusion caused by my earlier posting. -Darrell Lewis-Sandy _______________________________________________ Haskell-Cafe mailing list Haskell-Cafe(a)haskell.org http://www.haskell.org/mailman/listinfo/haskell-cafe

2 1

Functional Data Structures
by Michael T. Richter 21 Jun '07

21 Jun '07

Is there a good book or web site outlining decent pure-lazy-functional data structures, with or without code samples? -- Michael T. Richter <ttmrichter(a)gmail.com> (GoogleTalk: ttmrichter(a)gmail.com) I'm not schooled in the science of human factors, but I suspect surprise is not an element of a robust user interface. (Chip Rosenthal)

3 2

RE: [Haskell-cafe] FFI and Excel VBA
by Lewis-Sandy, Darrell 21 Jun '07

21 Jun '07

I was able to figure out how to get the example in chapter 11 of the GHC manual to work. Since it was not intuitive (to a non C programmer), I thought that I should post this so that others might take advantage of it. KEYWORDS: Foreign, Export, Win32, DLL, VBA, Excel, GCH, Example The contents of adder.hs are as follows: -------------------------------------------- module Adder(adder) where import Foreign adder :: Int -> Int -> IO Int adder x y = return (id$!(x+y)) foreign export stdcall adder :: Int -> Int -> IO Int -------------------------------------------- The contents of the dllMain.c file are below: -------------------------------------------- #include <windows.h> #include <Rts.h> extern void __stginit_Adder(void); static char* args[] = { "ghcDll", NULL }; BOOL STDCALL DllMain ( HANDLE hModule, DWORD reason, void* reserved ) { if (reason == DLL_PROCESS_ATTACH) { startupHaskell(1, args, __stginit_Adder); return TRUE; } if (reason == DLL_PROCESS_DETACH) { shutdownHaskell(); return TRUE; } return TRUE; } -------------------------------------------- Note that the GHC manual omits the space between the "void" and the __stgint_Adder(void) which causes a compile error. The second case (if (reason == DLL_PROCESS_DETACH) is essential for garbage collection, and shuts down the Haskell runtime when the DLL is unloaded. To execute the Haskell code, I created a VBA module in an Excel workbook with the following code snippet: -------------------------------------------- Private Declare Function adder Lib "adder.dll" _ (ByVal x As Integer, ByVal y As Integer) As Integer Private Sub test() Debug.Print adder(1, 2) End Sub -------------------------------------------- NOTE: If the dll is not ultimately placed in your environments' PATH, then you may have to modify the library name to include the actual path information (or else you will get an error indicating that the library can't be found). Example: ... adder Lib "c:\myDlls\adder\adder.dll" ... Finally, you need to explicitly define an exports file to keep the c compiler from mangling the names too badly. The contents of adder.def are as follows: -------------------------------------------- EXPORTS adder suber hello -------------------------------------------- With these preliminaries out of the way, you can compile this to a dll using the following sequence of commands: -------------------------------------------- ghc -c adder.hs -fglasgow-exts ghc -c dllMain.c ghc --mk-dll -optdll--def=adder.def -o adder.dll adder.o adder_stub.o dllMain.o -------------------------------------------- When this is all done, open the XLProject and press F5 to run, or simply type "=adder(1,2)" in any cell of the workbook. I hope that this was helpful. -Darrell Lewis-Sandy

1 0

advice on GADT type witnesses needed
by David Roundy 21 Jun '07

21 Jun '07

Hi all, Jason and I have been working on getting GADT type witnesses into darcs, and have run into a puzzling error. For the life of me, I can't see how this is an actual error, to the point that I'm wondering if it's actually a bug in ghc. You can check out the code and reproduce this with darcs get http://physics.oregonstate.edu/~roundyd/darcs-gadts cd darcs-gadts autoconf ./configure --with-type-witnesses make darcs At this point ghc will compile for a bit. It shouldn't get past Viewing, since we haven't converted over much of the code yet, but it fails inexplicably on Show. The error message we get is: ghc -DPACKAGE_NAME=\"darcs\" -DPACKAGE_TARNAME=\"darcs\" -DPACKAGE_VERSION=\"1.0.9\" -DPACKAGE_STRING=\"darcs\ 1.0.9\" -DPACKAGE_BUGREPORT=\"bugs(a)darcs.net\" -DSTDC_HEADERS=1 -DHAVE_SYS_TYPES_H=1 -DHAVE_SYS_STAT_H=1 -DHAVE_STDLIB_H=1 -DHAVE_STRING_H=1 -DHAVE_MEMORY_H=1 -DHAVE_STRINGS_H=1 -DHAVE_INTTYPES_H=1 -DHAVE_STDINT_H=1 -DHAVE_UNISTD_H=1 -DGADT_WITNESSES=1 -DHAVE_TERMIO_H=1 -cpp -package regex-compat -package QuickCheck -package mtl -package parsec -package html -package unix -O -funbox-strict-fields -Wall -Werror -I. -I./src -i./src -DHAVE_CURSES -DHAVE_CURL -c src/Darcs/Patch/Show.lhs src/Darcs/Patch/Show.lhs:50:0: Quantified type variable `y' is unified with another quantified type variable `x' When trying to generalise the type inferred for `showPatch' Signature type: forall x y. Patch x y -> Doc Type to generalise: Patch y y -> Doc In the type signature for `showPatch' When generalising the type(s) for showPatch, showComP, showSplit, showConflicted, showNamed make: *** [src/Darcs/Patch/Show.o] Error 1 The relevant code is showPatch :: Patch C(x,y) -> Doc showPatch (FP f AddFile) = showAddFile f ... showPatch (Conflicted p ps) = showConflicted p ps and the trouble comes about because of (in Core.lhs) data Patch C(x,y) where NamedP :: !PatchInfo -> ![PatchInfo] -> !(Patch C(x,y)) -> Patch C(x,y) ... Conflicted :: Patch C(a,b) -> FL Patch C(b,c) -> Patch C(c,c) Still, this makes no sense to me. If any type gurus could help clarify, that would be great. Thanks! -- David Roundy Department of Physics Oregon State University

4 8

Using Template Haskell to automate QuickCheck testing?
by Brent Yorgey 21 Jun '07

21 Jun '07

(I originally tried to send this on Jun 8, but it seems that due to various issues it did not actually get sent over the list. Apologies if anyone gets multiple copies.) Hi all, Following some recent discussions in #haskell, I've decided to try my hand at a module to allow automation of QuickCheck testing. I'm aware that there are already various "homegrown" solutions out there, (e.g. [1],[2]) as well as idiomatic boilerplate to do this (e.g. [3]), but it feels like there ought to be a more elegant/DRY-style solution. In my ideal vision, you'd be able to do something like this: import ModuleToBeTested import Test.AutoQuickCheck -- the library module I want to write prop_foo = blah -- some QuickCheck tests prop_bar = blah blah main = $(runChecks) ...where runChecks would use TH to reflect on the current module, find any top-level function declarations beginning with "prop_", and generate code to run them all through QuickCheck, printing the results. I think the attractions of such a system (if it could actually work) should be obvious. However, after reading all about TH it doesn't seem like there's a way to do this (reflecting on the current module to pull out the names of certain top-level declarations). Since I don't know much about how TH is implemented, I'm not sure whether (1) there's a good reason this is pretty much impossible with TH; (2) it would be possible but it's currently unimplemented; or (3) there actually is a way to do what I want, but I'm not clever enough in the ways of TH to figure it out. (Or (4) none of the above?) Any thoughts or advice would be greatly appreciated! thanks, -Brent [1] http://www.cs.chalmers.se/~rjmh/QuickCheck/quickcheck<http://www.cs.chalmers.se/%7Erjmh/QuickCheck/quickcheck> [2] http://blog.codersbase.com/2006/09/01/simple-unit-testing-in-haskell/ [3] http://www.haskell.org/haskell wiki/How_to_write_a_Haskell_program#Add_some_automated_testing:_QuickCheck

3 2

Re: [Haskell-cafe] Useful IDE features -
by Peter Verswyvelen 21 Jun '07

21 Jun '07

That looks nice, just unfortunate you need to cast to ::Float in homer2?Age::Float. I don't see why this is needed, but I must say I don't understand your code completely yet, working on that :) Also, wouldn't this approach be less performant? Or is GHC that good that ist compiles away all the overhead? >----- Oorspronkelijk bericht ----- >Van: Claus Reinke [mailto:claus.reinke@talk21.com] >Verzonden: dinsdag, juni 19, 2007 01:37 PM >Aan: haskell-cafe(a)haskell.org >Onderwerp: Re: [Haskell-cafe] Useful IDE features - "implement instance" > >> Just another wild idea which I might find useful, but is more like >> refactoring, is to convert the fields of a record to get/set type-classes, >> and refactor all usages of those fields. > >you could use a preprocessor (DrIFT, Data.Derive) to derive the >instances, but you need to share the class declarations between all >client modules. > >> ------------------- >> data Person = Person { name :: String, age :: Float } >> >> main = print $ name p ++ " is " ++ show (age p) ++ " years old" >> where p = Person { name = "Homer", age = 41 } >> ------------------- >>.. > >alternatively, you could generalise this a bit, so that there is only one >class for all combinations of records, fields, and field value types, and >then generalise it further so that you only need one pair of instances >to define selection and update for all records. that kind of operates at >the borders of the language, so you lose portability (the nicest version >is ghc-only; nearly all language extensions used are also supported >by hugs, but with a slightly different interpretation). you'd still need >to share the label types between all client modules. > >claus > >---------------------------------------------------------- >{-# OPTIONS_GHC -fallow-undecidable-instances #-} >{-# OPTIONS_GHC -fallow-overlapping-instances #-} >{-# OPTIONS_GHC -fglasgow-exts #-} > >infixl ? >infixr <:,:< > >------------------- poor man's records > >-- record extension >-- (ghc only: infix constructor; for hugs, use (,) instead) >data fieldValue :< record = fieldValue :< record > >-- field selection (?) and update (<:) >-- needs overlapping instances to recurse down record extensions >-- for hugs: drop the functional dependency, use more type annotations >class Has field value record | field record -> value where > (?) :: record -> field -> value > (<:) :: (field,value) -> record -> record > >-- if the first field matches, we're done >instance Has field value ((field,value) :< record) where > ((_f,v) :< _) ? f = v > (f,v) <: ((_f,_) :< r) = ((f,v) :< r) > >-- otherwise, try again, with the remaining record >instance Has field value record => Has field value ((f,v) :< record) where > ((f',v') :< r) ? f = r ? f > (f,v) <: ((f',v') :< r) = ((f',v') :< ( (f,v)<:r ) ) > >-- some field labels >data Name = Name >data Age = Age > >------------------- a generic version, no separate Person type or instances > >type Person1 = (Name,String) :< (Age,Float) :< () > >homer :: Person1 >homer = (Name,"Homer") :< (Age,41) :< () > >test1 = print $ homer?Name ++ " is " ++ show(homer?Age) ++ " years old" > >------------------- a more down-to-earth version, closer to the original > >data Person = Person String Float > >instance Has Name String Person where > (Person name age) ? Name = name > (Name,newName) <: (Person name age) = Person newName age > >instance Has Age Float Person where > (Person name age) ? Age = age > (Age,newAge) <: (Person name age) = Person name newAge > >defaultPerson = Person "" 0 > >homer2 = (Name,"Homer2") <: (Age,42::Float) <: defaultPerson > >test2 = print $ homer2?Name ++ " is " ++ show(homer2?Age::Float) ++ " years old" > >------------------- > >main = test1 >> test2 > > > >_______________________________________________ >Haskell-Cafe mailing list >Haskell-Cafe(a)haskell.org >http://www.haskell.org/mailman/listinfo/haskell-cafe > >

5 5

1d-rubik
by Arie Groeneveld 21 Jun '07

21 Jun '07

Hi all, I read this on the J -programming forum http://www.jsoftware.com/pipermail/programming/2007-June/007004.html Maybe of interest, especially the part of generating the subgroup or composing a more intelligent solver. quote I found an interesting game, as found on Andrew Nikitin's MSX-BASIC page http://nsg.upor.net/msx/basic/basic.htm , and I am not sure if its solver has been given as a puzzle. Here it goes. 1D Rubik's Cube is a line of 6 numbers with original position: 1 2 3 4 5 6 which can be rotated in 3 different ways in groups of four: _______ _______ (1 2 3 4)5 6 --(0)-> (4 3 2 1)5 6 _______ _______ 1(2 3 4 5)6 --(1)-> 1(5 4 3 2)6 _______ _______ 1 2(3 4 5 6) --(2)-> 1 2(6 5 4 3) Given a scrambled line, return the shortest sequence of rotations to restore the original position. Examples: solve 1 3 2 6 5 4 1 2 1 solve 5 6 2 1 4 3 0 2 solve 6 5 4 1 2 3 0 1 2 end quote What follows is a kind of emulation (in the sense of the nature of the J-program) of the solution of Roger Hui. see http://www.jsoftware.com/pipermail/programming/2007-June/007006.html Remarks: Rewards for me are learning and understanding J programming and programming a Haskell solution for the same problem, plus a bit of group theory. Roger Hui says that for his solution it's not guaranteed that the rotation-sequence is the shortest one --------------------- PROGRAM -------------------------------------------- -- subgroup generators -- all rotations are permutations of order 2 because they leave 2 elements in place -- f.e. [3,2,1,0,4,5] has cycle product (1 4)(2 3) rotaties :: [[Int]] rotaties = [[3,2,1,0,4,5],[0,4,3,2,1,5],[0,1,5,4,3,2]] ident :: [Int] ident = [1..6] rotix :: [[Int]] rotix = [ [e] | e <- [0..2]] -- flip consecutive part of the 1d-rubik ds `roteer` d = map (ds !!) d -- number of misplacements -- equivalent to the parity-function of permutations or the order of a permutation -- it seemed that only even order permutations are solvable, indeed the subgroup generated -- contains only even permutations mispl = sum . map (\[a,b] -> if b-a > 0 then 0 else 1) . combinationsOf 2 -- equivalent to J's : rotaties , ,/{"1/~ rotaties -- to keep in order with the J program I had to change 'map (roteer x)' to 'map (flip roteer x)' rotzelf xs = concat $ xs : [ map (flip roteer x) xs | x <- xs ] -- rotseqs equivalent to J-program line: q , , ,&.>/~ q rotseqs xs = xs ++ (map concat $ [ [x,y] | x <- xs, y <- xs ]) -- mark duplicates function equivalent to J's ~: p -- boolean array where a '0' marks a duplicate markdups = domark [] domark _ [] = [] domark ys (x:xs) | x `elem` ys = 0 : domark (x:ys) xs | otherwise = 1 : domark (x:ys) xs -- b <select> a -- selects elements from array 'a' according to bool array 'b' -- equivalent to J's m#n [] `boolsel` _ = [] (b:bs) `boolsel` (x:xs) | b==1 = x: bs `boolsel` xs | otherwise = bs `boolsel` xs -- after 5 iterations no further change occurs -- the number of elements then reaches the order of the subgroup = 360 (subg, rseqs) = head . drop 4 . iterate tab $ (rotaties, rotix) -- or : head . dropWhile ((/=360) . length . fst) . iterate tab $ (rotaties, rotix) tab (ps , qs) = (bs `boolsel` rs, bs `boolsel` ts) where rs = rotzelf ps ts = rotseqs qs bs = markdups rs solve :: [Int] -> [Int] solve rs | odd . mispl $ rs = error " no solution possible...." | rs == ident = [] -- identity of the subgroup | otherwise = as where rs' = map (flip (-) 1) rs is = fromJust $ elemIndex rs' subg as = rseqs !! is test = map solve [[1,3,2,6,5,4],[5,6,2,1,4,3],[6,5,4,1,2,3],[6,4,2,5,3,1]] greetings @@i = Aai

1 0

Re: [Haskell-cafe] Collections
by Chaddaï Fouché 20 Jun '07

20 Jun '07

Andrew Coppin writes: > Maybe it's just a culture thing then... In your typical OOP language, > you spend five minutes thinking "now, what collection type shall I use > here?" before going on to actually write the code. In Haskell, you just > go "OK, so I'll put a list here..." > Well lists are really useful, but I don't think all Haskell programmers are like you, in fact I think only the enthusiast newbies (like.. you maybe ?) only use lists without asking themselves if there is not a data structure better suited to their problem. A lot of work in the functional world goes to improve existing data structures, traversal and upgrade means and inventing new data structures to resolve real-world problems. Real Haskell programs don't limit themselves to lists, eg. if you look at xmonad you'll see that zippers play a really important role in the powerfulness of the code and it's elegance. -- Jedaï

2 1

Perl-style numeric type
by Brent Yorgey 20 Jun '07

20 Jun '07

Hi all, I've started developing a library to support a "Perl-style" numeric type that "does the right thing" without having to worry too much about types. Explicit static typing of numeric types is really great most of the time, and certainly a good idea for larger projects, but probably everyone's had one of those experiences where you just want to write some simple, "one-off" numeric code that ends up getting cluttered with all sorts of fromIntegers and whatnot just to make the type checker happy. The idea would be to internally use either an Integer, Rational, or Double, and transparently convert between them as necessary. I know I would enjoy having such a numeric type for use in, e.g. programs to solve Project Euler problems. But before I get too far (it looks like it will be straightforward yet tedious to implement), I thought I would throw the idea out there and see if anyone knows of anything similar that has already been done before (a cursory search of the wiki didn't turn up anything). I don't want to reinvent the wheel here. thanks! -Brent PS Also, did anyone get my e-mail to this list of June 8 about Template Haskell and QuickCheck? If you did and it's just that no one knows the answer to my questions, no problem. But I was subscribed in a strange way (through the fa.haskell Google group) and I'm beginning to suspect that perhaps my message never actually got sent over the list. If so I could resend it now that I'm subscribed by more conventional means.

6 12

Avoiding "Non-exhaustive patterns in function f"
by peterv 20 Jun '07

20 Jun '07

Haskell is known for its very strong static type checking, which eliminates a lot of runtime errors. But the following simple program crashes at runtime: data D = A | B f A = True main = print (f B) I understand this has nothing to do with type checking, but why can't the compiler give a warning about this? Or is this by design or because it is impossible to check with more complex recursive data types? Thanks, Peter

6 6