- Haskell-Cafe - Haskell.org

ghc-pkg list says a package is installed, but ghci won't load its exposed module (HDBC-ODBC)
by Thomas Hartman 15 Jun '07

15 Jun '07

ghc-pkg list says a package is installed, but ghci won't load its module (HDBC-ODBC) Any advice? hartthoma@dbnycws28816 ~/haskellInstalls/HDBC-odbc-1.0.1.0 $ ghc-pkg list c:/ghc/ghc-6.6.1\package.conf: Cabal-1.1.6.2, GLUT-2.1.1, HAppS-0.8.4, HDBC-1.0.1, HDBC-odbc-1.0.1.0, HUnit-1.1.1, HaXml-1.13.2, OpenGL-2.2.1, QuickCheck-1.0.1, Win32-2.1.1, base-2.1.1, cgi-3001.1.1, fgl-5.4.1, filepath-1.0, (ghc-6.6.1), haskell-src-1.0.1, haskell98-1.0, html-1.0.1, mtl-1.0.1, network-2.0.1, parsec-2.0, regex-base-0.72, regex-base-0.91, regex-compat-0.71, regex-posix-0.71, regex-tdfa-0.92, rts-1.0, stm-2.0, template-haskell-2.1, time-1.1.1, xhtml-3000.0.2 ..... Prelude> :m + Database.HDBC.ODBC module main:Database.HDBC.ODBC is not loaded ..... $ ghc-pkg.exe describe HDBC-odbc name: HDBC-odbc version: 1.0.1.0 license: LGPL copyright: Copyright (c) 2005-2006 John Goerzen maintainer: John Goerzen <jgoer...@complete.org> stability: Alpha homepage: package-url: description: category: author: exposed: True exposed-modules: Database.HDBC.ODBC hidden-modules: Database.HDBC.ODBC.Connection Database.HDBC.ODBC.Statement Database.HDBC.ODBC.Types Database.HDBC.ODBC.Utils Database.HDBC.ODBC.TypeConv import-dirs: "C:\\Program Files\\Haskell\\HDBC-odbc-1.0.1.0\ \ghc-6.6.1" library-dirs: "C:\\Program Files\\Haskell\\HDBC-odbc-1.0.1.0\ \ghc-6.6.1" hs-libraries: HSHDBC-odbc-1.0.1.0 extra-libraries: odbc32 extra-ghci-libraries: include-dirs: "C:\\Program Files\\Haskell\\HDBC-odbc-1.0.1.0\ \ghc-6.6.1\\include " includes: depends: base-2.1.1 mtl-1.0.1 HDBC-1.0.1 parsec-2.0 hugs-options: cc-options: ld-options: framework-dirs: frameworks: haddock-interfaces: "C:\\Program Files\\Common Files\\HDBC- odbc-1.0.1.0\\doc\\ht ml\\HDBC-odbc.haddock" haddock-html: "C:\\Program Files\\Common Files\\HDBC-odbc-1.0.1.0\\doc\ \html" --- This e-mail may contain confidential and/or privileged information. If you are not the intended recipient (or have received this e-mail in error) please notify the sender immediately and destroy this e-mail. Any unauthorized copying, disclosure or distribution of the material in this e-mail is strictly forbidden.

3 2

Updated urlcheck
by Lutz Donnerhacke 15 Jun '07

15 Jun '07

I'm proud to announce an updated version of dons' concurrent urlcheck. It's a bad and buggy rewrite from scratch. It can check a file of urls or the consistency of the transitive hull of a website incl. the existance of the border urls. Futhermore the warnings from TagSoup parsing can be reported. Main bugs are memory leaks in conjunction with unnecessary retrieval of binary files, and missing documentation. If somebody has enough time in the next weeks: Many thanks in advance. URL: http://www.iks-jena.de/mitarb/lutz/haskell/urlcheck-0.0.tar.gz

2 1

How to devide matrix into small blocks
by L.Guo 14 Jun '07

14 Jun '07

Hi all: I already have one matrix of type [[a]] to store one image. What I want to do is to devide the image into severial small blocks in same size. To do that, I wrote this tool function. chop :: Int -> [a] -> [[a]] chop _ [] = [] chop n ls = take n ls : chop n (drop n ls) But I do not know how to use it to write the function. Thanks for any advice. Regards -------------- L.Guo 2007-06-13

4 11

GTK2HS
by Andrew Coppin 14 Jun '07

14 Jun '07

Erm... wuh? I just tried to install Gtk2hs and got an error message to the effect that it cannot be installed since I have GHC 6.6.1, which isn't 6.6 or 6.4. Anybody know how to fix this? Am I being dumb? Thanks. Andrew.

3 3

