August 2006 - Haskell-Cafe

fast image processing in haskell?
by Jeff Briggs 06 Aug '06

06 Aug '06

Hello, I am attempting to process images captured from a webcam. My aim is to do so, in real time, at the frame rate of the camera. I'm using GHC 6.4.2 with -O3. A frame consists of ~100k 24bit colour values. The webcam is interfaced through FFI bindings to some C++ -- these are all labelled 'unsafe'. The image is passed to Haskell as a Ptr Word8. To blit this to the screen (via Gtk2Hs) I do the following: data Cam = Cam { snap_width :: !Int , snap_height :: !Int , snap_bytespp :: !Int , snap_size :: !Int , cam_img :: Ptr Word8 , cam_obj :: ForeignPtr () } do (PixbufData _ dst _) <- (pixbufGetPixels pixbuf :: IO (PixbufData Int Word8)) copyBytes dst (cam_img cam) This achieves the desired throughput (25-29fps.) However, I am at a bit of a loss how to do something similar for preprocessing the data in Haskell before blitting the data (whilst also retaining some semblance of functional programming...) Currently, I have: cam_snap cam f x = do let loop (r:g:b:rest) n x = f r g b n x >>= loop rest (n+3) loop _ _ x = return x px <- peekArray (snap_size cam) (cam_img cam) loop px 0 x cam_snap2 cam f x = let loop ptr n x | n >= snap_size cam = return x | otherwise = do let ptrs = scanl plusPtr ptr [1,1] [r,g,b] <- mapM peek ptrs f r g b n x >>= loop (ptr `plusPtr` 3) (n+3) in loop (cam_img cam) 0 x do ... let sum_px r g b _ (sr,sg,sb) = return (sr+r,sg+g,sb+b) sum <- cam_snap (cam ui) sum_px (0.0,0.0,0.0) print sum cam_snap only processes at 5 fps, whereas cam_snap2 operates at 6fps. Any suggestions? Thanks.

4 6

Exercise in YAHT
by algorithms＠gmx.de 06 Aug '06

06 Aug '06

Dear Hugs users, could you answer the following question from a Haskell novice? In "Yet another Haskell Tutorial" by Hal Daumé III there is the following exercise: Exercise 4.8 Write functions listHead, listTail, listFoldl and listFoldr which are equivalent to their Prelude twins, but function on our List datatype. Don’t worry about exceptional conditions on the first two. My question is solely on listfoldr, in fact I only want to ask whether the solution provided in the tutorial is really so obviously wrong as I perceive it to be: (What follows uses the definition data List a = Nil | Cons a (List a) ) listFoldr f y Nil = y listFoldr f y (Cons x xs) = f x (foldr f z xs) This IS wrong, isn't it? The y does not even appear after all. And what can you say about my attempt for listFoldr? listFoldr f y Nil = y listFoldr f y (Cons x xs) = f y (listFoldr f (f y x) xs) My attempt yields a similar, albeit not identical result compared with the Prelude function foldr when :t-ing it under Hugs: Hugs> :t foldr foldr :: (a -> b -> b) -> b -> [a] -> b Hugs> :t listFoldr listFoldr :: (a -> a -> a) -> a -> List a -> a Thank you very much. Christian -- Echte DSL-Flatrate dauerhaft für 0,- Euro*. Nur noch kurze Zeit! "Feel free" mit GMX DSL: http://www.gmx.net/de/go/dsl

3 2

A problem with Show
by zdenes＠seznam.cz 06 Aug '06

06 Aug '06

Hello, I made a simple datatype called Pair and I'd like to make it an instance of Show class. But when I try to do that I run into troubles: data Pair a b = Pair a b instance Show a b => Show (Pair a b) where show (Pair a b) = show a ++ "_" ++ show b In Hugs I get this error: "Haskell does not support multiple parameter classes" When I run it in ghci I get a kind error "Show is applied to too many type arguments in the instance declaration for Show (Pair a b)" Am I jsut using wrong syntax or is it not possible to do? Thanks in advance Zdenes

2 1

REALLY simple STRef examples
by Chad Scherrer 05 Aug '06

05 Aug '06

