November 2009 - Haskell-Cafe

ANNOUNCE: simple-observer-0.0.1, a simple implementation of the observer design pattern
by Andy Gimblett 11 Nov '09

11 Nov '09

Hi all, Further to earlier discussion on this topic, I've just released a first version of this package to hackage: http://hackage.haskell.org/package/simple-observer It is a fairly simple implementation of subject/observer which I've recently used to good effect in an GUI written using wxHaskell. Here's a blog post discussing it further and giving a simple example of use: http://gimbo.org.uk/blog/2009/11/12/simple-observers-in-haskell/ Many thanks for the earlier comments, even if they haven't resulted in any changes (yet?). Best regards, -Andy

1 0

Re: [Haskell-cafe] looking for a good algorithm
by Tillmann Vogt 11 Nov '09

11 Nov '09

Hong Yang schrieb: > The question is more about algorithm than Haskell. But I am going to code in > Haskell which I am still learning. > > Suppose I have a large table, with hundreds of columns and thousands of > rows. But not every cell has a value (of String, or Int, or Double type). > > I want to shuffle the rows to maximize the number of columns whose first 100 > rows have at least one number, given a list of preferred column names since > there is no guarantee that every number column will have at least one number > in its first 100 rows after shuffling. > > Can someone provide a good algorithm for this problem? (I do not have any > background in algorithms.) You can assume I already know which columns are > of Int or Double type. I would say it depends on the distribution of values in the table. If there are rows with a lot of values and rows with few values, then I would first sort the rows after the number of cells with values. If you look at all the columns and the number of values for each row is unique then it would be perfectly solved. With a list of preferred columns and also a uniform distribution the problem might be hard (NP-complete?), but these hard problems can often be approximated, i.e with simulated annealing, which in short is switching two rows repeatedly as long as the result improves. > > This is not a homework. > Thanks, > > Hong > > > ------------------------------------------------------------------------ > > _______________________________________________ > Haskell-Cafe mailing list > Haskell-Cafe(a)haskell.org > http://www.haskell.org/mailman/listinfo/haskell-cafe

3 2

Tabla de calculo de dolares viajero CADIVI
by Hector Guilarte 11 Nov '09

11 Nov '09

Tabla del operador cambiario para determinar cuantos dolares te tocan por viaje en el 2009... Saquen sus propias conclusiones... Además de la tabla, miren los bloqueos de ciertas transacciones de abajo... Increíble La reenvío como me llegó... **

1 0

What's the deal with Clean?
by Deniz Dogan 11 Nov '09

11 Nov '09

Recently there has been a lot of discussion on this list about the programming language Clean and converting Clean programs to Haskell. Reading the Wikipedia article on the language, I can't really see any major difference between that and Haskell, except for the monads vs. uniqueness types. So what's the deal with Clean? Why is it preferable to Haskell? Why is it not? -- Deniz Dogan

27 59

a problem defining a monad instance
by Petr Pudlak 11 Nov '09

11 Nov '09

Hi all, (This is a literate Haskell post.) I've encountered a small problem when trying to define a specialized monad instance. Maybe someone will able to help me or to tell me that it's impossible :-). To elaborate: I wanted to define a data type which is a little bit similar to the [] monad. Instead of just having a list of possible outcomes of a computation, I wanted to have a probability associated with each possible outcome. A natural way to define such a structure is to use a map from possible values to numbers, let's say Floats: > module Distribution where > > import qualified Data.Map as M > > newtype Distrib a = Distrib { undistrib :: M.Map a Float } Defining functions to get a monad instance is not difficult. "return" is just a singleton: > dreturn :: a -> Distrib a > dreturn k = Distrib (M.singleton k 1) Composition is a little bit more difficult, but the functionality is quite natural. (I welcome suggestions how to make the code nicer / more readable.) However, the exact definition is not so important. > dcompose :: (Ord b) => Distrib a -> (a -> Distrib b) -> Distrib b > dcompose (Distrib m) f = Distrib $ M.foldWithKey foldFn M.empty m > where > foldFn a prob umap = M.unionWith (\psum p -> psum + prob * p) umap (undistrib $ f a) The problem is the (Ord b) condition, which is required for the Map functions. When I try to define the monad instance as > instance Monad Distrib where > return = dreturn > (>>=) = dcompose obviously, I get an error at (>>=): Could not deduce (Ord b) from the context. Is there some way around? Either to somehow define the monad, or to achieve the same functionality without using Map, which requires Ord instances? Thanks a lot, Petr

8 8

Hoogle is great but ...
by zaxis 11 Nov '09

11 Nov '09

http://www.haskell.org/hoogle/ is VERY great for haskeller. However, i feel hoogle should be improved by providing more examples as : isInfixOf :: Eq a => [a] -> [a] -> Bool The isInfixOf function takes two lists and returns True iff the first list is contained, wholly and intact, anywhere within the second. Example: isInfixOf "Haskell" "I really like Haskell." -> True isInfixOf "Ial" "I really like Haskell." -> False The Example code will be helpful for programmer to understand its definition. Sincerely! -- View this message in context: http://www.nabble.com/Hoogle-is-great-but-...-tp26046410p26046410.html Sent from the Haskell - Haskell-Cafe mailing list archive at Nabble.com.

8 8

Fair diagonals
by Martijn van Steenbergen 11 Nov '09

