Copyright	(c) Winterland 2016
License	BSD
Maintainer	drkoster@qq.com
Stability	experimental
Portability	PORTABLE
Safe Haskell	Safe
Language	Haskell2010

Data.Has

Description

This module provide Has class which provide simple extensible product. The use case for this class is illustrated as following:

 {-# LANGUAGE FlexibleContexts #-}

 -- in some library code
 ...
 logInAnyReaderHasLogger :: (Has Logger r, MonadReader r m) => LogString -> m ()
 logInAnyReaderHasLogger s = asks getter >>= logWithLogger s

 queryInAnyReaderHasSQL :: (Has SqlBackEnd r, MonadReader r m) => Query -> m a
 queryInAnyReaderHasSQL q = asks getter >>= queryWithSQL q
 ...

 -- now you want to use these effects together
 ...
 logger <- initLogger  ...
 sql <- initSqlBackEnd ...

 (`runReader` (logger, sql)) $ do
       ...
       logInAnyReaderHasLogger ...
       ...
       x <- queryInAnyReaderHasSQL ...
       ...

If you need multiple elements with same type, you can use tagged like:

(Has (Tagged "StdLogger" Logger) r, Has (Tagged "FileLogger" Logger) r, ...) => ...

runYourMonad ... ( stdLogger :: Tagged "StdLogger" Logger
                 , fileLogger :: Tagged "FileLogger" Logger, ...)

Or you can define newtypes(which is less verbose and require no dependency):

newtype StdLogger = StdLogger Logger
newtype FileLogger = FileLogger Logger

runYourMonad ... (StdLogger stdLogger, FileLogger fileLogger)

Polymorphic values, such as numeric and string literals(with OverloadedString Enabled) may lead to type inference failure, you simply need type annotations in these cases:

 ... (3 :: Int, "hello" :: String, ...)

Synopsis

Documentation

class Has a t where #

A type class for extensible product.

We provide instances for tuples up to 12 elements by default. You can define your own instance of Has, but most of the time tuples will do fine.

Minimal complete definition

getter, modifier | hasLens

Methods

getter :: t -> a #

modifier :: (a -> a) -> t -> t #

hasLens :: Lens t a #

Instances

Has a a #
Methods getter :: a -> a # modifier :: (a -> a) -> a -> a # hasLens :: Lens a a #
Has b (a, b) #
Methods getter :: (a, b) -> b # modifier :: (b -> b) -> (a, b) -> (a, b) # hasLens :: Lens (a, b) b #
Has a (a, b) #
Methods getter :: (a, b) -> a # modifier :: (a -> a) -> (a, b) -> (a, b) # hasLens :: Lens (a, b) a #
Has c (a, b, c) #
Methods getter :: (a, b, c) -> c # modifier :: (c -> c) -> (a, b, c) -> (a, b, c) # hasLens :: Lens (a, b, c) c #
Has b (a, b, c) #
Methods getter :: (a, b, c) -> b # modifier :: (b -> b) -> (a, b, c) -> (a, b, c) # hasLens :: Lens (a, b, c) b #
Has a (a, b, c) #
Methods getter :: (a, b, c) -> a # modifier :: (a -> a) -> (a, b, c) -> (a, b, c) # hasLens :: Lens (a, b, c) a #
Has d (a, b, c, d) #
Methods getter :: (a, b, c, d) -> d # modifier :: (d -> d) -> (a, b, c, d) -> (a, b, c, d) # hasLens :: Lens (a, b, c, d) d #
Has c (a, b, c, d) #
Methods getter :: (a, b, c, d) -> c # modifier :: (c -> c) -> (a, b, c, d) -> (a, b, c, d) # hasLens :: Lens (a, b, c, d) c #
Has b (a, b, c, d) #
Methods getter :: (a, b, c, d) -> b # modifier :: (b -> b) -> (a, b, c, d) -> (a, b, c, d) # hasLens :: Lens (a, b, c, d) b #
Has a (a, b, c, d) #
Methods getter :: (a, b, c, d) -> a # modifier :: (a -> a) -> (a, b, c, d) -> (a, b, c, d) # hasLens :: Lens (a, b, c, d) a #
Has e (a, b, c, d, e) #
Methods getter :: (a, b, c, d, e) -> e # modifier :: (e -> e) -> (a, b, c, d, e) -> (a, b, c, d, e) # hasLens :: Lens (a, b, c, d, e) e #
Has d (a, b, c, d, e) #
Methods getter :: (a, b, c, d, e) -> d # modifier :: (d -> d) -> (a, b, c, d, e) -> (a, b, c, d, e) # hasLens :: Lens (a, b, c, d, e) d #
Has c (a, b, c, d, e) #
Methods getter :: (a, b, c, d, e) -> c # modifier :: (c -> c) -> (a, b, c, d, e) -> (a, b, c, d, e) # hasLens :: Lens (a, b, c, d, e) c #
Has b (a, b, c, d, e) #
Methods getter :: (a, b, c, d, e) -> b # modifier :: (b -> b) -> (a, b, c, d, e) -> (a, b, c, d, e) # hasLens :: Lens (a, b, c, d, e) b #
Has a (a, b, c, d, e) #
Methods getter :: (a, b, c, d, e) -> a # modifier :: (a -> a) -> (a, b, c, d, e) -> (a, b, c, d, e) # hasLens :: Lens (a, b, c, d, e) a #
Has f (a, b, c, d, e, f) #
Methods getter :: (a, b, c, d, e, f) -> f # modifier :: (f -> f) -> (a, b, c, d, e, f) -> (a, b, c, d, e, f) # hasLens :: Lens (a, b, c, d, e, f) f #
Has e (a, b, c, d, e, f) #
Methods getter :: (a, b, c, d, e, f) -> e # modifier :: (e -> e) -> (a, b, c, d, e, f) -> (a, b, c, d, e, f) # hasLens :: Lens (a, b, c, d, e, f) e #
Has d (a, b, c, d, e, f) #
Methods getter :: (a, b, c, d, e, f) -> d # modifier :: (d -> d) -> (a, b, c, d, e, f) -> (a, b, c, d, e, f) # hasLens :: Lens (a, b, c, d, e, f) d #
Has c (a, b, c, d, e, f) #
Methods getter :: (a, b, c, d, e, f) -> c # modifier :: (c -> c) -> (a, b, c, d, e, f) -> (a, b, c, d, e, f) # hasLens :: Lens (a, b, c, d, e, f) c #
Has b (a, b, c, d, e, f) #
Methods getter :: (a, b, c, d, e, f) -> b # modifier :: (b -> b) -> (a, b, c, d, e, f) -> (a, b, c, d, e, f) # hasLens :: Lens (a, b, c, d, e, f) b #
Has a (a, b, c, d, e, f) #
Methods getter :: (a, b, c, d, e, f) -> a # modifier :: (a -> a) -> (a, b, c, d, e, f) -> (a, b, c, d, e, f) # hasLens :: Lens (a, b, c, d, e, f) a #
Has g (a, b, c, d, e, f, g) #
Methods getter :: (a, b, c, d, e, f, g) -> g # modifier :: (g -> g) -> (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) # hasLens :: Lens (a, b, c, d, e, f, g) g #
Has f (a, b, c, d, e, f, g) #
Methods getter :: (a, b, c, d, e, f, g) -> f # modifier :: (f -> f) -> (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) # hasLens :: Lens (a, b, c, d, e, f, g) f #
Has e (a, b, c, d, e, f, g) #
Methods getter :: (a, b, c, d, e, f, g) -> e # modifier :: (e -> e) -> (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) # hasLens :: Lens (a, b, c, d, e, f, g) e #
Has d (a, b, c, d, e, f, g) #
Methods getter :: (a, b, c, d, e, f, g) -> d # modifier :: (d -> d) -> (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) # hasLens :: Lens (a, b, c, d, e, f, g) d #
Has c (a, b, c, d, e, f, g) #
Methods getter :: (a, b, c, d, e, f, g) -> c # modifier :: (c -> c) -> (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) # hasLens :: Lens (a, b, c, d, e, f, g) c #
Has b (a, b, c, d, e, f, g) #
Methods getter :: (a, b, c, d, e, f, g) -> b # modifier :: (b -> b) -> (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) # hasLens :: Lens (a, b, c, d, e, f, g) b #
Has a (a, b, c, d, e, f, g) #
Methods getter :: (a, b, c, d, e, f, g) -> a # modifier :: (a -> a) -> (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) # hasLens :: Lens (a, b, c, d, e, f, g) a #
Has h (a, b, c, d, e, f, g, h) #
Methods getter :: (a, b, c, d, e, f, g, h) -> h # modifier :: (h -> h) -> (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) # hasLens :: Lens (a, b, c, d, e, f, g, h) h #
Has g (a, b, c, d, e, f, g, h) #
Methods getter :: (a, b, c, d, e, f, g, h) -> g # modifier :: (g -> g) -> (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) # hasLens :: Lens (a, b, c, d, e, f, g, h) g #
Has f (a, b, c, d, e, f, g, h) #
Methods getter :: (a, b, c, d, e, f, g, h) -> f # modifier :: (f -> f) -> (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) # hasLens :: Lens (a, b, c, d, e, f, g, h) f #
Has e (a, b, c, d, e, f, g, h) #
Methods getter :: (a, b, c, d, e, f, g, h) -> e # modifier :: (e -> e) -> (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) # hasLens :: Lens (a, b, c, d, e, f, g, h) e #
Has d (a, b, c, d, e, f, g, h) #
Methods getter :: (a, b, c, d, e, f, g, h) -> d # modifier :: (d -> d) -> (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) # hasLens :: Lens (a, b, c, d, e, f, g, h) d #
Has c (a, b, c, d, e, f, g, h) #
Methods getter :: (a, b, c, d, e, f, g, h) -> c # modifier :: (c -> c) -> (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) # hasLens :: Lens (a, b, c, d, e, f, g, h) c #
Has b (a, b, c, d, e, f, g, h) #
Methods getter :: (a, b, c, d, e, f, g, h) -> b # modifier :: (b -> b) -> (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) # hasLens :: Lens (a, b, c, d, e, f, g, h) b #
Has a (a, b, c, d, e, f, g, h) #
Methods getter :: (a, b, c, d, e, f, g, h) -> a # modifier :: (a -> a) -> (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) # hasLens :: Lens (a, b, c, d, e, f, g, h) a #
Has i (a, b, c, d, e, f, g, h, i) #
Methods getter :: (a, b, c, d, e, f, g, h, i) -> i # modifier :: (i -> i) -> (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) # hasLens :: Lens (a, b, c, d, e, f, g, h, i) i #
Has h (a, b, c, d, e, f, g, h, i) #
Methods getter :: (a, b, c, d, e, f, g, h, i) -> h # modifier :: (h -> h) -> (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) # hasLens :: Lens (a, b, c, d, e, f, g, h, i) h #
Has g (a, b, c, d, e, f, g, h, i) #
Methods getter :: (a, b, c, d, e, f, g, h, i) -> g # modifier :: (g -> g) -> (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) # hasLens :: Lens (a, b, c, d, e, f, g, h, i) g #
Has f (a, b, c, d, e, f, g, h, i) #
Methods getter :: (a, b, c, d, e, f, g, h, i) -> f # modifier :: (f -> f) -> (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) # hasLens :: Lens (a, b, c, d, e, f, g, h, i) f #
Has e (a, b, c, d, e, f, g, h, i) #
Methods getter :: (a, b, c, d, e, f, g, h, i) -> e # modifier :: (e -> e) -> (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) # hasLens :: Lens (a, b, c, d, e, f, g, h, i) e #
Has d (a, b, c, d, e, f, g, h, i) #
Methods getter :: (a, b, c, d, e, f, g, h, i) -> d # modifier :: (d -> d) -> (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) # hasLens :: Lens (a, b, c, d, e, f, g, h, i) d #
Has c (a, b, c, d, e, f, g, h, i) #
Methods getter :: (a, b, c, d, e, f, g, h, i) -> c # modifier :: (c -> c) -> (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) # hasLens :: Lens (a, b, c, d, e, f, g, h, i) c #
Has b (a, b, c, d, e, f, g, h, i) #
Methods getter :: (a, b, c, d, e, f, g, h, i) -> b # modifier :: (b -> b) -> (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) # hasLens :: Lens (a, b, c, d, e, f, g, h, i) b #
Has a (a, b, c, d, e, f, g, h, i) #
Methods getter :: (a, b, c, d, e, f, g, h, i) -> a # modifier :: (a -> a) -> (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) # hasLens :: Lens (a, b, c, d, e, f, g, h, i) a #
Has j (a, b, c, d, e, f, g, h, i, j) #
Methods getter :: (a, b, c, d, e, f, g, h, i, j) -> j # modifier :: (j -> j) -> (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) # hasLens :: Lens (a, b, c, d, e, f, g, h, i, j) j #
Has i (a, b, c, d, e, f, g, h, i, j) #
Methods getter :: (a, b, c, d, e, f, g, h, i, j) -> i # modifier :: (i -> i) -> (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) # hasLens :: Lens (a, b, c, d, e, f, g, h, i, j) i #
Has h (a, b, c, d, e, f, g, h, i, j) #
Methods getter :: (a, b, c, d, e, f, g, h, i, j) -> h # modifier :: (h -> h) -> (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) # hasLens :: Lens (a, b, c, d, e, f, g, h, i, j) h #
Has g (a, b, c, d, e, f, g, h, i, j) #
Methods getter :: (a, b, c, d, e, f, g, h, i, j) -> g # modifier :: (g -> g) -> (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) # hasLens :: Lens (a, b, c, d, e, f, g, h, i, j) g #
Has f (a, b, c, d, e, f, g, h, i, j) #
Methods getter :: (a, b, c, d, e, f, g, h, i, j) -> f # modifier :: (f -> f) -> (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) # hasLens :: Lens (a, b, c, d, e, f, g, h, i, j) f #
Has e (a, b, c, d, e, f, g, h, i, j) #
Methods getter :: (a, b, c, d, e, f, g, h, i, j) -> e # modifier :: (e -> e) -> (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) # hasLens :: Lens (a, b, c, d, e, f, g, h, i, j) e #
Has d (a, b, c, d, e, f, g, h, i, j) #
Methods getter :: (a, b, c, d, e, f, g, h, i, j) -> d # modifier :: (d -> d) -> (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) # hasLens :: Lens (a, b, c, d, e, f, g, h, i, j) d #
Has c (a, b, c, d, e, f, g, h, i, j) #
Methods getter :: (a, b, c, d, e, f, g, h, i, j) -> c # modifier :: (c -> c) -> (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) # hasLens :: Lens (a, b, c, d, e, f, g, h, i, j) c #
Has b (a, b, c, d, e, f, g, h, i, j) #
Methods getter :: (a, b, c, d, e, f, g, h, i, j) -> b # modifier :: (b -> b) -> (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) # hasLens :: Lens (a, b, c, d, e, f, g, h, i, j) b #
Has a (a, b, c, d, e, f, g, h, i, j) #
Methods getter :: (a, b, c, d, e, f, g, h, i, j) -> a # modifier :: (a -> a) -> (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) # hasLens :: Lens (a, b, c, d, e, f, g, h, i, j) a #
Has k (a, b, c, d, e, f, g, h, i, j, k) #
Methods getter :: (a, b, c, d, e, f, g, h, i, j, k) -> k # modifier :: (k -> k) -> (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) # hasLens :: Lens (a, b, c, d, e, f, g, h, i, j, k) k #
Has j (a, b, c, d, e, f, g, h, i, j, k) #
Methods getter :: (a, b, c, d, e, f, g, h, i, j, k) -> j # modifier :: (j -> j) -> (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) # hasLens :: Lens (a, b, c, d, e, f, g, h, i, j, k) j #
Has i (a, b, c, d, e, f, g, h, i, j, k) #
Methods getter :: (a, b, c, d, e, f, g, h, i, j, k) -> i # modifier :: (i -> i) -> (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) # hasLens :: Lens (a, b, c, d, e, f, g, h, i, j, k) i #
Has h (a, b, c, d, e, f, g, h, i, j, k) #
Methods getter :: (a, b, c, d, e, f, g, h, i, j, k) -> h # modifier :: (h -> h) -> (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) # hasLens :: Lens (a, b, c, d, e, f, g, h, i, j, k) h #
Has g (a, b, c, d, e, f, g, h, i, j, k) #
Methods getter :: (a, b, c, d, e, f, g, h, i, j, k) -> g # modifier :: (g -> g) -> (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) # hasLens :: Lens (a, b, c, d, e, f, g, h, i, j, k) g #
Has f (a, b, c, d, e, f, g, h, i, j, k) #
Methods getter :: (a, b, c, d, e, f, g, h, i, j, k) -> f # modifier :: (f -> f) -> (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) # hasLens :: Lens (a, b, c, d, e, f, g, h, i, j, k) f #
Has e (a, b, c, d, e, f, g, h, i, j, k) #
Methods getter :: (a, b, c, d, e, f, g, h, i, j, k) -> e # modifier :: (e -> e) -> (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) # hasLens :: Lens (a, b, c, d, e, f, g, h, i, j, k) e #
Has d (a, b, c, d, e, f, g, h, i, j, k) #
Methods getter :: (a, b, c, d, e, f, g, h, i, j, k) -> d # modifier :: (d -> d) -> (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) # hasLens :: Lens (a, b, c, d, e, f, g, h, i, j, k) d #
Has c (a, b, c, d, e, f, g, h, i, j, k) #
Methods getter :: (a, b, c, d, e, f, g, h, i, j, k) -> c # modifier :: (c -> c) -> (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) # hasLens :: Lens (a, b, c, d, e, f, g, h, i, j, k) c #
Has b (a, b, c, d, e, f, g, h, i, j, k) #
Methods getter :: (a, b, c, d, e, f, g, h, i, j, k) -> b # modifier :: (b -> b) -> (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) # hasLens :: Lens (a, b, c, d, e, f, g, h, i, j, k) b #
Has a (a, b, c, d, e, f, g, h, i, j, k) #
Methods getter :: (a, b, c, d, e, f, g, h, i, j, k) -> a # modifier :: (a -> a) -> (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) # hasLens :: Lens (a, b, c, d, e, f, g, h, i, j, k) a #
Has l (a, b, c, d, e, f, g, h, i, j, k, l) #
Methods getter :: (a, b, c, d, e, f, g, h, i, j, k, l) -> l # modifier :: (l -> l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) # hasLens :: Lens (a, b, c, d, e, f, g, h, i, j, k, l) l #
Has k (a, b, c, d, e, f, g, h, i, j, k, l) #
Methods getter :: (a, b, c, d, e, f, g, h, i, j, k, l) -> k # modifier :: (k -> k) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) # hasLens :: Lens (a, b, c, d, e, f, g, h, i, j, k, l) k #
Has j (a, b, c, d, e, f, g, h, i, j, k, l) #
Methods getter :: (a, b, c, d, e, f, g, h, i, j, k, l) -> j # modifier :: (j -> j) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) # hasLens :: Lens (a, b, c, d, e, f, g, h, i, j, k, l) j #
Has i (a, b, c, d, e, f, g, h, i, j, k, l) #
Methods getter :: (a, b, c, d, e, f, g, h, i, j, k, l) -> i # modifier :: (i -> i) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) # hasLens :: Lens (a, b, c, d, e, f, g, h, i, j, k, l) i #
Has h (a, b, c, d, e, f, g, h, i, j, k, l) #
Methods getter :: (a, b, c, d, e, f, g, h, i, j, k, l) -> h # modifier :: (h -> h) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) # hasLens :: Lens (a, b, c, d, e, f, g, h, i, j, k, l) h #
Has g (a, b, c, d, e, f, g, h, i, j, k, l) #
Methods getter :: (a, b, c, d, e, f, g, h, i, j, k, l) -> g # modifier :: (g -> g) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) # hasLens :: Lens (a, b, c, d, e, f, g, h, i, j, k, l) g #
Has f (a, b, c, d, e, f, g, h, i, j, k, l) #
Methods getter :: (a, b, c, d, e, f, g, h, i, j, k, l) -> f # modifier :: (f -> f) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) # hasLens :: Lens (a, b, c, d, e, f, g, h, i, j, k, l) f #
Has e (a, b, c, d, e, f, g, h, i, j, k, l) #
Methods getter :: (a, b, c, d, e, f, g, h, i, j, k, l) -> e # modifier :: (e -> e) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) # hasLens :: Lens (a, b, c, d, e, f, g, h, i, j, k, l) e #
Has d (a, b, c, d, e, f, g, h, i, j, k, l) #
Methods getter :: (a, b, c, d, e, f, g, h, i, j, k, l) -> d # modifier :: (d -> d) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) # hasLens :: Lens (a, b, c, d, e, f, g, h, i, j, k, l) d #
Has c (a, b, c, d, e, f, g, h, i, j, k, l) #
Methods getter :: (a, b, c, d, e, f, g, h, i, j, k, l) -> c # modifier :: (c -> c) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) # hasLens :: Lens (a, b, c, d, e, f, g, h, i, j, k, l) c #
Has b (a, b, c, d, e, f, g, h, i, j, k, l) #
Methods getter :: (a, b, c, d, e, f, g, h, i, j, k, l) -> b # modifier :: (b -> b) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) # hasLens :: Lens (a, b, c, d, e, f, g, h, i, j, k, l) b #
Has a (a, b, c, d, e, f, g, h, i, j, k, l) #
Methods getter :: (a, b, c, d, e, f, g, h, i, j, k, l) -> a # modifier :: (a -> a) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) # hasLens :: Lens (a, b, c, d, e, f, g, h, i, j, k, l) a #