!"#$%&'()*+,-./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. 0)An identical lens. Accesses the context. self & a = a & self = a 11An empty reference that do not traverse anything  $emptyRef &+& a = a &+& emptyRef = a 'a & emptyRef = emptyRef & a = emptyRef 2Generates a traversal for any   31Generate a lens from a pair of inverse functions 4,Generates a lens from a getter and a setter 5$Creates a monomorphic partial lense 6Creates a simple partial lens 7Clones a lens from  Control.Lens 8Clones a traversal from  Control.Lens 9sFilters 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 ?References the head of a list @References the tail of a list AmInteracts with a line of text on the console. Values set are printed, getting is reading from the console. BAccess 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. DAccess the value of an IORef. E:Access the state inside a state monad (from any context). *+,-./0123456789:;<=>?@ABCDEFG*+,-./0123456789:;<=>?@ABCDE0123456789:;<=>?@,-./GF*+ABCDE*+,-./0123456789:;<=>?@ABCDEFG Safe-Inferred 2346=HJKMT"HGets 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. IPure version of '^#' JPartial version of '^#' KTraversal version of '^#' LIO version of '^#' MIO partial version of '^#' NIO traversal version of '^#' OPSets 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. PPure version of '#=' QPartial version of '#=' RTraversal version of '#=' SIO version of '#=' TPartial IO version of '#=' UTraversal IO version of '#=' VTApplies 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. WPure version of '#~' XPartial version of '#~' YTraversal version of '#~' ZIO 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 '#-' _Partial version of '#-' `Traversal version of '#-' aIO version of '#-' bPartial IO version of '#-' cTraversal IO version of '#-' dZPerforms 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. eIO version of '#|' fPartial IO version of '#|' gTraversal IO version of '#|' h8Composes 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)  iAdds 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. "HIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghi"HIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghi"HIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghi"HIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghi"HIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghiNonejCreates _1 ... _n* classes, and instances for tuples up to mjjjjNone2468!klmnopqrstuvwxyz{|}~ klmnopqrstuvwxyz{|}~}~{|yzwxuvstqropmnklklmnopqrstuvwxyz{|}~None$24JKT`A variable or function name or an expression, that can be converted into an expression inside . MA type name or a type expression, that can be converted into a type inside . Creates p instances from reflectivity, and transitivity of the relation. Uses data from all instances declared so far.   Safe-Inferred\ "#*+,-./0123456789:;<=>?@ABCDEHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghi"#  None 2346=HJKMNone3GMT+Reference all type variables inside a type FReference the name of the type variable inside a type variable binder oReference the characters of the name. If changed there is no guarantee that the created name will be unique. .Reference the record fields in a constructor. 6Reference all fields (data members) in a constructor. &Reference the name of the constructor Access 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. 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:;<=>?@ABCDEHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghiklmnopqrstuvwxyz{|}~   !"#$%&'())*+,-./01234556789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ references-0.1.0.0 Control.Reference.RepresentationControl.Reference.PredefinedControl.Reference.OperatorsControl.Reference.TH.Tuple Control.Reference.TupleInstancesControl.Reference.TH.MonadControl.Reference.Examples.THControl.Reference.TH.Generate#Control.Reference.InternalInterface#Control.Reference.TH.MonadInstancesControl.ReferenceMMorphmorphWriterTraversal'WriterTraversalWriterPartial' WriterPartial WriterLens' WriterLensStateTraversal'StateTraversal StatePartial' StatePartial StateLens' StateLens IOTraversal' IOTraversal IOPartial' IOPartialIOLens'IOLens Traversal' TraversalPartial'PartialRefPlusLens'LensSimple RefMonads ReferencerefGetrefSet refUpdate referencereferenceWithClose$fMMorphIdentity[]$fMMorphIdentityMaybe $fMMorphIOIO$fMMorphIOListT$fMMorphIOMaybeT $fRefMonadswrConsole Association AssocIndex AssocElemelementselfemptyReftraverseisolenspartial simplePartialfromLens fromTraversalfilteredjustrightleftanywayboth_head_tail consoleLinemvarchaniorefstate$fAssociationMap$fAssociation[]^#^.^?^*^!^?!^*!#=.=?=*=!=?!=*!=#~.~?~*~!~?!~*!~#-.-?-*-!-?!-*!-#|!|?!|*!|&&+& makeTupleRefsLens_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(,)(,)ab2ToQExptoQExpToQTypetoQType makeMonadRepr typeVariables typeVarName nameBaseStr recFields conFieldsconNamefunApplicationdebugTHmakeReferencestransformers-0.4.1.0Control.Monad.Trans.Writer.LazyWriterTControl.Monad.Trans.State.LazyStateTbase Data.MaybeNothingGHC.BaseMonadControl.Applicative ApplicativeFunctorData.Traversable Traversable Data.EitherEithergenClass genInstancereplacetemplate-haskellLanguage.Haskell.TH.SyntaxQBelowAboveInstanceGenStateIGS subsumeInstsIGStatemakeMonadRepr'collectedSubsumes liftMSCasted@.@generateSubsume $fToQExpName $fToQExpQ $fToQTypeName $fToQTypeQ $fToQTypeType$fMMorphIdentityIdentity$fMMorphIdentityIO$fMMorphMaybeTMaybeT $fMMorph[][]$fMMorphListTListT$fMMorphMaybeTListTmakePolyrefName addTypeArgsmakeLensesForConcreateLensForFieldmakePartialLensesForConcreatePartialLensForField referenceTypehasField fieldIndex newtypeToDatabindAndRebuild$fMMorphStateTListT$fMMorph[]ListT