h$     None'(-/[ attenuationA constraint that behaves like type role f representational _. See also . attenuationA constraint that behaves like type role f _ representational. See also . attenuationA constraint that behaves like type role f representational.This means that if we have this constraint in context and GHC can solve  for some types a and b$, it will also lift the coercion to f a and f b. attenuationA witness that a occurs representationally in s% and that, when substituting it for b , you get t.These compose like Lenses from the "lens" package, so you can e.g. lift s through several Functors by   .co.co $ x. attenuationAttenuation a b is a unidirectional  from a to b.8"Attenuate: reduce the force, effect, or value of." An  Attenuation takes a stronger, stricter type to a weaker, more lax type. It's meant to sound a bit like <, while conveying that it weakens the type of its argument.This arises from newtypes that impose additional invariants on their representations: if we define Fin :: Nat -> Type as a newtype over , such as in  +https://hackage.haskell.org/package/fin-intfin-int, then it's safe to  Fins to s, and Fin s to other Fins with larger Nat parameters, but not vice versa. Within the module defining this Fin type, we can obtain  between any two Fin types regardless of their roles, because their newtype constructors are in scope, but if we've taken appropriate precautions (namely not exporting the constructor), we can't obtain it outside the module. We can relax this and make the coercion "opt-in" by exporting it in the form of a  with a scary name like  unsafeCoFin!, but this is still error-prone./Instead, we introduce a newtype wrapper around  which restricts it to be used only in the forward direction, and carefully design its API so that it can only be obtained under the appropriate circumstances.Attenuation a b can be seen as a witness that a8 is, semantically and representationally, a subtype of b-: that is, any runtime object that inhabits a also inhabits b without any conversion. Note, however, that we can't have a useful typeclass of this subtyping relation because all of its instances would have to be specified individually: whereas  is willing to invert or compose coercions implicitly because of GHC magic, a subtyping class would not have that affordance. attenuationCoerce along an .6This is really, truly a coercion when it reaches Core. attenuationAny coercible types have an . attenuationTransitivity of s. See also the  instance. attenuation1Any type is unidirectionally coercible to itself.  attenuationBidirectional coercions can be weakened to unidirectional coercions.  attenuationLift an % covariantly over a type constructor f.Although we don't use the  constraint, it serves an important purpose: to guarantee that the type parameter a$ doesn't appear contravariantly in f a*; otherwise it'd be impossible to write a  instance. This is used as a standin for more-detailed "covariant" and "contravariant" type roles, which GHC doesn't have because there's no built-in notion of subtyping to use them with. 0 provides the actual lifting of coercions, and * guarantees we've got the variance right.  attenuationLift an ) contravariantly over a type constructor f.Regarding the  constraint, see  =, and interchange mentions of covariance and contravariance.  attenuationLift an  covariantly over the left of a . Like with   and  , we require a not-actually-used constraint as proof that the type has the appropriate variance. Since there's not a commonly-used class for functors over the last-but-one parameter, we use . Sadly, this rules out types which are covariant in parameter -1 and contravariant in parameter -0.  attenuationLift an 2 covariantly over the last-but-one type parameter. Like with   and  , we require a not-actually-used constraint as proof that the type has the appropriate variance. Since there's not a commonly-used class for functors over the last-but-one parameter, we use . Sadly, this rules out types which are covariant in parameter -1 and contravariant in parameter -0.%Note that any particular type with a  Bifunctor f instance should also have  Functor (f x), so   should work on any type that  - works on, but in polymorphic contexts, the  instance may not be available. attenuationLift an  covariantly over the left of a .Similarly to the use of  in   , we use ; to guarantee contravariance in the appropriate parameter. attenuationLift an ! covariantly over the right of a .Similarly to the use of  in   , we use ; to guarantee contravariance in the appropriate parameter.As with  , this functions the same as  , but the needed : instance might not be available in polymorphic contexts. attenuation of  to any type. If you have  appearing covariantly in a type, you can replace it with any other lifted type with a coercion, because the value can't contain any non-bottom - values (there are none), and any value that is bottom can "work" (i.e. throw or fail to terminate) just as well at any other lifted type.For example, if you have a  [Doc Void] (from  *https://hackage.haskell.org/package/prettypretty), you know it doesn't have any annotations (or they're errors), so you can use it as [Doc a]+ without actually traversing the list and Doc structure to apply  to all of the s. attenuation of any type to  . Similarly to , you can weaken any type to  5 for free, since any value is a valid value of type  .    Safe-Inferred!"#$%&'()      !"#$%&'()*+,-./0123456789*attenuation-0.1.0.0-2rKelWgHUI58USihCBtk4JData.Type.Attenuation Data.VoidabsurdPaths_attenuationRepresentational0Representational1RepresentationalVariance Attenuation attenuate coercibletransreprcoercocontrafstcosndcolcontrarcoattVoidattAny$fCategoryTYPEAttenuation$fEqAttenuation$fOrdAttenuation$fShowAttenuationghc-prim GHC.Types CoerciblebaseData.Type.CoercionCoercionIntGHC.PrimcoerceControl.CategoryCategoryGHC.BaseFunctorData.Functor.Contravariant ContravariantData.Bifunctor Bifunctor(profunctors-5.6.2-EEEqn41uhj5KrnjAoSJhkvData.Profunctor.Unsafe ProfunctorVoidAnyversion getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDirgetDataFileName