anchor.diff:                                p1.Probability * p2.Probability}))
             |> Seq.concat : 'b Distribution
     
  -  let inline (>>=) dist f = bindD dist f
  -  
  -  let returnD (value:'a) =   
  +  let inline (>>=) dist f = bind f dist
  +  
  +  let returnM (value:'a) =   
         Seq.singleton { Value = value ; Probability = 1N/1N }
           : 'a Distribution
     
     type DistributionMonadBuilder() =
  -      member this.Bind (r, f) = bindD r f
  -      member this.Return x = returnD x
  +      member this.Bind (r, f) = bind f r
  +      member this.Return x = returnM x
         member this.ReturnFrom x = x
     
     let distribution = DistributionMonadBuilder()
  
positive.code:   type 'a Distribution = 'a Outcome seq
    
    // P(A AND B) = P(A | B) * P(B)
    let bindD (dist:'a Distribution) (f: 'a -> 'b Distribution) =
        dist 
            |> Seq.map (fun p1 -> 
                    f p1.Value
  
negative.code:         |> Seq.map (fun o -> o.Probability)
          |> Seq.sum
    
    let certainly = returnM
    let impossible<'a> :'a Distribution = toUniformDistribution []
    
    let fairDice sides = toUniformDistribution [1..sides]
  