October 2009 - Haskell-Cafe

Fast times at Inferable-but-not-Checkable High.
by Joe Fredette 07 Oct '09

07 Oct '09

So, I've been fiddling with an utterly random idea. What if I had a class: class Hom a b where data Rep a b hm :: Rep a b -> b im :: a -> Rep a b That is, all types that have some conversion between them (an isomorphism originally, then I thought homomorphism, now I'm not sure what the hell I'm talking about, so I've just stuck with Hom...) which preserves some sense of "structure" and "content", for instance data CouldBe a = Only a | Nada is _obviously_ the same type as `Maybe`. However, it can't be used transparently where `Maybe` can be used. That is, shouldn't I be able to define a 1-1, onto function `phi :: CouldBe a -> Maybe a` and as such another `pho :: Maybe a -> CouldBe a` such that phi . pho = pho . phi = phum ... errr. `id`? Hom a b represents one end of that (specifically `hm . im = phi`, and `hm . im` for the instance `Hom b a` would `pho`), then I could, instead of writing a type which expects maybe, simply expects anything _equivalent_ to a maybe, eg safeHead :: Hom (Maybe a) b => [c] -> Rep a (Maybe c) safeHead [] = im Nothing safeHead (x:_) = im (Just x) Though- I think this is a little bit off in terms of how it should work, perhaps this is my problem, but the idea is that instead of returning a Maybe, it returns something which can be converted _from_ a maybe. That is, a "generic" type like: data X1 a = X a | Y which is the "form" of any "maybe-like" type. In one sense, I'm almost trying to be polymorphic over the constructors of a given type, kindof, sortof, if you squint your eyes just right and try not to think too much. My problem comes when I try to do this: hom = hm . im eq x y = hom x == hom y Which, I reason, ought to satisfy the type: eq :: (Hom a b, Eq b) => a -> a -> Bool this assumes that hom defines a equality-preserving conversion. However, the type it infers is: eq :: (Hom a b, Hom a1 b, Eq b) => a -> a1 -> Bool Now, this makes sense, all my signature is is a special case of this type. Interesting consequence, this eq could compare a `Maybe a` and `CouldBe a` in a sensical way. Which is a nice benefit. However, here's where it gets weird, If I try to _provide_ this signature (the second, more general one, or the first, specific one, it doesn't matter), GHC gives me the following error: Iso.hs:29:10: Could not deduce (Hom a b) from the context (Hom a b1, Eq b1) arising from a use of `hom' at Iso.hs:29:10-14 Possible fix: add (Hom a b) to the context of the type signature for `eq' In the first argument of `(==)', namely `(hom x)' In the expression: (hom x) == (hom y) In the definition of `eq': eq x y = (hom x) == (hom y) Failed, modules loaded: none. for the latter and a similar one (but for each of the `Hom a b`, `Hom a1 b` cases. Punchline is this, I'm trying to write a generic equality that works for any two types with the same constructor-structure, when I try to write said function, GHC can infer but not Check (it seems, I'm not sure if that's the correct lingo) the type... My question is twofold. 1. Is this whole idea even possible? I mean- is there some limitation I'm going to run into, I have run into problems when trying to do: instance (Hom a b, Eq b) => Eq a where blah wrt UndecideableInstances. But it seems so _obvious_ what that means, I don't think I fully understand what's going on -- that is, whether I'm misunderstanding how class contexts work here, and why this (seemingly obvious) signature is undecidable, or whether I'm just mistaken in my type signature all together. (My goal is to say that anything which can be converted freely to and from something that is an instance of the Eq class, must preserve the equality relationships. 2. Why is GHC unable to check the types, but infer them. I always understood inferring to be the "hard" part of the problem, and checking to be the "easy" part. Is my intuition wrong? I've posted the code here[1] for your perusal. It's not particularly important that I get this solved, it's just a random idea I wanted to explore and thought the notion might appeal to some other Haskeller's around there who like to have self-documenting datatypes, but hate having to rewrite lots of simple utility functions as penance for our documentarian sins. /Joe

2 1

Fast times as Inferable-but-not-Checkable High -- Link to Source
by Joe Fredette 07 Oct '09

07 Oct '09

Sorry, I forgot to actually include the link to the source: http://lowlymath.net/Iso.hs /Joe

1 0

Fwd: [Haskell-cafe] Num instances for 2-dimensional types
by Alberto G. Corona 07 Oct '09

07 Oct '09

Why? real numbers, complex nuimbers, n-dimensional spaces have well defined + and * operations (vectorial product in the latter case). even algebraic expressions like: data Expr = Var String | Number Integer | Sin Expr | Cos Expr can be instances of Num and express certain simplification rules in the definition. instance Num Expr where ... (Sin x) * (Cos x) = (Sin (2 * x))/2 ... I started to develop a extensible symbolic math manipulation around the idea of using symbolic expressions as instances of Num and other basic classes. But I leaved it out due to lack of time. By the way I attach it just in case anyone want to get some idea from it: module DynAlgebra where data Dyn= forall a.(Num a, Eq a, Show a, Ord a, Read a, Simplify a)=> Dyn a instance Show Dyn where show (Dyn a)= show a instance Eq Dyn where (Dyn a) == (Dyn b)= solve a== solve b class Simplify a where simplify :: a -> a solve :: a -> Polonomial Expr1 data Polonomial e = e :/ e | e :+ e | e :* e deriving Show data Expr1= Var String | I Integer | Pi | E deriving Show -- Integer :/ Integer for exact rational arithmetic data Expr= Polinomial Expr | Formula Dyn deriving (Show, Eq) instance Num (Polonomial Expr1) where fromInteger = I (+) (I a) (I b)= I (a+b) (+) e1 e2 = e1 :+ e2 (*) (I a) (I b)= I (a*b) (*) e1 e2 = (:*) e1 e2 abs (I x) | x>=0 = I x | otherwise = I (-x) signum (I x) | x >= 0 = 1 | otherwise= -1 instance Ord Polonomial where compare (I a) (I b)= compare a b compare ( x :+ z) y | x < y && z >0 = LT | x > y && z >0 = GT compare y ( x :+ z) | y > x && z >0 = LT | y > x && z >0 = GT instance Eq Polonomial where (I a) == (I b) = a == b (I a :+ I b)== ( I c :+ I d)= a + b== c + d (I a :* I b)== ( I c :* I d)= a * b== c * d (a :+ b)== (c :+ d)= a==c && b == d (a :* b)== (c :* d)= a== c && b == d (a :/ b)== (c :/ d)= a * d == b * c exp1 == exp2 = simplify exp1== simplify exp2 instance Simplify (Polonomial Expr1) where solve x = simplify x simplify ( (I x) :/ (I y))= case quotRem x y of (q,0) -> I q (q,r) -> let m= mcd y r in (I(x `div` m)) :/ (I(y `div` m)) simplify ((I a) :+ (I b))= I (a + b) simplify ((I a) :* (I b))= I (a * b) simplify ((a :* b) :+ (c :* d)) | a == c = simplify $ a * (b :+d) simplify (exp1 :+ exp2) = simplify exp1 :+ simplify exp2 simplify (exp1 :* exp2) = simplify exp1 :* simplify exp2 simplify expr= expr mcd x y= case mod x y of 0 -> y t -> mcd y t subst:: Polonomial -> [(String, Polonomial )] -> Polonomial subst exp l= subs1 exp where subs1 (Var v)= case lookup v l of Nothing -> Var v Just e -> e subs1 (e1 :+ e2) = ((subs1 e1) :+ (subs1 e2)) subs1 (e1 :* e2) = ((subs1 e1) :* (subs1 e2)) subs1 (e1 :/ e2) = ((subs1 e1) :/ (subs1 e2)) subst e= e f x= x :* x main= print $ solve $ 2 :+1 2009/10/5 Miguel Mitrofanov <miguelimo38(a)yandex.ru> > > Sönke Hahn wrote: > > I used to implement >> >> fromInteger n = (r, r) where r = fromInteger n >> >> , but thinking about it, >> fromInteger n = (fromInteger n, 0) >> >> seems very reasonable, too. >> > > Stop pretending something is a number when it's not. > > _______________________________________________ > Haskell-Cafe mailing list > Haskell-Cafe(a)haskell.org > http://www.haskell.org/mailman/listinfo/haskell-cafe >

1 0

Cabal - how do I remove a package?
by Paul Moore 06 Oct '09

06 Oct '09

As it says in the subject, how do I remove a package that I installed (with the --user flag) via cabal? Come to that, how do I list the packages I've installed via cabal? cabal list --installed includes all the GHC standard library (which I didn't install) and it doesn't seem to support a --user flag to list per-user installed packages. FWIW, I'm on Windows 7. Thanks, Paul.

3 6

ANNOUNCE: Graphalyze-0.8.0.0 and SourceGraph-0.5.5.0
by Ivan Lazar Miljenovic 06 Oct '09

06 Oct '09

To keep Joe Fredette happy [1] this time, I've combined these two announcements into one. [1] http://sequence.complete.org/hwn/20091003 I'm pleased to announce the latest versions of Graphalyze [2] and SourceGraph [3]. The only change to Graphalyze has been the addition of Legend support (which necessitated a slight change in the data structures used, hence the large version bump) but SourceGraph contains more substantial changes. [2] http://hackage.haskell.org/package/Graphalyze-0.8.0.0 [3] http://hackage.haskell.org/package/SourceGraph-0.5.5.0 Changes to SourceGraph include: * A legend so that you know what all the fancy symbols, etc. actually mean. * Class instances now drawn correctly. * Better colour support. * Clean up printing of cliques, etc. I've also put some sample SourceGraph reports online at http://code.haskell.org/~ivanm/Sample_SourceGraph/SampleReports.html so that you can see what kind of results it produces. Enjoy! -- Ivan Lazar Miljenovic Ivan.Miljenovic(a)gmail.com IvanMiljenovic.wordpress.com

2 1

Haskell Platform - changing the global install dir
by Paul Moore 06 Oct '09

06 Oct '09

I've installed the Haskell Platform to a non-default location (D:\Apps\Haskell) to avoid some of the Win7 funniness over writing to C:\Program Files. However, even though I've done this, the cabal global install directory is still C:\Program Files\haskell. This has been added to my PATH and is used by default. Is there a way I could have specified that I want the global install directory in D:\Apps\Haskell? I guess I could hack my cabal\config file (and presumably change PATH) but that seems a bit ugly. Is the use of Program Files even when the install was to somewhere else a bug? It's not a big deal - I can easily stick to user installs for now. Thanks, Paul.

3 7

I/O Haskell question
by Maria Boghiu 06 Oct '09

06 Oct '09

Hey. I'm trying to configure Xmonad, the window manager. for this purpose, I'm trying to read the *workspaces* variable in the code below from file. As you can see, I do workspaces = readWS where * readWS = do l <- readFile "~/bla" return l* I get an error saying I am mismatching types IO [String] and [String]. But I thought that once one does * l <- readFile "~/bla"*, l is the a string or, in this case, a String list. If I run that line in prelude it seems to be working fine, prints the content of the file "~/bla" on screen (though I'm not sure if as a String or as a list of Strings, i.e. [String]) Can anyone help please? I've been struggling with this for days... 94 main = do 95 xmonad 96 $ defaultConfig { 97 manageHook = manageDocks <+> myManageHook <+> manageHook defaultConfig, 98 layoutHook = avoidStruts $ layoutHook defaultConfig, 99 logHook = dynamicLogWithPP $ conkyPP "", 100 terminal = "gnome-terminal", 101 keys = myKeys, 102 workspaces = readWS, 103 mouseBindings = myMouseBindings, 104 focusedBorderColor = "#008E00", 105 borderWidth = 3 106 --modMask = mod1Mask, --This is to rebind mod key 107 } `additionalKeys`

6 5

Curried function terminology
by michael rice 06 Oct '09

06 Oct '09

This is from Learn You A Haskell: ========== "Curried functions Every function in Haskell officially only takes one parameter. So how is it possible that we defined and used several functions that take more than one parameter so far? Well, it's a clever trick! All the functions that accepted several parameters so far have been curried functions. What does that mean? You'll understand it best on an example. Let's take our good friend, the max function. It looks like it takes two parameters and returns the one that's bigger. Doing max 4 5 first creates a function that takes a parameter and returns either 4 or that parameter, depending on which is bigger. Then, 5 IS APPLIED TO THAT FUNCTION and that function produces our desired result. What really happens when we do multThree 3 5 9 or ((multThree 3) 5) 9? First, 3 is applied to multThree, because they're separated by a space. That creates a function that takes one parameter and returns a function. So then 5 IS APPLIED TO THAT, which creates a function that will take a parameter and multiply it by 15. 9 IS APPLIED TO THAT FUNCTION and the result is 135 or something." ======= The language (in CAPS) in the above two paragraphs seems to be backwards. In the first paragraph, since functions are conventionally "applied" to parameters shouldn't it read something like THE PARTIALLY APPLIED FUNCTION IS THEN APPLIED TO the 5? Or is the terminology different for Haskell, as opposed to say, Scheme or just about any other language? Michael

4 5

Mutable data within a (non-IO) monad
by Gregory Crosswhite 05 Oct '09

05 Oct '09

Hey everyone, I am thinking about creating a particular data structure with an immutable and mutable version. The key of my problem is that I would like the user to be able to work with a mutable version of the data within a non-IO monad and then get an immutable value at the end, allowing them to do stateful-like computation in pure code. The key is that I need to enforce the ordering within the monad, but I can't do this using a state-transformer since the state doesn't actually change; instead, the data structure is internally modified, but the original pointer is kept to it. There are many data structures which already have this kind of functionality, such as STRefs and MArrays, however I am having trouble distilling from the source code what the best "trick" is to accomplish mutability of this form within a monad. There seem to be at least a couple of strategies: using "type-threading" with GHC's State# type, and using the ST monad with a rank-2 qualifier over the type of the state. Do you all have any thoughts on ways to solve this problem, and/or a high-level explanation of what is going behind the scenes with STRefs and MArrays? Thanks! - Greg

4 4

dsl and gui toolkit
by Andrew U. Frank 05 Oct '09

05 Oct '09

writing a gui is a mess (independent of wx or gtk) - too much detail is shown and not enough abstraction is done. haskell can help. i have written an experimental way of producing the GUI automatically with a description of the semantics of the types and operations involved (a la ontology, evnetually comparable what protege produces). the input is a descriptionof the entity ypes, the fields used, the functional dependencies between the fiels, plus the operations used. the division in screens and their layout. the rest ist automatic. the result is a GUI (with preferably gtk but i had also a wx version running). the ideas were inspired by eliot conal's work and wxgeneric, which seemed for administrative applications either too restricted or to specific. if somebody wants to try it out for his application, please write frank(a)geoinfo.tuwien.ac.at (there is not much documentation and the code is not yet completely clean - testing by somebody else would be very valuable!) andrew

6 5