- Beginners - Haskell.org

Problems with Internal.ByteString
by Pauline Gomér 17 Jul '09

17 Jul '09

Hello, I'm trying to upgrade a library from 6.6 to 6.10, but has run into a problem where a Internal.ByteString is returned instead of a normal ByteString. The library uses bRead in BEncode library, but that function's input type has changed from ByteString to Internal.ByteString. I think the cause of the problem is the functions in ByteString that uses functions in ByteString.Internal. Data.BEncode.bRead uses Data.BEncode.Lexer.lexer Data.BEncode.Lexer.lexer uses Data.ByteString.Lazy.Char8.toChunks Data.ByteString.Lazy.Char8.toChunks uses Data.ByteString.Lazy.Internal.foldrChunk foldrChunk :: (Internal.ByteString -> a -> a) -> Internal.ByteString -> a Is there any way to avoid getting a Internal.ByteString or convert it to a normal ByteString? Pauline

1 0

type class question from MReader #8
by MH 17 Jul '09

17 Jul '09

I am reading the article from Monad Reader issue #8 called Type-Level Instant Insanity by Conrad Parker and I don't understand the part on recursive types. data Nil data Cons x xs data x ::: xs infixr 5 ::: class ListConcat a1 a2 a | a1 a2 -> a where listConcat :: a1 -> a2 -> a instance ListConcat Nil a a where listConcat = _|_ instance (ListConcat xs ys zs) => ListConcat (x ::: xs) ys (x ::: zs) where listConcat = _|_ 1. How does the last function becomes recursive? 2. Why do we need constraint '(ListConcat xs ys zs) =>' ? 3. I assume that listConcat function takes three arguments but from example provided, it takes two (see below): 4. Does the functional dependency sign (->) implies that the last argument is the return type? Main> :type listConcat (u:: R ::: G ::: B ::: Nil) (u:: W ::: Nil) listConcat (u::R:::G:::B:::Nil) (u::W:::Nil)::(:::) R ((:::) G ((:::) B ((:::) W Nil))) Thanks a lot. Malik

3 3

Handling cpp and hsc2hs with Distribution.Simple
by Maurício 15 Jul '09

15 Jul '09

Cabal package manual says those tools are handled automatically using extensions in file names, i.e., '.hsc' for hsc2hs and '.cpphs' for haskell cpp. What should I do if I want both, i.e., I would like my file to be processed first by cpp and then by hsc2hs? Thanks, Maurício

1 0

Recursive macros in hsc2hs
by Maurício 15 Jul '09

15 Jul '09

I'm trying to define a macro inside a template that generates an existing macro: --- #define hsc_test(hst,ct) \ { \ printf("#def inline int b_%s(void){return %s;}\n", hst,ct); \ printf("foreign import ccall b_%s :: CInt\n", hst); \ } --- Contrary to my expectation, the '#def' construct printed at the first 'printf' is included in the final haskell file, instead of beeing removed and replaced by a C function definition in a c header file. Is it possible to define an hsc_-like construct that generates code that is again parsed by hsc2hs? Thanks, Maurício

4 4

external sort
by Keith Sheppard 12 Jul '09

12 Jul '09

I'm reworking external sort to meet the needs of my app and I'm running into some trouble that I was hoping to get some advice on. I'm asking a lot of questions here so don't feel obligated to answer them all if you have input on one point: The code is here: http://tinyurl.com/extsort 1) The sort gives the correct result, but when I tried to sort very large files (~4 Gb) I got this message: tssql: /var/folders/Tl/TlS1rTCyFpWU9s-IsNFkdE+++TI/-Tmp-/sort4106.txt: openBinaryFile: resource exhausted (Too many open files) I tried to be careful about limiting the number of open file handles but I must have done something wrong. Do you see where I'm leaking file handles? 2) I'm guessing there's a smarter way to do unwrapMonads? 3) I'd like to create a function like BS.hGetContents which lazily reads the ByteString but in addition to closing the file after the last byte is read I want it to delete the file that I'm reading from. Like hGetContentsThenDelete. It seems like http://hackage.haskell.org/package/lazyio but it isn't clear to me how I would do this I cant do > LazyIO.run $ do > str <- BS.hGetContents file > removeFile file > return str can I? I assume that would close the file too soon 4) Is there any other wacky stuff in my code that I should change? I told you it was a lot :-) Thanks! -Keith -- keithsheppard.name

3 4

Re: [Haskell-beginners] List.sort
by John Dorsey 11 Jul '09

11 Jul '09

