import "JavaBuiltin" as Java
  
importJava "javax.vecmath.Quat4d" where
  // Immutable binding
  data Quat4d
  
  @JavaName "<init>"
  createQuat4d :: Double -> Double -> Double -> Double -> Quat4d
  @JavaName "<init>"
  copyQuat4d :: Quat4d -> Quat4d
  @JavaName "<init>"
  defaultQuat4d :: Quat4d
  
  getX :: Quat4d -> Double
  getY :: Quat4d -> Double
  getZ :: Quat4d -> Double
  getW :: Quat4d -> Double
  
  // Mutable binding
  data MQuat4d
  
  @JavaName "<init>"
  createMQuat4d :: Double -> Double -> Double -> Double -> <Proc> MQuat4d
  @JavaName "<init>"
  copyMQuat4d :: Quat4d -> <Proc> MQuat4d
  @JavaName "<init>"
  defaultMQuat4d :: <Proc> MQuat4d
  
  @JavaName getX
  getXM :: MQuat4d -> <Proc> Double
  @JavaName getY
  getYM :: MQuat4d -> <Proc> Double
  @JavaName getZ
  getZM :: MQuat4d -> <Proc> Double
  @JavaName getW
  getWM:: MQuat4d -> <Proc> Double
  setX :: MQuat4d -> Double -> <Proc> ()
  setY :: MQuat4d -> Double -> <Proc> ()
  setZ :: MQuat4d -> Double -> <Proc> ()
  setW :: MQuat4d -> Double -> <Proc> ()
  
  @JavaName mul
  mulM :: MQuat4d -> Quat4d -> <Proc> ()
  @JavaName mul
  mulM2 :: MQuat4d -> Quat4d -> Quat4d -> <Proc> ()
  
  @JavaName mulInverse
  mulInverseM :: MQuat4d -> Quat4d -> <Proc> ()
  @JavaName mulInverse
  mulInverseM2 :: MQuat4d -> Quat4d -> Quat4d -> <Proc> ()
  
  @JavaName inverse
  inverseM :: MQuat4d -> <Proc> ()
  @JavaName inverse
  inverseM2 :: MQuat4d -> Quat4d -> <Proc> ()
  
  @JavaName normalize
  normalizeM :: MQuat4d -> <Proc> ()
  @JavaName normalize
  normalizeM2 :: MQuat4d -> Quat4d -> <Proc> ()

freeze :: MQuat4d -> <Proc> Quat4d
freeze = Java.unsafeCoerce

// Mapping of mutable operations to immutable ones

@private
applyMOp :: (MQuat4d -> <Proc> ()) -> Quat4d -> Quat4d
applyMOp op x = runProc let
    z = copyMQuat4d x
    op z
    in freeze z

mul :: Quat4d -> Quat4d -> Quat4d
mul x y = applyMOp (flip mulM y) x

mulInverse :: Quat4d -> Quat4d -> Quat4d
mulInverse x y = applyMOp (flip mulInverseM y) x

inverse :: Quat4d -> Quat4d
inverse = applyMOp inverseM

normalize :: Quat4d -> Quat4d
normalize = applyMOp normalizeM