September 2010 - Haskell-Cafe

ANNOUNCE: AbortT-transformers version 1.0
by Gregory Crosswhite 11 Sep '10

11 Sep '10

For whatever reason, nobody seems to have gotten around to implementing an Abort monad transformer (outside the monadLib package), so I decided to write one myself since I wanted the functionality but I use "transformers" rather than "monadLib". An abortable monadic computation runs until either it is finished or it is aborted by calling the "abort" function. All steps in the computation after "abort" has been called are ignored, which means that abort can be assigned an arbitrary type for its value within the computation. My implementation uses an Either type which is Left if the computation has been prematurely terminated and Right of the computation is continuing to proceed as normal. I could have implemented the functionality using the Continuation monad, but that seemed to be overkill in cases where the user only wants a simple abort monad. Cheers, Greg

6 8

re: Oracle stored procedures
by Leonel Fonseca 11 Sep '10

11 Sep '10

Hi Peter, Yes, from Takusen you can call Oracle stored procedures, functions, packaged stored procedures or functions, or execute an arbitrary pl/sql block. In the Takusen software release there is a directory called "Database\Oracle\Test". There, Enumerator.lhs, among other code has these helpers you may want to use: >wrapPLSQLFunc funcname parms = > let sqltext = "begin " ++ (head args) ++ " := " ++ funcname > ++ "(" ++ placeholders ++ "); end;" > placeholders = concat (intersperse "," (tail args)) > args = take (length parms) (map (\n -> ":x" ++ show n) [1..]) > in cmdbind sqltext parms >wrapPLSQLProc procname parms = > let sqltext = "begin " ++ procname > ++ "(" ++ placeholders ++ "); end;" > placeholders = concat (intersperse "," args) > args = take (length parms) (map (\n -> ":x" ++ show n) [1..]) > in cmdbind sqltext parms Please, be aware of the following points: 1) If the pl/sql code doesn't need parameters and has no results, you can use "execDDL". (execDML returns a counter of affected rows). 2) If the procedure/function receives parameter, you'll need to use "cmdbind" (or similar to "cmdbind") to pass the parameters. 3) If the pl/sql code returns values, you have this options: 3.a) The returned value is a reference (cursor): Takusen supports this very fine. Use "doQuery" or similar. 3.b) The return value is an scalar value: You can collect the result with an iteratee, even if it is a single value. 3.c) The return value is a complex oracle object: As of Takusen 0.8.5 there is no support for table of records of ... 3.d) The return value is Boolean. You'll get an error. Little examples: For case #1: > -- Example 1.a: We set nls_language to american english. > set_NlsLang_Eng :: DBM mark Session () > set_NlsLang_Eng = execDDL $ sql > "alter session set nls_language='AMERICAN'" > -- Example #1.b: Now we set session language parameter to spanish. > set_NlsLang_Esp :: DBM mark Session () > set_NlsLang_Esp = execDDL $ sql > "alter session set nls_language='LATIN AMERICAN SPANISH'" For case #2: > -- Example 2.a: We use database string "concat" function >concat' :: String -> String -> DBM mark Session String >concat' a b = do > let ite :: Monad m => String -> IterAct m String > ite v _ = return $ Left v > sqlcmd = wrapPLSQLFunc "concat" > [bindP $ Out (""::String), bindP a, bindP b] > doQuery sqlcmd ite undefined > > -- later on the program, you'd have... > some_string <- concat' "a" "b" For case #3: > -- Case 3.b: We collect a single scalar value. > qNlsLang :: DBM mark Session [String] > qNlsLang = doQuery s ite [] > where > s = "select value from nls_session_parameters \ > \ where parameter = 'NLS_LANGUAGE'" > ite :: (Monad m) => String -> IterAct m [String] > ite a acc = result' ( a:acc ) > mostrar_NlsLang :: DBM mark Session () > mostrar_NlsLang = qNlsLang >>= liftIO . print . head > -- Another example for Case 3.b > -- This time we don't use a list to accumulate results. > s1 = sql "select systimestamp from dual" > > sysTSasCTQ :: DBM mark Session CalendarTime > sysTSasCTQ = do > > let ite :: (Monad m) => CalendarTime -> IterAct m CalendarTime > ite x _ = result' x > > t <- liftIO ( getClockTime >>= toCalendarTime) > doQuery s1 ite t -- Leonel Fonseca.

