    {-# LANGUAGE CPP #-}
    {-# LANGUAGE Rank2Types #-}
    {-# LANGUAGE FlexibleContexts #-}
    {-# LANGUAGE MultiParamTypeClasses #-}
    #ifdef TRUSTWORTHY
    {-# LANGUAGE Trustworthy #-}
    #endif
    -------------------------------------------------------------------------------
    -- |
    -- Module      :  Data.Vector.Lens
    -- Copyright   :  (C) 2012-16 Edward Kmett
    -- License     :  BSD-style (see the file LICENSE)
    -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
    -- Stability   :  provisional
    -- Portability :  non-portable
    --
    -- This module provides lenses and traversals for working with generic
    -- vectors.
    -------------------------------------------------------------------------------
    module Data.Vector.Lens
      ( toVectorOf
      -- * Isomorphisms
      , vector
      , forced
      -- * Lenses
      , sliced
      -- * Traversal of individual indices
      , ordinals
      ) where

    import Prelude ()

    import Control.Lens
    import Control.Lens.Internal.List (ordinalNub)
    import Control.Lens.Internal.Prelude
    import qualified Data.Vector as V
    import Data.Vector (Vector)

    -- $setup
    -- >>> import qualified Data.Vector as Vector
    -- >>> import Control.Lens

    -- | @sliced i n@ provides a t'Lens' that edits the @n@ elements starting
    -- at index @i@ from a t'Lens'.
    --
    -- This is only a valid t'Lens' if you do not change the length of the
    -- resulting 'Vector'.
    --
    -- Attempting to return a longer or shorter vector will result in
    -- violations of the t'Lens' laws.
    --
    -- >>> Vector.fromList [1..10] ^. sliced 2 5 == Vector.fromList [3,4,5,6,7]
    -- True
    --
    -- >>> (Vector.fromList [1..10] & sliced 2 5 . mapped .~ 0) == Vector.fromList [1,2,0,0,0,0,0,8,9,10]
    -- True
    sliced :: Int -- ^ @i@ starting index
           -> Int -- ^ @n@ length
           -> Lens' (Vector a) (Vector a)
    sliced :: forall a. Int -> Int -> Lens' (Vector a) (Vector a)
    sliced Int
    i Int
    n Vector a -> f (Vector a)
    f Vector a
    v = Vector a -> f (Vector a)
    f (Int -> Int -> Vector a -> Vector a
    forall a. Int -> Int -> Vector a -> Vector a
    V.slice Int
    i Int
    n Vector a
    v) f (Vector a) -> (Vector a -> Vector a) -> f (Vector a)
    forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
    <&> \ Vector a
    v0 -> Vector a
    v Vector a -> [(Int, a)] -> Vector a
    forall a. Vector a -> [(Int, a)] -> Vector a
    V.// [Int] -> [a] -> [(Int, a)]
    forall a b. [a] -> [b] -> [(a, b)]
    zip [Int
    i..Int
    iInt -> Int -> Int
    forall a. Num a => a -> a -> a
    +Int
    nInt -> Int -> Int
    forall a. Num a => a -> a -> a
    -Int
    1] (Vector a -> [a]
    forall a. Vector a -> [a]
    V.toList Vector a
    v0)
    {-# INLINE sliced #-}

    -- | Similar to 'toListOf', but returning a 'Vector'.
    --
    -- >>> toVectorOf both (8,15) == Vector.fromList [8,15]
    -- True
    toVectorOf :: Getting (Endo [a]) s a -> s -> Vector a
    toVectorOf :: forall a s. Getting (Endo [a]) s a -> s -> Vector a
    toVectorOf Getting (Endo [a]) s a
    l s
    s = [a] -> Vector a
    forall a. [a] -> Vector a
    V.fromList (Getting (Endo [a]) s a -> s -> [a]
    forall a s. Getting (Endo [a]) s a -> s -> [a]
    toListOf Getting (Endo [a]) s a
    l s
    s)
    {-# INLINE toVectorOf #-}

    -- | Convert a list to a 'Vector' (or back)
    --
    -- >>> [1,2,3] ^. vector == Vector.fromList [1,2,3]
    -- True
    --
    -- >>> [1,2,3] ^. vector . from vector
    -- [1,2,3]
    --
    -- >>> Vector.fromList [0,8,15] ^. from vector . vector == Vector.fromList [0,8,15]
    -- True
    vector :: Iso [a] [b] (Vector a) (Vector b)
    vector :: forall a b (p :: * -> * -> *) (f :: * -> *).
    (Profunctor p, Functor f) =>
    p (Vector a) (f (Vector b)) -> p [a] (f [b])
    vector = ([a] -> Vector a)
    -> (Vector b -> [b]) -> Iso [a] [b] (Vector a) (Vector b)
    forall s a b t. (s -> a) -> (b -> t) -> Iso s t a b
    iso [a] -> Vector a
    forall a. [a] -> Vector a
    V.fromList Vector b -> [b]
    forall a. Vector a -> [a]
    V.toList
    {-# INLINE vector #-}

    -- | Convert a 'Vector' to a version that doesn't retain any extra
    -- memory.
    forced :: Iso (Vector a) (Vector b) (Vector a) (Vector b)
    forced :: forall a b (p :: * -> * -> *) (f :: * -> *).
    (Profunctor p, Functor f) =>
    p (Vector a) (f (Vector b)) -> p (Vector a) (f (Vector b))
    forced = (Vector a -> Vector a)
    -> (Vector b -> Vector b)
    -> Iso (Vector a) (Vector b) (Vector a) (Vector b)
    forall s a b t. (s -> a) -> (b -> t) -> Iso s t a b
    iso Vector a -> Vector a
    forall a. Vector a -> Vector a
    V.force Vector b -> Vector b
    forall a. Vector a -> Vector a
    V.force
    {-# INLINE forced #-}

    -- | This t'Traversal' will ignore any duplicates in the supplied list
    -- of indices.
    --
    -- >>> toListOf (ordinals [1,3,2,5,9,10]) $ Vector.fromList [2,4..40]
    -- [4,8,6,12,20,22]
    ordinals :: [Int] -> IndexedTraversal' Int (Vector a) a
    ordinals :: forall a. [Int] -> IndexedTraversal' Int (Vector a) a
    ordinals [Int]
    is p a (f a)
    f Vector a
    v = ([(Int, a)] -> Vector a) -> f [(Int, a)] -> f (Vector a)
    forall a b. (a -> b) -> f a -> f b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (Vector a
    v Vector a -> [(Int, a)] -> Vector a
    forall a. Vector a -> [(Int, a)] -> Vector a
    V.//) (f [(Int, a)] -> f (Vector a)) -> f [(Int, a)] -> f (Vector a)
    forall a b. (a -> b) -> a -> b
    $ (Int -> f (Int, a)) -> [Int] -> f [(Int, a)]
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> [a] -> f [b]
    traverse (\Int
    i -> (,) Int
    i (a -> (Int, a)) -> f a -> f (Int, a)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> p a (f a) -> Int -> a -> f a
    forall a b. p a b -> Int -> a -> b
    forall i (p :: * -> * -> *) a b.
    Indexable i p =>
    p a b -> i -> a -> b
    indexed p a (f a)
    f Int
    i (Vector a
    v Vector a -> Int -> a
    forall a. Vector a -> Int -> a
    V.! Int
    i)) ([Int] -> f [(Int, a)]) -> [Int] -> f [(Int, a)]
    forall a b. (a -> b) -> a -> b
    $ Int -> [Int] -> [Int]
    ordinalNub (Vector a -> Int
    forall a. Vector a -> Int
    forall (t :: * -> *) a. Foldable t => t a -> Int
    length Vector a
    v) [Int]
    is
    {-# INLINE ordinals #-}