- Haskell-Cafe - Haskell.org

Type errors, would extensions help?
by Mauricio 16 Jan '09

16 Jan '09

Hi, I have this problem trying to define a function inside a do expression. I tried this small code to help me check. This works well: --- import Data.Ratio ; main = do { printNumber <- let { print :: (Num n,Show n) => n -> IO () ; print n = do { putStrLn $ show n} } in return print ; print (1%5) ; print 5.0 } --- However, just removing 'Num n' gives: Ambiguous type variable `n' in the constraint: `Show n' arising from a use of `print' at teste.hs:7:16-20 Why is it ambiguous? Since I don't use numeric functions, 'Num n,Show n' doesn't seem more specific. Besides that, the real problem I have is a similar function declared inside a 'let' as col :: (WidgetClass w) => w->IO Int col wid = do {... that, after beeing used with w beeing Table (and instance WidgetClass Table do exist) refuses beeing used with DrawingArea (also with instance WidgetClass DrawingArea), but I wasn't able to simulate that in a small program, and don't know if it's related to the case I'm showing. Thanks for your kindness, Maurício

4 7

How to simplify this code?
by Levi Greenspan 16 Jan '09

16 Jan '09

Dear list members, I started looking into monadic programming in Haskell and I have some difficulties to come up with code that is concise, easy to read and easy on the eyes. In particular I would like to have a function "add" with following type signature: JSON a => MyData -> String -> a -> MyData. MyData holds a JSValue and add should add a key and a value to this JSON object. here is what I came up with and I am far from satisfied. Maybe someone can help me to simplify this... module Test where import Text.JSON import Data.Maybe (isJust, fromJust) import Control.Monad data MyData = MyData { json :: JSValue } deriving (Read, Show) jsObj :: JSValue -> Maybe (JSObject JSValue) jsObj (JSObject o) = Just o jsObj _ = Nothing add :: JSON a => MyData -> String -> a -> MyData add m k v = fromJust $ (return $ json m) >>= jsObj >>= (return . fromJSObject) >>= (return . ((k, showJSON v):)) >>= (return . toJSObject) >>= (return . showJSON) >>= \js -> (return $ m { json = js }) add2 :: JSON a => MyData -> String -> a -> MyData add2 m k v = fromJust $ (\js -> m { json = js }) `liftM` (showJSON `liftM` (toJSObject `liftM` (((k, showJSON v):) `liftM` (fromJSObject `liftM` (jsObj $ json m))))) add3 :: JSON a => MyData -> String -> a -> MyData add3 = undefined -- How to simplify add? What the code essentially does is that using functions from Text.JSON, it gets the list of key-value pairs and conses another pair to it before wrapping it again in the JSValue-Type. Many thanks, Levi

4 5

Type Family Relations
by Thomas DuBuisson 16 Jan '09

16 Jan '09

Cafe, I am wondering if there is a way to enforce compile time checking of an axiom relating two separate type families. Mandatory contrived example: > type family AddressOf h > type family HeaderOf a > > -- I'm looking for something to the effect of: > type axiom HeaderOf (AddressOf x) ~ x > > -- Valid: > type instance AddressOf IPv4Header = IPv4 > type instance HeaderOf IPv4 = IPv4Header > > -- Invalid > type instance AddressOf AppHeader = AppAddress > type instance HeaderOf AppAddress = [AppHeader] So this is a universally enforced type equivalence. The stipulation could be arbitrarily complex, checked at compile time, and must hold for all instances of either type family. Am I making this too hard? Is there already a solution I'm missing? Cheers, Tom

7 8

Monads aren't evil
by Ertugrul Soeylemez 16 Jan '09

16 Jan '09

Hello fellow Haskellers, When I read questions from Haskell beginners, it somehow seems like they try to avoid monads and view them as a last resort, if there is no easy non-monadic way. I'm really sure that the cause for this is that most tutorials deal with monads very sparingly and mostly in the context of input/output. Also usually monads are associated with the do-notation, which makes them appear even more special, although there is really nothing special about them. I appeal to all experienced Haskell programmers, especially to tutorial writers, to try to focus more on how monads are nothing special, when talking to beginners. Let me tell you that usually 90% of my code is monadic and there is really nothing wrong with that. I use especially State monads and StateT transformers very often, because they are convenient and are just a clean combinator frontend to what you would do manually without them: passing state. Greets, Ertugrul. -- nightmare = unsafePerformIO (getWrongWife >>= sex) http://blog.ertes.de/

22 36

GHCi debugger question
by Galchin, Vasili 16 Jan '09

16 Jan '09

Hello, I have a collection of functions .. but no "main" function. I am reading "Step Inside the GHCi debugger" from Monad.Reader Issue 10 by Bernie Pope. If I don't have a "main" function can I still use the ghci debugger? (I tried to set a breakpoint on one of my functions but it didn't work). Regards, Vasili