found monad in a comic
by Marc A. Ziegert 14 Jun '07

14 Jun '07

<http://xkcd.com/c248.html> ( join /= coreturn ) IMHO this could be a beautiful and easy way to explain monads. comments? - marc

7 8

Implementing Mathematica
by Jon Harrop 14 Jun '07

14 Jun '07

I only just subscribed to this mailing list and I am a complete Haskell newbie, so forgive me if this is too OT. I noticed a recent thread about writing a Mathematica implementation in Haskell. I think this is an excellent idea and would be a great project for a Haskell newbie. I wrote a toy Mathematica implementation in OCaml while I waited to be viva'd for my PhD. It garnered so much interest that Wolfram Research bought it from me for £4,500 and gave me several free copies of Mathematica. Regarding the specific points made: 1. Numerical libraries: you should be able to reuse existing libraries like GMP, BLAS, LAPACK, FFTW and so on. These are often much faster than Mathematica's. For example, FFTW was about 4x faster than Mathematica's FFT the last time I benchmarked it. However, they do not support interval arithmetic. 2. GUI: I would take our existing vector graphics software: http://www.ffconsultancy.com/products/smoke_vector_graphics/ http://www.ffconsultancy.com/products/fsharp_for_visualization/ and rewrite it in Haskell as the foundation. This would far exceed anything that Mathematica has to offer, in part because Mathematica's graphics are still evaluated via the completely generic rewrite engine which is extremely slow. Our code already implements high-performance hardware-accelerated vector graphics and it is probably one of the first things I would consider porting to Haskell (if there is any commercial interest in such a library). 3. The language: the hardest part of reimplementing Mathematica is inferring what it means (there are no formal evaluation semantics). Once you've done that it is just a case of implementing an extensible term rewriter and putting in about 20 core rules. The pattern matcher is well under 100 LOC and you can do various things to make it more efficient. There are two tricks that vastly improve performance of the rewriter: return physically identical results whenever possible, and perform substitution and evaluation at the same time rather than as two separate passes. 4. Libraries: You should have no trouble exceeding the capabilities of Mathematica by pulling in existing libraries. For example, Mathematica provides no wavelet transforms, no time-frequency transforms, no function minimization over an arbitrary number of variables etc. Having worked in numerical computing for many years, I can say that Mathematica is an excellent tool for prototyping and for doing disposable analyses but many people reach for conventional languages when Mathematica's capabilities run dry. You should easily be able to implement a rewriter for the language that is ten times faster and doesn't leak. Incidentally, my implementation of Mathematica in OCaml took four days, and it was one of my first OCaml programs. -- Dr Jon D Harrop, Flying Frog Consultancy Ltd. OCaml for Scientists http://www.ffconsultancy.com/products/ocaml_for_scientists/?e

17 32

FunPtr stability - suggested clarification to FFI Addendum
by Claude Heiland-Allen 14 Jun '07

14 Jun '07

Hi, I think the FFI Addendum should make explicit that FunPtr values are stable (in the sense of StablePtr). I'm writing a Haskell plugin for an application written in C, and the control flow is: C->Haskell->C ; C->Haskell->C ; ... and I was confused by this statement in section 4.1 of the Addendum (under the subheading "Dynamic wrapper"): --8<-- The stub factory mkCallback turns any Haskell computation of type IO () into a C function pointer that can be passed to C routines, which can call back into the Haskell context by invoking the referenced function. --8<-- The usage of "call back" makes it clear that this control flow is ok: Haskell->C->Haskell but I wasn't sure whether the C code could store the pointer and call it later. Apparently it is safe, but it isn't made explicit in the Addendum. As SamB said in #haskell: --8<-- The fact that there is something called "freeHaskellFunPtr" seems to indicate that, yes, those things are stable. It would be totally bonkers to have a "free" function if the associated memory was not stable (and, therefor, garbage collected). --8<-- Thanks for your attention, Claude -- http://claudiusmaximus.goto10.org

1 0

Thread blocked indefinitely problem when playing with signals and MVar on Windows
by Olivier Boudry 14 Jun '07

14 Jun '07

