Îõ³h&.¨+ùù      !"#$%&'()*+,-./0123456789 :; <= >? @ A B C D E F G H I J K L M NOPQRSTUVWXYZ[\]^_`abcde f g h i j k l m n o p q r s t u v w x  Safe-Inferredòrec-def!A class indicating that the type a is has a top element.rec-def!A class indicating that the type a is has a bottom element.rec-def#This class indicates that the type a) is partially ordered by some relation ‘E.˜The class does not actually have a method for ‘E, because we do not need it at runtime. Nevertheless the order better exists for the safety of this API.8This order may be unrelated to the total order given by y.rec-defThe / method checks _related_ elements for equality.Formally: For all x ‘E y, eqOfLe x y == True iff x == y.ÍThis can be more efficient than testing for equality. For example for sets, z$ needs to compare the elements, but eqOfLe6 only needs to compare sizes. It is always ok to use z here.rec-defAdds {0 as a least element to an existing partial orderrec-defOrdered by '(<=)f'rec-def Ordered by  rec-defArbitrary using the  False < True order rec-defThe dual order rec-def Bottom is { rec-def Bottom is 0 rec-def Bottom is |rec-def Bottom is }rec-defTop is ~rec-defBottom is the  of a Safe-Inferred ÁÂÃÄÅÇÌÚßrec-defôThe Propagator class defines some functions shared by different propagator implementations. This backs the generic Data.Propagator.Purify wrapper. Safe-Inferred ÁÃÄÅÜãï rec-defA cell in a propagator networkrec-def%Creates a cell, initialized to bottomrec-def/Creates a constant cell, given an initial valuerec-def#Reads the current value of the cellrec-def)Is the current propagator already frozen?rec-defMarks the propagator as frozen.ÕWill prevent further calls to setProp and clears the list of watchers (to allow GC).rec-defÕSets a new value calculated from the given action. The action is executed atomically.*Throws if the propagator is already frozenÐIf the value has changed, all watchers are notified afterwards (not atomically). rec-defÀWatch a cell: If the value changes, the given action is executed!rec-defÌWhenever the first cell changes, update the second, using the given function"rec-defÖWhenever any of the first two cells change, update the third, using the given function#rec-defØWhenever any of the cells in the list change, update the other, using the given function  !"#  !"# Safe-InferredÄÅãî %rec-defÎA type for propagators for the two-point lattice, consisting of bottom and top€rec-def6Just act: Still bottom, run act (once!) when triggeredrec-defDefinitely bottom ‚rec-defDefinitely top&rec-def'A new propagator, initialized at bottom'rec-def$A new propagator, already set to top(rec-def whenTop p act runs act if p is already top, or after setTop p is run)rec-defSet a propagator to top.6If it was bottom before, runs the actions queued with (. It does so after: setting the propagator to top, so that cycles are broken.*rec-defp1 * p2 chains propagators: If p1 becomes top, then so does p2.+rec-defÂQueries the current state of the propagator. All related calls to setTop3 that have executed so far are taken into account.ƒrec-def0Freezes the value. Drops references to watchers.%&'()*+%&')(*+ Safe-Inferredã«„rec-defA - that is being evaluated-rec-defAn IO& action that is to be run at most once.rec-def Create a new - from an … action.The …ñ action may return other thunks that should be forced together whenver this thunk is forced (in arbitrary order)/rec-def"A Thunk that that already is done.Equivalent to +do {t <- thunk (pure []); force t; pure t }0rec-defüForce the execution of the thunk. If it has been forced already, it will do nothing. Else it will run the action passed to .Õ, force thunks returned by that action, and not return until all of them are forced.-./0-./0 Safe-Inferred )*5ÂÌÚh1rec-defA value of type Purify p is a propagator p,, gether with a (lazy) action to define it. You can use 6* to extract the value from the propagator.‰Do not use the extracted value in the definition of that value, this will loop just like a recursive definition with plain values would!2rec-defAny value of type a is also a value of type Purify p if p is a propagator for a.3rec-defDefines a value of type Purify b# to be a function of the values of Purify a.ÌThe action passed should declare that relation to the underlying propagator.The Prop a1 propagator must only be used for reading values from.4rec-defDefines a value of type Purify c# to be a function of the values of Purify a and Purify b.ÌThe action passed should declare that relation to the underlying propagator.The Prop a and Prop b2 propagators must only be used for reading values from.5rec-defDefines a value of type Purify b- to be a function of the values of a list of Purify a values.ÌThe action passed should declare that relation to the underlying propagator.The Prop a2 propagators must only be used for reading values from.6rec-defExtract the value from a Purify a. This must not be used when defining that value.123456162345 Safe-InferredïØ7rec-defLike †#, but admits recursive definitions.9rec-defLike ‡#, but admits recursive definitions.;rec-defLike ˆÅ, but admits recursive definitions, preferring the greatest solution.=rec-defLike ˆÂ, but admits recursive definitions, preferring the least solution.789:;<=>=>;<9:78  Safe-InferredÌÚq?rec-def Extracts the value of a 'RSet a'@rec-defRB.get (RB.mk s) === sArec-defRS.get RS.empty === S.emptyBrec-def)RS.get (RS.singleton x) === S.singleton xCrec-def2RS.get (RS.insert n r1) === S.insert n (RS.get r1)Drec-def2RS.get (RS.delete n r1) === S.delete n (RS.get r1)Erec-defÀ\(Fun _ p) -> RS.get (RS.filter p r1) === S.filter p (RS.get r1)Frec-def;RS.get (RS.union r1 r2) === S.union (RS.get r1) (RS.get r2)Grec-def2RS.get (RS.unions rs) === S.unions (map RS.get rs)Hrec-defÉRS.get (RS.intersection r1 r2) === S.intersection (RS.get r1) (RS.get r2)Irec-def2RB.get (RS.member n r1) === S.member n (RS.get r1)Jrec-def9RDB.get (RS.notMember n r1) === S.notMember n (RS.get r1)Krec-def)RDB.get (RS.null s) === S.null (RS.get s)Lrec-defÂRDB.get (RS.disjoint r1 r2) === S.disjoint (RS.get r1) (RS.get r2)Mrec-defÜThe identity function. This is useful when tying the knot, to avoid a loop that bottoms out: let x = x in RS.get xwill not work, butlet x = RS.id x in RS.get x fromList []does.%| prop> RS.get (RS.id s) === RS.get s9?@ABCDEFGHIJKLM9?@ABCDEFGHIJKLM Safe-InferredÌÚ%ÌNrec-defExtracts the value of a MSetOrec-defRM.get (RM.mk m) === mPrec-defRM.get RM.empty === M.emptyQrec-def-RM.get (RM.singleton k v) === M.singleton k vRrec-def4RM.get (RM.insert k v m) === M.insert k v (RM.get m)Srec-defØRM.get (RM.insertWith (applyFun2 f) k v m) === M.insertWith (applyFun2 f) k v (RM.get m)Trec-defÞRM.get (RM.insertWithKey (applyFun3 f) k v m) === M.insertWithKey (applyFun3 f) k v (RM.get m)Urec-def0RM.get (RM.delete k m) === M.delete k (RM.get m)Vrec-defÊRM.get (RM.adjust (applyFun f) k m) === M.adjust (applyFun f) k (RM.get m)Wrec-defÚRM.get (RM.adjustWithKey (applyFun2 f) k m) === M.adjustWithKey (applyFun2 f) k (RM.get m)Xrec-def;RM.get (RM.union m1 m2) === M.union (RM.get m1) (RM.get m2)Yrec-defßRM.get (RM.unionWith (applyFun2 f) m1 m2) === M.unionWith (applyFun2 f) (RM.get m1) (RM.get m2)Zrec-defåRM.get (RM.unionWithKey (applyFun3 f) m1 m2) === M.unionWithKey (applyFun3 f) (RM.get m1) (RM.get m2)[rec-defÉRM.get (RM.intersection m1 m2) === M.intersection (RM.get m1) (RM.get m2)\rec-defíRM.get (RM.intersectionWith (applyFun2 f) m1 m2) === M.intersectionWith (applyFun2 f) (RM.get m1) (RM.get m2)]rec-defóRM.get (RM.intersectionWithKey (applyFun3 f) m1 m2) === M.intersectionWithKey (applyFun3 f) (RM.get m1) (RM.get m2)^rec-def-RM.get (RM.singleton k v) === M.singleton k v_rec-def.RS.get (RM.keysSet m) === M.keysSet (RM.get m)`rec-defÅRM.get (RM.restrictKeys m s) === M.restrictKeys (RM.get m) (RS.get s)arec-def0RB.get (RM.member k m) === M.member k (RM.get m)brec-def9RDB.get (RM.notMember n r1) === M.notMember n (RM.get r1)crec-defÂRDB.get (RM.disjoint m1 m2) === M.disjoint (RM.get m1) (RM.get m2)drec-def)RDB.get (RM.null m) === M.null (RM.get m)7NOPQRSTUVWXYZ[\]^_`abcd7NOPQRSTUVWXYZ[\]abcd^_`  Safe-Inferredï(á erec-defExtracts the value of a ;frec-defRDB.get (RDB.mk b) === bgrec-defRDB.get RDB.true == Truehrec-defRDB.get RDB.false == Falseirec-def5RDB.get (r1 RDB.&& r2) === (RDB.get r1 && RDB.get r2)jrec-def5RDB.get (r1 RDB.|| r2) === (RDB.get r1 || RDB.get r2)krec-def-RDB.get (RDB.and rs) === and (map RDB.get rs)lrec-def+RDB.get (RDB.or rs) === or (map RDB.get rs)mrec-def(RDB.get (RDB.not r1) === not (RB.get r1)nrec-defÜThe identity function. This is useful when tying the knot, to avoid a loop that bottoms out: let x = x in RDB.get xwill not work, butlet x = RDB.id x in RDB.get xTruedoes.(| prop> RDB.get (RDB.id r) === RDB.get r ;efghijklmn ;efghijklmn  Safe-Inferredï+¹ orec-defExtracts the value of a =prec-defRB.get (RB.mk b) === bqrec-defRB.get RB.true == Truerrec-defRB.get RB.false == Falsesrec-def1RB.get (r1 RB.&& r2) === (RB.get r1 && RB.get r2)trec-def1RB.get (r1 RB.|| r2) === (RB.get r1 || RB.get r2)urec-def*RB.get (RB.and rs) === and (map RB.get rs)vrec-def(RB.get (RB.or rs) === or (map RB.get rs)wrec-def'RB.get (RB.not r1) === not (RDB.get r1)xrec-defÜThe identity function. This is useful when tying the knot, to avoid a loop that bottoms out: let x = x in RB.get xwill not work, butlet x = RB.id x in RB.get xFalsedoes.RB.get (RB.id r) === RB.get r =opqrstuvwx =opqrstuvwx Safe-Inferred+õ‰  !"#$%&'("#%$)*+,-./0123456789:;<=>?@AABBCCDD @ < E F G H I J K L M N O P Q@<EFGRSHTUJVWLXYZ[\MNPO @ < ] ^ _ ` a b c Q @ < ] ^ _ ` a b c QdefdeghijklEdmndmopqrstudmvkwxklydmzû"rec-def-0.2-EHrFjI4ap3R1Sey8msaxNU Data.POrderData.Propagator.ClassData.Propagator.NaiveData.Propagator.P2System.IO.RecThunkData.Propagator.PurifyData.Recursive.MapData.Recursive.InternalData.Recursive.SetData.Recursive.DualBoolData.Recursive.BoolSsubsetOfData.Recursive.ExamplesToptopBottombottomPOrdereqOfLe $fPOrderMaybe$fPOrderNatural $fPOrderSet $fPOrderBool $fPOrderDual $fBottomMaybe$fBottomNatural $fBottomSet $fBottomBool $fTopBool $fBottomDual WriteToFrozenPropagatorException PropagatornewProp newConstProp freezePropreadProp+$fExceptionWriteToFrozenPropagatorException&$fShowWriteToFrozenPropagatorExceptionPropsetProp watchProplift1lift2liftList$fPropagatorPropaP2newP2newTopP2whenTopsetTopimpliesisTop$fPropagatorP2BoolThunkthunk doneThunkforcePurifymkdef1def2defListgetRMapRSet RDualBoolRBoolempty singletoninsertdeletefilterunionunions intersectionmember notMembernulldisjointid insertWith insertWithKeyadjust adjustWithKey unionWith unionWithKeyintersectionWithintersectionWithKeyfromSetkeysSet restrictKeystruefalse&&||andornotghc-prim GHC.ClassesOrd==base GHC.MaybeNothingcontainers-0.6.5.1Data.Set.Internal GHC.TypesFalseTrueisFrozen StillBottom SurelyBottom SurelyTopfreeze KickedThunkIOData.Map.InternalMapSetBool