{-# LANGUAGE CPP #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE UndecidableInstances #-}
{-# LANGUAGE Trustworthy #-}

{-# OPTIONS_GHC -fno-warn-orphans #-}

#ifndef MIN_VERSION_base
#define MIN_VERSION_base(x,y,z) 1
#endif


{- |
Module      :  Lens.Micro.Platform
Copyright   :  (C) 2013-2016 Edward Kmett, 2015-2016 Artyom Kazak, 2018 Monadfix
License     :  BSD-style (see the file LICENSE)

This module is an approximation for @<http://hackage.haskell.org/package/lens/docs/Control-Lens.html Control.Lens>@ from <http://hackage.haskell.org/package/lens lens>; by importing it you get all functions and instances from <http://hackage.haskell.org/package/microlens microlens>, <http://hackage.haskell.org/package/microlens-mtl microlens-mtl>, <http://hackage.haskell.org/package/microlens-ghc microlens-ghc>, as well as the following instances:

* 'at' for 'HashMap'

* 'each' and 'ix' for

    * 'HashMap'
    * 'Vector.Vector' and variants (unboxed vectors, etc)
    * strict 'T.Text' and lazy 'TL.Text'

* '_head', '_tail', '_init', '_last' for

    * 'Vector.Vector' and variants
    * strict and lazy @Text@

* 'strict' and 'lazy' for @Text@
-}
module Lens.Micro.Platform
(
  module Lens.Micro,
  module Lens.Micro.GHC,
  module Lens.Micro.Mtl,
  module Lens.Micro.TH,
  packed, unpacked,
)
where


import Lens.Micro.Internal
import Lens.Micro
import Lens.Micro.GHC
import Lens.Micro.Mtl
import Lens.Micro.TH
import Lens.Micro.Platform.Internal

import Data.Hashable
import Data.Int
import Data.Monoid
import Data.Functor (($>))

import Data.HashMap.Lazy as HashMap
import Data.HashSet as HashSet
import Data.Vector as Vector
import Data.Vector.Primitive as Prim
import Data.Vector.Storable as Storable
import Data.Vector.Unboxed as Unboxed
import Data.Vector.Generic as Generic

import qualified Data.Text as T
import qualified Data.Text.Lazy as TL

#if !MIN_VERSION_base(4,8,0)
import Control.Applicative
#endif


type instance Index   (HashMap k a) = k
type instance IxValue (HashMap k a) = a
type instance Index   (HashSet a) = a
type instance IxValue (HashSet a) = ()
type instance IxValue (HashMap k a) = a
type instance Index   (Vector.Vector a) = Int
type instance IxValue (Vector.Vector a) = a
type instance Index   (Prim.Vector a) = Int
type instance IxValue (Prim.Vector a) = a
type instance Index   (Storable.Vector a) = Int
type instance IxValue (Storable.Vector a) = a
type instance Index   (Unboxed.Vector a) = Int
type instance IxValue (Unboxed.Vector a) = a
type instance Index   T.Text = Int
type instance IxValue T.Text = Char
type instance Index   TL.Text = Int64
type instance IxValue TL.Text = Char

instance (Eq k, Hashable k) => Ixed (HashMap k a) where
  ix :: Index (HashMap k a)
-> Traversal' (HashMap k a) (IxValue (HashMap k a))
ix Index (HashMap k a)
k IxValue (HashMap k a) -> f (IxValue (HashMap k a))
f HashMap k a
m = case k -> HashMap k a -> Maybe a
forall k v. (Eq k, Hashable k) => k -> HashMap k v -> Maybe v
HashMap.lookup k
Index (HashMap k a)
k HashMap k a
m of
     Just a
v  -> IxValue (HashMap k a) -> f (IxValue (HashMap k a))
f a
IxValue (HashMap k a)
v f a -> (a -> HashMap k a) -> f (HashMap k a)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \a
v' -> k -> a -> HashMap k a -> HashMap k a
forall k v.
(Eq k, Hashable k) =>
k -> v -> HashMap k v -> HashMap k v
HashMap.insert k
Index (HashMap k a)
k a
v' HashMap k a
m
     Maybe a
Nothing -> HashMap k a -> f (HashMap k a)
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure HashMap k a
m
  {-# INLINE ix #-}

instance (Eq k, Hashable k) => At (HashMap k a) where
  at :: Index (HashMap k a)
-> Lens' (HashMap k a) (Maybe (IxValue (HashMap k a)))
at Index (HashMap k a)
k Maybe (IxValue (HashMap k a)) -> f (Maybe (IxValue (HashMap k a)))
f HashMap k a
m = Maybe (IxValue (HashMap k a)) -> f (Maybe (IxValue (HashMap k a)))
f Maybe a
Maybe (IxValue (HashMap k a))
mv f (Maybe a) -> (Maybe a -> HashMap k a) -> f (HashMap k a)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \Maybe a
r -> case Maybe a
r of
    Maybe a
Nothing -> HashMap k a -> (a -> HashMap k a) -> Maybe a -> HashMap k a
forall b a. b -> (a -> b) -> Maybe a -> b
maybe HashMap k a
m (HashMap k a -> a -> HashMap k a
forall a b. a -> b -> a
const (k -> HashMap k a -> HashMap k a
forall k v. (Eq k, Hashable k) => k -> HashMap k v -> HashMap k v
HashMap.delete k
Index (HashMap k a)
k HashMap k a
m)) Maybe a
mv
    Just a
v' -> k -> a -> HashMap k a -> HashMap k a
forall k v.
(Eq k, Hashable k) =>
k -> v -> HashMap k v -> HashMap k v
HashMap.insert k
Index (HashMap k a)
k a
v' HashMap k a
m
    where mv :: Maybe a
mv = k -> HashMap k a -> Maybe a
forall k v. (Eq k, Hashable k) => k -> HashMap k v -> Maybe v
HashMap.lookup k
Index (HashMap k a)
k HashMap k a
m
  {-# INLINE at #-}

instance (Eq k, Hashable k) => Ixed (HashSet k) where
  ix :: Index (HashSet k) -> Traversal' (HashSet k) (IxValue (HashSet k))
ix Index (HashSet k)
k IxValue (HashSet k) -> f (IxValue (HashSet k))
f HashSet k
m = if k -> HashSet k -> Bool
forall a. (Eq a, Hashable a) => a -> HashSet a -> Bool
HashSet.member k
Index (HashSet k)
k HashSet k
m
     then IxValue (HashSet k) -> f (IxValue (HashSet k))
f () f () -> HashSet k -> f (HashSet k)
forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> HashSet k
m
     else HashSet k -> f (HashSet k)
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure HashSet k
m
  {-# INLINE ix #-}

instance (Eq k, Hashable k) => At (HashSet k) where
  at :: Index (HashSet k)
-> Lens' (HashSet k) (Maybe (IxValue (HashSet k)))
at Index (HashSet k)
k Maybe (IxValue (HashSet k)) -> f (Maybe (IxValue (HashSet k)))
f HashSet k
s = HashMap k () -> HashSet k
forall a. HashMap a () -> HashSet a
HashSet.fromMap (HashMap k () -> HashSet k) -> f (HashMap k ()) -> f (HashSet k)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Maybe () -> f (Maybe ())) -> k -> HashMap k () -> f (HashMap k ())
forall (f :: * -> *) k v.
(Functor f, Eq k, Hashable k) =>
(Maybe v -> f (Maybe v)) -> k -> HashMap k v -> f (HashMap k v)
HashMap.alterF Maybe () -> f (Maybe ())
Maybe (IxValue (HashSet k)) -> f (Maybe (IxValue (HashSet k)))
f k
Index (HashSet k)
k (HashSet k -> HashMap k ()
forall a. HashSet a -> HashMap a ()
HashSet.toMap HashSet k
s)
  {-# INLINE at #-}

instance Ixed (Vector.Vector a) where
  ix :: Index (Vector a) -> Traversal' (Vector a) (IxValue (Vector a))
ix Index (Vector a)
i IxValue (Vector a) -> f (IxValue (Vector a))
f Vector a
v
    | Int
0 Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
Index (Vector a)
i Bool -> Bool -> Bool
&& Int
Index (Vector a)
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Vector a -> Int
forall a. Vector a -> Int
Vector.length Vector a
v = IxValue (Vector a) -> f (IxValue (Vector a))
f (Vector a
v Vector a -> Int -> a
forall a. Vector a -> Int -> a
Vector.! Int
Index (Vector a)
i) f a -> (a -> Vector a) -> f (Vector a)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \a
a -> Vector a
v Vector a -> [(Int, a)] -> Vector a
forall a. Vector a -> [(Int, a)] -> Vector a
Vector.// [(Int
Index (Vector a)
i, a
a)]
    | Bool
otherwise                     = Vector a -> f (Vector a)
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Vector a
v
  {-# INLINE ix #-}

instance Prim a => Ixed (Prim.Vector a) where
  ix :: Index (Vector a) -> Traversal' (Vector a) (IxValue (Vector a))
ix Index (Vector a)
i IxValue (Vector a) -> f (IxValue (Vector a))
f Vector a
v
    | Int
0 Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
Index (Vector a)
i Bool -> Bool -> Bool
&& Int
Index (Vector a)
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Vector a -> Int
forall a. Prim a => Vector a -> Int
Prim.length Vector a
v = IxValue (Vector a) -> f (IxValue (Vector a))
f (Vector a
v Vector a -> Int -> a
forall a. Prim a => Vector a -> Int -> a
Prim.! Int
Index (Vector a)
i) f a -> (a -> Vector a) -> f (Vector a)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \a
a -> Vector a
v Vector a -> [(Int, a)] -> Vector a
forall a. Prim a => Vector a -> [(Int, a)] -> Vector a
Prim.// [(Int
Index (Vector a)
i, a
a)]
    | Bool
otherwise                   = Vector a -> f (Vector a)
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Vector a
v
  {-# INLINE ix #-}

instance Storable a => Ixed (Storable.Vector a) where
  ix :: Index (Vector a) -> Traversal' (Vector a) (IxValue (Vector a))
ix Index (Vector a)
i IxValue (Vector a) -> f (IxValue (Vector a))
f Vector a
v
    | Int
0 Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
Index (Vector a)
i Bool -> Bool -> Bool
&& Int
Index (Vector a)
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Vector a -> Int
forall a. Storable a => Vector a -> Int
Storable.length Vector a
v = IxValue (Vector a) -> f (IxValue (Vector a))
f (Vector a
v Vector a -> Int -> a
forall a. Storable a => Vector a -> Int -> a
Storable.! Int
Index (Vector a)
i) f a -> (a -> Vector a) -> f (Vector a)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \a
a -> Vector a
v Vector a -> [(Int, a)] -> Vector a
forall a. Storable a => Vector a -> [(Int, a)] -> Vector a
Storable.// [(Int
Index (Vector a)
i, a
a)]
    | Bool
otherwise                       = Vector a -> f (Vector a)
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Vector a
v
  {-# INLINE ix #-}

instance Unbox a => Ixed (Unboxed.Vector a) where
  ix :: Index (Vector a) -> Traversal' (Vector a) (IxValue (Vector a))
ix Index (Vector a)
i IxValue (Vector a) -> f (IxValue (Vector a))
f Vector a
v
    | Int
0 Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
Index (Vector a)
i Bool -> Bool -> Bool
&& Int
Index (Vector a)
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Vector a -> Int
forall a. Unbox a => Vector a -> Int
Unboxed.length Vector a
v = IxValue (Vector a) -> f (IxValue (Vector a))
f (Vector a
v Vector a -> Int -> a
forall a. Unbox a => Vector a -> Int -> a
Unboxed.! Int
Index (Vector a)
i) f a -> (a -> Vector a) -> f (Vector a)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \a
a -> Vector a
v Vector a -> [(Int, a)] -> Vector a
forall a. Unbox a => Vector a -> [(Int, a)] -> Vector a
Unboxed.// [(Int
Index (Vector a)
i, a
a)]
    | Bool
otherwise                      = Vector a -> f (Vector a)
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Vector a
v
  {-# INLINE ix #-}

instance Ixed T.Text where
  ix :: Index Text -> Traversal' Text (IxValue Text)
ix Index Text
e IxValue Text -> f (IxValue Text)
f Text
s = case Int -> Text -> (Text, Text)
T.splitAt Int
Index Text
e Text
s of
     (Text
l, Text
mr) -> case Text -> Maybe (Char, Text)
T.uncons Text
mr of
       Maybe (Char, Text)
Nothing      -> Text -> f Text
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Text
s
       Just (Char
c, Text
xs) -> IxValue Text -> f (IxValue Text)
f Char
IxValue Text
c f Char -> (Char -> Text) -> f Text
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \Char
d -> [Text] -> Text
T.concat [Text
l, Char -> Text
T.singleton Char
d, Text
xs]
  {-# INLINE ix #-}

instance Ixed TL.Text where
  ix :: Index Text -> Traversal' Text (IxValue Text)
ix Index Text
e IxValue Text -> f (IxValue Text)
f Text
s = case Int64 -> Text -> (Text, Text)
TL.splitAt Int64
Index Text
e Text
s of
     (Text
l, Text
mr) -> case Text -> Maybe (Char, Text)
TL.uncons Text
mr of
       Maybe (Char, Text)
Nothing      -> Text -> f Text
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Text
s
       Just (Char
c, Text
xs) -> IxValue Text -> f (IxValue Text)
f Char
IxValue Text
c f Char -> (Char -> Text) -> f Text
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \Char
d -> Text -> Text -> Text
TL.append Text
l (Char -> Text -> Text
TL.cons Char
d Text
xs)
  {-# INLINE ix #-}

instance Cons T.Text T.Text Char Char where
  _Cons :: Traversal Text Text (Char, Text) (Char, Text)
_Cons (Char, Text) -> f (Char, Text)
f Text
s = case Text -> Maybe (Char, Text)
T.uncons Text
s of
    Just (Char, Text)
x  -> (Char -> Text -> Text) -> (Char, Text) -> Text
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry Char -> Text -> Text
T.cons ((Char, Text) -> Text) -> f (Char, Text) -> f Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Char, Text) -> f (Char, Text)
f (Char, Text)
x
    Maybe (Char, Text)
Nothing -> Text -> f Text
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Text
T.empty
  {-# INLINE _Cons #-}

instance Cons TL.Text TL.Text Char Char where
  _Cons :: Traversal Text Text (Char, Text) (Char, Text)
_Cons (Char, Text) -> f (Char, Text)
f Text
s = case Text -> Maybe (Char, Text)
TL.uncons Text
s of
    Just (Char, Text)
x  -> (Char -> Text -> Text) -> (Char, Text) -> Text
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry Char -> Text -> Text
TL.cons ((Char, Text) -> Text) -> f (Char, Text) -> f Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Char, Text) -> f (Char, Text)
f (Char, Text)
x
    Maybe (Char, Text)
Nothing -> Text -> f Text
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Text
TL.empty
  {-# INLINE _Cons #-}

instance Snoc T.Text T.Text Char Char where
  _Snoc :: Traversal Text Text (Text, Char) (Text, Char)
_Snoc (Text, Char) -> f (Text, Char)
f Text
s = if Text -> Bool
T.null Text
s
    then Text -> f Text
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Text
T.empty
    else (Text -> Char -> Text) -> (Text, Char) -> Text
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry Text -> Char -> Text
T.snoc ((Text, Char) -> Text) -> f (Text, Char) -> f Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Text, Char) -> f (Text, Char)
f (HasCallStack => Text -> Text
Text -> Text
T.init Text
s, HasCallStack => Text -> Char
Text -> Char
T.last Text
s)
  {-# INLINE _Snoc #-}

instance Snoc TL.Text TL.Text Char Char where
  _Snoc :: Traversal Text Text (Text, Char) (Text, Char)
_Snoc (Text, Char) -> f (Text, Char)
f Text
s = if Text -> Bool
TL.null Text
s
    then Text -> f Text
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Text
TL.empty
    else (Text -> Char -> Text) -> (Text, Char) -> Text
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry Text -> Char -> Text
TL.snoc ((Text, Char) -> Text) -> f (Text, Char) -> f Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Text, Char) -> f (Text, Char)
f (HasCallStack => Text -> Text
Text -> Text
TL.init Text
s, HasCallStack => Text -> Char
Text -> Char
TL.last Text
s)
  {-# INLINE _Snoc #-}

instance Cons (Vector.Vector a) (Vector.Vector b) a b where
  _Cons :: Traversal (Vector a) (Vector b) (a, Vector a) (b, Vector b)
_Cons (a, Vector a) -> f (b, Vector b)
f Vector a
s = if Vector a -> Bool
forall a. Vector a -> Bool
Vector.null Vector a
s
    then Vector b -> f (Vector b)
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Vector b
forall a. Vector a
Vector.empty
    else (b -> Vector b -> Vector b) -> (b, Vector b) -> Vector b
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry b -> Vector b -> Vector b
forall a. a -> Vector a -> Vector a
Vector.cons ((b, Vector b) -> Vector b) -> f (b, Vector b) -> f (Vector b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (a, Vector a) -> f (b, Vector b)
f (Vector a -> a
forall a. Vector a -> a
Vector.unsafeHead Vector a
s, Vector a -> Vector a
forall a. Vector a -> Vector a
Vector.unsafeTail Vector a
s)
  {-# INLINE _Cons #-}

instance (Prim a, Prim b) => Cons (Prim.Vector a) (Prim.Vector b) a b where
  _Cons :: Traversal (Vector a) (Vector b) (a, Vector a) (b, Vector b)
_Cons (a, Vector a) -> f (b, Vector b)
f Vector a
s = if Vector a -> Bool
forall a. Prim a => Vector a -> Bool
Prim.null Vector a
s
    then Vector b -> f (Vector b)
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Vector b
forall a. Prim a => Vector a
Prim.empty
    else (b -> Vector b -> Vector b) -> (b, Vector b) -> Vector b
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry b -> Vector b -> Vector b
forall a. Prim a => a -> Vector a -> Vector a
Prim.cons ((b, Vector b) -> Vector b) -> f (b, Vector b) -> f (Vector b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (a, Vector a) -> f (b, Vector b)
f (Vector a -> a
forall a. Prim a => Vector a -> a
Prim.unsafeHead Vector a
s, Vector a -> Vector a
forall a. Prim a => Vector a -> Vector a
Prim.unsafeTail Vector a
s)
  {-# INLINE _Cons #-}

instance (Storable a, Storable b) => Cons (Storable.Vector a) (Storable.Vector b) a b where
  _Cons :: Traversal (Vector a) (Vector b) (a, Vector a) (b, Vector b)
_Cons (a, Vector a) -> f (b, Vector b)
f Vector a
s = if Vector a -> Bool
forall a. Storable a => Vector a -> Bool
Storable.null Vector a
s
    then Vector b -> f (Vector b)
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Vector b
forall a. Storable a => Vector a
Storable.empty
    else (b -> Vector b -> Vector b) -> (b, Vector b) -> Vector b
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry b -> Vector b -> Vector b
forall a. Storable a => a -> Vector a -> Vector a
Storable.cons ((b, Vector b) -> Vector b) -> f (b, Vector b) -> f (Vector b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (a, Vector a) -> f (b, Vector b)
f (Vector a -> a
forall a. Storable a => Vector a -> a
Storable.unsafeHead Vector a
s, Vector a -> Vector a
forall a. Storable a => Vector a -> Vector a
Storable.unsafeTail Vector a
s)
  {-# INLINE _Cons #-}

instance (Unbox a, Unbox b) => Cons (Unboxed.Vector a) (Unboxed.Vector b) a b where
  _Cons :: Traversal (Vector a) (Vector b) (a, Vector a) (b, Vector b)
_Cons (a, Vector a) -> f (b, Vector b)
f Vector a
s = if Vector a -> Bool
forall a. Unbox a => Vector a -> Bool
Unboxed.null Vector a
s
    then Vector b -> f (Vector b)
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Vector b
forall a. Unbox a => Vector a
Unboxed.empty
    else (b -> Vector b -> Vector b) -> (b, Vector b) -> Vector b
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry b -> Vector b -> Vector b
forall a. Unbox a => a -> Vector a -> Vector a
Unboxed.cons ((b, Vector b) -> Vector b) -> f (b, Vector b) -> f (Vector b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (a, Vector a) -> f (b, Vector b)
f (Vector a -> a
forall a. Unbox a => Vector a -> a
Unboxed.unsafeHead Vector a
s, Vector a -> Vector a
forall a. Unbox a => Vector a -> Vector a
Unboxed.unsafeTail Vector a
s)
  {-# INLINE _Cons #-}

instance Snoc (Vector.Vector a) (Vector.Vector b) a b where
  _Snoc :: Traversal (Vector a) (Vector b) (Vector a, a) (Vector b, b)
_Snoc (Vector a, a) -> f (Vector b, b)
f Vector a
s = if Vector a -> Bool
forall a. Vector a -> Bool
Vector.null Vector a
s
    then Vector b -> f (Vector b)
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Vector b
forall a. Vector a
Vector.empty
    else (Vector b -> b -> Vector b) -> (Vector b, b) -> Vector b
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry Vector b -> b -> Vector b
forall a. Vector a -> a -> Vector a
Vector.snoc ((Vector b, b) -> Vector b) -> f (Vector b, b) -> f (Vector b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Vector a, a) -> f (Vector b, b)
f (Vector a -> Vector a
forall a. Vector a -> Vector a
Vector.unsafeInit Vector a
s, Vector a -> a
forall a. Vector a -> a
Vector.unsafeLast Vector a
s)
  {-# INLINE _Snoc #-}

instance (Prim a, Prim b) => Snoc (Prim.Vector a) (Prim.Vector b) a b where
  _Snoc :: Traversal (Vector a) (Vector b) (Vector a, a) (Vector b, b)
_Snoc (Vector a, a) -> f (Vector b, b)
f Vector a
s = if Vector a -> Bool
forall a. Prim a => Vector a -> Bool
Prim.null Vector a
s
    then Vector b -> f (Vector b)
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Vector b
forall a. Prim a => Vector a
Prim.empty
    else (Vector b -> b -> Vector b) -> (Vector b, b) -> Vector b
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry Vector b -> b -> Vector b
forall a. Prim a => Vector a -> a -> Vector a
Prim.snoc ((Vector b, b) -> Vector b) -> f (Vector b, b) -> f (Vector b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Vector a, a) -> f (Vector b, b)
f (Vector a -> Vector a
forall a. Prim a => Vector a -> Vector a
Prim.unsafeInit Vector a
s, Vector a -> a
forall a. Prim a => Vector a -> a
Prim.unsafeLast Vector a
s)
  {-# INLINE _Snoc #-}

instance (Storable a, Storable b) => Snoc (Storable.Vector a) (Storable.Vector b) a b where
  _Snoc :: Traversal (Vector a) (Vector b) (Vector a, a) (Vector b, b)
_Snoc (Vector a, a) -> f (Vector b, b)
f Vector a
s = if Vector a -> Bool
forall a. Storable a => Vector a -> Bool
Storable.null Vector a
s
    then Vector b -> f (Vector b)
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Vector b
forall a. Storable a => Vector a
Storable.empty
    else (Vector b -> b -> Vector b) -> (Vector b, b) -> Vector b
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry Vector b -> b -> Vector b
forall a. Storable a => Vector a -> a -> Vector a
Storable.snoc ((Vector b, b) -> Vector b) -> f (Vector b, b) -> f (Vector b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Vector a, a) -> f (Vector b, b)
f (Vector a -> Vector a
forall a. Storable a => Vector a -> Vector a
Storable.unsafeInit Vector a
s, Vector a -> a
forall a. Storable a => Vector a -> a
Storable.unsafeLast Vector a
s)
  {-# INLINE _Snoc #-}

instance (Unbox a, Unbox b) => Snoc (Unboxed.Vector a) (Unboxed.Vector b) a b where
  _Snoc :: Traversal (Vector a) (Vector b) (Vector a, a) (Vector b, b)
_Snoc (Vector a, a) -> f (Vector b, b)
f Vector a
s = if Vector a -> Bool
forall a. Unbox a => Vector a -> Bool
Unboxed.null Vector a
s
    then Vector b -> f (Vector b)
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Vector b
forall a. Unbox a => Vector a
Unboxed.empty
    else (Vector b -> b -> Vector b) -> (Vector b, b) -> Vector b
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry Vector b -> b -> Vector b
forall a. Unbox a => Vector a -> a -> Vector a
Unboxed.snoc ((Vector b, b) -> Vector b) -> f (Vector b, b) -> f (Vector b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Vector a, a) -> f (Vector b, b)
f (Vector a -> Vector a
forall a. Unbox a => Vector a -> Vector a
Unboxed.unsafeInit Vector a
s, Vector a -> a
forall a. Unbox a => Vector a -> a
Unboxed.unsafeLast Vector a
s)
  {-# INLINE _Snoc #-}

instance Each (Vector.Vector a) (Vector.Vector b) a b where
  each :: Traversal (Vector a) (Vector b) a b
each = (a -> f b) -> Vector a -> f (Vector b)
Traversal (Vector a) (Vector b) a b
forall (v :: * -> *) a (w :: * -> *) b.
(Vector v a, Vector w b) =>
Traversal (v a) (w b) a b
vectorTraverse
  {-# INLINE each #-}

instance (Prim a, Prim b) => Each (Prim.Vector a) (Prim.Vector b) a b where
  each :: Traversal (Vector a) (Vector b) a b
each = (a -> f b) -> Vector a -> f (Vector b)
Traversal (Vector a) (Vector b) a b
forall (v :: * -> *) a (w :: * -> *) b.
(Vector v a, Vector w b) =>
Traversal (v a) (w b) a b
vectorTraverse
  {-# INLINE each #-}

instance (Storable a, Storable b) => Each (Storable.Vector a) (Storable.Vector b) a b where
  each :: Traversal (Vector a) (Vector b) a b
each = (a -> f b) -> Vector a -> f (Vector b)
Traversal (Vector a) (Vector b) a b
forall (v :: * -> *) a (w :: * -> *) b.
(Vector v a, Vector w b) =>
Traversal (v a) (w b) a b
vectorTraverse
  {-# INLINE each #-}

instance (Unbox a, Unbox b) => Each (Unboxed.Vector a) (Unboxed.Vector b) a b where
  each :: Traversal (Vector a) (Vector b) a b
each = (a -> f b) -> Vector a -> f (Vector b)
Traversal (Vector a) (Vector b) a b
forall (v :: * -> *) a (w :: * -> *) b.
(Vector v a, Vector w b) =>
Traversal (v a) (w b) a b
vectorTraverse
  {-# INLINE each #-}

instance (c ~ d) => Each (HashMap c a) (HashMap d b) a b where
  each :: Traversal (HashMap c a) (HashMap d b) a b
each = (a -> f b) -> HashMap c a -> f (HashMap c b)
(a -> f b) -> HashMap c a -> f (HashMap d b)
Traversal (HashMap c a) (HashMap c b) a b
forall (f :: * -> *) a b.
Traversable f =>
Traversal (f a) (f b) a b
traversed
  {-# INLINE each #-}

instance (a ~ Char, b ~ Char) => Each T.Text T.Text a b where
  each :: Traversal Text Text a b
each = (a -> f b) -> Text -> f Text
(Char -> f Char) -> Text -> f Text
Traversal' Text Char
strictText
  {-# INLINE each #-}

instance (a ~ Char, b ~ Char) => Each TL.Text TL.Text a b where
  each :: Traversal Text Text a b
each = (a -> f b) -> Text -> f Text
(Char -> f Char) -> Text -> f Text
Traversal' Text Char
lazyText
  {-# INLINE each #-}

strictUnpacked :: Lens' T.Text String
strictUnpacked :: Lens' Text String
strictUnpacked String -> f String
f Text
t = String -> Text
T.pack (String -> Text) -> f String -> f Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> String -> f String
f (Text -> String
T.unpack Text
t)
{-# INLINE strictUnpacked #-}

strictText :: Traversal' T.Text Char
strictText :: Traversal' Text Char
strictText = (String -> f String) -> Text -> f Text
Lens' Text String
strictUnpacked ((String -> f String) -> Text -> f Text)
-> ((Char -> f Char) -> String -> f String)
-> (Char -> f Char)
-> Text
-> f Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char -> f Char) -> String -> f String
Traversal String String Char Char
forall (f :: * -> *) a b.
Traversable f =>
Traversal (f a) (f b) a b
traversed
{-# INLINE [0] strictText #-}

{-# RULES
"strict text -> map"    strictText = sets T.map        :: ASetter' T.Text Char;
"strict text -> foldr"  strictText = foldring T.foldr  :: Getting (Endo r) T.Text Char;
 #-}

lazyUnpacked :: Lens' TL.Text String
lazyUnpacked :: Lens' Text String
lazyUnpacked String -> f String
f Text
t = String -> Text
TL.pack (String -> Text) -> f String -> f Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> String -> f String
f (Text -> String
TL.unpack Text
t)
{-# INLINE lazyUnpacked #-}

lazyText :: Traversal' TL.Text Char
lazyText :: Traversal' Text Char
lazyText = (String -> f String) -> Text -> f Text
Lens' Text String
lazyUnpacked ((String -> f String) -> Text -> f Text)
-> ((Char -> f Char) -> String -> f String)
-> (Char -> f Char)
-> Text
-> f Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char -> f Char) -> String -> f String
Traversal String String Char Char
forall (f :: * -> *) a b.
Traversable f =>
Traversal (f a) (f b) a b
traversed
{-# INLINE [0] lazyText #-}

{-# RULES
"lazy text -> map"    lazyText = sets TL.map        :: ASetter' TL.Text Char;
"lazy text -> foldr"  lazyText = foldring TL.foldr  :: Getting (Endo r) TL.Text Char;
 #-}

vectorTraverse :: (Generic.Vector v a, Generic.Vector w b) => Traversal (v a) (w b) a b
vectorTraverse :: forall (v :: * -> *) a (w :: * -> *) b.
(Vector v a, Vector w b) =>
Traversal (v a) (w b) a b
vectorTraverse a -> f b
f v a
v = Int -> [b] -> w b
forall (v :: * -> *) a. Vector v a => Int -> [a] -> v a
Generic.fromListN (v a -> Int
forall (v :: * -> *) a. Vector v a => v a -> Int
Generic.length v a
v) ([b] -> w b) -> f [b] -> f (w b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (a -> f b) -> [a] -> f [b]
Traversal [a] [b] a b
forall (f :: * -> *) a b.
Traversable f =>
Traversal (f a) (f b) a b
traversed a -> f b
f (v a -> [a]
forall (v :: * -> *) a. Vector v a => v a -> [a]
Generic.toList v a
v)
{-# INLINE [0] vectorTraverse #-}

{-# RULES
"vectorTraverse -> mapped" vectorTraverse  = sets Generic.map         :: (Generic.Vector v a, Generic.Vector v b) => ASetter (v a) (v b) a b;
"vectorTraverse -> foldr"  vectorTraverse  = foldring Generic.foldr   :: Generic.Vector v a => Getting (Endo r) (v a) a;
 #-}

instance Strict TL.Text T.Text where
  strict :: Lens' Text Text
strict Text -> f Text
f Text
s = Text -> Text
TL.fromStrict (Text -> Text) -> f Text -> f Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Text -> f Text
f (Text -> Text
TL.toStrict Text
s)
  {-# INLINE strict #-}
  lazy :: Lens' Text Text
lazy Text -> f Text
f Text
s = Text -> Text
TL.toStrict (Text -> Text) -> f Text -> f Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Text -> f Text
f (Text -> Text
TL.fromStrict Text
s)
  {-# INLINE lazy #-}