```{-# LANGUAGE DeriveDataTypeable #-}
{- |
Description :  definition of the datatype describing
the abstract FreeCAD terms and and a few tools describing simple
mathematical operations on those building-blocks (3d vectors,
rotation matrices, rotation quaternions)
Copyright   :  (c) Robert Savu and Uni Bremen 2011

Maintainer  :  Robert.Savu@dfki.de
Stability   :  experimental
Portability :  portable

Declaration of the abstract datatypes of FreeCAD terms
-}

import Data.Data
import qualified Data.Set as Set

data Vector3 =
Vector3 { Vector3 -> Double
x :: Double, Vector3 -> Double
y :: Double, Vector3 -> Double
z :: Double }
deriving (Int -> Vector3 -> ShowS
[Vector3] -> ShowS
Vector3 -> String
(Int -> Vector3 -> ShowS)
-> (Vector3 -> String) -> ([Vector3] -> ShowS) -> Show Vector3
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Vector3] -> ShowS
\$cshowList :: [Vector3] -> ShowS
show :: Vector3 -> String
\$cshow :: Vector3 -> String
showsPrec :: Int -> Vector3 -> ShowS
\$cshowsPrec :: Int -> Vector3 -> ShowS
Show, Vector3 -> Vector3 -> Bool
(Vector3 -> Vector3 -> Bool)
-> (Vector3 -> Vector3 -> Bool) -> Eq Vector3
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Vector3 -> Vector3 -> Bool
\$c/= :: Vector3 -> Vector3 -> Bool
== :: Vector3 -> Vector3 -> Bool
\$c== :: Vector3 -> Vector3 -> Bool
Eq, Eq Vector3
Eq Vector3 =>
(Vector3 -> Vector3 -> Ordering)
-> (Vector3 -> Vector3 -> Bool)
-> (Vector3 -> Vector3 -> Bool)
-> (Vector3 -> Vector3 -> Bool)
-> (Vector3 -> Vector3 -> Bool)
-> (Vector3 -> Vector3 -> Vector3)
-> (Vector3 -> Vector3 -> Vector3)
-> Ord Vector3
Vector3 -> Vector3 -> Bool
Vector3 -> Vector3 -> Ordering
Vector3 -> Vector3 -> Vector3
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Vector3 -> Vector3 -> Vector3
\$cmin :: Vector3 -> Vector3 -> Vector3
max :: Vector3 -> Vector3 -> Vector3
\$cmax :: Vector3 -> Vector3 -> Vector3
>= :: Vector3 -> Vector3 -> Bool
\$c>= :: Vector3 -> Vector3 -> Bool
> :: Vector3 -> Vector3 -> Bool
\$c> :: Vector3 -> Vector3 -> Bool
<= :: Vector3 -> Vector3 -> Bool
\$c<= :: Vector3 -> Vector3 -> Bool
< :: Vector3 -> Vector3 -> Bool
\$c< :: Vector3 -> Vector3 -> Bool
compare :: Vector3 -> Vector3 -> Ordering
\$ccompare :: Vector3 -> Vector3 -> Ordering
\$cp1Ord :: Eq Vector3
Ord, Typeable, Typeable Vector3
Constr
DataType
Typeable Vector3 =>
(forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Vector3 -> c Vector3)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Vector3)
-> (Vector3 -> Constr)
-> (Vector3 -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Vector3))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Vector3))
-> ((forall b. Data b => b -> b) -> Vector3 -> Vector3)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Vector3 -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Vector3 -> r)
-> (forall u. (forall d. Data d => d -> u) -> Vector3 -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Vector3 -> u)
-> (forall (m :: * -> *).
(forall d. Data d => d -> m d) -> Vector3 -> m Vector3)
-> (forall (m :: * -> *).
(forall d. Data d => d -> m d) -> Vector3 -> m Vector3)
-> (forall (m :: * -> *).
(forall d. Data d => d -> m d) -> Vector3 -> m Vector3)
-> Data Vector3
Vector3 -> Constr
Vector3 -> DataType
(forall b. Data b => b -> b) -> Vector3 -> Vector3
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Vector3 -> c Vector3
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Vector3
forall a.
Typeable a =>
(forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
(forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Vector3 -> u
forall u. (forall d. Data d => d -> u) -> Vector3 -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Vector3 -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Vector3 -> r
forall (m :: * -> *).
(forall d. Data d => d -> m d) -> Vector3 -> m Vector3
forall (m :: * -> *).
(forall d. Data d => d -> m d) -> Vector3 -> m Vector3
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Vector3
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Vector3 -> c Vector3
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Vector3)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Vector3)
\$cVector3 :: Constr
\$tVector3 :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Vector3 -> m Vector3
\$cgmapMo :: forall (m :: * -> *).
(forall d. Data d => d -> m d) -> Vector3 -> m Vector3
gmapMp :: (forall d. Data d => d -> m d) -> Vector3 -> m Vector3
\$cgmapMp :: forall (m :: * -> *).
(forall d. Data d => d -> m d) -> Vector3 -> m Vector3
gmapM :: (forall d. Data d => d -> m d) -> Vector3 -> m Vector3
\$cgmapM :: forall (m :: * -> *).
(forall d. Data d => d -> m d) -> Vector3 -> m Vector3
gmapQi :: Int -> (forall d. Data d => d -> u) -> Vector3 -> u
\$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Vector3 -> u
gmapQ :: (forall d. Data d => d -> u) -> Vector3 -> [u]
\$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Vector3 -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Vector3 -> r
\$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Vector3 -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Vector3 -> r
\$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Vector3 -> r
gmapT :: (forall b. Data b => b -> b) -> Vector3 -> Vector3
\$cgmapT :: (forall b. Data b => b -> b) -> Vector3 -> Vector3
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Vector3)
\$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Vector3)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Vector3)
\$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Vector3)
dataTypeOf :: Vector3 -> DataType
\$cdataTypeOf :: Vector3 -> DataType
toConstr :: Vector3 -> Constr
\$ctoConstr :: Vector3 -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Vector3
\$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Vector3
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Vector3 -> c Vector3
\$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Vector3 -> c Vector3
\$cp1Data :: Typeable Vector3
Data)

data Matrix33 = Matrix33 { Matrix33 -> Double
a11 :: Double , Matrix33 -> Double
a12 :: Double , Matrix33 -> Double
a13 :: Double
, Matrix33 -> Double
a21 :: Double , Matrix33 -> Double
a22 :: Double , Matrix33 -> Double
a23 :: Double
, Matrix33 -> Double
a31 :: Double , Matrix33 -> Double
a32 :: Double , Matrix33 -> Double
a33 :: Double
} deriving (Int -> Matrix33 -> ShowS
[Matrix33] -> ShowS
Matrix33 -> String
(Int -> Matrix33 -> ShowS)
-> (Matrix33 -> String) -> ([Matrix33] -> ShowS) -> Show Matrix33
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Matrix33] -> ShowS
\$cshowList :: [Matrix33] -> ShowS
show :: Matrix33 -> String
\$cshow :: Matrix33 -> String
showsPrec :: Int -> Matrix33 -> ShowS
\$cshowsPrec :: Int -> Matrix33 -> ShowS
Show, Matrix33 -> Matrix33 -> Bool
(Matrix33 -> Matrix33 -> Bool)
-> (Matrix33 -> Matrix33 -> Bool) -> Eq Matrix33
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Matrix33 -> Matrix33 -> Bool
\$c/= :: Matrix33 -> Matrix33 -> Bool
== :: Matrix33 -> Matrix33 -> Bool
\$c== :: Matrix33 -> Matrix33 -> Bool
Eq, Eq Matrix33
Eq Matrix33 =>
(Matrix33 -> Matrix33 -> Ordering)
-> (Matrix33 -> Matrix33 -> Bool)
-> (Matrix33 -> Matrix33 -> Bool)
-> (Matrix33 -> Matrix33 -> Bool)
-> (Matrix33 -> Matrix33 -> Bool)
-> (Matrix33 -> Matrix33 -> Matrix33)
-> (Matrix33 -> Matrix33 -> Matrix33)
-> Ord Matrix33
Matrix33 -> Matrix33 -> Bool
Matrix33 -> Matrix33 -> Ordering
Matrix33 -> Matrix33 -> Matrix33
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Matrix33 -> Matrix33 -> Matrix33
\$cmin :: Matrix33 -> Matrix33 -> Matrix33
max :: Matrix33 -> Matrix33 -> Matrix33
\$cmax :: Matrix33 -> Matrix33 -> Matrix33
>= :: Matrix33 -> Matrix33 -> Bool
\$c>= :: Matrix33 -> Matrix33 -> Bool
> :: Matrix33 -> Matrix33 -> Bool
\$c> :: Matrix33 -> Matrix33 -> Bool
<= :: Matrix33 -> Matrix33 -> Bool
\$c<= :: Matrix33 -> Matrix33 -> Bool
< :: Matrix33 -> Matrix33 -> Bool
\$c< :: Matrix33 -> Matrix33 -> Bool
compare :: Matrix33 -> Matrix33 -> Ordering
\$ccompare :: Matrix33 -> Matrix33 -> Ordering
\$cp1Ord :: Eq Matrix33
Ord, Typeable, Typeable Matrix33
Constr
DataType
Typeable Matrix33 =>
(forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Matrix33 -> c Matrix33)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Matrix33)
-> (Matrix33 -> Constr)
-> (Matrix33 -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Matrix33))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Matrix33))
-> ((forall b. Data b => b -> b) -> Matrix33 -> Matrix33)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Matrix33 -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Matrix33 -> r)
-> (forall u. (forall d. Data d => d -> u) -> Matrix33 -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Matrix33 -> u)
-> (forall (m :: * -> *).
(forall d. Data d => d -> m d) -> Matrix33 -> m Matrix33)
-> (forall (m :: * -> *).
(forall d. Data d => d -> m d) -> Matrix33 -> m Matrix33)
-> (forall (m :: * -> *).
(forall d. Data d => d -> m d) -> Matrix33 -> m Matrix33)
-> Data Matrix33
Matrix33 -> Constr
Matrix33 -> DataType
(forall b. Data b => b -> b) -> Matrix33 -> Matrix33
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Matrix33 -> c Matrix33
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Matrix33
forall a.
Typeable a =>
(forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
(forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Matrix33 -> u
forall u. (forall d. Data d => d -> u) -> Matrix33 -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Matrix33 -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Matrix33 -> r
forall (m :: * -> *).
(forall d. Data d => d -> m d) -> Matrix33 -> m Matrix33
forall (m :: * -> *).
(forall d. Data d => d -> m d) -> Matrix33 -> m Matrix33
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Matrix33
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Matrix33 -> c Matrix33
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Matrix33)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Matrix33)
\$cMatrix33 :: Constr
\$tMatrix33 :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Matrix33 -> m Matrix33
\$cgmapMo :: forall (m :: * -> *).
(forall d. Data d => d -> m d) -> Matrix33 -> m Matrix33
gmapMp :: (forall d. Data d => d -> m d) -> Matrix33 -> m Matrix33
\$cgmapMp :: forall (m :: * -> *).
(forall d. Data d => d -> m d) -> Matrix33 -> m Matrix33
gmapM :: (forall d. Data d => d -> m d) -> Matrix33 -> m Matrix33
\$cgmapM :: forall (m :: * -> *).
(forall d. Data d => d -> m d) -> Matrix33 -> m Matrix33
gmapQi :: Int -> (forall d. Data d => d -> u) -> Matrix33 -> u
\$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Matrix33 -> u
gmapQ :: (forall d. Data d => d -> u) -> Matrix33 -> [u]
\$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Matrix33 -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Matrix33 -> r
\$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Matrix33 -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Matrix33 -> r
\$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Matrix33 -> r
gmapT :: (forall b. Data b => b -> b) -> Matrix33 -> Matrix33
\$cgmapT :: (forall b. Data b => b -> b) -> Matrix33 -> Matrix33
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Matrix33)
\$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Matrix33)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Matrix33)
\$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Matrix33)
dataTypeOf :: Matrix33 -> DataType
\$cdataTypeOf :: Matrix33 -> DataType
toConstr :: Matrix33 -> Constr
\$ctoConstr :: Matrix33 -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Matrix33
\$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Matrix33
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Matrix33 -> c Matrix33
\$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Matrix33 -> c Matrix33
\$cp1Data :: Typeable Matrix33
Data)
-- used as a rotation matrix

data Vector4 = Vector4 { Vector4 -> Double
q0 :: Double, Vector4 -> Double
q1 :: Double, Vector4 -> Double
q2 :: Double, Vector4 -> Double
q3 :: Double}
deriving (Int -> Vector4 -> ShowS
[Vector4] -> ShowS
Vector4 -> String
(Int -> Vector4 -> ShowS)
-> (Vector4 -> String) -> ([Vector4] -> ShowS) -> Show Vector4
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Vector4] -> ShowS
\$cshowList :: [Vector4] -> ShowS
show :: Vector4 -> String
\$cshow :: Vector4 -> String
showsPrec :: Int -> Vector4 -> ShowS
\$cshowsPrec :: Int -> Vector4 -> ShowS
Show, Vector4 -> Vector4 -> Bool
(Vector4 -> Vector4 -> Bool)
-> (Vector4 -> Vector4 -> Bool) -> Eq Vector4
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Vector4 -> Vector4 -> Bool
\$c/= :: Vector4 -> Vector4 -> Bool
== :: Vector4 -> Vector4 -> Bool
\$c== :: Vector4 -> Vector4 -> Bool
Eq, Eq Vector4
Eq Vector4 =>
(Vector4 -> Vector4 -> Ordering)
-> (Vector4 -> Vector4 -> Bool)
-> (Vector4 -> Vector4 -> Bool)
-> (Vector4 -> Vector4 -> Bool)
-> (Vector4 -> Vector4 -> Bool)
-> (Vector4 -> Vector4 -> Vector4)
-> (Vector4 -> Vector4 -> Vector4)
-> Ord Vector4
Vector4 -> Vector4 -> Bool
Vector4 -> Vector4 -> Ordering
Vector4 -> Vector4 -> Vector4
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Vector4 -> Vector4 -> Vector4
\$cmin :: Vector4 -> Vector4 -> Vector4
max :: Vector4 -> Vector4 -> Vector4
\$cmax :: Vector4 -> Vector4 -> Vector4
>= :: Vector4 -> Vector4 -> Bool
\$c>= :: Vector4 -> Vector4 -> Bool
> :: Vector4 -> Vector4 -> Bool
\$c> :: Vector4 -> Vector4 -> Bool
<= :: Vector4 -> Vector4 -> Bool
\$c<= :: Vector4 -> Vector4 -> Bool
< :: Vector4 -> Vector4 -> Bool
\$c< :: Vector4 -> Vector4 -> Bool
compare :: Vector4 -> Vector4 -> Ordering
\$ccompare :: Vector4 -> Vector4 -> Ordering
\$cp1Ord :: Eq Vector4
Ord, Typeable, Typeable Vector4
Constr
DataType
Typeable Vector4 =>
(forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Vector4 -> c Vector4)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Vector4)
-> (Vector4 -> Constr)
-> (Vector4 -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Vector4))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Vector4))
-> ((forall b. Data b => b -> b) -> Vector4 -> Vector4)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Vector4 -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Vector4 -> r)
-> (forall u. (forall d. Data d => d -> u) -> Vector4 -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Vector4 -> u)
-> (forall (m :: * -> *).
(forall d. Data d => d -> m d) -> Vector4 -> m Vector4)
-> (forall (m :: * -> *).
(forall d. Data d => d -> m d) -> Vector4 -> m Vector4)
-> (forall (m :: * -> *).
(forall d. Data d => d -> m d) -> Vector4 -> m Vector4)
-> Data Vector4
Vector4 -> Constr
Vector4 -> DataType
(forall b. Data b => b -> b) -> Vector4 -> Vector4
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Vector4 -> c Vector4
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Vector4
forall a.
Typeable a =>
(forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
(forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Vector4 -> u
forall u. (forall d. Data d => d -> u) -> Vector4 -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Vector4 -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Vector4 -> r
forall (m :: * -> *).
(forall d. Data d => d -> m d) -> Vector4 -> m Vector4
forall (m :: * -> *).
(forall d. Data d => d -> m d) -> Vector4 -> m Vector4
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Vector4
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Vector4 -> c Vector4
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Vector4)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Vector4)
\$cVector4 :: Constr
\$tVector4 :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Vector4 -> m Vector4
\$cgmapMo :: forall (m :: * -> *).
(forall d. Data d => d -> m d) -> Vector4 -> m Vector4
gmapMp :: (forall d. Data d => d -> m d) -> Vector4 -> m Vector4
\$cgmapMp :: forall (m :: * -> *).
(forall d. Data d => d -> m d) -> Vector4 -> m Vector4
gmapM :: (forall d. Data d => d -> m d) -> Vector4 -> m Vector4
\$cgmapM :: forall (m :: * -> *).
(forall d. Data d => d -> m d) -> Vector4 -> m Vector4
gmapQi :: Int -> (forall d. Data d => d -> u) -> Vector4 -> u
\$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Vector4 -> u
gmapQ :: (forall d. Data d => d -> u) -> Vector4 -> [u]
\$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Vector4 -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Vector4 -> r
\$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Vector4 -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Vector4 -> r
\$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Vector4 -> r
gmapT :: (forall b. Data b => b -> b) -> Vector4 -> Vector4
\$cgmapT :: (forall b. Data b => b -> b) -> Vector4 -> Vector4
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Vector4)
\$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Vector4)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Vector4)
\$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Vector4)
dataTypeOf :: Vector4 -> DataType
\$cdataTypeOf :: Vector4 -> DataType
toConstr :: Vector4 -> Constr
\$ctoConstr :: Vector4 -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Vector4
\$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Vector4
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Vector4 -> c Vector4
\$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Vector4 -> c Vector4
\$cp1Data :: Typeable Vector4
Data)
-- quaternion rotational representation

data Placement = Placement { Placement -> Vector3
position :: Vector3, Placement -> Vector4
orientation :: Vector4 }
deriving (Int -> Placement -> ShowS
[Placement] -> ShowS
Placement -> String
(Int -> Placement -> ShowS)
-> (Placement -> String)
-> ([Placement] -> ShowS)
-> Show Placement
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Placement] -> ShowS
\$cshowList :: [Placement] -> ShowS
show :: Placement -> String
\$cshow :: Placement -> String
showsPrec :: Int -> Placement -> ShowS
\$cshowsPrec :: Int -> Placement -> ShowS
Show, Placement -> Placement -> Bool
(Placement -> Placement -> Bool)
-> (Placement -> Placement -> Bool) -> Eq Placement
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Placement -> Placement -> Bool
\$c/= :: Placement -> Placement -> Bool
== :: Placement -> Placement -> Bool
\$c== :: Placement -> Placement -> Bool
Eq, Eq Placement
Eq Placement =>
(Placement -> Placement -> Ordering)
-> (Placement -> Placement -> Bool)
-> (Placement -> Placement -> Bool)
-> (Placement -> Placement -> Bool)
-> (Placement -> Placement -> Bool)
-> (Placement -> Placement -> Placement)
-> (Placement -> Placement -> Placement)
-> Ord Placement
Placement -> Placement -> Bool
Placement -> Placement -> Ordering
Placement -> Placement -> Placement
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Placement -> Placement -> Placement
\$cmin :: Placement -> Placement -> Placement
max :: Placement -> Placement -> Placement
\$cmax :: Placement -> Placement -> Placement
>= :: Placement -> Placement -> Bool
\$c>= :: Placement -> Placement -> Bool
> :: Placement -> Placement -> Bool
\$c> :: Placement -> Placement -> Bool
<= :: Placement -> Placement -> Bool
\$c<= :: Placement -> Placement -> Bool
< :: Placement -> Placement -> Bool
\$c< :: Placement -> Placement -> Bool
compare :: Placement -> Placement -> Ordering
\$ccompare :: Placement -> Placement -> Ordering
\$cp1Ord :: Eq Placement
Ord, Typeable, Typeable Placement
Constr
DataType
Typeable Placement =>
(forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Placement -> c Placement)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Placement)
-> (Placement -> Constr)
-> (Placement -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Placement))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Placement))
-> ((forall b. Data b => b -> b) -> Placement -> Placement)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Placement -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Placement -> r)
-> (forall u. (forall d. Data d => d -> u) -> Placement -> [u])
-> (forall u.
Int -> (forall d. Data d => d -> u) -> Placement -> u)
-> (forall (m :: * -> *).
(forall d. Data d => d -> m d) -> Placement -> m Placement)
-> (forall (m :: * -> *).
(forall d. Data d => d -> m d) -> Placement -> m Placement)
-> (forall (m :: * -> *).
(forall d. Data d => d -> m d) -> Placement -> m Placement)
-> Data Placement
Placement -> Constr
Placement -> DataType
(forall b. Data b => b -> b) -> Placement -> Placement
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Placement -> c Placement
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Placement
forall a.
Typeable a =>
(forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
(forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Placement -> u
forall u. (forall d. Data d => d -> u) -> Placement -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Placement -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Placement -> r
forall (m :: * -> *).
(forall d. Data d => d -> m d) -> Placement -> m Placement
forall (m :: * -> *).
(forall d. Data d => d -> m d) -> Placement -> m Placement
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Placement
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Placement -> c Placement
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Placement)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Placement)
\$cPlacement :: Constr
\$tPlacement :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Placement -> m Placement
\$cgmapMo :: forall (m :: * -> *).
(forall d. Data d => d -> m d) -> Placement -> m Placement
gmapMp :: (forall d. Data d => d -> m d) -> Placement -> m Placement
\$cgmapMp :: forall (m :: * -> *).
(forall d. Data d => d -> m d) -> Placement -> m Placement
gmapM :: (forall d. Data d => d -> m d) -> Placement -> m Placement
\$cgmapM :: forall (m :: * -> *).
(forall d. Data d => d -> m d) -> Placement -> m Placement
gmapQi :: Int -> (forall d. Data d => d -> u) -> Placement -> u
\$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Placement -> u
gmapQ :: (forall d. Data d => d -> u) -> Placement -> [u]
\$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Placement -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Placement -> r
\$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Placement -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Placement -> r
\$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Placement -> r
gmapT :: (forall b. Data b => b -> b) -> Placement -> Placement
\$cgmapT :: (forall b. Data b => b -> b) -> Placement -> Placement
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Placement)
\$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Placement)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Placement)
\$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Placement)
dataTypeOf :: Placement -> DataType
\$cdataTypeOf :: Placement -> DataType
toConstr :: Placement -> Constr
\$ctoConstr :: Placement -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Placement
\$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Placement
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Placement -> c Placement
\$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Placement -> c Placement
\$cp1Data :: Typeable Placement
Data)

{-
--   the placement is determined by 2 vectors:
--   the first one points to the 'center' of the objet in the space
--   the second one determines the orientation of the object in the given space
data Edgelist = []
| 1:Edgelist
| 0:Edgelist

reference from compound objects to 'building-blocks'
objects made through strings or containment of the other
objects
-}
data BaseObject = Box Double Double Double -- Height, Width, Length
| Cylinder Double Double Double -- Angle, Height, Radius
| Sphere Double Double Double Double -- Angle1,Angle2,Angle3,Radius
| Torus Double Double Double Double Double
| Line Double -- length
| Circle Double Double Double -- StartAngle, EndAngle, Radius
| Rectangle Double Double -- Height, Length
deriving (Int -> BaseObject -> ShowS
[BaseObject] -> ShowS
BaseObject -> String
(Int -> BaseObject -> ShowS)
-> (BaseObject -> String)
-> ([BaseObject] -> ShowS)
-> Show BaseObject
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BaseObject] -> ShowS
\$cshowList :: [BaseObject] -> ShowS
show :: BaseObject -> String
\$cshow :: BaseObject -> String
showsPrec :: Int -> BaseObject -> ShowS
\$cshowsPrec :: Int -> BaseObject -> ShowS
Show, BaseObject -> BaseObject -> Bool
(BaseObject -> BaseObject -> Bool)
-> (BaseObject -> BaseObject -> Bool) -> Eq BaseObject
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BaseObject -> BaseObject -> Bool
\$c/= :: BaseObject -> BaseObject -> Bool
== :: BaseObject -> BaseObject -> Bool
\$c== :: BaseObject -> BaseObject -> Bool
Eq, Eq BaseObject
Eq BaseObject =>
(BaseObject -> BaseObject -> Ordering)
-> (BaseObject -> BaseObject -> Bool)
-> (BaseObject -> BaseObject -> Bool)
-> (BaseObject -> BaseObject -> Bool)
-> (BaseObject -> BaseObject -> Bool)
-> (BaseObject -> BaseObject -> BaseObject)
-> (BaseObject -> BaseObject -> BaseObject)
-> Ord BaseObject
BaseObject -> BaseObject -> Bool
BaseObject -> BaseObject -> Ordering
BaseObject -> BaseObject -> BaseObject
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: BaseObject -> BaseObject -> BaseObject
\$cmin :: BaseObject -> BaseObject -> BaseObject
max :: BaseObject -> BaseObject -> BaseObject
\$cmax :: BaseObject -> BaseObject -> BaseObject
>= :: BaseObject -> BaseObject -> Bool
\$c>= :: BaseObject -> BaseObject -> Bool
> :: BaseObject -> BaseObject -> Bool
\$c> :: BaseObject -> BaseObject -> Bool
<= :: BaseObject -> BaseObject -> Bool
\$c<= :: BaseObject -> BaseObject -> Bool
< :: BaseObject -> BaseObject -> Bool
\$c< :: BaseObject -> BaseObject -> Bool
compare :: BaseObject -> BaseObject -> Ordering
\$ccompare :: BaseObject -> BaseObject -> Ordering
\$cp1Ord :: Eq BaseObject
Ord, Typeable, Typeable BaseObject
Constr
DataType
Typeable BaseObject =>
(forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BaseObject -> c BaseObject)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BaseObject)
-> (BaseObject -> Constr)
-> (BaseObject -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BaseObject))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c BaseObject))
-> ((forall b. Data b => b -> b) -> BaseObject -> BaseObject)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BaseObject -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BaseObject -> r)
-> (forall u. (forall d. Data d => d -> u) -> BaseObject -> [u])
-> (forall u.
Int -> (forall d. Data d => d -> u) -> BaseObject -> u)
-> (forall (m :: * -> *).
(forall d. Data d => d -> m d) -> BaseObject -> m BaseObject)
-> (forall (m :: * -> *).
(forall d. Data d => d -> m d) -> BaseObject -> m BaseObject)
-> (forall (m :: * -> *).
(forall d. Data d => d -> m d) -> BaseObject -> m BaseObject)
-> Data BaseObject
BaseObject -> Constr
BaseObject -> DataType
(forall b. Data b => b -> b) -> BaseObject -> BaseObject
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BaseObject -> c BaseObject
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BaseObject
forall a.
Typeable a =>
(forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
(forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> BaseObject -> u
forall u. (forall d. Data d => d -> u) -> BaseObject -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BaseObject -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BaseObject -> r
forall (m :: * -> *).
(forall d. Data d => d -> m d) -> BaseObject -> m BaseObject
forall (m :: * -> *).
(forall d. Data d => d -> m d) -> BaseObject -> m BaseObject
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BaseObject
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BaseObject -> c BaseObject
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BaseObject)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BaseObject)
\$cRectangle :: Constr
\$cCircle :: Constr
\$cLine :: Constr
\$cTorus :: Constr
\$cCone :: Constr
\$cSphere :: Constr
\$cCylinder :: Constr
\$cBox :: Constr
\$tBaseObject :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> BaseObject -> m BaseObject
\$cgmapMo :: forall (m :: * -> *).
(forall d. Data d => d -> m d) -> BaseObject -> m BaseObject
gmapMp :: (forall d. Data d => d -> m d) -> BaseObject -> m BaseObject
\$cgmapMp :: forall (m :: * -> *).
(forall d. Data d => d -> m d) -> BaseObject -> m BaseObject
gmapM :: (forall d. Data d => d -> m d) -> BaseObject -> m BaseObject
\$cgmapM :: forall (m :: * -> *).
(forall d. Data d => d -> m d) -> BaseObject -> m BaseObject
gmapQi :: Int -> (forall d. Data d => d -> u) -> BaseObject -> u
\$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> BaseObject -> u
gmapQ :: (forall d. Data d => d -> u) -> BaseObject -> [u]
\$cgmapQ :: forall u. (forall d. Data d => d -> u) -> BaseObject -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BaseObject -> r
\$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BaseObject -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BaseObject -> r
\$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BaseObject -> r
gmapT :: (forall b. Data b => b -> b) -> BaseObject -> BaseObject
\$cgmapT :: (forall b. Data b => b -> b) -> BaseObject -> BaseObject
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BaseObject)
\$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BaseObject)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c BaseObject)
\$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BaseObject)
dataTypeOf :: BaseObject -> DataType
\$cdataTypeOf :: BaseObject -> DataType
toConstr :: BaseObject -> Constr
\$ctoConstr :: BaseObject -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BaseObject
\$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BaseObject
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BaseObject -> c BaseObject
\$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BaseObject -> c BaseObject
\$cp1Data :: Typeable BaseObject
Data)
-- TODO: Plane, Vertex, etc..

data Object = BaseObject BaseObject
| Cut ExtendedObject ExtendedObject
| Common ExtendedObject ExtendedObject
| Fusion ExtendedObject ExtendedObject
| Extrusion ExtendedObject Vector3
| Section ExtendedObject ExtendedObject
deriving (Int -> Object -> ShowS
[Object] -> ShowS
Object -> String
(Int -> Object -> ShowS)
-> (Object -> String) -> ([Object] -> ShowS) -> Show Object
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Object] -> ShowS
\$cshowList :: [Object] -> ShowS
show :: Object -> String
\$cshow :: Object -> String
showsPrec :: Int -> Object -> ShowS
\$cshowsPrec :: Int -> Object -> ShowS
Show, Object -> Object -> Bool
(Object -> Object -> Bool)
-> (Object -> Object -> Bool) -> Eq Object
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Object -> Object -> Bool
\$c/= :: Object -> Object -> Bool
== :: Object -> Object -> Bool
\$c== :: Object -> Object -> Bool
Eq, Eq Object
Eq Object =>
(Object -> Object -> Ordering)
-> (Object -> Object -> Bool)
-> (Object -> Object -> Bool)
-> (Object -> Object -> Bool)
-> (Object -> Object -> Bool)
-> (Object -> Object -> Object)
-> (Object -> Object -> Object)
-> Ord Object
Object -> Object -> Bool
Object -> Object -> Ordering
Object -> Object -> Object
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Object -> Object -> Object
\$cmin :: Object -> Object -> Object
max :: Object -> Object -> Object
\$cmax :: Object -> Object -> Object
>= :: Object -> Object -> Bool
\$c>= :: Object -> Object -> Bool
> :: Object -> Object -> Bool
\$c> :: Object -> Object -> Bool
<= :: Object -> Object -> Bool
\$c<= :: Object -> Object -> Bool
< :: Object -> Object -> Bool
\$c< :: Object -> Object -> Bool
compare :: Object -> Object -> Ordering
\$ccompare :: Object -> Object -> Ordering
\$cp1Ord :: Eq Object
Ord, Typeable, Typeable Object
Constr
DataType
Typeable Object =>
(forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Object -> c Object)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Object)
-> (Object -> Constr)
-> (Object -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Object))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Object))
-> ((forall b. Data b => b -> b) -> Object -> Object)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Object -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Object -> r)
-> (forall u. (forall d. Data d => d -> u) -> Object -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Object -> u)
-> (forall (m :: * -> *).
(forall d. Data d => d -> m d) -> Object -> m Object)
-> (forall (m :: * -> *).
(forall d. Data d => d -> m d) -> Object -> m Object)
-> (forall (m :: * -> *).
(forall d. Data d => d -> m d) -> Object -> m Object)
-> Data Object
Object -> Constr
Object -> DataType
(forall b. Data b => b -> b) -> Object -> Object
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Object -> c Object
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Object
forall a.
Typeable a =>
(forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
(forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Object -> u
forall u. (forall d. Data d => d -> u) -> Object -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Object -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Object -> r
forall (m :: * -> *).
(forall d. Data d => d -> m d) -> Object -> m Object
forall (m :: * -> *).
(forall d. Data d => d -> m d) -> Object -> m Object
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Object
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Object -> c Object
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Object)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Object)
\$cSection :: Constr
\$cExtrusion :: Constr
\$cFusion :: Constr
\$cCommon :: Constr
\$cCut :: Constr
\$cBaseObject :: Constr
\$tObject :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Object -> m Object
\$cgmapMo :: forall (m :: * -> *).
(forall d. Data d => d -> m d) -> Object -> m Object
gmapMp :: (forall d. Data d => d -> m d) -> Object -> m Object
\$cgmapMp :: forall (m :: * -> *).
(forall d. Data d => d -> m d) -> Object -> m Object
gmapM :: (forall d. Data d => d -> m d) -> Object -> m Object
\$cgmapM :: forall (m :: * -> *).
(forall d. Data d => d -> m d) -> Object -> m Object
gmapQi :: Int -> (forall d. Data d => d -> u) -> Object -> u
\$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Object -> u
gmapQ :: (forall d. Data d => d -> u) -> Object -> [u]
\$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Object -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Object -> r
\$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Object -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Object -> r
\$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Object -> r
gmapT :: (forall b. Data b => b -> b) -> Object -> Object
\$cgmapT :: (forall b. Data b => b -> b) -> Object -> Object
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Object)
\$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Object)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Object)
\$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Object)
dataTypeOf :: Object -> DataType
\$cdataTypeOf :: Object -> DataType
toConstr :: Object -> Constr
\$ctoConstr :: Object -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Object
\$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Object
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Object -> c Object
\$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Object -> c Object
\$cp1Data :: Typeable Object
Data)

{- --| Fillet, (Base::String, Edges::Edgelist, Radius::Double)),
--not enough data in the xml
--| Chamfer, (Base::String, Edges::Edgelist, Amount::Double)),
--not enough data in the xml
--| Mirror, (Base::String, Position2::Vector))
--mirroring of an object
-}

data ExtendedObject = Placed PlacedObject | Ref String
deriving (Int -> ExtendedObject -> ShowS
[ExtendedObject] -> ShowS
ExtendedObject -> String
(Int -> ExtendedObject -> ShowS)
-> (ExtendedObject -> String)
-> ([ExtendedObject] -> ShowS)
-> Show ExtendedObject
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ExtendedObject] -> ShowS
\$cshowList :: [ExtendedObject] -> ShowS
show :: ExtendedObject -> String
\$cshow :: ExtendedObject -> String
showsPrec :: Int -> ExtendedObject -> ShowS
\$cshowsPrec :: Int -> ExtendedObject -> ShowS
Show, ExtendedObject -> ExtendedObject -> Bool
(ExtendedObject -> ExtendedObject -> Bool)
-> (ExtendedObject -> ExtendedObject -> Bool) -> Eq ExtendedObject
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ExtendedObject -> ExtendedObject -> Bool
\$c/= :: ExtendedObject -> ExtendedObject -> Bool
== :: ExtendedObject -> ExtendedObject -> Bool
\$c== :: ExtendedObject -> ExtendedObject -> Bool
Eq, Eq ExtendedObject
Eq ExtendedObject =>
(ExtendedObject -> ExtendedObject -> Ordering)
-> (ExtendedObject -> ExtendedObject -> Bool)
-> (ExtendedObject -> ExtendedObject -> Bool)
-> (ExtendedObject -> ExtendedObject -> Bool)
-> (ExtendedObject -> ExtendedObject -> Bool)
-> (ExtendedObject -> ExtendedObject -> ExtendedObject)
-> (ExtendedObject -> ExtendedObject -> ExtendedObject)
-> Ord ExtendedObject
ExtendedObject -> ExtendedObject -> Bool
ExtendedObject -> ExtendedObject -> Ordering
ExtendedObject -> ExtendedObject -> ExtendedObject
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: ExtendedObject -> ExtendedObject -> ExtendedObject
\$cmin :: ExtendedObject -> ExtendedObject -> ExtendedObject
max :: ExtendedObject -> ExtendedObject -> ExtendedObject
\$cmax :: ExtendedObject -> ExtendedObject -> ExtendedObject
>= :: ExtendedObject -> ExtendedObject -> Bool
\$c>= :: ExtendedObject -> ExtendedObject -> Bool
> :: ExtendedObject -> ExtendedObject -> Bool
\$c> :: ExtendedObject -> ExtendedObject -> Bool
<= :: ExtendedObject -> ExtendedObject -> Bool
\$c<= :: ExtendedObject -> ExtendedObject -> Bool
< :: ExtendedObject -> ExtendedObject -> Bool
\$c< :: ExtendedObject -> ExtendedObject -> Bool
compare :: ExtendedObject -> ExtendedObject -> Ordering
\$ccompare :: ExtendedObject -> ExtendedObject -> Ordering
\$cp1Ord :: Eq ExtendedObject
Ord, Typeable, Typeable ExtendedObject
Constr
DataType
Typeable ExtendedObject =>
(forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ExtendedObject -> c ExtendedObject)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ExtendedObject)
-> (ExtendedObject -> Constr)
-> (ExtendedObject -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ExtendedObject))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ExtendedObject))
-> ((forall b. Data b => b -> b)
-> ExtendedObject -> ExtendedObject)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ExtendedObject -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ExtendedObject -> r)
-> (forall u.
(forall d. Data d => d -> u) -> ExtendedObject -> [u])
-> (forall u.
Int -> (forall d. Data d => d -> u) -> ExtendedObject -> u)
-> (forall (m :: * -> *).
(forall d. Data d => d -> m d)
-> ExtendedObject -> m ExtendedObject)
-> (forall (m :: * -> *).
(forall d. Data d => d -> m d)
-> ExtendedObject -> m ExtendedObject)
-> (forall (m :: * -> *).
(forall d. Data d => d -> m d)
-> ExtendedObject -> m ExtendedObject)
-> Data ExtendedObject
ExtendedObject -> Constr
ExtendedObject -> DataType
(forall b. Data b => b -> b) -> ExtendedObject -> ExtendedObject
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ExtendedObject -> c ExtendedObject
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ExtendedObject
forall a.
Typeable a =>
(forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
(forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> ExtendedObject -> u
forall u. (forall d. Data d => d -> u) -> ExtendedObject -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ExtendedObject -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ExtendedObject -> r
forall (m :: * -> *).
(forall d. Data d => d -> m d)
-> ExtendedObject -> m ExtendedObject
forall (m :: * -> *).
(forall d. Data d => d -> m d)
-> ExtendedObject -> m ExtendedObject
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ExtendedObject
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ExtendedObject -> c ExtendedObject
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ExtendedObject)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ExtendedObject)
\$cRef :: Constr
\$cPlaced :: Constr
\$tExtendedObject :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> ExtendedObject -> m ExtendedObject
\$cgmapMo :: forall (m :: * -> *).
(forall d. Data d => d -> m d)
-> ExtendedObject -> m ExtendedObject
gmapMp :: (forall d. Data d => d -> m d)
-> ExtendedObject -> m ExtendedObject
\$cgmapMp :: forall (m :: * -> *).
(forall d. Data d => d -> m d)
-> ExtendedObject -> m ExtendedObject
gmapM :: (forall d. Data d => d -> m d)
-> ExtendedObject -> m ExtendedObject
\$cgmapM :: forall (m :: * -> *).
(forall d. Data d => d -> m d)
-> ExtendedObject -> m ExtendedObject
gmapQi :: Int -> (forall d. Data d => d -> u) -> ExtendedObject -> u
\$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> ExtendedObject -> u
gmapQ :: (forall d. Data d => d -> u) -> ExtendedObject -> [u]
\$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ExtendedObject -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ExtendedObject -> r
\$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ExtendedObject -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ExtendedObject -> r
\$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ExtendedObject -> r
gmapT :: (forall b. Data b => b -> b) -> ExtendedObject -> ExtendedObject
\$cgmapT :: (forall b. Data b => b -> b) -> ExtendedObject -> ExtendedObject
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ExtendedObject)
\$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ExtendedObject)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c ExtendedObject)
\$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ExtendedObject)
dataTypeOf :: ExtendedObject -> DataType
\$cdataTypeOf :: ExtendedObject -> DataType
toConstr :: ExtendedObject -> Constr
\$ctoConstr :: ExtendedObject -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ExtendedObject
\$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ExtendedObject
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ExtendedObject -> c ExtendedObject
\$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ExtendedObject -> c ExtendedObject
\$cp1Data :: Typeable ExtendedObject
Data)

data PlacedObject =
PlacedObject {PlacedObject -> Placement
p :: Placement, PlacedObject -> Object
o :: Object}
deriving (Int -> PlacedObject -> ShowS
[PlacedObject] -> ShowS
PlacedObject -> String
(Int -> PlacedObject -> ShowS)
-> (PlacedObject -> String)
-> ([PlacedObject] -> ShowS)
-> Show PlacedObject
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PlacedObject] -> ShowS
\$cshowList :: [PlacedObject] -> ShowS
show :: PlacedObject -> String
\$cshow :: PlacedObject -> String
showsPrec :: Int -> PlacedObject -> ShowS
\$cshowsPrec :: Int -> PlacedObject -> ShowS
Show, PlacedObject -> PlacedObject -> Bool
(PlacedObject -> PlacedObject -> Bool)
-> (PlacedObject -> PlacedObject -> Bool) -> Eq PlacedObject
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PlacedObject -> PlacedObject -> Bool
\$c/= :: PlacedObject -> PlacedObject -> Bool
== :: PlacedObject -> PlacedObject -> Bool
\$c== :: PlacedObject -> PlacedObject -> Bool
Eq, Eq PlacedObject
Eq PlacedObject =>
(PlacedObject -> PlacedObject -> Ordering)
-> (PlacedObject -> PlacedObject -> Bool)
-> (PlacedObject -> PlacedObject -> Bool)
-> (PlacedObject -> PlacedObject -> Bool)
-> (PlacedObject -> PlacedObject -> Bool)
-> (PlacedObject -> PlacedObject -> PlacedObject)
-> (PlacedObject -> PlacedObject -> PlacedObject)
-> Ord PlacedObject
PlacedObject -> PlacedObject -> Bool
PlacedObject -> PlacedObject -> Ordering
PlacedObject -> PlacedObject -> PlacedObject
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: PlacedObject -> PlacedObject -> PlacedObject
\$cmin :: PlacedObject -> PlacedObject -> PlacedObject
max :: PlacedObject -> PlacedObject -> PlacedObject
\$cmax :: PlacedObject -> PlacedObject -> PlacedObject
>= :: PlacedObject -> PlacedObject -> Bool
\$c>= :: PlacedObject -> PlacedObject -> Bool
> :: PlacedObject -> PlacedObject -> Bool
\$c> :: PlacedObject -> PlacedObject -> Bool
<= :: PlacedObject -> PlacedObject -> Bool
\$c<= :: PlacedObject -> PlacedObject -> Bool
< :: PlacedObject -> PlacedObject -> Bool
\$c< :: PlacedObject -> PlacedObject -> Bool
compare :: PlacedObject -> PlacedObject -> Ordering
\$ccompare :: PlacedObject -> PlacedObject -> Ordering
\$cp1Ord :: Eq PlacedObject
Ord, Typeable, Typeable PlacedObject
Constr
DataType
Typeable PlacedObject =>
(forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PlacedObject -> c PlacedObject)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PlacedObject)
-> (PlacedObject -> Constr)
-> (PlacedObject -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PlacedObject))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c PlacedObject))
-> ((forall b. Data b => b -> b) -> PlacedObject -> PlacedObject)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PlacedObject -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PlacedObject -> r)
-> (forall u. (forall d. Data d => d -> u) -> PlacedObject -> [u])
-> (forall u.
Int -> (forall d. Data d => d -> u) -> PlacedObject -> u)
-> (forall (m :: * -> *).
(forall d. Data d => d -> m d) -> PlacedObject -> m PlacedObject)
-> (forall (m :: * -> *).
(forall d. Data d => d -> m d) -> PlacedObject -> m PlacedObject)
-> (forall (m :: * -> *).
(forall d. Data d => d -> m d) -> PlacedObject -> m PlacedObject)
-> Data PlacedObject
PlacedObject -> Constr
PlacedObject -> DataType
(forall b. Data b => b -> b) -> PlacedObject -> PlacedObject
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PlacedObject -> c PlacedObject
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PlacedObject
forall a.
Typeable a =>
(forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
(forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> PlacedObject -> u
forall u. (forall d. Data d => d -> u) -> PlacedObject -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PlacedObject -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PlacedObject -> r
forall (m :: * -> *).
(forall d. Data d => d -> m d) -> PlacedObject -> m PlacedObject
forall (m :: * -> *).
(forall d. Data d => d -> m d) -> PlacedObject -> m PlacedObject
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PlacedObject
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PlacedObject -> c PlacedObject
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PlacedObject)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c PlacedObject)
\$cPlacedObject :: Constr
\$tPlacedObject :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> PlacedObject -> m PlacedObject
\$cgmapMo :: forall (m :: * -> *).
(forall d. Data d => d -> m d) -> PlacedObject -> m PlacedObject
gmapMp :: (forall d. Data d => d -> m d) -> PlacedObject -> m PlacedObject
\$cgmapMp :: forall (m :: * -> *).
(forall d. Data d => d -> m d) -> PlacedObject -> m PlacedObject
gmapM :: (forall d. Data d => d -> m d) -> PlacedObject -> m PlacedObject
\$cgmapM :: forall (m :: * -> *).
(forall d. Data d => d -> m d) -> PlacedObject -> m PlacedObject
gmapQi :: Int -> (forall d. Data d => d -> u) -> PlacedObject -> u
\$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> PlacedObject -> u
gmapQ :: (forall d. Data d => d -> u) -> PlacedObject -> [u]
\$cgmapQ :: forall u. (forall d. Data d => d -> u) -> PlacedObject -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PlacedObject -> r
\$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PlacedObject -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PlacedObject -> r
\$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PlacedObject -> r
gmapT :: (forall b. Data b => b -> b) -> PlacedObject -> PlacedObject
\$cgmapT :: (forall b. Data b => b -> b) -> PlacedObject -> PlacedObject
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c PlacedObject)
\$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c PlacedObject)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c PlacedObject)
\$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PlacedObject)
dataTypeOf :: PlacedObject -> DataType
\$cdataTypeOf :: PlacedObject -> DataType
toConstr :: PlacedObject -> Constr
\$ctoConstr :: PlacedObject -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PlacedObject
\$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PlacedObject
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PlacedObject -> c PlacedObject
\$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PlacedObject -> c PlacedObject
\$cp1Data :: Typeable PlacedObject
Data)

data NamedObject = NamedObject { NamedObject -> String
name :: String
, NamedObject -> PlacedObject
object :: PlacedObject}
| EmptyObject -- for objects that are WIP
deriving (Int -> NamedObject -> ShowS
[NamedObject] -> ShowS
NamedObject -> String
(Int -> NamedObject -> ShowS)
-> (NamedObject -> String)
-> ([NamedObject] -> ShowS)
-> Show NamedObject
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [NamedObject] -> ShowS
\$cshowList :: [NamedObject] -> ShowS
show :: NamedObject -> String
\$cshow :: NamedObject -> String
showsPrec :: Int -> NamedObject -> ShowS
\$cshowsPrec :: Int -> NamedObject -> ShowS
Show, NamedObject -> NamedObject -> Bool
(NamedObject -> NamedObject -> Bool)
-> (NamedObject -> NamedObject -> Bool) -> Eq NamedObject
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NamedObject -> NamedObject -> Bool
\$c/= :: NamedObject -> NamedObject -> Bool
== :: NamedObject -> NamedObject -> Bool
\$c== :: NamedObject -> NamedObject -> Bool
Eq, Eq NamedObject
Eq NamedObject =>
(NamedObject -> NamedObject -> Ordering)
-> (NamedObject -> NamedObject -> Bool)
-> (NamedObject -> NamedObject -> Bool)
-> (NamedObject -> NamedObject -> Bool)
-> (NamedObject -> NamedObject -> Bool)
-> (NamedObject -> NamedObject -> NamedObject)
-> (NamedObject -> NamedObject -> NamedObject)
-> Ord NamedObject
NamedObject -> NamedObject -> Bool
NamedObject -> NamedObject -> Ordering
NamedObject -> NamedObject -> NamedObject
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: NamedObject -> NamedObject -> NamedObject
\$cmin :: NamedObject -> NamedObject -> NamedObject
max :: NamedObject -> NamedObject -> NamedObject
\$cmax :: NamedObject -> NamedObject -> NamedObject
>= :: NamedObject -> NamedObject -> Bool
\$c>= :: NamedObject -> NamedObject -> Bool
> :: NamedObject -> NamedObject -> Bool
\$c> :: NamedObject -> NamedObject -> Bool
<= :: NamedObject -> NamedObject -> Bool
\$c<= :: NamedObject -> NamedObject -> Bool
< :: NamedObject -> NamedObject -> Bool
\$c< :: NamedObject -> NamedObject -> Bool
compare :: NamedObject -> NamedObject -> Ordering
\$ccompare :: NamedObject -> NamedObject -> Ordering
\$cp1Ord :: Eq NamedObject
Ord, Typeable, Typeable NamedObject
Constr
DataType
Typeable NamedObject =>
(forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NamedObject -> c NamedObject)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NamedObject)
-> (NamedObject -> Constr)
-> (NamedObject -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NamedObject))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c NamedObject))
-> ((forall b. Data b => b -> b) -> NamedObject -> NamedObject)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NamedObject -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NamedObject -> r)
-> (forall u. (forall d. Data d => d -> u) -> NamedObject -> [u])
-> (forall u.
Int -> (forall d. Data d => d -> u) -> NamedObject -> u)
-> (forall (m :: * -> *).
(forall d. Data d => d -> m d) -> NamedObject -> m NamedObject)
-> (forall (m :: * -> *).
(forall d. Data d => d -> m d) -> NamedObject -> m NamedObject)
-> (forall (m :: * -> *).
(forall d. Data d => d -> m d) -> NamedObject -> m NamedObject)
-> Data NamedObject
NamedObject -> Constr
NamedObject -> DataType
(forall b. Data b => b -> b) -> NamedObject -> NamedObject
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NamedObject -> c NamedObject
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NamedObject
forall a.
Typeable a =>
(forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
(forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> NamedObject -> u
forall u. (forall d. Data d => d -> u) -> NamedObject -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NamedObject -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NamedObject -> r
forall (m :: * -> *).
(forall d. Data d => d -> m d) -> NamedObject -> m NamedObject
forall (m :: * -> *).
(forall d. Data d => d -> m d) -> NamedObject -> m NamedObject
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NamedObject
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NamedObject -> c NamedObject
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NamedObject)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c NamedObject)
\$cEmptyObject :: Constr
\$cNamedObject :: Constr
\$tNamedObject :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> NamedObject -> m NamedObject
\$cgmapMo :: forall (m :: * -> *).
(forall d. Data d => d -> m d) -> NamedObject -> m NamedObject
gmapMp :: (forall d. Data d => d -> m d) -> NamedObject -> m NamedObject
\$cgmapMp :: forall (m :: * -> *).
(forall d. Data d => d -> m d) -> NamedObject -> m NamedObject
gmapM :: (forall d. Data d => d -> m d) -> NamedObject -> m NamedObject
\$cgmapM :: forall (m :: * -> *).
(forall d. Data d => d -> m d) -> NamedObject -> m NamedObject
gmapQi :: Int -> (forall d. Data d => d -> u) -> NamedObject -> u
\$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NamedObject -> u
gmapQ :: (forall d. Data d => d -> u) -> NamedObject -> [u]
\$cgmapQ :: forall u. (forall d. Data d => d -> u) -> NamedObject -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NamedObject -> r
\$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NamedObject -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NamedObject -> r
\$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NamedObject -> r
gmapT :: (forall b. Data b => b -> b) -> NamedObject -> NamedObject
\$cgmapT :: (forall b. Data b => b -> b) -> NamedObject -> NamedObject
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c NamedObject)
\$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c NamedObject)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c NamedObject)
\$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NamedObject)
dataTypeOf :: NamedObject -> DataType
\$cdataTypeOf :: NamedObject -> DataType
toConstr :: NamedObject -> Constr
\$ctoConstr :: NamedObject -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NamedObject
\$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NamedObject
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NamedObject -> c NamedObject
\$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NamedObject -> c NamedObject
\$cp1Data :: Typeable NamedObject
Data)

{- the first parameter is the name of the object as it is stored in the
FreeCAD document. the second parameter determines the placement of the object
(a pair of vectors) the third parameter contains the type of the object and
a list of doubles (numbers) describing the characteristics
of the object (e.g. dimensions, angles, etc) -}

type Document = [NamedObject]

Signatures are just sets of named objects -}

data Sign = Sign { Sign -> Set NamedObject
objects :: Set.Set NamedObject }
deriving (Int -> Sign -> ShowS
[Sign] -> ShowS
Sign -> String
(Int -> Sign -> ShowS)
-> (Sign -> String) -> ([Sign] -> ShowS) -> Show Sign
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Sign] -> ShowS
\$cshowList :: [Sign] -> ShowS
show :: Sign -> String
\$cshow :: Sign -> String
showsPrec :: Int -> Sign -> ShowS
\$cshowsPrec :: Int -> Sign -> ShowS
Show, Sign -> Sign -> Bool
(Sign -> Sign -> Bool) -> (Sign -> Sign -> Bool) -> Eq Sign
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Sign -> Sign -> Bool
\$c/= :: Sign -> Sign -> Bool
== :: Sign -> Sign -> Bool
\$c== :: Sign -> Sign -> Bool
Eq, Eq Sign
Eq Sign =>
(Sign -> Sign -> Ordering)
-> (Sign -> Sign -> Bool)
-> (Sign -> Sign -> Bool)
-> (Sign -> Sign -> Bool)
-> (Sign -> Sign -> Bool)
-> (Sign -> Sign -> Sign)
-> (Sign -> Sign -> Sign)
-> Ord Sign
Sign -> Sign -> Bool
Sign -> Sign -> Ordering
Sign -> Sign -> Sign
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Sign -> Sign -> Sign
\$cmin :: Sign -> Sign -> Sign
max :: Sign -> Sign -> Sign
\$cmax :: Sign -> Sign -> Sign
>= :: Sign -> Sign -> Bool
\$c>= :: Sign -> Sign -> Bool
> :: Sign -> Sign -> Bool
\$c> :: Sign -> Sign -> Bool
<= :: Sign -> Sign -> Bool
\$c<= :: Sign -> Sign -> Bool
< :: Sign -> Sign -> Bool
\$c< :: Sign -> Sign -> Bool
compare :: Sign -> Sign -> Ordering
\$ccompare :: Sign -> Sign -> Ordering
\$cp1Ord :: Eq Sign
Ord, Typeable, Typeable Sign
Constr
DataType
Typeable Sign =>
(forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Sign -> c Sign)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Sign)
-> (Sign -> Constr)
-> (Sign -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Sign))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Sign))
-> ((forall b. Data b => b -> b) -> Sign -> Sign)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Sign -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Sign -> r)
-> (forall u. (forall d. Data d => d -> u) -> Sign -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Sign -> u)
-> (forall (m :: * -> *).
(forall d. Data d => d -> m d) -> Sign -> m Sign)
-> (forall (m :: * -> *).
(forall d. Data d => d -> m d) -> Sign -> m Sign)
-> (forall (m :: * -> *).
(forall d. Data d => d -> m d) -> Sign -> m Sign)
-> Data Sign
Sign -> Constr
Sign -> DataType
(forall b. Data b => b -> b) -> Sign -> Sign
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Sign -> c Sign
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Sign
forall a.
Typeable a =>
(forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
(forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Sign -> u
forall u. (forall d. Data d => d -> u) -> Sign -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Sign -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Sign -> r
forall (m :: * -> *).
(forall d. Data d => d -> m d) -> Sign -> m Sign
forall (m :: * -> *).
(forall d. Data d => d -> m d) -> Sign -> m Sign
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Sign
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Sign -> c Sign
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Sign)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Sign)
\$cSign :: Constr
\$tSign :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Sign -> m Sign
\$cgmapMo :: forall (m :: * -> *).
(forall d. Data d => d -> m d) -> Sign -> m Sign
gmapMp :: (forall d. Data d => d -> m d) -> Sign -> m Sign
\$cgmapMp :: forall (m :: * -> *).
(forall d. Data d => d -> m d) -> Sign -> m Sign
gmapM :: (forall d. Data d => d -> m d) -> Sign -> m Sign
\$cgmapM :: forall (m :: * -> *).
(forall d. Data d => d -> m d) -> Sign -> m Sign
gmapQi :: Int -> (forall d. Data d => d -> u) -> Sign -> u
\$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Sign -> u
gmapQ :: (forall d. Data d => d -> u) -> Sign -> [u]
\$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Sign -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Sign -> r
\$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Sign -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Sign -> r
\$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Sign -> r
gmapT :: (forall b. Data b => b -> b) -> Sign -> Sign
\$cgmapT :: (forall b. Data b => b -> b) -> Sign -> Sign
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Sign)
\$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Sign)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Sign)
\$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Sign)
dataTypeOf :: Sign -> DataType
\$cdataTypeOf :: Sign -> DataType
toConstr :: Sign -> Constr
\$ctoConstr :: Sign -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Sign
\$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Sign
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Sign -> c Sign
\$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Sign -> c Sign
\$cp1Data :: Typeable Sign
Data)
```