January 2003 - Haskell-Cafe

RE: Evaluation Question
by Simon Marlow 20 Jan '03

20 Jan '03

[ moved to haskell-café ] > Simon Marlow wrote: > > The original version should also evaluate the expression > 'cis wn' only > > once: [...] > > Nice theory, but GHC's interpreter and compiler behave differently: > > -- Main.hs ----------------------------------------------------------- > module Main where > > import Data.Complex ( Complex ) > import qualified Data.Complex ( cis ) > import Debug.Trace > > cis :: (RealFloat a) => a -> Complex a > cis x = trace "cis" $ Data.Complex.cis x > > nco1, nco2 :: RealFloat a => a -> [ Complex a ] > nco1 wn = 1 : map ((*) (cis wn)) (nco1 wn) > nco2 wn = iterate (cis wn *) 1 > > main :: IO () > main = do > let test f = print . take 5 . f $ (pi/2 :: Double) > test nco1 > test nco2 > ---------------------------------------------------------------------- Oops, I didn't notice that nco1 was recursive. I should have said the expression (cis wn) is evaluated once for each call to nco1. It is not evaluated once for each element of the list in map's second argument, which is what I thought was being asked. > panne@jeanluc:~> ghci Main.hs > ___ ___ _ > / _ \ /\ /\/ __(_) > / /_\// /_/ / / | | GHC Interactive, version 5.05, > for Haskell 98. > / /_\\/ __ / /___| | http://www.haskell.org/ghc/ > \____/\/ /_/\____/|_| Type :? for help. > > Loading package base ... linking ... done. > Compiling Main ( Main.hs, interpreted ) > Ok, modules loaded: Main. > *Main> main > [1.0 :+ 0.0,cis > 6.123031769111886e-17 :+ 1.0,cis > (-1.0) :+ 1.2246063538223773e-16,cis > (-1.836909530733566e-16) :+ (-1.0),cis > 1.0 :+ (-2.4492127076447545e-16)] > [1.0 :+ 0.0,cis > 6.123031769111886e-17 :+ 1.0,(-1.0) :+ > 1.2246063538223773e-16,(-1.836909530733566e-16) :+ (-1.0),1.0 > :+ (-2.4492127076447545e-16)] > *Main> :quit > Leaving GHCi. > panne@jeanluc:~> ghc -Wall -O Main.hs && ./a.out > cis > cis > cis > cis > [1.0 :+ 0.0,6.123031769111886e-17 :+ 1.0,(-1.0) :+ > 1.2246063538223773e-16,(-1.836909530733566e-16) :+ (-1.0),1.0 > :+ (-2.4492127076447545e-16)] > cis > [1.0 :+ 0.0,6.123031769111886e-17 :+ 1.0,(-1.0) :+ > 1.2246063538223773e-16,(-1.836909530733566e-16) :+ (-1.0),1.0 > :+ (-2.4492127076447545e-16)] > ---------------------------------------------------------------------- This difference is due to the different buffering behaviour on stdout/stderr between compiled and interpreted programs. GHCi sets these handles to unbuffered by default, which tends to be more useful for an interpreter. Cheers, Simon

1 0

Re: A question about dynamic typing
by Jon Cast 19 Jan '03

19 Jan '03

Nick Name <nick.name(a)inwind.it> wrote: > On Sun, 19 Jan 2003 16:02:41 -0600 > Jon Cast <jcast(a)ou.edu> wrote: > > So, I would attach a list of named operations of type (Dynamic -> > > Result) to each type, and offer the operations for a given type to > > the user. > Thanks for your answer, it's interesting. > What do you mean with "named operations"? Something like operations > labeled with string, to be able to compare it? Yes: (String, Dynamic -> Result). > Vincenzo Jon Cast

1 0

Question about lists
by cris cris 19 Jan '03

19 Jan '03

hello there, To be honest I'm not very familiar with haskell and stuff so don't laugh with my question... here it goes.. We can represent a matrix as a list of lists... which means that 1 2 3 4 7 6 2 5 1 could be written as follows: [[1,2,3],[4,7,6],[2,5,1]] The question is how can I reverse the matrix (each row becomes a column) Thanx a lot ______________________________________________________________________________________ http://mobile.pathfinder.gr - Pathfinder Mobile logos & Ringtones! http://www.pathfinder.gr - Δωρεάν mail από τον Pathfinder!

3 2

Re: A question about dynamic typing
by Jon Cast 19 Jan '03

19 Jan '03

