úÎ!M4Iä.      !"#$%&'()*+,-None,-.7=?@AFHSVX.»  mutable-lens+Representation of a mutable reference as a ..oThis type is useful if you need to store a lens in a container. To recover the original type, pass it through . mutable-lens+Representation of a mutable reference as a /.$When the lens functor type-param is (,) r2, then the output transition function is of type  s rW. To use it as a monadic action e.g. to run it, you'll need to first convert it using .ÌAgain, in principle this ought not to be necessary, but the Haskell runtime forces us to do this due to historical design decisions to hide necessary details that seemed appropriate to hide at the time. mutable-lens Convert an 'LST p! to and from some monadic action m. mutable-lens Convert an  p to and from some context m.This is similar to 0 and 1 from the  primitives package except our extra pE type-param helps us avoid accidentally mixing incompatible primops. mutable-lensBA lifted primitive state-transformer that interoperates with lens.+Specifically, this is a bare (unwrapped in StateT6) state transition on a lifted ("normal") state type.(To obtain one of these, you may apply a  p s a6 to a bare state transition, i.e. a function of type  (a -> (r, a)). mutable-lensLifted 2¥. This is needed to interoperate lifted ("normal") types and unlifted types (such as primitives), but it also gives us the chance to restrict composition based on  V which sadly isn't done in the unlifted internal representation (though it could be).  mutable-lensžGHC implements different primitive operations, some of which cannot be mixed together and some of which can only be run in certain contexts. In particular, 3/-related primops cannot be run directly in the 4Q monad. However, this restriction is not represented at the bottom layer of the 4; runtime which we need to wrap around and expose to users.¼This data structure is our ad-hoc attempt to group together "compatible" primops so that only lens representing compatible references can be composed together, avoiding deadly segfaults.See Nhttps://gitlab.haskell.org/ghc/ghc/blob/master/compiler/prelude/primops.txt.pp See also Ehttps://github.com/haskell/primitive/issues/43#issuecomment-613771394  mutable-lens7Run a bare state transition on a lens in the monad for p.The lens may be an  pM or any compositions of it with other optics, including prisms and so forth. mutable-lens"Run a bare state transition on an . in the monad for p. mutable-lens6A bare state transition representing a read operation. mutable-lens7A bare state transition representing a write operation. b can be passed to   to write b to the reference. mutable-lens<A bare state transition representing a modify/map operation. f can be passed to   to apply f to the reference.   None .=>?@AFPSXHº mutable-lens1A state in which you can allocate new references.{This can be defined on either pure or impure references. For pure references one could e.g. define an instance of this on Map k v with Const k8 as the reference type - see unit tests for an example. mutable-lens.Allocate a new reference with the given value. mutable-lens7Deallocate an existing reference, and return its value.)The default implementation simply writes 5® into the reference and returns the old value. The caller is responsible for actually throwing away the reference and never using it again, as per Haskell's GC semantics. mutable-lensCheck if a reference is valid.CThe default implementation simply forces the reference and returns 61. If the reference has already been freed (via =) then an error will be raised, which you can catch in the 4T monad as per usual. In other words, the default implementation will never return 7.  mutable-lensConvert a reference type to a /.$ mutable-lensView a 8 a as a  '  9 a.%Note: when this is eventually run in 4\, the action will block the thread until there is a value present, as per the semantics of :%. It will then put a value into the 8a, which will block the thread if the value is absent. GHC doesn't give atomicity guarantees for 8Á so it's possible this does happen, e.g. if another producer managed to "get in there" during the intervening period between the two operations. Unfortunately GHC does not provide an atomic  modifyMVar function or primop.2If you don't want to deal with this, don't use an 8, use a ;. ! !NoneI   !   !<       !"#$%&'()*+,-./01234536789:89;<=>?@A<BC?DE<BF<BG?HI<=J<=KLMNO+mutable-lens-0.3.0.0-1mNc8Plz5W420Fusss0FQ9Control.Lens.Mutable.TypesControl.Lens.Mutable.Internal Control.Lens cloneLensControl.Lens.MutableASLensSLensMonadLSTIsoLSTstToMmToSTLSTS PrimOpGroupOpSTOpMVarOpSTMrunSLens runASLens stateRead stateWrite stateModify$fIsoLSTOpSTMRealWorldSTM$fIsoLSTOpMVarRealWorldIO$fIsoLSTOpSTsm$fReadPrimOpGroup$fShowPrimOpGroup$fGenericPrimOpGroup$fEqPrimOpGroup$fOrdPrimOpGroup$fEnumPrimOpGroup$fBoundedPrimOpGroup AllocableallocfreeisValidAsLensasLens$fAsLensSaTMVar$fAsLensSaTVar$fAsLensSaMVar$fAsLensSaIORef$fAsLensSaSTRef$fAsLensSaMutVar$fAllocableSaTMVar$fAllocableSaTVar$fAllocableSaMVar$fAllocableSaIORef$fAllocableSaSTRef$fAllocableSaMutVar"lens-4.19.2-7p9GJM6Xo00LAM9nYxR7QDControl.Lens.LensALens'Control.Lens.TypeLens''primitive-0.7.0.1-4OYEE8uw8FE1Ko7THF1ebControl.Monad.Primitive PrimMonadPrimBaseghc-primGHC.PrimState#base GHC.Conc.SyncSTM GHC.TypesIOGHC.ErrerrorTrueFalseGHC.MVarMVar RealWorld takeMVar# stm-2.5.0.0Control.Concurrent.STM.TMVarTMVar