lens-5.3.3: Lenses, Folds and Traversals

Copyright | (C) 2012-2016 Edward Kmett
License | BSD-style (see the file LICENSE)
Maintainer | Edward Kmett <ekmett@gmail.com>
Stability | provisional
Portability | non-portable
Safe Haskell | Trustworthy
Language | Haskell2010

Data.Vector.Generic.Lens

Contents

- Isomorphisms
- Lenses
- Traversal of individual indices

Description

This module provides lenses and traversals for working with generic vectors.

Synopsis

- toVectorOf :: Vector v a => Getting (Endo [a]) s a -> s -> v a
- forced :: forall (v :: Type -> Type) a. Vector v a => Iso' (v a) (v a)
- vector :: forall (v :: Type -> Type) a b. (Vector v a, Vector v b) => Iso [a] [b] (v a) (v b)
- asStream :: forall (v :: Type -> Type) a b. (Vector v a, Vector v b) => Iso (v a) (v b) (Bundle v a) (Bundle v b)
- asStreamR :: forall (v :: Type -> Type) a b. (Vector v a, Vector v b) => Iso (v a) (v b) (Bundle v a) (Bundle v b)
- cloned :: forall (v :: Type -> Type) a. Vector v a => Iso' (v a) (New v a)
- converted :: forall (v :: Type -> Type) a (w :: Type -> Type) b. (Vector v a, Vector w a, Vector v b, Vector w b) => Iso (v a) (v b) (w a) (w b)
- sliced :: forall (v :: Type -> Type) a. Vector v a => Int -> Int -> Lens' (v a) (v a)
- ordinals :: forall (v :: Type -> Type) a. Vector v a => [Int] -> IndexedTraversal' Int (v a) a
- vectorIx :: forall (v :: Type -> Type) a. Vector v a => Int -> Traversal' (v a) a
- vectorTraverse :: forall (v :: Type -> Type) a (w :: Type -> Type) b. (Vector v a, Vector w b) => IndexedTraversal Int (v a) (w b) a b

# Documentation

toVectorOf :: Vector v a => Getting (Endo [a]) s a -> s -> v a #

Similar to `toListOf`, but returning a `Vector`.

    >>> (toVectorOf both (8,15) :: Vector.Vector Int) == Vector.fromList [8,15]
    True

# Isomorphisms

forced :: forall (v :: Type -> Type) a. Vector v a => Iso' (v a) (v a) #

Convert a `Vector` to a version that doesn't retain any extra memory.

vector :: forall (v :: Type -> Type) a b. (Vector v a, Vector v b) => Iso [a] [b] (v a) (v b) #

Convert a list to a `Vector` (or back.)

    >>> ([1,2,3] ^. vector :: Vector.Vector Int) == Vector.fromList [1,2,3]
    True

    >>> Vector.fromList [0,8,15] ^. from vector
    [0,8,15]

asStream :: forall (v :: Type -> Type) a b. (Vector v a, Vector v b) => Iso (v a) (v b) (Bundle v a) (Bundle v b) #

Convert a `Vector` to a finite `Bundle` (or back.)

asStreamR :: forall (v :: Type -> Type) a b. (Vector v a, Vector v b) => Iso (v a) (v b) (Bundle v a) (Bundle v b) #

Convert a `Vector` to a finite `Bundle` from right to left (or back.)

cloned :: forall (v :: Type -> Type) a. Vector v a => Iso' (v a) (New v a) #

Convert a `Vector` back and forth to an initializer that when run produces a copy of the `Vector`.

converted :: forall (v :: Type -> Type) a (w :: Type -> Type) b. (Vector v a, Vector w a, Vector v b, Vector w b) => Iso (v a) (v b) (w a) (w b) #

Different vector implementations are isomorphic to each other.

# Lenses

sliced #

Arguments

:: forall (v :: Type -> Type) a. Vector v a |
=> Int | `i` starting index
-> Int | `n` length
-> Lens' (v a) (v a) |

`sliced i n` provides a `Lens` that edits the `n` elements starting at index `i` from a `Lens`.

This is only a valid `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 `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

# Traversal of individual indices

ordinals :: forall (v :: Type -> Type) a. Vector v a => [Int] -> IndexedTraversal' Int (v a) a #

This `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]

vectorIx :: forall (v :: Type -> Type) a. Vector v a => Int -> Traversal' (v a) a #

Like `ix` but polymorphic in the vector type.

vectorTraverse :: forall (v :: Type -> Type) a (w :: Type -> Type) b. (Vector v a, Vector w b) => IndexedTraversal Int (v a) (w b) a b #

Indexed vector traversal for a generic vector.