- Haskell-Cafe - Haskell.org

Haskell DB bindings
by oleg＠pobox.com 10 Jan '06

10 Jan '06

[moved from the main Haskell-list: I'm afraid the HDB discussion on the Haskell mailing list had already been long] Tim Docker wrote on the Haskell mailing list > The differences between HDBC and HSQL have been recently discussed. > Where does Takusen fit into this picture? From the above, it sounds > like it has quite a different API. Are all 3 of these actively > maintained? Takusen is built around an enumerator -- left fold enumerator, to be precise. That is, a database query is considered to be `left-folding' over the result table. Early termination is supported -- the iteration can be finished at any time the iteratee decided it has had enough. Cursors -- derivatives (pun intended) of the enumerator -- are supported as well, and we have a withCursor function (although, due to laziness, we haven't implemented the type-based region management for cursors. But we have talked about it!) The best supported databases are Oracle and Sqlite. For them, we implement buffer pre-allocation, pre-fetching (useful for minimizing the communication overhead if rows are small), parameter binding, handling date-time datatypes. Parameter binding is not yet supported for PostgreSQL. All interfaces support DML/DDL statements, transactions and isolation modes (if the back-end supports that), transparent translation from the DB type to a Haskell type. The user doesn't need to do anything for the translation. Database NULLs are fully handled: if the Haskell datatype is a Maybe datatype, NULL is permitted and translated into Nothing. Otherwise, NULL raises an exception. Nulls are distinguished from empty strings, provided the database server does so. Takusen has two layers. The low-level API (which is not actually meant for the end user) reconciles the differences among various DB interfaces. Currently supported are Oracle, Sqlite, PostgreSQL, Stub (that is, no DB -- useful for testing), and the ntwdblib interface to MSSqlServer (Microsoft encourages a newer interface though). Krasimir Angelov wrote: > Can you explain how do you manage the lifetime of handles in Takusen? > It isn't clear to me where are the advantages of enumerators. The handles are not visible to the user. The user cannot close the handle (or forget to close the handle) because the user is not given the handle in the first place. Just as we left-fold over a list, we are not given the pointer to the ``current list''. We are merely given the current element of the list. Perhaps the following links might be of help: http://www.eros-os.org/pipermail/e-lang/2004-March/009643.html http://pobox.com/~oleg/ftp/Haskell/misc.html#fold-stream http://pobox.com/~oleg/ftp/papers/LL3-collections-enumerators.txt

1 0

Is there a notion for identity?
by Tim Walkenhorst 09 Jan '06

09 Jan '06

{- Disclaimer: I'm rather new to Haskell and completely new to this board. I may not use the correct terminology in all cases, but I hope my intention becomes clear when you have a look at the code-snippets. -} Hey ho, Is there any way two find out whether two variables refer to the same cell? That is I'm looking for a notion of identity (compareable to == in Java) as opposed to equality (== in Haskell). The motivation is that I need to find out whether two infinite structures are identical. Consider this Haskell implementation of the simple typed lambda calculus (STLC) with the primitive Type "TyUnit" and the primitive value "TmUnit": data Type = TyUnit | TyArrow Type Type deriving (Show,Eq) data Term = TmUnit | TmVar String | TmAbs String Type Term | TmApp Term Term deriving Show {- Context is some LIFO structure which stores Argument-Type bindings: -} data Context = {- ... -} ctxEmpty :: Context addBinding :: Context -> String -> Type -> Context getBinding :: Context -> String -> Type typeof :: Context -> Term -> Type typeof _ TmUnit = TyUnit typeof ctx (TmVar s) = getBinding ctx s typeof ctx (TmAbs s ty1 t) = let ctx' = addBinding ctx s ty1 ty2 = typeof ctx' t in TyArrow ty1 ty2 typeof ctx (TmApp t1 t2) = let (TyArrow ttp tte) = typeof ctx t1 tta = typeof ctx t2 {- (1) problem here: -} in if tta==ttp then tte else error "..." -- eval omitted... The STLC does not provide a notion for recursion as it stands. My idea was to simulate recursion by using infinte structures of type Type. Consider this definition of the omega-combinator: omegaType :: Type omegaType = TyArrow omegaType omegaType omega, omegaAbs :: Term omega = TmApp omegaAbs omegaAbs omegaAbs = TmAbs "x" omegaType (TmApp (TmVar "x") (TmVar "x")) Now it would be nice if "typeof ctxEmpty omega" would return omegaType. Unfortunately it doesn't. Instead it loops on line ((1)), since omegaType and omegaType will never be compared to be equal using (==). If we had a function `sameAddress` we could write "tta `sameAddress` ttp || tta==ttp" instead of "tta==ttp" in line ((1)). If I interpret the chapter about infinite lists in the bird book correctly, this should be sound. omegaType will be represented by a cyclic graph in the runtime system and will therefore always refer to the same cell. The issue becomes a little more complicated if we consider: omegaType, omegaType' :: Type omegaType = TyArrow omegaType omegaType omegaType' = TyArrow omegaType' omegaType' omega, omegaAbs, omegaAbs' :: Term omega = TmApp omegaAbs omegaAbs' omegaAbs = TmAbs "x" omegaType (TmApp (TmVar "x") (TmVar "x")) omegaAbs' = TmAbs "x" omegaType' (TmApp (TmVar "x") (TmVar "x")) In this case it wouldn't be clear whether " omegaType `sameAddress` omegaType' " should be True or False, as a clever compiler might detect that both are identical and make them refer to the same address (, correct me if I'm wrong). This might be a reason that there is no `sameAddress`. My questions are: Is there any way to implement "sameAddress" in Haskell? Or is it at least possible to implement it with GHC using some compiler-specific notation? Thanks, Tim

3 4

Parsec Question
by Gerd M 09 Jan '06

09 Jan '06

I'm trying to use parsec for parsing a custom input stream. As far as I understood the manual correctly I need to define the primitive parser: type MyParser a = GenParser (SourcePos,Tok) () a mytoken :: (Tok -> Maybe a) -> MyParser a mytoken test = token showToken posToken testToken where showToken (pos,tok) = show tok posToken (pos,tok) = pos testToken (pos,tok) = test tok The problem is, since SourcePos is an abstract datatype, how can I actually run this parser without explicitly using values of type SourcePos in the input stream? Many thanks in advance! _________________________________________________________________ Express yourself instantly with MSN Messenger! Download today it's FREE! http://messenger.msn.click-url.com/go/onm00200471ave/direct/01/

3 3

Re: [Haskell] Re: haskell.org Public Domain
by Brian Sniffen 09 Jan '06

09 Jan '06

> > It might be nice to at least include some disclaimers of warranty. I'm not a lawyer. But those US copyright lawyers I've spoken with have expressed doubts about anybody's ability to put things into the public domain. Certainly, if you put it in the public domain, you can't also disclaim a warranty. I suspect that some license that is a superset of the following would be best: * The documentation of GHC * The documentation of Hugs * The Haskell 98 report I think that works out to be "BSD, with an option for authors to copyleft pages or code as they wish." On the other hand, I also think MoinMoin has lots to offer over Mediawiki---not least ease of maintenance and improvements such as license markers. -- Brian T. Sniffen bts(a)alum.mit.edu or brian.sniffen(a)gmail.com http://www.evenmere.org/~bts

1 0

Expanding do notation
by David F. Place 09 Jan '06

09 Jan '06

Hi All, Is there a program for expanding 'do' notation? I am trying to understand why the following code (from the Fannkuch entry) doesn't hold onto the list 'p' causing a space leak. main = do n <- getArgs >>= return . read . head let p = permutations [1..n] mapM_ (putStrLn . concatMap show) $ take 30 p putStr $ "Pfannkuchen(" ++ show n ++ ") = " putStrLn . show $ foldl' (flip (max . steps 0)) 0 p If I add a line which refers to 'p' at the end, there is a space leak. print (head p) Thanks. Cheers, David ---------without extra line ./Latest 9 +RTS -K256m -c -sstderr 123456789 ... Pfannkuchen(9) = 30 244,215,012 bytes allocated in the heap 613,972 bytes copied during GC 3,920 bytes maximum residency (1 sample(s)) 931 collections in generation 0 ( 0.06s) 1 collections in generation 1 ( 0.00s) 1 Mb total memory in use INIT time 0.00s ( 0.01s elapsed) MUT time 2.20s ( 2.72s elapsed) GC time 0.06s ( 0.13s elapsed) EXIT time 0.00s ( 0.00s elapsed) Total time 2.26s ( 2.86s elapsed) %GC time 2.7% (4.5% elapsed) Alloc rate 111,006,823 bytes per MUT second Productivity 97.3% of total user, 76.9% of total elapsed --------with extra line ./Latest 9 +RTS -K256m -c -sstderr ... Pfannkuchen(9) = 30 [1,2,3,4,5,6,7,8,9] 244,216,248 bytes allocated in the heap 19,804,816 bytes copied during GC 10,586,416 bytes maximum residency (6 sample(s)) 931 collections in generation 0 ( 0.96s) 6 collections in generation 1 ( 1.28s) 18 Mb total memory in use INIT time 0.00s ( 0.01s elapsed) MUT time 2.30s ( 2.72s elapsed) GC time 2.24s ( 3.15s elapsed) EXIT time 0.00s ( 0.00s elapsed) Total time 4.54s ( 5.88s elapsed) %GC time 49.3% (53.6% elapsed) Alloc rate 106,180,977 bytes per MUT second Productivity 50.7% of total user, 39.1% of total elapsed -------------------------------- David F. Place mailto:d@vidplace.com

10 18

Where does memory go?
by Joel Reymont 09 Jan '06

09 Jan '06

I compiled a simple one-liner: main = print "Blah". This is the GC report: 5,620 bytes allocated in the heap 0 bytes copied during GC 0 collections in generation 0 ( 0.00s) 0 collections in generation 1 ( 0.00s) 1 Mb total memory in use Where did the memory go? What is 5K and what is (more suprisingly) 1Mb? Thanks, Joel -- http://wagerlabs.com/

4 3

Re: [Haskell-cafe] x86 code generation going wrong?
by Chris Kuklewicz 09 Jan '06

09 Jan '06

Brian Sniffen wrote: > The first couldn't even complete on my 2.26 GHz Celeron! It's only got > 512 MB of RAM, which may be part of the problem. I should not leak memory but it may be an optimization problem. Try explicitly using "ghc -O2 -funbox-strict-fields". > > Stack space overflow: current size 1048576 bytes. > Use `+RTS -Ksize' to increase it. > ./test1 < sum-file-test-input 25.33s user 2.89s system 18% cpu 2:32.02 total > > ./test2 < sum-file-test-input 4.79s user 0.20s system 94% cpu 5.276 total > > ./test3 < sum-file-test-input 4.46s user 0.14s system 99% cpu 4.623 total > > -- > Brian T. Sniffen > bts(a)alum.mit.edu or brian.sniffen(a)gmail.com > http://www.evenmere.org/~bts >

3 3

fastest Binary library!
by Bulat Ziganshin 08 Jan '06

08 Jan '06

Hello yes, i did it! today i spend time to optimize my own Binary library and got the (de)serialization speed about 50 mb/s with my 1 ghz cpu. it is a peek speed for unboxed arrays, in real life GC times and other overhead expenses will need much more time than (de)serialization itself. but at least noone can now say that serialization is a bottleneck of Haskell program :) i uploaded current version to http://freearc.narod.ru/Binary.tar.gz Main.hs in package is a testing program which builds, puts to memory buffer and then gets back a 40mb array and prints runtime of each operation Joel, if you are interested in switchinh to my library - write me. i have ideas about supporting your 150 records using your own DDL. smth like this: data Command = Cmd1 field1 Word32 333 field2 Word16 0 | Cmd2 field3 String "" field4 [SubRecord] [] you will describe all your records just one time and then these definitions will be compiled for the language/library you are using -- Best regards, Bulat mailto:bulatz@HotPOP.com

3 3

Project postmortem II /Haskell vs. Erlang/
by Joel Reymont 08 Jan '06

08 Jan '06

Simon, Please see this post for an extended reply: http://wagerlabs.com/articles/2006/01/01/haskell-vs-erlang-reloaded Thanks, Joel On Dec 29, 2005, at 8:22 AM, Simon Peyton-Jones wrote: > | Using Haskell for this networking app forced me to focus on all the > | issues _but_ the business logic. Type constraints, binary IO and > | serialization, minimizing memory use and fighting laziness, timers, > | tweaking concurrency and setting up message channels, you name it. > > That's a disappointing result. Mostly I think Haskell lets you > precisely focus on the logic of your program, because lots else is > taken > care of behind the scenes. You found precisely the reverse. > > It'd be interesting to understand which of these issues are > - language issues > - library issues > - compiler/run-time issues > > My (ill-informed) hypothesis is that better libraries would have > solved > much of your problems. A good example is a fast, generic > serialisation > library. > > If you felt able (sometime) to distil your experience under headings > like the above, only more concretely and precisely, I think it might > help to motivate Haskellers to start solving them. -- http://wagerlabs.com/

4 10

do {x<-[1,2,3]; True <- return (odd x); return x}.. why? (do notation, monads, guards)
by Marc Weber 08 Jan '06

08 Jan '06

Here is a simple program implementing the above function in 4 different ways.. See my comments to get to know where I have problems: ---------- begin test.hs ---------- module Main where import IO import Control.Monad.List {- list1,2 are both implementations of the same function f=[1,3] ;-) I've both rewritten with the translation rules for do notation to better understand what's going on and where the differences are -} list1=do { x <- [1,2,3]; True <- return (odd x); return x} list2=do { x <- [1,2,3]; guard (odd x); return x} -- <- provided by xerox list1rewritten :: [Int] list1rewritten=let ok x = let ok2 True = do return x --1r1 ok2 _ = fail "ok2" --1r2 in return (odd x) >>= ok2 --1r3 ok _ = fail "outer" --1r4 in [1,2,3] >>= ok {- The outer let .. in >>= is used to "call" the inner >>= for each element of [1,2,3] (the list Monad causes this) True <- return (odd x): really nice trick...! if x is odd then line --1r1 is matched the values is returned otherwise line --1r2 is matched calling fail which is implemented as = [] ignoring the message hence no element is added but I'm not sure which implementation of >>= is used in --lr3: It should satisfy (Monad m) => m Bool -> (Bool -> m Int), right ? Looking at the definition taken from GHC/Base.lhs: class Monad m where (>>=) :: forall a b. m a -> (a -> m b) -> m b and a sample implementation: instance Monad [] where m >>= k = foldr ((++) . k) [] m I wonder how a, b (from m a and m b) and m (from class Monad m) are renated? Can you tell me how the implementation declaration of m a -> (...) -> m b differs in these cases: eg: 1. a = Int, b=String 2. the other way round: a=String b=Int? -} list2rewritten :: [Int] list2rewritten = let ok x = guard (odd x) >> return x ok _ = fail "I think never used?" in [1,2,3] >>= ok {- Here ok is feeded with 1,2 and three due to the list Monad again? So fail will never be called, right? I also know that guard returns either the monad data type constructor mzero or return () But how is this used in combintation with >> return x::Int to return either [] or [x] ? -} main=do -- print result of all implementations to show that they are equal sequence [ print x| x <- [[1,3], -- [1,3] should be the result list1, list1rewritten, list2, list2rewritten ] ] -------------- end ------------------------- I hope there will be some time when I can say: Monads.. I don't bother anymore I'm practicing every night while dreaming.... ;-) Marc

3 3