EŶ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ Safe 3457IKLNUA 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 differentReference lawsVAs 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 52) 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  wtWriter monad, controls how the value can be reassembled when the part is changed. See differences between Lens, IOLens and  StateLensr^Reader monad. Controls how part of the value can be asked. See differences between Lens, Partial and  Traversalw'Backward writer monad. See turnr'Backward reader monad. See turns!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 (Morph 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 lens7Updater for the lens. Handles monadic update functions. Creates a reference. JCreates a reference where all operations are added in their original form.pThe use of this method is not suggested, because it is closely related to the representation of the references.aCreates a reference with explicit close operations that are executed after the data is accessed. GetterSetterUpdaterBackward getterBackward setterBackward updater GetterSetterUpdater GetterSetterUpdaterBackward getterBackward setterBackward updaterGetterClose after gettingSetterClose after settingUpdaterClose after updating     None 3457>ILN8A class for representing calculation in a simpler monad. pullBack . sink === id.A reference that can access a value inside an 9 transformed monad that may exist in multiple instances..A reference that can access a value inside an ' transformed monad that may not exist..A reference that can access a value inside an  transformed monad.-A reference that can access a value inside a WriteT9 transformed monad that may exist in multiple instances.-A reference that can access a value inside a ' transformed monad that may not exist.-A reference that can access a value inside a  transformed monad.-A reference that can access a value inside a 9 transformed monad that may exist in multiple instances.-A reference that can access a value inside a ' transformed monad that may not exist.-A reference that can access a value inside a  transformed monad.KA reference that can access mutable data that may not exist in the context. )A reference that can access mutable data."aA 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.#Partial lens. A W that can access data that may not exist in the context. Every lens is a partial lens.RAny 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 ).$vA reference that may not have the accessed element, and that can look for the accessed element in multiple locations.%A ? that can access a part of data that exists in the context. A %. can have any read and write semantics that a  can have.&?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 %, ", #D, etc... Setting or updating does not change the type of the base., !"#$%&'()*+,-./0123456789:;<! !"#$%&'()*+,-./01,<;*)('&%$#"!: 980176./54,-32+ !"#$%&'()*32+54,-76./9801:;<None4=7Composes 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) >Adds two references.`Using 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: Aa ^? 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.? Pack two references in parallel.@nFlips a reference to the other direction. The monads of the references can change when a reference is turned.=>?@=>?@=>?@=>?@=>?None 3457>IKLNU APure getter operatorBGeneric getter operatorCFGets the context from the referenced element by turning the reference.DPure setter functionEMonadic setter functionF"Monadic updater with a pure resultGMonadic updaterHPure updater with pure functionI!Monadic update with pure functionJ"Perform a given action monadically ABCDEFGHIJ ABCDEFGHIJ ABCDEFGHIJ ABCDEFGHIJ ABDEFGHIJNone4IN KGenerates a traversal for any  L0Generate a lens from a pair of inverse functionsN+Generates a lens from a getter and a setterO#Creates a polymorphic partial lense Either t a is used instead of Maybe a to permit the types of s and t to differ.PJCreates a polymorphic partial lens that can be turned to give a total lensQJCreates a monomorphic partial lens that can be turned to give a total lensRCreates a simple partial lensSClones a lens from  Control.LensTClones a traversal from  Control.LensU0References all the elements accessed by uniplateV/References all the elements accessed by biplateWqFilters the traversed elements with a given predicate. Has specific versions for traversals and partial lenses. KLMNOPQRSTUVW KLMNOPQRSTUVW KLMNOPQRSTUVW KLMNOPQRSTUVWNone34579>FHIKLNUX=A dummy object to interact with the user through the console.Z(An identical lens. Accesses the context. self & a = a & self = a[0An empty reference that do not traverse anything #emptyRef &+& a = a &+& emptyRef = a &a & emptyRef = emptyRef & a = emptyRef\/An indexed lens for accessing points a function]5A 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 a#References both elements of a tuplebReferences the head of a listc.References the element at the head of the listdReferences the tail of a listeReferences a suffix of a listfViews a list as an optinal pairgCAn isomorphism between the list and text representation of a stringh'Accesses the reversed version of a list 'turn' reversed == reversedi!Accesses the numerator of a ratioj#Accesses the denominator of a ratiok*Accesses the real part of a complex numberl/Accesses the imaginary part of a complex numberm5Accesses the polar representation of a complex numbernkInteracts with a line of text on the console. Values set are printed, getting is reading from the console.o7Reference to the contents of the file. Not thread-safe.An empty file's content is Just "" while a non-existent file's is Nothing-Creates a temporary file to store the result.pAccess 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.qGeneralized version of  .rGeneralized version of .sGeneralized version of .uAccess the value of an IORef. v9Access the state inside a state monad (from any context).wAccess the value inside an x/Filters an indexed reference based on the index!XYZ[\]^_`abcdefghijklmnopqrstuvwx!XYZ[\]^_`abcdefghijklmnopqrstuvwx!Z[\]^_`abcdefghijklmXYnopqrstuvwx XYZ[\]^_`abcdefghijklmnopqrstuvwxNone 345>ILNUyEContainers that can be used as a set, inserting and removing elements~DLenses for given values in a data structure that is indexed by keys.yz{|}~ yz{|}~~|}yz{yz{|}~Nonei  !"#$%&'()*+,-./01=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ 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   None3579!  None>L None4HNU*Reference all type variables inside a type'Reference the name of the type variable*Reference all type variables inside a type3Reference all type variables not binded by a forallEReference the name of the type variable inside a type variable bindermReference 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.5Reference all fields (data members) in a constructor.Reference types of fields%Reference the name of the constructorAccess 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.LAccesses 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 None3457KLU7Shows the generated declarations instead of using them.2Creates references for fields of a data structure./Creates the type of the reference being definedPCreates a new field type with changing the type variables that are bound outsideBDictates what reference names should be generated from field namesECreates a type from applying binded type variables to a type functionNone  !"#$%&'()*+,-./01=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijkklmnopqrstuvwxyz{|}~                  refer_7PxixqPMamU9BAQI4AtVRj Control.Reference.RepresentationControl.Reference.TypesControl.Reference.CombinatorsControl.Reference.OperatorsControl.Reference.GeneratorsControl.Reference.Predefined'Control.Reference.Predefined.ContainersControl.Reference.TH.Tuple Control.Reference.TupleInstances,Control.Reference.Predefined.Containers.TreeControl.Reference.Examples.THControl.Reference.TH.RecordsControl.Concurrent.MVarmodifyMVarMasked_Control.Exceptionmask_ onException#Control.Reference.InternalInterfaceControl.ReferenceMU RefMonadsIndexedReference ReferencerefGetrefSet refUpdaterefGet'refSet' refUpdate' bireference reference rawReferencereferenceWithClose unusableOp $fRefMonadswr MorphControlMStsinkpullBack STTraversal STPartialSTLensWriterTraversal WriterPartial WriterLensStateTraversal StatePartial StateLens IOTraversal IOPartialIOLensIOMonads TraversalPartialRefPlusLensPrismIsoSetterGetterSimpleProxyMSt ReflIOMSt fromReflIOMStListMSt fromListMStMaybeMSt fromMaybeMStTFCo:R:MStmProxya$fMorphControlmProxyTFCo:R:MStIOIOa$fMorphControlIOIOTFCo:R:MStmListTa$fMorphControlmListTTFCo:R:MStmMaybeTa$fMorphControlmMaybeT $fIOMonadswr$fMonadPlusProxy$fAlternativeProxy&&+&&|&turn^.^?review.=!=.~!~.-!-!| traversalisoiso'lenspartialprism simplePrism simplePartialfromLens fromTraversal uniplateRef biplateReffilteredConsoleselfemptyRefatArgjustrightleftanywaybothatHeadheadElem_taildroppedviewtextreversed _numerator _denominator _realPart _imagPart_polar consoleLine fileContentmvarchaniorefstatestRefwhereOfSetLikeSetElemcontainsMappingat 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_16(,,,,,,,,,,,,,,,)(,,,,,,,,,,,,,,,)ab2$fAssociationTreetypeVariableNamestypeVar typeVariablesfreeTypeVariables typeVarName nameBaseStr recFields conFieldsconTypesconNamefunApplication definedNamedefinedConstructorsdefinedTypeArgsdebugTHmakeReferencesbaseGHC.BaseMonad ApplicativeFunctorGHC.STSTtrans_GZTjP9K5WFq01xC9BAGQpFControl.Monad.Trans.Writer.LazyWriterTControl.Monad.Trans.State.LazyStateTNothingData.Traversable Traversable Data.EitherEither GHC.STRefSTRefreplacegenClass lensClasslensFun classDeclared genInstance referenceTypemakePolyrefName addTypeArgscreateReferencescreateLensForFieldcreatePartialLensForFieldhasField fieldIndex newtypeToDatabindAndRebuild$fMorphStateTStateT