Darcs.Patch.Commute

Documentation

class Commute p where

Commute represents things that can be (possibly) commuted.

Methods

commute :: (p :> p) wX wY -> Maybe ((p :> p) wX wY)

Instances

Commute Prim

Commute Prim

Commute DummyPatch

Commute p => Commute (RL p)

Commute p => Commute (FL p)

(Commute p, NameHack p) => Commute (Named p)

Commute (RebaseName p)

PrimPatchBase p => Commute (RebaseFixup p)

PrimPatch prim => Commute (Patch prim)

PrimPatch prim => Commute (RealPatch prim)

(Commute p, NameHack p) => Commute (PatchInfoAnd p)

(PrimPatchBase p, FromPrim p, Effect p, Invert p, Commute p) => Commute (Rebasing p)

Commute (RebaseChange p)

(PrimPatchBase p, FromPrim p, Effect p, Commute p, Invert p, NameHack p) => Commute (RebaseSelect p)

Commute p => Commute (LabelledPatch p)

commuteFL :: Commute p => (p :> FL p) wX wY -> Maybe ((FL p :> p) wX wY)

commuteFL commutes a single element past a FL.

commuteFLorComplain :: Commute p => (p :> FL p) wX wY -> Either (Sealed2 p) ((FL p :> p) wX wY)

commuteFLorComplain attempts to commute a single element past a FL. If any individual commute fails, then we return the patch that first patch that cannot be commuted past.

commuteRL :: Commute p => (RL p :> p) wX wY -> Maybe ((p :> RL p) wX wY)

commuteRL commutes a RL past a single element.

commuteRLFL :: Commute p => (RL p :> FL p) wX wY -> Maybe ((FL p :> RL p) wX wY)

commuteRLFL commutes an RL past an FL.

toFwdCommute :: (Commute p, Commute q, Monad m) => ((p :< q) wX wY -> m ((q :< p) wX wY)) -> (q :> p) wX wY -> m ((p :> q) wX wY)

Swaps the ordered pair type so that commute can be called directly.

toRevCommute :: (Commute p, Commute q, Monad m) => ((p :> q) wX wY -> m ((q :> p) wX wY)) -> (q :< p) wX wY -> m ((p :< q) wX wY)

Swaps the ordered pair type from the order expected by commute to the reverse order.

selfCommuter :: Commute p => CommuteFn p p

Build a commuter between a patch and itself using the operation from the type class.