úÎЫÍò     None24 KThe type of values that supply an initial quantity for quantity semaphores.Type of , used only by this library.<An expression for a value contained in a unique declaration. Transform a container with kind * -> * into a concrete type */ by applying the type '()' to the constructor.>Intended to be used for tagging types for unique declarations.Tagged unique declaration type.Tagged name type.^Identity type wrapper that indicates that the unique declaration should be "empty" by default.5Types that can be uniquely declared on the top level.Like x, this type class itself is not "magical". Its instances, however, may be primitive, at least conceptually, much like s  instance.ÿKIndividual instances may be accompanied with certain caveats. Each individual instance should include in its documentation what these are. These caveats may affect surrounding code, perhaps in ways detrimental to the program's performance or efficiency; users should thus consider isolating "global" declarations in their own .Global¢ module; this is not necessarily necessary for every instance. See the documentation of the particular instance to see how the declarations should be declared.•The type should be monomorphic, or concrete enough, to be type safe, so that the references cannot be treated as multiple concreet types (writing  [Integer]# to a reference that has the type  IORef [a] and subsequently reading [Char]ÿÙ can cause the program to core dump). Ensuring this safety is the responsibility of the implementer of the instances of this type class; other users of this library who do not extend this class's functionality generally do not need to be concerned whether the program will run correctly at run-time, since the mistakes, which can violate type safety, will be caught at compile-time and the code will not build (this is, however, not intrinsically guaranteed, much like the monad laws: they are expected to be followed). It is worth reiterating that instances of this class need to be sure to not allow code with such erroneous types to compile. For more information about type safety, see the documentation of .Example: 7un "lives" =:: ([| 3 |], ut [t| Integer |] :: UT TVar) lives would then refer to the ' and would initially contain the value 3.Declare uniquely. 8Construct a name for a unique declaration from a string. +Tagged unique declaration type constructor. (Determine whether a type is polymorphic.HInternal means of constructing unique values, used only by this library.6 should never be used directly, outside this library.  Translate an Extsb AST to a Template Haskell AST, failing when the translation result is not a Template Haskell AST.This is defined in terms of  6Apply translateExtsToTH' and lift the result into the  monad.This is often used with | to refer to variables whose names are not required to be in scope when the quotation is expanded, in a very roundabout way.„"utl" can be thought of as a mnemonic for "unique", "translate" and "lift"; and will be updated appropriately to reflect changes to .ˆFor example, to enable self-referential recursion by referring to variables whose names are not yet in scope, an expression quotation [| & |] can usually be written as  utl [ud| & |]. Alias to the  w, which does not require names to be in scope when the quotation is expanded, which enables self-referential recursion.-An alternative to providing an initial value.TWarning: attempting to read uninitialized references can cause the program to crash.Declaring unique =s that are initially empty; caveats are the same as those of s that are initially empty.The initial value is ignored.pThese preconditions apply to GHC 7.0.4 and base-0.4.3.1 and likely similar versions and implementations as well.4In its low-level implementation, this instance uses ÿ'; thus, the same caveats apply to this instance, particularly those regarding top-level declarations (referential transparency cannot be violated here). As of base-4.3.1.0, these conditions, that the user needs to be aware of, are the following: * Compile the declarations with the compiler flag -fno-cse. This prevents multiple references from being substituted to refer to the same data. This flag thus does not affect the semantics of the program, but may potentially adversely affect its performance; thus, isolating in a .GlobalÜ module may be advisable in some cases. This condition is not strictly necessary when only one declaration is made in a module, since the compiler cannot substitute multiple references to refer to same data.ÿuIf your code behaves differently when optimizations are enabled, ensure that this flag is indeed being used when the declarations are being compiled. Setting or passing this flag is NOT handled automatically by this implementation; it is the responsibility of users of this implementation to ensure that such appropriate behaviour is set when necessary.-This can be accomplished by placing the line {- OPTIONS_GHC -fno-cse -}V in the file in which the declarations are declared, before the "module" line.Declaring unique =s that are initially empty; caveats are the same as those of s that are initially empty.The initial value is ignored.pThese preconditions apply to GHC 7.0.4 and base-0.4.3.1 and likely similar versions and implementations as well.4In its low-level implementation, this instance uses ÿ'; thus, the same caveats apply to this instance, particularly those regarding top-level declarations (referential transparency cannot be violated here). As of base-4.3.1.0, these conditions, that the user needs to be aware of, are the following: * Compile the declarations with the compiler flag -fno-cse. This prevents multiple references from being substituted to refer to the same data. This flag thus does not affect the semantics of the program, but may potentially adversely affect its performance; thus, isolating in a .GlobalÜ module may be advisable in some cases. This condition is not strictly necessary when only one declaration is made in a module, since the compiler cannot substitute multiple references to refer to same data.ÿuIf your code behaves differently when optimizations are enabled, ensure that this flag is indeed being used when the declarations are being compiled. Setting or passing this flag is NOT handled automatically by this implementation; it is the responsibility of users of this implementation to ensure that such appropriate behaviour is set when necessary.-This can be accomplished by placing the line {- OPTIONS_GHC -fno-cse -}V in the file in which the declarations are declared, before the "module" line.Declaring unique $s; caveats are the same as those of s.OThe initial value is used so that the reference refers initially to that value.pThese preconditions apply to GHC 7.0.4 and base-0.4.3.1 and likely similar versions and implementations as well.4In its low-level implementation, this instance uses ÿ'; thus, the same caveats apply to this instance, particularly those regarding top-level declarations (referential transparency cannot be violated here). As of base-4.3.1.0, these conditions, that the user needs to be aware of, are the following: * Compile the declarations with the compiler flag -fno-cse. This prevents multiple references from being substituted to refer to the same data. This flag thus does not affect the semantics of the program, but may potentially adversely affect its performance; thus, isolating in a .GlobalÜ module may be advisable in some cases. This condition is not strictly necessary when only one declaration is made in a module, since the compiler cannot substitute multiple references to refer to same data.ÿuIf your code behaves differently when optimizations are enabled, ensure that this flag is indeed being used when the declarations are being compiled. Setting or passing this flag is NOT handled automatically by this implementation; it is the responsibility of users of this implementation to ensure that such appropriate behaviour is set when necessary.-This can be accomplished by placing the line {- OPTIONS_GHC -fno-cse -}V in the file in which the declarations are declared, before the "module" line. Declaring unique $s; caveats are the same as those of s.OThe initial value is used so that the reference refers initially to that value.pThese preconditions apply to GHC 7.0.4 and base-0.4.3.1 and likely similar versions and implementations as well.4In its low-level implementation, this instance uses ÿ'; thus, the same caveats apply to this instance, particularly those regarding top-level declarations (referential transparency cannot be violated here). As of base-4.3.1.0, these conditions, that the user needs to be aware of, are the following: * Compile the declarations with the compiler flag -fno-cse. This prevents multiple references from being substituted to refer to the same data. This flag thus does not affect the semantics of the program, but may potentially adversely affect its performance; thus, isolating in a .GlobalÜ module may be advisable in some cases. This condition is not strictly necessary when only one declaration is made in a module, since the compiler cannot substitute multiple references to refer to same data.ÿuIf your code behaves differently when optimizations are enabled, ensure that this flag is indeed being used when the declarations are being compiled. Setting or passing this flag is NOT handled automatically by this implementation; it is the responsibility of users of this implementation to ensure that such appropriate behaviour is set when necessary.-This can be accomplished by placing the line {- OPTIONS_GHC -fno-cse -}V in the file in which the declarations are declared, before the "module" line.!Declaring unique "s.kThe initial value; which is, in this case, determines the initial quantity of the semaphore; is passed to newMSemNA; the types thus must match. The internal type is given to the "A constructor to construct a semaphore based on an integral type.PNB: When multiple units of a resource are needed simultaneously, consider using "s to avoid deadlocks.pThese preconditions apply to GHC 7.0.4 and base-0.4.3.1 and likely similar versions and implementations as well.4In its low-level implementation, this instance uses ÿ'; thus, the same caveats apply to this instance, particularly those regarding top-level declarations (referential transparency cannot be violated here). As of base-4.3.1.0, these conditions, that the user needs to be aware of, are the following: * Compile the declarations with the compiler flag -fno-cse. This prevents multiple references from being substituted to refer to the same data. This flag thus does not affect the semantics of the program, but may potentially adversely affect its performance; thus, isolating in a .GlobalÜ module may be advisable in some cases. This condition is not strictly necessary when only one declaration is made in a module, since the compiler cannot substitute multiple references to refer to same data.ÿuIf your code behaves differently when optimizations are enabled, ensure that this flag is indeed being used when the declarations are being compiled. Setting or passing this flag is NOT handled automatically by this implementation; it is the responsibility of users of this implementation to ensure that such appropriate behaviour is set when necessary.-This can be accomplished by placing the line {- OPTIONS_GHC -fno-cse -}V in the file in which the declarations are declared, before the "module" line.#Declaring unique $s.kThe initial value; which is, in this case, determines the initial quantity of the semaphore; is passed to newMSemA; the types thus must match. The internal type is given to the $A constructor to construct a semaphore based on an integral type.PNB: When multiple units of a resource are needed simultaneously, consider using "s to avoid deadlocks.pThese preconditions apply to GHC 7.0.4 and base-0.4.3.1 and likely similar versions and implementations as well.4In its low-level implementation, this instance uses ÿ'; thus, the same caveats apply to this instance, particularly those regarding top-level declarations (referential transparency cannot be violated here). As of base-4.3.1.0, these conditions, that the user needs to be aware of, are the following: * Compile the declarations with the compiler flag -fno-cse. This prevents multiple references from being substituted to refer to the same data. This flag thus does not affect the semantics of the program, but may potentially adversely affect its performance; thus, isolating in a .GlobalÜ module may be advisable in some cases. This condition is not strictly necessary when only one declaration is made in a module, since the compiler cannot substitute multiple references to refer to same data.ÿuIf your code behaves differently when optimizations are enabled, ensure that this flag is indeed being used when the declarations are being compiled. Setting or passing this flag is NOT handled automatically by this implementation; it is the responsibility of users of this implementation to ensure that such appropriate behaviour is set when necessary.-This can be accomplished by placing the line {- OPTIONS_GHC -fno-cse -}V in the file in which the declarations are declared, before the "module" line.%Declaring unique  MSampleVars=s that are initially empty; caveats are the same as those of s that are initially empty.The initial value is ignored.pThese preconditions apply to GHC 7.0.4 and base-0.4.3.1 and likely similar versions and implementations as well.4In its low-level implementation, this instance uses ÿ'; thus, the same caveats apply to this instance, particularly those regarding top-level declarations (referential transparency cannot be violated here). As of base-4.3.1.0, these conditions, that the user needs to be aware of, are the following: * Compile the declarations with the compiler flag -fno-cse. This prevents multiple references from being substituted to refer to the same data. This flag thus does not affect the semantics of the program, but may potentially adversely affect its performance; thus, isolating in a .GlobalÜ module may be advisable in some cases. This condition is not strictly necessary when only one declaration is made in a module, since the compiler cannot substitute multiple references to refer to same data.ÿuIf your code behaves differently when optimizations are enabled, ensure that this flag is indeed being used when the declarations are being compiled. Setting or passing this flag is NOT handled automatically by this implementation; it is the responsibility of users of this implementation to ensure that such appropriate behaviour is set when necessary.-This can be accomplished by placing the line {- OPTIONS_GHC -fno-cse -}V in the file in which the declarations are declared, before the "module" line.&Declaring unique '$s; caveats are the same as those of s.OThe initial value is used so that the reference refers initially to that value.pThese preconditions apply to GHC 7.0.4 and base-0.4.3.1 and likely similar versions and implementations as well.4In its low-level implementation, this instance uses ÿ'; thus, the same caveats apply to this instance, particularly those regarding top-level declarations (referential transparency cannot be violated here). As of base-4.3.1.0, these conditions, that the user needs to be aware of, are the following: * Compile the declarations with the compiler flag -fno-cse. This prevents multiple references from being substituted to refer to the same data. This flag thus does not affect the semantics of the program, but may potentially adversely affect its performance; thus, isolating in a .GlobalÜ module may be advisable in some cases. This condition is not strictly necessary when only one declaration is made in a module, since the compiler cannot substitute multiple references to refer to same data.ÿuIf your code behaves differently when optimizations are enabled, ensure that this flag is indeed being used when the declarations are being compiled. Setting or passing this flag is NOT handled automatically by this implementation; it is the responsibility of users of this implementation to ensure that such appropriate behaviour is set when necessary.-This can be accomplished by placing the line {- OPTIONS_GHC -fno-cse -}V in the file in which the declarations are declared, before the "module" line.(Declaring unique )s.4The initial value and the internal type are ignored.PNB: When multiple units of a resource are needed simultaneously, consider using *s to avoid deadlocks.pThese preconditions apply to GHC 7.0.4 and base-0.4.3.1 and likely similar versions and implementations as well.4In its low-level implementation, this instance uses ÿ'; thus, the same caveats apply to this instance, particularly those regarding top-level declarations (referential transparency cannot be violated here). As of base-4.3.1.0, these conditions, that the user needs to be aware of, are the following: * Compile the declarations with the compiler flag -fno-cse. This prevents multiple references from being substituted to refer to the same data. This flag thus does not affect the semantics of the program, but may potentially adversely affect its performance; thus, isolating in a .GlobalÜ module may be advisable in some cases. This condition is not strictly necessary when only one declaration is made in a module, since the compiler cannot substitute multiple references to refer to same data.ÿuIf your code behaves differently when optimizations are enabled, ensure that this flag is indeed being used when the declarations are being compiled. Setting or passing this flag is NOT handled automatically by this implementation; it is the responsibility of users of this implementation to ensure that such appropriate behaviour is set when necessary.-This can be accomplished by placing the line {- OPTIONS_GHC -fno-cse -}V in the file in which the declarations are declared, before the "module" line.+Declaring unique *s.kThe initial value; which is, in this case, determines the initial quantity of the semaphore; is passed to ,<; the types thus must match. The internal type is ignored.PNB: When multiple units of a resource are needed simultaneously, consider using *s to avoid deadlocks.pThese preconditions apply to GHC 7.0.4 and base-0.4.3.1 and likely similar versions and implementations as well.4In its low-level implementation, this instance uses ÿ'; thus, the same caveats apply to this instance, particularly those regarding top-level declarations (referential transparency cannot be violated here). As of base-4.3.1.0, these conditions, that the user needs to be aware of, are the following: * Compile the declarations with the compiler flag -fno-cse. This prevents multiple references from being substituted to refer to the same data. This flag thus does not affect the semantics of the program, but may potentially adversely affect its performance; thus, isolating in a .GlobalÜ module may be advisable in some cases. This condition is not strictly necessary when only one declaration is made in a module, since the compiler cannot substitute multiple references to refer to same data.ÿuIf your code behaves differently when optimizations are enabled, ensure that this flag is indeed being used when the declarations are being compiled. Setting or passing this flag is NOT handled automatically by this implementation; it is the responsibility of users of this implementation to ensure that such appropriate behaviour is set when necessary.-This can be accomplished by placing the line {- OPTIONS_GHC -fno-cse -}V in the file in which the declarations are declared, before the "module" line.-Declaring unique .s.kThe initial value; which is, in this case, determines the initial quantity of the semaphore; is passed to /<; the types thus must match. The internal type is ignored.PNB: When multiple units of a resource are needed simultaneously, consider using *s to avoid deadlocks.pThese preconditions apply to GHC 7.0.4 and base-0.4.3.1 and likely similar versions and implementations as well.4In its low-level implementation, this instance uses ÿ'; thus, the same caveats apply to this instance, particularly those regarding top-level declarations (referential transparency cannot be violated here). As of base-4.3.1.0, these conditions, that the user needs to be aware of, are the following: * Compile the declarations with the compiler flag -fno-cse. This prevents multiple references from being substituted to refer to the same data. This flag thus does not affect the semantics of the program, but may potentially adversely affect its performance; thus, isolating in a .GlobalÜ module may be advisable in some cases. This condition is not strictly necessary when only one declaration is made in a module, since the compiler cannot substitute multiple references to refer to same data.ÿuIf your code behaves differently when optimizations are enabled, ensure that this flag is indeed being used when the declarations are being compiled. Setting or passing this flag is NOT handled automatically by this implementation; it is the responsibility of users of this implementation to ensure that such appropriate behaviour is set when necessary.-This can be accomplished by placing the line {- OPTIONS_GHC -fno-cse -}V in the file in which the declarations are declared, before the "module" line.0Declaring unique 1Ns that are initially empty; for thread-safe atomic accessing of channels, see #; caveats are the same as those of s that are initially empty.The initial value is ignored.pThese preconditions apply to GHC 7.0.4 and base-0.4.3.1 and likely similar versions and implementations as well.4In its low-level implementation, this instance uses ÿ'; thus, the same caveats apply to this instance, particularly those regarding top-level declarations (referential transparency cannot be violated here). As of base-4.3.1.0, these conditions, that the user needs to be aware of, are the following: * Compile the declarations with the compiler flag -fno-cse. This prevents multiple references from being substituted to refer to the same data. This flag thus does not affect the semantics of the program, but may potentially adversely affect its performance; thus, isolating in a .GlobalÜ module may be advisable in some cases. This condition is not strictly necessary when only one declaration is made in a module, since the compiler cannot substitute multiple references to refer to same data.ÿuIf your code behaves differently when optimizations are enabled, ensure that this flag is indeed being used when the declarations are being compiled. Setting or passing this flag is NOT handled automatically by this implementation; it is the responsibility of users of this implementation to ensure that such appropriate behaviour is set when necessary.-This can be accomplished by placing the line {- OPTIONS_GHC -fno-cse -}V in the file in which the declarations are declared, before the "module" line.2Declaring unique %s that are initially empty; see also .The initial value is ignored.pThese preconditions apply to GHC 7.0.4 and base-0.4.3.1 and likely similar versions and implementations as well.4In its low-level implementation, this instance uses ÿ'; thus, the same caveats apply to this instance, particularly those regarding top-level declarations (referential transparency cannot be violated here). As of base-4.3.1.0, these conditions, that the user needs to be aware of, are the following: * Compile the declarations with the compiler flag -fno-cse. This prevents multiple references from being substituted to refer to the same data. This flag thus does not affect the semantics of the program, but may potentially adversely affect its performance; thus, isolating in a .GlobalÜ module may be advisable in some cases. This condition is not strictly necessary when only one declaration is made in a module, since the compiler cannot substitute multiple references to refer to same data.ÿuIf your code behaves differently when optimizations are enabled, ensure that this flag is indeed being used when the declarations are being compiled. Setting or passing this flag is NOT handled automatically by this implementation; it is the responsibility of users of this implementation to ensure that such appropriate behaviour is set when necessary.-This can be accomplished by placing the line {- OPTIONS_GHC -fno-cse -}V in the file in which the declarations are declared, before the "module" line.3Declaring unique  s; see also #; caveats are the same as those of s.OThe initial value is used so that the reference refers initially to that value.pThese preconditions apply to GHC 7.0.4 and base-0.4.3.1 and likely similar versions and implementations as well.4In its low-level implementation, this instance uses ÿ'; thus, the same caveats apply to this instance, particularly those regarding top-level declarations (referential transparency cannot be violated here). As of base-4.3.1.0, these conditions, that the user needs to be aware of, are the following: * Compile the declarations with the compiler flag -fno-cse. This prevents multiple references from being substituted to refer to the same data. This flag thus does not affect the semantics of the program, but may potentially adversely affect its performance; thus, isolating in a .GlobalÜ module may be advisable in some cases. This condition is not strictly necessary when only one declaration is made in a module, since the compiler cannot substitute multiple references to refer to same data.ÿuIf your code behaves differently when optimizations are enabled, ensure that this flag is indeed being used when the declarations are being compiled. Setting or passing this flag is NOT handled automatically by this implementation; it is the responsibility of users of this implementation to ensure that such appropriate behaviour is set when necessary.-This can be accomplished by placing the line {- OPTIONS_GHC -fno-cse -}V in the file in which the declarations are declared, before the "module" line.4Declaring unique 1s; for thread-safe handling of mutable data, see .OThe initial value is used so that the reference refers initially to that value.pThese preconditions apply to GHC 7.0.4 and base-0.4.3.1 and likely similar versions and implementations as well.4In its low-level implementation, this instance uses ÿ-; thus, the same preconditions apply to this instance, particularly those regarding top-level declarations (referential transparency cannot be violated here). As of base-4.3.1.0, these conditions, that the user needs to be aware of, are the following: * Compile the declarations with the compiler flag -fno-cse. This prevents multiple references from being substituted to refer to the same data. This flag thus does not affect the semantics of the program, but may potentially adversely affect its performance; thus, isolating in a .GlobalÜ module may be advisable in some cases. This condition is not strictly necessary when only one declaration is made in a module, since the compiler cannot substitute multiple references to refer to same data.ÿuIf your code behaves differently when optimizations are enabled, ensure that this flag is indeed being used when the declarations are being compiled. Setting or passing this flag is NOT handled automatically by this implementation; it is the responsibility of users of this implementation to ensure that such appropriate behaviour is set when necessary.-This can be accomplished by placing the line {- OPTIONS_GHC -fno-cse -}V in the file in which the declarations are declared, before the "module" line.!Name of reference˜Initial value, accompanied with the internal type and tagged with the unique constructor so that the correct instance can be unambiguously determined.éAn initial value may not make sense in some contexts; implementations of instances may choose to ignore this value, as well as the internal type and unique constructor. Implementations should document how this parameter is used.2Top-level declarations for the unique declaration.KAt least a definition for the name and a type signature should be provided.   !#%&(+-0234       !#%&(+-02345       !"#$%&'()*+,'-./01234567489:;4<=>4?@ABCADEFGFHIJKLMNOglobal-0.2.0.1 Data.GlobalLanguage.Haskell.Exts.QQtranslateExtsToTH QSemQuantityUVCntUTUNUDEmptyUniqueDeclaration=::unut monomorphictranslateExtsToTH'utlud uninitializedUnsafeUDeclInternalunsafeUDeclInternalbaseGHC.BaseMonadghc-prim GHC.TypesIOGHC.IOunsafePerformIO GHC.Conc.SyncTVartemplate-haskellLanguage.Haskell.TH.SyntaxQLanguage.Haskell.TH.Quote QuasiQuoterhaskell-src-exts-qq-0.6.1hs$fUniqueDeclarationUDEmpty stm-2.4.3Control.Concurrent.STM.TChanTChanGHC.MVarMVar$fUniqueDeclarationUDEmpty0Control.Concurrent.STM.TMVarTMVar$fUniqueDeclarationTMVar GHC.IORefIORef$fUniqueDeclarationTVar$fUniqueDeclarationMSemNSafeSemaphore-0.10.1Control.Concurrent.MSemNMSemN$fUniqueDeclarationMSemControl.Concurrent.MSemMSem$fUniqueDeclarationUDEmpty1$fUniqueDeclarationMSampleVarControl.Concurrent.MSampleVar MSampleVar$fUniqueDeclarationConstControl.Concurrent.FairRWLockRWLockControl.Concurrent.QSemNQSemN$fUniqueDeclarationConst0newQSemN$fUniqueDeclarationConst1Control.Concurrent.QSemQSemnewQSem$fUniqueDeclarationUDEmpty2Control.Concurrent.ChanChan$fUniqueDeclarationUDEmpty3$fUniqueDeclarationMVar$fUniqueDeclarationIORef