diff --git a/ProbabilityMonad.Test/Models/HiddenMarkovModel.cs b/ProbabilityMonad.Test/Models/HiddenMarkovModel.cs
index f7e8d7f..34a4b1f 100644
--- a/ProbabilityMonad.Test/Models/HiddenMarkovModel.cs
+++ b/ProbabilityMonad.Test/Models/HiddenMarkovModel.cs
@@ -29,7 +29,7 @@ from emit in emissionDist(initial)
                 samples = from prev in samples
                           from next in transitionDist(prev.Last().Item1)
                           from emit in emissionDist(next)
-                          select Append(prev, Tuple(next, emit)).ToList();
+                          select prev.Append(Tuple(next, emit)).ToList();
                 numSamples -= 1;
             }
             return samples;
@@ -94,7 +94,7 @@ public static Dist<List<int>> Hmm(List<double> observed)
                 Condition(xs => emission(xs.Last(), y),
                 (from rest in d
                  from x in transitionMatrix(rest.Last())
-                 select Append(rest, x).ToList()));
+                 select rest.Append(x).ToList()));
 
             return observed.Aggregate(startDist, expand);
         }
diff --git a/ProbabilityMonad/Base.cs b/ProbabilityMonad/Base.cs
index 3b041d4..a5b1b08 100644
--- a/ProbabilityMonad/Base.cs
+++ b/ProbabilityMonad/Base.cs
@@ -1,650 +1,639 @@
-using System.Collections.Generic;
-using System.Linq;
-using System;
-using MathNet.Numerics.LinearAlgebra;
-using MathNet.Numerics.LinearAlgebra.Double;
-
-namespace ProbCSharp
-{
-   /// <summary>
-   /// This class exports a whole bunch of constructors.
-   /// Basically avoids us typing new X<A, B, C>()
-   /// which can make code unreadable when we have really large types.
-   /// </summary>
-   public static class ProbBase
-   {
-      // Singleton instance of the random generator to avoid repeated values in tight loops
-      public static Random Gen = new Random();
-
-      #region Primitive object constructors
-      /// <summary>
-      /// Probability constructor
-      /// </summary>
-      public static Prob Prob(double probability)
-      {
-         return new LogProb(Math.Log(probability));
-      }
-
-      /// <summary>
-      /// ItemProb constructor 
-      /// </summary>
-      public static ItemProb<A> ItemProb<A>(A item, Prob prob)
-      {
-         return new ItemProb<A>(item, prob);
-      }
-
-      /// <summary>
-      /// Samples constructor
-      /// </summary>
-      public static Samples<A> Samples<A>(IEnumerable<ItemProb<A>> itemProbs)
-      {
-         return new Samples<A>(itemProbs);
-      }
-
-      /// <summary>
-      /// Tuple constructor
-      /// </summary>
-      public static Tuple<A, B> Tuple<A, B>(A a, B b)
-      {
-         return new Tuple<A, B>(a, b);
-      }
-      #endregion
-
-      #region Distribution constructors
-      /// <summary>
-      /// Finite uniform distribution over list of items. 
-      /// Only composable with other finite distributions.
-      /// </summary>
-      public static FiniteDist<A> EnumUniformF<A>(IEnumerable<A> items)
-      {
-         var uniform = Samples(items.Select(i => new ItemProb<A>(i, Prob(1))));
-         return new FiniteDist<A>(Importance.Normalize(uniform));
-      }
-
-      /// <summary>
-      /// Uniform distribution over list of items
-      /// </summary>
-      public static Dist<A> UniformFromList<A>(IEnumerable<A> items)
-      {
-         return Primitive(EnumUniformF(items));
-      }
-
-      /// <summary>
-      /// Uniform distribution over parameter items
-      /// Only composable with other finite distributions.
-      /// </summary>
-      public static FiniteDist<A> UniformF<A>(params A[] items)
-      {
-         var itemList = new List<A>(items);
-         return EnumUniformF(itemList);
-      }
-
-      /// <summary>
-      /// Uniform distribution over parameter items
-      /// </summary>
-      public static Dist<A> Uniform<A>(params A[] items)
-      {
-         return Primitive(UniformF(items));
-      }
-
-      /// <summary>
-      /// Bernoulli distribution constructed from success probability
-      /// Only composable with other finite distributions.
-      /// </summary>
-      public static FiniteDist<bool> BernoulliF(Prob prob)
-      {
-         return new FiniteDist<bool>(ItemProb(true, prob), ItemProb(false, Prob(1 - prob.Value)));
-      }
-
-      /// <summary>
-      /// Bernoulli distribution constructed from success probability
-      /// </summary>
-      public static Dist<bool> Bernoulli(Prob prob)
-      {
-         return Primitive(BernoulliF(prob));
-      }
-
-      /// <summary>
-      /// Bernoulli distribution constructed from success probability
-      /// </summary>
-      public static Dist<bool> Bernoulli(double prob)
-      {
-         return Primitive(BernoulliF(Prob(prob)));
-      }
-
-      /// <summary>
-      /// Bernoulli distribution constructed from two items, and probability of first item
-      /// </summary>
-      public static Dist<A> Bernoulli<A>(double prob, A option1, A option2)
-      {
-         return Primitive(BernoulliF(Prob(prob))).Select(b => b ? option1 : option2);
-      }
-
-      /// <summary>
-      /// Categorical distribution
-      /// Only composable with other finite distributions
-      /// </summary>
-      public static FiniteDist<A> CategoricalF<A>(params ItemProb<A>[] itemProbs)
-      {
-        return new FiniteDist<A>(Samples(itemProbs));
-      }
-
-      /// <summary>
-      /// Categorical distribution
-      /// Only composable with other finite distributions
-      /// </summary>
-      public static FiniteDist<A> CategoricalF<A>(Samples<A> samples)
-      {
-         return new FiniteDist<A>(samples);
-      }
-
-      /// <summary>
-      /// Categorical distribution
-      /// </summary> 
-      public static Dist<A> Categorical<A>(Samples<A> samples)
-      {
-         return Primitive(CategoricalF(samples).ToSampleDist());
-      }
-
-      /// <summary>
-      /// Categorical distribution
-      /// </summary> 
-      public static CategoricalPrimitive<A> CategoricalPrimitive<A>(A[] items, double [] probabilities)
-      {
-         return new CategoricalPrimitive<A>(items, probabilities, Gen);
-      }
-
-      /// <summary>
-      /// Primitive studentT distribution
-      /// Only composable with other primitive distributions
-      /// </summary>
-      public static StudentTPrimitive StudentTPrimitive(double location, double scale, double normality)
-      {
-          return new StudentTPrimitive(location, scale, normality, Gen);
-      }
-
-      /// <summary>
-      /// Primitive Exponential distribution
-      /// Only composable with other primitive distributions
-      /// </summary>
-      public static ExponentialPrimitive ExponentialPrimitive(double rate)
-      {
-          return new ExponentialPrimitive(rate);
-      }
-
-      /// <summary>
-      /// Primitive Contiuous Uniform distribution
-      /// Only composable with other primitive distributions
-      /// </summary>
-      public static ContinuousUniformPrimitive ContinuousUniformPrimitive()
-      {
-         return new ContinuousUniformPrimitive(Gen);
-      }
-
-      /// <summary>
-      /// Primitive Contiuous Uniform distribution
-      /// Only composable with other primitive distributions
-      /// </summary>
-      public static ContinuousUniformPrimitive ContinuousUniformPrimitive(double lower, double upper)
-      {
-         return new ContinuousUniformPrimitive(lower,upper, Gen);
-      }
-
-
-      /// <summary>
-      /// Primitive Poisson distribution
-      /// Only composable with other primitive distributions
-      /// </summary>
-      public static PoissonPrimitive PoissonPrimitive(double lambda)
-      {
-         return new PoissonPrimitive(lambda, Gen);
-      }
-
-      /// <summary>
-      /// Primitive Normal distribution
-      /// Only composable with other primitive distributions
-      /// </summary>
-      public static NormalPrimitive NormalPrimitive(double mean, double variance)
-      {
-         return new NormalPrimitive(mean, variance, Gen);
-      }
-
-      /// <summary>
-      /// Primitive LogNormal distribution
-      /// Only composable with other primitive distributions
-      /// </summary>
-      public static LogNormalPrimitive LogNormalPrimitive(double mean, double variance)
-      {
-         return new LogNormalPrimitive(mean, variance, Gen);
-      }
-
-      public static LogNormalPrimitive LogNormalPrimitiveMu(double mu, double sigma)
-      {
-         return new LogNormalPrimitive(mu, sigma, true, Gen);
-      }
-
-      /// <summary>
-      /// Primitive Beta distribution
-      /// Only composable with other primitive distributions
-      /// </summary>
-      public static BetaPrimitive BetaPrimitive(double alpha, double beta)
-      {
-         return new BetaPrimitive(alpha, beta, Gen);
-      }
-
-      /// <summary>
-      /// Primitive Gamma distribution
-      /// Only composable with other primitive distributions
-      /// </summary>
-      public static GammaPrimitive GammaPrimitive(double shape, double rate)
-      {
-         return new GammaPrimitive(shape, rate, Gen);
-      }
-
-      public static MultiVariateNormalPrimitive MultiVariateNormalPrimitive(double[] mean, Matrix<double> covariance)
-      {
-         return new MultiVariateNormalPrimitive(mean, covariance, Gen);
-      }
-
-      public static WishartPrimitive WishartPrimitive(double dof, Matrix<double> scale)
-      {
-        return new WishartPrimitive(dof, scale, Gen);
-      }
-
-      /// <summary>
-      /// Primitive Dirichlet distribution
-      /// Only composable with other primitive distributions
-      /// </summary>
-      public static DirichletPrimitive DirichletPrimitive(double[] alpha)
-      {
-         return new DirichletPrimitive(alpha, Gen);
-      }
-
-      /// <summary>
-      /// Poisson distribution
-      /// </summary>
-      public static Dist<int> Poisson(double lambda)
-      {
-         return Primitive(PoissonPrimitive(lambda));
-      }
-
-      /// <summary>
-      /// Normal distribution
-      /// </summary>
-      public static Dist<double> Normal(double mean, double variance)
-      {
-         return Primitive(NormalPrimitive(mean, variance));
-      }
-
-      /// <summary>
-      /// Log Normal distribution
-      /// </summary>
-      public static Dist<double> LogNormal(double mean, double variance)
-      {
-         return Primitive(LogNormalPrimitive(mean, variance));
-      }
-
-      public static Dist<double> LogNormalMu(double mu, double sigma)
-      {
-         return Primitive(LogNormalPrimitiveMu(mu, sigma));
-      }
-
-      /// <summary>
-      /// Gamma distribution
-      /// </summary>
-      public static Dist<double> Gamma(double shape, double rate)
-      {
-         return Primitive(GammaPrimitive(shape, rate));
-      }
-
-      /// <summary>
-      /// Categorical distribution
-      /// </summary>
-      public static Dist<T> Categorical<T>(T[] items, double[] probabilities)
-      {
-         return Primitive(CategoricalPrimitive<T>(items, probabilities));
-      }
-
-      public static Dist<double> Uniform()
-      {
-         return Primitive(ContinuousUniformPrimitive());
-      }
-
-      public static Dist<double> Uniform(double lower, double upper)
-      {
-         return Primitive(ContinuousUniformPrimitive(lower,upper));
-      }
-
-      /// <summary>
-      /// StudenT distribution
-      /// </summary>
-      public static Dist<double> StudentT(double location, double scale, double normality)
-      {
-          return Primitive(StudentTPrimitive(location, scale, normality));
-      }
-
-      /// <summary>
-      /// Exponential distribution
-      /// </summary>
-      public static Dist<double> Exponential(double rate)
-      {
-          return Primitive(ExponentialPrimitive(rate));
-      }
-
-      /// <summary>
-      /// Beta distribution
-      /// </summary>
-      public static Dist<double> Beta(double alpha, double beta)
-      {
-         return Primitive(BetaPrimitive(alpha, beta));
-      }
-
-      /// <summary>
-      /// Dirichlet distribution
-      /// </summary>
-      public static Dist<double[]> Dirichlet(double[] alpha)
-      {
-         return Primitive(DirichletPrimitive(alpha));
-      }
-
-      public static Dist<double[]> MultiVariateNormal(double[] mean, Matrix<double> covariance)
-      {
-         return Primitive(MultiVariateNormalPrimitive(mean, covariance));
-      }
-
-      public static Dist<Matrix<double>> Wishart(double dof, Matrix<double> scale)
-      {
-        return Primitive(WishartPrimitive(dof, scale));
-      }
-      #endregion
-
-      #region GADT constructors
-
-      #region Parallel constructors
-      /// <summary>
-      /// Wraps the distribution to defer evaluation until explicitly parallelized
-      /// </summary>
-      public static Dist<Dist<A>> Independent<A>(Dist<A> dist)
-      {
-         return new Independent<A>(dist);
-      }
-
-      /// <summary>
-      /// Evaluates two distributions in parallel, passing the results to a function
-      /// </summary>
-      public static Dist<A> RunIndependentWith<T1, T2, A>(Dist<T1> dist1, Dist<T2> dist2, Func<T1, T2, Dist<A>> run)
-      {
-         return new RunIndependent<T1, T2, A>(dist1, dist2, run);
-      }
-
-      /// <summary>
-      /// Evaluates two distributions in parallel. The results are collected into a tuple.
-      /// </summary>
-      public static Dist<Tuple<T1, T2>> RunIndependent<T1, T2>(Dist<T1> dist1, Dist<T2> dist2)
-      {
-         return new RunIndependent<T1, T2, Tuple<T1, T2>>(dist1, dist2, (t1, t2) => Return(new Tuple<T1, T2>(t1, t2)));
-      }
-
-      /// <summary>
-      /// Evaluates three distributions in parallel. The results are collected into a tuple.
-      /// </summary>
-      public static Dist<Tuple<T1, T2, T3>> RunIndependent<T1, T2, T3>(Dist<T1> dist1, Dist<T2> dist2, Dist<T3> dist3)
-      {
-         return new RunIndependent3<T1, T2, T3, Tuple<T1, T2, T3>>(dist1, dist2, dist3, (t1, t2, t3) => Return(new Tuple<T1, T2, T3>(t1, t2, t3)));
-      }
-
-      /// <summary>
-      /// Evaluates three distributions in parallel, passing the results to a function
-      /// </summary>
-      public static Dist<A> RunIndependentWith<T1, T2, T3, A>(Dist<T1> dist1, Dist<T2> dist2, Dist<T3> dist3, Func<T1, T2, T3, Dist<A>> run)
-      {
-         return new RunIndependent3<T1, T2, T3, A>(dist1, dist2, dist3, run);
-      }
-      #endregion
-
-      /// <summary>
-      /// Primitive constructor for continuous dists
-      /// </summary>
-      public static Dist<A> Primitive<A>(PrimitiveDist<A> dist)
-      {
-         return new Primitive<A>(dist);
-      }
-
-      /// <summary>
-      /// Primitive constructor for finite dists
-      /// </summary>
-      public static Dist<A> Primitive<A>(FiniteDist<A> dist)
-      {
-         return new Primitive<A>(dist.ToSampleDist());
-      }
-
-      /// <summary>
-      /// Pure constructor, monadic return
-      /// </summary>
-      public static Dist<A> Return<A>(A value)
-      {
-         return new Pure<A>(value);
-      }
-
-      /// <summary>
-      /// Create a conditional distribution with given likelihood function and distribution
-      /// </summary>
-      public static Dist<A> Condition<A>(Func<A, Prob> likelihood, Dist<A> dist)
-      {
-         return new Conditional<A>(likelihood, dist);
-      }
-
-      /// <summary>
-      /// Conditional constructor
-      /// </summary>
-      public static Dist<A> Condition<A>(this Dist<A> dist, Func<A, Prob> likelihood)
-      {
-         return new Conditional<A>(likelihood, dist);
-      }
-
-      #endregion
-
-      #region Utility functions
-      /// <summary>
-      /// Aggregates probabilities of samples with identical values
-      /// The samples are arranged in ascending order
-      /// </summary>
-      /// <param name="keyFunc">Used to identify identical values</param>
-      public static Samples<A> Compact<A, Key>(Samples<A> samples, Func<A, Key> keyFunc) where A : IComparable<A>
-      {
-         return Samples(CompactUnordered(samples, keyFunc).Weights.OrderBy(w => w.Item));
-      }
-
-      /// <summary>
-      /// Aggregates probabilities of samples with identical values
-      /// </summary>
-      /// <param name="keyFunc">Used to identify identical values</param>
-      public static Samples<A> CompactUnordered<A, Key>(Samples<A> samples, Func<A, Key> keyFunc)
-      {
-         var compacted =
-             samples.Weights
-                 .GroupBy(ip => keyFunc(ip.Item))
-                 .Select(g =>
-                     ItemProb(
-                         g.First().Item,
-                         Prob(g.Select(ip => ip.Prob.Value).Sum())
-                     )
-                 );
-         return Samples(compacted);
-      }
-
-      /// <summary>
-      /// Aggregate & normalize samples
-      /// The samples are arranged in ascending order
-      /// </summary>
-      public static Samples<A> Enumerate<A, Key>(FiniteDist<A> dist, Func<A, Key> keyFunc) where A : IComparable<A>
-      {
-         return Importance.Normalize(Compact(dist.Explicit, keyFunc));
-      }
-
-      /// <summary>
-      /// The probability density function for a primitive distribution and point.
-      /// Throws NotImplementedException if no PDF is defined for given distribution.
-      /// </summary>
-      public static Prob Pdf(PrimitiveDist<double[]> dist, double[] x)
-      {
-
-         if (dist is DirichletPrimitive)
-         {
-            var dir = dist as DirichletPrimitive;
-            var d = new MathNet.Numerics.Distributions.Dirichlet(dir.alpha);
-
-            return Prob(d.Density(x));
-         }
-
-         if (dist is MultiVariateNormalPrimitive)
-         {
-            var d = dist as MultiVariateNormalPrimitive;
-
-            return Prob(d.mvn.Density(DenseMatrix.OfRowArrays(x)));
-         }
-         throw new NotImplementedException("No PDF for this distribution implemented");
-      }
-      /// <summary>
-      /// The probability density function for a primitive distribution and point.
-      /// Throws NotImplementedException if no PDF is defined for given distribution.
-      /// </summary>
-      public static Prob Pdf(PrimitiveDist<Matrix<double>> dist, Matrix<double> x)
-      {
-
-        if (dist is WishartPrimitive)
-        {
-          var wish = dist as WishartPrimitive;           
-          return Prob(wish.Wishart.Density(x));
-        }
-         
-        throw new NotImplementedException("No PDF for this distribution implemented");
-      }
-      /// <summary>
-      /// The probability density function for a primitive distribution and point.
-      /// Throws NotImplementedException if no PDF is defined for given distribution.
-      /// </summary>
-      public static Prob Pdf(PrimitiveDist<double> dist, double y)
-      {
-         if (dist is NormalPrimitive)
-         {
-            var normal = dist as NormalPrimitive;
-            return Prob(MathNet.Numerics.Distributions.Normal.PDF(normal.Mean, Math.Sqrt(normal.Variance), y));
-         }
-         if (dist is LogNormalPrimitive)
-         {
-            var lognormal = dist as LogNormalPrimitive;
-            return Prob(MathNet.Numerics.Distributions.LogNormal.PDF(lognormal.mu, lognormal.sigma, y));
-         }
-         if (dist is BetaPrimitive)
-         {
-            var beta = dist as BetaPrimitive;
-            return Prob(MathNet.Numerics.Distributions.Beta.PDF(beta.alpha, beta.beta, y));
-         }
-         if (dist is GammaPrimitive)
-         {
-            var gamma = dist as GammaPrimitive;
-            return Prob(MathNet.Numerics.Distributions.Gamma.PDF(gamma.shape, gamma.rate, y));
-         }
-         throw new NotImplementedException("No PDF for this distribution implemented");
-      }
-
-      /// <summary>
-      /// The probability mass function for a primitive distribution and point.
-      /// Throws NotImplementedException if no PMF is defined for given distribution.
-      /// </summary>
-      public static Prob Pmf(PrimitiveDist<int> dist, int y)
-      {
-         if (dist is PoissonPrimitive)
-         {
-            var poisson = dist as PoissonPrimitive;
-            return Prob(MathNet.Numerics.Distributions.Poisson.PMF(poisson.Lambda, y));
-         }
-         throw new NotImplementedException("No PMF for this distribution implemented");
-      }
-
-      public static Prob Pmf<T>(PrimitiveDist<T> dist, T k)
-      {
-         if (dist is CategoricalPrimitive<T>)
-         {
-            var cat = dist as CategoricalPrimitive<T>;
-            
-            return Prob(MathNet.Numerics.Distributions.Categorical.PMF(cat.ProbabilityMass, cat.ItemIndex[k]));
-         }
-         throw new NotImplementedException("No PMF for this distribution implemented");
-      }
-
-      /// <summary>
-      /// The probability density function for a distribution and point.
-      /// Throws ArgumentException if the distribution is not a Primitive.
-      /// </summary>
-      public static Prob Pdf(Dist<double> dist, double y)
-      {
-         if (dist is Primitive<double>)
-         {
-            var primitive = dist as Primitive<double>;
-            return Pdf(primitive.dist, y);
-         }
-         throw new ArgumentException("Can only calculate PDF for primitive distributions");
-      }
-
-      public static Prob Pdf(Dist<double[]> dist, double[] y)
-      {
-         if (dist is Primitive<double[]>)
-         {
-            var primitive = dist as Primitive<double[]>;
-            return Pdf(primitive.dist, y);
-         }
-         throw new ArgumentException("Can only calculate PDF for primitive distributions");
-      }
-      public static Prob Pdf(Dist<Matrix<double>> dist, Matrix<double> y)
-      {
-        if (dist is Primitive<Matrix<double>>)
-        {
-          var primitive = dist as Primitive<Matrix<double>>;
-          return Pdf(primitive.dist, y);
-        }
-        throw new ArgumentException("Can only calculate PDF for primitive distributions");
-      }
-
-      public static Prob Pmf<T>(Dist<T> dist, T k)
-      {
-         if (dist is Primitive<T>)
-         {
-            var primitive = dist as Primitive<T>;
-            return Pmf(primitive.dist, k);
-         }
-         throw new ArgumentException("Can only calculate PDF for primitive distributions");
-      }
-
-      public static Prob Pmf(Dist<int> dist, int y)
-      {
-         if (dist is Primitive<int>)
-         {
-            var primitive = dist as Primitive<int>;
-            return Pmf(primitive.dist, y);
-         }
-         throw new ArgumentException("Can only calculate pmf for primitive distributions");
-      }
-
-
-      /// <summary>
-      /// Appends a value to a list. Non-mutative.
-      /// </summary>
-      public static IEnumerable<A> Append<A>(IEnumerable<A> list, A value)
-      {
-         var appendList = new List<A>(list);
-         appendList.Add(value);
-         return appendList;
-      }
-
-      /// <summary>
-      /// Sigmoid function
-      /// </summary>
-      public static double Sigmoid(double x)
-      {
-         return 1 / (1 + Math.Exp(-x));
-      }
-      #endregion
-   }
-}
+using System.Collections.Generic;
+using System.Linq;
+using System;
+using MathNet.Numerics.LinearAlgebra;
+using MathNet.Numerics.LinearAlgebra.Double;
+
+namespace ProbCSharp
+{
+   /// <summary>
+   /// This class exports a whole bunch of constructors.
+   /// Basically avoids us typing new X<A, B, C>()
+   /// which can make code unreadable when we have really large types.
+   /// </summary>
+   public static class ProbBase
+   {
+      // Singleton instance of the random generator to avoid repeated values in tight loops
+      public static Random Gen = new Random();
+
+      #region Primitive object constructors
+      /// <summary>
+      /// Probability constructor
+      /// </summary>
+      public static Prob Prob(double probability)
+      {
+         return new LogProb(Math.Log(probability));
+      }
+
+      /// <summary>
+      /// ItemProb constructor 
+      /// </summary>
+      public static ItemProb<A> ItemProb<A>(A item, Prob prob)
+      {
+         return new ItemProb<A>(item, prob);
+      }
+
+      /// <summary>
+      /// Samples constructor
+      /// </summary>
+      public static Samples<A> Samples<A>(IEnumerable<ItemProb<A>> itemProbs)
+      {
+         return new Samples<A>(itemProbs);
+      }
+
+      /// <summary>
+      /// Tuple constructor
+      /// </summary>
+      public static Tuple<A, B> Tuple<A, B>(A a, B b)
+      {
+         return new Tuple<A, B>(a, b);
+      }
+      #endregion
+
+      #region Distribution constructors
+      /// <summary>
+      /// Finite uniform distribution over list of items. 
+      /// Only composable with other finite distributions.
+      /// </summary>
+      public static FiniteDist<A> EnumUniformF<A>(IEnumerable<A> items)
+      {
+         var uniform = Samples(items.Select(i => new ItemProb<A>(i, Prob(1))));
+         return new FiniteDist<A>(Importance.Normalize(uniform));
+      }
+
+      /// <summary>
+      /// Uniform distribution over list of items
+      /// </summary>
+      public static Dist<A> UniformFromList<A>(IEnumerable<A> items)
+      {
+         return Primitive(EnumUniformF(items));
+      }
+
+      /// <summary>
+      /// Uniform distribution over parameter items
+      /// Only composable with other finite distributions.
+      /// </summary>
+      public static FiniteDist<A> UniformF<A>(params A[] items)
+      {
+         var itemList = new List<A>(items);
+         return EnumUniformF(itemList);
+      }
+
+      /// <summary>
+      /// Uniform distribution over parameter items
+      /// </summary>
+      public static Dist<A> Uniform<A>(params A[] items)
+      {
+         return Primitive(UniformF(items));
+      }
+
+      /// <summary>
+      /// Bernoulli distribution constructed from success probability
+      /// Only composable with other finite distributions.
+      /// </summary>
+      public static FiniteDist<bool> BernoulliF(Prob prob)
+      {
+         return new FiniteDist<bool>(ItemProb(true, prob), ItemProb(false, Prob(1 - prob.Value)));
+      }
+
+      /// <summary>
+      /// Bernoulli distribution constructed from success probability
+      /// </summary>
+      public static Dist<bool> Bernoulli(Prob prob)
+      {
+         return Primitive(BernoulliF(prob));
+      }
+
+      /// <summary>
+      /// Bernoulli distribution constructed from success probability
+      /// </summary>
+      public static Dist<bool> Bernoulli(double prob)
+      {
+         return Primitive(BernoulliF(Prob(prob)));
+      }
+
+      /// <summary>
+      /// Bernoulli distribution constructed from two items, and probability of first item
+      /// </summary>
+      public static Dist<A> Bernoulli<A>(double prob, A option1, A option2)
+      {
+         return Primitive(BernoulliF(Prob(prob))).Select(b => b ? option1 : option2);
+      }
+
+      /// <summary>
+      /// Categorical distribution
+      /// Only composable with other finite distributions
+      /// </summary>
+      public static FiniteDist<A> CategoricalF<A>(params ItemProb<A>[] itemProbs)
+      {
+        return new FiniteDist<A>(Samples(itemProbs));
+      }
+
+      /// <summary>
+      /// Categorical distribution
+      /// Only composable with other finite distributions
+      /// </summary>
+      public static FiniteDist<A> CategoricalF<A>(Samples<A> samples)
+      {
+         return new FiniteDist<A>(samples);
+      }
+
+      /// <summary>
+      /// Categorical distribution
+      /// </summary> 
+      public static Dist<A> Categorical<A>(Samples<A> samples)
+      {
+         return Primitive(CategoricalF(samples).ToSampleDist());
+      }
+
+      /// <summary>
+      /// Categorical distribution
+      /// </summary> 
+      public static CategoricalPrimitive<A> CategoricalPrimitive<A>(A[] items, double [] probabilities)
+      {
+         return new CategoricalPrimitive<A>(items, probabilities, Gen);
+      }
+
+      /// <summary>
+      /// Primitive studentT distribution
+      /// Only composable with other primitive distributions
+      /// </summary>
+      public static StudentTPrimitive StudentTPrimitive(double location, double scale, double normality)
+      {
+          return new StudentTPrimitive(location, scale, normality, Gen);
+      }
+
+      /// <summary>
+      /// Primitive Exponential distribution
+      /// Only composable with other primitive distributions
+      /// </summary>
+      public static ExponentialPrimitive ExponentialPrimitive(double rate)
+      {
+          return new ExponentialPrimitive(rate);
+      }
+
+      /// <summary>
+      /// Primitive Contiuous Uniform distribution
+      /// Only composable with other primitive distributions
+      /// </summary>
+      public static ContinuousUniformPrimitive ContinuousUniformPrimitive()
+      {
+         return new ContinuousUniformPrimitive(Gen);
+      }
+
+      /// <summary>
+      /// Primitive Contiuous Uniform distribution
+      /// Only composable with other primitive distributions
+      /// </summary>
+      public static ContinuousUniformPrimitive ContinuousUniformPrimitive(double lower, double upper)
+      {
+         return new ContinuousUniformPrimitive(lower,upper, Gen);
+      }
+
+
+      /// <summary>
+      /// Primitive Poisson distribution
+      /// Only composable with other primitive distributions
+      /// </summary>
+      public static PoissonPrimitive PoissonPrimitive(double lambda)
+      {
+         return new PoissonPrimitive(lambda, Gen);
+      }
+
+      /// <summary>
+      /// Primitive Normal distribution
+      /// Only composable with other primitive distributions
+      /// </summary>
+      public static NormalPrimitive NormalPrimitive(double mean, double variance)
+      {
+         return new NormalPrimitive(mean, variance, Gen);
+      }
+
+      /// <summary>
+      /// Primitive LogNormal distribution
+      /// Only composable with other primitive distributions
+      /// </summary>
+      public static LogNormalPrimitive LogNormalPrimitive(double mean, double variance)
+      {
+         return new LogNormalPrimitive(mean, variance, Gen);
+      }
+
+      public static LogNormalPrimitive LogNormalPrimitiveMu(double mu, double sigma)
+      {
+         return new LogNormalPrimitive(mu, sigma, true, Gen);
+      }
+
+      /// <summary>
+      /// Primitive Beta distribution
+      /// Only composable with other primitive distributions
+      /// </summary>
+      public static BetaPrimitive BetaPrimitive(double alpha, double beta)
+      {
+         return new BetaPrimitive(alpha, beta, Gen);
+      }
+
+      /// <summary>
+      /// Primitive Gamma distribution
+      /// Only composable with other primitive distributions
+      /// </summary>
+      public static GammaPrimitive GammaPrimitive(double shape, double rate)
+      {
+         return new GammaPrimitive(shape, rate, Gen);
+      }
+
+      public static MultiVariateNormalPrimitive MultiVariateNormalPrimitive(double[] mean, Matrix<double> covariance)
+      {
+         return new MultiVariateNormalPrimitive(mean, covariance, Gen);
+      }
+
+      public static WishartPrimitive WishartPrimitive(double dof, Matrix<double> scale)
+      {
+        return new WishartPrimitive(dof, scale, Gen);
+      }
+
+      /// <summary>
+      /// Primitive Dirichlet distribution
+      /// Only composable with other primitive distributions
+      /// </summary>
+      public static DirichletPrimitive DirichletPrimitive(double[] alpha)
+      {
+         return new DirichletPrimitive(alpha, Gen);
+      }
+
+      /// <summary>
+      /// Poisson distribution
+      /// </summary>
+      public static Dist<int> Poisson(double lambda)
+      {
+         return Primitive(PoissonPrimitive(lambda));
+      }
+
+      /// <summary>
+      /// Normal distribution
+      /// </summary>
+      public static Dist<double> Normal(double mean, double variance)
+      {
+         return Primitive(NormalPrimitive(mean, variance));
+      }
+
+      /// <summary>
+      /// Log Normal distribution
+      /// </summary>
+      public static Dist<double> LogNormal(double mean, double variance)
+      {
+         return Primitive(LogNormalPrimitive(mean, variance));
+      }
+
+      public static Dist<double> LogNormalMu(double mu, double sigma)
+      {
+         return Primitive(LogNormalPrimitiveMu(mu, sigma));
+      }
+
+      /// <summary>
+      /// Gamma distribution
+      /// </summary>
+      public static Dist<double> Gamma(double shape, double rate)
+      {
+         return Primitive(GammaPrimitive(shape, rate));
+      }
+
+      /// <summary>
+      /// Categorical distribution
+      /// </summary>
+      public static Dist<T> Categorical<T>(T[] items, double[] probabilities)
+      {
+         return Primitive(CategoricalPrimitive<T>(items, probabilities));
+      }
+
+      public static Dist<double> Uniform()
+      {
+         return Primitive(ContinuousUniformPrimitive());
+      }
+
+      public static Dist<double> Uniform(double lower, double upper)
+      {
+         return Primitive(ContinuousUniformPrimitive(lower,upper));
+      }
+
+      /// <summary>
+      /// StudenT distribution
+      /// </summary>
+      public static Dist<double> StudentT(double location, double scale, double normality)
+      {
+          return Primitive(StudentTPrimitive(location, scale, normality));
+      }
+
+      /// <summary>
+      /// Exponential distribution
+      /// </summary>
+      public static Dist<double> Exponential(double rate)
+      {
+          return Primitive(ExponentialPrimitive(rate));
+      }
+
+      /// <summary>
+      /// Beta distribution
+      /// </summary>
+      public static Dist<double> Beta(double alpha, double beta)
+      {
+         return Primitive(BetaPrimitive(alpha, beta));
+      }
+
+      /// <summary>
+      /// Dirichlet distribution
+      /// </summary>
+      public static Dist<double[]> Dirichlet(double[] alpha)
+      {
+         return Primitive(DirichletPrimitive(alpha));
+      }
+
+      public static Dist<double[]> MultiVariateNormal(double[] mean, Matrix<double> covariance)
+      {
+         return Primitive(MultiVariateNormalPrimitive(mean, covariance));
+      }
+
+      public static Dist<Matrix<double>> Wishart(double dof, Matrix<double> scale)
+      {
+        return Primitive(WishartPrimitive(dof, scale));
+      }
+      #endregion
+
+      #region GADT constructors
+
+      #region Parallel constructors
+      /// <summary>
+      /// Wraps the distribution to defer evaluation until explicitly parallelized
+      /// </summary>
+      public static Dist<Dist<A>> Independent<A>(Dist<A> dist)
+      {
+         return new Independent<A>(dist);
+      }
+
+      /// <summary>
+      /// Evaluates two distributions in parallel, passing the results to a function
+      /// </summary>
+      public static Dist<A> RunIndependentWith<T1, T2, A>(Dist<T1> dist1, Dist<T2> dist2, Func<T1, T2, Dist<A>> run)
+      {
+         return new RunIndependent<T1, T2, A>(dist1, dist2, run);
+      }
+
+      /// <summary>
+      /// Evaluates two distributions in parallel. The results are collected into a tuple.
+      /// </summary>
+      public static Dist<Tuple<T1, T2>> RunIndependent<T1, T2>(Dist<T1> dist1, Dist<T2> dist2)
+      {
+         return new RunIndependent<T1, T2, Tuple<T1, T2>>(dist1, dist2, (t1, t2) => Return(new Tuple<T1, T2>(t1, t2)));
+      }
+
+      /// <summary>
+      /// Evaluates three distributions in parallel. The results are collected into a tuple.
+      /// </summary>
+      public static Dist<Tuple<T1, T2, T3>> RunIndependent<T1, T2, T3>(Dist<T1> dist1, Dist<T2> dist2, Dist<T3> dist3)
+      {
+         return new RunIndependent3<T1, T2, T3, Tuple<T1, T2, T3>>(dist1, dist2, dist3, (t1, t2, t3) => Return(new Tuple<T1, T2, T3>(t1, t2, t3)));
+      }
+
+      /// <summary>
+      /// Evaluates three distributions in parallel, passing the results to a function
+      /// </summary>
+      public static Dist<A> RunIndependentWith<T1, T2, T3, A>(Dist<T1> dist1, Dist<T2> dist2, Dist<T3> dist3, Func<T1, T2, T3, Dist<A>> run)
+      {
+         return new RunIndependent3<T1, T2, T3, A>(dist1, dist2, dist3, run);
+      }
+      #endregion
+
+      /// <summary>
+      /// Primitive constructor for continuous dists
+      /// </summary>
+      public static Dist<A> Primitive<A>(PrimitiveDist<A> dist)
+      {
+         return new Primitive<A>(dist);
+      }
+
+      /// <summary>
+      /// Primitive constructor for finite dists
+      /// </summary>
+      public static Dist<A> Primitive<A>(FiniteDist<A> dist)
+      {
+         return new Primitive<A>(dist.ToSampleDist());
+      }
+
+      /// <summary>
+      /// Pure constructor, monadic return
+      /// </summary>
+      public static Dist<A> Return<A>(A value)
+      {
+         return new Pure<A>(value);
+      }
+
+      /// <summary>
+      /// Create a conditional distribution with given likelihood function and distribution
+      /// </summary>
+      public static Dist<A> Condition<A>(Func<A, Prob> likelihood, Dist<A> dist)
+      {
+         return new Conditional<A>(likelihood, dist);
+      }
+
+      /// <summary>
+      /// Conditional constructor
+      /// </summary>
+      public static Dist<A> Condition<A>(this Dist<A> dist, Func<A, Prob> likelihood)
+      {
+         return new Conditional<A>(likelihood, dist);
+      }
+
+      #endregion
+
+      #region Utility functions
+      /// <summary>
+      /// Aggregates probabilities of samples with identical values
+      /// The samples are arranged in ascending order
+      /// </summary>
+      /// <param name="keyFunc">Used to identify identical values</param>
+      public static Samples<A> Compact<A, Key>(Samples<A> samples, Func<A, Key> keyFunc) where A : IComparable<A>
+      {
+         return Samples(CompactUnordered(samples, keyFunc).Weights.OrderBy(w => w.Item));
+      }
+
+      /// <summary>
+      /// Aggregates probabilities of samples with identical values
+      /// </summary>
+      /// <param name="keyFunc">Used to identify identical values</param>
+      public static Samples<A> CompactUnordered<A, Key>(Samples<A> samples, Func<A, Key> keyFunc)
+      {
+         var compacted =
+             samples.Weights
+                 .GroupBy(ip => keyFunc(ip.Item))
+                 .Select(g =>
+                     ItemProb(
+                         g.First().Item,
+                         Prob(g.Sum(ip => ip.Prob.Value))
+                     )
+                 );
+         return Samples(compacted);
+      }
+
+      /// <summary>
+      /// Aggregate & normalize samples
+      /// The samples are arranged in ascending order
+      /// </summary>
+      public static Samples<A> Enumerate<A, Key>(FiniteDist<A> dist, Func<A, Key> keyFunc) where A : IComparable<A>
+      {
+         return Importance.Normalize(Compact(dist.Explicit, keyFunc));
+      }
+
+      /// <summary>
+      /// The probability density function for a primitive distribution and point.
+      /// Throws NotImplementedException if no PDF is defined for given distribution.
+      /// </summary>
+      public static Prob Pdf(PrimitiveDist<double[]> dist, double[] x)
+      {
+
+         if (dist is DirichletPrimitive)
+         {
+            var dir = dist as DirichletPrimitive;
+            var d = new MathNet.Numerics.Distributions.Dirichlet(dir.alpha);
+
+            return Prob(d.Density(x));
+         }
+
+         if (dist is MultiVariateNormalPrimitive)
+         {
+            var d = dist as MultiVariateNormalPrimitive;
+
+            return Prob(d.mvn.Density(DenseMatrix.OfRowArrays(x)));
+         }
+         throw new NotImplementedException("No PDF for this distribution implemented");
+      }
+      /// <summary>
+      /// The probability density function for a primitive distribution and point.
+      /// Throws NotImplementedException if no PDF is defined for given distribution.
+      /// </summary>
+      public static Prob Pdf(PrimitiveDist<Matrix<double>> dist, Matrix<double> x)
+      {
+
+        if (dist is WishartPrimitive)
+        {
+          var wish = dist as WishartPrimitive;           
+          return Prob(wish.Wishart.Density(x));
+        }
+         
+        throw new NotImplementedException("No PDF for this distribution implemented");
+      }
+      /// <summary>
+      /// The probability density function for a primitive distribution and point.
+      /// Throws NotImplementedException if no PDF is defined for given distribution.
+      /// </summary>
+      public static Prob Pdf(PrimitiveDist<double> dist, double y)
+      {
+         if (dist is NormalPrimitive)
+         {
+            var normal = dist as NormalPrimitive;
+            return Prob(MathNet.Numerics.Distributions.Normal.PDF(normal.Mean, Math.Sqrt(normal.Variance), y));
+         }
+         if (dist is LogNormalPrimitive)
+         {
+            var lognormal = dist as LogNormalPrimitive;
+            return Prob(MathNet.Numerics.Distributions.LogNormal.PDF(lognormal.mu, lognormal.sigma, y));
+         }
+         if (dist is BetaPrimitive)
+         {
+            var beta = dist as BetaPrimitive;
+            return Prob(MathNet.Numerics.Distributions.Beta.PDF(beta.alpha, beta.beta, y));
+         }
+         if (dist is GammaPrimitive)
+         {
+            var gamma = dist as GammaPrimitive;
+            return Prob(MathNet.Numerics.Distributions.Gamma.PDF(gamma.shape, gamma.rate, y));
+         }
+         throw new NotImplementedException("No PDF for this distribution implemented");
+      }
+
+      /// <summary>
+      /// The probability mass function for a primitive distribution and point.
+      /// Throws NotImplementedException if no PMF is defined for given distribution.
+      /// </summary>
+      public static Prob Pmf(PrimitiveDist<int> dist, int y)
+      {
+         if (dist is PoissonPrimitive)
+         {
+            var poisson = dist as PoissonPrimitive;
+            return Prob(MathNet.Numerics.Distributions.Poisson.PMF(poisson.Lambda, y));
+         }
+         throw new NotImplementedException("No PMF for this distribution implemented");
+      }
+
+      public static Prob Pmf<T>(PrimitiveDist<T> dist, T k)
+      {
+         if (dist is CategoricalPrimitive<T>)
+         {
+            var cat = dist as CategoricalPrimitive<T>;
+            
+            return Prob(MathNet.Numerics.Distributions.Categorical.PMF(cat.ProbabilityMass, cat.ItemIndex[k]));
+         }
+         throw new NotImplementedException("No PMF for this distribution implemented");
+      }
+
+      /// <summary>
+      /// The probability density function for a distribution and point.
+      /// Throws ArgumentException if the distribution is not a Primitive.
+      /// </summary>
+      public static Prob Pdf(Dist<double> dist, double y)
+      {
+         if (dist is Primitive<double>)
+         {
+            var primitive = dist as Primitive<double>;
+            return Pdf(primitive.dist, y);
+         }
+         throw new ArgumentException("Can only calculate PDF for primitive distributions");
+      }
+
+      public static Prob Pdf(Dist<double[]> dist, double[] y)
+      {
+         if (dist is Primitive<double[]>)
+         {
+            var primitive = dist as Primitive<double[]>;
+            return Pdf(primitive.dist, y);
+         }
+         throw new ArgumentException("Can only calculate PDF for primitive distributions");
+      }
+      public static Prob Pdf(Dist<Matrix<double>> dist, Matrix<double> y)
+      {
+        if (dist is Primitive<Matrix<double>>)
+        {
+          var primitive = dist as Primitive<Matrix<double>>;
+          return Pdf(primitive.dist, y);
+        }
+        throw new ArgumentException("Can only calculate PDF for primitive distributions");
+      }
+
+      public static Prob Pmf<T>(Dist<T> dist, T k)
+      {
+         if (dist is Primitive<T>)
+         {
+            var primitive = dist as Primitive<T>;
+            return Pmf(primitive.dist, k);
+         }
+         throw new ArgumentException("Can only calculate PDF for primitive distributions");
+      }
+
+      public static Prob Pmf(Dist<int> dist, int y)
+      {
+         if (dist is Primitive<int>)
+         {
+            var primitive = dist as Primitive<int>;
+            return Pmf(primitive.dist, y);
+         }
+         throw new ArgumentException("Can only calculate pmf for primitive distributions");
+      }
+
+      /// <summary>
+      /// Sigmoid function
+      /// </summary>
+      public static double Sigmoid(double x)
+      {
+         return 1 / (1 + Math.Exp(-x));
+      }
+      #endregion
+   }
+}
diff --git a/ProbabilityMonad/DistGadt.cs b/ProbabilityMonad/DistGadt.cs
index 7d995b3..3bd3dbe 100644
--- a/ProbabilityMonad/DistGadt.cs
+++ b/ProbabilityMonad/DistGadt.cs
@@ -293,7 +293,7 @@ private static Dist<IEnumerable<A>> RunSequence<A>(IEnumerable<Dist<A>> dists)
                 Return<IEnumerable<A>>(new List<A>()),
                 (listDist, aDist) => from a in aDist
                                      from list in listDist
