June 2007 - Haskell-Cafe

Re: Re[2]: [Haskell-cafe] IDE?
by Peter Verswyvelen 22 Jun '07

22 Jun '07

That's just my point. Although I have no practical experience with Haskell (besides writing a simple L-System using HOpenGL), from what I've read Haskell is indeed much better than typical OO languages... So it *deserves* an easy entry level IDE that will get many many more people started with it. Like Concurrent Clean has, although their IDE is also far from perfect (e.g. they don't have multi-level undo, sigh) Anyway, it seems many people use Emacs for their Haskell edit/compile/run cycle. I've used Emacs on IBM OS/2 a long time ago so I guess I can get back into it. But man, was I happy back then when I could switch over to Visual Studio... The productivity I nowadays have with Visual Studio 2005 and Resharper for doing compilation, code-documentation-tips, code-completion, refactoring, navigation, debugging, boiler plate code generation, is amazing. Some of my colleagues still use Emacs, and maybe they are not using it correctly, but at first sight their development is much much slower. >From this cafe talk I now know such an IDE for Haskell does not exist. So I won't search any further for a great IDE before starting to do some real Haskell programming, because my L-Systems experiment was a lot of fun! So I just installed XEmacs with the latest Haskell mode. I'll go from here... If that doesn't work, Notepad++ and GHCI/GHC in a command prompt also works, although it does make me feel I'm back in the eighties. Thanks for all the help folks! >----- Oorspronkelijk bericht ----- >Van: Bulat Ziganshin [mailto:bulat.ziganshin@gmail.com] >Verzonden: zaterdag, juni 16, 2007 08:50 PM >Aan: bf3(a)telenet.be >CC: haskell-cafe(a)haskell.org >Onderwerp: Re[2]: [Haskell-cafe] IDE? > >Hello bf3, > >Saturday, June 16, 2007, 3:23:40 PM, you wrote: > >> The point I wanted to make is, that I can't find an >> easy-to-install-ready-to-use-and-rock-n-roll IDE for Windows that comes with >> all or most of those features. I mean something like Borland TurboPascal > >it's well-known trap. haskell is an order of magnitude better than >widespread OOP languages. why it's not used by everyone? just due to >shortage on libs, training and - yes - IDEs. "programming" in Delphi >in many cases need just clicking here and there > >so, you got something, you lost something > >ps: i use editor which supports only syntax highlighting. it's very >like working in tp 3.0 or quickc 1.0 - are you had such experience? :) > > > >-- >Best regards, > Bulat mailto:Bulat.Ziganshin@gmail.com > > >

26 69

Re: Type classes vs C++ overloading Re: [Haskell-cafe] Messing around with types [newbie]
by Cristiano Paris 22 Jun '07

22 Jun '07

