diff --git a/ProbabilityMonad/Base.cs b/ProbabilityMonad/Base.cs
index 3b041d4..dd7df1d 100644
--- a/ProbabilityMonad/Base.cs
+++ b/ProbabilityMonad/Base.cs
@@ -14,40 +14,33 @@ namespace ProbCSharp
    public static class ProbBase
    {
       // Singleton instance of the random generator to avoid repeated values in tight loops
-      public static Random Gen = new Random();
+      public static readonly Random Gen = new Random();
 
       #region Primitive object constructors
       /// <summary>
       /// Probability constructor
       /// </summary>
       public static Prob Prob(double probability)
-      {
-         return new LogProb(Math.Log(probability));
-      }
+         => 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);
-      }
+         => new ItemProb<A>(item, prob);
 
       /// <summary>
       /// Samples constructor
       /// </summary>
       public static Samples<A> Samples<A>(IEnumerable<ItemProb<A>> itemProbs)
-      {
-         return new Samples<A>(itemProbs);
-      }
+         => 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);
-      }
+         => new Tuple<A, B>(a, b);
+
       #endregion
 
       #region Distribution constructors
@@ -65,130 +58,99 @@ public static FiniteDist<A> EnumUniformF<A>(IEnumerable<A> items)
       /// Uniform distribution over list of items
       /// </summary>
       public static Dist<A> UniformFromList<A>(IEnumerable<A> items)
-      {
-         return Primitive(EnumUniformF(items));
-      }
+         => 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);
-      }
+         => EnumUniformF(new List<A>(items));
 
       /// <summary>
       /// Uniform distribution over parameter items
       /// </summary>
       public static Dist<A> Uniform<A>(params A[] items)
-      {
-         return Primitive(UniformF(items));
-      }
+         => 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)));
-      }
+         => 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));
-      }
+         => Primitive(BernoulliF(prob));
 
       /// <summary>
       /// Bernoulli distribution constructed from success probability
       /// </summary>
       public static Dist<bool> Bernoulli(double prob)
-      {
-         return Primitive(BernoulliF(Prob(prob)));
-      }
+         => 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);
-      }
+         => 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));
-      }
+         => 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);
-      }
+         => new FiniteDist<A>(samples);
 
       /// <summary>
       /// Categorical distribution
       /// </summary> 
       public static Dist<A> Categorical<A>(Samples<A> samples)
-      {
-         return Primitive(CategoricalF(samples).ToSampleDist());
-      }
+         => 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);
-      }
+         => 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);
-      }
+         => 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);
-      }
+         => new ExponentialPrimitive(rate);
 
       /// <summary>
       /// Primitive Contiuous Uniform distribution
       /// Only composable with other primitive distributions
       /// </summary>
       public static ContinuousUniformPrimitive ContinuousUniformPrimitive()
-      {
-         return new ContinuousUniformPrimitive(Gen);
-      }
+         => 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);
-      }
+         => new ContinuousUniformPrimitive(lower,upper, Gen);
 
 
       /// <summary>
@@ -196,166 +158,121 @@ public static ContinuousUniformPrimitive ContinuousUniformPrimitive(double lower
       /// Only composable with other primitive distributions
       /// </summary>
       public static PoissonPrimitive PoissonPrimitive(double lambda)
-      {
-         return new PoissonPrimitive(lambda, Gen);
-      }
+         => 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);
-      }
+         => 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);
-      }
+         => new LogNormalPrimitive(mean, variance, Gen);
 
       public static LogNormalPrimitive LogNormalPrimitiveMu(double mu, double sigma)
-      {
-         return new LogNormalPrimitive(mu, sigma, true, Gen);
-      }
+         => 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);
-      }
+         => 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);
-      }
+         => new GammaPrimitive(shape, rate, Gen);
 
       public static MultiVariateNormalPrimitive MultiVariateNormalPrimitive(double[] mean, Matrix<double> covariance)
-      {
-         return new MultiVariateNormalPrimitive(mean, covariance, Gen);
-      }
+         => new MultiVariateNormalPrimitive(mean, covariance, Gen);
 
       public static WishartPrimitive WishartPrimitive(double dof, Matrix<double> scale)
-      {
-        return new WishartPrimitive(dof, scale, Gen);
-      }
+         => 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);
-      }
+         => new DirichletPrimitive(alpha, Gen);
 
       /// <summary>
       /// Poisson distribution
       /// </summary>
       public static Dist<int> Poisson(double lambda)
-      {
-         return Primitive(PoissonPrimitive(lambda));
-      }
+         => Primitive(PoissonPrimitive(lambda));
 
       /// <summary>
       /// Normal distribution
       /// </summary>
       public static Dist<double> Normal(double mean, double variance)
-      {
-         return Primitive(NormalPrimitive(mean, variance));
-      }
+         => Primitive(NormalPrimitive(mean, variance));
 
       /// <summary>
       /// Log Normal distribution
       /// </summary>
       public static Dist<double> LogNormal(double mean, double variance)
-      {
-         return Primitive(LogNormalPrimitive(mean, variance));
-      }
+         => Primitive(LogNormalPrimitive(mean, variance));
 
       public static Dist<double> LogNormalMu(double mu, double sigma)
-      {
-         return Primitive(LogNormalPrimitiveMu(mu, sigma));
-      }
+         => Primitive(LogNormalPrimitiveMu(mu, sigma));
 
       /// <summary>
       /// Gamma distribution
       /// </summary>
       public static Dist<double> Gamma(double shape, double rate)
-      {
-         return Primitive(GammaPrimitive(shape, rate));
-      }
+         => Primitive(GammaPrimitive(shape, rate));
 
       /// <summary>
       /// Categorical distribution
       /// </summary>
       public static Dist<T> Categorical<T>(T[] items, double[] probabilities)
-      {
-         return Primitive(CategoricalPrimitive<T>(items, probabilities));
-      }
+         => Primitive(CategoricalPrimitive<T>(items, probabilities));
 
       public static Dist<double> Uniform()
-      {
-         return Primitive(ContinuousUniformPrimitive());
-      }
+         => Primitive(ContinuousUniformPrimitive());
 
       public static Dist<double> Uniform(double lower, double upper)
-      {
-         return Primitive(ContinuousUniformPrimitive(lower,upper));
-      }
+         => 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));
-      }
+         => Primitive(StudentTPrimitive(location, scale, normality));
 
       /// <summary>
       /// Exponential distribution
       /// </summary>
       public static Dist<double> Exponential(double rate)
-      {
-          return Primitive(ExponentialPrimitive(rate));
-      }
+         => Primitive(ExponentialPrimitive(rate));
 
       /// <summary>
       /// Beta distribution
       /// </summary>
       public static Dist<double> Beta(double alpha, double beta)
-      {
-         return Primitive(BetaPrimitive(alpha, beta));
-      }
+         => Primitive(BetaPrimitive(alpha, beta));
 
       /// <summary>
       /// Dirichlet distribution
       /// </summary>
       public static Dist<double[]> Dirichlet(double[] alpha)
-      {
-         return Primitive(DirichletPrimitive(alpha));
-      }
+         => Primitive(DirichletPrimitive(alpha));
 
       public static Dist<double[]> MultiVariateNormal(double[] mean, Matrix<double> covariance)
-      {
-         return Primitive(MultiVariateNormalPrimitive(mean, covariance));
-      }
+         => Primitive(MultiVariateNormalPrimitive(mean, covariance));
 
       public static Dist<Matrix<double>> Wishart(double dof, Matrix<double> scale)
-      {
-        return Primitive(WishartPrimitive(dof, scale));
-      }
+         => Primitive(WishartPrimitive(dof, scale));
+
       #endregion
 
       #region GADT constructors
@@ -365,82 +282,63 @@ public static Dist<Matrix<double>> Wishart(double dof, Matrix<double> scale)
       /// 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);
-      }
+         => 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);
-      }
+         => 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)));
-      }
+         => 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)));
-      }
+         => 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);
-      }
+         => 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);
-      }
+         => 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());
-      }
+         => new Primitive<A>(dist.ToSampleDist());
 
       /// <summary>
       /// Pure constructor, monadic return
       /// </summary>
       public static Dist<A> Return<A>(A value)
-      {
-         return new Pure<A>(value);
-      }
+         => 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);
-      }
+         => 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);
-      }
+         => new Conditional<A>(likelihood, dist);
 
       #endregion
 
@@ -451,9 +349,7 @@ public static Dist<A> Condition<A>(this Dist<A> dist, Func<A, Prob> likelihood)
       /// </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));
-      }
+         => Samples(CompactUnordered(samples, keyFunc).Weights.OrderBy(w => w.Item));
 
       /// <summary>
       /// Aggregates probabilities of samples with identical values