-                                     select Append(list, a)
+                                     select list.Append(a)
             );
         }
 
diff --git a/ProbabilityMonad/Finite/FiniteExtensions.cs b/ProbabilityMonad/Finite/FiniteExtensions.cs
index 30558c0..0f3a676 100644
--- a/ProbabilityMonad/Finite/FiniteExtensions.cs
+++ b/ProbabilityMonad/Finite/FiniteExtensions.cs
@@ -44,7 +44,7 @@ public static Prob ProbOf<A>(this FiniteDist<A> dist, Func<A, bool> eventTest)
         {
             var matches = dist.Explicit.Weights.Where(p => eventTest(p.Item));
             if (!matches.Any()) return Prob(0);
-            return Prob(matches.Select(p => p.Prob.Value).Sum());
+            return Prob(matches.Sum(p => p.Prob.Value));
         }
 
         /// <summary>
diff --git a/ProbabilityMonad/Histogram.cs b/ProbabilityMonad/Histogram.cs
index 94e13c6..586e9bb 100644
--- a/ProbabilityMonad/Histogram.cs
+++ b/ProbabilityMonad/Histogram.cs
@@ -87,7 +87,7 @@ internal static string ShowBuckets(IEnumerable<Bucket> buckets, double scale)
         /// </summary>
         internal static int LongestString<A>(IEnumerable<A> list, Func<A, string> toString)
         {
-            return list.Select(x => toString(x).Length).Max();
+            return list.Max(x => toString(x).Length);
         }
 
         /// <summary>