2 2

Dependent types
by Mitar 10 Sep '10

10 Sep '10

Hi! I believe dependent types is the right term for my problem. I was trying to solve it with GADTs but I was not successful so I am turning to infinite (lazy) wisdom of Haskell Cafe. I am attaching example code where I had to define MaybePacket data type which combines different types of Packets I would like to allow over Line. The problem is that there is a correlation between Line type and MaybePacket type and I would like to tell Haskell about that. But I am not sure how. Because now compiler, for example, warns me of a non-exhaustive pattern even if some MaybePacket value is not possible for given Line. Somehow I would like to have a getFromFirstLine function which would based on type of given Line return Maybe (Packet i) (for Line) or Maybe AnyPacket (for LineAny). So that this would be enforced and type checked. Best regards and thanks for any help Mitar

2 3

Google AI Challenge: Planet Wars - Accepting Haskell Submissions
by Jake McArthur 10 Sep '10

10 Sep '10

Just wanted to let everybody know that there is an AI contest [1] that started today. Everybody has about two months to create bots that compete against each other 1-on-1 in a game based on Galcon [2]. A couple issues to mention for full disclosure: There is some sponsorship by Google, but unfortunately they aren't running the hardware, so the site is getting pretty hammered right now. We (it's all open source and open for contributions) are working to get it optimized to better handle the load. Also, the version of GHC on the server is very old (6.8.2) and isn't likely to get updated. I'm working to allow binary submissions though. If that goes through, you guys will be able to submit 64-bit Linux binaries rather than Haskell code to be compiled on the server. Just letting everybody know so the Haskell community can represent! - Jake [1] http://ai-contest.com [2] http://galcon.com

2 1

Re: [Haskell-cafe] Restricted type classes
by John Lato 10 Sep '10

10 Sep '10

> > From: Ivan Lazar Miljenovic <ivan.miljenovic(a)gmail.com> > > 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? > You could prefix (or postfix) classes with an 'R' similar to RMonad, but that would conflict with the rmonad package. For just Foldable, maybe Reduceable? Do you have a kind * implementation of Foldable? I'd be interested in seeing it, because I was unable to create a usable implementation (based upon the RMonad scheme) on my last attempt. > > 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: > I don't have a strong opinion either way, but could you re-use RMonad and RFunctor from the rmonad package? > 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? > +1 for using the proper constraints, and especially for bringing over Pointed (and anything else that applies). > > 3) Am I wasting my time with this? > I would find it useful, and I appreciate all the care you're putting into the design. Cheers, John

10 37

gathering position information lazily using traverse
by Jan Christiansen 10 Sep '10

10 Sep '10