@@ -478,9 +374,7 @@ public static Samples<A> CompactUnordered<A, Key>(Samples<A> samples, Func<A, Ke
       /// 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));
-      }
+         => Importance.Normalize(Compact(dist.Explicit, keyFunc));
 
       /// <summary>
       /// The probability density function for a primitive distribution and point.
@@ -488,22 +382,18 @@ public static Samples<A> Enumerate<A, Key>(FiniteDist<A> dist, Func<A, Key> keyF
       /// </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)
+         switch (dist) 
          {
-            var d = dist as MultiVariateNormalPrimitive;
-
-            return Prob(d.mvn.Density(DenseMatrix.OfRowArrays(x)));
+            case DirichletPrimitive dirichlet:
+               var d = new MathNet.Numerics.Distributions.Dirichlet(dirichlet.alpha);
+               return Prob(d.Density(x));
+            
+            case MultiVariateNormalPrimitive multiVariateNormal:
+               return Prob(multiVariateNormal.mvn.Density(DenseMatrix.OfRowArrays(x)));
+            
+            default:
+               throw new NotImplementedException("No PDF for this distribution implemented");
          }
-         throw new NotImplementedException("No PDF for this distribution implemented");
       }
       /// <summary>
       /// The probability density function for a primitive distribution and point.
@@ -511,13 +401,9 @@ public static Prob Pdf(PrimitiveDist<double[]> dist, double[] x)
       /// </summary>
       public static Prob Pdf(PrimitiveDist<Matrix<double>> dist, Matrix<double> x)
       {
+        if (dist is WishartPrimitive wish)
+           return Prob(wish.Wishart.Density(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>
@@ -526,27 +412,23 @@ public static Prob Pdf(PrimitiveDist<Matrix<double>> dist, Matrix<double> x)
       /// </summary>
       public static Prob Pdf(PrimitiveDist<double> dist, double y)
       {
-         if (dist is NormalPrimitive)
+         switch (dist)
          {
-            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));
+            case NormalPrimitive normal:
+               return Prob(MathNet.Numerics.Distributions.Normal.PDF(normal.Mean, Math.Sqrt(normal.Variance), y));
+            
+            case LogNormalPrimitive lognormal:
+               return Prob(MathNet.Numerics.Distributions.LogNormal.PDF(lognormal.mu, lognormal.sigma, y));
+            
+            case BetaPrimitive beta:
+               return Prob(MathNet.Numerics.Distributions.Beta.PDF(beta.alpha, beta.beta, y));
+            
+            case GammaPrimitive gamma:
+               return Prob(MathNet.Numerics.Distributions.Gamma.PDF(gamma.shape, gamma.rate, y));
+            
+            default:
+               throw new NotImplementedException("No PDF for this distribution implemented");
          }
-         throw new NotImplementedException("No PDF for this distribution implemented");
       }
 
       /// <summary>
@@ -555,22 +437,17 @@ public static Prob Pdf(PrimitiveDist<double> dist, double y)
       /// </summary>
       public static Prob Pmf(PrimitiveDist<int> dist, int y)
       {
-         if (dist is PoissonPrimitive)
-         {
-            var poisson = dist as PoissonPrimitive;
+         if (dist is PoissonPrimitive poisson)
             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>;
-            
+         if (dist is CategoricalPrimitive<T> cat)
             return Prob(MathNet.Numerics.Distributions.Categorical.PMF(cat.ProbabilityMass, cat.ItemIndex[k]));
-         }
+
          throw new NotImplementedException("No PMF for this distribution implemented");
       }
 
@@ -580,50 +457,40 @@ public static Prob Pmf<T>(PrimitiveDist<T> dist, T k)
       /// </summary>
       public static Prob Pdf(Dist<double> dist, double y)
       {
-         if (dist is Primitive<double>)
-         {
-            var primitive = dist as Primitive<double>;
+         if (dist is Primitive<double> primitive)
             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[]>;
+         if (dist is Primitive<double[]> primitive)
             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);
-        }
+        if (dist is Primitive<Matrix<double>> primitive)
+           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>;
+         if (dist is Primitive<T> primitive)
             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>;
+         if (dist is Primitive<int> primitive)
             return Pmf(primitive.dist, y);
-         }
+
          throw new ArgumentException("Can only calculate pmf for primitive distributions");
       }
 
@@ -642,9 +509,8 @@ public static IEnumerable<A> Append<A>(IEnumerable<A> list, A value)
       /// Sigmoid function
       /// </summary>
       public static double Sigmoid(double x)
-      {
-         return 1 / (1 + Math.Exp(-x));
-      }
+         => 1 / (1 + Math.Exp(-x));
+
       #endregion
    }
 }
diff --git a/ProbabilityMonad/DistGadt.cs b/ProbabilityMonad/DistGadt.cs
index 7d995b3..0243922 100644
--- a/ProbabilityMonad/DistGadt.cs
+++ b/ProbabilityMonad/DistGadt.cs
@@ -54,20 +54,15 @@ public interface ParallelDistInterpreter<A, X>
     public class Pure<A> : Dist<A>
     {
         public readonly A Value;
+        
         public Pure(A value)
-        {
-            Value = value;
-        }
+            => Value = value;
 
         public X Run<X>(DistInterpreter<A, X> interpreter)
-        {
-            return interpreter.Pure(Value);
-        }
+            => interpreter.Pure(Value);
 
         public X RunParallel<X>(ParallelDistInterpreter<A, X> interpreter)
-        {
-            return interpreter.Pure(Value);
-        }
+            => interpreter.Pure(Value);
     }
 
     /// <summary>
@@ -76,20 +71,15 @@ public X RunParallel<X>(ParallelDistInterpreter<A, X> interpreter)
     public class Primitive<A> : Dist<A>
     {
         public readonly PrimitiveDist<A> dist;
+        
         public Primitive(PrimitiveDist<A> dist)
-        {
-            this.dist = dist;
-        }
+            => this.dist = dist;
 
         public X Run<X>(DistInterpreter<A, X> interpreter)
-        {
-            return interpreter.Primitive(dist);
-        }
+            => interpreter.Primitive(dist);
 
         public X RunParallel<X>(ParallelDistInterpreter<A, X> interpreter)
-        {
-            return interpreter.Primitive(dist);
-        }
+            => interpreter.Primitive(dist);
     }
 
     /// <summary>
@@ -99,21 +89,15 @@ public class Conditional<A> : Dist<A>
     {
         public readonly Func<A, Prob> likelihood;
         public readonly Dist<A> dist;
+
         public Conditional(Func<A, Prob> likelihood, Dist<A> dist)
-        {
-            this.likelihood = likelihood;
-            this.dist = dist;
-        }
+            => (this.likelihood, this.dist) = (likelihood, dist);
 
         public X Run<X>(DistInterpreter<A, X> interpreter)
-        {
-            return interpreter.Conditional(likelihood, dist);
-        }
+            => interpreter.Conditional(likelihood, dist);
 
         public X RunParallel<X>(ParallelDistInterpreter<A, X> interpreter)
-        {
-            return interpreter.Conditional(likelihood, dist);
-        }
+            => interpreter.Conditional(likelihood, dist);
     }
 
     /// <summary>
@@ -125,6 +109,7 @@ public class RunIndependent3<T1, T2, T3, A> : Dist<A>
         public readonly Dist<T2> second;
         public readonly Dist<T3> third;
         public readonly Func<T1, T2, T3, Dist<A>> run;
+        
         public RunIndependent3(Dist<T1> first, Dist<T2> second, Dist<T3> third, Func<T1, T2, T3, Dist<A>> run)
         {
             this.first = first;
@@ -145,9 +130,7 @@ from result in run(x, y, z)
         }
 
         public X RunParallel<X>(ParallelDistInterpreter<A, X> interpreter)
-        {
-            return interpreter.RunIndependent3(first, second, third, run);
-        }
+            => interpreter.RunIndependent3(first, second, third, run);
     }
 
     /// <summary>
@@ -158,6 +141,7 @@ public class RunIndependent<T1, T2, A> : Dist<A>
         public readonly Dist<T1> first;
         public readonly Dist<T2> second;
         public readonly Func<T1, T2, Dist<A>> run;
+        
         public RunIndependent(Dist<T1> first, Dist<T2> second, Func<T1, T2, Dist<A>> run)
         {
             this.first = first;
@@ -176,9 +160,7 @@ from result in run(x, y)
         }
 
         public X RunParallel<X>(ParallelDistInterpreter<A, X> interpreter)
-        {
-            return interpreter.RunIndependent(first, second, run);
-        }
+            => interpreter.RunIndependent(first, second, run);
     }
 
     /// <summary>
