!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ None 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 an ; transformed monad that may exist in multiple instances. .A reference that can access a value inside an ; transformed monad that may exist in multiple instances. /A reference that must access a value inside an ) transformed monad that may not exist. .A reference that can access a value inside an ) transformed monad that may not exist. /A reference that must access a value inside an  transformed monad. .A reference that can access a value inside an  transformed monad. .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 partial lens that can be turned to get a total lens. # A two-way ( that represents an isomorphism between two datatypes. Can be used to access the same data in two different representations. $ 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) &QPolymorph unit type. Can represent a calculation that cannot calculate anything. (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  w'Backward writer monad. See turn r'Backward reader monad. See turn 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. 1Creates a reference. 2KCreates a reference where all operations are added in their original form. rThe use of this method is not suggested, because it is closely related to the representation of the references. 3cCreates a reference with explicit close operations that are executed after the data is accessed. C  !"#$%&'()*+,-./0Getter Setter Updater Backward getter Backward setter Backward updater 1Getter Setter Updater 2Getter Setter Updater Backward getter Backward setter Backward updater 3Getter Close after getting Setter Close after setting Updater Close after updating 456789:;<=>?@AB4  !"#$%&'()*+,-./0123C()*+,-./0123&'BA@?%>$#"! = <;:987654:  !"#$%&'()*+,-./0123456789:;<=>?@ABNone 2346=HJKMT$C)Flips a reference to the other direction EGets 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. FPure version of E GPartial version of E HTraversal version of E IIO version of E JIO partial version of E KIO traversal version of E LPSets 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. MPure version of '#=' NPartial version of '#=' OTraversal version of '#=' PIO version of '#=' QPartial IO version of '#=' RTraversal IO version of '#=' STApplies 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. TPure version of '#~' UPartial version of '#~' VTraversal version of '#~' WIO version of '#~' XPartial IO version of '#~' YTraversal IO version of '#~' ZQApplies 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 '#-' ^IO version of '#-' _Partial IO version of '#-' `Traversal IO version of '#-' aZPerforms 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. bIO version of '#|' cPartial IO version of '#|' dTraversal IO version of '#|' e8Composes 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)  fAdds 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. g!Pack two references in parallel. %CDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefg%CDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefg%CDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefg%CDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefg#EFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefgNone23468=EGHJKMT#h=A dummy object to interact with the user through the console.j(An identical lens. Accesses the context. self & a = a & self = ak0An empty reference that do not traverse anything #emptyRef &+& a = a &+& emptyRef = a &a & emptyRef = emptyRef & a = emptyReflGenerates a traversal for any  m0Generate a lens from a pair of inverse functionso+Generates a lens from a getter and a setterp#Creates a polymorphic partial lense Either t a is used instead of Maybe a to permit the types of s and t to differ.qJCreates a polymorphic partial lens that can be turned to give a total lensrJCreates a monomorphic partial lens that can be turned to give a total lenssCreates a simple partial lenstClones a lens from  Control.LensuClones a traversal from  Control.LensvqFilters the traversed elements with a given predicate. Has specific versions for traversals and partial lenses.w5A partial lens to access the value that may not existx0A partial lens to access the right option of an y/A partial lens to access the left option of an  z: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 element at the head of the list~References the tail of a listReferences a suffix of a listViews a list as an optinal pairCAn isomorphism between the list and text representation of a string'Accesses the reversed version of a list 'turn' reversed == reversed!Accesses the numerator of a ratio#Accesses the denominator of a ratio*Accesses the real part of a complex number/Accesses the imaginary part of a complex number5Accesses the polar representation of a complex numberkInteracts with a line of text on the console. Values set are printed, getting is reading from the console.Access 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.EReads and updates are done in sequence, always using consistent data.Access the value of an IORef. 9Access the state inside a state monad (from any context).Access the value inside an &hijklmnopqrstuvwxyz{|}~&hijklmnopqrstuvwxyz{|}~&jklmnopqrstuvwxyz{|}~hi%hijklmnopqrstuvwxyz{|}~None$24JKT_A variable or function name or an expression, that can be converted into an expression inside .LA type name or a type expression, that can be converted into a type inside .Creates n instances from reflectivity, and transitivity of the relation. Uses data from all instances declared so far.None 234=HKMTEContainers that can be used as a set, inserting and removing elementsDLenses for given values in a data structure that is indexed by keys.  Nonet  !#$(013CDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ $(013#!   None2346=HJKM  NoneAA 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            None2468! ΧNone=K None3GMT+Reference all type variables inside a type (Reference the name of the type variable +Reference all type variables inside a type 4Reference all type variables not binded by a forall 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 types of fields &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. MAccesses the name of the defined object. Does not return name in signatures. Accesses the constructors of a data or newtype definition. After changing the definition becames a newtype if there is only one constructor. ,Accesses the type variables of a definition  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  !#$(013CDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ !"#$%&'()*+,-./012344556789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrsttuvwxyz{|}~                 !" # $ % & ' ( ) * + , - ./references-0.2.1.2 Control.Reference.RepresentationControl.Reference.OperatorsControl.Reference.PredefinedControl.Reference.TH.Monad'Control.Reference.Predefined.ContainersControl.Reference.TH.Tuple Control.Reference.TupleInstances,Control.Reference.Predefined.Containers.TreeControl.Reference.Examples.THControl.Reference.TH.Records#Control.Reference.InternalInterface#Control.Reference.TH.MonadInstancesControl.ReferenceMMorphmorph STTraversal' STTraversal STPartial' STPartialSTLens'STLensWriterTraversal'WriterTraversalWriterPartial' WriterPartial WriterLens' WriterLensStateTraversal'StateTraversal StatePartial' StatePartial StateLens' StateLens IOTraversal' IOTraversal IOPartial' IOPartialIOLens'IOLensIOMonads Traversal' TraversalPartial'PartialRefPlusLens'LensPrismIsoSimple RefMonadsMU ReferencerefGetrefSet refUpdaterefGet'refSet' refUpdate' bireference reference rawReferencereferenceWithClose $fMMorphmMU $fMMorph[][]$fMMorphMaybe[]$fMMorphMaybeMaybe$fMMorphIdentity[]$fMMorphIdentityMaybe $fMMorphIOIO$fMMorphIOListT$fMMorphIOMaybeT $fIOMonadswr $fRefMonadswr $fMonadPlusMU $fMonadMU$fApplicativeMU $fFunctorMUturnreview^#^.^?^*^!^?!^*!#=.=?=*=!=?!=*!=#~.~?~*~!~?!~*!~#-.-?-*-!-?!-*!-#|!|?!|*!|&&+&&|&ConsoleselfemptyReftraverseisoiso'lenspartialprism simplePrism simplePartialfromLens fromTraversalfilteredjustrightleftanywaybothatHeadheadElem_taildroppedviewtextreversed _numerator _denominator _realPart _imagPart_polar consoleLinemvarchaniorefstatestRefToQExptoQExpToQTypetoQType makeMonadReprSetLikeSetElemcontainsMappingat Association AssocIndex AssocElemelement$fSetLikeIntSet $fSetLikeSet$fMappingIntMap$fAssociationIntMap $fMappingMap$fAssociationMap $fMapping(->)$fAssociation(->)$fAssociationText$fAssociationSeq$fAssociationArray$fAssociation[] 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(,)(,)ab2$fAssociationTreetypeVariableNamestypeVar typeVariablesfreeTypeVariables typeVarName nameBaseStr recFields conFieldsconTypesconNamefunApplication definedNamedefinedConstructorsdefinedTypeArgsdebugTHmakeReferencesbaseGHC.STSTtransformers-0.4.1.0Control.Monad.Trans.Writer.LazyWriterTControl.Monad.Trans.State.LazyStateT Data.MaybeNothingGHC.BaseMonadControl.Applicative ApplicativeFunctorData.Traversable Traversable Data.EitherEither GHC.STRefSTReftemplate-haskellLanguage.Haskell.TH.SyntaxQBelowAboveInstanceGenStateIGS subsumeInstsIGStatemakeMonadRepr'collectedSubsumes liftMSCasted@.@generateSubsume $fToQExpName $fToQExpQ $fToQTypeName $fToQTypeQ $fToQTypeType$fMMorphIdentityIdentity$fMMorphIdentityIO$fMMorphMaybeTMaybeT$fMMorphListTListT$fMMorphStateTListT$fMMorphMaybeListT0$fMMorph[]ListT0$fMMorphMaybeListT1$fMMorph[]ListT1$fMMorphMaybeTListTreplacegenClass lensClasslensFun classDeclared genInstancemakePolyrefName addTypeArgsmakeLensesForConcreateLensForFieldmakePartialLensesForConcreatePartialLensForField referenceTypehasField fieldIndex newtypeToDatabindAndRebuild