content: {- |
  Labels for data types in the base package. The lens types are kept abstract to
  be fully reusable in custom contexts. Build to be imported qualified.
  -}
  
  {-# LANGUAGE
      NoMonomorphismRestriction
    , TemplateHaskell
    , TypeOperators
    #-}
  
  module Data.Label.Base
  (
  -- * Lenses for lists.
    head
  , tail
  
  -- * Lenses for Either.
  , left
  , right
  
  -- * Lens for Maybe.
  , just
  
  -- * Lenses for 2-tuples.
  , fst
  , snd
  , swap
  
  -- * Lenses for 3-tuples.
  , fst3
  , snd3
  , trd3
  
  -- * Read/Show isomorphism.
  , readShow
  )
  where
  
  import Prelude hiding (fst, snd, head, tail)
  import Control.Arrow (arr, Kleisli(..), ArrowApply, ArrowZero, ArrowChoice)
  import Data.Maybe (listToMaybe)
  import Data.Label.Partial (Partial)
  import Data.Label
  
  import qualified Data.Label.Mono as Mono
  import qualified Data.Label.Poly as Poly
  import qualified Data.Tuple      as Tuple
  
  -- | Lens pointing to the head of a list's cons cell. (Partial and monomorphic)
  
  head :: (ArrowZero arr, ArrowApply arr, ArrowChoice arr)
       => Mono.Lens arr [a] a
  
  -- | Lens pointing to the tail of a list's cons cell. (Partial and monomorphic)
  
  tail :: (ArrowZero arr, ArrowApply arr, ArrowChoice arr)
       => Mono.Lens arr [a] [a]
  
  (head, tail) = $(getLabel ''[])
  
  -- | Lens pointing to the left value in an Either. (Partial and polymorphic)
  
  left :: (ArrowZero arr, ArrowApply arr, ArrowChoice arr)
       => Poly.Lens arr (Either a b -> Either o b) (a -> o)
  
  -- | Lens pointing to the right value in an Either. (Partial and polymorphic)
  
  right :: (ArrowZero arr, ArrowApply arr, ArrowChoice arr)
        => Poly.Lens arr (Either a b -> Either a o) (b -> o)
  
  (left, right) = $(getLabel ''Either)
  
  -- | Lens pointing to the value in a Maybe. (Partial and polymorphic)
  
  just :: (ArrowChoice cat, ArrowZero cat, ArrowApply cat)
       => Poly.Lens cat (Maybe a -> Maybe b) (a -> b)
  
  just = $(getLabel ''Maybe)
  
  -- | Lens pointing to the first component of a 2-tuple. (Total and polymorphic)
  
  fst :: ArrowApply arr => Poly.Lens arr ((a, b) -> (o, b)) (a -> o)
  
  -- | Lens pointing to the second component of a 2-tuple. (Total and polymorphic)
  
  snd :: ArrowApply arr => Poly.Lens arr ((a, b) -> (a, o)) (b -> o)
  
  (fst, snd) = $(getLabel ''(,))
  
  -- | Polymorphic lens that swaps the components of a tuple. (Total and polymorphic)
  
  swap :: ArrowApply arr => Poly.Lens arr ((a, b) -> (c, d)) ((b, a) -> (d, c))
  swap = let io = Iso (arr Tuple.swap) (arr Tuple.swap) in Poly.iso io io
  
  -- | Lens pointing to the first component of a 3-tuple. (Total and polymorphic)
  
  fst3 :: ArrowApply arr => Poly.Lens arr ((a, b, c) -> (o, b, c)) (a -> o)
  
  -- | Lens pointing to the second component of a 3-tuple. (Total and polymorphic)
  
  snd3 :: ArrowApply arr => Poly.Lens arr ((a, b, c) -> (a, o, c)) (b -> o)
  
  -- | Lens pointing to the third component of a 3-tuple. (Total and polymorphic)
  
  trd3 :: ArrowApply arr => Poly.Lens arr ((a, b, c) -> (a, b, o)) (c -> o)
  
  (fst3, snd3, trd3) = $(getLabel ''(,,))
  
  -- | Partial isomorphism for readable and showable values. Can easily be lifted
  -- into a lens by using `iso`.
  
  readShow :: (Read a, Show a) => Iso Partial String a
  readShow = Iso r s
    where r = Kleisli (fmap Tuple.fst  . listToMaybe . readsPrec 0)
          s = arr show
  
  