--------------------------------------------------------------------------------
-- |
-- Module      :  HGeometry.Vector.Type
-- Copyright   :  (C) Frank Staals
-- License     :  see the LICENSE file
-- Maintainer  :  Frank Staals
--
-- D-dimensional Vectors
--
--------------------------------------------------------------------------------
{-# LANGUAGE UndecidableInstances #-}
module HGeometry.Vector.Type
  ( Vector(.., Vector1, Vector2, Vector3, Vector4)
  , HasComponents(..)
  , cross
  ) where

import           Control.DeepSeq
import           Control.Lens
import           Data.Aeson
import           Data.Coerce
import qualified Data.Functor.Apply as Apply
import           Data.Kind (Type)
import qualified Data.List as List
import           Data.Proxy
import           Data.Semigroup.Foldable
import           Data.These
import qualified Data.Vector as Array
-- import           Data.YAML
import           Data.Zip
import           GHC.Generics (Generic)
import           GHC.TypeNats
import           HGeometry.Properties
import qualified Linear.V1 as Linear
import qualified Linear.V2 as Linear
import qualified Linear.V3 as Linear
import qualified Linear.V4 as Linear
import           Prelude hiding (zipWith)

--------------------------------------------------------------------------------

-- | Data type representing d-dimensional vectors storing elements of type r.
data family Vector (d :: Nat) (r :: Type)

type instance Dimension (Vector d r) = d
type instance NumType   (Vector d r) = r
type instance IxValue   (Vector d r) = r
type instance Index     (Vector d r) = Int

--------------------------------------------------------------------------------

{- $setup
>>> import HGeometry.Vector
>>> let myVec2 = Vector2 10 20 :: Vector 2 Int
>>> let myVec3 = Vector3 1 2 3 :: Vector 3 Int
-}

--------------------------------------------------------------------------------

-- | Types that have a 'components' indexed traversal
class HasComponents vector vector' where
  -- | An Indexed Traversal over the components of a vector
  --
  -- >>> myVec3 ^.. components
  -- [1,2,3]
  -- >>> myVec3 ^@.. components
  -- [(0,1),(1,2),(2,3)]
  components :: IndexedTraversal1 Int vector vector' (IxValue vector) (IxValue vector')

--------------------------------------------------------------------------------