Dear Applicative experts, I am seeking advice on Applicative instances and their use in traverse. Consider the following Applicative instance. newtype Proj a = Proj { unProj :: [Bool] -> a } instance Functor Proj where fmap g (Proj f) = Proj (g . f) instance Applicative Proj where pure = Proj . const Proj f <*> Proj x = Proj (\p -> f (False:p) (x (True:p))) In fact, this is not an Applicative instance as it does not satisfy the laws. On basis of this "instance" I have defined the following function. gshape :: Traversable t => t a -> t [Bool] gshape x = unProj (traverse (const (Proj reverse)) x) [] The idea is simply to replace every polymorphic component by an identifier that identifies the position of the component in the data structure. That is, provided with the identifier I want to be able to project to the corresponding component. In this case this identifier is a path in the "idiomatic term" from the root to the component. I can define a correct Applicative instance if I add an additional constructor, which represents pure. I did not prove that it satisfies all laws but I think it does. data Proj a = Pure a | Proj ([Bool] -> a) instance Functor Proj where fmap g (Pure x) = Pure (g x) fmap g (Proj f) = Proj (g . f) instance Applicative Proj where pure x = Pure x Pure f <*> Pure x = Pure (f x) Pure f <*> Proj x = Proj (\p -> f (x p)) Proj f <*> Pure x = Proj (\p -> f p x) Proj f <*> Proj x = Proj (\p -> f (False:p) (x (True:p))) My problem is that this correct instance is too strict for my purpose. It is important that gshape operates correctly on partial data, that is, even if its argument is partial all the components should be replaced correctly. For example, we have gshape (Node _|_ 0 (Leaf 1))) = Node _|_ [False,True] (Leaf [True]) If the applicative instance performs pattern matching, like the latter instance, then gshape is too strict. Therefore I suspect that there is no correct Applicative instance that satisfies my needs but I am not at all certain. Thanks, Jan

2 2

Haddock comments for GADT constructors?
by Conal Elliott 10 Sep '10

10 Sep '10

I'm updating a library (TV) and getting haddock parse errors for the doc strings attached to GADT constructors. Is there a way to haddock-document GADT constructors? I've tried both "-- | ..." before and "-- ^ ... " after. Both give parse errors. Thanks, - Conal

2 2

ANNOUNCE: text-icu 0.4.0.0
by Bryan O'Sullivan 10 Sep '10

10 Sep '10

The text-icu library is the more practical cousin to the text library, implementing a myriad of Unicode-related functionality that is not yet otherwise available in Haskell. It is implemented as bindings to the widely used ICU library. http://hackage.haskell.org/package/text-icu Features: - Locale sensitive case mapping. - Text normalization. (What is normalization? http://unicode.org/faq/normalization.html) - [NEW] Locale sensitive string collation. - Conversion to and from a huge number of native encodings. - [NEW] Efficient comparison of ByteString and Text. The library is thoroughly documented, and most interfaces are pure and easy to use. Look for further releases over the coming weeks as I complete the ICU integration.

1 0

ANNOUNCE: DSTM 0.1.1
by Frank Kupke 10 Sep '10

10 Sep '10

Hi, DSTM is an implementation of a robust distributed Software Transactional Memory (STM) library for Haskell. Many real-life applications are distributed by nature. Concurrent applications may profit from robustness added by re-implementation as distributed applications. DSTM extends the STM abstraction to distributed systems and presents an implementation efficient enough to be used in soft real-time applications. Further, the implemented library is robust in itself, offering the application developer a high abstraction level to realize robustness, hence, significantly simplifying this, in general, complex task. The DSTM package consists of the DSTM library, a name server application, and three sample distributed programs using the library. Provided are a simple Dining Philosophers, a Chat, and a soft real-time Bomberman game application. Distributed communication is transparent to the application programmer. The application designer uses a very simple name server mechanism to set up the system. The DSTM library includes the management of unavailable process nodes and provides the application with abstract error information thus facilitating the implementation of robust distributed application programs. For usage please look into the documentation file: DSTMManual.pdf. The package including the documentation can be found on: http://hackage.haskell.org/package/DSTM-0.1.1 Best regards, Frank Kupke

12 26

Style and a problem
by Wanas 10 Sep '10

10 Sep '10

Hey all, So I have a two part question (I'm new to haskell, so you can throw all your mugs at me). a) I want to write a function that generates lists of lists of size $n$. All having the property that sum lst = sum [1..n]. a-1) After that, I want to remove all permutations. My idea of doing this is to get all lists from the first function and create a new list with the property that "if sorted list A is not in the list, add it." b-2) I think that's too much questions, but I want to get the hang of this quickly (it was kickass for the few things I've tried out). Thanks, \/\/

6 8