I sent this only to Patrick by mistake. Sorry for the duplicate, Patrick. -- Patrick, > Ord a => [a] -> [a] > > I don't understand how this type can allow it to sort pairs: > > Prelude> :m +List > Prelude List> sort [(1, "1"), (3, "3"), (2, "2")] > [(1,"1"),(2,"2"),(3,"3")] > > How can a pair by of type "Ord a"? Is it a rule that the first element > is automatically used? "Ord a" isn't really the type of a pair... it's a type *constraint* on the argument to the sort function, which is otherwise any type "a". So it means List.sort can be applied to any type "a" which satisfies "Ord a". But what does that mean? It means that there is an instance for the typeclass Ord for whatever type is given to Listsort. In the case of pairs, it's exactly as you guessed... the leftmost parts are compared first. This is so because somewhere there's an "instance Ord (a,b)" that defines how to compare pairs, and it does it that way (left-to-right). (And this generalizes to tuples bigger than pairs, up to some compiler-specific limit.) Does this make sense? John

4 4

The Applicative instance for ((->) a)
by Ian Duncan 11 Jul '09

11 Jul '09

Hey folks, I understand most of what is going on with the applicative class, but I can't figure out why this instance is useful: "instance Applicative ((->) a) where..." Can anyone offer some intuition into how this is could be used? Ian Duncan

4 4

List.sort
by Patrick LeBoutillier 11 Jul '09

11 Jul '09

Hi, I see the type of the List.sort function is: Ord a => [a] -> [a] I don't understand how this type can allow it to sort pairs: Prelude> :m +List Prelude List> sort [(1, "1"), (3, "3"), (2, "2")] [(1,"1"),(2,"2"),(3,"3")] How can a pair by of type "Ord a"? Is it a rule that the first element is automatically used? Patrick -- ===================== Patrick LeBoutillier Rosemère, Québec, Canada

2 1

decorate-sort-undecorate in haskell
by Ivan Uemlianin 11 Jul '09

11 Jul '09

Dear All I'm learning Haskell from a background in Python, and I'm just looking at the sort and sortBy functions in Data.List. In Python, the decorate-sort-undecorate pattern is a popular alternative to using an explicit compare function. For example, to sort a list of lists by length: def sortByLength(xs): dec_xs = [(len(x), x) for x in xs] dec_xs.sort() undec_xs = [x[1] for x in dec_xs] return undec_xs This is often preferred to something like: xs.sort(lambda x,y: len(x) > len(y)) # just used lambda so it fits on one line I think the reasoning is that plain sort() is done at C speed, whereas sort(func) is done in Python, so, depending on the list I suppose, dsu can be worth the trouble. (Sorry for vagueness). Anyway, I was wondering if dsu is popular in Haskell, and whether or when it would make sense to use dsu rather than sortBy. Here's a verbose dsu I wrote myself: sortDSU decFunc a = undecorate (sort (decorate decFunc a)) decorate decFunc [] = [] decorate decFunc (x:xs) = ( ((decFunc x), x) : decorate decFunc xs ) undecorate [] = [] undecorate ( (_, y) :xs) = ( y : undecorate xs ) Here's a terser and perhaps more idiomatic (but I think equivalent) dsu which I then found in a comment at the Real World Haskell website: dsuSort decFunc a = map snd (sort (zip (map decFunc a) a)) I have tested both functions with length and sum in ghci. So, do Haskell programmers use the decorate-sort-undecorate pattern? If not, why not? If so, when? Thanks and best wishes Ivan -- ============================================================ Ivan A. Uemlianin Speech Technology Research and Development ivan(a)llaisdy.com www.llaisdy.com llaisdy.wordpress.com www.linkedin.com/in/ivanuemlianin "Froh, froh! Wie seine Sonnen, seine Sonnen fliegen" (Schiller, Beethoven) ============================================================

4 7

Understanding State
by Geoffrey Marchant 10 Jul '09

10 Jul '09

I'm trying to understand how to use State in a function. I've avoided the topic for several years because State just never seemed very useful, but I figure it's time for me to figure it out: I have the following function > update :: (a -> (r,a)) -> Int -> [a] -> (r, [a]) > update s 0 (a:as) = let (r,a') = s a in (r,a':as) > update s i (a:as) = let (r,as') = update s (i-1) as in (r, a:as') which updates a particular element of a list. Looking at it, I see two parts of the type signature that look like State types, which leads me to think of this: > update' :: State a r -> Int -> State [a] r Which leads to me writing this: > update' s 0 = do > (a:as) <- get > let (r, a') = runState s a > put (a':as) > return r > update' s i = do > (a:as) <- get > put as > r <- update' s (i-1) > as' <- get > put (a:as') > return r Now, this just looks awful. The first half, the base condition, is actually "running" a State calculation. And the second half sets the state within the monad twice! I like the idea of using State because it simplifies the type. When I see (a -> (b,a)) I say "Wait a second, that's a State calculation, isn't it?" and then, hopefully, generalize. But I can't write that calculation nearly as concisely. How do I do this properly?

3 3