newtype instance Vector 1 r = MkVector1 (Linear.V1 r)
  deriving newtype (Vector 1 r -> Vector 1 r -> Bool
(Vector 1 r -> Vector 1 r -> Bool)
-> (Vector 1 r -> Vector 1 r -> Bool) -> Eq (Vector 1 r)
forall r. Eq r => Vector 1 r -> Vector 1 r -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall r. Eq r => Vector 1 r -> Vector 1 r -> Bool
== :: Vector 1 r -> Vector 1 r -> Bool
$c/= :: forall r. Eq r => Vector 1 r -> Vector 1 r -> Bool
/= :: Vector 1 r -> Vector 1 r -> Bool
Eq,Eq (Vector 1 r)
Eq (Vector 1 r) =>
(Vector 1 r -> Vector 1 r -> Ordering)
-> (Vector 1 r -> Vector 1 r -> Bool)
-> (Vector 1 r -> Vector 1 r -> Bool)
-> (Vector 1 r -> Vector 1 r -> Bool)
-> (Vector 1 r -> Vector 1 r -> Bool)
-> (Vector 1 r -> Vector 1 r -> Vector 1 r)
-> (Vector 1 r -> Vector 1 r -> Vector 1 r)
-> Ord (Vector 1 r)
Vector 1 r -> Vector 1 r -> Bool
Vector 1 r -> Vector 1 r -> Ordering
Vector 1 r -> Vector 1 r -> Vector 1 r
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
forall r. Ord r => Eq (Vector 1 r)
forall r. Ord r => Vector 1 r -> Vector 1 r -> Bool
forall r. Ord r => Vector 1 r -> Vector 1 r -> Ordering
forall r. Ord r => Vector 1 r -> Vector 1 r -> Vector 1 r
$ccompare :: forall r. Ord r => Vector 1 r -> Vector 1 r -> Ordering
compare :: Vector 1 r -> Vector 1 r -> Ordering
$c< :: forall r. Ord r => Vector 1 r -> Vector 1 r -> Bool
< :: Vector 1 r -> Vector 1 r -> Bool
$c<= :: forall r. Ord r => Vector 1 r -> Vector 1 r -> Bool
<= :: Vector 1 r -> Vector 1 r -> Bool
$c> :: forall r. Ord r => Vector 1 r -> Vector 1 r -> Bool
> :: Vector 1 r -> Vector 1 r -> Bool
$c>= :: forall r. Ord r => Vector 1 r -> Vector 1 r -> Bool
>= :: Vector 1 r -> Vector 1 r -> Bool
$cmax :: forall r. Ord r => Vector 1 r -> Vector 1 r -> Vector 1 r
max :: Vector 1 r -> Vector 1 r -> Vector 1 r
$cmin :: forall r. Ord r => Vector 1 r -> Vector 1 r -> Vector 1 r
min :: Vector 1 r -> Vector 1 r -> Vector 1 r
Ord,Vector 1 r -> ()
(Vector 1 r -> ()) -> NFData (Vector 1 r)
forall r. NFData r => Vector 1 r -> ()
forall a. (a -> ()) -> NFData a
$crnf :: forall r. NFData r => Vector 1 r -> ()
rnf :: Vector 1 r -> ()
NFData,Foldable (Vector 1)
Foldable (Vector 1) =>
(forall m. Semigroup m => Vector 1 m -> m)
-> (forall m a. Semigroup m => (a -> m) -> Vector 1 a -> m)
-> (forall m a. Semigroup m => (a -> m) -> Vector 1 a -> m)
-> (forall a. Vector 1 a -> NonEmpty a)
-> (forall a. Ord a => Vector 1 a -> a)
-> (forall a. Ord a => Vector 1 a -> a)
-> (forall a. Vector 1 a -> a)
-> (forall a. Vector 1 a -> a)
-> (forall a b. (a -> b) -> (a -> b -> b) -> Vector 1 a -> b)
-> (forall a b. (a -> b) -> (b -> a -> b) -> Vector 1 a -> b)
-> (forall a b. (a -> b) -> (b -> a -> b) -> Vector 1 a -> b)
-> (forall a b. (a -> b) -> (a -> b -> b) -> Vector 1 a -> b)
-> Foldable1 (Vector 1)
forall a. Ord a => Vector 1 a -> a
forall m. Semigroup m => Vector 1 m -> m
forall a. Vector 1 a -> a
forall a. Vector 1 a -> NonEmpty a
forall m a. Semigroup m => (a -> m) -> Vector 1 a -> m
forall a b. (a -> b) -> (a -> b -> b) -> Vector 1 a -> b
forall a b. (a -> b) -> (b -> a -> b) -> Vector 1 a -> b
forall (t :: * -> *).
Foldable t =>
(forall m. Semigroup m => t m -> m)
-> (forall m a. Semigroup m => (a -> m) -> t a -> m)
-> (forall m a. Semigroup m => (a -> m) -> t a -> m)
-> (forall a. t a -> NonEmpty a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. t a -> a)
-> (forall a. t a -> a)
-> (forall a b. (a -> b) -> (a -> b -> b) -> t a -> b)
-> (forall a b. (a -> b) -> (b -> a -> b) -> t a -> b)
-> (forall a b. (a -> b) -> (b -> a -> b) -> t a -> b)
-> (forall a b. (a -> b) -> (a -> b -> b) -> t a -> b)
-> Foldable1 t
$cfold1 :: forall m. Semigroup m => Vector 1 m -> m
fold1 :: forall m. Semigroup m => Vector 1 m -> m
$cfoldMap1 :: forall m a. Semigroup m => (a -> m) -> Vector 1 a -> m
foldMap1 :: forall m a. Semigroup m => (a -> m) -> Vector 1 a -> m
$cfoldMap1' :: forall m a. Semigroup m => (a -> m) -> Vector 1 a -> m
foldMap1' :: forall m a. Semigroup m => (a -> m) -> Vector 1 a -> m
$ctoNonEmpty :: forall a. Vector 1 a -> NonEmpty a
toNonEmpty :: forall a. Vector 1 a -> NonEmpty a
$cmaximum :: forall a. Ord a => Vector 1 a -> a
maximum :: forall a. Ord a => Vector 1 a -> a
$cminimum :: forall a. Ord a => Vector 1 a -> a
minimum :: forall a. Ord a => Vector 1 a -> a
$chead :: forall a. Vector 1 a -> a
head :: forall a. Vector 1 a -> a
$clast :: forall a. Vector 1 a -> a
last :: forall a. Vector 1 a -> a
$cfoldrMap1 :: forall a b. (a -> b) -> (a -> b -> b) -> Vector 1 a -> b
foldrMap1 :: forall a b. (a -> b) -> (a -> b -> b) -> Vector 1 a -> b
$cfoldlMap1' :: forall a b. (a -> b) -> (b -> a -> b) -> Vector 1 a -> b
foldlMap1' :: forall a b. (a -> b) -> (b -> a -> b) -> Vector 1 a -> b
$cfoldlMap1 :: forall a b. (a -> b) -> (b -> a -> b) -> Vector 1 a -> b
foldlMap1 :: forall a b. (a -> b) -> (b -> a -> b) -> Vector 1 a -> b
$cfoldrMap1' :: forall a b. (a -> b) -> (a -> b -> b) -> Vector 1 a -> b
foldrMap1' :: forall a b. (a -> b) -> (a -> b -> b) -> Vector 1 a -> b
Foldable1,Functor (Vector 1)
Functor (Vector 1) =>
(forall a. a -> Vector 1 a)
-> (forall a b. Vector 1 (a -> b) -> Vector 1 a -> Vector 1 b)
-> (forall a b c.
    (a -> b -> c) -> Vector 1 a -> Vector 1 b -> Vector 1 c)
-> (forall a b. Vector 1 a -> Vector 1 b -> Vector 1 b)
-> (forall a b. Vector 1 a -> Vector 1 b -> Vector 1 a)
-> Applicative (Vector 1)
forall a. a -> Vector 1 a
forall a b. Vector 1 a -> Vector 1 b -> Vector 1 a
forall a b. Vector 1 a -> Vector 1 b -> Vector 1 b
forall a b. Vector 1 (a -> b) -> Vector 1 a -> Vector 1 b
forall a b c.
(a -> b -> c) -> Vector 1 a -> Vector 1 b -> Vector 1 c
forall (f :: * -> *).
Functor f =>
(forall a. a -> f a)
-> (forall a b. f (a -> b) -> f a -> f b)
-> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
-> (forall a b. f a -> f b -> f b)
-> (forall a b. f a -> f b -> f a)
-> Applicative f
$cpure :: forall a. a -> Vector 1 a
pure :: forall a. a -> Vector 1 a
$c<*> :: forall a b. Vector 1 (a -> b) -> Vector 1 a -> Vector 1 b
<*> :: forall a b. Vector 1 (a -> b) -> Vector 1 a -> Vector 1 b
$cliftA2 :: forall a b c.
(a -> b -> c) -> Vector 1 a -> Vector 1 b -> Vector 1 c
liftA2 :: forall a b c.
(a -> b -> c) -> Vector 1 a -> Vector 1 b -> Vector 1 c
$c*> :: forall a b. Vector 1 a -> Vector 1 b -> Vector 1 b
*> :: forall a b. Vector 1 a -> Vector 1 b -> Vector 1 b
$c<* :: forall a b. Vector 1 a -> Vector 1 b -> Vector 1 a
<* :: forall a b. Vector 1 a -> Vector 1 b -> Vector 1 a
Applicative)
  deriving (Functor (Vector 1)
Functor (Vector 1) =>
(forall a b. Vector 1 a -> Vector 1 b -> Vector 1 (These a b))
-> (forall a b c.
    (These a b -> c) -> Vector 1 a -> Vector 1 b -> Vector 1 c)
-> Semialign (Vector 1)
forall a b. Vector 1 a -> Vector 1 b -> Vector 1 (These a b)
forall a b c.
(These a b -> c) -> Vector 1 a -> Vector 1 b -> Vector 1 c
forall (f :: * -> *).
Functor f =>
(forall a b. f a -> f b -> f (These a b))
-> (forall a b c. (These a b -> c) -> f a -> f b -> f c)
-> Semialign f
$calign :: forall a b. Vector 1 a -> Vector 1 b -> Vector 1 (These a b)
align :: forall a b. Vector 1 a -> Vector 1 b -> Vector 1 (These a b)
$calignWith :: forall a b c.
(These a b -> c) -> Vector 1 a -> Vector 1 b -> Vector 1 c
alignWith :: forall a b c.
(These a b -> c) -> Vector 1 a -> Vector 1 b -> Vector 1 c
Semialign,Semialign (Vector 1)
Semialign (Vector 1) =>
(forall a b. Vector 1 a -> Vector 1 b -> Vector 1 (a, b))
-> (forall a b c.
    (a -> b -> c) -> Vector 1 a -> Vector 1 b -> Vector 1 c)
-> Zip (Vector 1)
forall a b. Vector 1 a -> Vector 1 b -> Vector 1 (a, b)
forall a b c.
(a -> b -> c) -> Vector 1 a -> Vector 1 b -> Vector 1 c
forall (f :: * -> *).
Semialign f =>
(forall a b. f a -> f b -> f (a, b))
-> (forall a b c. (a -> b -> c) -> f a -> f b -> f c) -> Zip f
$czip :: forall a b. Vector 1 a -> Vector 1 b -> Vector 1 (a, b)
zip :: forall a b. Vector 1 a -> Vector 1 b -> Vector 1 (a, b)
$czipWith :: forall a b c.
(a -> b -> c) -> Vector 1 a -> Vector 1 b -> Vector 1 c
zipWith :: forall a b c.
(a -> b -> c) -> Vector 1 a -> Vector 1 b -> Vector 1 c
Zip) via Identity
  deriving stock ((forall x. Vector 1 r -> Rep (Vector 1 r) x)
-> (forall x. Rep (Vector 1 r) x -> Vector 1 r)
-> Generic (Vector 1 r)
forall x. Rep (Vector 1 r) x -> Vector 1 r
forall x. Vector 1 r -> Rep (Vector 1 r) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall r x. Rep (Vector 1 r) x -> Vector 1 r
forall r x. Vector 1 r -> Rep (Vector 1 r) x
$cfrom :: forall r x. Vector 1 r -> Rep (Vector 1 r) x
from :: forall x. Vector 1 r -> Rep (Vector 1 r) x
$cto :: forall r x. Rep (Vector 1 r) x -> Vector 1 r
to :: forall x. Rep (Vector 1 r) x -> Vector 1 r
Generic,(forall a b. (a -> b) -> Vector 1 a -> Vector 1 b)
-> (forall a b. a -> Vector 1 b -> Vector 1 a)
-> Functor (Vector 1)
forall a b. a -> Vector 1 b -> Vector 1 a
forall a b. (a -> b) -> Vector 1 a -> Vector 1 b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> Vector 1 a -> Vector 1 b
fmap :: forall a b. (a -> b) -> Vector 1 a -> Vector 1 b
$c<$ :: forall a b. a -> Vector 1 b -> Vector 1 a
<$ :: forall a b. a -> Vector 1 b -> Vector 1 a
Functor,(forall m. Monoid m => Vector 1 m -> m)
-> (forall m a. Monoid m => (a -> m) -> Vector 1 a -> m)
-> (forall m a. Monoid m => (a -> m) -> Vector 1 a -> m)
-> (forall a b. (a -> b -> b) -> b -> Vector 1 a -> b)
-> (forall a b. (a -> b -> b) -> b -> Vector 1 a -> b)
-> (forall b a. (b -> a -> b) -> b -> Vector 1 a -> b)
-> (forall b a. (b -> a -> b) -> b -> Vector 1 a -> b)
-> (forall a. (a -> a -> a) -> Vector 1 a -> a)
-> (forall a. (a -> a -> a) -> Vector 1 a -> a)
-> (forall a. Vector 1 a -> [a])
-> (forall a. Vector 1 a -> Bool)
-> (forall a. Vector 1 a -> Int)
-> (forall a. Eq a => a -> Vector 1 a -> Bool)
-> (forall a. Ord a => Vector 1 a -> a)
-> (forall a. Ord a => Vector 1 a -> a)
-> (forall a. Num a => Vector 1 a -> a)
-> (forall a. Num a => Vector 1 a -> a)
-> Foldable (Vector 1)
forall a. Eq a => a -> Vector 1 a -> Bool
forall a. Num a => Vector 1 a -> a
forall a. Ord a => Vector 1 a -> a
forall m. Monoid m => Vector 1 m -> m
forall a. Vector 1 a -> Bool
forall a. Vector 1 a -> Int
forall a. Vector 1 a -> [a]
forall a. (a -> a -> a) -> Vector 1 a -> a
forall m a. Monoid m => (a -> m) -> Vector 1 a -> m
forall b a. (b -> a -> b) -> b -> Vector 1 a -> b
forall a b. (a -> b -> b) -> b -> Vector 1 a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => Vector 1 m -> m
fold :: forall m. Monoid m => Vector 1 m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Vector 1 a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Vector 1 a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Vector 1 a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> Vector 1 a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> Vector 1 a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Vector 1 a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Vector 1 a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Vector 1 a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Vector 1 a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Vector 1 a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Vector 1 a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> Vector 1 a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> Vector 1 a -> a
foldr1 :: forall a. (a -> a -> a) -> Vector 1 a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Vector 1 a -> a
foldl1 :: forall a. (a -> a -> a) -> Vector 1 a -> a
$ctoList :: forall a. Vector 1 a -> [a]
toList :: forall a. Vector 1 a -> [a]
$cnull :: forall a. Vector 1 a -> Bool
null :: forall a. Vector 1 a -> Bool
$clength :: forall a. Vector 1 a -> Int
length :: forall a. Vector 1 a -> Int
$celem :: forall a. Eq a => a -> Vector 1 a -> Bool
elem :: forall a. Eq a => a -> Vector 1 a -> Bool
$cmaximum :: forall a. Ord a => Vector 1 a -> a
maximum :: forall a. Ord a => Vector 1 a -> a
$cminimum :: forall a. Ord a => Vector 1 a -> a
minimum :: forall a. Ord a => Vector 1 a -> a
$csum :: forall a. Num a => Vector 1 a -> a
sum :: forall a. Num a => Vector 1 a -> a
$cproduct :: forall a. Num a => Vector 1 a -> a
product :: forall a. Num a => Vector 1 a -> a
Foldable,Functor (Vector 1)
Foldable (Vector 1)
(Functor (Vector 1), Foldable (Vector 1)) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> Vector 1 a -> f (Vector 1 b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Vector 1 (f a) -> f (Vector 1 a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Vector 1 a -> m (Vector 1 b))
-> (forall (m :: * -> *) a.
    Monad m =>
    Vector 1 (m a) -> m (Vector 1 a))
-> Traversable (Vector 1)
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => Vector 1 (m a) -> m (Vector 1 a)
forall (f :: * -> *) a.
Applicative f =>
Vector 1 (f a) -> f (Vector 1 a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Vector 1 a -> m (Vector 1 b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Vector 1 a -> f (Vector 1 b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Vector 1 a -> f (Vector 1 b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Vector 1 a -> f (Vector 1 b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Vector 1 (f a) -> f (Vector 1 a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Vector 1 (f a) -> f (Vector 1 a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Vector 1 a -> m (Vector 1 b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Vector 1 a -> m (Vector 1 b)
$csequence :: forall (m :: * -> *) a. Monad m => Vector 1 (m a) -> m (Vector 1 a)
sequence :: forall (m :: * -> *) a. Monad m => Vector 1 (m a) -> m (Vector 1 a)
Traversable)

-- | Construct a vector1
pattern Vector1 :: r -> Vector 1 r
pattern $bVector1 :: forall a. a -> Vector 1 a
$mVector1 :: forall {r} {r}. Vector 1 r -> (r -> r) -> ((# #) -> r) -> r
Vector1 x = MkVector1 (Linear.V1 x)
{-# COMPLETE Vector1 #-}

asV1 :: forall r s. Iso (Vector 1 r) (Vector 1 s) (Linear.V1 r) (Linear.V1 s)
asV1 :: forall r s (p :: * -> * -> *) (f :: * -> *).
(Profunctor p, Functor f) =>
p (V1 r) (f (V1 s)) -> p (Vector 1 r) (f (Vector 1 s))
asV1 = (Vector 1 r -> V1 r)
-> (V1 s -> Vector 1 s)
-> Iso (Vector 1 r) (Vector 1 s) (V1 r) (V1 s)
forall s a b t. (s -> a) -> (b -> t) -> Iso s t a b
iso (forall a b. Coercible a b => a -> b
forall a b. Coercible a b => a -> b
coerce @(Vector 1 r) @(Linear.V1 r))
           (forall a b. Coercible a b => a -> b
forall a b. Coercible a b => a -> b
coerce @(Linear.V1 s) @(Vector 1 s))
{-# INLINE asV1 #-}

instance Traversable1 (Vector 1) where
  traverse1 :: forall (f :: * -> *) a b.
Apply f =>
(a -> f b) -> Vector 1 a -> f (Vector 1 b)
traverse1 a -> f b
f (Vector1 a
x) = b -> Vector 1 b
forall a. a -> Vector 1 a
Vector1 (b -> Vector 1 b) -> f b -> f (Vector 1 b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> f b
f a
x
  {-# INLINE traverse1 #-}

instance TraversableWithIndex Int (Vector 1)
instance FoldableWithIndex    Int (Vector 1)
instance FunctorWithIndex     Int (Vector 1)

instance Ixed (Vector 1 r) where
  ix :: Index (Vector 1 r)
-> Traversal' (Vector 1 r) (IxValue (Vector 1 r))
ix Index (Vector 1 r)
i IxValue (Vector 1 r) -> f (IxValue (Vector 1 r))
f v :: Vector 1 r
v@(Vector1 r
x) = case Index (Vector 1 r)
i of
                           Index (Vector 1 r)
0 -> r -> Vector 1 r
forall a. a -> Vector 1 a
Vector1 (r -> Vector 1 r) -> f r -> f (Vector 1 r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IxValue (Vector 1 r) -> f (IxValue (Vector 1 r))
f r
IxValue (Vector 1 r)
x
                           Index (Vector 1 r)
_ -> Vector 1 r -> f (Vector 1 r)
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Vector 1 r
v
  {-# INLINE ix #-}

instance HasComponents (Vector 1 r) (Vector 1 s) where
  components :: IndexedTraversal1
  Int
  (Vector 1 r)
  (Vector 1 s)
  (IxValue (Vector 1 r))
  (IxValue (Vector 1 s))
components = (V1 r -> f (V1 s)) -> Vector 1 r -> f (Vector 1 s)
forall r s (p :: * -> * -> *) (f :: * -> *).
(Profunctor p, Functor f) =>
p (V1 r) (f (V1 s)) -> p (Vector 1 r) (f (Vector 1 s))
asV1 ((V1 r -> f (V1 s)) -> Vector 1 r -> f (Vector 1 s))
-> (p r (f s) -> V1 r -> f (V1 s))
-> p r (f s)
-> Vector 1 r
-> f (Vector 1 s)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. p r (f s) -> V1 r -> f (V1 s)
p (IxValue (V1 r)) (f (IxValue (V1 s))) -> V1 r -> f (V1 s)
forall vector vector'.
HasComponents vector vector' =>
IndexedTraversal1
  Int vector vector' (IxValue vector) (IxValue vector')
IndexedTraversal1
  Int (V1 r) (V1 s) (IxValue (V1 r)) (IxValue (V1 s))
components
  {-# INLINE components #-}


-- instance FromYAML r => FromYAML (Vector 1 r) where
--   -- node pos -> Parser
--   parseYAML node = withSeq "Vector1" f node
--     where
--       f = \case
--         [pos] -> Vector1 <$> parseYAML pos
--         _     -> failAtNode node "expected exactly 1 element"

instance FromJSON r => FromJSON (Vector 1 r) where
  parseJSON :: Value -> Parser (Vector 1 r)
parseJSON = String
-> (Array -> Parser (Vector 1 r)) -> Value -> Parser (Vector 1 r)
forall a. String -> (Array -> Parser a) -> Value -> Parser a
withArray String
"Vector1" ([Value] -> Parser (Vector 1 r)
f ([Value] -> Parser (Vector 1 r))
-> (Array -> [Value]) -> Array -> Parser (Vector 1 r)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Array -> [Value]
forall a. Vector a -> [a]
Array.toList)
    where
      f :: [Value] -> Parser (Vector 1 r)
f = \case
        [Value
x] -> r -> Vector 1 r
forall a. a -> Vector 1 a
Vector1 (r -> Vector 1 r) -> Parser r -> Parser (Vector 1 r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Value -> Parser r
forall a. FromJSON a => Value -> Parser a
parseJSON Value
x
        [Value]
_   -> String -> Parser (Vector 1 r)
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"expected exactly 1 element"

instance Reversing (Vector 1 r) where
  reversing :: Vector 1 r -> Vector 1 r
reversing = Vector 1 r -> Vector 1 r
forall a. a -> a
id

--------------------------------------------------------------------------------

newtype instance Vector 2 r = MkVector2 (Linear.V2 r)
  deriving newtype (Vector 2 r -> Vector 2 r -> Bool
(Vector 2 r -> Vector 2 r -> Bool)
-> (Vector 2 r -> Vector 2 r -> Bool) -> Eq (Vector 2 r)
forall r. Eq r => Vector 2 r -> Vector 2 r -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall r. Eq r => Vector 2 r -> Vector 2 r -> Bool
== :: Vector 2 r -> Vector 2 r -> Bool
$c/= :: forall r. Eq r => Vector 2 r -> Vector 2 r -> Bool
/= :: Vector 2 r -> Vector 2 r -> Bool
Eq,Eq (Vector 2 r)
Eq (Vector 2 r) =>
(Vector 2 r -> Vector 2 r -> Ordering)
-> (Vector 2 r -> Vector 2 r -> Bool)
-> (Vector 2 r -> Vector 2 r -> Bool)
-> (Vector 2 r -> Vector 2 r -> Bool)
-> (Vector 2 r -> Vector 2 r -> Bool)
-> (Vector 2 r -> Vector 2 r -> Vector 2 r)
-> (Vector 2 r -> Vector 2 r -> Vector 2 r)
-> Ord (Vector 2 r)
Vector 2 r -> Vector 2 r -> Bool
Vector 2 r -> Vector 2 r -> Ordering
Vector 2 r -> Vector 2 r -> Vector 2 r
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
forall r. Ord r => Eq (Vector 2 r)
forall r. Ord r => Vector 2 r -> Vector 2 r -> Bool
forall r. Ord r => Vector 2 r -> Vector 2 r -> Ordering
forall r. Ord r => Vector 2 r -> Vector 2 r -> Vector 2 r
$ccompare :: forall r. Ord r => Vector 2 r -> Vector 2 r -> Ordering
compare :: Vector 2 r -> Vector 2 r -> Ordering
$c< :: forall r. Ord r => Vector 2 r -> Vector 2 r -> Bool
< :: Vector 2 r -> Vector 2 r -> Bool
$c<= :: forall r. Ord r => Vector 2 r -> Vector 2 r -> Bool
<= :: Vector 2 r -> Vector 2 r -> Bool
$c> :: forall r. Ord r => Vector 2 r -> Vector 2 r -> Bool
> :: Vector 2 r -> Vector 2 r -> Bool
$c>= :: forall r. Ord r => Vector 2 r -> Vector 2 r -> Bool
>= :: Vector 2 r -> Vector 2 r -> Bool
$cmax :: forall r. Ord r => Vector 2 r -> Vector 2 r -> Vector 2 r
max :: Vector 2 r -> Vector 2 r -> Vector 2 r
$cmin :: forall r. Ord r => Vector 2 r -> Vector 2 r -> Vector 2 r
min :: Vector 2 r -> Vector 2 r -> Vector 2 r
Ord,Vector 2 r -> ()
(Vector 2 r -> ()) -> NFData (Vector 2 r)
forall r. NFData r => Vector 2 r -> ()
forall a. (a -> ()) -> NFData a
$crnf :: forall r. NFData r => Vector 2 r -> ()
rnf :: Vector 2 r -> ()
NFData,Foldable (Vector 2)
Foldable (Vector 2) =>
(forall m. Semigroup m => Vector 2 m -> m)
-> (forall m a. Semigroup m => (a -> m) -> Vector 2 a -> m)
-> (forall m a. Semigroup m => (a -> m) -> Vector 2 a -> m)
-> (forall a. Vector 2 a -> NonEmpty a)
-> (forall a. Ord a => Vector 2 a -> a)
-> (forall a. Ord a => Vector 2 a -> a)
-> (forall a. Vector 2 a -> a)
-> (forall a. Vector 2 a -> a)
-> (forall a b. (a -> b) -> (a -> b -> b) -> Vector 2 a -> b)
-> (forall a b. (a -> b) -> (b -> a -> b) -> Vector 2 a -> b)
-> (forall a b. (a -> b) -> (b -> a -> b) -> Vector 2 a -> b)
-> (forall a b. (a -> b) -> (a -> b -> b) -> Vector 2 a -> b)
-> Foldable1 (Vector 2)
forall a. Ord a => Vector 2 a -> a
forall m. Semigroup m => Vector 2 m -> m
forall a. Vector 2 a -> a
forall a. Vector 2 a -> NonEmpty a
forall m a. Semigroup m => (a -> m) -> Vector 2 a -> m
forall a b. (a -> b) -> (a -> b -> b) -> Vector 2 a -> b
forall a b. (a -> b) -> (b -> a -> b) -> Vector 2 a -> b
forall (t :: * -> *).
Foldable t =>
(forall m. Semigroup m => t m -> m)
-> (forall m a. Semigroup m => (a -> m) -> t a -> m)
-> (forall m a. Semigroup m => (a -> m) -> t a -> m)
-> (forall a. t a -> NonEmpty a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. t a -> a)
-> (forall a. t a -> a)
-> (forall a b. (a -> b) -> (a -> b -> b) -> t a -> b)
-> (forall a b. (a -> b) -> (b -> a -> b) -> t a -> b)
-> (forall a b. (a -> b) -> (b -> a -> b) -> t a -> b)
-> (forall a b. (a -> b) -> (a -> b -> b) -> t a -> b)
-> Foldable1 t
$cfold1 :: forall m. Semigroup m => Vector 2 m -> m
fold1 :: forall m. Semigroup m => Vector 2 m -> m
$cfoldMap1 :: forall m a. Semigroup m => (a -> m) -> Vector 2 a -> m
foldMap1 :: forall m a. Semigroup m => (a -> m) -> Vector 2 a -> m
$cfoldMap1' :: forall m a. Semigroup m => (a -> m) -> Vector 2 a -> m
foldMap1' :: forall m a. Semigroup m => (a -> m) -> Vector 2 a -> m
$ctoNonEmpty :: forall a. Vector 2 a -> NonEmpty a
toNonEmpty :: forall a. Vector 2 a -> NonEmpty a
$cmaximum :: forall a. Ord a => Vector 2 a -> a
maximum :: forall a. Ord a => Vector 2 a -> a
$cminimum :: forall a. Ord a => Vector 2 a -> a
minimum :: forall a. Ord a => Vector 2 a -> a
$chead :: forall a. Vector 2 a -> a
head :: forall a. Vector 2 a -> a
$clast :: forall a. Vector 2 a -> a
last :: forall a. Vector 2 a -> a
$cfoldrMap1 :: forall a b. (a -> b) -> (a -> b -> b) -> Vector 2 a -> b
foldrMap1 :: forall a b. (a -> b) -> (a -> b -> b) -> Vector 2 a -> b
$cfoldlMap1' :: forall a b. (a -> b) -> (b -> a -> b) -> Vector 2 a -> b
foldlMap1' :: forall a b. (a -> b) -> (b -> a -> b) -> Vector 2 a -> b
$cfoldlMap1 :: forall a b. (a -> b) -> (b -> a -> b) -> Vector 2 a -> b
foldlMap1 :: forall a b. (a -> b) -> (b -> a -> b) -> Vector 2 a -> b
$cfoldrMap1' :: forall a b. (a -> b) -> (a -> b -> b) -> Vector 2 a -> b
foldrMap1' :: forall a b. (a -> b) -> (a -> b -> b) -> Vector 2 a -> b
Foldable1,Functor (Vector 2)
Functor (Vector 2) =>
(forall a. a -> Vector 2 a)
-> (forall a b. Vector 2 (a -> b) -> Vector 2 a -> Vector 2 b)
-> (forall a b c.
    (a -> b -> c) -> Vector 2 a -> Vector 2 b -> Vector 2 c)
-> (forall a b. Vector 2 a -> Vector 2 b -> Vector 2 b)
-> (forall a b. Vector 2 a -> Vector 2 b -> Vector 2 a)
-> Applicative (Vector 2)
forall a. a -> Vector 2 a
forall a b. Vector 2 a -> Vector 2 b -> Vector 2 a
forall a b. Vector 2 a -> Vector 2 b -> Vector 2 b
forall a b. Vector 2 (a -> b) -> Vector 2 a -> Vector 2 b
forall a b c.
(a -> b -> c) -> Vector 2 a -> Vector 2 b -> Vector 2 c
forall (f :: * -> *).
Functor f =>
(forall a. a -> f a)
-> (forall a b. f (a -> b) -> f a -> f b)
-> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
-> (forall a b. f a -> f b -> f b)
-> (forall a b. f a -> f b -> f a)
-> Applicative f
$cpure :: forall a. a -> Vector 2 a
pure :: forall a. a -> Vector 2 a
$c<*> :: forall a b. Vector 2 (a -> b) -> Vector 2 a -> Vector 2 b
<*> :: forall a b. Vector 2 (a -> b) -> Vector 2 a -> Vector 2 b
$cliftA2 :: forall a b c.
(a -> b -> c) -> Vector 2 a -> Vector 2 b -> Vector 2 c
liftA2 :: forall a b c.
(a -> b -> c) -> Vector 2 a -> Vector 2 b -> Vector 2 c
$c*> :: forall a b. Vector 2 a -> Vector 2 b -> Vector 2 b
*> :: forall a b. Vector 2 a -> Vector 2 b -> Vector 2 b
$c<* :: forall a b. Vector 2 a -> Vector 2 b -> Vector 2 a
<* :: forall a b. Vector 2 a -> Vector 2 b -> Vector 2 a
Applicative)
  deriving stock ((forall x. Vector 2 r -> Rep (Vector 2 r) x)
-> (forall x. Rep (Vector 2 r) x -> Vector 2 r)
-> Generic (Vector 2 r)
forall x. Rep (Vector 2 r) x -> Vector 2 r
forall x. Vector 2 r -> Rep (Vector 2 r) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall r x. Rep (Vector 2 r) x -> Vector 2 r
forall r x. Vector 2 r -> Rep (Vector 2 r) x
$cfrom :: forall r x. Vector 2 r -> Rep (Vector 2 r) x
from :: forall x. Vector 2 r -> Rep (Vector 2 r) x
$cto :: forall r x. Rep (Vector 2 r) x -> Vector 2 r
to :: forall x. Rep (Vector 2 r) x -> Vector 2 r
Generic,(forall a b. (a -> b) -> Vector 2 a -> Vector 2 b)
-> (forall a b. a -> Vector 2 b -> Vector 2 a)
-> Functor (Vector 2)
forall a b. a -> Vector 2 b -> Vector 2 a
forall a b. (a -> b) -> Vector 2 a -> Vector 2 b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> Vector 2 a -> Vector 2 b
fmap :: forall a b. (a -> b) -> Vector 2 a -> Vector 2 b
$c<$ :: forall a b. a -> Vector 2 b -> Vector 2 a
<$ :: forall a b. a -> Vector 2 b -> Vector 2 a
Functor,(forall m. Monoid m => Vector 2 m -> m)
-> (forall m a. Monoid m => (a -> m) -> Vector 2 a -> m)
-> (forall m a. Monoid m => (a -> m) -> Vector 2 a -> m)
-> (forall a b. (a -> b -> b) -> b -> Vector 2 a -> b)
-> (forall a b. (a -> b -> b) -> b -> Vector 2 a -> b)
-> (forall b a. (b -> a -> b) -> b -> Vector 2 a -> b)
-> (forall b a. (b -> a -> b) -> b -> Vector 2 a -> b)
-> (forall a. (a -> a -> a) -> Vector 2 a -> a)
-> (forall a. (a -> a -> a) -> Vector 2 a -> a)
-> (forall a. Vector 2 a -> [a])
-> (forall a. Vector 2 a -> Bool)
-> (forall a. Vector 2 a -> Int)
-> (forall a. Eq a => a -> Vector 2 a -> Bool)
-> (forall a. Ord a => Vector 2 a -> a)
-> (forall a. Ord a => Vector 2 a -> a)
-> (forall a. Num a => Vector 2 a -> a)
-> (forall a. Num a => Vector 2 a -> a)
-> Foldable (Vector 2)
forall a. Eq a => a -> Vector 2 a -> Bool
forall a. Num a => Vector 2 a -> a
forall a. Ord a => Vector 2 a -> a
forall m. Monoid m => Vector 2 m -> m
forall a. Vector 2 a -> Bool
forall a. Vector 2 a -> Int
forall a. Vector 2 a -> [a]
forall a. (a -> a -> a) -> Vector 2 a -> a
forall m a. Monoid m => (a -> m) -> Vector 2 a -> m
forall b a. (b -> a -> b) -> b -> Vector 2 a -> b
forall a b. (a -> b -> b) -> b -> Vector 2 a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => Vector 2 m -> m
fold :: forall m. Monoid m => Vector 2 m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Vector 2 a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Vector 2 a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Vector 2 a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> Vector 2 a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> Vector 2 a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Vector 2 a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Vector 2 a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Vector 2 a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Vector 2 a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Vector 2 a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Vector 2 a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> Vector 2 a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> Vector 2 a -> a
foldr1 :: forall a. (a -> a -> a) -> Vector 2 a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Vector 2 a -> a
foldl1 :: forall a. (a -> a -> a) -> Vector 2 a -> a
$ctoList :: forall a. Vector 2 a -> [a]
toList :: forall a. Vector 2 a -> [a]
$cnull :: forall a. Vector 2 a -> Bool
null :: forall a. Vector 2 a -> Bool
$clength :: forall a. Vector 2 a -> Int
length :: forall a. Vector 2 a -> Int
$celem :: forall a. Eq a => a -> Vector 2 a -> Bool
elem :: forall a. Eq a => a -> Vector 2 a -> Bool
$cmaximum :: forall a. Ord a => Vector 2 a -> a
maximum :: forall a. Ord a => Vector 2 a -> a
$cminimum :: forall a. Ord a => Vector 2 a -> a
minimum :: forall a. Ord a => Vector 2 a -> a
$csum :: forall a. Num a => Vector 2 a -> a
sum :: forall a. Num a => Vector 2 a -> a
$cproduct :: forall a. Num a => Vector 2 a -> a
product :: forall a. Num a => Vector 2 a -> a
Foldable,Functor (Vector 2)
Foldable (Vector 2)
(Functor (Vector 2), Foldable (Vector 2)) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> Vector 2 a -> f (Vector 2 b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Vector 2 (f a) -> f (Vector 2 a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Vector 2 a -> m (Vector 2 b))
-> (forall (m :: * -> *) a.
    Monad m =>
    Vector 2 (m a) -> m (Vector 2 a))
-> Traversable (Vector 2)
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => Vector 2 (m a) -> m (Vector 2 a)
forall (f :: * -> *) a.
Applicative f =>
Vector 2 (f a) -> f (Vector 2 a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Vector 2 a -> m (Vector 2 b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Vector 2 a -> f (Vector 2 b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Vector 2 a -> f (Vector 2 b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Vector 2 a -> f (Vector 2 b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Vector 2 (f a) -> f (Vector 2 a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Vector 2 (f a) -> f (Vector 2 a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Vector 2 a -> m (Vector 2 b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Vector 2 a -> m (Vector 2 b)
$csequence :: forall (m :: * -> *) a. Monad m => Vector 2 (m a) -> m (Vector 2 a)
sequence :: forall (m :: * -> *) a. Monad m => Vector 2 (m a) -> m (Vector 2 a)
Traversable)

-- | Construct a vector2
pattern Vector2 :: r -> r -> Vector 2 r
pattern $bVector2 :: forall r. r -> r -> Vector 2 r
$mVector2 :: forall {r} {r}. Vector 2 r -> (r -> r -> r) -> ((# #) -> r) -> r
Vector2 x y = MkVector2 (Linear.V2 x y)
{-# COMPLETE Vector2 #-}

asV2 :: forall r s. Iso (Vector 2 r) (Vector 2 s) (Linear.V2 r) (Linear.V2 s)
asV2 :: forall r s (p :: * -> * -> *) (f :: * -> *).
(Profunctor p, Functor f) =>
p (V2 r) (f (V2 s)) -> p (Vector 2 r) (f (Vector 2 s))
asV2 = (Vector 2 r -> V2 r)
-> (V2 s -> Vector 2 s)
-> Iso (Vector 2 r) (Vector 2 s) (V2 r) (V2 s)
forall s a b t. (s -> a) -> (b -> t) -> Iso s t a b
iso (forall a b. Coercible a b => a -> b
forall a b. Coercible a b => a -> b
coerce @(Vector 2 r) @(Linear.V2 r))
           (forall a b. Coercible a b => a -> b
forall a b. Coercible a b => a -> b
coerce @(Linear.V2 s) @(Vector 2 s))
{-# INLINE asV2 #-}

instance Traversable1 (Vector 2) where
  traverse1 :: forall (f :: * -> *) a b.
Apply f =>
(a -> f b) -> Vector 2 a -> f (Vector 2 b)
traverse1 a -> f b
f (Vector2 a
x a
y) = b -> b -> Vector 2 b
forall r. r -> r -> Vector 2 r
Vector2 (b -> b -> Vector 2 b) -> f b -> f (b -> Vector 2 b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> f b
f a
x f (b -> Vector 2 b) -> f b -> f (Vector 2 b)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Apply f => f (a -> b) -> f a -> f b
Apply.<.> a -> f b
f a
y
  {-# INLINE traverse1 #-}

instance TraversableWithIndex Int (Vector 2)
instance FoldableWithIndex    Int (Vector 2)
instance FunctorWithIndex     Int (Vector 2)

instance Ixed (Vector 2 r) where
  ix :: Index (Vector 2 r)
-> Traversal' (Vector 2 r) (IxValue (Vector 2 r))
ix Index (Vector 2 r)
i IxValue (Vector 2 r) -> f (IxValue (Vector 2 r))
f v :: Vector 2 r
v@(Vector2 r
x r
y) = case Index (Vector 2 r)
i of
                             Index (Vector 2 r)
0 -> (r -> r -> Vector 2 r) -> r -> r -> Vector 2 r
forall a b c. (a -> b -> c) -> b -> a -> c
flip r -> r -> Vector 2 r
forall r. r -> r -> Vector 2 r
Vector2 r
y (r -> Vector 2 r) -> f r -> f (Vector 2 r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IxValue (Vector 2 r) -> f (IxValue (Vector 2 r))
f r
IxValue (Vector 2 r)
x
                             Index (Vector 2 r)
1 -> r -> r -> Vector 2 r
forall r. r -> r -> Vector 2 r
Vector2 r
x      (r -> Vector 2 r) -> f r -> f (Vector 2 r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IxValue (Vector 2 r) -> f (IxValue (Vector 2 r))
f r
IxValue (Vector 2 r)
y
                             Index (Vector 2 r)
_ -> Vector 2 r -> f (Vector 2 r)
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Vector 2 r
v
  {-# INLINE ix #-}

instance HasComponents (Vector 2 r) (Vector 2 s) where
  components :: IndexedTraversal1
  Int
  (Vector 2 r)
  (Vector 2 s)
  (IxValue (Vector 2 r))
  (IxValue (Vector 2 s))
components = (V2 r -> f (V2 s)) -> Vector 2 r -> f (Vector 2 s)
forall r s (p :: * -> * -> *) (f :: * -> *).
(Profunctor p, Functor f) =>
p (V2 r) (f (V2 s)) -> p (Vector 2 r) (f (Vector 2 s))
asV2 ((V2 r -> f (V2 s)) -> Vector 2 r -> f (Vector 2 s))
-> (p r (f s) -> V2 r -> f (V2 s))
-> p r (f s)
-> Vector 2 r
-> f (Vector 2 s)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. p r (f s) -> V2 r -> f (V2 s)
p (IxValue (V2 r)) (f (IxValue (V2 s))) -> V2 r -> f (V2 s)
forall vector vector'.
HasComponents vector vector' =>
IndexedTraversal1
  Int vector vector' (IxValue vector) (IxValue vector')
IndexedTraversal1
  Int (V2 r) (V2 s) (IxValue (V2 r)) (IxValue (V2 s))
components
  {-# INLINE components #-}

instance Semialign (Vector 2) where
  align :: forall a b. Vector 2 a -> Vector 2 b -> Vector 2 (These a b)
align = (a -> b -> These a b)
-> Vector 2 a -> Vector 2 b -> Vector 2 (These a b)
forall a b c.
(a -> b -> c) -> Vector 2 a -> Vector 2 b -> Vector 2 c
forall (f :: * -> *) a b c.
Zip f =>
(a -> b -> c) -> f a -> f b -> f c
zipWith a -> b -> These a b
forall a b. a -> b -> These a b
These
  {-# INLINE align #-}
instance Zip (Vector 2) where
  zipWith :: forall a b c.
(a -> b -> c) -> Vector 2 a -> Vector 2 b -> Vector 2 c
zipWith a -> b -> c
f (Vector2 a
x a
y) (Vector2 b
x' b
y') = c -> c -> Vector 2 c
forall r. r -> r -> Vector 2 r
Vector2 (a -> b -> c
f a
x b
x') (a -> b -> c
f a
y b
y')
  {-# INLINE zipWith #-}

-- instance FromYAML r => FromYAML (Vector 2 r) where
--   parseYAML node = withSeq "Vector2" f node
--     where
--       f = \case
--         [posX,posY] -> Vector2 <$> parseYAML posX <*> parseYAML posY
--         _           -> failAtNode node "expected exactly 2 elements"

instance FromJSON r => FromJSON (Vector 2 r) where
  parseJSON :: Value -> Parser (Vector 2 r)
parseJSON = String
-> (Array -> Parser (Vector 2 r)) -> Value -> Parser (Vector 2 r)
forall a. String -> (Array -> Parser a) -> Value -> Parser a
withArray String
"Vector2" ([Value] -> Parser (Vector 2 r)
f ([Value] -> Parser (Vector 2 r))
-> (Array -> [Value]) -> Array -> Parser (Vector 2 r)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Array -> [Value]
forall a. Vector a -> [a]
Array.toList)
    where
      f :: [Value] -> Parser (Vector 2 r)
f = \case
        [Value
x,Value
y] -> r -> r -> Vector 2 r
forall r. r -> r -> Vector 2 r
Vector2 (r -> r -> Vector 2 r) -> Parser r -> Parser (r -> Vector 2 r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Value -> Parser r
forall a. FromJSON a => Value -> Parser a
parseJSON Value
x Parser (r -> Vector 2 r) -> Parser r -> Parser (Vector 2 r)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Value -> Parser r
forall a. FromJSON a => Value -> Parser a
parseJSON Value
y
        [Value]
_     -> String -> Parser (Vector 2 r)
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"expected exactly 2 elements"

instance Reversing (Vector 2 r) where
  reversing :: Vector 2 r -> Vector 2 r
reversing (Vector2 r
x r
y) = r -> r -> Vector 2 r
forall r. r -> r -> Vector 2 r
Vector2 r
y r
x

--------------------------------------------------------------------------------

newtype instance Vector 3 r = MkVector3 (Linear.V3 r)
  deriving newtype (Vector 3 r -> Vector 3 r -> Bool
(Vector 3 r -> Vector 3 r -> Bool)
-> (Vector 3 r -> Vector 3 r -> Bool) -> Eq (Vector 3 r)
forall r. Eq r => Vector 3 r -> Vector 3 r -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall r. Eq r => Vector 3 r -> Vector 3 r -> Bool
== :: Vector 3 r -> Vector 3 r -> Bool
$c/= :: forall r. Eq r => Vector 3 r -> Vector 3 r -> Bool
/= :: Vector 3 r -> Vector 3 r -> Bool
Eq,Eq (Vector 3 r)
Eq (Vector 3 r) =>
(Vector 3 r -> Vector 3 r -> Ordering)
-> (Vector 3 r -> Vector 3 r -> Bool)
-> (Vector 3 r -> Vector 3 r -> Bool)
-> (Vector 3 r -> Vector 3 r -> Bool)
-> (Vector 3 r -> Vector 3 r -> Bool)
-> (Vector 3 r -> Vector 3 r -> Vector 3 r)
-> (Vector 3 r -> Vector 3 r -> Vector 3 r)
-> Ord (Vector 3 r)
Vector 3 r -> Vector 3 r -> Bool
Vector 3 r -> Vector 3 r -> Ordering
Vector 3 r -> Vector 3 r -> Vector 3 r
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
forall r. Ord r => Eq (Vector 3 r)
forall r. Ord r => Vector 3 r -> Vector 3 r -> Bool
forall r. Ord r => Vector 3 r -> Vector 3 r -> Ordering
forall r. Ord r => Vector 3 r -> Vector 3 r -> Vector 3 r
$ccompare :: forall r. Ord r => Vector 3 r -> Vector 3 r -> Ordering
compare :: Vector 3 r -> Vector 3 r -> Ordering
$c< :: forall r. Ord r => Vector 3 r -> Vector 3 r -> Bool
< :: Vector 3 r -> Vector 3 r -> Bool
$c<= :: forall r. Ord r => Vector 3 r -> Vector 3 r -> Bool
<= :: Vector 3 r -> Vector 3 r -> Bool
$c> :: forall r. Ord r => Vector 3 r -> Vector 3 r -> Bool
> :: Vector 3 r -> Vector 3 r -> Bool
$c>= :: forall r. Ord r => Vector 3 r -> Vector 3 r -> Bool
>= :: Vector 3 r -> Vector 3 r -> Bool
$cmax :: forall r. Ord r => Vector 3 r -> Vector 3 r -> Vector 3 r
max :: Vector 3 r -> Vector 3 r -> Vector 3 r
$cmin :: forall r. Ord r => Vector 3 r -> Vector 3 r -> Vector 3 r
min :: Vector 3 r -> Vector 3 r -> Vector 3 r
Ord,Vector 3 r -> ()
(Vector 3 r -> ()) -> NFData (Vector 3 r)
forall r. NFData r => Vector 3 r -> ()
forall a. (a -> ()) -> NFData a
$crnf :: forall r. NFData r => Vector 3 r -> ()
rnf :: Vector 3 r -> ()
NFData,Foldable (Vector 3)
Foldable (Vector 3) =>
(forall m. Semigroup m => Vector 3 m -> m)
-> (forall m a. Semigroup m => (a -> m) -> Vector 3 a -> m)
-> (forall m a. Semigroup m => (a -> m) -> Vector 3 a -> m)
-> (forall a. Vector 3 a -> NonEmpty a)
-> (forall a. Ord a => Vector 3 a -> a)
-> (forall a. Ord a => Vector 3 a -> a)
-> (forall a. Vector 3 a -> a)
-> (forall a. Vector 3 a -> a)
-> (forall a b. (a -> b) -> (a -> b -> b) -> Vector 3 a -> b)
-> (forall a b. (a -> b) -> (b -> a -> b) -> Vector 3 a -> b)
-> (forall a b. (a -> b) -> (b -> a -> b) -> Vector 3 a -> b)
-> (forall a b. (a -> b) -> (a -> b -> b) -> Vector 3 a -> b)
-> Foldable1 (Vector 3)
forall a. Ord a => Vector 3 a -> a
forall m. Semigroup m => Vector 3 m -> m
forall a. Vector 3 a -> a
forall a. Vector 3 a -> NonEmpty a
forall m a. Semigroup m => (a -> m) -> Vector 3 a -> m
forall a b. (a -> b) -> (a -> b -> b) -> Vector 3 a -> b
forall a b. (a -> b) -> (b -> a -> b) -> Vector 3 a -> b
forall (t :: * -> *).
Foldable t =>
(forall m. Semigroup m => t m -> m)
-> (forall m a. Semigroup m => (a -> m) -> t a -> m)
-> (forall m a. Semigroup m => (a -> m) -> t a -> m)
-> (forall a. t a -> NonEmpty a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. t a -> a)
-> (forall a. t a -> a)
-> (forall a b. (a -> b) -> (a -> b -> b) -> t a -> b)
-> (forall a b. (a -> b) -> (b -> a -> b) -> t a -> b)
-> (forall a b. (a -> b) -> (b -> a -> b) -> t a -> b)
-> (forall a b. (a -> b) -> (a -> b -> b) -> t a -> b)
-> Foldable1 t
$cfold1 :: forall m. Semigroup m => Vector 3 m -> m
fold1 :: forall m. Semigroup m => Vector 3 m -> m
$cfoldMap1 :: forall m a. Semigroup m => (a -> m) -> Vector 3 a -> m
foldMap1 :: forall m a. Semigroup m => (a -> m) -> Vector 3 a -> m
$cfoldMap1' :: forall m a. Semigroup m => (a -> m) -> Vector 3 a -> m
foldMap1' :: forall m a. Semigroup m => (a -> m) -> Vector 3 a -> m
$ctoNonEmpty :: forall a. Vector 3 a -> NonEmpty a
toNonEmpty :: forall a. Vector 3 a -> NonEmpty a
$cmaximum :: forall a. Ord a => Vector 3 a -> a
maximum :: forall a. Ord a => Vector 3 a -> a
$cminimum :: forall a. Ord a => Vector 3 a -> a
minimum :: forall a. Ord a => Vector 3 a -> a
$chead :: forall a. Vector 3 a -> a
head :: forall a. Vector 3 a -> a
$clast :: forall a. Vector 3 a -> a
last :: forall a. Vector 3 a -> a
$cfoldrMap1 :: forall a b. (a -> b) -> (a -> b -> b) -> Vector 3 a -> b
foldrMap1 :: forall a b. (a -> b) -> (a -> b -> b) -> Vector 3 a -> b
$cfoldlMap1' :: forall a b. (a -> b) -> (b -> a -> b) -> Vector 3 a -> b
foldlMap1' :: forall a b. (a -> b) -> (b -> a -> b) -> Vector 3 a -> b
$cfoldlMap1 :: forall a b. (a -> b) -> (b -> a -> b) -> Vector 3 a -> b
foldlMap1 :: forall a b. (a -> b) -> (b -> a -> b) -> Vector 3 a -> b
$cfoldrMap1' :: forall a b. (a -> b) -> (a -> b -> b) -> Vector 3 a -> b
foldrMap1' :: forall a b. (a -> b) -> (a -> b -> b) -> Vector 3 a -> b
Foldable1,Functor (Vector 3)
Functor (Vector 3) =>
(forall a. a -> Vector 3 a)
-> (forall a b. Vector 3 (a -> b) -> Vector 3 a -> Vector 3 b)
-> (forall a b c.
    (a -> b -> c) -> Vector 3 a -> Vector 3 b -> Vector 3 c)
-> (forall a b. Vector 3 a -> Vector 3 b -> Vector 3 b)
-> (forall a b. Vector 3 a -> Vector 3 b -> Vector 3 a)
-> Applicative (Vector 3)
forall a. a -> Vector 3 a
forall a b. Vector 3 a -> Vector 3 b -> Vector 3 a
forall a b. Vector 3 a -> Vector 3 b -> Vector 3 b
forall a b. Vector 3 (a -> b) -> Vector 3 a -> Vector 3 b
forall a b c.
(a -> b -> c) -> Vector 3 a -> Vector 3 b -> Vector 3 c
forall (f :: * -> *).
Functor f =>
(forall a. a -> f a)
-> (forall a b. f (a -> b) -> f a -> f b)
-> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
-> (forall a b. f a -> f b -> f b)
-> (forall a b. f a -> f b -> f a)
-> Applicative f
$cpure :: forall a. a -> Vector 3 a
pure :: forall a. a -> Vector 3 a
$c<*> :: forall a b. Vector 3 (a -> b) -> Vector 3 a -> Vector 3 b
<*> :: forall a b. Vector 3 (a -> b) -> Vector 3 a -> Vector 3 b
$cliftA2 :: forall a b c.
(a -> b -> c) -> Vector 3 a -> Vector 3 b -> Vector 3 c
liftA2 :: forall a b c.
(a -> b -> c) -> Vector 3 a -> Vector 3 b -> Vector 3 c
$c*> :: forall a b. Vector 3 a -> Vector 3 b -> Vector 3 b
*> :: forall a b. Vector 3 a -> Vector 3 b -> Vector 3 b
$c<* :: forall a b. Vector 3 a -> Vector 3 b -> Vector 3 a
<* :: forall a b. Vector 3 a -> Vector 3 b -> Vector 3 a
Applicative)
  deriving stock ((forall x. Vector 3 r -> Rep (Vector 3 r) x)
-> (forall x. Rep (Vector 3 r) x -> Vector 3 r)
-> Generic (Vector 3 r)
forall x. Rep (Vector 3 r) x -> Vector 3 r
forall x. Vector 3 r -> Rep (Vector 3 r) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall r x. Rep (Vector 3 r) x -> Vector 3 r
forall r x. Vector 3 r -> Rep (Vector 3 r) x
$cfrom :: forall r x. Vector 3 r -> Rep (Vector 3 r) x
from :: forall x. Vector 3 r -> Rep (Vector 3 r) x
$cto :: forall r x. Rep (Vector 3 r) x -> Vector 3 r
to :: forall x. Rep (Vector 3 r) x -> Vector 3 r
Generic,(forall a b. (a -> b) -> Vector 3 a -> Vector 3 b)
-> (forall a b. a -> Vector 3 b -> Vector 3 a)
-> Functor (Vector 3)
forall a b. a -> Vector 3 b -> Vector 3 a
forall a b. (a -> b) -> Vector 3 a -> Vector 3 b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> Vector 3 a -> Vector 3 b
fmap :: forall a b. (a -> b) -> Vector 3 a -> Vector 3 b
$c<$ :: forall a b. a -> Vector 3 b -> Vector 3 a
<$ :: forall a b. a -> Vector 3 b -> Vector 3 a
Functor,(forall m. Monoid m => Vector 3 m -> m)
-> (forall m a. Monoid m => (a -> m) -> Vector 3 a -> m)
-> (forall m a. Monoid m => (a -> m) -> Vector 3 a -> m)
-> (forall a b. (a -> b -> b) -> b -> Vector 3 a -> b)
-> (forall a b. (a -> b -> b) -> b -> Vector 3 a -> b)
-> (forall b a. (b -> a -> b) -> b -> Vector 3 a -> b)
-> (forall b a. (b -> a -> b) -> b -> Vector 3 a -> b)
-> (forall a. (a -> a -> a) -> Vector 3 a -> a)
-> (forall a. (a -> a -> a) -> Vector 3 a -> a)
-> (forall a. Vector 3 a -> [a])
-> (forall a. Vector 3 a -> Bool)
-> (forall a. Vector 3 a -> Int)
-> (forall a. Eq a => a -> Vector 3 a -> Bool)
-> (forall a. Ord a => Vector 3 a -> a)
-> (forall a. Ord a => Vector 3 a -> a)
-> (forall a. Num a => Vector 3 a -> a)
-> (forall a. Num a => Vector 3 a -> a)
-> Foldable (Vector 3)
forall a. Eq a => a -> Vector 3 a -> Bool
forall a. Num a => Vector 3 a -> a
forall a. Ord a => Vector 3 a -> a
forall m. Monoid m => Vector 3 m -> m
forall a. Vector 3 a -> Bool
forall a. Vector 3 a -> Int
forall a. Vector 3 a -> [a]
forall a. (a -> a -> a) -> Vector 3 a -> a
forall m a. Monoid m => (a -> m) -> Vector 3 a -> m
forall b a. (b -> a -> b) -> b -> Vector 3 a -> b
forall a b. (a -> b -> b) -> b -> Vector 3 a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => Vector 3 m -> m
fold :: forall m. Monoid m => Vector 3 m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Vector 3 a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Vector 3 a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Vector 3 a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> Vector 3 a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> Vector 3 a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Vector 3 a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Vector 3 a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Vector 3 a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Vector 3 a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Vector 3 a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Vector 3 a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> Vector 3 a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> Vector 3 a -> a
foldr1 :: forall a. (a -> a -> a) -> Vector 3 a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Vector 3 a -> a
foldl1 :: forall a. (a -> a -> a) -> Vector 3 a -> a
$ctoList :: forall a. Vector 3 a -> [a]
toList :: forall a. Vector 3 a -> [a]
$cnull :: forall a. Vector 3 a -> Bool
null :: forall a. Vector 3 a -> Bool
$clength :: forall a. Vector 3 a -> Int
length :: forall a. Vector 3 a -> Int
$celem :: forall a. Eq a => a -> Vector 3 a -> Bool
elem :: forall a. Eq a => a -> Vector 3 a -> Bool
$cmaximum :: forall a. Ord a => Vector 3 a -> a
maximum :: forall a. Ord a => Vector 3 a -> a
$cminimum :: forall a. Ord a => Vector 3 a -> a
minimum :: forall a. Ord a => Vector 3 a -> a
$csum :: forall a. Num a => Vector 3 a -> a
sum :: forall a. Num a => Vector 3 a -> a
$cproduct :: forall a. Num a => Vector 3 a -> a
product :: forall a. Num a => Vector 3 a -> a
Foldable,Functor (Vector 3)
Foldable (Vector 3)
(Functor (Vector 3), Foldable (Vector 3)) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> Vector 3 a -> f (Vector 3 b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Vector 3 (f a) -> f (Vector 3 a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Vector 3 a -> m (Vector 3 b))
-> (forall (m :: * -> *) a.
    Monad m =>
    Vector 3 (m a) -> m (Vector 3 a))
-> Traversable (Vector 3)
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => Vector 3 (m a) -> m (Vector 3 a)
forall (f :: * -> *) a.
Applicative f =>
Vector 3 (f a) -> f (Vector 3 a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Vector 3 a -> m (Vector 3 b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Vector 3 a -> f (Vector 3 b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Vector 3 a -> f (Vector 3 b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Vector 3 a -> f (Vector 3 b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Vector 3 (f a) -> f (Vector 3 a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Vector 3 (f a) -> f (Vector 3 a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Vector 3 a -> m (Vector 3 b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Vector 3 a -> m (Vector 3 b)
$csequence :: forall (m :: * -> *) a. Monad m => Vector 3 (m a) -> m (Vector 3 a)
sequence :: forall (m :: * -> *) a. Monad m => Vector 3 (m a) -> m (Vector 3 a)
Traversable)

-- | Construct a vector3
pattern Vector3       :: r -> r -> r -> Vector 3 r
pattern $bVector3 :: forall r. r -> r -> r -> Vector 3 r
$mVector3 :: forall {r} {r}.
Vector 3 r -> (r -> r -> r -> r) -> ((# #) -> r) -> r
Vector3 x y z = MkVector3 (Linear.V3 x y z)
{-# COMPLETE Vector3 #-}

asV3 :: forall r s. Iso (Vector 3 r) (Vector 3 s) (Linear.V3 r) (Linear.V3 s)
asV3 :: forall r s (p :: * -> * -> *) (f :: * -> *).
(Profunctor p, Functor f) =>
p (V3 r) (f (V3 s)) -> p (Vector 3 r) (f (Vector 3 s))
asV3 = (Vector 3 r -> V3 r)
-> (V3 s -> Vector 3 s)
-> Iso (Vector 3 r) (Vector 3 s) (V3 r) (V3 s)
forall s a b t. (s -> a) -> (b -> t) -> Iso s t a b
iso (forall a b. Coercible a b => a -> b
forall a b. Coercible a b => a -> b
coerce @(Vector 3 r) @(Linear.V3 r))
           (forall a b. Coercible a b => a -> b
forall a b. Coercible a b => a -> b
coerce @(Linear.V3 s) @(Vector 3 s))
{-# INLINE asV3 #-}

instance Traversable1 (Vector 3) where
  traverse1 :: forall (f :: * -> *) a b.
Apply f =>
(a -> f b) -> Vector 3 a -> f (Vector 3 b)
traverse1 a -> f b
f (Vector3 a
x a
y a
z) = b -> b -> b -> Vector 3 b
forall r. r -> r -> r -> Vector 3 r
Vector3 (b -> b -> b -> Vector 3 b) -> f b -> f (b -> b -> Vector 3 b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> f b
f a
x f (b -> b -> Vector 3 b) -> f b -> f (b -> Vector 3 b)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Apply f => f (a -> b) -> f a -> f b
Apply.<.> a -> f b
f a
y f (b -> Vector 3 b) -> f b -> f (Vector 3 b)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Apply f => f (a -> b) -> f a -> f b
Apply.<.> a -> f b
f a
z
  {-# INLINE traverse1 #-}

instance TraversableWithIndex Int (Vector 3)
instance FoldableWithIndex    Int (Vector 3)
instance FunctorWithIndex     Int (Vector 3)

instance Ixed (Vector 3 r) where
  ix :: Index (Vector 3 r)
-> Traversal' (Vector 3 r) (IxValue (Vector 3 r))
ix Index (Vector 3 r)
i IxValue (Vector 3 r) -> f (IxValue (Vector 3 r))
f v :: Vector 3 r
v@(Vector3 r
x r
y r
z) = case Index (Vector 3 r)
i of
                               Index (Vector 3 r)
0 -> (\r
x' -> r -> r -> r -> Vector 3 r
forall r. r -> r -> r -> Vector 3 r
Vector3 r
x' r
y r
z) (r -> Vector 3 r) -> f r -> f (Vector 3 r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IxValue (Vector 3 r) -> f (IxValue (Vector 3 r))
f r
IxValue (Vector 3 r)
x
                               Index (Vector 3 r)
1 -> (\r
y' -> r -> r -> r -> Vector 3 r
forall r. r -> r -> r -> Vector 3 r
Vector3 r
x r
y' r
z) (r -> Vector 3 r) -> f r -> f (Vector 3 r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IxValue (Vector 3 r) -> f (IxValue (Vector 3 r))
f r
IxValue (Vector 3 r)
y
                               Index (Vector 3 r)
2 -> (\r
z' -> r -> r -> r -> Vector 3 r
forall r. r -> r -> r -> Vector 3 r
Vector3 r
x r
y r
z') (r -> Vector 3 r) -> f r -> f (Vector 3 r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IxValue (Vector 3 r) -> f (IxValue (Vector 3 r))
f r
IxValue (Vector 3 r)
z
                               Index (Vector 3 r)
_ -> Vector 3 r -> f (Vector 3 r)
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Vector 3 r
v
  {-# INLINE ix #-}

instance HasComponents (Vector 3 r) (Vector 3 s) where
  components :: IndexedTraversal1
  Int
  (Vector 3 r)
  (Vector 3 s)
  (IxValue (Vector 3 r))
  (IxValue (Vector 3 s))
components = (V3 r -> f (V3 s)) -> Vector 3 r -> f (Vector 3 s)
forall r s (p :: * -> * -> *) (f :: * -> *).
(Profunctor p, Functor f) =>
p (V3 r) (f (V3 s)) -> p (Vector 3 r) (f (Vector 3 s))
asV3 ((V3 r -> f (V3 s)) -> Vector 3 r -> f (Vector 3 s))
-> (p r (f s) -> V3 r -> f (V3 s))
-> p r (f s)
-> Vector 3 r
-> f (Vector 3 s)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. p r (f s) -> V3 r -> f (V3 s)
p (IxValue (V3 r)) (f (IxValue (V3 s))) -> V3 r -> f (V3 s)
forall vector vector'.
HasComponents vector vector' =>
IndexedTraversal1
  Int vector vector' (IxValue vector) (IxValue vector')
IndexedTraversal1
  Int (V3 r) (V3 s) (IxValue (V3 r)) (IxValue (V3 s))
components
  {-# INLINE components #-}

instance Semialign (Vector 3) where
  align :: forall a b. Vector 3 a -> Vector 3 b -> Vector 3 (These a b)
align = (a -> b -> These a b)
-> Vector 3 a -> Vector 3 b -> Vector 3 (These a b)
forall a b c.
(a -> b -> c) -> Vector 3 a -> Vector 3 b -> Vector 3 c
forall (f :: * -> *) a b c.
Zip f =>
(a -> b -> c) -> f a -> f b -> f c
zipWith a -> b -> These a b
forall a b. a -> b -> These a b
These
  {-# INLINE align #-}
instance Zip (Vector 3) where
  zipWith :: forall a b c.
(a -> b -> c) -> Vector 3 a -> Vector 3 b -> Vector 3 c
zipWith a -> b -> c
f (Vector3 a
x a
y a
z) (Vector3 b
x' b
y' b
z') = c -> c -> c -> Vector 3 c
forall r. r -> r -> r -> Vector 3 r
Vector3 (a -> b -> c
f a
x b
x') (a -> b -> c
f a
y b
y') (a -> b -> c
f a
z b
z')
  {-# INLINE zipWith #-}

-- instance FromYAML r => FromYAML (Vector 3 r) where
--   -- node pos -> Parser
--   parseYAML node = withSeq "Vector3" f node
--     where
--       f = \case
--         [posX,posY,posZ] -> Vector3 <$> parseYAML posX <*> parseYAML posY <*> parseYAML posZ
--         _                -> failAtNode node "expected exactly 3 elements"

instance FromJSON r => FromJSON (Vector 3 r) where
  parseJSON :: Value -> Parser (Vector 3 r)
parseJSON = String
-> (Array -> Parser (Vector 3 r)) -> Value -> Parser (Vector 3 r)
forall a. String -> (Array -> Parser a) -> Value -> Parser a
withArray String
"Vector3" ([Value] -> Parser (Vector 3 r)
f ([Value] -> Parser (Vector 3 r))
-> (Array -> [Value]) -> Array -> Parser (Vector 3 r)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Array -> [Value]
forall a. Vector a -> [a]
Array.toList)
    where
      f :: [Value] -> Parser (Vector 3 r)
f = \case
        [Value
x,Value
y,Value
z] -> r -> r -> r -> Vector 3 r
forall r. r -> r -> r -> Vector 3 r
Vector3 (r -> r -> r -> Vector 3 r)
-> Parser r -> Parser (r -> r -> Vector 3 r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Value -> Parser r
forall a. FromJSON a => Value -> Parser a
parseJSON Value
x Parser (r -> r -> Vector 3 r)
-> Parser r -> Parser (r -> Vector 3 r)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Value -> Parser r
forall a. FromJSON a => Value -> Parser a
parseJSON Value
y Parser (r -> Vector 3 r) -> Parser r -> Parser (Vector 3 r)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Value -> Parser r
forall a. FromJSON a => Value -> Parser a
parseJSON Value
z
        [Value]
_       -> String -> Parser (Vector 3 r)
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"expected exactly 3 elements"

instance Reversing (Vector 3 r) where
  reversing :: Vector 3 r -> Vector 3 r
reversing (Vector3 r
x r
y r
z) = r -> r -> r -> Vector 3 r
forall r. r -> r -> r -> Vector 3 r
Vector3 r
z r
y r
x


-- | cross product
cross                            :: Num r
                                  => Vector 3 r -> Vector 3 r -> Vector 3 r
cross :: forall r. Num r => Vector 3 r -> Vector 3 r -> Vector 3 r
cross (MkVector3 V3 r
u) (MkVector3 V3 r
v) = V3 r -> Vector 3 r
forall r. V3 r -> Vector 3 r
MkVector3 (V3 r -> Vector 3 r) -> V3 r -> Vector 3 r
forall a b. (a -> b) -> a -> b
$ V3 r -> V3 r -> V3 r
forall a. Num a => V3 a -> V3 a -> V3 a
Linear.cross V3 r
u V3 r
v
{-# INLINE cross #-}

--------------------------------------------------------------------------------

newtype instance Vector 4 r = MkVector4 (Linear.V4 r)
  deriving newtype (Vector 4 r -> Vector 4 r -> Bool
(Vector 4 r -> Vector 4 r -> Bool)
-> (Vector 4 r -> Vector 4 r -> Bool) -> Eq (Vector 4 r)
forall r. Eq r => Vector 4 r -> Vector 4 r -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall r. Eq r => Vector 4 r -> Vector 4 r -> Bool
== :: Vector 4 r -> Vector 4 r -> Bool
$c/= :: forall r. Eq r => Vector 4 r -> Vector 4 r -> Bool
/= :: Vector 4 r -> Vector 4 r -> Bool
Eq,Eq (Vector 4 r)
Eq (Vector 4 r) =>
(Vector 4 r -> Vector 4 r -> Ordering)
-> (Vector 4 r -> Vector 4 r -> Bool)
-> (Vector 4 r -> Vector 4 r -> Bool)
-> (Vector 4 r -> Vector 4 r -> Bool)
-> (Vector 4 r -> Vector 4 r -> Bool)
-> (Vector 4 r -> Vector 4 r -> Vector 4 r)
-> (Vector 4 r -> Vector 4 r -> Vector 4 r)
-> Ord (Vector 4 r)
Vector 4 r -> Vector 4 r -> Bool
Vector 4 r -> Vector 4 r -> Ordering
Vector 4 r -> Vector 4 r -> Vector 4 r
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
forall r. Ord r => Eq (Vector 4 r)
forall r. Ord r => Vector 4 r -> Vector 4 r -> Bool
forall r. Ord r => Vector 4 r -> Vector 4 r -> Ordering
forall r. Ord r => Vector 4 r -> Vector 4 r -> Vector 4 r
$ccompare :: forall r. Ord r => Vector 4 r -> Vector 4 r -> Ordering
compare :: Vector 4 r -> Vector 4 r -> Ordering
$c< :: forall r. Ord r => Vector 4 r -> Vector 4 r -> Bool
< :: Vector 4 r -> Vector 4 r -> Bool
$c<= :: forall r. Ord r => Vector 4 r -> Vector 4 r -> Bool
<= :: Vector 4 r -> Vector 4 r -> Bool
$c> :: forall r. Ord r => Vector 4 r -> Vector 4 r -> Bool
> :: Vector 4 r -> Vector 4 r -> Bool
$c>= :: forall r. Ord r => Vector 4 r -> Vector 4 r -> Bool
>= :: Vector 4 r -> Vector 4 r -> Bool
$cmax :: forall r. Ord r => Vector 4 r -> Vector 4 r -> Vector 4 r
max :: Vector 4 r -> Vector 4 r -> Vector 4 r
$cmin :: forall r. Ord r => Vector 4 r -> Vector 4 r -> Vector 4 r
min :: Vector 4 r -> Vector 4 r -> Vector 4 r
Ord,Vector 4 r -> ()
(Vector 4 r -> ()) -> NFData (Vector 4 r)
forall r. NFData r => Vector 4 r -> ()
forall a. (a -> ()) -> NFData a
$crnf :: forall r. NFData r => Vector 4 r -> ()
rnf :: Vector 4 r -> ()
NFData,Foldable (Vector 4)
Foldable (Vector 4) =>
(forall m. Semigroup m => Vector 4 m -> m)
-> (forall m a. Semigroup m => (a -> m) -> Vector 4 a -> m)
-> (forall m a. Semigroup m => (a -> m) -> Vector 4 a -> m)
-> (forall a. Vector 4 a -> NonEmpty a)
-> (forall a. Ord a => Vector 4 a -> a)
-> (forall a. Ord a => Vector 4 a -> a)
-> (forall a. Vector 4 a -> a)
-> (forall a. Vector 4 a -> a)
-> (forall a b. (a -> b) -> (a -> b -> b) -> Vector 4 a -> b)
-> (forall a b. (a -> b) -> (b -> a -> b) -> Vector 4 a -> b)
-> (forall a b. (a -> b) -> (b -> a -> b) -> Vector 4 a -> b)
-> (forall a b. (a -> b) -> (a -> b -> b) -> Vector 4 a -> b)
-> Foldable1 (Vector 4)
forall a. Ord a => Vector 4 a -> a
forall m. Semigroup m => Vector 4 m -> m
forall a. Vector 4 a -> a
forall a. Vector 4 a -> NonEmpty a
forall m a. Semigroup m => (a -> m) -> Vector 4 a -> m
forall a b. (a -> b) -> (a -> b -> b) -> Vector 4 a -> b
forall a b. (a -> b) -> (b -> a -> b) -> Vector 4 a -> b
forall (t :: * -> *).
Foldable t =>
(forall m. Semigroup m => t m -> m)
-> (forall m a. Semigroup m => (a -> m) -> t a -> m)
-> (forall m a. Semigroup m => (a -> m) -> t a -> m)
-> (forall a. t a -> NonEmpty a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. t a -> a)
-> (forall a. t a -> a)
-> (forall a b. (a -> b) -> (a -> b -> b) -> t a -> b)
-> (forall a b. (a -> b) -> (b -> a -> b) -> t a -> b)
-> (forall a b. (a -> b) -> (b -> a -> b) -> t a -> b)
-> (forall a b. (a -> b) -> (a -> b -> b) -> t a -> b)
-> Foldable1 t
$cfold1 :: forall m. Semigroup m => Vector 4 m -> m
fold1 :: forall m. Semigroup m => Vector 4 m -> m
$cfoldMap1 :: forall m a. Semigroup m => (a -> m) -> Vector 4 a -> m
foldMap1 :: forall m a. Semigroup m => (a -> m) -> Vector 4 a -> m
$cfoldMap1' :: forall m a. Semigroup m => (a -> m) -> Vector 4 a -> m
foldMap1' :: forall m a. Semigroup m => (a -> m) -> Vector 4 a -> m
$ctoNonEmpty :: forall a. Vector 4 a -> NonEmpty a
toNonEmpty :: forall a. Vector 4 a -> NonEmpty a
$cmaximum :: forall a. Ord a => Vector 4 a -> a
maximum :: forall a. Ord a => Vector 4 a -> a
$cminimum :: forall a. Ord a => Vector 4 a -> a
minimum :: forall a. Ord a => Vector 4 a -> a
$chead :: forall a. Vector 4 a -> a
head :: forall a. Vector 4 a -> a
$clast :: forall a. Vector 4 a -> a
last :: forall a. Vector 4 a -> a
$cfoldrMap1 :: forall a b. (a -> b) -> (a -> b -> b) -> Vector 4 a -> b
foldrMap1 :: forall a b. (a -> b) -> (a -> b -> b) -> Vector 4 a -> b
$cfoldlMap1' :: forall a b. (a -> b) -> (b -> a -> b) -> Vector 4 a -> b
foldlMap1' :: forall a b. (a -> b) -> (b -> a -> b) -> Vector 4 a -> b
$cfoldlMap1 :: forall a b. (a -> b) -> (b -> a -> b) -> Vector 4 a -> b
foldlMap1 :: forall a b. (a -> b) -> (b -> a -> b) -> Vector 4 a -> b
$cfoldrMap1' :: forall a b. (a -> b) -> (a -> b -> b) -> Vector 4 a -> b
foldrMap1' :: forall a b. (a -> b) -> (a -> b -> b) -> Vector 4 a -> b
Foldable1,Functor (Vector 4)
Functor (Vector 4) =>
(forall a. a -> Vector 4 a)
-> (forall a b. Vector 4 (a -> b) -> Vector 4 a -> Vector 4 b)
-> (forall a b c.
    (a -> b -> c) -> Vector 4 a -> Vector 4 b -> Vector 4 c)
-> (forall a b. Vector 4 a -> Vector 4 b -> Vector 4 b)
-> (forall a b. Vector 4 a -> Vector 4 b -> Vector 4 a)
-> Applicative (Vector 4)
forall a. a -> Vector 4 a
forall a b. Vector 4 a -> Vector 4 b -> Vector 4 a
forall a b. Vector 4 a -> Vector 4 b -> Vector 4 b
forall a b. Vector 4 (a -> b) -> Vector 4 a -> Vector 4 b
forall a b c.
(a -> b -> c) -> Vector 4 a -> Vector 4 b -> Vector 4 c
forall (f :: * -> *).
Functor f =>
(forall a. a -> f a)
-> (forall a b. f (a -> b) -> f a -> f b)
-> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
-> (forall a b. f a -> f b -> f b)
-> (forall a b. f a -> f b -> f a)
-> Applicative f
$cpure :: forall a. a -> Vector 4 a
pure :: forall a. a -> Vector 4 a
$c<*> :: forall a b. Vector 4 (a -> b) -> Vector 4 a -> Vector 4 b
<*> :: forall a b. Vector 4 (a -> b) -> Vector 4 a -> Vector 4 b
$cliftA2 :: forall a b c.
(a -> b -> c) -> Vector 4 a -> Vector 4 b -> Vector 4 c
liftA2 :: forall a b c.
(a -> b -> c) -> Vector 4 a -> Vector 4 b -> Vector 4 c
$c*> :: forall a b. Vector 4 a -> Vector 4 b -> Vector 4 b
*> :: forall a b. Vector 4 a -> Vector 4 b -> Vector 4 b
$c<* :: forall a b. Vector 4 a -> Vector 4 b -> Vector 4 a
<* :: forall a b. Vector 4 a -> Vector 4 b -> Vector 4 a
Applicative)
  deriving stock ((forall x. Vector 4 r -> Rep (Vector 4 r) x)
-> (forall x. Rep (Vector 4 r) x -> Vector 4 r)
-> Generic (Vector 4 r)
forall x. Rep (Vector 4 r) x -> Vector 4 r
forall x. Vector 4 r -> Rep (Vector 4 r) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall r x. Rep (Vector 4 r) x -> Vector 4 r
forall r x. Vector 4 r -> Rep (Vector 4 r) x
$cfrom :: forall r x. Vector 4 r -> Rep (Vector 4 r) x
from :: forall x. Vector 4 r -> Rep (Vector 4 r) x
$cto :: forall r x. Rep (Vector 4 r) x -> Vector 4 r
to :: forall x. Rep (Vector 4 r) x -> Vector 4 r
Generic,(forall a b. (a -> b) -> Vector 4 a -> Vector 4 b)
-> (forall a b. a -> Vector 4 b -> Vector 4 a)
-> Functor (Vector 4)
forall a b. a -> Vector 4 b -> Vector 4 a
forall a b. (a -> b) -> Vector 4 a -> Vector 4 b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> Vector 4 a -> Vector 4 b
fmap :: forall a b. (a -> b) -> Vector 4 a -> Vector 4 b
$c<$ :: forall a b. a -> Vector 4 b -> Vector 4 a
<$ :: forall a b. a -> Vector 4 b -> Vector 4 a
Functor,(forall m. Monoid m => Vector 4 m -> m)
-> (forall m a. Monoid m => (a -> m) -> Vector 4 a -> m)
-> (forall m a. Monoid m => (a -> m) -> Vector 4 a -> m)
-> (forall a b. (a -> b -> b) -> b -> Vector 4 a -> b)
-> (forall a b. (a -> b -> b) -> b -> Vector 4 a -> b)
-> (forall b a. (b -> a -> b) -> b -> Vector 4 a -> b)
-> (forall b a. (b -> a -> b) -> b -> Vector 4 a -> b)
-> (forall a. (a -> a -> a) -> Vector 4 a -> a)
-> (forall a. (a -> a -> a) -> Vector 4 a -> a)
-> (forall a. Vector 4 a -> [a])
-> (forall a. Vector 4 a -> Bool)
-> (forall a. Vector 4 a -> Int)
-> (forall a. Eq a => a -> Vector 4 a -> Bool)
-> (forall a. Ord a => Vector 4 a -> a)
-> (forall a. Ord a => Vector 4 a -> a)
-> (forall a. Num a => Vector 4 a -> a)
-> (forall a. Num a => Vector 4 a -> a)
-> Foldable (Vector 4)
forall a. Eq a => a -> Vector 4 a -> Bool
forall a. Num a => Vector 4 a -> a
forall a. Ord a => Vector 4 a -> a
forall m. Monoid m => Vector 4 m -> m
forall a. Vector 4 a -> Bool
forall a. Vector 4 a -> Int
forall a. Vector 4 a -> [a]
forall a. (a -> a -> a) -> Vector 4 a -> a
forall m a. Monoid m => (a -> m) -> Vector 4 a -> m
forall b a. (b -> a -> b) -> b -> Vector 4 a -> b
forall a b. (a -> b -> b) -> b -> Vector 4 a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => Vector 4 m -> m
fold :: forall m. Monoid m => Vector 4 m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Vector 4 a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Vector 4 a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Vector 4 a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> Vector 4 a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> Vector 4 a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Vector 4 a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Vector 4 a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Vector 4 a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Vector 4 a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Vector 4 a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Vector 4 a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> Vector 4 a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> Vector 4 a -> a
foldr1 :: forall a. (a -> a -> a) -> Vector 4 a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Vector 4 a -> a
foldl1 :: forall a. (a -> a -> a) -> Vector 4 a -> a
$ctoList :: forall a. Vector 4 a -> [a]
toList :: forall a. Vector 4 a -> [a]
$cnull :: forall a. Vector 4 a -> Bool
null :: forall a. Vector 4 a -> Bool
$clength :: forall a. Vector 4 a -> Int
length :: forall a. Vector 4 a -> Int
$celem :: forall a. Eq a => a -> Vector 4 a -> Bool
elem :: forall a. Eq a => a -> Vector 4 a -> Bool
$cmaximum :: forall a. Ord a => Vector 4 a -> a
maximum :: forall a. Ord a => Vector 4 a -> a
$cminimum :: forall a. Ord a => Vector 4 a -> a
minimum :: forall a. Ord a => Vector 4 a -> a
$csum :: forall a. Num a => Vector 4 a -> a
sum :: forall a. Num a => Vector 4 a -> a
$cproduct :: forall a. Num a => Vector 4 a -> a
product :: forall a. Num a => Vector 4 a -> a
Foldable,Functor (Vector 4)
Foldable (Vector 4)
(Functor (Vector 4), Foldable (Vector 4)) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> Vector 4 a -> f (Vector 4 b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Vector 4 (f a) -> f (Vector 4 a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Vector 4 a -> m (Vector 4 b))
-> (forall (m :: * -> *) a.
    Monad m =>
    Vector 4 (m a) -> m (Vector 4 a))
-> Traversable (Vector 4)
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => Vector 4 (m a) -> m (Vector 4 a)
forall (f :: * -> *) a.
Applicative f =>
Vector 4 (f a) -> f (Vector 4 a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Vector 4 a -> m (Vector 4 b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Vector 4 a -> f (Vector 4 b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Vector 4 a -> f (Vector 4 b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Vector 4 a -> f (Vector 4 b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Vector 4 (f a) -> f (Vector 4 a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Vector 4 (f a) -> f (Vector 4 a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Vector 4 a -> m (Vector 4 b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Vector 4 a -> m (Vector 4 b)
$csequence :: forall (m :: * -> *) a. Monad m => Vector 4 (m a) -> m (Vector 4 a)
sequence :: forall (m :: * -> *) a. Monad m => Vector 4 (m a) -> m (Vector 4 a)
Traversable)

-- | Construct a vector4
pattern Vector4         :: r -> r -> r -> r -> Vector 4 r
pattern $bVector4 :: forall r. r -> r -> r -> r -> Vector 4 r
$mVector4 :: forall {r} {r}.
Vector 4 r -> (r -> r -> r -> r -> r) -> ((# #) -> r) -> r
Vector4 x y z w = MkVector4 (Linear.V4 x y z w)
{-# COMPLETE Vector4 #-}

asV4 :: forall r s. Iso (Vector 4 r) (Vector 4 s) (Linear.V4 r) (Linear.V4 s)
asV4 :: forall r s (p :: * -> * -> *) (f :: * -> *).
(Profunctor p, Functor f) =>
p (V4 r) (f (V4 s)) -> p (Vector 4 r) (f (Vector 4 s))
asV4 = (Vector 4 r -> V4 r)
-> (V4 s -> Vector 4 s)
-> Iso (Vector 4 r) (Vector 4 s) (V4 r) (V4 s)
forall s a b t. (s -> a) -> (b -> t) -> Iso s t a b
iso (forall a b. Coercible a b => a -> b
forall a b. Coercible a b => a -> b
coerce @(Vector 4 r) @(Linear.V4 r))
           (forall a b. Coercible a b => a -> b
forall a b. Coercible a b => a -> b
coerce @(Linear.V4 s) @(Vector 4 s))
{-# INLINE asV4 #-}

instance Traversable1 (Vector 4) where
  traverse1 :: forall (f :: * -> *) a b.
Apply f =>
(a -> f b) -> Vector 4 a -> f (Vector 4 b)
traverse1 a -> f b
f (Vector4 a
x a
y a
z a
w) = b -> b -> b -> b -> Vector 4 b
forall r. r -> r -> r -> r -> Vector 4 r
Vector4 (b -> b -> b -> b -> Vector 4 b)
-> f b -> f (b -> b -> b -> Vector 4 b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> f b
f a
x f (b -> b -> b -> Vector 4 b) -> f b -> f (b -> b -> Vector 4 b)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Apply f => f (a -> b) -> f a -> f b
Apply.<.> a -> f b
f a
y f (b -> b -> Vector 4 b) -> f b -> f (b -> Vector 4 b)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Apply f => f (a -> b) -> f a -> f b
Apply.<.> a -> f b
f a
z f (b -> Vector 4 b) -> f b -> f (Vector 4 b)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Apply f => f (a -> b) -> f a -> f b
Apply.<.> a -> f b
f a
w
  {-# INLINE traverse1 #-}

instance TraversableWithIndex Int (Vector 4)
instance FoldableWithIndex    Int (Vector 4)
instance FunctorWithIndex     Int (Vector 4)

instance Ixed (Vector 4 r) where
  ix :: Index (Vector 4 r)
-> Traversal' (Vector 4 r) (IxValue (Vector 4 r))
ix Index (Vector 4 r)
i IxValue (Vector 4 r) -> f (IxValue (Vector 4 r))
f v :: Vector 4 r
v@(Vector4 r
x r
y r
z r
w) = case Index (Vector 4 r)
i of
                                 Index (Vector 4 r)
0 -> (\r
x' -> r -> r -> r -> r -> Vector 4 r
forall r. r -> r -> r -> r -> Vector 4 r
Vector4 r
x' r
y r
z r
w) (r -> Vector 4 r) -> f r -> f (Vector 4 r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IxValue (Vector 4 r) -> f (IxValue (Vector 4 r))
f r
IxValue (Vector 4 r)
x
                                 Index (Vector 4 r)
1 -> (\r
y' -> r -> r -> r -> r -> Vector 4 r
forall r. r -> r -> r -> r -> Vector 4 r
Vector4 r
x r
y' r
z r
w) (r -> Vector 4 r) -> f r -> f (Vector 4 r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IxValue (Vector 4 r) -> f (IxValue (Vector 4 r))
f r
IxValue (Vector 4 r)
y
                                 Index (Vector 4 r)
2 -> (\r
z' -> r -> r -> r -> r -> Vector 4 r
forall r. r -> r -> r -> r -> Vector 4 r
Vector4 r
x r
y r
z' r
w) (r -> Vector 4 r) -> f r -> f (Vector 4 r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IxValue (Vector 4 r) -> f (IxValue (Vector 4 r))
f r
IxValue (Vector 4 r)
z
                                 Index (Vector 4 r)
3 -> (\r
w' -> r -> r -> r -> r -> Vector 4 r
forall r. r -> r -> r -> r -> Vector 4 r
Vector4 r
x r
y r
z r
w') (r -> Vector 4 r) -> f r -> f (Vector 4 r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IxValue (Vector 4 r) -> f (IxValue (Vector 4 r))
f r
IxValue (Vector 4 r)
w
                                 Index (Vector 4 r)
_ -> Vector 4 r -> f (Vector 4 r)
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Vector 4 r
v
  {-# INLINE ix #-}

instance HasComponents (Vector 4 r) (Vector 4 s) where
  components :: IndexedTraversal1
  Int
  (Vector 4 r)
  (Vector 4 s)
  (IxValue (Vector 4 r))
  (IxValue (Vector 4 s))
components = (V4 r -> f (V4 s)) -> Vector 4 r -> f (Vector 4 s)
forall r s (p :: * -> * -> *) (f :: * -> *).
(Profunctor p, Functor f) =>
p (V4 r) (f (V4 s)) -> p (Vector 4 r) (f (Vector 4 s))
asV4 ((V4 r -> f (V4 s)) -> Vector 4 r -> f (Vector 4 s))
-> (p r (f s) -> V4 r -> f (V4 s))
-> p r (f s)
-> Vector 4 r
-> f (Vector 4 s)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. p r (f s) -> V4 r -> f (V4 s)
p (IxValue (V4 r)) (f (IxValue (V4 s))) -> V4 r -> f (V4 s)
forall vector vector'.
HasComponents vector vector' =>
IndexedTraversal1
  Int vector vector' (IxValue vector) (IxValue vector')
IndexedTraversal1
  Int (V4 r) (V4 s) (IxValue (V4 r)) (IxValue (V4 s))
components
  {-# INLINE components #-}

instance Semialign (Vector 4) where
  align :: forall a b. Vector 4 a -> Vector 4 b -> Vector 4 (These a b)
align = (a -> b -> These a b)
-> Vector 4 a -> Vector 4 b -> Vector 4 (These a b)
forall a b c.
(a -> b -> c) -> Vector 4 a -> Vector 4 b -> Vector 4 c
forall (f :: * -> *) a b c.
Zip f =>
(a -> b -> c) -> f a -> f b -> f c
zipWith a -> b -> These a b
forall a b. a -> b -> These a b
These
  {-# INLINE align #-}
instance Zip (Vector 4) where
  zipWith :: forall a b c.
(a -> b -> c) -> Vector 4 a -> Vector 4 b -> Vector 4 c
zipWith a -> b -> c
f (Vector4 a
x a
y a
z a
w) (Vector4 b
x' b
y' b
z' b
w') = c -> c -> c -> c -> Vector 4 c
forall r. r -> r -> r -> r -> Vector 4 r
Vector4 (a -> b -> c
f a
x b
x') (a -> b -> c
f a
y b
y') (a -> b -> c
f a
z b
z') (a -> b -> c
f a
w b
w')
  {-# INLINE zipWith #-}

-- instance FromYAML r => FromYAML (Vector 4 r) where
--   -- node pos -> Parser
--   parseYAML node = withSeq "Vector4" f node
--     where
--       f = \case
--         [posX,posY,posZ,posW] ->
--           Vector4 <$> parseYAML posX <*> parseYAML posY <*> parseYAML posZ  <*> parseYAML posW
--         _                     -> failAtNode node "expected exactly 4 elements"

instance FromJSON r => FromJSON (Vector 4 r) where
  parseJSON :: Value -> Parser (Vector 4 r)
parseJSON = String
-> (Array -> Parser (Vector 4 r)) -> Value -> Parser (Vector 4 r)
forall a. String -> (Array -> Parser a) -> Value -> Parser a
withArray String
"Vector4" ([Value] -> Parser (Vector 4 r)
f ([Value] -> Parser (Vector 4 r))
-> (Array -> [Value]) -> Array -> Parser (Vector 4 r)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Array -> [Value]
forall a. Vector a -> [a]
Array.toList)
    where
      f :: [Value] -> Parser (Vector 4 r)
f = \case
        [Value
x,Value
y,Value
z,Value
w] -> r -> r -> r -> r -> Vector 4 r
forall r. r -> r -> r -> r -> Vector 4 r
Vector4 (r -> r -> r -> r -> Vector 4 r)
-> Parser r -> Parser (r -> r -> r -> Vector 4 r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Value -> Parser r
forall a. FromJSON a => Value -> Parser a
parseJSON Value
x Parser (r -> r -> r -> Vector 4 r)
-> Parser r -> Parser (r -> r -> Vector 4 r)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Value -> Parser r
forall a. FromJSON a => Value -> Parser a
parseJSON Value
y Parser (r -> r -> Vector 4 r)
-> Parser r -> Parser (r -> Vector 4 r)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Value -> Parser r
forall a. FromJSON a => Value -> Parser a
parseJSON Value
z Parser (r -> Vector 4 r) -> Parser r -> Parser (Vector 4 r)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Value -> Parser r
forall a. FromJSON a => Value -> Parser a
parseJSON Value
w
        [Value]
_         -> String -> Parser (Vector 4 r)
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"expected exactly 4 elements"

instance Reversing (Vector 4 r) where
  reversing :: Vector 4 r -> Vector 4 r
reversing (Vector4 r
x r
y r
z r
w) = r -> r -> r -> r -> Vector 4 r
forall r. r -> r -> r -> r -> Vector 4 r
Vector4 r
w r
z r
y r
x

--------------------------------------------------------------------------------
-- * Linear Instances

instance HasComponents (Linear.V1 r) (Linear.V1 s)  where
  components :: IndexedTraversal1
  Int (V1 r) (V1 s) (IxValue (V1 r)) (IxValue (V1 s))
components = ((p ~ (->)) => (r -> f s) -> V1 r -> f (V1 s))
-> (p r (f s) -> V1 r -> f (V1 s)) -> p r (f s) -> V1 r -> f (V1 s)
forall (p :: * -> * -> *) (q :: * -> * -> *) a b r.
Conjoined p =>
((p ~ (->)) => q (a -> b) r) -> q (p a b) r -> q (p a b) r
forall (q :: * -> * -> *) a b r.
((p ~ (->)) => q (a -> b) r) -> q (p a b) r -> q (p a b) r
conjoined (p ~ (->)) => (r -> f s) -> V1 r -> f (V1 s)
(r -> f s) -> V1 r -> f (V1 s)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable1 t, Apply f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b. Apply f => (a -> f b) -> V1 a -> f (V1 b)
traverse1 ((Int -> r -> f s) -> V1 r -> f (V1 s)
forall (f :: * -> *).
Apply f =>
(Int -> r -> f s) -> V1 r -> f (V1 s)
itraverse1 ((Int -> r -> f s) -> V1 r -> f (V1 s))
-> (p r (f s) -> Int -> r -> f s) -> p r (f s) -> V1 r -> f (V1 s)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. p r (f s) -> Int -> r -> f s
forall a b. p a b -> Int -> a -> b
forall i (p :: * -> * -> *) a b.
Indexable i p =>
p a b -> i -> a -> b
indexed)
    where
      itraverse1 :: Apply.Apply f => (Int -> r -> f s) -> Linear.V1 r -> f (Linear.V1 s)
      itraverse1 :: forall (f :: * -> *).
Apply f =>
(Int -> r -> f s) -> V1 r -> f (V1 s)
itraverse1 Int -> r -> f s
f (Linear.V1 r
x) = s -> V1 s
forall a. a -> V1 a
Linear.V1 (s -> V1 s) -> f s -> f (V1 s)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> r -> f s
f Int
0 r
x
  {-# INLINE components #-}

instance HasComponents (Linear.V2 r) (Linear.V2 s)  where
  components :: IndexedTraversal1
  Int (V2 r) (V2 s) (IxValue (V2 r)) (IxValue (V2 s))
components = ((p ~ (->)) => (r -> f s) -> V2 r -> f (V2 s))
-> (p r (f s) -> V2 r -> f (V2 s)) -> p r (f s) -> V2 r -> f (V2 s)
forall (p :: * -> * -> *) (q :: * -> * -> *) a b r.
Conjoined p =>
((p ~ (->)) => q (a -> b) r) -> q (p a b) r -> q (p a b) r
forall (q :: * -> * -> *) a b r.
((p ~ (->)) => q (a -> b) r) -> q (p a b) r -> q (p a b) r
conjoined (p ~ (->)) => (r -> f s) -> V2 r -> f (V2 s)
(r -> f s) -> V2 r -> f (V2 s)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable1 t, Apply f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b. Apply f => (a -> f b) -> V2 a -> f (V2 b)
traverse1 ((Int -> r -> f s) -> V2 r -> f (V2 s)
forall (f :: * -> *).
Apply f =>
(Int -> r -> f s) -> V2 r -> f (V2 s)
itraverse1 ((Int -> r -> f s) -> V2 r -> f (V2 s))
-> (p r (f s) -> Int -> r -> f s) -> p r (f s) -> V2 r -> f (V2 s)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. p r (f s) -> Int -> r -> f s
forall a b. p a b -> Int -> a -> b
forall i (p :: * -> * -> *) a b.
Indexable i p =>
p a b -> i -> a -> b
indexed)
    where
      itraverse1 :: Apply.Apply f => (Int -> r -> f s) -> Linear.V2 r -> f (Linear.V2 s)
      itraverse1 :: forall (f :: * -> *).
Apply f =>
(Int -> r -> f s) -> V2 r -> f (V2 s)
itraverse1 Int -> r -> f s
f (Linear.V2 r
x r
y) =
        s -> s -> V2 s
forall a. a -> a -> V2 a
Linear.V2 (s -> s -> V2 s) -> f s -> f (s -> V2 s)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> r -> f s
f Int
0 r
x f (s -> V2 s) -> f s -> f (V2 s)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Apply f => f (a -> b) -> f a -> f b
Apply.<.> Int -> r -> f s
f Int
1 r
y
  {-# INLINE components #-}

instance HasComponents (Linear.V3 r) (Linear.V3 s)  where
  components :: IndexedTraversal1
  Int (V3 r) (V3 s) (IxValue (V3 r)) (IxValue (V3 s))
components = ((p ~ (->)) => (r -> f s) -> V3 r -> f (V3 s))
-> (p r (f s) -> V3 r -> f (V3 s)) -> p r (f s) -> V3 r -> f (V3 s)
forall (p :: * -> * -> *) (q :: * -> * -> *) a b r.
Conjoined p =>
((p ~ (->)) => q (a -> b) r) -> q (p a b) r -> q (p a b) r
forall (q :: * -> * -> *) a b r.
((p ~ (->)) => q (a -> b) r) -> q (p a b) r -> q (p a b) r
conjoined (p ~ (->)) => (r -> f s) -> V3 r -> f (V3 s)
(r -> f s) -> V3 r -> f (V3 s)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable1 t, Apply f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b. Apply f => (a -> f b) -> V3 a -> f (V3 b)
traverse1 ((Int -> r -> f s) -> V3 r -> f (V3 s)
forall (f :: * -> *).
Apply f =>
(Int -> r -> f s) -> V3 r -> f (V3 s)
itraverse1 ((Int -> r -> f s) -> V3 r -> f (V3 s))
-> (p r (f s) -> Int -> r -> f s) -> p r (f s) -> V3 r -> f (V3 s)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. p r (f s) -> Int -> r -> f s
forall a b. p a b -> Int -> a -> b
forall i (p :: * -> * -> *) a b.
Indexable i p =>
p a b -> i -> a -> b
indexed)
    where
      itraverse1 :: Apply.Apply f => (Int -> r -> f s) -> Linear.V3 r -> f (Linear.V3 s)
      itraverse1 :: forall (f :: * -> *).
Apply f =>
(Int -> r -> f s) -> V3 r -> f (V3 s)
itraverse1 Int -> r -> f s
f (Linear.V3 r
x r
y r
z) =
        s -> s -> s -> V3 s
forall a. a -> a -> a -> V3 a
Linear.V3 (s -> s -> s -> V3 s) -> f s -> f (s -> s -> V3 s)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> r -> f s
f Int
0 r
x f (s -> s -> V3 s) -> f s -> f (s -> V3 s)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Apply f => f (a -> b) -> f a -> f b
Apply.<.> Int -> r -> f s
f Int
1 r
y f (s -> V3 s) -> f s -> f (V3 s)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Apply f => f (a -> b) -> f a -> f b
Apply.<.> Int -> r -> f s
f Int
2 r
z
  {-# INLINE components #-}

instance HasComponents (Linear.V4 r) (Linear.V4 s)  where
  components :: IndexedTraversal1
  Int (V4 r) (V4 s) (IxValue (V4 r)) (IxValue (V4 s))
components = ((p ~ (->)) => (r -> f s) -> V4 r -> f (V4 s))
-> (p r (f s) -> V4 r -> f (V4 s)) -> p r (f s) -> V4 r -> f (V4 s)
forall (p :: * -> * -> *) (q :: * -> * -> *) a b r.
Conjoined p =>
((p ~ (->)) => q (a -> b) r) -> q (p a b) r -> q (p a b) r
forall (q :: * -> * -> *) a b r.
((p ~ (->)) => q (a -> b) r) -> q (p a b) r -> q (p a b) r
conjoined (p ~ (->)) => (r -> f s) -> V4 r -> f (V4 s)
(r -> f s) -> V4 r -> f (V4 s)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable1 t, Apply f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b. Apply f => (a -> f b) -> V4 a -> f (V4 b)
traverse1 ((Int -> r -> f s) -> V4 r -> f (V4 s)
forall (f :: * -> *).
Apply f =>
(Int -> r -> f s) -> V4 r -> f (V4 s)
itraverse1 ((Int -> r -> f s) -> V4 r -> f (V4 s))
-> (p r (f s) -> Int -> r -> f s) -> p r (f s) -> V4 r -> f (V4 s)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. p r (f s) -> Int -> r -> f s
forall a b. p a b -> Int -> a -> b
forall i (p :: * -> * -> *) a b.
Indexable i p =>
p a b -> i -> a -> b
indexed)
    where
      itraverse1 :: Apply.Apply f => (Int -> r -> f s) -> Linear.V4 r -> f (Linear.V4 s)
      itraverse1 :: forall (f :: * -> *).
Apply f =>
(Int -> r -> f s) -> V4 r -> f (V4 s)
itraverse1 Int -> r -> f s
f (Linear.V4 r
x r
y r
z r
w) =
        s -> s -> s -> s -> V4 s
forall a. a -> a -> a -> a -> V4 a
Linear.V4 (s -> s -> s -> s -> V4 s) -> f s -> f (s -> s -> s -> V4 s)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> r -> f s
f Int
0 r
x f (s -> s -> s -> V4 s) -> f s -> f (s -> s -> V4 s)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Apply f => f (a -> b) -> f a -> f b
Apply.<.> Int -> r -> f s
f Int
1 r
y f (s -> s -> V4 s) -> f s -> f (s -> V4 s)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Apply f => f (a -> b) -> f a -> f b
Apply.<.> Int -> r -> f s
f Int
2 r
z f (s -> V4 s) -> f s -> f (V4 s)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Apply f => f (a -> b) -> f a -> f b
Apply.<.> Int -> r -> f s
f Int
3 r
w
  {-# INLINE components #-}


--------------------------------------------------------------------------------

instance ( HasComponents (Vector d r) (Vector d r)
         , Show r
         , KnownNat d
         ) => Show (Vector d r) where
  -- | Show implementation for vectors
  showsPrec :: Int -> Vector d r -> ShowS
showsPrec Int
k Vector d r
v = Bool -> ShowS -> ShowS
showParen (Int
k Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
app_prec) (ShowS -> ShowS) -> ShowS -> ShowS
forall a b. (a -> b) -> a -> b
$
                     String -> ShowS
showString String
constr ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> ShowS
showChar Char
' ' ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
                     [ShowS] -> ShowS
unwordsS ((r -> ShowS) -> [r] -> [ShowS]
forall a b. (a -> b) -> [a] -> [b]
map (Int -> r -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec Int
11) (Vector d r
vVector d r -> Getting (Endo [r]) (Vector d r) r -> [r]
forall s a. s -> Getting (Endo [a]) s a -> [a]
^..Getting (Endo [r]) (Vector d r) r
(IxValue (Vector d r) -> Const (Endo [r]) (IxValue (Vector d r)))
-> Vector d r -> Const (Endo [r]) (Vector d r)
forall vector vector'.
HasComponents vector vector' =>
IndexedTraversal1
  Int vector vector' (IxValue vector) (IxValue vector')
IndexedTraversal1
  Int
  (Vector d r)
  (Vector d r)
  (IxValue (Vector d r))
  (IxValue (Vector d r))
components))
    where
      app_prec :: Int
app_prec = Int
10
      constr :: String
constr   = String
"Vector" String -> ShowS
forall a. Semigroup a => a -> a -> a
<> Integer -> String
forall a. Show a => a -> String
show (Nat -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral (forall (n :: Nat) (proxy :: Nat -> *). KnownNat n => proxy n -> Nat
natVal @d Proxy d
forall {k} (t :: k). Proxy t
Proxy))
      unwordsS :: [ShowS] -> ShowS
unwordsS = (ShowS -> ShowS -> ShowS) -> ShowS -> [ShowS] -> ShowS
forall a b. (a -> b -> b) -> b -> [a] -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
(.) ShowS
forall a. a -> a
id ([ShowS] -> ShowS) -> ([ShowS] -> [ShowS]) -> [ShowS] -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ShowS -> [ShowS] -> [ShowS]
forall a. a -> [a] -> [a]
List.intersperse (Char -> ShowS
showChar Char
' ')

--------------------------------------------------------------------------------

-- instance (ToYAML r, HasComponents (Vector d r) (Vector d r)) => ToYAML (Vector d r) where
--   toYAML = toYAML . toListOf components

instance (ToJSON r, HasComponents (Vector d r) (Vector d r)) => ToJSON (Vector d r) where
  toJSON :: Vector d r -> Value
toJSON = [r] -> Value
forall a. ToJSON a => a -> Value
toJSON ([r] -> Value) -> (Vector d r -> [r]) -> Vector d r -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Getting (Endo [r]) (Vector d r) r -> Vector d r -> [r]
forall a s. Getting (Endo [a]) s a -> s -> [a]
toListOf Getting (Endo [r]) (Vector d r) r
(IxValue (Vector d r) -> Const (Endo [r]) (IxValue (Vector d r)))
-> Vector d r -> Const (Endo [r]) (Vector d r)
forall vector vector'.
HasComponents vector vector' =>
IndexedTraversal1
  Int vector vector' (IxValue vector) (IxValue vector')
IndexedTraversal1
  Int
  (Vector d r)
  (Vector d r)
  (IxValue (Vector d r))
  (IxValue (Vector d r))
components