- Haskell-Cafe - Haskell.org

Re: [Haskell-cafe] numeric minimization in Haskell
by Chad Scherrer 01 Mar '07

01 Mar '07

David Roundy wrote: > It seems like GSLHaskell is an awfully big stick, when all you need are > scalar multiply and vector addition. Of course, we don't know what > functions he wants to minimize, but in the absence of any need for GSL > functions, I don't see a good reason for it. The function is just a linear combination of sines and cosines. No need for GSL for that. > I see that GSLHaskell has a binding to a conjugate gradients minimizer, but > it's not useful for any hard problems (it stores the trajectory, which > defeats the purpose of using conjugate gradients), and can only be very, > very slow. I had been throwing the trajectory away without any more thought, but I suppose it would slow things down quite a bit. > >From the API alone it cannot be efficient. Code that is written by people > who obviously either don't know or don't care about efficiency is just not > in general a good idea. I don't know what you use GSLHaskell for in your > work, but I hope you don't use it for conjugate gradients, or only use it > on easy problems. I agree, given the API it seems like it could be very nice for visualizing how CG works, but it does seem to rule out high performance. > -- > David Roundy > Department of Physics > Oregon State University Chad Scherrer

1 0

Blog post: 'Haskell IO for imperative programmers'
by David House 01 Mar '07

01 Mar '07

It's not mine, but I just came across the following from a link in #haskell: http://blogs.nubgames.com/code/?p=22 A brilliantly written, fantastically clear exposition of IO from the point of view of a long-time imperative programmer. Don't miss it. One to forward to friends and coworkers. -- -David House, dmhouse(a)gmail.com

1 0

OO Design in Haskell Example (Draft)
by Steve Downey 01 Mar '07

01 Mar '07

In the last OO design in Haskell thread (and probably in every one preceeding it), it was suggested that having some examples might be a good idea. Since most people with existing designs will have some familiarity with Design Patterns, and those are typical building blocks for OO designs, it occured to me that implementing some of them might be a useful excersize. If for nothing other than learning some more Haskell. Now, some of them are probably bad ideas for implementing in Haskell. There's a better, or more natural, way than what is suggested by the design pattern. Visitor is probably not a good pattern to follow, for example. On the other hand, others may still be useful, even in a functional language. So, I've been working on a Composite example. I've used existential types to have a generic proxy to the base type, rather than a simple algebraic type, since adding new leaves to the algebraic type means modifying the whole type, a violation of the Open-Closed principle (open for extension, closed for modification) The interface of the composite. Two methods, add and draw. > class IComponent e where > draw ::e -> String > add :: (IComponent e') => e -> e' -> Component A proxy type which can hold any kind of component, and provides the 'virtual' dispatch implementation. That is, it forwards to the add or draw implementation of the instance it is proxying for. > data Component = > forall e.(IComponent e) => Component e > componentDraw :: Component -> String > componentDraw (Component c) = draw c > componentAdd :: (IComponent e) => Component -> e -> Component > componentAdd (Component e) a = Component (add e a) > instance IComponent Component where > draw = componentDraw > add = componentAdd The Single type, which is the leaf node in this composite, add is a no-op, except for wrapping the value in a Component. Since there isn't an implicit down cast from the 'derived' Single to the 'base' Component. > data Leaf = > Text String > deriving(Show, Eq) > leafDraw :: Leaf -> String > leafDraw (Text s) = show s > leafAdd :: (IComponent e) => Leaf -> e -> Component > leafAdd s _ = Component s > instance IComponent Leaf where > draw = leafDraw > add = leafAdd The Composite type, which holds a list of Components through the composite proxy. I was tempted to make the list a state variable, so that add could modify rather than produce a new Many, but I wanted to get the basics working. > data Composite = > Many [Component] > compositeDraw :: Composite -> String > compositeDraw (Many []) = "()" > compositeDraw (Many leaves) = "(" ++ (foldr1 (++) $ map draw leaves) ++ ")" > compositeAdd :: (IComponent e) => Composite -> e -> Component > compositeAdd (Many leaves) c = > Component $ Many ((Component c) : leaves) > instance IComponent Composite where > draw = compositeDraw > add = compositeAdd >

5 6

Hi can u explain me how drop works in Haskell
by iliali16 01 Mar '07

01 Mar '07

Hi I am trying to implement the function drop in haskell the thing is that I I have been trying for some time and I came up with this code where I am trying to do recursion: drop :: Integer -> [Integer] -> [Integer] drop 0 (x:xs) = (x:xs) drop n (x:xs) |n < lList (x:xs) = dropN (n-1) xs : |otherwise = [] So I want to understand how would this work and what exacttly should I put as an answer on line 4 couse that is where I am lost. I know I might got the base case wrong as well but I don't know what to think for it. I have done the lList as a function before writing this one. Thanks to those who can help me understand this. Thanks alot in advance! Have a nice day! -- View this message in context: http://www.nabble.com/Hi-can-u-explain-me-how-drop-works-in-Haskell-tf32904… Sent from the Haskell - Haskell-Cafe mailing list archive at Nabble.com.

7 10

State monad in the wikibood article
by TJ 01 Mar '07

01 Mar '07

In the wikibook article here: http://en.wikibooks.org/wiki/Haskell/Understanding_monads, which really does an excellent job explaining things (nuclear waste woohoo!), I am stuck at the following code snippet: container >>= fn = \st -> let (a, st2) = container st container2 = fn a in container2 st2 What stumps me is that (>>=) is supposed to return a container, but if we return (container2 st2) as in the code, then what we're really returning is the contents of the container! So what would happen if we do this: nuclearWasteInContainer >>= processTheWaste >>= thoroughProcessTheWaste It seems to me that the second (>>=) in the above expression would have the arguments (nuclearWaste) and (nuclearWasteProcessor), when what it really expects are (Container nuclearWaste) and (nuclearWasteProcessor). So isn't something wrong with the definition of (>>=) above? Or am I missing something? (I know the article says that the type for their supposed State monad at that point is not actually correct, and will be clarified further on, but that seems to be irrelevant to my question.) TJ the forever noobie.

