{-# OPTIONS -Wno-orphans #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE UndecidableInstances #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# OPTIONS_HADDOCK hide #-}

-- | This module contains all instances for V
module Data.V.Linear.Internal.Instances where

import qualified Data.Functor.Linear.Internal.Applicative as Data
import qualified Data.Functor.Linear.Internal.Functor as Data
import qualified Data.Functor.Linear.Internal.Traversable as Data
import Data.V.Linear.Internal (V (..))
import qualified Data.V.Linear.Internal as V
import qualified Data.Vector as Vector
import GHC.TypeLits
import Prelude.Linear.Internal
import qualified Unsafe.Linear as Unsafe

-- # Instances of V
-------------------------------------------------------------------------------

instance Data.Functor (V n) where
  fmap :: forall a b. (a %1 -> b) -> V n a %1 -> V n b
fmap = (a %1 -> b) -> V n a %1 -> V n b
forall a b (n :: Nat). (a %1 -> b) -> V n a %1 -> V n b
V.map

instance KnownNat n => Data.Applicative (V n) where
  pure :: forall a. a -> V n a
pure = a -> V n a
forall (n :: Nat) a. KnownNat n => a -> V n a
V.pure
  V n (a %1 -> b)
a <*> :: forall a b. V n (a %1 -> b) %1 -> V n a %1 -> V n b
<*> V n a
b = V n (a %1 -> b)
a V n (a %1 -> b) %1 -> V n a %1 -> V n b
forall (n :: Nat) a b. V n (a %1 -> b) %1 -> V n a %1 -> V n b
V.<*> V n a
b

instance KnownNat n => Data.Traversable (V n) where
  traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a %1 -> f b) -> V n a %1 -> f (V n b)
traverse a %1 -> f b
f (V Vector a
xs) =
    (Vector b %1 -> V n b
forall (n :: Nat) a. Vector a -> V n a
V (Vector b %1 -> V n b) -> ([b] %1 -> Vector b) -> [b] %1 -> V n b
forall b c a. (b %1 -> c) -> (a %1 -> b) -> a -> c
. ([b] -> Vector b) %1 -> [b] %1 -> Vector b
forall a b. (a -> b) %1 -> a -> b
Unsafe.toLinear (Int -> [b] -> Vector b
forall a. Int -> [a] -> Vector a
Vector.fromListN (forall (n :: Nat). KnownNat n => Int
V.theLength @n)))
      ([b] %1 -> V n b) -> f [b] %1 -> f (V n b)
forall (f :: * -> *) a b. Functor f => (a %1 -> b) -> f a %1 -> f b
Data.<$> (a %1 -> f b) -> [a] %1 -> f [b]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a %1 -> f b) -> t a %1 -> f (t b)
Data.traverse a %1 -> f b
f ((Vector a -> [a]) %1 -> Vector a %1 -> [a]
forall a b. (a -> b) %1 -> a -> b
Unsafe.toLinear Vector a -> [a]
forall a. Vector a -> [a]
Vector.toList Vector a
xs)