- Haskell-Cafe - Haskell.org

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 22 Jun '07

22 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

RE: [Haskell-cafe] FFI and Excel VBA
by Lewis-Sandy, Darrell 21 Jun '07

21 Jun '07

Whoops - I posted the wrong version of the exports list. Compilation with that adder.def will fail (since it the Haskell code doesn't export either suber or hello). Below is the revised example: KEYWORDS: Foreign, Export, Win32, DLL, VBA, Excel, GCH, Example The contents of adder.hs are as follows: -------------------------------------------- module Adder(adder) where import Foreign adder :: Int -> Int -> IO Int adder x y = return (id$!(x+y)) foreign export stdcall adder :: Int -> Int -> IO Int -------------------------------------------- The contents of the dllMain.c file are below: -------------------------------------------- #include <windows.h> #include <Rts.h> extern void __stginit_Adder(void); static char* args[] = { "ghcDll", NULL }; BOOL STDCALL DllMain ( HANDLE hModule, DWORD reason, void* reserved ) { if (reason == DLL_PROCESS_ATTACH) { startupHaskell(1, args, __stginit_Adder); return TRUE; } if (reason == DLL_PROCESS_DETACH) { shutdownHaskell(); return TRUE; } return TRUE; } -------------------------------------------- Note that the GHC manual omits the space between the "void" and the __stgint_Adder(void) which causes a compile error. The second case (if (reason == DLL_PROCESS_DETACH) is essential for garbage collection, and shuts down the Haskell runtime when the DLL is unloaded. To execute the Haskell code, I created a VBA module in an Excel workbook with the following code snippet: -------------------------------------------- Private Declare Function adder Lib "adder.dll" _ (ByVal x As Integer, ByVal y As Integer) As Integer Private Sub test() Debug.Print adder(1, 2) End Sub -------------------------------------------- NOTE: If the dll is not ultimately placed in your environments' PATH, then you may have to modify the library name to include the actual path information (or else you will get an error indicating that the library can't be found). Example: ... adder Lib "c:\myDlls\adder\adder.dll" ... Finally, you need to explicitly define an exports file to keep the c compiler from mangling the names too badly. The contents of adder.def are as follows: -------------------------------------------- EXPORTS adder -------------------------------------------- With these preliminaries out of the way, you can compile this to a dll using the following sequence of commands: -------------------------------------------- ghc -c adder.hs -fglasgow-exts ghc -c dllMain.c ghc --mk-dll -optdll--def=adder.def -o adder.dll adder.o adder_stub.o dllMain.o -------------------------------------------- When this is all done, open the XLProject and press F5 to run, or simply type "=adder(1,2)" in any cell of the workbook. My apologies for any confusion caused by my earlier posting. -Darrell Lewis-Sandy _______________________________________________ Haskell-Cafe mailing list Haskell-Cafe(a)haskell.org http://www.haskell.org/mailman/listinfo/haskell-cafe

2 1