I sent this message yesterday to Bulat but it was intended for the haskel cafe, so I'm resending it here today. Thank to everyone who answered me privately. Today I'll keep on experimenting and read the reference you gave me. Cristiano ---------- Forwarded message ---------- From: Cristiano Paris <cristiano.paris.ml(a)gmail.com> Date: Jun 21, 2007 6:20 PM Subject: Re: Type classes vs C++ overloading Re: [Haskell-cafe] Messing around with types [newbie] To: Bulat Ziganshin <Bulat.Ziganshin(a)gmail.com> On 6/21/07, Bulat Ziganshin <bulat.ziganshin(a)gmail.com> wrote: > > Hello Cristiano, > > Thursday, June 21, 2007, 4:46:27 PM, you wrote: > > > class FooOp a b where > > foo :: a -> b -> IO () > > > > instance FooOp Int Double where > > foo x y = putStrLn $ (show x) ++ " Double " ++ (show y) > > this is rather typical question :) I knew it was... :D unlike C++ which resolves any > overloading at COMPILE TIME, selecting among CURRENTLY available > overloaded definitions and complaining only when when this overloading > is ambiguous, type classes are the RUN-TIME overloading mechanism > > your definition of partialFoo compiled into code which may be used > with any instance of foo, not only defined in this module. so, it > cannot rely on that first argument of foo is always Int because you may > define other instance of FooOp in other module. "10" is really > constant function of type: > > 10 :: (Num t) => t > > i.e. this function should receive dictionary of class Num in order to > return value of type t (this dictionary contains fromInteger::Integer->t > method which used to convert Integer representation of 10 into type > actually required at this place) > > this means that partialFoo should have a method to deduce type of 10 > in order to pass it into foo call. Let's consider its type: > > partialFoo :: (FooOp t y) => y -> IO () > > when partialFoo is called with *any* argument, there is no way to > deduce type of t from type of y which means that GHC has no way to > determine which type 10 in your example should have. for example, if > you will define > > instance FooOp Int32 Double where > > anywhere, then call partialFoo (5.0::Double) will become ambiguous > > shortly speaking, overloading resolved based on global class > properties, not on the few instances present in current module. OTOH, > you build POLYMORPHIC functions this way while C++ just selects > best-suited variant of overloaded function and hard-code its call > > further reading: > http://homepages.inf.ed.ac.uk/wadler/papers/class/class.ps.gz > http://haskell.org/haskellwiki/OOP_vs_type_classes > chapter 7 of GHC user's guide, "functional dependencies" Mmmmmhhhh... your point is hard to understand for me. In his message, I can understand Bryan Burgers' point better (thanks Bryan) and I think it's somewhat right even if I don't fully understand the type machinery occuring during ghc compilation (yet). Quoting Bryan: "*From this you can see that 10 is not necessarily an Int, and 5.0 is *not necessarily a Double. So the typechecker does not know, given just 10 and 5.0, which instance of 'foo' to use. But when you explicitly told the typechecker that 10 is an Int and 5.0 is a Double, then the type checker was able to choose which instance of 'foo' it should use." So, let's see if I've understood how ghc works: 1 - It sees 5.0, which belongs to the Fractional class, and so for 10 belonging to the Num class. 2 - It only does have a (FooOp x y) instance of foo where x = Int and y = Double but it can't tell whether 5.0 and 10.0 would fit in the Int and Double types (there's some some of uncertainty here). 3 - Thus, ghci complains. So far so good. Now consider the following snippet: module Main where foo :: Double -> Double foo = (+2.0) bar = foo 5.0 I specified intentionally the type signature of foo. Using the same argument as above, ghci should get stuck in evaluating foo 5.0 as it may not be a Double, but only a Fractional. Surprisingly (at least to me) it works! So, it seems as if the type of 5.0 was induced by the type system to be Double as foo accepts only Double's. If I understand well, there's some sort of asymmetry when typechecking a function application (the case of foo 5.0), where the type signature of a function is dominant, and where typechecking an overloaded function application (the original case) since there type inference can't take place as someone could add a new overloading later as Bulat says. So, I tried to fix my code and I came up with this (partial) solution: module Main where class FooOp a b where foo :: a -> b -> IO () instance (Num t) => FooOp t Double where foo x y = putStrLn $ (show x) ++ " Double " ++ (show y) partialFoo :: Double -> IO () partialFoo = foo 10 bar = partialFoo 5.0 As you can see, I specified that partialFoo does accept Double so the type of 5.0 if induced to be Double by that type signature and the ambiguity disappear (along with relaxing the type of a to be simply a member of the Num class so 10 can fit in anyway). Problems arise if I add another instance of FooOp where b is Int (i.e. FooOp Int Int): module Main where class FooOp a b where foo :: a -> b -> IO () instance (Num t) => FooOp t Double where foo x y = putStrLn $ (show x) ++ " Double " ++ (show y) instance (Num t) => FooOp t Int where foo x y = putStrLn $ (show x) ++ " Int " ++ (show y) partialFoo = foo 10 bar = partialFoo (5.0::Double) while I thought could be solved likewise: module Main where class FooOp a b where foo :: a -> b -> IO () instance (Num t1, Fractional t2) => FooOp t1 t2 where foo x y = putStrLn $ (show x) ++ " Double " ++ (show y) instance (Num t1, Num t2) => FooOp t1 t2 where foo x y = putStrLn $ (show x) ++ " Int " ++ (show y) partialFoo = foo 10 bar = partialFoo 5.0 but it didn't work. Here's ghci's complaint: example.hs:7:0: Duplicate instance declarations: instance (Num t1, Fractional t2) => FooOp t1 t2 -- Defined at example.hs:7:0 instance (Num t1, Num t2) => FooOp t1 t2 -- Defined at example.hs:10:0 Failed, modules loaded: none. It seems that Num and Fractional are somewhat related. Any hint? Were my reasonings correct or was it only crap? Thanks, Cristiano

2 2

Filesystem access
by Andrew Coppin 22 Jun '07

22 Jun '07

OK, a few questions... 1. Is there *any* way to determine how large a file is *without* opening it? The only library function I can find to do with file sizes is hFileSize; obviously this only works for files that you have permission to open! 2. Is there any way to discover Windoze-style "attributes" for files? (Read-only, archive, system, hidden, et al.)

5 6

Collections
by Andrew Coppin 22 Jun '07

22 Jun '07

When I was at university, we learned a programming language known as Smalltalk. I was rather good at it. [Ironically, making "small talk" is one of the things I do worst IRL! But anyway, back to the topic...] In Smalltalk, there is a wide selection of collection types, all with different facilities and efficiency trade offs. There is bag, set, list, array, ordered list, dictionary, hash table, weak array, etc. A whole menagerie of collection types. However, Haskell only has 1 type of collection: linked lists. (And only single-linked at that.) While other "normal" programming languages spend huge amounts of effort trying to select exactly the right collection type for the task in hand, Haskell programs only ever use linked lists. Why is that, exactly? Does writing software in Haskell magically change the properties of these data structures such that lists become more efficient than all the other types? Or is it that other data structures are only efficient when used with in-place updates? (The latter statement appears to be isomorphic to stating that Haskell programs must necessarily be less efficient than impure ones.) Thoughts?

25 55

WMI via Haskell?
by Dean Herington 22 Jun '07

22 Jun '07

Has anyone built a library providing an interface to WMI (Windows Management Instrumentation) in Haskell?

1 0

Parsec question
by Levi Stephen 22 Jun '07

22 Jun '07

Hi, Fairly new to Haskell and trying some parsec. (Also, new to parsers/interpreters) I had come up with this, which works, but I can't help thinking there's a better way :) |> newtype Identifier = Identifier String > newtype Literal = StringLiteral String -- to be extended later > data Primary = PrimaryLiteral Literal | PrimaryIdentifier Identifier > ||> primary = do { > i <- identifier; > return $ PrimaryIdentifier i; } > <|> do { > l <- stringLiteral; > return $ PrimaryLiteral l; } > ||> identifier = do > i <- many1 letter > return $ Identifier i > > stringLiteral = do > (char '\'') > s <- manyTill anyChar (char '\'') > return $ StringLiteral s Is there a way through combining types/parsers that the double do block in primary could be avoided? I understand it's necessary right now because the parsers identifier and stringLiteral return different types, so I can't just write: > i <- identifier <|> stringLiteral So, I'm not sure whether my types need work, the parsers, or if this is the simplest way. Thanks, Levi lstephen.wordpress.com PS, have lurked on the list for a while, enjoy the discussions and content. |

