--Last weeks I've played with ObjectIO-GUIs (until I realised the
one-button-mouse implementation and that it still runs only on Win). They
are very fascinating designed.
--Inspired by them...
--To unify 1D/2D/3D/4D vectors/vertices, I would try to implement the
following:
--(I did not test it - I hope this is Haskell98 and "%precompiler" conform.)
class VectorClass v where
dotVec :: (VectorTyp a) => v a -> v a -> a
class VectorTyp va where
addVec :: va -> va -> va
subVec :: va -> va -> va
negVec :: va -> va
data Vector b a = (VectorContainer b) => Vector (b a)
instance VectorClass (Vector b) where
dotVec :: (VectorTyp a) => Vector b a -> Vector b a -> a
dotVec (Vector ba1) (Vector ba2) = dotVecCont ba1 ba2
instance VectorTyp (Vector b a) where
addVec :: Vector b a -> Vector b a -> Vector b a
addVec (Vector ba1) (Vector ba2) = addVecCont ba1 ba2
....
instance (Num v) => VectorTyp v where
addVec = (+)
...
class VectorContainer b where
addVecCont :: (VectorTyp a) => b a -> b a -> b a
subVecCont :: (VectorTyp a) => b a -> b a -> b a
negVecCont :: (VectorTyp a) => b a -> b a
dotVecCont :: (VectorTyp a) => b a -> b a -> a
infixr 8 `VSep`, `VEnd`
-- (Vector $ x `VSep` y `VSep` z `VEnd`)
data VectorContainerPart b a = (VectorContainer b,VectorTyp a) => VSep a (b
a)
data VectorContainerEnd a = (VectorTyp a) => VEnd a
instance VectorContainer VectorContainerEnd where
addVecCont :: (VectorTyp a) => VectorContainerEnd a ->
VectorContainerEnd a -> VectorContainerEnd a
addVecCont (a1 `VEnd`) (a2 `VEnd`) = (a1 `addVec` a2) `VEnd`
...
instance (VectorContainer b) => VectorContainer (VectorContainerPart b)
where
addVecCont :: (VectorTyp a) => VectorContainerPart b a ->
VectorContainerPart b a -> VectorContainerPart b a
addVecCont (a1 `VSep` ba1) (a2 `VSep` ba2) = (a1 àddVec` a2) `VSep` (ba1
`addVecCont` ba2)
...
type Vector1 a = Vector (VectorContainerEnd a) a
type Vector2 a = Vector (VectorContainerPart (VectorContainerEnd a) a) a
type Vector3 a = Vector (VectorContainerPart (VectorContainerPart
(VectorContainerEnd a) a) a) a
type Vector4 a = Vector (VectorContainerPart (VectorContainerPart
(VectorContainerPart (VectorContainerEnd a) a) a) a) a
class GLVector v where
glVector :: v -> IO ()
%fun glVector1s :: GLshort -> IO ()
%fun glVector2s :: GLshort -> GLshort -> IO ()
%fun glVector3s :: GLshort -> GLshort -> GLshort -> IO ()
%fun glVector4s :: GLshort -> GLshort -> GLshort -> GLshort -> IO ()
instance GLVector (Vector1 GLShort) where
glVector (Vector (x `VEnd`)) = glVector1s x
instance GLVector (Vector2 GLShort) where
glVector (Vector (x `VSep` y `VEnd`)) = glVector2s x y
instance GLVector (Vector3 GLShort) where
glVector (Vector (x `VSep` y `VSep` z `VEnd`)) = glVector3s x y z
instance GLVector (Vector4 GLShort) where
glVector (Vector (x `VSep` y `VSep` z `VSep` w `VEnd`)) = glVector4s x y
z w
vector1 :: (VectorTyp a) => a -> (Vector1 a)
vector2 :: (VectorTyp a) => a -> a -> (Vector2 a)
vector3 :: (VectorTyp a) => a -> a -> a -> (Vector3 a)
vector4 :: (VectorTyp a) => a -> a -> a -> a -> (Vector4 a)
vector1 x = (Vector $ x `VEnd`)
vector2 x y = (Vector $ x `VSep` y `VEnd`)
vector3 x y z = (Vector $ x `VSep` y `VSep` z `VEnd`)
vector4 x y z w = (Vector $ x `VSep` y `VSep` z `VSep` w `VEnd`)
glVector1 :: GLShort -> IO ()
glVector2 :: GLShort -> GLShort -> IO ()
glVector3 :: GLShort -> GLShort -> GLShort -> IO ()
glVector4 :: GLShort -> GLShort -> GLShort -> GLShort -> IO ()
glVector1 x = (glVector . vector1)
glVector2 x = (glVector . vector2)
glVector3 x = (glVector . vector3)
glVector4 x = (glVector . vector4)
-- examples:
-- glVector (vector3 x y z)
-- glVector3 x y z
----- Original Message -----
From: "Sven Panne"
While I'm at it: I really like to hear opinions and improvements of the API, e.g. the vertex specification stuff like
class Vertex a where vertex :: a -> IO ()
data Vertex2 a = Vertex2 a a
instance Vertex (Vertex2 GLshort) where -- complex instance head!!! vertex (Vertex2 x y) = vertex2s x y
%fun glVertex2s :: GLshort -> GLshort -> IO ()
is not Haskell98. How can we do better, i.e. unify 1D/2D/3D/4D vertices with differing component types in pure Haskell98?