Nick Name <nick.name(a)inwind.it> wrote: > Or maybe the subject has nothing to do with my question :) It does, I think. <snip subject="class Visible"/> > My problem is: an user putting someway different "visible" elements in > a list (wich could be represented in a side panel) will want to > retrieve an object with its full type when clicking on it (to be able > to perform specific applications), but this isn't allowed by the type > system. This does require dynamic, run-time typing (to make the cast safe). GHC has a dynamic typing library (for monomorphic types only, but I doubt that'll be an issue for you); it's in Data.Dynamic. Short version: if Typeable is a super-class of Visible or mentioned in your existential type (i.e., forall a. (Visible a, Typeable a) => Con) you can use (fromDynamic . toDyn) to safely (attempt to) convert the abstract type into the concrete one. If that last paragraph wasn't coherent, I can try to explain it more. > It's not a problem of functional programming: even in object oriented > programming I see the same problem if one doesn't use some form of > typecast. > Where am I wrong? Are there alternatives? > Vincenzo Jon Cast

2 1

A question about dynamic typing
by Nick Name 18 Jan '03

18 Jan '03

Or maybe the subject has nothing to do with my question :) I was thinking of an "haskell desktop interface", i.e. just a desktop interface, but written in haskell. I thought this: one can define a type class with the "view" method: data Draw -- the drawing monad class Visible t where view :: t -> Time -> Draw And so one can have a list of viewable objects and by mapping some "runDrawIntoIO" function wich spawns a thread for each element of a list, obtain animated icons and applets where one expects just icons. If I use the "Visible" class, I can use existential types to create a non-homogeneous list and "view" all the objects. The same thing could be achieved, of course, with record types: data Visible = { view :: Time -> Draw } and I can achieve the same result I get with existential types. My problem is: an user putting someway different "visible" elements in a list (wich could be represented in a side panel) will want to retrieve an object with its full type when clicking on it (to be able to perform specific applications), but this isn't allowed by the type system. It's not a problem of functional programming: even in object oriented programming I see the same problem if one doesn't use some form of typecast. Where am I wrong? Are there alternatives? Vincenzo

1 0

non-question, instance decl
by ketil＠ii.uib.no 14 Jan '03

14 Jan '03

Hi, experimenting with QuickCheck, I write > instance (Arbitrary e) => Arbitrary (Array Int e) where > arbitrary = undefined and I get: | Illegal instance declaration for `Arbitrary (Array Int e)' | (The instance type must be of form (T a b c) | where T is not a synonym, and a,b,c are distinct type variables) | In the instance declaration for `Arbitrary (Array Int e)' |Failed, modules loaded: QuickCheck. Okay, after experimenting a bit (more fun than reading documentation) I see what's happening: I can't instantiate a halfway specialized type, but 'Ix i => Arbitrary (Array i e)' is Okay. Unfortunately, I really depend on i being Int in my (real) definition of 'arbitrary'. I got around it by liberal doses of 'fromInteger' and a 'Num' context -- ugly, but it seems to work. I suppose there's a solid reason why my previous attempt is illegal? -kzm -- If I haven't seen further, it is by standing in the footprints of giants

1 0

A newbie question about Arrows.
by Nicolas Oury 13 Jan '03

13 Jan '03

Hello, I read some of the material about Arrows on www.haskell.org/arrows and I have some questions : * Why is made the choice to use (,) as Cartesian in first? Can't we write something like : class Cartesian p where pair :: a -> b -> (p a b) projLeft :: (p a b) -> a projRight :: (p a b) -> b class Cartesian pair => Arrow ar where arr ::( ar pair a b) -> (ar pair a b) (>>>) :: (ar pair a b) -> (ar pair b c) -> (ar pair a c) first :: (ar pair a b) -> (ar (pair a d) (pair b d)) (The same could be said for ArrowChoice) I think this could be more powerful and could allow a smarter management of inputs and outputs of arrows than tuples. I think for example to event-driven arrows : we could make a pair of inputs without mixing the "event happened" information. * Why is made the choice of first as being a base function? We have first f = f *** (arr id) second f = (arr id) *** f So they could be define from (***). Moreover, the definition of f *** with first and second creates an order in the use of the f and g (first f >>> second g) whereas it seems that (***) is a "parallel" operator. In an event-driven arrow we have to give the same events to f and g even if they are independent. Best regards, Nicolas Oury

4 4

Re: Web Application Development
by Dominic Steinitz 11 Jan '03

11 Jan '03