2 1

version information in the documentation
by Manlio Perillo 15 Jan '09

15 Jan '09

Hi. I'm reading the GHC documentation, in detail: http://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html I have noted that there is no indication about the GHC version where an extension has been first implemented. The same with the documentation from the libraries. I think that this is an important information, and should be added. Thanks Manlio Perillo

1 0

about System.Posix.Files.fileAccess
by Manlio Perillo 15 Jan '09

15 Jan '09

Hi. This is of course a personal opinion, but I think the interface of: fileAccess :: FilePath -> Bool -> Bool -> Bool -> IO Bool http://haskell.org/ghc/docs/latest/html/libraries/unix/System-Posix-Files.h… is not very good. Is it possible to design (in theory) a better interface? Thanks Manlio Perillo

3 4

ANN: monad-interleave 0.1
by Patrick Perry 15 Jan '09

15 Jan '09

My two favorite functions in Haskell are "unsafeInterleaveIO" and "unsafeInterleaveST". I'm surprised there isn't a type class for them. I just fixed this by adding the "monad-interleave" package to hackage: http://hackage.haskell.org/cgi-bin/hackage-scripts/package/monad-interleave The package adds a "Control.Monad.Interleave" module. Here is the entirety of the module: \begin{code} -- | Monads that have an operation like 'unsafeInterleaveIO'. class Monad m => MonadInterleave m where -- | Get the baton from the monad without doing any computation. unsafeInterleave :: m a -> m a instance MonadInterleave IO where unsafeInterleave = unsafeInterleaveIO {-# INLINE unsafeInterleave #-} instance MonadInterleave (ST s) where unsafeInterleave = unsafeInterleaveST {-# INLINE unsafeInterleave #-} instance MonadInterleave (Lazy.ST s) where unsafeInterleave = Lazy.unsafeInterleaveST {-# INLINE unsafeInterleave #-} \end{code} Use it if you need it. Patrick

1 0

Re: [Haskell-cafe] Haskell not ready for Foo [was: Re: Hypothetical Haskell job in New York]
by Robert Greayer 15 Jan '09

15 Jan '09

----- Original Message ---- From: John A. De Goes <john(a)n-brain.net> On Jan 15, 2009, at 9:31 AM, John Goerzen wrote: >> AFAIK, the only language where that sort of wheel reinvention is >> popular is Java. But then Java seems to encourage wheel reinvention >> anyhow ;-) > The Java reinventions look and feel like Java, because they're native implementations. > This is even more important in Haskell where the differences between > Haskell and C is about as large as you can get. The Java reinventions largely exist because of the huge deployment-time benefits you get from pure-Java code (cross-platform portability of compiled (byte) code, dynamic loading of compiled code over a network, etc.). Such reinventions are much less important for Haskell, since the typical deployment model for a Haskell program is much closer to that of a C program than a Java program or even a Python program.

4 3

software correctness ... can we in FPL step up to the plate??
by Galchin, Vasili 15 Jan '09

15 Jan '09

http://www.businessweek.com/the_thread/techbeat/archives/2009/01/nsa_dhs_in… ... I think that http://www.galois.com is already doing as stated in the article/ ...... I sincerely think there is a segway for Haskell here with strong and static type checking.. ?? Vasili

2 1