!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~  Safe-Inferred 2346=HJKM" States that m1 can be represented with m2. That is because m2 contains more infromation than m1. The 0 relation defines a natural transformation from m1 to m2" that keeps the following laws:  Jmorph (return x) = return x morph (m >>= f) = morph m >>= morph . f +It is a reflexive and transitive relation. 'Lifts the first monad into the second. .A reference that must access a value inside a WriteT; transformed monad that may exist in multiple instances. -A reference that can access a value inside a WriteT; transformed monad that may exist in multiple instances. .A reference that must access a value inside a WriteT) transformed monad that may not exist. -A reference that can access a value inside a ) transformed monad that may not exist. .A reference that must access a value inside a  transformed monad. -A reference that can access a value inside a  transformed monad. .A reference that must access a value inside a ; transformed monad that may exist in multiple instances. -A reference that can access a value inside a ; transformed monad that may exist in multiple instances. .A reference that must access a value inside a ) transformed monad that may not exist. -A reference that can access a value inside a ) transformed monad that may not exist. .A reference that must access a value inside a  transformed monad. -A reference that can access a value inside a  transformed monad. kA reference that can access mutable data that is available in a number of instances inside the contexts. MA reference that must access mutable data that may not exist in the context. LA reference that can access mutable data that may not exist in the context. LA reference that must access mutable data that is available in the context. *A reference that can access mutable data. uStrict traversal. A reference that must access data that is available in a number of instances inside the context. cA reference that can access data that is available in a number of instances inside the contexts. Any reference that is a  should perform the action given to its updater in the exactly the same number of times that is the number of the values returned by it's getRef function. Strict partial lens. A < that must access data that may not exist in the context. Partial lens. A Y that can access data that may not exist in the context. Every lens is a partial lens. SAny reference that is a partial lens should only perform the action given to its  updateRef7 function if it can get a value (the value returned by getRef is not the lifted form of ). xA reference that may not have the accessed element, and that can look for the accessed element in multiple locations. Strict lens. A F that must access a part of data that surely exists in the context. A P that can access a part of data that exists in the context. Every well-formed  is a .  A monomorph , , F, etc... Setting or updating does not change the type of the base. UA simple class to enforce that both reader and writer semantics of the reference are s (as well as s and s) A reference is an accessor to a part or different view of some data. The referenc has a separate getter, setter and updater. In some cases, the semantics are a bit different Reference laws WAs the references are generalizations of lenses, they should conform to the lens laws: !1) You get back what you put in:  ! l a s >>=   l return "a a 62) Putting back what you got doesn't change anything:    l return a >>= \b -> ! l b s "a s .3) Setting twice is the same as setting once:  ! l a s >>= ! l b "a ! l b s <But because update, set and get are different operations, . 4) Updating something is the same as getting and then setting (if the reader and writer monads are the same, or one can be converted into the other):    l a >>= f >>= \b -> ! l b s "a " l f s (This has some consequences. For example lensUpdate l id = return. Type arguments of  wuWriter monad, controls how the value can be reassembled when the part is changed. See differences between ,  and   r_Reader monad. Controls how part of the value can be asked. See differences between ,  and  s"The type of the original context. t;The after replacing the accessed part to something of type b/ the type of the context changes to t. aThe type of the accessed part. b<The accessed part can be changed to something of this type. Usually s and b determines t, t and a determines s. 0The reader monad usually have more information (MMorph w r). Getter for the lens. Takes a monadic function and runs it on the accessed value. This is necessary to run actions after a read. !Setter for the lens "8Updater for the lens. Handles monadic update functions. #Creates a reference. $cCreates a reference with explicit close operations that are executed after the data is accessed. ,  !"#Getter Setter Updater $Getter Close after getting Setter Close after setting Updater Close after updating %&'()*+%  !"#$, !"#$+* )('&%'  !"#$%&'()*+ Safe-Inferred23468=EGHJKMT,>A dummy object to interact with the user through the console. .ELenses for given values in a data structure that is indexed by keys. 2)An identical lens. Accesses the context. self & a = a & self = a 31An empty reference that do not traverse anything  $emptyRef &+& a = a &+& emptyRef = a 'a & emptyRef = emptyRef & a = emptyRef 4Generates a traversal for any   51Generate a lens from a pair of inverse functions 6,Generates a lens from a getter and a setter 7$Creates a monomorphic partial lense 8Creates a simple partial lens 9Clones a lens from  Control.Lens :Clones a traversal from  Control.Lens ;sFilters the traversed elements with a given predicate. Has specific versions for traversals and partial lenses. <6A partial lens to access the value that may not exist =0A partial lens to access the right option of an  >/A partial lens to access the left option of an  ?:Access the value that is in the left or right state of an  @$References both elements of a tuple AReferences the head of a list BReferences the tail of a list CmInteracts with a line of text on the console. Values set are printed, getting is reading from the console. DAccess a value inside an MVar. Setting is not atomic. If there is two supplier that may set the accessed value, one may block and can corrupt the following updates. FReads and updates are done in sequence, always using consistent data. FAccess the value of an IORef. G:Access the state inside a state monad (from any context). ,-./0123456789:;<=>?@ABCDEFGHI,-./0123456789:;<=>?@ABCDEFG23456789:;<=>?@AB./01IH,-CDEFG,-./0123456789:;<=>?@ABCDEFGHI Safe-Inferred 2346=HJKMT"JGets the referenced data in the monad of the lens. Does not bind the type of the writer monad, so the reference must have its type disambiguated. KPure version of '^#' LPartial version of '^#' MTraversal version of '^#' NIO version of '^#' OIO partial version of '^#' PIO traversal version of '^#' QPSets the referenced data to the given pure value in the monad of the reference. _Does not bind the type of the reader monad, so the reference must have its type disambiguated. RPure version of '#=' SPartial version of '#=' TTraversal version of '#=' UIO version of '#=' VPartial IO version of '#=' WTraversal IO version of '#=' XTApplies the given monadic function on the referenced data in the monad of the lens. _Does not bind the type of the reader monad, so the reference must have its type disambiguated. YPure version of '#~' ZPartial version of '#~' [Traversal version of '#~' \IO version of '#~' ]Partial IO version of '#~' ^Traversal IO version of '#~' _QApplies the given pure function on the referenced data in the monad of the lens. _Does not bind the type of the reader monad, so the reference must have its type disambiguated. `Pure version of '#-' aPartial version of '#-' bTraversal version of '#-' cIO version of '#-' dPartial IO version of '#-' eTraversal IO version of '#-' fZPerforms the given monadic action on referenced data while giving back the original data. _Does not bind the type of the reader monad, so the reference must have its type disambiguated. gIO version of '#|' hPartial IO version of '#|' iTraversal IO version of '#|' j8Composes two references. They must be of the same kind.  If reference r accesses b inside the context a, and reference p accesses c inside the context b, than the reference r&p will access c inside a. Composition is associative:  (r&p)&q = r&(p&q)  kAdds two references. aUsing this operator may result in accessing the same parts of data multiple times. For example  twice = self &+& self , is a reference that accesses itself twice:  Da ^* twice == [a,a] (twice *= x) a == x (twice *- f) a == f (f a) Addition is commutative only if we do not consider the order of the results from a get, or the order in which monadic actions are performed. "JKLMNOPQRSTUVWXYZ[\]^_`abcdefghijk"JKLMNOPQRSTUVWXYZ[\]^_`abcdefghijk"JKLMNOPQRSTUVWXYZ[\]^_`abcdefghijk"JKLMNOPQRSTUVWXYZ[\]^_`abcdefghijk"JKLMNOPQRSTUVWXYZ[\]^_`abcdefghijkNone$24JKTl`A variable or function name or an expression, that can be converted into an expression inside . nMA type name or a type expression, that can be converted into a type inside . pCreates p instances from reflectivity, and transitivity of the relation. Uses data from all instances declared so far. lmnoplmnoppnolmlmnop  Safe-Inferred\ #$,-./0123456789:;<=>?@ABCDEFGJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijk#$  None 2346=HJKMNone3GMTq+Reference all type variables inside a type rFReference the name of the type variable inside a type variable binder soReference the characters of the name. If changed there is no guarantee that the created name will be unique. t.Reference the record fields in a constructor. u6Reference all fields (data members) in a constructor. v&Reference the name of the constructor wAccess a function application as a list of expressions with the function application at the head of the list and the arguments on it's tail. qrstuvwqrstuvwqrstuvwqrstuvwNonexAA tuple configuration is a scheme for tuple-like data structures.}Creates Lens_1 ... Lens_n) classes, and instances for tuples up to m..Classes and instances look like the following: class Lens_1 s t a b | s -> a, t -> b , a t -> s, b s -> t where _1 :: Lens s t a b instance Lens_1 (a,b) (a',b) a a' where _1 = lens ((a,b) -> a) (a' (a,b) -> (a',b)) ~%Generates the normal haskell tuples ((a,b), (a,b,c), (a,b,c,d) ) OUtility function to replace the N'th element of a list xyz{|}~xyz{|}~xyz{|~} xyz{|}~None2468! None246JKT8Shows the generated declarations instead of using them. 3Creates references for fields of a data structure. QCreates a new field type with changing the type variables that are bound outside CDictates what reference names should be generated from field names FCreates a type from applying binded type variables to a type function  None #$,-./0123456789:;<=>?@ABCDEFGJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnop   !"#$%&'()**+,-./01234567789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ references-0.2.1.0 Control.Reference.RepresentationControl.Reference.PredefinedControl.Reference.OperatorsControl.Reference.TH.MonadControl.Reference.Examples.THControl.Reference.TH.Tuple Control.Reference.TupleInstancesControl.Reference.TH.Records#Control.Reference.InternalInterface#Control.Reference.TH.MonadInstancesControl.ReferenceMMorphmorphWriterTraversal'WriterTraversalWriterPartial' WriterPartial WriterLens' WriterLensStateTraversal'StateTraversal StatePartial' StatePartial StateLens' StateLens IOTraversal' IOTraversal IOPartial' IOPartialIOLens'IOLensIOMonads Traversal' TraversalPartial'PartialRefPlusLens'LensSimple RefMonads ReferencerefGetrefSet refUpdate referencereferenceWithClose$fMMorphIdentity[]$fMMorphIdentityMaybe $fMMorphIOIO$fMMorphIOListT$fMMorphIOMaybeT $fIOMonadswr $fRefMonadswrConsole Association AssocIndex AssocElemelementselfemptyReftraverseisolenspartial simplePartialfromLens fromTraversalfilteredjustrightleftanywayboth_head_tail consoleLinemvarchaniorefstate$fAssociationMap$fAssociation[]^#^.^?^*^!^?!^*!#=.=?=*=!=?!=*!=#~.~?~*~!~?!~*!~#-.-?-*-!-?!-*!-#|!|?!|*!|&&+&ToQExptoQExpToQTypetoQType makeMonadRepr typeVariables typeVarName nameBaseStr recFields conFieldsconNamefunApplication TupleConf tupleType tuplePattern tupleExpr makeTupleRefs hsTupConfLens_16_16Lens_15_15Lens_14_14Lens_13_13Lens_12_12Lens_11_11Lens_10_10Lens_9_9Lens_8_8Lens_7_7Lens_6_6Lens_5_5Lens_4_4Lens_3_3Lens_2_2Lens_1_1$fLens_1(,)(,)ab2debugTHmakeReferencestransformers-0.4.1.0Control.Monad.Trans.Writer.LazyWriterTControl.Monad.Trans.State.LazyStateTbase Data.MaybeNothingGHC.BaseMonadControl.Applicative ApplicativeFunctorData.Traversable Traversable Data.EitherEithertemplate-haskellLanguage.Haskell.TH.SyntaxQBelowAboveInstanceGenStateIGS subsumeInstsIGStatemakeMonadRepr'collectedSubsumes liftMSCasted@.@generateSubsume $fToQExpName $fToQExpQ $fToQTypeName $fToQTypeQ $fToQTypeType$fMMorphIdentityIdentity$fMMorphIdentityIO$fMMorphMaybeTMaybeT $fMMorph[][]$fMMorphListTListT$fMMorphMaybeTListTreplacegenClass lensClasslensFun classDeclared genInstancemakePolyrefName addTypeArgsmakeLensesForConcreateLensForFieldmakePartialLensesForConcreatePartialLensForField referenceTypehasField fieldIndex newtypeToDatabindAndRebuild$fMMorphStateTListT$fMMorph[]ListT