diff --git a/src/main/scala/splatter/stutter/parsing.scala b/src/main/scala/splatter/stutter/parsing.scala
index 80fa5a3..e369c10 100644
--- a/src/main/scala/splatter/stutter/parsing.scala
+++ b/src/main/scala/splatter/stutter/parsing.scala
@@ -5,7 +5,7 @@ import scala.annotation.tailrec
 
 object parsing:
   
-  case class P[+A](parse: String => Option[(A,String)]):
+  case class P[+A](parse: String => Option[(A, String)]):
   
     def flatMap[B](f: A => P[B]): P[B] =
       P(s =>
diff --git a/src/main/scala/splatter/stutter/stutter.scala b/src/main/scala/splatter/stutter/stutter.scala
index 69a925f..a0b94b7 100644
--- a/src/main/scala/splatter/stutter/stutter.scala
+++ b/src/main/scala/splatter/stutter/stutter.scala
@@ -36,7 +36,7 @@ case class ExtractableOp1(name: String) extends ExtractableOp[Expr](name):
     case Lisp(Seq(Op, arg)) => arg
   }
 
-case class ExtractableOp2(name: String) extends ExtractableOp[(Expr,Expr)](name):
+case class ExtractableOp2(name: String) extends ExtractableOp[(Expr, Expr)](name):
   def extract: PartialFunction[Expr, (Expr, Expr)] = {
     case Lisp(Seq(Op, a, b)) => (a, b)
   }
@@ -58,26 +58,26 @@ val PrimitiveOps: Seq[Atom] =
   Seq(AtomLit.Op, QuoteLit.Op, EqLit.Op, CarLit.Op, CdrLit.Op, ConsLit.Op, CondLit.Op)
 
   // (lambda (p1 ... pn) e)
-object Lambda extends ExtractableOp[(Seq[Expr],Expr)]("lambda"):
+object Lambda extends ExtractableOp[(Seq[Expr], Expr)]("lambda"):
   def extract: PartialFunction[Expr, (Seq[Expr], Expr)] = {
     case Lisp(Seq(Op, Lisp(parms), expr)) => (parms, expr)
   }
 
 // (quote (lambda (p1 ... pn) e))
-object QuotedLambda extends ExtractableOp[(Seq[Expr],Expr)]("quote"):
+object QuotedLambda extends ExtractableOp[(Seq[Expr], Expr)]("quote"):
   def extract: PartialFunction[Expr, (Seq[Expr], Expr)] = {
     case Lisp(Seq(Op, Lambda(parms, expr))) => (parms, expr)
   }
 
 // ((lambda (p1 ... pn) e) a1 ... an)
-object Function extends Extractable[(Seq[Expr],Expr,Seq[Expr])]:
+object Function extends Extractable[(Seq[Expr], Expr, Seq[Expr])]:
   def extract: PartialFunction[Expr, (Seq[Expr], Expr, Seq[Expr])] = {
     case Lisp(Lambda(parms, expr) +: args) =>
       (parms, expr, args)
   }
 
 // ((lambda (p1 ... pn) (f fa1 ... fan)) a1 ... an)
-object QuotedFunction extends Extractable[(Seq[Expr],Atom,Seq[Expr],Seq[Expr])]:
+object QuotedFunction extends Extractable[(Seq[Expr], Atom, Seq[Expr],  Seq[Expr])]:
   def extract: PartialFunction[Expr, (Seq[Expr], Atom, Seq[Expr], Seq[Expr])] = {
     case Lisp(Lambda(parms, Lisp((op : Atom) +: fargs)) +: args)
       if !PrimitiveOps.contains(op) && args.nonEmpty && QuotedLambda.is(args.head) =>
diff --git a/src/test/scala/splatter/stutter/PrimitiveExpressions.scala b/src/test/scala/splatter/stutter/PrimitiveExpressions.scala
index 3f4923b..dfdc0ad 100644
--- a/src/test/scala/splatter/stutter/PrimitiveExpressions.scala
+++ b/src/test/scala/splatter/stutter/PrimitiveExpressions.scala
@@ -20,7 +20,7 @@ class PrimitiveExpressions extends AnyFunSpec:
         parseLisp("(cond (eq ('a 'b) 'first) (eq ('a 'a) ('second)))")
       ) foreach (
         e => (
-          e match {
+          e match
             case Lisp(Seq(AtomLit.Op, _))    => AtomLit.Op.value
             case Lisp(Seq(QuoteLit.Op, _))   => QuoteLit.Op.value
             case Lisp(Seq(EqLit.Op, _, _))   => EqLit.Op.value
@@ -29,7 +29,6 @@ class PrimitiveExpressions extends AnyFunSpec:
             case Lisp(Seq(ConsLit.Op, _, _)) => ConsLit.Op.value
             case Lisp(CondLit.Op +: _)       => CondLit.Op.value
             case _ => sys.error(s"unmatched test expression $e")
-          }
         ) should be (e.asInstanceOf[Lisp].subs.head.asInstanceOf[Atom].value)
       )