@@ -187,21 +169,16 @@ public X RunParallel<X>(ParallelDistInterpreter<A, X> interpreter)
     public class Independent<A> : Dist<Dist<A>>
     {
         public readonly Dist<A> dist;
+        
         public Independent(Dist<A> dist)
-        {
-            this.dist = dist;
-        }
+            => this.dist = dist;
 
         // Run sequentially if we're not using a parallel interpreter
         public X Run<X>(DistInterpreter<Dist<A>, X> interpreter)
-        {
-            return Return(dist).Run(interpreter);
-        }
+            => Return(dist).Run(interpreter);
 
         public X RunParallel<X>(ParallelDistInterpreter<Dist<A>, X> interpreter)
-        {
-            return interpreter.Independent(Return(dist));
-        }
+            => interpreter.Independent(Return(dist));
     }
 
     /// <summary>
@@ -211,6 +188,7 @@ public class Bind<Y, A> : Dist<A>
     {
         public readonly Dist<Y> dist;
         public readonly Func<Y, Dist<A>> bind;
+        
         public Bind(Dist<Y> dist, Func<Y, Dist<A>> bind)
         {
             this.dist = dist;
@@ -218,14 +196,10 @@ public Bind(Dist<Y> dist, Func<Y, Dist<A>> bind)
         }
 
         public X Run<X>(DistInterpreter<A, X> interpreter)
-        {
-            return interpreter.Bind(dist, bind);
-        }
+            => interpreter.Bind(dist, bind);
 
         public X RunParallel<X>(ParallelDistInterpreter<A, X> interpreter)
-        {
-            return interpreter.Bind(dist, bind);
-        }
+            => interpreter.Bind(dist, bind);
     }
 
     /// <summary>
