diff --git a/gtsam_unstable/nonlinear/Expression-inl.h b/gtsam_unstable/nonlinear/Expression-inl.h
index 500b4493b..fb05444c6 100644
--- a/gtsam_unstable/nonlinear/Expression-inl.h
+++ b/gtsam_unstable/nonlinear/Expression-inl.h
@@ -254,14 +254,14 @@ class NullaryMethodExpression: public UnaryExpression<T, A> {
 
 public:
 
-  typedef T (A::*method)(boost::optional<Matrix&>) const;
+  typedef T (A::*Method)(boost::optional<Matrix&>) const;
 
 private:
 
-  method method_;
+  Method method_;
 
   /// Constructor with a unary function f, and input argument e
-  NullaryMethodExpression(const Expression<A>& e, method f) :
+  NullaryMethodExpression(const Expression<A>& e, Method f) :
       UnaryExpression<T, A>(e), method_(f) {
   }
 
@@ -298,14 +298,14 @@ class UnaryFunctionExpression: public UnaryExpression<T, A> {
 
 public:
 
-  typedef boost::function<T(const A&, boost::optional<Matrix&>)> function;
+  typedef boost::function<T(const A&, boost::optional<Matrix&>)> Function;
 
 private:
 
-  function function_;
+  Function function_;
 
   /// Constructor with a unary function f, and input argument e
-  UnaryFunctionExpression(function f, const Expression<A>& e) :
+  UnaryFunctionExpression(Function f, const Expression<A>& e) :
       UnaryExpression<T, A>(e), function_(f) {
   }
 
@@ -374,15 +374,15 @@ class UnaryMethodExpression: public BinaryExpression<T, A1, A2> {
 
 public:
 
-  typedef T (A1::*method)(const A2&, boost::optional<Matrix&>,
+  typedef T (A1::*Method)(const A2&, boost::optional<Matrix&>,
       boost::optional<Matrix&>) const;
 
 private:
 
-  method method_;
+  Method method_;
 
   /// Constructor with a binary function f, and two input arguments
-  UnaryMethodExpression(const Expression<A1>& e1, method f,
+  UnaryMethodExpression(const Expression<A1>& e1, Method f,
       const Expression<A2>& e2) :
       BinaryExpression<T, A1, A2>(e1, e2), method_(f) {
   }
@@ -426,14 +426,14 @@ public:
 
   typedef boost::function<
       T(const A1&, const A2&, boost::optional<Matrix&>,
-          boost::optional<Matrix&>)> function;
+          boost::optional<Matrix&>)> Function;
 
 private:
 
-  function function_;
+  Function function_;
 
   /// Constructor with a binary function f, and two input arguments
-  BinaryFunctionExpression(function f, //
+  BinaryFunctionExpression(Function f, //
       const Expression<A1>& e1, const Expression<A2>& e2) :
       BinaryExpression<T, A1, A2>(e1, e2), function_(f) {
   }
diff --git a/gtsam_unstable/nonlinear/Expression.h b/gtsam_unstable/nonlinear/Expression.h
index ab276434c..1cf167e0d 100644
--- a/gtsam_unstable/nonlinear/Expression.h
+++ b/gtsam_unstable/nonlinear/Expression.h
@@ -55,14 +55,14 @@ public:
   /// Construct a nullary method expression
   template<typename E>
   Expression(const Expression<E>& expression,
-      typename NullaryMethodExpression<T, E>::method f) {
+      typename NullaryMethodExpression<T, E>::Method f) {
     // TODO Assert that root of expression is not null.
     root_.reset(new NullaryMethodExpression<T, E>(expression, f));
   }
 
   /// Construct a unary function expression
   template<typename E>
-  Expression(typename UnaryFunctionExpression<T, E>::function f,
+  Expression(typename UnaryFunctionExpression<T, E>::Function f,
       const Expression<E>& expression) {
     // TODO Assert that root of expression is not null.
     root_.reset(new UnaryFunctionExpression<T, E>(f, expression));
@@ -71,7 +71,7 @@ public:
   /// Construct a unary method expression
   template<typename E1, typename E2>
   Expression(const Expression<E1>& expression1,
-      typename UnaryMethodExpression<T, E1, E2>::method f,
+      typename UnaryMethodExpression<T, E1, E2>::Method f,
       const Expression<E2>& expression2) {
     // TODO Assert that root of expressions 1 and 2 are not null.
     root_.reset(new UnaryMethodExpression<T, E1, E2>(expression1, f, expression2));
@@ -79,7 +79,7 @@ public:
 
   /// Construct a binary function expression
   template<typename E1, typename E2>
-  Expression(typename BinaryFunctionExpression<T, E1, E2>::function f,
+  Expression(typename BinaryFunctionExpression<T, E1, E2>::Function f,
       const Expression<E1>& expression1, const Expression<E2>& expression2) {
     // TODO Assert that root of expressions 1 and 2 are not null.
     root_.reset(new BinaryFunctionExpression<T, E1, E2>(f, expression1, expression2));