6 8

Template Haskell, information about data constructor types
by Neil Mitchell 21 Jun '07

21 Jun '07

Hi I'm trying to write a function: reaches :: Type -> Q [Type] The intention is that reaches (Either Bool [Int]) would return [Either Bool [Int], Bool, [Int], Int] - i.e. all types which are contained by the initial type at any level. I took a shot at this: getTypes :: Type -> Q [Type] getTypes t = do let (ConT c, cs) = typeApp t TyConI dat <- reify c return $ concatMap ctorTypes $ dataCtors dat reaches :: Type -> Q [Type] reaches t = f [] [t] where f done [] = return done f done (t:odo) | t `elem` done = f done odo | otherwise = do ts <- getTypes t f (t:done) (odo ++ ts) Where typeApp splits a type to find its constructor, ctorTypes gets the types of the fields, and dataCtors gets the constructors in a data type. Unfortunately reify doesn't seem to work on types. Is it possible to do what I am after? Thanks Neil

3 4

memory usage in repeated reading of an external program's output
by Andrea Rossato 21 Jun '07

21 Jun '07

Hello, I have this very simple program that executes an external program, reads its output and prints it (the program is "date"). The readings is done with pipes. The problem is that memory usage constantly increases over time. Profiling does not show garbage collection of any sort. File descriptors and handles seem to be properly closed. Still I cannot find out where the problem lays. Can it be related to the fact that runProcess closes the handles so that the write file descriptor of the pipe is left open? using a "closeFd w" after runProcess gives a Bad fd error. Moreover, fdToHandle "converts" the fd into a handle, so I presume that closing the second should be enough. And indeed removing or inserting rc <- handleToFd rh and closeFd rc doesn't change anything. Thanks for your help. Andrea The code: ---------------- module Main where import System.Process import System.Posix.IO import System.IO import Control.Concurrent runComLoop :: String -> IO () runComLoop command = do (r,w) <- createPipe wh <- fdToHandle w hSetBuffering wh LineBuffering p <- runProcess command [] Nothing Nothing Nothing (Just wh) (Just wh) rh <- fdToHandle r str <- hGetLine rh rc <- handleToFd rh hClose rh closeFd rc -- get and print the status of handles swh <- hShow wh srh <- hShow rh putStrLn $ show swh putStrLn $ show srh putStrLn str threadDelay $ 100000 * 1 runComLoop command main = runComLoop "date"