@@ -235,36 +209,27 @@ public X RunParallel<X>(ParallelDistInterpreter<A, X> interpreter)
     public static class DistExt
     {
         public static Dist<B> Select<A, B>(this Dist<A> dist, Func<A, B> f)
-        {
-            return new Bind<A, B>(dist, a => new Pure<B>(f(a)));
-        }
+            => new Bind<A, B>(dist, a => new Pure<B>(f(a)));
 
         public static Dist<B> SelectMany<A, B>(this Dist<A> dist, Func<A, Dist<B>> bind)
-        {
-            return new Bind<A, B>(dist, bind);
-        }
+            => new Bind<A, B>(dist, bind);
 
         public static Dist<C> SelectMany<A, B, C>(
             this Dist<A> dist,
             Func<A, Dist<B>> bind,
             Func<A, B, C> project
         )
-        {
-            return
-                new Bind<A, C>(dist, a =>
-                   new Bind<B, C>(bind(a), b =>
-                       new Pure<C>(project(a, b))
-                    )
-                );
-        }
+            => new Bind<A, C>(dist, a =>
+                new Bind<B, C>(bind(a), b =>
+                    new Pure<C>(project(a, b))
+                )
+            );
 
         /// <summary>
         /// Default to using recursion depth limit of 100
         /// </summary>
         public static Dist<IEnumerable<A>> Sequence<A>(this IEnumerable<Dist<A>> dists)
-        {
-            return SequenceWithDepth(dists, 100);
-        }
+            => SequenceWithDepth(dists, 100);
 
         /// <summary>
         /// This implementation sort of does trampolining to avoid stack overflows,
diff --git a/ProbabilityMonad/Finite/FiniteDist.cs b/ProbabilityMonad/Finite/FiniteDist.cs
index 6c5937c..7848411 100644
--- a/ProbabilityMonad/Finite/FiniteDist.cs
+++ b/ProbabilityMonad/Finite/FiniteDist.cs
@@ -11,14 +11,10 @@ namespace ProbCSharp
     public class FiniteDist<A>
     {
         public FiniteDist(Samples<A> samples)
-        {
-            Explicit = samples;
-        }
+            => Explicit = samples;
 
         public FiniteDist(params ItemProb<A>[] samples)
-        {
-            Explicit = Samples(samples);
-        }
+            => Explicit = Samples(samples);
 
         public Samples<A> Explicit { get; }
     }
@@ -31,10 +27,8 @@ public static class FiniteDistMonad
         /// fmap f (FiniteDist (Samples xs)) = FiniteDist $ Samples $ map (first f) xs
         /// </summary>
         public static FiniteDist<B> Select<A, B>(this FiniteDist<A> self, Func<A, B> select)
-        {
-            return new FiniteDist<B>(Samples(self.Explicit.Weights.Select(i =>
-                ItemProb(select(i.Item), i.Prob))));
-        }
+            => new FiniteDist<B>(Samples(self.Explicit.Weights.Select(i =>
+                ItemProb(@select(i.Item), i.Prob))));
 
         /// <summary>
         /// (FiniteDist dist) >>= bind = FiniteDist $ do
diff --git a/ProbabilityMonad/Finite/FiniteExtensions.cs b/ProbabilityMonad/Finite/FiniteExtensions.cs
index 30558c0..91279ac 100644
--- a/ProbabilityMonad/Finite/FiniteExtensions.cs
+++ b/ProbabilityMonad/Finite/FiniteExtensions.cs
@@ -29,13 +29,11 @@ public static A Pick<A>(this FiniteDist<A> distribution, Prob pickProb)
         /// Lifts a FiniteDist<A> into a SampleableDist<A>
         /// </summary>
         public static PrimitiveDist<A> ToSampleDist<A>(this FiniteDist<A> dist)
-        {
-            return new SampleDist<A>(() =>
+            => new SampleDist<A>(() =>
             {
                 var rand = new MathNet.Numerics.Distributions.ContinuousUniform().Sample();
                 return dist.Pick(Prob(rand));
             });
-        }
 
         /// <summary>
         /// Returns the probability of a certain event
@@ -51,71 +49,55 @@ public static Prob ProbOf<A>(this FiniteDist<A> dist, Func<A, bool> eventTest)
         /// Reweight by a probability that depends on associated item
         /// </summary>
         public static FiniteDist<A> ConditionSoft<A>(this FiniteDist<A> distribution, Func<A, Prob> likelihood)
-        {
-            return new FiniteDist<A>(
+            => new FiniteDist<A>(
                 distribution.Explicit
                     .Select(p => ItemProb(p.Item, likelihood(p.Item).Mult(p.Prob)))
                     .Normalize()
             );
-        }
 
         /// <summary>
         /// Reweight by a probability that depends on associated item, without normalizing
         /// </summary>
         public static FiniteDist<A> ConditionSoftUnnormalized<A>(this FiniteDist<A> distribution, Func<A, Prob> likelihood)
-        {
-            return new FiniteDist<A>(
+            => new FiniteDist<A>(
                 distribution.Explicit.Select(p => ItemProb(p.Item, likelihood(p.Item).Mult(p.Prob)))
             );
-        }
 
         /// <summary>
         /// Hard reweight by a condition that depends on associated item
         /// </summary>
         public static FiniteDist<A> ConditionHard<A>(this FiniteDist<A> distribution, Func<A, bool> condition)
-        {
-            return new FiniteDist<A>(
+            => new FiniteDist<A>(
                 distribution.Explicit
                     .Select(p => ItemProb(p.Item, condition(p.Item) ? p.Prob : Prob(0)))
                     .Normalize()
             );
-                    
-                
-        }
 
         /// <summary>
         /// Computes the posterior distribution, given a piece of data and a likelihood function
         /// </summary>
         public static FiniteDist<A> UpdateOn<A, D>(this FiniteDist<A> prior, Func<A, D, Prob> likelihood, D datum)
-        {
-            return prior.ConditionSoft(w => likelihood(w, datum));
-        }
+            => prior.ConditionSoft(w => likelihood(w, datum));
 
         /// <summary>
         /// Computes the posterior distribution, given a list of data and a likelihood function
         /// </summary>
         public static FiniteDist<A> UpdateOn<A, D>(this FiniteDist<A> prior, Func<A, D, Prob> likelihood, IEnumerable<D> data)
-        {
-            return data.Aggregate(prior, (dist, datum) => dist.UpdateOn(likelihood, datum));
-        }
+            => data.Aggregate(prior, (dist, datum) => dist.UpdateOn(likelihood, datum));
 
         /// <summary>
         /// Normalize a finite distribution
         /// </summary>
         public static FiniteDist<A> Normalize<A>(this FiniteDist<A> dist)
-        {
-            return new FiniteDist<A>(dist.Explicit.Normalize());
-        }
-        
+            => new FiniteDist<A>(dist.Explicit.Normalize());
+
         /// <summary>
         /// Join two independent distributions
         /// </summary>
         public static FiniteDist<Tuple<A,B>> Join<A, B>(this FiniteDist<A> self, FiniteDist<B> other)
-        {
-            return from a in self
-                   from b in other
-                   select new Tuple<A, B>(a, b);
-        }
+            => from a in self
+                from b in other
+                select new Tuple<A, B>(a, b);
 
         /// <summary>
         /// Returns all elements, and the collection without that element
diff --git a/ProbabilityMonad/Histogram.cs b/ProbabilityMonad/Histogram.cs
index 94e13c6..f4c70ec 100644
--- a/ProbabilityMonad/Histogram.cs
+++ b/ProbabilityMonad/Histogram.cs
@@ -67,15 +67,16 @@ internal static List<Bucket> MakeIntBucketList(int min, int max, int numBuckets)
         internal static string ShowBuckets(IEnumerable<Bucket> buckets, double scale)
         {
             var sb = new StringBuilder();
-            Func<double, string> formatDouble = d => $"{d:N2}";
 
-            var minPadding = LongestString(buckets, b => formatDouble(b.Min));
-            var maxPadding = LongestString(buckets, b => formatDouble(b.Max));
+            string FormatDouble(double d) => d.ToString("N2");
+
+            var minPadding = LongestString(buckets, b => FormatDouble(b.Min));
+            var maxPadding = LongestString(buckets, b => FormatDouble(b.Max));
             var barScale = BarScale(buckets.Select(b => b.BarSize), scale);
             foreach (var bucket in buckets)
             {
-                var min = formatDouble(bucket.Min).PadLeft(minPadding, ' ');
-                var max = formatDouble(bucket.Max).PadLeft(maxPadding, ' ');
+                var min = FormatDouble(bucket.Min).PadLeft(minPadding, ' ');
+                var max = FormatDouble(bucket.Max).PadLeft(maxPadding, ' ');
                 sb.AppendLine($"{min} {max} {Bar((int) (bucket.BarSize * barScale))}");
             }
             sb.AppendLine("");
@@ -86,9 +87,7 @@ internal static string ShowBuckets(IEnumerable<Bucket> buckets, double scale)
         /// Returns the size of the longest string representation of an item in a list
         /// </summary>
         internal static int LongestString<A>(IEnumerable<A> list, Func<A, string> toString)
-        {
-            return list.Select(x => toString(x).Length).Max();
-        }
+            => list.Select(x => toString(x).Length).Max();
 
         /// <summary>
         /// Calculate scale factor for a list of bar lengths
@@ -103,22 +102,13 @@ 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();
-        }
+            => new string('#', n);
 
         /// <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();
-        }
+            => list.Select(getVal).Sum();
 
         /// <summary>
         /// Generates a weighted histogram from a list of ItemProbs
@@ -147,9 +137,7 @@ public static string Weighted(IEnumerable<ItemProb<double>> nums, int numBuckets
         /// </summary>
         /// <param name="scale">Scale factor. Defaults to 40</param>
         public static string Weighted(Samples<double> nums, int numBuckets = 10, double scale = DEFAULT_SCALE)
-        {
-            return Weighted(nums.Weights, numBuckets, scale);
-        }
+            => Weighted(nums.Weights, numBuckets, scale);
 
         /// <summary>
         /// Generates an unweigted histogram for a list of numbers
@@ -178,9 +166,7 @@ public static string Unweighted(IEnumerable<double> nums, int numBuckets = 10, d
         /// </summary>
         /// <param name="scale">Scale factor. Defaults to 40</param>
         public static string Unweighted(IEnumerable<int> nums, int numBuckets = 10, double scale = DEFAULT_SCALE)
-        {
-            return Unweighted(nums.Select(x => (double)x), numBuckets, scale);
-        }
+            => Unweighted(nums.Select(x => (double)x), numBuckets, scale);
 
         /// <summary>
         /// Generates a histogram from some samples, grouping by a show function. 
diff --git a/ProbabilityMonad/Inference/Importance.cs b/ProbabilityMonad/Inference/Importance.cs
index 6833020..8fae155 100644
--- a/ProbabilityMonad/Inference/Importance.cs
+++ b/ProbabilityMonad/Inference/Importance.cs
@@ -10,9 +10,7 @@ public static class ImportanceExt
         /// Importance sample with given number of samples
         /// </summary>
         public static Dist<Samples<A>> ImportanceSamples<A>(this Dist<A> dist, int numSamples)
-        {
-            return Importance.ImportanceSamples(numSamples, dist);
-        }
+            => Importance.ImportanceSamples(numSamples, dist);
     }
 
     /// <summary>
@@ -35,11 +33,9 @@ public static Dist<Samples<A>> Resample<A>(Samples<A> samples)
         /// Flattens nested samples
         /// </summary>
         public static Samples<A> Flatten<A>(Samples<Samples<A>> samples)
-        {
-            return Samples(from outer in Normalize(samples).Weights
-                   from inner in outer.Item.Weights
-                   select ItemProb(inner.Item, inner.Prob.Mult(outer.Prob)));
-        }
+            => Samples(from outer in Normalize(samples).Weights
+                from inner in outer.Item.Weights
+                select ItemProb(inner.Item, inner.Prob.Mult(outer.Prob)));
 
         /// <summary>
         /// Performs importance sampling on a distribution
@@ -57,11 +53,9 @@ public static Dist<Samples<A>> ImportanceSamples<A>(int numSamples, Dist<A> dist
         /// </summary>
         /// <returns>An importance sampled distribution</returns>
         public static Dist<A> ImportanceDist<A>(int numSamples, Dist<A> dist)
-        {
-            return from probs in ImportanceSamples(numSamples, dist)
-                   from resampled in Categorical(probs)
-                   select resampled;
-        }
+            => from probs in ImportanceSamples(numSamples, dist)
+                from resampled in Categorical(probs)
+                select resampled;
 
         /// <summary>
         /// Normalizes a list of samples
diff --git a/ProbabilityMonad/Inference/MetropolisHastings.cs b/ProbabilityMonad/Inference/MetropolisHastings.cs
index 2c552ac..47ae9e3 100644
--- a/ProbabilityMonad/Inference/MetropolisHastings.cs
+++ b/ProbabilityMonad/Inference/MetropolisHastings.cs
@@ -42,9 +42,6 @@ from accept in Primitive(BernoulliF(Prob(Math.Min(1.0, candidate.Prob.Div(chainS
         /// Returns the value of the metropolis chain at specified index
         /// </summary>
         public static Dist<A> MHIndex<A>(Dist<A> dist, int n, int index)
-        {
-            return MHPrior(dist, n).Select(list => list.ElementAt(index));
-        }
-
+            => MHPrior(dist, n).Select(list => list.ElementAt(index));
     }
 } 
diff --git a/ProbabilityMonad/Inference/Pimh.cs b/ProbabilityMonad/Inference/Pimh.cs
index 29066c0..96b1d46 100644
--- a/ProbabilityMonad/Inference/Pimh.cs
+++ b/ProbabilityMonad/Inference/Pimh.cs
@@ -8,8 +8,6 @@ public static class Pimh
         /// Particle indepedent Metropolis-Hastings
         /// </summary>
         public static Dist<IEnumerable<Samples<A>>> Create<A>(int numParticles, int chainLen, Dist<A> dist)
-        {
-            return MetropolisHastings.MHPrior(dist.Run(new Smc<A>(numParticles)), chainLen);
-        }
+            => MetropolisHastings.MHPrior(dist.Run(new Smc<A>(numParticles)), chainLen);
     }
 }
diff --git a/ProbabilityMonad/Inference/Prior.cs b/ProbabilityMonad/Inference/Prior.cs
index 80b0dd3..7402e0b 100644
--- a/ProbabilityMonad/Inference/Prior.cs
+++ b/ProbabilityMonad/Inference/Prior.cs
@@ -8,29 +8,19 @@ namespace ProbCSharp
     public class Prior<A> : DistInterpreter<A, Dist<A>>
     {
         public DistInterpreter<B, Y> New<B, Y>()
-        {
-            return new Prior<B>() as DistInterpreter<B,Y>;
-        }
+            => new Prior<B>() as DistInterpreter<B,Y>;
 
         Dist<A> DistInterpreter<A, Dist<A>>.Bind<B>(Dist<B> dist, Func<B, Dist<A>> bind)
-        {
-            return new Bind<B, A>(dist.Run(new Prior<B>()), bind);
-        }
+            => new Bind<B, A>(dist.Run(new Prior<B>()), bind);
 
         Dist<A> DistInterpreter<A, Dist<A>>.Conditional(Func<A, Prob> lik, Dist<A> dist)
-        {
-            return dist.Run(new Prior<A>());
-        }
+            => dist.Run(new Prior<A>());
 
         Dist<A> DistInterpreter<A, Dist<A>>.Primitive(PrimitiveDist<A> dist)
-        {
-            return new Pure<A>(dist.Sample());
-        }
+            => new Pure<A>(dist.Sample());
 
         Dist<A> DistInterpreter<A, Dist<A>>.Pure(A value)
-        {
-            return new Pure<A>(value);
-        }
+            => new Pure<A>(value);
     }
 
 
diff --git a/ProbabilityMonad/Inference/PriorWeighted.cs b/ProbabilityMonad/Inference/PriorWeighted.cs
index 70cefd1..8ea366e 100644
--- a/ProbabilityMonad/Inference/PriorWeighted.cs
+++ b/ProbabilityMonad/Inference/PriorWeighted.cs
@@ -7,9 +7,7 @@ namespace ProbCSharp
     public static class PriorWeightedExtensions
     {
         public static Dist<ItemProb<A>> WeightedPrior<A>(this Dist<A> dist)
-        {
-            return dist.Run(new PriorWeighted<A>());
-        }
+            => dist.Run(new PriorWeighted<A>());
     }
 
     /// <summary>
@@ -20,32 +18,22 @@ public static Dist<ItemProb<A>> WeightedPrior<A>(this Dist<A> dist)
     public class PriorWeighted<A> : DistInterpreter<A, Dist<ItemProb<A>>>
     {
         public Dist<ItemProb<A>> Bind<B>(Dist<B> dist, Func<B, Dist<A>> bind)
-        {
-            return from x in dist.Run(new PriorWeighted<B>())
-                   from y in bind(x.Item) // Don't remove conditionals here
-                   select new ItemProb<A>(y, x.Prob);
-        }
+            => from x in dist.Run(new PriorWeighted<B>())
+                from y in bind(x.Item) // Don't remove conditionals here
+                select new ItemProb<A>(y, x.Prob);
 
         public Dist<ItemProb<A>> Conditional(Func<A, Prob> lik, Dist<A> dist)
-        {
-            return from itemProb in dist.Run(new PriorWeighted<A>())
-            select new ItemProb<A>(itemProb.Item, itemProb.Prob.Mult(lik(itemProb.Item)));
-        }
+            => from itemProb in dist.Run(new PriorWeighted<A>())
+                select new ItemProb<A>(itemProb.Item, itemProb.Prob.Mult(lik(itemProb.Item)));
 
         public DistInterpreter<B, Y> New<B, Y>()
-        {
-            return new PriorWeighted<B>() as DistInterpreter<B, Y>;
-        }
+            => new PriorWeighted<B>() as DistInterpreter<B, Y>;
 
         public Dist<ItemProb<A>> Primitive(PrimitiveDist<A> dist)
-        {
-            return new Primitive<ItemProb<A>>(dist.Select(a => ItemProb(a, Prob(1))));
-        }
+            => new Primitive<ItemProb<A>>(dist.Select(a => ItemProb(a, Prob(1))));
 
         public Dist<ItemProb<A>> Pure(A value)
-        {
-            return new Pure<ItemProb<A>>(new ItemProb<A>(value, Prob(1)));
-        }
+            => new Pure<ItemProb<A>>(new ItemProb<A>(value, Prob(1)));
     }
 
 }
diff --git a/ProbabilityMonad/Inference/Smc.cs b/ProbabilityMonad/Inference/Smc.cs
index 4b4a8cd..94f7d5c 100644
--- a/ProbabilityMonad/Inference/Smc.cs
+++ b/ProbabilityMonad/Inference/Smc.cs
@@ -12,17 +12,13 @@ public static class SmcExtensions
         /// SMC that discards pseudo-marginal likelihoods
         /// </summary>
         public static Dist<Samples<A>> SmcStandard<A>(this Dist<A> dist, int n)
-        {
-            return dist.Run(new Smc<A>(n)).Run(new Prior<Samples<A>>());
-        }
+            => dist.Run(new Smc<A>(n)).Run(new Prior<Samples<A>>());
 
         /// <summary>
         /// SMC that does importance sampling
         /// </summary>
         public static Dist<Samples<A>> SmcMultiple<A>(this Dist<A> dist, int numSamples, int numParticles)
-        {
-            return dist.Run(new Smc<A>(numParticles)).ImportanceSamples(numSamples).Select(Importance.Flatten);
-        }
+            => dist.Run(new Smc<A>(numParticles)).ImportanceSamples(numSamples).Select(Importance.Flatten);
     }
 
     /// <summary>
@@ -32,17 +28,13 @@ public class Smc<A> : DistInterpreter<A, Dist<Samples<A>>>
     {
         public int numParticles;
         public Smc(int numParticles)
-        {
-            this.numParticles = numParticles;
-        }
+            => this.numParticles = numParticles;
 
         public Dist<Samples<A>> Bind<B>(Dist<B> dist, Func<B, Dist<A>> bind)
-        {
-            return from ps in dist.Run(new Smc<B>(numParticles))
-                   let unzipped = ps.Unzip()
-                   from ys in unzipped.Item1.Select(bind).Sequence()
-                   select Samples(ys.Zip(unzipped.Item2, ItemProb));
-        }
+            => from ps in dist.Run(new Smc<B>(numParticles))
+                let unzipped = ps.Unzip()
+                from ys in unzipped.Item1.Select(bind).Sequence()
+                select Samples(ys.Zip(unzipped.Item2, ItemProb));
 
         public Dist<Samples<A>> Conditional(Func<A, Prob> lik, Dist<A> dist)
         {
@@ -58,9 +50,7 @@ select ps.Select(ip => ItemProb(ip.Item, lik(ip.Item).Mult(ip.Prob)))
         }
 
         public DistInterpreter<B, Y> New<B, Y>()
-        {
-            return new Smc<B>(numParticles) as DistInterpreter<B, Y>;
-        }
+            => new Smc<B>(numParticles) as DistInterpreter<B, Y>;
 
         public Dist<Samples<A>> Primitive(PrimitiveDist<A> dist)
         {
diff --git a/ProbabilityMonad/ItemProb.cs b/ProbabilityMonad/ItemProb.cs
index df360dc..84750c4 100644
--- a/ProbabilityMonad/ItemProb.cs
+++ b/ProbabilityMonad/ItemProb.cs
@@ -7,15 +7,11 @@ public class ItemProb<A>
     {
         public A Item { get; }
         public Prob Prob { get; }
+
         public ItemProb(A item, Prob prob)
-        {
-            Item = item;
-            Prob = prob;
-        }
+            => (Item, Prob) = (item, prob);
 
         public override string ToString()
-        {
-            return $"ItemProb ({Item}, {Prob})";
-        }
+            => $"ItemProb ({Item}, {Prob})";
     }
 }
diff --git a/ProbabilityMonad/KullbackLeibler.cs b/ProbabilityMonad/KullbackLeibler.cs
index e8f5118..c60818b 100644
--- a/ProbabilityMonad/KullbackLeibler.cs
+++ b/ProbabilityMonad/KullbackLeibler.cs
@@ -13,17 +13,20 @@ public static class KullbackLeibler
         public static double KLDivergenceF<A, Key>(FiniteDist<A> distQ, FiniteDist<A> distP, Func<A, Key> keyFunc) where A : IComparable<A>
         {
             var qWeights = Enumerate(distQ, keyFunc);
-            Func<A, Prob> qDensity = x =>
+
+            Prob QDensity(A x)
             {
                 var weight = qWeights.FirstOrDefault(ip => keyFunc(ip.Item).Equals(keyFunc(x)));
-                if (weight == null) return Prob(0);
+                if (weight == null)
+                    return Prob(0);
+
                 return weight.Prob;
-            };
+            }
 
             var pWeights = Enumerate(distP, keyFunc);
 
             var divergences = pWeights.Weights
-                                      .Select(w => w.Prob.Value * Math.Log(w.Prob.Div(qDensity(w.Item)).Value));
+                                      .Select(w => w.Prob.Value * Math.Log(w.Prob.Div(QDensity(w.Item)).Value));
             return divergences.Sum();
         }
 
diff --git a/ProbabilityMonad/LogNormalCreate.cs b/ProbabilityMonad/LogNormalCreate.cs
deleted file mode 100644
index 97022a2..0000000
--- a/ProbabilityMonad/LogNormalCreate.cs
+++ /dev/null
@@ -1,12 +0,0 @@
-using MathNet.Numerics.Distributions;
-
-namespace ProbCSharp
-{
-   class LogNormalCreate
-   {
-      public static LogNormal fromMeanVariance(double mean, double variance)
-      {
-         return LogNormal.WithMeanVariance(mean, variance);
-      }
-   }
-}
diff --git a/ProbabilityMonad/ParallelSampler.cs b/ProbabilityMonad/ParallelSampler.cs
index 30fe000..5e8b59e 100644
--- a/ProbabilityMonad/ParallelSampler.cs
+++ b/ProbabilityMonad/ParallelSampler.cs
@@ -14,9 +14,7 @@ public static class ParallelSampleExtensions
         /// This will throw an exception if the distribution contains any conditionals.
         /// </summary>
         public static A SampleParallel<A>(this Dist<A> dist)
-        {
-            return dist.RunParallel(new ParallelSampler<A>());
-        }
+            => dist.RunParallel(new ParallelSampler<A>());
 
         /// <summary>
         /// Draws n samples from a distribution in parallel
@@ -24,9 +22,7 @@ public static A SampleParallel<A>(this Dist<A> dist)
         /// This will throw an exception if the distribution contains any conditionals.
         /// </summary>
         public static IEnumerable<A> SampleNParallel<A>(this Dist<A> dist, int n)
-        {
-            return Enumerable.Range(0, n).Select(_ => dist.SampleParallel());
-        }
+            => Enumerable.Range(0, n).Select(_ => dist.SampleParallel());
     }
 
     /// <summary>
@@ -41,24 +37,16 @@ public A Bind<B>(Dist<B> dist, Func<B, Dist<A>> bind)
         }
 
         public A Conditional(Func<A, Prob> lik, Dist<A> dist)
-        {
-            throw new ArgumentException("Cannot sample from conditional distribution.");
-        }
+            => throw new ArgumentException("Cannot sample from conditional distribution.");
 
         public A Primitive(PrimitiveDist<A> dist)
-        {
-            return dist.Sample();
-        }
+            => dist.Sample();
 
         public A Pure(A value)
-        {
-            return value;
-        }
+            => value;
 
         public A Independent(Dist<A> independent)
-        {
-            return independent.RunParallel(new ParallelSampler<A>());
-        }
+            => independent.RunParallel(new ParallelSampler<A>());
 
         public A RunIndependent<B, C>(Dist<B> distB, Dist<C> distC, Func<B, C, Dist<A>> run)
         {
diff --git a/ProbabilityMonad/Primitive/Beta.cs b/ProbabilityMonad/Primitive/Beta.cs
index 9536868..86a112b 100644
--- a/ProbabilityMonad/Primitive/Beta.cs
+++ b/ProbabilityMonad/Primitive/Beta.cs
@@ -10,6 +10,7 @@ public class BetaPrimitive : PrimitiveDist<double>
         public double alpha;
         public double beta;
         public MathNet.Numerics.Distributions.Beta dist;
+
         public BetaPrimitive(double alpha, double beta, Random gen)
         {
             this.alpha = alpha;
@@ -18,8 +19,6 @@ public BetaPrimitive(double alpha, double beta, Random gen)
         }
 
         public Func<double> Sample
-        {
-            get { return () => dist.Sample(); }
-        }
+            => () => dist.Sample();
     }
 }
diff --git a/ProbabilityMonad/Primitive/Categorical.cs b/ProbabilityMonad/Primitive/Categorical.cs
index 6379373..24b39c6 100644
--- a/ProbabilityMonad/Primitive/Categorical.cs
+++ b/ProbabilityMonad/Primitive/Categorical.cs
@@ -7,36 +7,31 @@
 
 namespace ProbCSharp
 {
-   /// <summary>
-   /// Primitive Categorical distribution
-   /// </summary>
-   public class CategoricalPrimitive<T> : PrimitiveDist<T>
-   {
-      public double[] ProbabilityMass { get; }
-      public T[] Items { get; }
-      public Random Gen { get; }
-      public Categorical categorical { get; }
-      public Dictionary<T, int> ItemIndex {get ;}
+    /// <summary>
+    /// Primitive Categorical distribution
+    /// </summary>
+    public class CategoricalPrimitive<T> : PrimitiveDist<T>
+    {
+        public double[] ProbabilityMass { get; }
+        public T[] Items { get; }
+        public Random Gen { get; }
+        public Categorical categorical { get; }
+        public Dictionary<T, int> ItemIndex { get; }
 
-      public CategoricalPrimitive(T[] items , double[] probabilities, Random gen)
-      {
-         Gen = gen;
-         Items = items;
-         ProbabilityMass = probabilities;
-         categorical = new Categorical(ProbabilityMass, gen);
-         ItemIndex = new Dictionary<T, int>();
-         for (int c = 0; c < items.Length; c++)
-         {
-            ItemIndex.Add(items[c],c);
-         }
-      }
+        public CategoricalPrimitive(T[] items, double[] probabilities, Random gen)
+        {
+            Gen = gen;
+            Items = items;
+            ProbabilityMass = probabilities;
+            categorical = new Categorical(ProbabilityMass, gen);
+            ItemIndex = new Dictionary<T, int>();
+            for (int c = 0; c < items.Length; c++)
+            {
+                ItemIndex.Add(items[c], c);
+            }
+        }
 
-      public Func<T> Sample
-      {
-         get
-         {
-            return () => Items[categorical.Sample()];
-         }
-      }
-   } 
+        public Func<T> Sample
+            => () => Items[categorical.Sample()];
+    }
 }
diff --git a/ProbabilityMonad/Primitive/Dirichlet.cs b/ProbabilityMonad/Primitive/Dirichlet.cs
index f826bfa..cad475a 100644
--- a/ProbabilityMonad/Primitive/Dirichlet.cs
+++ b/ProbabilityMonad/Primitive/Dirichlet.cs
@@ -2,7 +2,6 @@
 
 namespace ProbCSharp
 {
-
     /// <summary>
     /// Primitive Dirichlet distribution
     /// </summary>
@@ -11,16 +10,15 @@ public class DirichletPrimitive : PrimitiveDist<double[]>
         public double[] alpha;
 
         public MathNet.Numerics.Distributions.Dirichlet dist;
+
         public DirichletPrimitive(double[] alpha, Random gen)
         {
             this.alpha = alpha;
-            
+
             dist = new MathNet.Numerics.Distributions.Dirichlet(alpha, gen);
         }
 
         public Func<double[]> Sample
-        {
-            get { return () => dist.Sample(); }
-        }
+            => () => dist.Sample();
     }
 }
diff --git a/ProbabilityMonad/Primitive/Gamma.cs b/ProbabilityMonad/Primitive/Gamma.cs
index 16389dc..3d4c238 100644
--- a/ProbabilityMonad/Primitive/Gamma.cs
+++ b/ProbabilityMonad/Primitive/Gamma.cs
@@ -1,21 +1,24 @@
 using System;
 
-namespace ProbCSharp {
+namespace ProbCSharp
+{
     /// <summary>
     /// Primitive Gamma distribution
     /// </summary>
-    public class GammaPrimitive : PrimitiveDist<double> {
+    public class GammaPrimitive : PrimitiveDist<double>
+    {
         public double shape;
         public double rate;
         public MathNet.Numerics.Distributions.Gamma dist;
-        public GammaPrimitive(double shape, double rate, Random gen) {
+
+        public GammaPrimitive(double shape, double rate, Random gen)
+        {
             this.shape = shape;
             this.rate = rate;
             dist = new MathNet.Numerics.Distributions.Gamma(shape, rate);
         }
 
-        public Func<double> Sample {
-            get { return () => dist.Sample(); }
-        }
+        public Func<double> Sample
+            => () => dist.Sample();
     }
 }
diff --git a/ProbabilityMonad/Primitive/LogNormal.cs b/ProbabilityMonad/Primitive/LogNormal.cs
index 479e472..4885f31 100644
--- a/ProbabilityMonad/Primitive/LogNormal.cs
+++ b/ProbabilityMonad/Primitive/LogNormal.cs
@@ -1,36 +1,36 @@
 using System;
 using MathNet.Numerics.Distributions;
 
-namespace ProbCSharp {
-   /// <summary>
-   /// Primitive Lognormal distribution
-   /// </summary>
-   public class LogNormalPrimitive : PrimitiveDist<double>
-   {
-      public double mean;
-      public double variance;
-      public double mu;
-      public double sigma;
-      public LogNormal dist;
-      public LogNormalPrimitive(double mu, double sigma, bool dummy, Random gen)
-      {
-         dist = new LogNormal(mu, sigma);
-         mu = dist.Mu;
-         sigma = dist.Sigma;
-      }
-      public LogNormalPrimitive(double mean, double variance, Random gen)
-      {
-         this.mean = mean;
-         this.variance = variance;
-         dist = LogNormalCreate.fromMeanVariance(mean, variance); // MathNet.Numerics.Distributions.LogNormal(mu, sigma);
-         mu = dist.Mu;
-         sigma = dist.Sigma;
-      }
+namespace ProbCSharp
+{
+    /// <summary>
+    /// Primitive Lognormal distribution
+    /// </summary>
+    public class LogNormalPrimitive : PrimitiveDist<double>
+    {
+        public double mean;
+        public double variance;
+        public double mu;
+        public double sigma;
+        public LogNormal dist;
 
-      public Func<double> Sample
-      {
-         get { return () => dist.Sample(); }
-      }
-   }
+        public LogNormalPrimitive(double mu, double sigma, bool dummy, Random gen)
+        {
+            dist = new LogNormal(mu, sigma);
+            mu = dist.Mu;
+            sigma = dist.Sigma;
+        }
+
+        public LogNormalPrimitive(double mean, double variance, Random gen)
+        {
+            this.mean = mean;
+            this.variance = variance;
+            dist = LogNormal.WithMeanVariance(mean, variance); // MathNet.Numerics.Distributions.LogNormal(mu, sigma);
+            mu = dist.Mu;
+            sigma = dist.Sigma;
+        }
+
+        public Func<double> Sample
+            => () => dist.Sample();
+    }
 }
- 
\ No newline at end of file
diff --git a/ProbabilityMonad/Primitive/MultiVariateNormal.cs b/ProbabilityMonad/Primitive/MultiVariateNormal.cs
index 1e5de12..461ffcb 100644
--- a/ProbabilityMonad/Primitive/MultiVariateNormal.cs
+++ b/ProbabilityMonad/Primitive/MultiVariateNormal.cs
@@ -5,39 +5,31 @@
 
 namespace ProbCSharp
 {
-   /// <summary>
-   /// Primitive Multivariate Normal distribution
-   /// </summary>
-   public class MultiVariateNormalPrimitive : PrimitiveDist<double[]>
-   {
-      public double[] Mean { get; }
-      public Matrix<double> Covariance { get; }
-      public Random Gen { get; }
-      public MatrixNormal mvn { get; }
+    /// <summary>
+    /// Primitive Multivariate Normal distribution
+    /// </summary>
+    public class MultiVariateNormalPrimitive : PrimitiveDist<double[]>
+    {
+        public double[] Mean { get; }
+        public Matrix<double> Covariance { get; }
+        public Random Gen { get; }
+        public MatrixNormal mvn { get; }
 
-      static public MatrixNormal CreateMultivariateNormal(double[] meanVector, Matrix<double> cv)
-      {
-         return new MatrixNormal(DenseMatrix.OfRowArrays(meanVector), 
-                                 DenseMatrix.OfRowArrays(new double[][] { new double[] { 1.0 } }), 
-                                 cv);
-      }
+        public static MatrixNormal CreateMultivariateNormal(double[] meanVector, Matrix<double> cv)
+            => new MatrixNormal(
+                m: DenseMatrix.OfRowArrays(meanVector),
+                v: DenseMatrix.OfRowArrays(new double[][] { new double[] { 1.0 } }),
+                k: cv);
 
-      public MultiVariateNormalPrimitive(double[] mean, Matrix<double> covariance, Random gen)
-      {
-         Mean = mean;
-         Covariance = covariance;
-         Gen = gen;
-         mvn = MultiVariateNormalPrimitive.CreateMultivariateNormal(mean, covariance);
-      }
+        public MultiVariateNormalPrimitive(double[] mean, Matrix<double> covariance, Random gen)
+        {
+            Mean = mean;
+            Covariance = covariance;
+            Gen = gen;
+            mvn = CreateMultivariateNormal(mean, covariance);
+        }
 
-      public Func<double[]> Sample
-      {
-         get
-         {
-            return () => mvn.Sample().Row(0).ToArray();
-         }
-      }
-   }
+        public Func<double[]> Sample
+            => () => mvn.Sample().Row(0).ToArray();
+    }
 }
-
- 
\ No newline at end of file
diff --git a/ProbabilityMonad/Primitive/Normal.cs b/ProbabilityMonad/Primitive/Normal.cs
index 0c35483..3a8274d 100644
--- a/ProbabilityMonad/Primitive/Normal.cs
+++ b/ProbabilityMonad/Primitive/Normal.cs
@@ -10,23 +10,18 @@ public class NormalPrimitive : PrimitiveDist<double>
     {
         public double Mean { get; }
         public double Variance { get; }
-        public Random Gen {get;}
+        public Random Gen { get; }
         public Normal normal { get; }
 
-      public NormalPrimitive(double mean, double variance, Random gen)
-      {
+        public NormalPrimitive(double mean, double variance, Random gen)
+        {
             Mean = mean;
             Variance = variance;
             Gen = gen;
             normal = Normal.WithMeanVariance(Mean, Variance, Gen);
-      }
-
-       public Func<double> Sample
-       {
-            get
-            {
-                return () => normal.Sample();
-            }
         }
+
+        public Func<double> Sample
+            => () => normal.Sample();
     }
 }
diff --git a/ProbabilityMonad/Primitive/Poisson.cs b/ProbabilityMonad/Primitive/Poisson.cs
index 5911bf7..6642aad 100644
--- a/ProbabilityMonad/Primitive/Poisson.cs
+++ b/ProbabilityMonad/Primitive/Poisson.cs
@@ -9,9 +9,10 @@ namespace ProbCSharp
     /// </summary>
     public class PoissonPrimitive : PrimitiveDist<int>
     {
-        public double Lambda;  
+        public double Lambda;
         public Poisson Dist;
         public Random Gen;
+
         public PoissonPrimitive(double lambda, Random gen)
         {
             Lambda = lambda;
@@ -20,11 +21,6 @@ public PoissonPrimitive(double lambda, Random gen)
         }
 
         public Func<int> Sample
-        {
-            get
-            {
-                return () => Dist.Sample();
-            }
-        }
+            => () => Dist.Sample();
     }
 }
diff --git a/ProbabilityMonad/Primitive/PrimitiveDist.cs b/ProbabilityMonad/Primitive/PrimitiveDist.cs
index f688b98..340fc2c 100644
--- a/ProbabilityMonad/Primitive/PrimitiveDist.cs
+++ b/ProbabilityMonad/Primitive/PrimitiveDist.cs
@@ -19,15 +19,12 @@ public interface PrimitiveDist<A>
     public class SampleDist<A> : PrimitiveDist<A>
     {
         private readonly Func<A> _sample;
+
         public SampleDist(Func<A> sample)
-        {
-            _sample = sample;
-        }
+            => _sample = sample;
 
         public Func<A> Sample
-        {
-            get { return _sample; }
-        }
+            => _sample;
     }
 
 
@@ -35,23 +32,17 @@ public Func<A> Sample
     public static class PrimitiveDistMonad
     {
         public static PrimitiveDist<B> Select<A, B>(this PrimitiveDist<A> self, Func<A, B> f)
-        {
-            return new SampleDist<B>(() => f(self.Sample()));
-        }
+            => new SampleDist<B>(() => f(self.Sample()));
 
         public static PrimitiveDist<C> SelectMany<A, B, C>(
             this PrimitiveDist<A> self,
             Func<A, PrimitiveDist<B>> bind,
-            Func<A, B, C> project
-        )
-        {
-            return new SampleDist<C>(() =>
+            Func<A, B, C> project)
+            => new SampleDist<C>(() =>
             {
                 var firstSample = self.Sample();
                 var secondSample = bind(firstSample).Sample();
                 return project(firstSample, secondSample);
             });
-        }
     }
-
 }
diff --git a/ProbabilityMonad/Primitive/Uniform.cs b/ProbabilityMonad/Primitive/Uniform.cs
index 4090a93..c12c017 100644
--- a/ProbabilityMonad/Primitive/Uniform.cs
+++ b/ProbabilityMonad/Primitive/Uniform.cs
@@ -3,20 +3,17 @@
 
 namespace ProbCSharp
 {
-   public class ContinuousUniformPrimitive : PrimitiveDist<double>
-   {
-      public ContinuousUniform dist;
-      public ContinuousUniformPrimitive(double lower, double upper, Random gen)
-      { 
-         dist = new ContinuousUniform(lower,upper);
-      }
-      public ContinuousUniformPrimitive(Random gen)
-      {
-         dist = new ContinuousUniform();
-      }
-      public Func<double> Sample
-      {
-         get { return () => dist.Sample(); }
-      }
-   }
+    public class ContinuousUniformPrimitive : PrimitiveDist<double>
+    {
+        public ContinuousUniform dist;
+
+        public ContinuousUniformPrimitive(double lower, double upper, Random gen)
+            => dist = new ContinuousUniform(lower, upper);
+
+        public ContinuousUniformPrimitive(Random gen)
+            => dist = new ContinuousUniform();
+
+        public Func<double> Sample
+            => () => dist.Sample();
+    }
 }
diff --git a/ProbabilityMonad/Primitive/Wishart.cs b/ProbabilityMonad/Primitive/Wishart.cs
index 10d48d7..42ac744 100644
--- a/ProbabilityMonad/Primitive/Wishart.cs
+++ b/ProbabilityMonad/Primitive/Wishart.cs
@@ -4,30 +4,25 @@
 
 namespace ProbCSharp
 {
-  /// <summary>
-  /// Primitive Wishart distribution
-  /// </summary>
-  public class WishartPrimitive : PrimitiveDist<Matrix<double>>
-  {
-    public double DegreesOfFreedom { get; }
-    public Matrix<double> Scale { get; }
-    public Random Gen { get; }
-    public Wishart Wishart { get; }
-
-    public WishartPrimitive(double dof, Matrix<double> scale, Random gen)
+    /// <summary>
+    /// Primitive Wishart distribution
+    /// </summary>
+    public class WishartPrimitive : PrimitiveDist<Matrix<double>>
     {
-      DegreesOfFreedom = dof;
-      Scale = scale;
-      Gen = gen;
-      Wishart = new Wishart(dof, scale);
-    }
+        public double DegreesOfFreedom { get; }
+        public Matrix<double> Scale { get; }
+        public Random Gen { get; }
+        public Wishart Wishart { get; }
 
-    public Func<Matrix<double>> Sample
-    {
-      get
-      {
-        return () => Wishart.Sample();
-      }
+        public WishartPrimitive(double dof, Matrix<double> scale, Random gen)
+        {
+            DegreesOfFreedom = dof;
+            Scale = scale;
+            Gen = gen;
+            Wishart = new Wishart(dof, scale);
+        }
+
+        public Func<Matrix<double>> Sample
+            => () => Wishart.Sample();
     }
-  }
 }
diff --git a/ProbabilityMonad/Prob.cs b/ProbabilityMonad/Prob.cs
index e8eea2d..47b5bee 100644
--- a/ProbabilityMonad/Prob.cs
+++ b/ProbabilityMonad/Prob.cs
@@ -21,17 +21,10 @@ public class DoubleProb : Prob
         public double Value { get; }
 
         public double LogValue
-        {
-            get
-            {
-                return Math.Log(Value);
-            }
-        }
+            => Math.Log(Value);
 
         public DoubleProb(double probability)
-        {
-            Value = probability;
-        }
+            => Value = probability;
 
         public override string ToString()
         {
@@ -40,24 +33,16 @@ public override string ToString()
         }
 
         public Prob Mult(Prob other)
-        {
-            return new DoubleProb(Value * other.Value);
-        }
+            => new DoubleProb(Value * other.Value);
 
         public Prob Div(Prob other)
-        {
-            return new DoubleProb(Value / other.Value);
-        }
+            => new DoubleProb(Value / other.Value);
 
         public int CompareTo(Prob other)
-        {
-            return Value.CompareTo(other.Value);
-        }
+            => Value.CompareTo(other.Value);
 
         public bool Equals(Prob other)
-        {
-            return Value.Equals(other.Value);
-        }
+            => Value.Equals(other.Value);
     }
 
     /// <summary>
@@ -75,45 +60,24 @@ public LogProb(double logProb)
         }
 
         public double Value
-        {
-            get
-            {
-                return Math.Exp(logProb);
-            }
-        }
+            => Math.Exp(logProb);
 
         public double LogValue
-        {
-            get
-            {
-                return logProb;
-            }
-        }
+            => logProb;
 
         public override string ToString()
-        {
-            var str = $"{Value*100:G3}%";
-            return str;
-        }
+            => $"{Value*100:G3}%";
 
         public int CompareTo(Prob other)
-        {
-            return logProb.CompareTo(other.LogValue);
-        }
+            => logProb.CompareTo(other.LogValue);
 
         public Prob Div(Prob other)
-        {
-            return new LogProb(logProb - other.LogValue);
-        }
+            => new LogProb(logProb - other.LogValue);
 
         public bool Equals(Prob other)
-        {
-            return other.LogValue == logProb;
-        }
+            => other.LogValue == logProb;
 
         public Prob Mult(Prob other)
-        {
-            return new LogProb(logProb + other.LogValue);
-        }
+            => new LogProb(logProb + other.LogValue);
     }
 }
