diff --git a/include/ceres/internal/expression_ref.h b/include/ceres/internal/expression_ref.h
index f4b920f..e0386f0 100644
--- a/include/ceres/internal/expression_ref.h
+++ b/include/ceres/internal/expression_ref.h
@@ -50,7 +50,11 @@
   // Create a compile time constant expression directly from a double value.
   // This is important so that we can write T(3.14) in our code and
   // it's automatically converted to the correct expression.
-  explicit ExpressionRef(double compile_time_constant);
+  //
+  // This constructor is implicit, because the line
+  //    T a(0);
+  // must work for T = Jet<ExpressionRef>.
+  ExpressionRef(double compile_time_constant);
 
   // Create an ASSIGNMENT expression from other to this.
   //
@@ -71,6 +75,7 @@
   //
   // If 'other' is not pointing to a variable (id==invalid), we found an
   // uninitialized assignment, which is handled as an error.
+  ExpressionRef(const ExpressionRef& other);
   ExpressionRef& operator=(const ExpressionRef& other);
 
   // Compound operators
@@ -96,8 +101,45 @@
 ExpressionRef operator/(ExpressionRef x, ExpressionRef y);
 
 // Functions
-// TODO: Add all function supported by Jet.
-ExpressionRef sin(ExpressionRef x);
+
+// Helper function to create a function call expression.
+// Users can generate code for their own custom functions by adding an overload
+// for ExpressionRef that maps to MakeFunctionCall. See below for examples.
+ExpressionRef MakeFunctionCall(const std::string& name,
+                               const std::vector<ExpressionRef>& params);
+
+#define CERES_DEFINE_UNARY_FUNCTION_CALL(name) \
+  inline ExpressionRef name(ExpressionRef x) { \
+    return MakeFunctionCall(#name, {x});       \
+  }
+#define CERES_DEFINE_BINARY_FUNCTION_CALL(name)                 \
+  inline ExpressionRef name(ExpressionRef x, ExpressionRef y) { \
+    return MakeFunctionCall(#name, {x, y});                     \
+  }
+CERES_DEFINE_UNARY_FUNCTION_CALL(abs);
+CERES_DEFINE_UNARY_FUNCTION_CALL(acos);
+CERES_DEFINE_UNARY_FUNCTION_CALL(asin);
+CERES_DEFINE_UNARY_FUNCTION_CALL(atan);
+CERES_DEFINE_UNARY_FUNCTION_CALL(cbrt);
+CERES_DEFINE_UNARY_FUNCTION_CALL(ceil);
+CERES_DEFINE_UNARY_FUNCTION_CALL(cos);
+CERES_DEFINE_UNARY_FUNCTION_CALL(cosh);
+CERES_DEFINE_UNARY_FUNCTION_CALL(exp);
+CERES_DEFINE_UNARY_FUNCTION_CALL(exp2);
+CERES_DEFINE_UNARY_FUNCTION_CALL(floor);
+CERES_DEFINE_UNARY_FUNCTION_CALL(log);
+CERES_DEFINE_UNARY_FUNCTION_CALL(log2);
+CERES_DEFINE_UNARY_FUNCTION_CALL(sin);
+CERES_DEFINE_UNARY_FUNCTION_CALL(sinh);
+CERES_DEFINE_UNARY_FUNCTION_CALL(sqrt);
+CERES_DEFINE_UNARY_FUNCTION_CALL(tan);
+CERES_DEFINE_UNARY_FUNCTION_CALL(tanh);
+
+CERES_DEFINE_BINARY_FUNCTION_CALL(atan2);
+CERES_DEFINE_BINARY_FUNCTION_CALL(pow);
+
+#undef CERES_DEFINE_UNARY_FUNCTION_CALL
+#undef CERES_DEFINE_BINARY_FUNCTION_CALL
 
 // This additonal type is required, so that we can detect invalid conditions
 // during compile time. For example, the following should create a compile time
@@ -142,13 +184,21 @@
 template <typename T>
 struct RuntimeConstant {
   using ReturnType = T;
-  static inline ReturnType Get(double v, const char* name) { return v; }
+  static inline ReturnType Get(double v, const char* /* unused */) { return v; }
+};
+
+template <>
+struct RuntimeConstant<ExpressionRef> {
+  using ReturnType = ExpressionRef;
+  static inline ReturnType Get(double /* unused */, const char* name) {
+    return ExpressionRef::Create(Expression::CreateRuntimeConstant(name));
+  }
 };
 
 template <typename G, int N>
 struct RuntimeConstant<Jet<G, N>> {
   using ReturnType = Jet<G, N>;
-  static inline Jet<G, N> Get(double v, const char* name) {
+  static inline Jet<G, N> Get(double v, const char* /* unused */) {
     return Jet<G, N>(v);
   }
 };
@@ -156,11 +206,11 @@
 template <int N>
 struct RuntimeConstant<Jet<ExpressionRef, N>> {
   using ReturnType = Jet<ExpressionRef, N>;
-  static inline ReturnType Get(double v, const char* name) {
+  static inline ReturnType Get(double /* unused */, const char* name) {
     // Note: The scalar value of v will be thrown away, because we don't need it
     // during code generation.
-    (void)v;
-    return Jet<ExpressionRef, N>(Expression::CreateRuntimeConstant(name));
+    return Jet<ExpressionRef, N>(
+        ExpressionRef::Create(Expression::CreateRuntimeConstant(name)));
   }
 };
 
@@ -173,6 +223,13 @@
 #define CERES_EXPRESSION_RUNTIME_CONSTANT(_v) \
   ceres::internal::MakeRuntimeConstant<T>(_v, #_v)
 
+inline ExpressionRef MakeParameter(const std::string& name) {
+  return ExpressionRef::Create(Expression::CreateParameter(name));
+}
+inline ExpressionRef MakeOutput(ExpressionRef v, const std::string& name) {
+  return ExpressionRef::Create(Expression::CreateOutputAssignment(v.id, name));
+}
+
 // The CERES_CODEGEN macro is defined by the build system only during code
 // generation. In all other cases the CERES_IF/ELSE macros just expand to the
 // if/else keywords.
diff --git a/internal/ceres/conditional_expressions_test.cc b/internal/ceres/conditional_expressions_test.cc
index 72fe3ee..d7b3979 100644
--- a/internal/ceres/conditional_expressions_test.cc
+++ b/internal/ceres/conditional_expressions_test.cc
@@ -55,7 +55,7 @@
 
   // clang-format off
   // Id  Type                   Lhs  Value Name  Arguments
-  TE(0,  COMPILE_TIME_CONSTANT, 0,   2,     "");
+  CHECK_EXPRESSION(0,  COMPILE_TIME_CONSTANT, 0,   2,     "",);
   // clang-format on
 
   // Variables after execution:
@@ -86,9 +86,9 @@
 
   // clang-format off
   // Id, Type, Lhs, Value, Name, Arguments
-  TE(  0,  COMPILE_TIME_CONSTANT,   0,   2,   "",   );
-  TE(  1,  COMPILE_TIME_CONSTANT,   1,   4,   "",   );
-  TE(  2,             ASSIGNMENT,   1,   0,   "",  0);
+  CHECK_EXPRESSION(  0,  COMPILE_TIME_CONSTANT,   0,   2,   "",   );
+  CHECK_EXPRESSION(  1,  COMPILE_TIME_CONSTANT,   1,   4,   "",   );
+  CHECK_EXPRESSION(  2,             ASSIGNMENT,   1,   0,   "",  0);
   // clang-format on
 
   // Variables after execution:
@@ -123,12 +123,12 @@
 
   // clang-format off
   // Id, Type, Lhs, Value, Name, Arguments...
-  TE(  0, COMPILE_TIME_CONSTANT,   0,   2,   "",      );
-  TE(  1, COMPILE_TIME_CONSTANT,   1,   3,   "",      );
-  TE(  2,     BINARY_COMPARISON,   2,   0,  "<",  0, 1);
-  TE(  3,                    IF,  -1,   0,   "",     2);
-  TE(  4,                  ELSE,  -1,   0,   "",      );
-  TE(  5,                 ENDIF,  -1,   0,   "",      );
+  CHECK_EXPRESSION(  0, COMPILE_TIME_CONSTANT,   0,   2,   "",      );
+  CHECK_EXPRESSION(  1, COMPILE_TIME_CONSTANT,   1,   3,   "",      );
+  CHECK_EXPRESSION(  2,     BINARY_COMPARISON,   2,   0,  "<",  0, 1);
+  CHECK_EXPRESSION(  3,                    IF,  -1,   0,   "",     2);
+  CHECK_EXPRESSION(  4,                  ELSE,  -1,   0,   "",      );
+  CHECK_EXPRESSION(  5,                 ENDIF,  -1,   0,   "",      );
   // clang-format on
 }
 
@@ -162,17 +162,17 @@
 
   // clang-format off
   // Id,   Type,                  Lhs, Value, Name, Arguments...
-  TE(  0,  COMPILE_TIME_CONSTANT,    0,    2,   "",      );
-  TE(  1,  COMPILE_TIME_CONSTANT,    1,    3,   "",      );
-  TE(  2,      BINARY_COMPARISON,    2,    0,  "<",  0, 1);
-  TE(  3,                     IF,   -1,    0,   "",     2);
-  TE(  4,      BINARY_ARITHMETIC,    4,    0,  "+",  0, 1);
-  TE(  5,                   ELSE,   -1,    0,   "",      );
-  TE(  6,      BINARY_ARITHMETIC,    6,    0,  "-",  0, 1);
-  TE(  7,             ASSIGNMENT,    4,    0,   "",  6   );
-  TE(  8,                  ENDIF,   -1,    0,   "",      );
-  TE(  9,      BINARY_ARITHMETIC,    9,    0,  "+",  4, 0);
-  TE( 10,             ASSIGNMENT,    4,    0,   "",  9   );
+  CHECK_EXPRESSION(  0,  COMPILE_TIME_CONSTANT,    0,    2,   "",      );
+  CHECK_EXPRESSION(  1,  COMPILE_TIME_CONSTANT,    1,    3,   "",      );
+  CHECK_EXPRESSION(  2,      BINARY_COMPARISON,    2,    0,  "<",  0, 1);
+  CHECK_EXPRESSION(  3,                     IF,   -1,    0,   "",     2);
+  CHECK_EXPRESSION(  4,      BINARY_ARITHMETIC,    4,    0,  "+",  0, 1);
+  CHECK_EXPRESSION(  5,                   ELSE,   -1,    0,   "",      );
+  CHECK_EXPRESSION(  6,      BINARY_ARITHMETIC,    6,    0,  "-",  0, 1);
+  CHECK_EXPRESSION(  7,             ASSIGNMENT,    4,    0,   "",  6   );
+  CHECK_EXPRESSION(  8,                  ENDIF,   -1,    0,   "",      );
+  CHECK_EXPRESSION(  9,      BINARY_ARITHMETIC,    9,    0,  "+",  4, 0);
+  CHECK_EXPRESSION( 10,             ASSIGNMENT,    4,    0,   "",  9   );
   // clang-format on
 
   // Variables after execution:
diff --git a/internal/ceres/expression_ref.cc b/internal/ceres/expression_ref.cc
index 224a3bf..7c2bc5d 100644
--- a/internal/ceres/expression_ref.cc
+++ b/internal/ceres/expression_ref.cc
@@ -44,6 +44,8 @@
   id = Expression::CreateCompileTimeConstant(compile_time_constant);
 }
 
+ExpressionRef::ExpressionRef(const ExpressionRef& other) { *this = other; }
+
 ExpressionRef& ExpressionRef::operator=(const ExpressionRef& other) {
   // Assigning an uninitialized variable to another variable is an error.
   CHECK(other.IsInitialized()) << "Uninitialized Assignment.";
@@ -111,8 +113,13 @@
 }
 
 // Functions
-ExpressionRef sin(ExpressionRef x) {
-  return ExpressionRef::Create(Expression::CreateFunctionCall("sin", {x.id}));
+ExpressionRef MakeFunctionCall(const std::string& name,
+                               const std::vector<ExpressionRef>& params) {
+  std::vector<ExpressionId> ids;
+  for (auto p : params) {
+    ids.push_back(p.id);
+  }
+  return ExpressionRef::Create(Expression::CreateFunctionCall(name, ids));
 }
 
 ExpressionRef Ternary(ComparisonExpressionRef c,
diff --git a/internal/ceres/expression_test.cc b/internal/ceres/expression_test.cc
index d020192..a8a8213 100644
--- a/internal/ceres/expression_test.cc
+++ b/internal/ceres/expression_test.cc
@@ -31,10 +31,8 @@
 
 #define CERES_CODEGEN
 
-#include "ceres/internal/expression_graph.h"
-#include "ceres/internal/expression_ref.h"
-
-#include "gtest/gtest.h"
+#include "ceres/expression_test.h"
+#include "ceres/jet.h"
 
 namespace ceres {
 namespace internal {
@@ -115,6 +113,51 @@
   ASSERT_TRUE(graph.ExpressionForId(d.id).DirectlyDependsOn(c.id));
 }
 
+TEST(Expression, Jet) {
+  using T = Jet<ExpressionRef, 1>;
+
+  StartRecordingExpressions();
+
+  T a(2, 0);
+  T b = a * a;
+
+  auto graph = StopRecordingExpressions();
+
+  // b is valid during the assignment so we expect an
+  // additional assignment expression.
+  EXPECT_EQ(graph.Size(), 8);
+
+  // Expected code
+  //   v_0 = 2;
+  //   v_1 = 0;
+  //   v_2 = 1;
+  //   v_1 = v_2;
+  //   v_3 = v_0 * v_0;
+  //   v_4 = v_0 * v_1;
+  //   v_5 = v_1 * v_0;
+  //   v_6 = v_3 * v_4;
+  //   v_7 = v_5 * v_6;
+
+  // clang-format off
+  // Id, Type, Lhs, Value, Name, Arguments
+  CHECK_EXPRESSION(  0,  COMPILE_TIME_CONSTANT,   0,   2,   "",     );
+  CHECK_EXPRESSION(  1,  COMPILE_TIME_CONSTANT,   1,   0,   "",     );
+  CHECK_EXPRESSION(  2,  COMPILE_TIME_CONSTANT,   2,   1,   "",     );
+  CHECK_EXPRESSION(  3,             ASSIGNMENT,   1,   0,   "", 2   );
+  CHECK_EXPRESSION(  4,      BINARY_ARITHMETIC,   4,   0,  "*", 0, 0);
+  CHECK_EXPRESSION(  5,      BINARY_ARITHMETIC,   5,   0,  "*", 0, 1);
+  CHECK_EXPRESSION(  6,      BINARY_ARITHMETIC,   6,   0,  "*", 1, 0);
+  CHECK_EXPRESSION(  7,      BINARY_ARITHMETIC,   7,   0,  "+", 5, 6);
+  // clang-format on
+
+  // Variables after execution:
+  //
+  // b.a         <=> v_4
+  // b.v[0]      <=> v_7
+  EXPECT_EQ(b.a.id, 4);
+  EXPECT_EQ(b.v[0].id, 7);
+}
+
 // Todo: remaining functions of Expression
 
 }  // namespace internal
diff --git a/internal/ceres/expression_test.h b/internal/ceres/expression_test.h
index de9e2c2..2be7f8e 100644
--- a/internal/ceres/expression_test.h
+++ b/internal/ceres/expression_test.h
@@ -55,12 +55,12 @@
   EXPECT_EQ(expr.arguments(), arguments);
 }
 
-#define TE(_id, _type, _lhs_id, _value, _name, ...) \
-  TestExpression(graph.ExpressionForId(_id),        \
-                 ExpressionType::_type,             \
-                 _lhs_id,                           \
-                 _value,                            \
-                 _name,                             \
+#define CHECK_EXPRESSION(_id, _type, _lhs_id, _value, _name, ...) \
+  TestExpression(graph.ExpressionForId(_id),                      \
+                 ExpressionType::_type,                           \
+                 _lhs_id,                                         \
+                 _value,                                          \
+                 _name,                                           \
                  {__VA_ARGS__})
 
 }  // namespace internal