4 7

lazy patterns versus where-clauses
by Peter Padawitz 21 Jun '07

21 Jun '07

Is f(~p(x))=e(x) semantically equivalent to: f(z)=e(x) where p(x)=z?

3 3

Messing around with types [newbie]
by Cristiano Paris 21 Jun '07

21 Jun '07

Hi, I'm making my way through Haskell which seems to me one of the languages with steepest learning curve around. Now, please consider this snippet: {-# OPTIONS_GHC -fglasgow-exts #-} module Main where class FooOp a b where foo :: a -> b -> IO () instance FooOp Int Double where foo x y = putStrLn $ (show x) ++ " Double " ++ (show y) partialFoo = foo (10::Int) bar = partialFoo (5.0::Double) I hope the indentation looks ok in your email client. I'm experimenting with currying and typeclasses at the moment. If I try to import this in ghci, it works flawlessy. Now, if I remove the type signature from 10 and 5.0, ghci complaints saying: example.hs:12:6: Ambiguous type variable `t' in the constraint: `Num t' arising from use of `partialFoo' at example.hs:12:6-19 Probable fix: add a type signature that fixes these type variable(s) example.hs:12:6: Ambiguous type variables `t', `t1' in the constraint: `FooOp t t1' arising from use of `partialFoo' at example.hs:12:6-19 Probable fix: add a type signature that fixes these type variable(s) example.hs:12:17: Ambiguous type variable `t1' in the constraint: `Fractional t1' arising from the literal `5.0' at example.hs:12:17-19 Probable fix: add a type signature that fixes these type variable(s) I switched off the monomorphism restriction (btw, is this bad? No flame war please :D) otherwise it'd have complained louder. Can you explain how to fix the code (if possible) and give some explanation? Thanks, Cristiano

5 5