I have summarised the responses I have received and cross posted this to Haskell-Cafe in case anyone wishes to carry on the conversation. > In a moment of weakness, I offered to help a friend develop a website. It's > a simple database application which carries out very little calculation and > then displays the results via HTML. > > The original code was in PHP and MySQL so rather than re-invent the wheel I > > So my question is: what should I do to re-write this in Haskell? > 1. SQL 1.a. MySQL 1.a.i Use MySQL-HS which requires the use of H/Direct. Available via www.haskell.org. 1.a.ii Use http://cvs.sourceforge.net/cgi-bin/viewcvs.cgi/hbase/Source/Foreign/. This is pre-alpha. 1.b Oracle 1.b.i Use C2HS and libsqlora8 (a simple C library for interfacing to Oracle http://www.poitschke.de/libsqlora8/) There is no publicly available code. 1.c Database Independent 1.c.i Use the DBI model as found in Perl and the libpq binding as listed on Haskell.org (http://www.astercity.net/~khaliff/haskell/dbi/dbi.tgz) This currently has a PostgreSQL binding but is not listed on SourceForge. 1.c.ii Use the code at http://sourceforge.net/projects/htoolkit/. This is planning (that is pre pre-alpha). There appear to be bindings for MySQL, ODBC and PostgreSQL. 2. HTML I have tried out Wash/CGI and this seems satisfactory for my purposes at the moment. Many thanks to everyone who replied, Dominic.

1 0

Re: Interpret haskell within haskell.
by cwitty＠newtonlabs.com 10 Jan '03

10 Jan '03

Matt Hellige <matt(a)immute.net> writes: > So it seems natural, especially to new users, to hope that Haskell and > the ML variants, sharing many other features common to these > languages, would offer this facility as well. The answer, in general, > is that they do not. (Sorry for the belated reply.) Evidently, some ML variants do include eval or eval-like facilities. When reading through the sources of the Isabelle 2002 proof verification system, I noticed the "use_text" eval-like function which is implemented using the following system-specific functions: smlnj-0.93: System.Compile.use_stream polyml: PolyML.Compiler mlworks, mosml: use Carl Witty

1 0

newbie questions
by Max Ischenko 09 Jan '03

09 Jan '03

Hello! I'm started to learn Haskell and have some questions. After reading a "Gentle introduction..." I've decided to write a simple program -- a complement to Literate.hs from hugs demos which reads a plain haskell source file and converts it to literate haskell source. The source code of this program follows. Now the questions: - To be able to run it both in Hugs and by GHC I need an `import Data.Char(isSpace) for GHC`. Can this be conditionally included in a source for GHC only? - Am I reinventing the wheel with my `pad` function? Could I use some standard function(s) instead? - What if I'd want to do a more complex processing, like handling {--} comments? The `classify` function analize one line at a time and I'd want too see a surronding context? Should I use another pass, just like for `addblanks`? module Lit where import System(getArgs) -- classification of the haskell source lines data Classified = Program String | Blank | Comment String deriving (Show) classify :: String -> Classified classify ('-':'-':xs) = Comment (dropWhile isSpace xs) classify s | all isSpace s = Blank | otherwise = Program s unclassify :: Classified -> String unclassify (Program s) = "> " ++ s unclassify (Comment s) = s unclassify Blank = [] process :: String -> String process hs = unlines (map unclassify (addblanks (clines hs))) clines hs = map classify (lines hs) -- inserts a blank between a program line and a comment line where needed addblanks :: [Classified] -> [Classified] addblanks = pad needBlank Blank needBlank :: Classified -> Classified -> Bool needBlank (Program p) (Comment c) = True needBlank (Comment c) (Program p) = True needBlank _ _ = False -- inserts a value between those adjanced elements for which -- function p returns True pad :: (a -> a -> Bool) -> a -> [a] -> [a] pad p value [] = [] pad p value (x:[]) = [x] pad p value (x:xs) | p x (head xs) = x:value:rest | otherwise = x:rest where rest = pad p value xs usage err = err ++ "\n" ++ "USAGE: lit <filename>" main :: IO () main = do strs <- getArgs case strs of [] -> ioError (userError (usage "Not enough arguments.")) [str] -> mklit str _ -> ioError (userError (usage "Too many arguments.")) -- takes a filename without suffix, reads a plain haskell source -- and creates a literate haskell source. mklit :: String -> IO () mklit f = do hs <- readFile (f ++ ".hs") writeFile (f ++ ".lhs") (process hs) -- Bst rgrds, M.A.X.: Mechanical Artificial Xenomorph.

2 2