@@ -103,22 +103,7 @@ internal static double BarScale(IEnumerable<int> barLengths, double scale)
         /// Draw bar of width n
         /// </summary>
         internal static string Bar(int n)
-        {
-            var barBuilder = new StringBuilder();
-            for (var i = 0; i < n; i++)
-            {
-                barBuilder.Append("#");
-            }
-            return barBuilder.ToString();
-        }
-
-        /// <summary>
-        /// Return sum of list with a given value function
-        /// </summary>
-        internal static double Sum<A>(Func<A, double> getVal, IEnumerable<A> list)
-        {
-            return list.Select(getVal).Sum();
-        }
+            => new string('#', n);
 
         /// <summary>
         /// Generates a weighted histogram from a list of ItemProbs
@@ -128,16 +113,16 @@ public static string Weighted(IEnumerable<ItemProb<double>> nums, int numBuckets
         {
             if (!nums.Any()) return "No data to graph.";
 
-            var sorted = nums.OrderBy(x => x.Item);
+            var sorted = nums.OrderBy(x => x.Item).ToArray();
             var min = sorted.First().Item;
             var max = sorted.Last().Item;
             var bucketList = MakeBucketList(min, max, numBuckets);
 
-            var totalMass = Sum(ip => ip.Prob.Value, sorted.Where(ip => !Double.IsInfinity(ip.Prob.LogValue)));
+            var totalMass = sorted.Where(ip => !Double.IsInfinity(ip.Prob.LogValue)).Sum(ip => ip.Prob.Value);
             foreach (var bucket in bucketList)
             {
                 bucket.WeightedValues.AddRange(sorted.Where(x => x.Item >= bucket.Min && x.Item < bucket.Max));
-                bucket.BarSize = (int) Math.Floor(bucket.WeightedValues.Select(x => x.Prob.Value).Sum() / totalMass * scale);
+                bucket.BarSize = (int) Math.Floor(bucket.WeightedValues.Sum(x => x.Prob.Value) / totalMass * scale);
             }
             return ShowBuckets(bucketList, scale);
         }
@@ -158,10 +143,10 @@ public static string Weighted(Samples<double> nums, int numBuckets = 10, double
         public static string Unweighted(IEnumerable<double> nums, int numBuckets = 10, double scale = DEFAULT_SCALE)
         {
             if (!nums.Any()) return "No data to graph.";
-            var sorted = nums.OrderBy(x => x);
+            var sorted = nums.OrderBy(x => x).ToArray();
             var min = sorted.First();
             var max = sorted.Last() + 10e-10;
-            var total = Sum(x => x, sorted);
+            var total = sorted.Sum(x => x);
 
             var bucketList = MakeBucketList(min, max, numBuckets);
 
@@ -193,8 +178,10 @@ public static string Finite<A>(Samples<A> itemProbs, Func<A, string> showFunc =
 
             var normalized = Importance.Normalize(CompactUnordered(itemProbs, showFunc));
             var sb = new StringBuilder();
-            var display = normalized.Weights.Select(ip => new Tuple<string, int, Prob>(showFunc(ip.Item), (int) Math.Floor(ip.Prob.Value * scale), ip.Prob));
-            var maxWidth = display.Select(d => d.Item1.Length).Max();
+            var display = normalized.Weights
+                .Select(ip => new Tuple<string, int, Prob>(showFunc(ip.Item), (int)Math.Floor(ip.Prob.Value * scale), ip.Prob))
+                .ToArray();
+            var maxWidth = display.Max(d => d.Item1.Length);
             var barScale = BarScale(display.Select(d => d.Item2), scale);
             foreach (var line in display)
             {
diff --git a/ProbabilityMonad/KullbackLeibler.cs b/ProbabilityMonad/KullbackLeibler.cs
index e8f5118..35fbf0b 100644
--- a/ProbabilityMonad/KullbackLeibler.cs
+++ b/ProbabilityMonad/KullbackLeibler.cs
@@ -22,9 +22,8 @@ public static double KLDivergenceF<A, Key>(FiniteDist<A> distQ, FiniteDist<A> di
 
             var pWeights = Enumerate(distP, keyFunc);
 
-            var divergences = pWeights.Weights
-                                      .Select(w => w.Prob.Value * Math.Log(w.Prob.Div(qDensity(w.Item)).Value));
-            return divergences.Sum();
+            return pWeights.Weights
+                .Sum(w => w.Prob.Value * Math.Log(w.Prob.Div(qDensity(w.Item)).Value));
         }
 
         /// <summary>
diff --git a/ProbabilityMonad/Sampler.cs b/ProbabilityMonad/Sampler.cs
index 28f2e2c..1b605fa 100644
--- a/ProbabilityMonad/Sampler.cs
+++ b/ProbabilityMonad/Sampler.cs
@@ -21,7 +21,8 @@ public static A Sample<A>(this Dist<A> dist)
         /// </summary>
         public static IEnumerable<A> SampleN<A>(this Dist<A> dist, int n)
         {
-            return Enumerable.Range(0, n).Select(_ => dist.Sample());
+            for (int i = 0; i < n; ++i)
+                yield return dist.Sample();
         }
     }
 
diff --git a/ProbabilityMonad/Samples.cs b/ProbabilityMonad/Samples.cs
index 2e6e009..73e3be8 100644
--- a/ProbabilityMonad/Samples.cs
+++ b/ProbabilityMonad/Samples.cs
@@ -27,7 +27,7 @@ public static Samples<B> MapSample<A, B>(this Samples<A> self, Func<A, B> f)
         /// </summary>
         public static Prob SumProbs<A>(this Samples<A> self)
         {
-            return Prob(self.Weights.Select(ip => ip.Prob.Value).Sum());
+            return Prob(self.Weights.Sum(ip => ip.Prob.Value));
         }
 
         public static Samples<A> Normalize<A>(this Samples<A> self)