Hi all, I'm playing with signal handlers on Win32. I found a good post on signal handlers but it works with System.Posix.Signals which on Win32 is empty. Blog is here: http://therning.org/magnus/archives/285 I tried to adapt this code to GHC.ConsoleHandler, the Win32 counterpart of System.Posix.Signals. The code: ===================================== module Main where --import System.Posix.Signals import GHC.ConsoleHandler import Control.Concurrent import Control.Concurrent.MVar import System -- ControlC increments counter handler :: MVar (Int, Bool) -> ConsoleEvent -> IO () handler mi ControlC = do (i, exit) <- takeMVar mi putStrLn "In ControlC handler" putMVar mi ((i + 1), False) -- Break sets Bool to True to stop application handler mi Break = do (i, exit) <- takeMVar mi putStrLn "In Break handler" putMVar mi (i, True) -- Ignore other signals handler _ _ = do return () doNothing :: MVar (Int, Bool) -> IO () doNothing mi = do threadDelay 1000000 (i, exit) <- takeMVar mi if exit then do putStrLn "Good bye!" exitWith ExitSuccess else do putStrLn $ "Repeating " ++ (show i) main :: IO () main = do mi <- newMVar (0, False) installHandler (Catch $ handler mi) sequence_ $ repeat $ doNothing mi ===================================== It compiles but when run I receive this: Repeating 0 SignalsText.exe: <<loop>> First iteration is executed but then it gets trapped in what looks like a dead lock. If I remove the installation of the signal handler to just have an infinite loop (comment out installHandler ...) I get this: Repeating 0 SignalsText.exe: thread blocked indefinitely Without the signal handler the code uses only the main and doNothing function and I can't figure out what causes this to block? Something to do with my use of MVar, but what??? Lazy evaluation? Thanks for any advice, Olivier.

1 1

practicality of typeful programming
by Daniil Elovkov 14 Jun '07

14 Jun '07

Hello folks I've recently asked some questions here about some little type hackery implementing an embedded dsl. But now I wonder if it's worth the effort at all... The thing is enforcing static constraints turns out to be quite time consuming, even for 'reasonble' things. The dsl I'm writing will not primarily be used from Haskell sources, rather more likely be input to the interpreter, and hence dynamic analysis after parsing will occur any way. On the other hand, enforcing them excludes some errors... To give you a flavour, classical example, I could represent expressions simply by 'data Exp' or by 'data Exp a' where a is the type of expression and 4 + "str" is illegal, or by 'data Exp s a' where a is the same and s is an additional property, like some kind of things the expression mentions, and there are restrictions on how Exp s1 and Exp s2 can combine. And s is not otrhogonal with a. There may be more properties. I'd like to hear your thoughts on how practical it is, and to which extent, to use typeful programing for statically enforcing constraints, in real-life applications, where readability and maintainability matter.

1 0

Construct all possible trees
by Andrew Coppin 14 Jun '07

14 Jun '07

I'm trying to construct a function all_trees :: [Int] -> [Tree] such that all_trees [1,2,3] will yield [ Leaf 1, Leaf 2, Leaf 3, Branch (Leaf 1) (Leaf 2), Branch (Leaf 1) (Leaf 3), Branch (Leaf 2) (Leaf 1), Branch (Leaf 2) (Leaf 3), Branch (Leaf 3) (Leaf 1), Branch (Leaf 3) (Leaf 2), Branch (Branch (Leaf 1) (Leaf 2)) (Leaf 3), Branch (Branch (Leaf 1) (Leaf 3)) (Leaf 1), Branch (Branch (Leaf 2) (Leaf 1)) (Leaf 3), Branch (Branch (Leaf 2) (Leaf 3)) (Leaf 1), Branch (Branch (Leaf 3) (Leaf 1)) (Leaf 2), Branch (Branch (Leaf 3) (Leaf 2)) (Leaf 1), Branch (Leaf 1) (Branch (Leaf 2) (Leaf 3)), Branch (Leaf 1) (Branch (Leaf 3) (Leaf 2)), Branch (Leaf 2) (Branch (Leaf 1) (Leaf 3)), Branch (Leaf 2) (Branch (Leaf 3) (Leaf 2)), Branch (Leaf 3) (Branch (Leaf 1) (Leaf 2)), Branch (Leaf 3) (Branch (Leaf 2) (Leaf 1)) ] So far I'm not doing too well. Here's what I've got: data Tree = Leaf Int | Branch Tree Tree pick :: [x] -> [(x,[x])] pick = pick_from [] pick_from :: [x] -> [x] -> [(x,[x])] pick_from ks [] = [] pick_from ks [x] = [] pick_from ks xs = (head xs, ks ++ tail xs) : pick_from (ks ++ [head xs]) (tail xs) setup :: [Int] -> [Tree] setup = map Leaf tree2 :: [Tree] -> [Tree] tree2 xs = do (x0,xs0) <- pick xs (x1,xs1) <- pick xs0 return (Branch x0 x1) all_trees ns = (setup ns) ++ (tree2 $ setup ns) Clearly I need another layer of recursion here. (The input list is of arbitrary length.) However, I need to somehow avoid creating duplicate subtrees... (BTW, I'm really impressed with how useful the list monad is for constructing tree2...)

6 14