I've looked around at the various STRef examples out there, but still nothing I write myself using this will work. I'm trying to figure out how the s is escaping in really simple examples like x = runST $ return 1 y = runST $ do {r <- newSTRef 1; readSTRef r} Neither of these works in ghci - they both say <interactive>:1:0: Inferred type is less polymorphic than expected Quantified type variable `s' escapes Expected type: ST s a -> b Inferred type: (forall s1. ST s1 a) -> a In the first argument of `($)', namely `runST' In the definition of `it': ... I thought maybe I needed to replace 1 with (1 :: Int) so the state representation didn't force the type, but it still gives the same result. Can someone point me to the simplest possible runST example that actually works? Thanks! -- Chad Scherrer "Time flies like an arrow; fruit flies like a banana" -- Groucho Marx

2 2

Monad Imparative Usage Example
by Kaveh Shahbazian 05 Aug '06

05 Aug '06

Haskell is the most powerfull and interesting "thing" I'v ever encountered in IT world. But with an imparative background and lack of understanding (because of any thing include that maybe I am not that smart) has brought me problems. I know this is an old issue. But please help it. Question : Could anyone show me a sample of using a monad as a statefull variable? For example see this code in C# : // public class Test { int var; static void Fun1() { var = 0; Console.Write(var); } static void Fun2() { var = var + 4; Console.Write(var); } static void Main() { Fun1(); Fun2(); var = 10; Console.Write("var = " + var.ToString()); } } // I want to see this code in haskell. Thankyou

8 12

Monad Imparative Usage Example
by Kaveh Shahbazian 05 Aug '06

05 Aug '06

Monad Imparative Usage Example Thanks for your replies. I have not haskell on this computer and I will try this solutions tonight. I must notice that IO computations is not the point here. My target is to have this code for mutable variable 'var'. ############################################################################# Haskell is the most powerfull and interesting "thing" I'v ever encountered in IT world. But with an imparative background and lack of understanding (because of any thing include that maybe I am not that smart) has brought me problems. I know this is an old issue. But please help it. Question : Could anyone show me a sample of using a monad as a statefull variable? For example see this code in C# : // public class Test { int var; static void Fun1() { var = 0; Console.Write(var); } static void Fun2() { var = var + 4; Console.Write(var); } static void Main() { Fun1(); Fun2(); var = 10; Console.Write("var = " + var.ToString()); } } // I want to see this code in haskell. Thankyou #############################################################################

3 3

Why shouldn't variable names be capitalized?
by Martin Percossi 04 Aug '06

04 Aug '06

Hi, I'm wondering what the rationale was for not allowing capitalized variable names (and uncapitalized type names and constructors). I can only think of two arguments, and IMHO both of them are bad: 1. Enforces a naming convention. Fine - but my view is that this doesn't belong in the language definition (it belongs in the user's coding standards). I get annoyed, for example, that when I write code that manipulates matrices and vectors, I can't refer to the matrices with capital letters as is common in the literature. And to anyone who says that it's good to enforce naming consistency, I have this to say: Any language that requires me to learn about category theory in order to write imperative code should treat me like an adult when it comes to the naming of variables as well. ;-) 2. It makes it easier to write the compiler. I don't think I need to explain why this is bad... I imagine that someone is just itching to "sort me out". Do your worst! ;-) Thx Martin

9 9

a bunch of newbie questions
by Imam Tashdid ul Alam 04 Aug '06

04 Aug '06

what's the difference between data and co-data exactly? or between inductive data types and co-inductive data types? can you give me some reference points that explain these? > (read "56")::Integer does it in fact pass the type (Integer) to the function (read)? I guess what we want is for the (Integer) implementation of the (read) function to evaluate, not really to cast the value of (read) function to (Integer). in the regex libraries, (~=) cast this way results in completely different things altogether, should type classes have namespaces associated with them? somewhat like Integer.read "56"? this way of selecting the intended implementation, does it work without trouble with multiparameter type classes as well? theoretically is it possible to do a strictness analysis without any help from the programmer? thanks a bunch in advance. __________________________________________________ Do You Yahoo!? Tired of spam? Yahoo! Mail has the best spam protection around http://mail.yahoo.com

6 9

RE: ANN: System.FilePath 0.9
by Brian Smith 04 Aug '06

04 Aug '06

[ I tried to send this through the fa.haskell USENET group but apparently it did not go through] I kind of expect that a Haskell library for file paths will use the type system to ensure some useful properties about the paths. For example, when writing security-conscious software I often want to be able to distinguish between absolute, ascending (paths with leading "../" and similar items), and decending paths (paths that contain no "../"). I want to make sure a filename is valid. For example, "prn" and "con" are not valid path elements for normal files on Windows, certain characters are not allowed in filenames (depending on platform), some platforms may require paths to be escaped in different ways. I see there is a "isValid" function and even a (magical) "makeValid" function, but they do not report what was wrong with the filename in the first place. Furthermore, it isn't clear from the documentation how these functions determine whether a filename is valid. Many people might be familiar with Joel Spolsky's article "Making Wrong Code Look Wrong" at http://www.joelonsoftware.com/articles/Wrong.html . If you read that article, you will see that advocates a variable naming convenctions to distinguish between HTML-escaped "safe" and non-escaped "unsafe" strings. In Haskell, we can do much better than that by using convenient strong static typing to enforce such constraints. We should be able to use type signatures to ensure that we are operating on syntactically valid paths of a certain form. For example, a function's type should indicate that it expects an absolute path, or a relative path that doesn't use "../../.." to decend into parent/sibling directories unexpectedly, which is a common exploit technique. IMO, safety is the most important issue regarding file paths and it is not addressed in this library as far as I can see. Writing code to handle these issues is tedious, error-prone, and boring to write despite being critical. It isn't the kind of code that you want to just download off of some guy's webpage. Basically, it is exactly the type of thing that belongs in a standard library. In this library proposal, there are a bunch of "xxxDrive" functions that many Unix-oriented programmers are sure to ignore because they are no-ops on Unixy systems. Even on Windows, they are not very useful: Windows software almost never cares what drive a directory is on, especially because the directory might not be on a drive at all (for example, a UNC network path "\\foo\bar" has no "drive" component but it is an absolute path). Really, Windows software usually works similarly to Unixy software in this regard--the big difference is that Unixy systems have one root path, whereas Windows systems can have many, many root paths (drives and UNC's). - Brian

20 68

Code review: initial factoring for sequences and other structures
by Brian Hulley 04 Aug '06

04 Aug '06

Hi - I've started work on an initial factoring of sequence ops into classes, and already I've run into some major design issues which stand like a mountain in the way of progress. The classes are below: -- all code below standard BSD3 licence :-) module Duma.Data.Class.Foldable ( Foldable(..) ) where import qualified Data.List as List class Foldable c a | c -> a where foldR :: (a -> b -> b) -> b -> c -> b foldL :: (b -> a -> b) -> b -> c -> b foldL' :: (b -> a -> b) -> b -> c -> b -- arg order from FingerTree paper -- opposite to Edison arg order reduceR :: (a -> b -> b) -> (c -> b -> b) reduceR f xs y = foldR f y xs reduceL :: (b -> a -> b) -> (b -> c -> b) reduceL = foldL reduceL' :: (b -> a -> b) -> (b -> c -> b) reduceL' = foldL' instance Foldable [a] a where foldR = List.foldr foldL = List.foldl foldL' = List.foldl' and module Duma.Data.Class.BasicSeq ( BasicSeq(..) ) where import Prelude hiding(map) import Duma.Data.Class.Foldable import qualified Data.List as List import Control.Monad class Foldable c a => BasicSeq c a where empty :: c isEmpty :: c -> Bool atL :: c -> a atR :: c -> a pushL :: a -> c -> c pushR :: c -> a -> c viewL :: Monad m => c -> m (a, c) viewR :: Monad m => c -> m (c, a) -- (1) Should this be in its own class? convert :: BasicSeq d a => c -> d convert = foldR pushL empty -- (2) Is this too general or not general enough? map :: BasicSeq d b => (a -> b) -> c -> d map f xs = case viewL xs of Just (x, xs') -> pushL (f x) (map f xs') Nothing -> empty instance BasicSeq [a] a where empty = [] isEmpty [] = True isEmpty _ = False atL (x:_) = x atR = List.last pushL = (:) pushR xs x = xs ++ [x] viewL (x:xs) = return (x,xs) viewL _ = fail "viewL" viewR xs@(_:_) = return (List.init xs, List.last xs) viewR _ = fail "viewR" (Indexing ops like take, drop, length, at, split would be provided by a third class and measurements (to access the power of finger trees and similar structures) would be dealt with by a fourth class with analogous ops ie takeWith, splitWith etc) However already with just the above I have some questions about the (convert) and (map) functions: 1) Because (convert) takes BasicSeq d a as a context, it is currently impossible to provide an optimized version for specific combinations of source/dest types eg if both types are the same (convert) should just be (id). Does this mean I should put (convert) into its own class or should I expect the compiler to be able to rewrite (foldR pushL empty) into (id) in this situation? 2) Ditto with (map), but here there is another issue: it is at once too general and too specific compared to the usual definitions of (map): --Prelude - limited to lists only map f (x:xs) = f x : map f xs map _ [] = [] -- Functor - source and dest limited to the same type fmap :: (a->b) -> f a -> f b So even though fmap is constrained to only map between the same type, it is more general than BasicSeq.map because the type doesn't need to be a BasicSeq. However it is less general in the sense that fmap wouldn't allow to map between two different instances of BasicSeq. There is a general problem that when the element type needs to be specified along with the type of the overall collection, there is no way to talk about the functor type at the same time eg I'd like to be able to write something like this: class Functor f a b where fmap :: (a->b) -> f a -> f b instance (BasicSeq (f a) a, BasicSeq (f b) b) => Functor f a b where fmap = map but GHC complains that I'd need to use -fallow-undecidable-instances which I'm reluctant to do because I don't know what the implications of such a decision would be. Why are these instances for such a simple thing (ie just pattern matching against the components of a type) already undecidable? The issues above are the kind of problems I just don't know how to solve or even how to approach, since there seem to be too many conflicting dimensions in the design space. Any ideas? Thanks, Brian. -- Logic empowers us and Love gives us purpose. Yet still phantoms restless for eras long past, congealed in the present in unthought forms, strive mightily unseen to destroy us. http://www.metamilk.com

1 1