11 Nov '09

Dear café, I am looking for a function that does an N-dimensional diagonal traversal. I want the traversal to be fair: the sum of the indices of the produced combinations should be non-decreasing. Let me illustrate with an example. The type of a 2-dimensional traversal would look like this: > diag2 :: [a] -> [b] -> [(a, b)] The first two arguments are the two half-axes of the grid and the result is a fair diagonal traversal of all the points. For example: >> diag2 [1,2,3] [4,5,6,7] > [(1,4),(2,4),(1,5),(3,4),(1,6),(2,5),(1,7),(3,5),(2,6),(2,7),(3,6),(3,7)] Of course the function should work on infinite lists: >> diag2 [1..] [1..] > [(1,1),(2,1),(1,2),(3,1),... Or a combination of finite and infinite lists: >> diag2 [1,2] [1..] > [(1,1),(2,1),(1,2),(1,3),(2,2),(1,4),... Notice that in each case the sum of the pairs (which can seen as indices in these particular examples) are non-decreasing: >> let sums = map (uncurry (+)) >> sums $ diag2 [1,2,3] [4,5,6,7] > [5,6,6,7,7,7,8,8,8,9,9,10] >> sums $ diag2 [1..] [1..] > [2,3,3,4,4,4,5,5,5,5,6,... >> sums $ diag2 [1,2] [1..] > [2,3,3,4,4,5,5,6,6,7,7,... Similarly for 3 dimensions the type would be: > diag3 :: [a] -> [b] -> [c] -> [(a, b, c)] For N dimensions we have to sacrifice some generality and ask all axes to be of the same type and produce lists instead of tuples, but I'm perfectly happy with that: > diagN :: [[a]] -> [[a]] I have implemented diag2 and diag3 [1] but noticed that the function bodies increase in size exponentially following Pascal's triangle and have no clue how to generialize to N dimensions. Can you help me write diagN? Bonus points for the following: * An infinite number of singleton axes produces [origin] (and finishes computing), e.g. forall (infinite) xs. diagN (map (:[]) xs) == map (:[]) xs * For equal indices, the traversal biases to axes that are occur early in the input (but I don't know how to formalize this). * The implementation shows regularity and elegance. Many thanks, Martijn. [1] http://hpaste.org/fastcgi/hpaste.fcgi/view?id=11515

9 15

Working with multiple projects
by Tony Morris 11 Nov '09

11 Nov '09

I have two projects that I intend to put on hackage soon. One depends on the other. I have "cabaled" both. I am wondering how others work with this kind of set up where changes are made to both libraries as they work. -- Tony Morris http://tmorris.net/

5 5

ANN: haskell-mode 2.6
by Svein Ove Aas 11 Nov '09

11 Nov '09

Fellow haskellers: Haskell-mode 2.6 has been released. * By web: http://projects.haskell.org/haskellmode-emacs/ * By darcs: http://code.haskell.org/haskellmode-emacs/ This is mainly a bugfix release; to anyone using haskell-indentation, the big news will be that it no longer under some circumstances hands you a parse error and refuses to insert a newline, or backspace. It still gives you a parse error. It just tries its best to proceed anyway. There are also some new features, courtesy of Alex Ott: More font-lock symbols, and a hayoo function. In the case of the font-lock symbols, your mileage may vary on how nice the picked ones are. Mine certainly does. As such, I'm announcing open season on font-lock symbols: Comment to your heart's desire, and I'll use whatever you decide on for the next official release. The tab-cycle implementation is thanks to ivanm, whose random comments can trigger hours and hours of work. I'll just quote from the NEWS file now: === Changes since 2.5.1 * haskell-indentation: Pressing tab in the rightmost position now moves to the leftmost, by default with a warning. * Typo fix: One haskell-indentation variable had ended up in the haskell-ntation customize group. * haskell-hoogle aliased to hoogle, haskell-hayoo aliased to hayoo * Courtesy of Alex Ott: - Additional unicode symbols for font-lock-symbols: () == /= >= <= !! && || sqrt - M-x haskell-hayoo search added, opens using browse-url - Bug-fix for inferior-haskell-type * If haskell-indentation errors out, it now fail-safes to inserting a literal newline or deleting one character, for return and backspace respectively. -- Svein Ove Aas

4 9

Problems with Language.Haskell.Interpreter and errors
by Martin Hofmann 11 Nov '09

11 Nov '09

Hi, The API of Language.Haskell.Interpreter says, that 'runInterpreter' runInterpreter :: (MonadCatchIO m, Functor m) => InterpreterT m a -> m (Either InterpreterError a) returns 'Left' in case of errors and 'GhcExceptions from the underlying GHC API are caught and rethrown as this'. What kind of errors do a generate here, why are they not caught by runInterpreter and how can I catch them? I assumed to get a 'Left InterpreterError' from the first and an error in MonadCatchIO in the second. > :m +Language.Haskell.Interpreter > let estr1 = "let lst [a] = a; lst _ = error \"foo\" in lst []" > let estr1 = "let lst [a] = a; in lst []" > runInterpreter (setImportsQ [("Prelude", Nothing)] >> eval estr1 ) Right "*** Exception: foo > runInterpreter ( eval estr2) Right "*** Exception: <interactive>:1:101-111: Non-exhaustive patterns in function lst Thanks a lot

2 7