[Haskell-cafe] Decoupling OpenAL/ALUT packages from OpenGL
Sven Panne
Sven.Panne at aedion.de
Sun May 10 07:50:08 EDT 2009
Am Montag, 4. Mai 2009 13:33:33 schrieb David Duke:
> Decoupling basic primitives for geometric modelling from OpenGL would be
> useful. [...]
> Even just data constructors and instances of these within Functor and
> Applicative are a useful starting point. [...]
I've taken a closer look at the available packages for vector math/linear
algebra. They differ in a lot of respects, starting from their representations
of vectors and matrices, use of the type system and its extensions,
strictness, structure of their type classes, etc.
This leads me to the conclusion that I should only lift the data types for
vectors and matrices out of the OpenGL package, including only instances for
standard type classes like Eq, Ord, Functor, etc. This means that the new
package will *not* include type classes for things like scalars, vector
spaces, etc. These can be defined by the other packages in their own "type
class language". I really fail to see a common ground in this respect, even
for basic things: Keeping things H98-compliant is a must for me, so putting
things like fundeps or associated types in this new package is a no-go for me.
Nevertheless, having a common set of (strict) data types for vector math will
probably be very useful, even if it won't fulfill everybody's needs.
What standard instances should be defined for those vectors and matrices?
Things coming to mind are Eq, Ord, Show, Storable, Typeable1, Functor and
Applicative. Have I missed some type classes?
Regarding Functor/Applicative: The obvious instances for e.g. a 2-dimensional
vertex are:
data Vertex2 a = Vertex2 a a
instance Functor Vertex2 where
fmap f (Vertex2 x y) = Vertex2 (f x) (f y)
instance Applicative Vertex2 where
pure a = Vertex2 a a
Vertex2 f g <*> Vertex2 x y = Vertex2 (f x) (g y)
They fulfill all required laws, but are these the only possible instances? If
not, are they at least the most "canonical" ones in a given sense? And
finally: Does somebody have a real-world example where the Applicative
instance is useful? Usages of the Functor instance are much more obvious for
me.
Cheers,
S.
More information about the Haskell-Cafe
mailing list