2 2

Raiding the blogosphere
by dons＠cse.unsw.edu.au 28 Feb '07

28 Feb '07

I've done a quick pass over the 100s of blog articles written in the last few months about Haskell, collecting and categorizing the best on Haskell.org: http://haskell.org/haskellwiki/Blog_articles Since it would be a real shame to not take advantage of these new tutorials. That page should serve something like the cookbook page, but for external contributions. If you have some older favourites, please add them! The list might also serve to inspire people to write about areas not yet well covered... (hint hint: more articles on parallelism, XML, building servers ... ;) -- Don

1 0

Logic programming using lazy evaluation
by Henning Thielemann 28 Feb '07

28 Feb '07

I suspect that someone has already done this: A Haskell library which solves a system of simple equations, where it is only necessary to derive a value from an equation where all but one variables are determined. Say 1+2=x -- add 1 2 x y*z=20 -- times y z 20 x+y=5 -- add x y 5 should be solved as x=3 y=2 z=10 Of course, it is easy to do this for a finite number of variables and equations by assigning integer identifiers to the variables, then scanning the equations repeatedly until all determinable variables are determined. However, imagine I have an infinite number of equations and an infinite number of variables, say 1=x0 -- equal 1 x0 2*x0=x1 -- times 2 x0 x1 2*x1=x2 -- times 2 x1 x2 2*x2=x3 -- times 2 x2 x3 ... Accessing variable values by integer identifiers means that the garbage collector cannot free values that are no longer needed. Thus I thought about how to solve the equations by lazy evaluation. Maybe it is possible to ty the knot this way let (_,_,x0) = add 1 2 x (y0,z0,_) = times y z 20 (x1,y1,_) = add x y 5 x = alternatives [x0,x1] y = alternatives [y0,y1] z = alternatives [z0] in (solve x, solve y, solve z) Independent from the question of how to implement 'alternatives' and 'solve' I wonder if there is a less cumbersome way to do this kind of logic programming in Haskell.

3 5

TFP 2007: Last Call for Participation
by TFP 2007 28 Feb '07

28 Feb '07

Dear Colleagues, The deadline to register for TFP 2007 is quickly approaching. You may register at: http://cs.shu.edu/tfp2007/registration.html . Also, please be advised that the deadline to make hotel reservations at the guaranteed rate for TFP 2007 participants is also quickly approaching. Hotel information can be found at: http://cs.shu.edu/tfp2007/accomodations.html . You may browse the program and schedule for TFP 2007 at: http://cs.shu.edu/tfp2007/schedule.html . We look forward to seeing you in NYC!!! Cheers, Marco ************************************************************************************ Dr. Marco T. Morazan TFP 2007 Program Committee Chair http://cs.shu.edu/tfp2007/

1 0

Plotting in Haskell
by Chris Witte 28 Feb '07

28 Feb '07

Are there any good libraries for drawing plots (2D and 3D) in Haskell (under Windows using GHC)? Cheers Chris Witte

6 5

Re: overlapping instances, selecting if type a does not belong to class?
by oleg＠pobox.com 27 Feb '07

27 Feb '07

The problem you report can be fixed with some trickery and local functional dependencies. I'd like to show a different solution, which follows a useful general pattern, of isolating overlapping instances to one small part of the program that analyzes the type. The rest of the type program just uses the results of the analysis. > I wasn't able to find the definition of AllOf(But): It is in the complete code http://pobox.com/~oleg/ftp/Haskell/poly2.hs It isn't that interesting: > data AllOfBut x y {-# OPTIONS -fglasgow-exts #-} {-# OPTIONS -fallow-undecidable-instances #-} {-# OPTIONS -fallow-overlapping-instances #-} module HAA where import HListPrelude data HTrue data HFalse -- If two arguments are HList's, concatenate them. If only one of them -- is HList, add the other to the head. We assume at least one is an HList. class IsHList a b | a -> b instance IsHList HNil HTrue instance IsHList (HCons a b) HTrue instance TypeCast HFalse y => IsHList x y -- The are no overlapping instances below class (HList c) => HListAppendArbitrary a b c | a b -> c where hAppendArbitrary :: a -> b -> c instance (IsHList a af, IsHList b bf, HAA af bf a b c) => HListAppendArbitrary a b c where hAppendArbitrary = haa (undefined::af) (undefined::bf) class (HList c) => HAA af bf a b c | af bf a b -> c where haa :: af -> bf -> a -> b -> c -- Both are HLists instance (HList c, HAppend a b c) => HAA HTrue HTrue a b c where haa _ _ = hAppend instance HList a => HAA HTrue HFalse a b (HCons b a) where haa _ _ a b = HCons b a instance HList b => HAA HFalse HTrue a b (HCons a b) where haa _ _ a b = HCons a b -- deliberately unimplemented: at least one must be an HList... -- instance HList b => HAA HFalse HFalse a b c where test1 = hAppendArbitrary HNil True test2 = hAppendArbitrary True (HCons () HNil) test3 = hAppendArbitrary (HCons () HNil) (HCons False HNil) test4 = hAppendArbitrary (HCons () HNil) 'a' -- testf = hAppendArbitrary 'n' () -- TypeCast is skipped

1 0