- Haskell-Cafe - Haskell.org

RE: [Haskell-cafe] Making MVar and Chan Instances of Typeable
by Simon Peyton-Jones 08 Nov '04

08 Nov '04

| instance Typeable a => Typeable (MVar a) where | typeOf x = | mkAppTy (mkTyCon "Control.Concurrent.MVar.MVar") [typeOf (undefined::a)] As I think you now know, the above declaration is fine if you use -fglasgow-exts. Haskell 98 does not support lexically scoped type variables, but GHC -fglasgow-exts does. You can read about it in the GHC user manual. Type variables are bound by instance declarations, as above, but you can also bind them in patterns. So as others have said an alternative is | instance Typeable a => Typeable (MVar a) where | typeOf (x::MVar b) = | mkAppTy (mkTyCon "Control.Concurrent.MVar.MVar") [typeOf (undefined::b)] But that's not legal in Haskell 98 either, and since 'a' is already in scope with -fglasgow-exts, the extra binding for 'b' seems less nice. The best Haskell 98 solution is the one Remi gives: instance Typeable a => Typeable (MVar a) where typeOf v = mkAppTy (mkTyCon "Control.Concurrent.MVar.MVar") [typeOf (t v)] where t :: a b -> b t = undefined Simon

1 0

Lnear algebra library for game programming.
by Serguey Zefirov 08 Nov '04

08 Nov '04

Right now I explore the possibilities of building the prototype for game physics library in Haskell. This is a purely hobby approach to gain more knowledge on Haskell and library design in general. One of intermediate steps is to build linear algebra library for further utilisation. But, here I face some difficulties. In C++ I could define needed operators on per-type basis, and define universal operators for, say, Vec3 * Mat3x3, Vec3 * Mat3x4, etc. In Haskell I should define different operators, something like `v3mulm3x3`, `v3mulm3x4`. This is somewhat inconvenient, given that I expect to utilize Vec2,3,4 and Mat(3,4)x(3,4) parametrized by Double and Float. So the question is: what other people do in situation like this and is there any paper(s) on linear algebra library design? -- Yours truly, Serguey Zefirov, theszATmail.ru.

4 4

Re: [Haskell-cafe] (Re arrows and Haskell) ...
by Andy Elvey 08 Nov '04

08 Nov '04

On Saturday 06 November 2004 08:36 am, you wrote: < snip > > > It might be an immense project, but I also think it would be interesting. > I wonder if Haskell would be much faster after being restructured around > arrows. > If an arrow-based version of Haskell existed, I'd love to try it. > > I think it's entirely possible that it would have significant benefits in > speed, elegance, and structural simplicity. > -- > Shae Matijs Erisson - Programmer Hi Shae! Thanks for your comments, and i agree totally! It would indeed be very interesting, and I tend to agree too that speed might be helped if this were done. ( and yes - I'd love to try an arrow-based Haskell too! ). While I was mulling this over this morning, I was thinking how (or even "if" ) an EBNF grammar (Haskell's in this case) could be represented in terms or arrows. I stopped pretty quickly as it made my head hurt just thinking about it ... :-)) - Andy

3 3

(Re arrows and Haskell) ...
by Andy Elvey 07 Nov '04

07 Nov '04

Hi again - Apologies for another post from me so soon (and for replying to my own post). Regarding my post about arrows and Haskell (and the idea of trying to define Haskell's grammar in terms of arrows) - upon thinking about that, I'm pretty much of the opinion that it'd be an immense task ... I also think that although maybe some of the grammar might be possible to define using arrows, it wouldn't be possible to do all of it :-) . So, I'll politely "withdraw to a corner" for a little while, resolving to think a bit more before I post! ;-) - Andy

1 0

Defining Haskell using "arrows"
by Andy Elvey 07 Nov '04

07 Nov '04

Hi all - I'm a first-timer here, and am *very* much attracted by Haskell's elegance and power ... :-) I have only poked around briefly with Haskell so far (at the "hello world" level). One thing that I have come across, and which really got me thinking, was the page on the Haskell website about "arrows". They really seem to take elegance and the "generic-ness" of algorithms to a new level. I was thinking - arrows are a relatively recent concept. Haskell's grammar (as defined in the Haskell report) has now been around for quite some time. So - I thought "what if?" What if Haskell were to be defined (er, *re*-defined) in terms of arrows? In other words, what if it were possible to start totally "from scratch", re-defining Haskell's grammar using arrows? (and preferably, *only* arrows ... ). This would presumably involve somehow coding up the arrows first, and then (haivng got them), using them to create/define the rest of the language. My reason for suggesting this - simply to see if it were possible to do a very small (but still quite comprehensive) Haskell implementation. Small meaning maybe 2-3 MB or so ... As an interesting "benchmark" of this, the Rebol language (though proprietary - sigh!) - comes in at 0.5 Mb or so, including a GUI. So, "very small but very powerful" is possible (although undoubtedly pretty difficult ... ) As a Haskell newbie, I have to defer to everyone else on this list (in terms of my Haskell ability), but just thought I'd post this idea anyway. I was thinking " I wonder if anyone has thought of this? ....... " . Arrows seem to be a recent "add-on", as it were, so I thought -given their power and flexibility, why not turn things totally around, and put them at the *very core* of the language, using them to define the language itself. Anyway, I'm keen to hear people's thoughts on this! Very many thanks in advance ... :-) - Andy

