anchor.diff:          |> Seq.map (fun o -> o.Probability)
           |> Seq.sum
     
  -  let certainly = returnD
  +  let certainly = returnM
     let impossible<'a> :'a Distribution = toUniformDistribution []
     
     let fairDice sides = toUniformDistribution [1..sides]
  
positive.code:                               p1.Probability * p2.Probability}))
            |> Seq.concat : 'b Distribution
    
    let inline (>>=) dist f = bindD dist f
    
    let returnD (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.ReturnFrom x = x
    
    let distribution = DistributionMonadBuilder()
  
negative.code:   type 'a Distribution = 'a Outcome seq
    
    // P(A AND B) = P(A | B) * P(B)
    let bind (f: 'a -> 'b Distribution) (dist:'a Distribution) =
        dist 
            |> Seq.map (fun p1 -> 
                    f p1.Value
  