diff --git a/ProbabilityMonad/Sampler.cs b/ProbabilityMonad/Sampler.cs
index 28f2e2c..1a76909 100644
--- a/ProbabilityMonad/Sampler.cs
+++ b/ProbabilityMonad/Sampler.cs
@@ -11,18 +11,14 @@ public static class SamplerExt
         /// This will throw an exception if the distribution contains any conditionals.
         /// </summary>
         public static A Sample<A>(this Dist<A> dist)
-        {
-            return dist.Run(new Sampler<A>());
-        }
+            => dist.Run(new Sampler<A>());
 
         /// <summary>
         /// Draws n samples from a distribution.
         /// This will throw an exception if the distribution contains any conditionals.
         /// </summary>
         public static IEnumerable<A> SampleN<A>(this Dist<A> dist, int n)
-        {
-            return Enumerable.Range(0, n).Select(_ => dist.Sample());
-        }
+            => Enumerable.Range(0, n).Select(_ => dist.Sample());
     }
 
     /// <summary>
@@ -31,9 +27,7 @@ public static IEnumerable<A> SampleN<A>(this Dist<A> dist, int n)
     public class Sampler<A> : DistInterpreter<A, A>
     {
         public DistInterpreter<C, Y> New<C, Y>()
-        {
-            return new Sampler<C>() as DistInterpreter<C, Y>;
-        }
+            => new Sampler<C>() as DistInterpreter<C, Y>;
 
         A DistInterpreter<A, A>.Bind<B>(Dist<B> dist, Func<B, Dist<A>> bind)
         {
@@ -45,19 +39,13 @@ A DistInterpreter<A, A>.Bind<B>(Dist<B> dist, Func<B, Dist<A>> bind)
         /// All conditionals must be removed before sampling.
         /// </summary>
         A DistInterpreter<A, A>.Conditional(Func<A, Prob> lik, Dist<A> dist)
-        {
-            throw new ArgumentException("Cannot sample from conditional distribution.");
-        }
+            => throw new ArgumentException("Cannot sample from conditional distribution.");
 
         A DistInterpreter<A, A>.Primitive(PrimitiveDist<A> dist)
-        {
-            return dist.Sample();
-        }
+            => dist.Sample();
 
         A DistInterpreter<A, A>.Pure(A value)
-        {
-            return value;
-        }
+            => value;
     }
 
 }
