{-# LANGUAGE DeriveDataTypeable #-}
{- |
Module      :  ./FreeCAD/As.hs
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
License     :  GPLv2 or higher, see LICENSE.txt

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

Declaration of the abstract datatypes of FreeCAD terms
-}

module FreeCAD.As where

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 :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Vector3 -> m Vector3)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Vector3 -> m Vector3)
-> (forall (m :: * -> *).
    MonadPlus 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 :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus 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 :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Vector3 -> m Vector3
forall (m :: * -> *).
MonadPlus 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 :: * -> *).
MonadPlus 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 :: * -> *).
MonadPlus 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 :: * -> *).
Monad 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 :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Matrix33 -> m Matrix33)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Matrix33 -> m Matrix33)
-> (forall (m :: * -> *).
    MonadPlus 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 :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus 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 :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Matrix33 -> m Matrix33
forall (m :: * -> *).
MonadPlus 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 :: * -> *).
MonadPlus 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 :: * -> *).
MonadPlus 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 :: * -> *).
Monad 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 :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Vector4 -> m Vector4)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Vector4 -> m Vector4)
-> (forall (m :: * -> *).
    MonadPlus 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 :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus 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 :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Vector4 -> m Vector4
forall (m :: * -> *).
MonadPlus 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 :: * -> *).
MonadPlus 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 :: * -> *).
MonadPlus 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 :: * -> *).
Monad 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 :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Placement -> m Placement)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Placement -> m Placement)
-> (forall (m :: * -> *).
    MonadPlus 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 :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus 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 :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Placement -> m Placement
forall (m :: * -> *).
MonadPlus 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 :: * -> *).
MonadPlus 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 :: * -> *).
MonadPlus 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 :: * -> *).
Monad 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
            | Cone Double Double Double Double -- Angle,Radius1,Radius2,Height
            | Torus Double Double Double Double Double
            -- Angle1, Angle2, Angle3, Radius1, Radius2
            | 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 :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> BaseObject -> m BaseObject)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BaseObject -> m BaseObject)
-> (forall (m :: * -> *).
    MonadPlus 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 :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus 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 :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BaseObject -> m BaseObject
forall (m :: * -> *).
MonadPlus 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 :: * -> *).
MonadPlus 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 :: * -> *).
MonadPlus 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 :: * -> *).
Monad 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 :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Object -> m Object)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Object -> m Object)
-> (forall (m :: * -> *).
    MonadPlus 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 :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus 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 :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Object -> m Object
forall (m :: * -> *).
MonadPlus 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 :: * -> *).
MonadPlus 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 :: * -> *).
MonadPlus 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 :: * -> *).
Monad 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 :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> ExtendedObject -> m ExtendedObject)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ExtendedObject -> m ExtendedObject)
-> (forall (m :: * -> *).
    MonadPlus 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 :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus 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 :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ExtendedObject -> m ExtendedObject
forall (m :: * -> *).
MonadPlus 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 :: * -> *).
MonadPlus 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 :: * -> *).
MonadPlus 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 :: * -> *).
Monad 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 :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> PlacedObject -> m PlacedObject)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PlacedObject -> m PlacedObject)
-> (forall (m :: * -> *).
    MonadPlus 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 :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus 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 :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PlacedObject -> m PlacedObject
forall (m :: * -> *).
MonadPlus 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 :: * -> *).
MonadPlus 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 :: * -> *).
MonadPlus 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 :: * -> *).
Monad 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 :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> NamedObject -> m NamedObject)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NamedObject -> m NamedObject)
-> (forall (m :: * -> *).
    MonadPlus 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 :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus 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 :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NamedObject -> m NamedObject
forall (m :: * -> *).
MonadPlus 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 :: * -> *).
MonadPlus 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 :: * -> *).
MonadPlus 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 :: * -> *).
Monad 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]

{- | Datatype for FreeCAD Signatures
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 :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Sign -> m Sign)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Sign -> m Sign)
-> (forall (m :: * -> *).
    MonadPlus 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 :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus 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 :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Sign -> m Sign
forall (m :: * -> *).
MonadPlus 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 :: * -> *).
MonadPlus 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 :: * -> *).
MonadPlus 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 :: * -> *).
Monad 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)