anchor.diff:      let inline lens sa sbt afb s = sbt s <!> afb (sa s)
   
   
  -    /// Build a Prism usign Choice instead of Option a to permit the types of s and t to differ.
  +    /// Build a Prism using Choice instead of Option to permit the types of 's and 't to differ.
       let inline prism (bt:'b->'t) (seta:'s->Choice<'a,'t>) = dimap seta (choice result (map bt)) << (fun g -> choice Choice2Of2 (Choice1Of2 << g))
       let inline prism' (bs:'b->'s) (sma:'s->Option<'a>) = prism bs (fun s -> option (Choice2Of2 s) Choice1Of2 (sma s))
   
  
positive.code:     let (.->) l s = set  l s
      let (%->) l s = over l s
      let (^?)  s l = preview  l s
      let (^..) s l = toListOf l s
  
  
     
negative.code:     // functions
      let inline to' k = dimap k (contramap k)
  
      let foldMapOf l f = Const.run </rmap'/> l (Const </rmap'/> f)
      let foldOf    l   = Const.run </rmap'/> l Const
      let foldrOf l f z = flip Endo.run z << foldMapOf l (Endo </rmap'/> f)
      let foldlOf l f z = (flip Endo.run z </lmap'/> Dual.run) </rmap'/> foldMapOf l (Dual </rmap'/> Endo </rmap'/> flip f)
      let toListOf  l   = let cons x y = x :: y in foldrOf l cons []
  
      let anyOf  l f = getAny </rmap'/> foldMapOf l (Any </rmap'/> f)
      let allOf  l f = getAll </rmap'/> foldMapOf l (All </rmap'/> f)
      let elemOf l = anyOf l << (=)
      let inline items x = traverse x
  
      let inline filtered p f s = if p s then f s else result s
      let inline both f (a, b) = tuple2 <!> f a <*> f b
  
      let inline withIso ai k = let (Exchange (sa, bt)) = ai (Exchange (id, Identity)) in k sa (Identity.run </rmap'/> bt)
      let inline from l    = withIso l <| fun sa bt -> iso bt sa
      let inline mapping k = withIso k <| fun sa bt -> iso (map sa) (map bt)
  
  