diff --git a/ProbabilityMonad/Samples.cs b/ProbabilityMonad/Samples.cs
index 2e6e009..bc7c65e 100644
--- a/ProbabilityMonad/Samples.cs
+++ b/ProbabilityMonad/Samples.cs
@@ -13,35 +13,25 @@ namespace ProbCSharp
     public static class SamplesExt
     {
         public static Samples<B> Select<A, B>(this Samples<A> self, Func<ItemProb<A>, ItemProb<B>> f)
-        {
-            return Samples(self.Weights.Select(f));
-        }
+            => Samples(self.Weights.Select(f));
 
         public static Samples<B> MapSample<A, B>(this Samples<A> self, Func<A, B> f)
-        {
-            return Samples(self.Weights.Select(ip => ItemProb(f(ip.Item), ip.Prob)));
-        }
+            => Samples(self.Weights.Select(ip => ItemProb(f(ip.Item), ip.Prob)));
 
         /// <summary>
         /// Sum all probabilities in samples
         /// </summary>
         public static Prob SumProbs<A>(this Samples<A> self)
-        {
-            return Prob(self.Weights.Select(ip => ip.Prob.Value).Sum());
-        }
+            => Prob(self.Weights.Select(ip => ip.Prob.Value).Sum());
 
         public static Samples<A> Normalize<A>(this Samples<A> self)
-        {
-            return Importance.Normalize(self);
-        }
+            => Importance.Normalize(self);
 
         /// <summary>
         /// Unzip samples into items and weights
         /// </summary>
         public static Tuple<IEnumerable<A>, IEnumerable<Prob>> Unzip<A>(this Samples<A> samples)
-        {
-            return new Tuple<IEnumerable<A>, IEnumerable<Prob>>(samples.Weights.Select(ip => ip.Item), samples.Weights.Select(ip => ip.Prob));
-        }
+            => new Tuple<IEnumerable<A>, IEnumerable<Prob>>(samples.Weights.Select(ip => ip.Item), samples.Weights.Select(ip => ip.Prob));
     }
 
     // This is a Wrapper class for IEnumerable<ItemProb<A>>
@@ -53,18 +43,12 @@ public class Samples<A> : IEnumerable<ItemProb<A>>
     {
         public readonly IEnumerable<ItemProb<A>> Weights;
         public Samples(IEnumerable<ItemProb<A>> list)
-        {
-            Weights = list;
-        }
+            => Weights = list;
 
         public IEnumerator<ItemProb<A>> GetEnumerator()
-        {
-            return Weights.GetEnumerator();
-        }
+            => Weights.GetEnumerator();
 
         IEnumerator IEnumerable.GetEnumerator()
-        {
-            return Weights.GetEnumerator();
-        }
+            => Weights.GetEnumerator();
     }
 }