1 0

mkEmptyWeakPtr?
by David Roundy 06 Nov '04

06 Nov '04

I was wondering whether there might be any sort of trick one could use to create an empty "Weak a", i.e. one that has already been GCed? It should be possible to create such a pointer without having an object of type a. mkEmptyWeakPtr :: IO (Weak a) I know I could get this effect by using instead a "Maybe (Weak a)", but that's ugly and adds an additional layer of redirection. The point is that the weak pointer is being used to cache a value, but I'd like to not fill the cache until I actually need to read it. i.e. I have a data type AntiMemo (IO a) (IORef (Weak a)) where the second term is a cache of the result of the first, which is really a pure function, but I'm using the IO monad to force reevaluation, so the result, which is large, can be discarded and recomputed. So I could change this to AntiMemo (IO a) (IORef (Maybe (Weak a))) but it just seems a shame when Weak already effectively has a "Nothing" value type. I suppose one could also make it a "Weak (Maybe a)", but in any case, I'd rather be able to just initialize the IORef to an empty weak pointer, so there wouldn't need to be any extra code when reading the value. -- David Roundy http://www.abridgegame.org

1 0

Making MVar and Chan Instances of Typeable
by Benjamin Franksen 06 Nov '04

06 Nov '04

Hello Experts, I need MVar and Chan to be instances of Typeable. Any hint on how this is most easily done would be greatly appreciated. I could change the libraries and add 'deriving Typeable' but I hesitate to do so. Cheers, Ben

4 6

Re: [Haskell-cafe] Re: Double -> CDouble, realToFrac doesn't work
by MR K P SCHUPKE 06 Nov '04

06 Nov '04

>My guess is because irrationals can't be represented on a discrete computer Well, call it arbitrary precision floating point then. Having built in Integer support, it does seem odd only having Float/Double/Rational... Keean. ..

2 1

Literate Haskell and piecewise construction of classes/instances
by Graham Klyne 06 Nov '04

06 Nov '04

I'm experimenting with a Literate Haskell style to construct a tutorial about Description Logics [1][2]. I'm developing the material in small sections, and using examples in the document to test the code as I go along . I therefore find that I want to introduce the components of class and instance declarations in pieces, rather than having the entire declaration in a single place. Am I right in thinking this is not possible? For example, I find myself resorting to tricks like this: [[ So far, a single Description Logic (AL) has been considered. My next step is to generalize the function interface to a collection of type classes that can handle arbitrary description logics. The basic ideas of concepts, roles and interpretations are common to all description logics, so these are used as defined above. It is the concept descriptions, role descriptions and associated operations that need to be further abstracted: - class ConceptExpr c where - iConcept :: Ord a => TInterpretation a -> c -> Set a (The full and final definition of ConceptExpr is given later.) : ]] and later... [[ The class interface for concept expressions is therefore extended thus: > class ConceptExpr c where > iConcept :: Ord a => TInterpretation a -> c -> Set a > isSatisfiableWith :: TBox c -> c -> Bool > isSatisfiableWith t c = not (isSubsumedByWith t c emptyClass) > isSubsumedByWith :: TBox c -> c -> c -> Bool > isSubsumedByWith t c d = > not $ isSatisfiableWith t (intersectClass c (complementClass d)) > emptyClass :: c > complementClass :: c -> c > intersectClass :: c -> c -> c ]] What this suggests to me is that for Literate Haskell it is desirable to have multiple appearances of a class/instance declaration, constrained so that one version contains all of the definitions contained in any other appearance, and no two appearances contain differing definitions for any component (using a fairly strict syntactic comparison to determine difference here). Does this strike any chords with anyone? #g -- [1] http://dl.kr.org/ (Description Logics web page) [2] http://www.ninebynine.org/Software/HaskellDL/DLExploration.lhs (My tutorial, work-in-progress - implements "structural subsumption" for a simple Description Logic.) ------------ Graham Klyne For email: http://www.ninebynine.org/#Contact

1 0

Re: [Haskell-cafe] Making MVar and Chan Instances of Typeable
by MR K P SCHUPKE 05 Nov '04

05 Nov '04

My mistake: instance Typeable a => Typeable (MVar a) where typeOf (x::MVar x) = mkAppTy (mkTyCon "Control.Concurrent.MVar.MVar") [typeOf (undefined::x)] Keean.

1 0