diff --git a/vtkm/cont/ArrayHandleCompositeVector.h b/vtkm/cont/ArrayHandleCompositeVector.h
index f506b3b2d..cd504d7e0 100644
--- a/vtkm/cont/ArrayHandleCompositeVector.h
+++ b/vtkm/cont/ArrayHandleCompositeVector.h
@@ -30,6 +30,8 @@
 
 #include <boost/static_assert.hpp>
 
+#include <sstream>
+
 namespace vtkm {
 namespace cont {
 
@@ -128,16 +130,17 @@ struct CompositeVectorArrayToPortalCont {
 
 template<typename DeviceAdapterTag>
 struct CompositeVectorArrayToPortalExec {
-  template<typename ArrayHandleType>
+  template<typename ArrayHandleType, vtkm::IdComponent Index>
   struct ReturnType {
     typedef typename ArrayHandleType::template ExecutionTypes<
           DeviceAdapterTag>::PortalConst type;
   };
 
-  template<typename ArrayHandleType>
+  template<typename ArrayHandleType, vtkm::IdComponent Index>
   VTKM_CONT_EXPORT
-  typename ReturnType<ArrayHandleType>::type
-  operator()(const ArrayHandleType &array) const {
+  typename ReturnType<ArrayHandleType, Index>::type
+  operator()(const ArrayHandleType &array,
+             vtkm::internal::IndexTag<Index>) const {
     return array.PrepareForInput(DeviceAdapterTag());
   }
 };
@@ -146,12 +149,15 @@ struct CheckArraySizeFunctor {
   vtkm::Id ExpectedSize;
   CheckArraySizeFunctor(vtkm::Id expectedSize) : ExpectedSize(expectedSize) {  }
 
-  template<typename T>
-  void operator()(const T &a) const {
+  template<typename T, vtkm::IdComponent Index>
+  void operator()(const T &a, vtkm::internal::IndexTag<Index>) const {
     if (a.GetNumberOfValues() != this->ExpectedSize)
     {
-      throw vtkm::cont::ErrorControlBadValue(
-            "All input arrays to ArrayHandleCompositeVector must be the same size.");
+      std::stringstream message;
+      message << "All input arrays to ArrayHandleCompositeVector must be the same size.\n"
+              << "Array " << Index-1 << " has " << a.GetNumberOfValues()
+              << ". Expected " << this->ExpectedSize << ".";
+      throw vtkm::cont::ErrorControlBadValue(message.str().c_str());
     }
   }
 };
diff --git a/vtkm/cont/internal/DynamicTransform.h b/vtkm/cont/internal/DynamicTransform.h
index d2f695ab8..c4cb63a48 100644
--- a/vtkm/cont/internal/DynamicTransform.h
+++ b/vtkm/cont/internal/DynamicTransform.h
@@ -20,7 +20,7 @@
 #ifndef vtk_m_cont_internal_DynamicTransform_h
 #define vtk_m_cont_internal_DynamicTransform_h
 
-#include "vtkm/internal/ExportMacros.h"
+#include "vtkm/internal/IndexTag.h"
 
 namespace vtkm {
 namespace cont {
@@ -62,10 +62,13 @@ struct DynamicTransformTraits {
 ///
 struct DynamicTransform
 {
-  template<typename InputType, typename ContinueFunctor>
+  template<typename InputType,
+           typename ContinueFunctor,
+           vtkm::IdComponent Index>
   VTKM_CONT_EXPORT
   void operator()(const InputType &input,
-                  const ContinueFunctor &continueFunc) const
+                  const ContinueFunctor &continueFunc,
+                  vtkm::internal::IndexTag<Index>) const
   {
     this->DoTransform(
           input,
diff --git a/vtkm/cont/internal/testing/UnitTestDynamicTransform.cxx b/vtkm/cont/internal/testing/UnitTestDynamicTransform.cxx
index ffa8ef58a..e3ab8902d 100644
--- a/vtkm/cont/internal/testing/UnitTestDynamicTransform.cxx
+++ b/vtkm/cont/internal/testing/UnitTestDynamicTransform.cxx
@@ -85,22 +85,24 @@ void TestBasicTransform()
   std::cout << "Testing basic transform." << std::endl;
 
   vtkm::cont::internal::DynamicTransform transform;
+  vtkm::internal::IndexTag<1> indexTag;
 
   std::cout << "  Trying with simple scalar." << std::endl;
-  TRY_TRANSFORM(transform(vtkm::FloatDefault(5), ScalarFunctor()));
+  TRY_TRANSFORM(transform(vtkm::FloatDefault(5), ScalarFunctor(), indexTag));
 
   std::cout << "  Trying with basic scalar array." << std::endl;
   vtkm::cont::ArrayHandle<vtkm::FloatDefault> concreteArray;
-  TRY_TRANSFORM(transform(concreteArray, ArrayHandleScalarFunctor()));
+  TRY_TRANSFORM(transform(concreteArray, ArrayHandleScalarFunctor(), indexTag));
 
   std::cout << "  Trying scalar dynamic array." << std::endl;
   vtkm::cont::DynamicArrayHandle dynamicArray = concreteArray;
-  TRY_TRANSFORM(transform(dynamicArray, ArrayHandleScalarFunctor()));
+  TRY_TRANSFORM(transform(dynamicArray, ArrayHandleScalarFunctor(), indexTag));
 
   std::cout << "  Trying with unusual (string) dynamic array." << std::endl;
   dynamicArray = vtkm::cont::ArrayHandle<std::string>();
   TRY_TRANSFORM(transform(dynamicArray.ResetTypeList(TypeListTagString()),
-                          ArrayHandleStringFunctor()));
+                          ArrayHandleStringFunctor(),
+                          indexTag));
 }
 
 void TestFunctionTransform()
diff --git a/vtkm/internal/CMakeLists.txt b/vtkm/internal/CMakeLists.txt
index dbf855514..f4d5d38ca 100644
--- a/vtkm/internal/CMakeLists.txt
+++ b/vtkm/internal/CMakeLists.txt
@@ -25,6 +25,7 @@ set(headers
   FunctionInterface.h
   FunctionInterfaceDetailPost.h
   FunctionInterfaceDetailPre.h
+  IndexTag.h
   Invocation.h
   ListTagDetail.h
   )
diff --git a/vtkm/internal/FunctionInterface.h b/vtkm/internal/FunctionInterface.h
index 44c0dc3be..c26281fc0 100644
--- a/vtkm/internal/FunctionInterface.h
+++ b/vtkm/internal/FunctionInterface.h
@@ -20,9 +20,10 @@
 #ifndef vtk_m_internal_FunctionInterface_h
 #define vtk_m_internal_FunctionInterface_h
 
-#include <vtkm/Pair.h>
 #include <vtkm/Types.h>
 
+#include <vtkm/internal/IndexTag.h>
+
 #include <boost/function_types/components.hpp>
 #include <boost/function_types/function_arity.hpp>
 #include <boost/function_types/function_type.hpp>
@@ -301,27 +302,75 @@ public:
   }
 
   /// Gets the value for the parameter of the given index. Parameters are
-  /// indexed starting at 1. To use this method you have to specify the index
-  /// as a template parameter. If you are using FunctionInterface within a
-  /// template (which is almost always the case), then you will have to use the
-  /// template keyword. For example, here is a simple implementation of a
-  /// method that grabs the first parameter of FunctionInterface.
+  /// indexed starting at 1. To use this method you have to specify a static,
+  /// compile time index. There are two ways to specify the index. The first is
+  /// to specify a specific template parameter (e.g.
+  /// <tt>GetParameter<1>()</tt>). Note that if you are using FunctionInterface
+  /// within a template (which is almost always the case), then you will have
+  /// to use the template keyword. For example, here is a simple implementation
+  /// of a method that grabs the first parameter of FunctionInterface.
   ///
   /// \code{.cpp}
   /// template<FunctionSignature>
-  /// void Foo(const vtkm::cont::internal::FunctionInterface<FunctionSignature> &fInterface)
+  /// void Foo(const vtkm::internal::FunctionInterface<FunctionSignature> &fInterface)
   /// {
   ///   bar(fInterface.template GetParameter<1>());
   /// }
   /// \endcode
   ///
+  /// Alternatively the \c GetParameter method also has an optional argument
+  /// that can be a \c IndexTag that specifies the parameter index. Here is
+  /// a repeat of the previous example using this method.
+  ///
+  /// \code{.cpp}
+  /// template<FunctionSignature>
+  /// void Foo(const vtkm::internal::FunctionInterface<FunctionSignature> &fInterface)
+  /// {
+  ///   using vtkm::internal::IndexTag;
+  ///   bar(fInterface.GetParameter(IndexTag<1>()));
+  /// }
+  /// \endcode
+  ///
   template<vtkm::IdComponent ParameterIndex>
   VTKM_EXEC_CONT_EXPORT
   typename ParameterType<ParameterIndex>::type
-  GetParameter() const {
+  GetParameter(
+      vtkm::internal::IndexTag<ParameterIndex> =
+        vtkm::internal::IndexTag<ParameterIndex>()) const {
     return detail::GetParameter<ParameterIndex>(this->Parameters);
   }
 
+  /// Sets the value for the parameter of the given index. Parameters are
+  /// indexed starting at 1. To use this method you have to specify a static,
+  /// compile time index. There are two ways to specify the index. The first is
+  /// to specify a specific template parameter (e.g.
+  /// <tt>SetParameter<1>(value)</tt>). Note that if you are using
+  /// FunctionInterface within a template (which is almost always the case),
+  /// then you will have to use the template keyword. For example, here is a
+  /// simple implementation of a method that grabs the first parameter of
+  /// FunctionInterface.
+  ///
+  /// \code{.cpp}
+  /// template<FunctionSignature>
+  /// void Foo(vtkm::internal::FunctionInterface<FunctionSignature> &fInterface)
+  /// {
+  ///   fInterface.template SetParameter<1>(bar);
+  /// }
+  /// \endcode
+  ///
+  /// Alternatively the \c GetParameter method also has an optional argument
+  /// that can be a \c IndexTag that specifies the parameter index. Here is
+  /// a repeat of the previous example using this method.
+  ///
+  /// \code{.cpp}
+  /// template<FunctionSignature>
+  /// void Foo(vtkm::internal::FunctionInterface<FunctionSignature> &fInterface)
+  /// {
+  ///   using vtkm::internal::IndexTag;
+  ///   fInterface.SetParameter(bar, IndexTag<1>());
+  /// }
+  /// \endcode
+  ///
   /// Sets the value for the parameter of the given index. Parameters are
   /// indexed starting at 1. To use this method you have to specify the index
   /// as a template parameter. If you are using FunctionInterface within a
@@ -330,7 +379,10 @@ public:
   ///
   template<vtkm::IdComponent ParameterIndex>
   VTKM_EXEC_CONT_EXPORT
-  void SetParameter(typename ParameterType<ParameterIndex>::type parameter)
+  void SetParameter(
+      typename ParameterType<ParameterIndex>::type parameter,
+      vtkm::internal::IndexTag<ParameterIndex> =
+        vtkm::internal::IndexTag<ParameterIndex>())
   {
     detail::SetParameter<ParameterIndex>(this->Parameters, parameter);
   }
@@ -461,15 +513,47 @@ public:
 
   /// Returns a new \c FunctionInterface with all the parameters of this \c
   /// FunctionInterface except that the parameter indexed at the template
-  /// parameter \c ParameterIndex is replaced with the given argument. This
-  /// method can be used in place of SetParameter when the parameter type
-  /// changes. The return type can be determined with the \c ReplaceType
-  /// template.
+  /// parameter \c ParameterIndex (also specified with the optional second
+  /// argument) is replaced with the given argument. This method can be used in
+  /// place of SetParameter when the parameter type changes. The return type
+  /// can be determined with the \c ReplaceType template.
+  /// Gets the value for the parameter of the given index. Parameters are
+  /// indexed starting at 1. To use this method you have to specify a static,
+  /// compile time index. There are two ways to specify the index. The first is
+  /// to specify a specific template parameter (e.g.
+  /// <tt>GetParameter<1>()</tt>). Note that if you are using FunctionInterface
+  /// within a template (which is almost always the case), then you will have
+  /// to use the template keyword. For example, here is a simple implementation
+  /// of a method that grabs the first parameter of FunctionInterface.
+  ///
+  /// \code{.cpp}
+  /// template<FunctionSignature>
+  /// void Foo(const vtkm::internal::FunctionInterface<FunctionSignature> &fInterface)
+  /// {
+  ///   bar(fInterface.template GetParameter<1>());
+  /// }
+  /// \endcode
+  ///
+  /// Alternatively the \c GetParameter method also has an optional argument
+  /// that can be a \c IndexTag that specifies the parameter index. Here is
+  /// a repeat of the previous example using this method.
+  ///
+  /// \code{.cpp}
+  /// template<FunctionSignature>
+  /// void Foo(const vtkm::internal::FunctionInterface<FunctionSignature> &fInterface)
+  /// {
+  ///   using vtkm::internal::IndexTag;
+  ///   bar(fInterface.GetParameter(IndexTag<1>()));
+  /// }
+  /// \endcode
+  ///
   ///
   template<vtkm::IdComponent ParameterIndex, typename NewType>
   VTKM_EXEC_CONT_EXPORT
   typename ReplaceType<ParameterIndex, NewType>::type
-  Replace(NewType newParameter) const {
+  Replace(NewType newParameter,
+          vtkm::internal::IndexTag<ParameterIndex> =
+            vtkm::internal::IndexTag<ParameterIndex>()) const {
     typename ReplaceType<ParameterIndex, NewType>::type replacedFuncInterface;
     detail::FunctionInterfaceCopyParameters<ParameterIndex-1>::
         Copy(replacedFuncInterface.Parameters, this->Parameters);
@@ -491,11 +575,13 @@ public:
   ///
   /// The \c StaticTransform methods transform all the parameters of this \c
   /// FunctionInterface to different types and values based on compile-time
-  /// information. It operates by accepting a functor that defines a unary
-  /// function whose argument is the parameter to transform and the return
-  /// value is the transformed value. The functor must also contain a templated
-  /// struct name ReturnType with an internal type named \c type that defines
-  /// the return type of the transform for a given input type.
+  /// information. It operates by accepting a functor that two arguments. The
+  /// first argument is the parameter to transform and the second argument is
+  /// an \c IndexTag specifying the index of the parameter (which can be
+  /// ignored in many cases). The functor's return value is the transformed
+  /// value. The functor must also contain a templated struct name ReturnType
+  /// with an internal type named \c type that defines the return type of the
+  /// transform for a given input type and parameter index.
   ///
   /// The transformation is only applied to the parameters of the function. The
   /// return argument is unaffected.
@@ -509,14 +595,14 @@ public:
   ///
   /// \code
   /// struct MyTransformFunctor {
-  ///   template<typename T>
+  ///   template<typename T, vtkm::IdComponent Index>
   ///   struct ReturnType {
   ///     typedef const T *type;
   ///   };
   ///
-  ///   template<typename T>
+  ///   template<typename T, vtkm::IdComponent Index>
   ///   VTKM_CONT_EXPORT
-  ///   const T *operator()(const T &x) const {
+  ///   const T *operator()(const T &x, vtkm::internal::IndexTag<Index>) const {
   ///     return &x;
   ///   }
   /// };
@@ -557,10 +643,11 @@ public:
   /// The \c DynamicTransform method transforms all the parameters of this \c
   /// FunctionInterface to different types and values based on run-time
   /// information. It operates by accepting two functors. The first functor
-  /// accepts two arguments. The first argument is a parameter to transform and
-  /// the second is a functor to call with the transformed result.
+  /// accepts three arguments. The first argument is a parameter to transform,
+  /// the second is a functor to call with the transformed result, and the third
+  /// is an instance of \c IndexTag denoting the index parameter..
   ///
-  /// The second argument to \c DynamicTransform is another function that
+  /// The second argument to \c DynamicTransform is another functor that
   /// accepts the transformed \c FunctionInterface and does something. If that
   /// transformed \c FunctionInterface has a return value, that return value
   /// will be passed back to this \c FunctionInterface.
@@ -568,23 +655,27 @@ public:
   /// Here is a contrived but illustrative example. This transformation will
   /// pass all arguments except any string that looks like a number will be
   /// converted to a vtkm::FloatDefault. Note that because the types are not
-  /// determined till runtime, this transform cannot be determined at compile
+  /// determined until runtime, this transform cannot be determined at compile
   /// time with meta-template programming.
   ///
   /// \code
   /// struct MyTransformFunctor {
-  ///   template<typename InputType, typename ContinueFunctor>
+  ///   template<typename InputType,
+  ///            typename ContinueFunctor,
+  ///            vtkm::IdComponent Index>
   ///   VTKM_CONT_EXPORT
   ///   void operator()(const InputType &input,
-  ///                   const ContinueFunctor &continueFunc) const
+  ///                   const ContinueFunctor &continueFunc,
+  ///                   vtkm::internal::IndexTag<Index>) const
   ///   {
   ///     continueFunc(input);
   ///   }
   ///
-  ///   template<typename ContinueFunctor>
+  ///   template<typename ContinueFunctor, vtkm::IdComponent Index>
   ///   VTKM_CONT_EXPORT
   ///   void operator()(const std::string &input,
-  ///                   const ContinueFunctor &continueFunc) const
+  ///                   const ContinueFunctor &continueFunc,
+  ///                   vtkm::internal::IndexTag<Index>) const
   ///   {
   ///     if ((input[0] >= '0' && (input[0] <= '9'))
   ///     {
@@ -642,9 +733,11 @@ public:
 
   /// \brief Applies a function to all the parameters.
   ///
-  /// The \c ForEach methods take a function and apply that function to each
-  /// of the parameters in the \c FunctionInterface. (Return values are not
-  /// effected.)
+  /// The \c ForEach methods take a functor and apply that functor to each of
+  /// the parameters in the \c FunctionInterface. (Return values are not
+  /// effected.) The first argument of the functor is the parameter value and
+  /// the second argument is an \c IndexTag, which can be used to identify the
+  /// index of the parameter.
   ///
   template<typename Functor>
   VTKM_CONT_EXPORT
@@ -721,8 +814,12 @@ public:
                                                      nextInterface,
                                                      this->Transform,
                                                      this->Finish);
-    this->Transform(this->OriginalInterface.template GetParameter<vtkm::internal::FunctionInterface<NextFunction>::ARITY + 1>(),
-                    nextContinue);
+    static const vtkm::IdComponent Index =
+        vtkm::internal::FunctionInterface<NextFunction>::ARITY + 1;
+    vtkm::internal::IndexTag<Index> indexTag;
+    this->Transform(this->OriginalInterface.GetParameter(indexTag),
+                    nextContinue,
+                    indexTag);
   }
 
   template<typename NextFunction>
diff --git a/vtkm/internal/FunctionInterfaceDetailPost.h b/vtkm/internal/FunctionInterfaceDetailPost.h
index 7adbf6197..5ae107519 100644
--- a/vtkm/internal/FunctionInterfaceDetailPost.h
+++ b/vtkm/internal/FunctionInterfaceDetailPost.h
@@ -53,7 +53,7 @@ template<typename Transform,
          typename P1>
 struct FunctionInterfaceStaticTransformType<R(P1), Transform> {
   typedef R(type)(
-        typename Transform::template ReturnType<P1>::type
+        typename Transform::template ReturnType<P1,1>::type
         );
 };
 
@@ -63,8 +63,8 @@ template<typename Transform,
          typename P2>
 struct FunctionInterfaceStaticTransformType<R(P1,P2), Transform> {
   typedef R(type)(
-        typename Transform::template ReturnType<P1>::type,
-        typename Transform::template ReturnType<P2>::type
+        typename Transform::template ReturnType<P1,1>::type,
+        typename Transform::template ReturnType<P2,2>::type
         );
 };
 
@@ -75,9 +75,9 @@ template<typename Transform,
          typename P3>
 struct FunctionInterfaceStaticTransformType<R(P1,P2,P3), Transform> {
   typedef R(type)(
-        typename Transform::template ReturnType<P1>::type,
-        typename Transform::template ReturnType<P2>::type,
-        typename Transform::template ReturnType<P3>::type
+        typename Transform::template ReturnType<P1,1>::type,
+        typename Transform::template ReturnType<P2,2>::type,
+        typename Transform::template ReturnType<P3,3>::type
         );
 };
 
@@ -89,10 +89,10 @@ template<typename Transform,
          typename P4>
 struct FunctionInterfaceStaticTransformType<R(P1,P2,P3,P4), Transform> {
   typedef R(type)(
-        typename Transform::template ReturnType<P1>::type,
-        typename Transform::template ReturnType<P2>::type,
-        typename Transform::template ReturnType<P3>::type,
-        typename Transform::template ReturnType<P4>::type
+        typename Transform::template ReturnType<P1,1>::type,
+        typename Transform::template ReturnType<P2,2>::type,
+        typename Transform::template ReturnType<P3,3>::type,
+        typename Transform::template ReturnType<P4,4>::type
         );
 };
 
@@ -105,11 +105,11 @@ template<typename Transform,
          typename P5>
 struct FunctionInterfaceStaticTransformType<R(P1,P2,P3,P4,P5), Transform> {
   typedef R(type)(
-        typename Transform::template ReturnType<P1>::type,
-        typename Transform::template ReturnType<P2>::type,
-        typename Transform::template ReturnType<P3>::type,
-        typename Transform::template ReturnType<P4>::type,
-        typename Transform::template ReturnType<P5>::type
+        typename Transform::template ReturnType<P1,1>::type,
+        typename Transform::template ReturnType<P2,2>::type,
+        typename Transform::template ReturnType<P3,3>::type,
+        typename Transform::template ReturnType<P4,4>::type,
+        typename Transform::template ReturnType<P5,5>::type
         );
 };
 
@@ -123,12 +123,12 @@ template<typename Transform,
          typename P6>
 struct FunctionInterfaceStaticTransformType<R(P1,P2,P3,P4,P5,P6), Transform> {
   typedef R(type)(
-        typename Transform::template ReturnType<P1>::type,
-        typename Transform::template ReturnType<P2>::type,
-        typename Transform::template ReturnType<P3>::type,
-        typename Transform::template ReturnType<P4>::type,
-        typename Transform::template ReturnType<P5>::type,
-        typename Transform::template ReturnType<P6>::type
+        typename Transform::template ReturnType<P1,1>::type,
+        typename Transform::template ReturnType<P2,2>::type,
+        typename Transform::template ReturnType<P3,3>::type,
+        typename Transform::template ReturnType<P4,4>::type,
+        typename Transform::template ReturnType<P5,5>::type,
+        typename Transform::template ReturnType<P6,6>::type
         );
 };
 
@@ -143,13 +143,13 @@ template<typename Transform,
          typename P7>
 struct FunctionInterfaceStaticTransformType<R(P1,P2,P3,P4,P5,P6,P7), Transform> {
   typedef R(type)(
-        typename Transform::template ReturnType<P1>::type,
-        typename Transform::template ReturnType<P2>::type,
-        typename Transform::template ReturnType<P3>::type,
-        typename Transform::template ReturnType<P4>::type,
-        typename Transform::template ReturnType<P5>::type,
-        typename Transform::template ReturnType<P6>::type,
-        typename Transform::template ReturnType<P7>::type
+        typename Transform::template ReturnType<P1,1>::type,
+        typename Transform::template ReturnType<P2,2>::type,
+        typename Transform::template ReturnType<P3,3>::type,
+        typename Transform::template ReturnType<P4,4>::type,
+        typename Transform::template ReturnType<P5,5>::type,
+        typename Transform::template ReturnType<P6,6>::type,
+        typename Transform::template ReturnType<P7,7>::type
         );
 };
 
@@ -165,14 +165,14 @@ template<typename Transform,
          typename P8>
 struct FunctionInterfaceStaticTransformType<R(P1,P2,P3,P4,P5,P6,P7,P8), Transform> {
   typedef R(type)(
-        typename Transform::template ReturnType<P1>::type,
-        typename Transform::template ReturnType<P2>::type,
-        typename Transform::template ReturnType<P3>::type,
-        typename Transform::template ReturnType<P4>::type,
-        typename Transform::template ReturnType<P5>::type,
-        typename Transform::template ReturnType<P6>::type,
-        typename Transform::template ReturnType<P7>::type,
-        typename Transform::template ReturnType<P8>::type
+        typename Transform::template ReturnType<P1,1>::type,
+        typename Transform::template ReturnType<P2,2>::type,
+        typename Transform::template ReturnType<P3,3>::type,
+        typename Transform::template ReturnType<P4,4>::type,
+        typename Transform::template ReturnType<P5,5>::type,
+        typename Transform::template ReturnType<P6,6>::type,
+        typename Transform::template ReturnType<P7,7>::type,
+        typename Transform::template ReturnType<P8,8>::type
         );
 };
 
@@ -189,15 +189,15 @@ template<typename Transform,
          typename P9>
 struct FunctionInterfaceStaticTransformType<R(P1,P2,P3,P4,P5,P6,P7,P8,P9), Transform> {
   typedef R(type)(
-        typename Transform::template ReturnType<P1>::type,
-        typename Transform::template ReturnType<P2>::type,
-        typename Transform::template ReturnType<P3>::type,
-        typename Transform::template ReturnType<P4>::type,
-        typename Transform::template ReturnType<P5>::type,
-        typename Transform::template ReturnType<P6>::type,
-        typename Transform::template ReturnType<P7>::type,
-        typename Transform::template ReturnType<P8>::type,
-        typename Transform::template ReturnType<P9>::type
+        typename Transform::template ReturnType<P1,1>::type,
+        typename Transform::template ReturnType<P2,2>::type,
+        typename Transform::template ReturnType<P3,3>::type,
+        typename Transform::template ReturnType<P4,4>::type,
+        typename Transform::template ReturnType<P5,5>::type,
+        typename Transform::template ReturnType<P6,6>::type,
+        typename Transform::template ReturnType<P7,7>::type,
+        typename Transform::template ReturnType<P8,8>::type,
+        typename Transform::template ReturnType<P9,9>::type
         );
 };
 
@@ -215,16 +215,16 @@ template<typename Transform,
          typename P10>
 struct FunctionInterfaceStaticTransformType<R(P1,P2,P3,P4,P5,P6,P7,P8,P9,P10), Transform> {
   typedef R(type)(
-        typename Transform::template ReturnType<P1>::type,
-        typename Transform::template ReturnType<P2>::type,
-        typename Transform::template ReturnType<P3>::type,
-        typename Transform::template ReturnType<P4>::type,
-        typename Transform::template ReturnType<P5>::type,
-        typename Transform::template ReturnType<P6>::type,
-        typename Transform::template ReturnType<P7>::type,
-        typename Transform::template ReturnType<P8>::type,
-        typename Transform::template ReturnType<P9>::type,
-        typename Transform::template ReturnType<P10>::type
+        typename Transform::template ReturnType<P1,1>::type,
+        typename Transform::template ReturnType<P2,2>::type,
+        typename Transform::template ReturnType<P3,3>::type,
+        typename Transform::template ReturnType<P4,4>::type,
+        typename Transform::template ReturnType<P5,5>::type,
+        typename Transform::template ReturnType<P6,6>::type,
+        typename Transform::template ReturnType<P7,7>::type,
+        typename Transform::template ReturnType<P8,8>::type,
+        typename Transform::template ReturnType<P9,9>::type,
+        typename Transform::template ReturnType<P10,10>::type
         );
 };
 
diff --git a/vtkm/internal/FunctionInterfaceDetailPost.h.in b/vtkm/internal/FunctionInterfaceDetailPost.h.in
index 380c43ce4..6cc3498f6 100644
--- a/vtkm/internal/FunctionInterfaceDetailPost.h.in
+++ b/vtkm/internal/FunctionInterfaceDetailPost.h.in
@@ -94,7 +94,7 @@ template<typename Transform,
 struct FunctionInterfaceStaticTransformType<$signature(num_params), Transform> {
   typedef $ptype(0)(type)(
 $for(param_index in xrange(1, num_params+1))\
-        typename Transform::template ReturnType<$ptype(param_index)>::type$comma_if(param_index<num_params)
+        typename Transform::template ReturnType<$ptype(param_index),$(param_index)>::type$comma_if(param_index<num_params)
 $endfor\
         );
 };
diff --git a/vtkm/internal/FunctionInterfaceDetailPre.h b/vtkm/internal/FunctionInterfaceDetailPre.h
index 69fefc2bc..4599e4de8 100644
--- a/vtkm/internal/FunctionInterfaceDetailPre.h
+++ b/vtkm/internal/FunctionInterfaceDetailPre.h
@@ -28,6 +28,7 @@
 #endif
 
 #include <vtkm/Types.h>
+#include <vtkm/internal/IndexTag.h>
 
 #include <boost/function_types/function_type.hpp>
 #include <boost/mpl/at.hpp>
@@ -2478,7 +2479,8 @@ void DoStaticTransformCont(
       const ParameterContainer<OriginalR(OriginalP1)> &originalParameters,
       ParameterContainer<TransformedR(TransformedP1)> &transformedParameters)
 {
-  transformedParameters.Parameter1 = transform(originalParameters.Parameter1);
+  transformedParameters.Parameter1 =
+    transform(originalParameters.Parameter1, vtkm::internal::IndexTag<1>());
 }
 
 template<typename Transform,
@@ -2492,7 +2494,8 @@ void DoStaticTransformExec(
       const ParameterContainer<OriginalR(OriginalP1)> &originalParameters,
       ParameterContainer<TransformedR(TransformedP1)> &transformedParameters)
 {
-  transformedParameters.Parameter1 = transform(originalParameters.Parameter1);
+  transformedParameters.Parameter1 =
+    transform(originalParameters.Parameter1, vtkm::internal::IndexTag<1>());
 }
 
 template<typename Transform,
@@ -2508,8 +2511,10 @@ void DoStaticTransformCont(
       const ParameterContainer<OriginalR(OriginalP1,OriginalP2)> &originalParameters,
       ParameterContainer<TransformedR(TransformedP1,TransformedP2)> &transformedParameters)
 {
-  transformedParameters.Parameter1 = transform(originalParameters.Parameter1);
-  transformedParameters.Parameter2 = transform(originalParameters.Parameter2);
+  transformedParameters.Parameter1 =
+    transform(originalParameters.Parameter1, vtkm::internal::IndexTag<1>());
+  transformedParameters.Parameter2 =
+    transform(originalParameters.Parameter2, vtkm::internal::IndexTag<2>());
 }
 
 template<typename Transform,
@@ -2525,8 +2530,10 @@ void DoStaticTransformExec(
       const ParameterContainer<OriginalR(OriginalP1,OriginalP2)> &originalParameters,
       ParameterContainer<TransformedR(TransformedP1,TransformedP2)> &transformedParameters)
 {
-  transformedParameters.Parameter1 = transform(originalParameters.Parameter1);
-  transformedParameters.Parameter2 = transform(originalParameters.Parameter2);
+  transformedParameters.Parameter1 =
+    transform(originalParameters.Parameter1, vtkm::internal::IndexTag<1>());
+  transformedParameters.Parameter2 =
+    transform(originalParameters.Parameter2, vtkm::internal::IndexTag<2>());
 }
 
 template<typename Transform,
@@ -2544,9 +2551,12 @@ void DoStaticTransformCont(
       const ParameterContainer<OriginalR(OriginalP1,OriginalP2,OriginalP3)> &originalParameters,
       ParameterContainer<TransformedR(TransformedP1,TransformedP2,TransformedP3)> &transformedParameters)
 {
-  transformedParameters.Parameter1 = transform(originalParameters.Parameter1);
-  transformedParameters.Parameter2 = transform(originalParameters.Parameter2);
-  transformedParameters.Parameter3 = transform(originalParameters.Parameter3);
+  transformedParameters.Parameter1 =
+    transform(originalParameters.Parameter1, vtkm::internal::IndexTag<1>());
+  transformedParameters.Parameter2 =
+    transform(originalParameters.Parameter2, vtkm::internal::IndexTag<2>());
+  transformedParameters.Parameter3 =
+    transform(originalParameters.Parameter3, vtkm::internal::IndexTag<3>());
 }
 
 template<typename Transform,
@@ -2564,9 +2574,12 @@ void DoStaticTransformExec(
       const ParameterContainer<OriginalR(OriginalP1,OriginalP2,OriginalP3)> &originalParameters,
       ParameterContainer<TransformedR(TransformedP1,TransformedP2,TransformedP3)> &transformedParameters)
 {
-  transformedParameters.Parameter1 = transform(originalParameters.Parameter1);
-  transformedParameters.Parameter2 = transform(originalParameters.Parameter2);
-  transformedParameters.Parameter3 = transform(originalParameters.Parameter3);
+  transformedParameters.Parameter1 =
+    transform(originalParameters.Parameter1, vtkm::internal::IndexTag<1>());
+  transformedParameters.Parameter2 =
+    transform(originalParameters.Parameter2, vtkm::internal::IndexTag<2>());
+  transformedParameters.Parameter3 =
+    transform(originalParameters.Parameter3, vtkm::internal::IndexTag<3>());
 }
 
 template<typename Transform,
@@ -2586,10 +2599,14 @@ void DoStaticTransformCont(
       const ParameterContainer<OriginalR(OriginalP1,OriginalP2,OriginalP3,OriginalP4)> &originalParameters,
       ParameterContainer<TransformedR(TransformedP1,TransformedP2,TransformedP3,TransformedP4)> &transformedParameters)
 {
-  transformedParameters.Parameter1 = transform(originalParameters.Parameter1);
-  transformedParameters.Parameter2 = transform(originalParameters.Parameter2);
-  transformedParameters.Parameter3 = transform(originalParameters.Parameter3);
-  transformedParameters.Parameter4 = transform(originalParameters.Parameter4);
+  transformedParameters.Parameter1 =
+    transform(originalParameters.Parameter1, vtkm::internal::IndexTag<1>());
+  transformedParameters.Parameter2 =
+    transform(originalParameters.Parameter2, vtkm::internal::IndexTag<2>());
+  transformedParameters.Parameter3 =
+    transform(originalParameters.Parameter3, vtkm::internal::IndexTag<3>());
+  transformedParameters.Parameter4 =
+    transform(originalParameters.Parameter4, vtkm::internal::IndexTag<4>());
 }
 
 template<typename Transform,
@@ -2609,10 +2626,14 @@ void DoStaticTransformExec(
       const ParameterContainer<OriginalR(OriginalP1,OriginalP2,OriginalP3,OriginalP4)> &originalParameters,
       ParameterContainer<TransformedR(TransformedP1,TransformedP2,TransformedP3,TransformedP4)> &transformedParameters)
 {
-  transformedParameters.Parameter1 = transform(originalParameters.Parameter1);
-  transformedParameters.Parameter2 = transform(originalParameters.Parameter2);
-  transformedParameters.Parameter3 = transform(originalParameters.Parameter3);
-  transformedParameters.Parameter4 = transform(originalParameters.Parameter4);
+  transformedParameters.Parameter1 =
+    transform(originalParameters.Parameter1, vtkm::internal::IndexTag<1>());
+  transformedParameters.Parameter2 =
+    transform(originalParameters.Parameter2, vtkm::internal::IndexTag<2>());
+  transformedParameters.Parameter3 =
+    transform(originalParameters.Parameter3, vtkm::internal::IndexTag<3>());
+  transformedParameters.Parameter4 =
+    transform(originalParameters.Parameter4, vtkm::internal::IndexTag<4>());
 }
 
 template<typename Transform,
@@ -2634,11 +2655,16 @@ void DoStaticTransformCont(
       const ParameterContainer<OriginalR(OriginalP1,OriginalP2,OriginalP3,OriginalP4,OriginalP5)> &originalParameters,
       ParameterContainer<TransformedR(TransformedP1,TransformedP2,TransformedP3,TransformedP4,TransformedP5)> &transformedParameters)
 {
-  transformedParameters.Parameter1 = transform(originalParameters.Parameter1);
-  transformedParameters.Parameter2 = transform(originalParameters.Parameter2);
-  transformedParameters.Parameter3 = transform(originalParameters.Parameter3);
-  transformedParameters.Parameter4 = transform(originalParameters.Parameter4);
-  transformedParameters.Parameter5 = transform(originalParameters.Parameter5);
+  transformedParameters.Parameter1 =
+    transform(originalParameters.Parameter1, vtkm::internal::IndexTag<1>());
+  transformedParameters.Parameter2 =
+    transform(originalParameters.Parameter2, vtkm::internal::IndexTag<2>());
+  transformedParameters.Parameter3 =
+    transform(originalParameters.Parameter3, vtkm::internal::IndexTag<3>());
+  transformedParameters.Parameter4 =
+    transform(originalParameters.Parameter4, vtkm::internal::IndexTag<4>());
+  transformedParameters.Parameter5 =
+    transform(originalParameters.Parameter5, vtkm::internal::IndexTag<5>());
 }
 
 template<typename Transform,
@@ -2660,11 +2686,16 @@ void DoStaticTransformExec(
       const ParameterContainer<OriginalR(OriginalP1,OriginalP2,OriginalP3,OriginalP4,OriginalP5)> &originalParameters,
       ParameterContainer<TransformedR(TransformedP1,TransformedP2,TransformedP3,TransformedP4,TransformedP5)> &transformedParameters)
 {
-  transformedParameters.Parameter1 = transform(originalParameters.Parameter1);
-  transformedParameters.Parameter2 = transform(originalParameters.Parameter2);
-  transformedParameters.Parameter3 = transform(originalParameters.Parameter3);
-  transformedParameters.Parameter4 = transform(originalParameters.Parameter4);
-  transformedParameters.Parameter5 = transform(originalParameters.Parameter5);
+  transformedParameters.Parameter1 =
+    transform(originalParameters.Parameter1, vtkm::internal::IndexTag<1>());
+  transformedParameters.Parameter2 =
+    transform(originalParameters.Parameter2, vtkm::internal::IndexTag<2>());
+  transformedParameters.Parameter3 =
+    transform(originalParameters.Parameter3, vtkm::internal::IndexTag<3>());
+  transformedParameters.Parameter4 =
+    transform(originalParameters.Parameter4, vtkm::internal::IndexTag<4>());
+  transformedParameters.Parameter5 =
+    transform(originalParameters.Parameter5, vtkm::internal::IndexTag<5>());
 }
 
 template<typename Transform,
@@ -2688,12 +2719,18 @@ void DoStaticTransformCont(
       const ParameterContainer<OriginalR(OriginalP1,OriginalP2,OriginalP3,OriginalP4,OriginalP5,OriginalP6)> &originalParameters,
       ParameterContainer<TransformedR(TransformedP1,TransformedP2,TransformedP3,TransformedP4,TransformedP5,TransformedP6)> &transformedParameters)
 {
-  transformedParameters.Parameter1 = transform(originalParameters.Parameter1);
-  transformedParameters.Parameter2 = transform(originalParameters.Parameter2);
-  transformedParameters.Parameter3 = transform(originalParameters.Parameter3);
-  transformedParameters.Parameter4 = transform(originalParameters.Parameter4);
-  transformedParameters.Parameter5 = transform(originalParameters.Parameter5);
-  transformedParameters.Parameter6 = transform(originalParameters.Parameter6);
+  transformedParameters.Parameter1 =
+    transform(originalParameters.Parameter1, vtkm::internal::IndexTag<1>());
+  transformedParameters.Parameter2 =
+    transform(originalParameters.Parameter2, vtkm::internal::IndexTag<2>());
+  transformedParameters.Parameter3 =
+    transform(originalParameters.Parameter3, vtkm::internal::IndexTag<3>());
+  transformedParameters.Parameter4 =
+    transform(originalParameters.Parameter4, vtkm::internal::IndexTag<4>());
+  transformedParameters.Parameter5 =
+    transform(originalParameters.Parameter5, vtkm::internal::IndexTag<5>());
+  transformedParameters.Parameter6 =
+    transform(originalParameters.Parameter6, vtkm::internal::IndexTag<6>());
 }
 
 template<typename Transform,
@@ -2717,12 +2754,18 @@ void DoStaticTransformExec(
       const ParameterContainer<OriginalR(OriginalP1,OriginalP2,OriginalP3,OriginalP4,OriginalP5,OriginalP6)> &originalParameters,
       ParameterContainer<TransformedR(TransformedP1,TransformedP2,TransformedP3,TransformedP4,TransformedP5,TransformedP6)> &transformedParameters)
 {
-  transformedParameters.Parameter1 = transform(originalParameters.Parameter1);
-  transformedParameters.Parameter2 = transform(originalParameters.Parameter2);
-  transformedParameters.Parameter3 = transform(originalParameters.Parameter3);
-  transformedParameters.Parameter4 = transform(originalParameters.Parameter4);
-  transformedParameters.Parameter5 = transform(originalParameters.Parameter5);
-  transformedParameters.Parameter6 = transform(originalParameters.Parameter6);
+  transformedParameters.Parameter1 =
+    transform(originalParameters.Parameter1, vtkm::internal::IndexTag<1>());
+  transformedParameters.Parameter2 =
+    transform(originalParameters.Parameter2, vtkm::internal::IndexTag<2>());
+  transformedParameters.Parameter3 =
+    transform(originalParameters.Parameter3, vtkm::internal::IndexTag<3>());
+  transformedParameters.Parameter4 =
+    transform(originalParameters.Parameter4, vtkm::internal::IndexTag<4>());
+  transformedParameters.Parameter5 =
+    transform(originalParameters.Parameter5, vtkm::internal::IndexTag<5>());
+  transformedParameters.Parameter6 =
+    transform(originalParameters.Parameter6, vtkm::internal::IndexTag<6>());
 }
 
 template<typename Transform,
@@ -2748,13 +2791,20 @@ void DoStaticTransformCont(
       const ParameterContainer<OriginalR(OriginalP1,OriginalP2,OriginalP3,OriginalP4,OriginalP5,OriginalP6,OriginalP7)> &originalParameters,
       ParameterContainer<TransformedR(TransformedP1,TransformedP2,TransformedP3,TransformedP4,TransformedP5,TransformedP6,TransformedP7)> &transformedParameters)
 {
-  transformedParameters.Parameter1 = transform(originalParameters.Parameter1);
-  transformedParameters.Parameter2 = transform(originalParameters.Parameter2);
-  transformedParameters.Parameter3 = transform(originalParameters.Parameter3);
-  transformedParameters.Parameter4 = transform(originalParameters.Parameter4);
-  transformedParameters.Parameter5 = transform(originalParameters.Parameter5);
-  transformedParameters.Parameter6 = transform(originalParameters.Parameter6);
-  transformedParameters.Parameter7 = transform(originalParameters.Parameter7);
+  transformedParameters.Parameter1 =
+    transform(originalParameters.Parameter1, vtkm::internal::IndexTag<1>());
+  transformedParameters.Parameter2 =
+    transform(originalParameters.Parameter2, vtkm::internal::IndexTag<2>());
+  transformedParameters.Parameter3 =
+    transform(originalParameters.Parameter3, vtkm::internal::IndexTag<3>());
+  transformedParameters.Parameter4 =
+    transform(originalParameters.Parameter4, vtkm::internal::IndexTag<4>());
+  transformedParameters.Parameter5 =
+    transform(originalParameters.Parameter5, vtkm::internal::IndexTag<5>());
+  transformedParameters.Parameter6 =
+    transform(originalParameters.Parameter6, vtkm::internal::IndexTag<6>());
+  transformedParameters.Parameter7 =
+    transform(originalParameters.Parameter7, vtkm::internal::IndexTag<7>());
 }
 
 template<typename Transform,
@@ -2780,13 +2830,20 @@ void DoStaticTransformExec(
       const ParameterContainer<OriginalR(OriginalP1,OriginalP2,OriginalP3,OriginalP4,OriginalP5,OriginalP6,OriginalP7)> &originalParameters,
       ParameterContainer<TransformedR(TransformedP1,TransformedP2,TransformedP3,TransformedP4,TransformedP5,TransformedP6,TransformedP7)> &transformedParameters)
 {
-  transformedParameters.Parameter1 = transform(originalParameters.Parameter1);
-  transformedParameters.Parameter2 = transform(originalParameters.Parameter2);
-  transformedParameters.Parameter3 = transform(originalParameters.Parameter3);
-  transformedParameters.Parameter4 = transform(originalParameters.Parameter4);
-  transformedParameters.Parameter5 = transform(originalParameters.Parameter5);
-  transformedParameters.Parameter6 = transform(originalParameters.Parameter6);
-  transformedParameters.Parameter7 = transform(originalParameters.Parameter7);
+  transformedParameters.Parameter1 =
+    transform(originalParameters.Parameter1, vtkm::internal::IndexTag<1>());
+  transformedParameters.Parameter2 =
+    transform(originalParameters.Parameter2, vtkm::internal::IndexTag<2>());
+  transformedParameters.Parameter3 =
+    transform(originalParameters.Parameter3, vtkm::internal::IndexTag<3>());
+  transformedParameters.Parameter4 =
+    transform(originalParameters.Parameter4, vtkm::internal::IndexTag<4>());
+  transformedParameters.Parameter5 =
+    transform(originalParameters.Parameter5, vtkm::internal::IndexTag<5>());
+  transformedParameters.Parameter6 =
+    transform(originalParameters.Parameter6, vtkm::internal::IndexTag<6>());
+  transformedParameters.Parameter7 =
+    transform(originalParameters.Parameter7, vtkm::internal::IndexTag<7>());
 }
 
 template<typename Transform,
@@ -2814,14 +2871,22 @@ void DoStaticTransformCont(
       const ParameterContainer<OriginalR(OriginalP1,OriginalP2,OriginalP3,OriginalP4,OriginalP5,OriginalP6,OriginalP7,OriginalP8)> &originalParameters,
       ParameterContainer<TransformedR(TransformedP1,TransformedP2,TransformedP3,TransformedP4,TransformedP5,TransformedP6,TransformedP7,TransformedP8)> &transformedParameters)
 {
-  transformedParameters.Parameter1 = transform(originalParameters.Parameter1);
-  transformedParameters.Parameter2 = transform(originalParameters.Parameter2);
-  transformedParameters.Parameter3 = transform(originalParameters.Parameter3);
-  transformedParameters.Parameter4 = transform(originalParameters.Parameter4);
-  transformedParameters.Parameter5 = transform(originalParameters.Parameter5);
-  transformedParameters.Parameter6 = transform(originalParameters.Parameter6);
-  transformedParameters.Parameter7 = transform(originalParameters.Parameter7);
-  transformedParameters.Parameter8 = transform(originalParameters.Parameter8);
+  transformedParameters.Parameter1 =
+    transform(originalParameters.Parameter1, vtkm::internal::IndexTag<1>());
+  transformedParameters.Parameter2 =
+    transform(originalParameters.Parameter2, vtkm::internal::IndexTag<2>());
+  transformedParameters.Parameter3 =
+    transform(originalParameters.Parameter3, vtkm::internal::IndexTag<3>());
+  transformedParameters.Parameter4 =
+    transform(originalParameters.Parameter4, vtkm::internal::IndexTag<4>());
+  transformedParameters.Parameter5 =
+    transform(originalParameters.Parameter5, vtkm::internal::IndexTag<5>());
+  transformedParameters.Parameter6 =
+    transform(originalParameters.Parameter6, vtkm::internal::IndexTag<6>());
+  transformedParameters.Parameter7 =
+    transform(originalParameters.Parameter7, vtkm::internal::IndexTag<7>());
+  transformedParameters.Parameter8 =
+    transform(originalParameters.Parameter8, vtkm::internal::IndexTag<8>());
 }
 
 template<typename Transform,
@@ -2849,14 +2914,22 @@ void DoStaticTransformExec(
       const ParameterContainer<OriginalR(OriginalP1,OriginalP2,OriginalP3,OriginalP4,OriginalP5,OriginalP6,OriginalP7,OriginalP8)> &originalParameters,
       ParameterContainer<TransformedR(TransformedP1,TransformedP2,TransformedP3,TransformedP4,TransformedP5,TransformedP6,TransformedP7,TransformedP8)> &transformedParameters)
 {
-  transformedParameters.Parameter1 = transform(originalParameters.Parameter1);
-  transformedParameters.Parameter2 = transform(originalParameters.Parameter2);
-  transformedParameters.Parameter3 = transform(originalParameters.Parameter3);
-  transformedParameters.Parameter4 = transform(originalParameters.Parameter4);
-  transformedParameters.Parameter5 = transform(originalParameters.Parameter5);
-  transformedParameters.Parameter6 = transform(originalParameters.Parameter6);
-  transformedParameters.Parameter7 = transform(originalParameters.Parameter7);
-  transformedParameters.Parameter8 = transform(originalParameters.Parameter8);
+  transformedParameters.Parameter1 =
+    transform(originalParameters.Parameter1, vtkm::internal::IndexTag<1>());
+  transformedParameters.Parameter2 =
+    transform(originalParameters.Parameter2, vtkm::internal::IndexTag<2>());
+  transformedParameters.Parameter3 =
+    transform(originalParameters.Parameter3, vtkm::internal::IndexTag<3>());
+  transformedParameters.Parameter4 =
+    transform(originalParameters.Parameter4, vtkm::internal::IndexTag<4>());
+  transformedParameters.Parameter5 =
+    transform(originalParameters.Parameter5, vtkm::internal::IndexTag<5>());
+  transformedParameters.Parameter6 =
+    transform(originalParameters.Parameter6, vtkm::internal::IndexTag<6>());
+  transformedParameters.Parameter7 =
+    transform(originalParameters.Parameter7, vtkm::internal::IndexTag<7>());
+  transformedParameters.Parameter8 =
+    transform(originalParameters.Parameter8, vtkm::internal::IndexTag<8>());
 }
 
 template<typename Transform,
@@ -2886,15 +2959,24 @@ void DoStaticTransformCont(
       const ParameterContainer<OriginalR(OriginalP1,OriginalP2,OriginalP3,OriginalP4,OriginalP5,OriginalP6,OriginalP7,OriginalP8,OriginalP9)> &originalParameters,
       ParameterContainer<TransformedR(TransformedP1,TransformedP2,TransformedP3,TransformedP4,TransformedP5,TransformedP6,TransformedP7,TransformedP8,TransformedP9)> &transformedParameters)
 {
-  transformedParameters.Parameter1 = transform(originalParameters.Parameter1);
-  transformedParameters.Parameter2 = transform(originalParameters.Parameter2);
-  transformedParameters.Parameter3 = transform(originalParameters.Parameter3);
-  transformedParameters.Parameter4 = transform(originalParameters.Parameter4);
-  transformedParameters.Parameter5 = transform(originalParameters.Parameter5);
-  transformedParameters.Parameter6 = transform(originalParameters.Parameter6);
-  transformedParameters.Parameter7 = transform(originalParameters.Parameter7);
-  transformedParameters.Parameter8 = transform(originalParameters.Parameter8);
-  transformedParameters.Parameter9 = transform(originalParameters.Parameter9);
+  transformedParameters.Parameter1 =
+    transform(originalParameters.Parameter1, vtkm::internal::IndexTag<1>());
+  transformedParameters.Parameter2 =
+    transform(originalParameters.Parameter2, vtkm::internal::IndexTag<2>());
+  transformedParameters.Parameter3 =
+    transform(originalParameters.Parameter3, vtkm::internal::IndexTag<3>());
+  transformedParameters.Parameter4 =
+    transform(originalParameters.Parameter4, vtkm::internal::IndexTag<4>());
+  transformedParameters.Parameter5 =
+    transform(originalParameters.Parameter5, vtkm::internal::IndexTag<5>());
+  transformedParameters.Parameter6 =
+    transform(originalParameters.Parameter6, vtkm::internal::IndexTag<6>());
+  transformedParameters.Parameter7 =
+    transform(originalParameters.Parameter7, vtkm::internal::IndexTag<7>());
+  transformedParameters.Parameter8 =
+    transform(originalParameters.Parameter8, vtkm::internal::IndexTag<8>());
+  transformedParameters.Parameter9 =
+    transform(originalParameters.Parameter9, vtkm::internal::IndexTag<9>());
 }
 
 template<typename Transform,
@@ -2924,15 +3006,24 @@ void DoStaticTransformExec(
       const ParameterContainer<OriginalR(OriginalP1,OriginalP2,OriginalP3,OriginalP4,OriginalP5,OriginalP6,OriginalP7,OriginalP8,OriginalP9)> &originalParameters,
       ParameterContainer<TransformedR(TransformedP1,TransformedP2,TransformedP3,TransformedP4,TransformedP5,TransformedP6,TransformedP7,TransformedP8,TransformedP9)> &transformedParameters)
 {
-  transformedParameters.Parameter1 = transform(originalParameters.Parameter1);
-  transformedParameters.Parameter2 = transform(originalParameters.Parameter2);
-  transformedParameters.Parameter3 = transform(originalParameters.Parameter3);
-  transformedParameters.Parameter4 = transform(originalParameters.Parameter4);
-  transformedParameters.Parameter5 = transform(originalParameters.Parameter5);
-  transformedParameters.Parameter6 = transform(originalParameters.Parameter6);
-  transformedParameters.Parameter7 = transform(originalParameters.Parameter7);
-  transformedParameters.Parameter8 = transform(originalParameters.Parameter8);
-  transformedParameters.Parameter9 = transform(originalParameters.Parameter9);
+  transformedParameters.Parameter1 =
+    transform(originalParameters.Parameter1, vtkm::internal::IndexTag<1>());
+  transformedParameters.Parameter2 =
+    transform(originalParameters.Parameter2, vtkm::internal::IndexTag<2>());
+  transformedParameters.Parameter3 =
+    transform(originalParameters.Parameter3, vtkm::internal::IndexTag<3>());
+  transformedParameters.Parameter4 =
+    transform(originalParameters.Parameter4, vtkm::internal::IndexTag<4>());
+  transformedParameters.Parameter5 =
+    transform(originalParameters.Parameter5, vtkm::internal::IndexTag<5>());
+  transformedParameters.Parameter6 =
+    transform(originalParameters.Parameter6, vtkm::internal::IndexTag<6>());
+  transformedParameters.Parameter7 =
+    transform(originalParameters.Parameter7, vtkm::internal::IndexTag<7>());
+  transformedParameters.Parameter8 =
+    transform(originalParameters.Parameter8, vtkm::internal::IndexTag<8>());
+  transformedParameters.Parameter9 =
+    transform(originalParameters.Parameter9, vtkm::internal::IndexTag<9>());
 }
 
 
@@ -2990,7 +3081,7 @@ void DoForEachCont(
       const Functor &f,
       const ParameterContainer<R(P1)> &parameters)
 {
-  f(parameters.Parameter1);
+  f(parameters.Parameter1, vtkm::internal::IndexTag<1>());
 }
 
 template<typename Functor,
@@ -3001,7 +3092,7 @@ void DoForEachCont(
       const Functor &f,
       ParameterContainer<R(P1)> &parameters)
 {
-  f(parameters.Parameter1);
+  f(parameters.Parameter1, vtkm::internal::IndexTag<1>());
 }
 
 template<typename Functor,
@@ -3012,7 +3103,7 @@ void DoForEachExec(
       const Functor &f,
       const ParameterContainer<R(P1)> &parameters)
 {
-  f(parameters.Parameter1);
+  f(parameters.Parameter1, vtkm::internal::IndexTag<1>());
 }
 
 template<typename Functor,
@@ -3023,7 +3114,7 @@ void DoForEachExec(
       const Functor &f,
       ParameterContainer<R(P1)> &parameters)
 {
-  f(parameters.Parameter1);
+  f(parameters.Parameter1, vtkm::internal::IndexTag<1>());
 }
 
 template<typename Functor,
@@ -3035,8 +3126,8 @@ void DoForEachCont(
       const Functor &f,
       const ParameterContainer<R(P1,P2)> &parameters)
 {
-  f(parameters.Parameter1);
-  f(parameters.Parameter2);
+  f(parameters.Parameter1, vtkm::internal::IndexTag<1>());
+  f(parameters.Parameter2, vtkm::internal::IndexTag<2>());
 }
 
 template<typename Functor,
@@ -3048,8 +3139,8 @@ void DoForEachCont(
       const Functor &f,
       ParameterContainer<R(P1,P2)> &parameters)
 {
-  f(parameters.Parameter1);
-  f(parameters.Parameter2);
+  f(parameters.Parameter1, vtkm::internal::IndexTag<1>());
+  f(parameters.Parameter2, vtkm::internal::IndexTag<2>());
 }
 
 template<typename Functor,
@@ -3061,8 +3152,8 @@ void DoForEachExec(
       const Functor &f,
       const ParameterContainer<R(P1,P2)> &parameters)
 {
-  f(parameters.Parameter1);
-  f(parameters.Parameter2);
+  f(parameters.Parameter1, vtkm::internal::IndexTag<1>());
+  f(parameters.Parameter2, vtkm::internal::IndexTag<2>());
 }
 
 template<typename Functor,
@@ -3074,8 +3165,8 @@ void DoForEachExec(
       const Functor &f,
       ParameterContainer<R(P1,P2)> &parameters)
 {
-  f(parameters.Parameter1);
-  f(parameters.Parameter2);
+  f(parameters.Parameter1, vtkm::internal::IndexTag<1>());
+  f(parameters.Parameter2, vtkm::internal::IndexTag<2>());
 }
 
 template<typename Functor,
@@ -3088,9 +3179,9 @@ void DoForEachCont(
       const Functor &f,
       const ParameterContainer<R(P1,P2,P3)> &parameters)
 {
-  f(parameters.Parameter1);
-  f(parameters.Parameter2);
-  f(parameters.Parameter3);
+  f(parameters.Parameter1, vtkm::internal::IndexTag<1>());
+  f(parameters.Parameter2, vtkm::internal::IndexTag<2>());
+  f(parameters.Parameter3, vtkm::internal::IndexTag<3>());
 }
 
 template<typename Functor,
@@ -3103,9 +3194,9 @@ void DoForEachCont(
       const Functor &f,
       ParameterContainer<R(P1,P2,P3)> &parameters)
 {
-  f(parameters.Parameter1);
-  f(parameters.Parameter2);
-  f(parameters.Parameter3);
+  f(parameters.Parameter1, vtkm::internal::IndexTag<1>());
+  f(parameters.Parameter2, vtkm::internal::IndexTag<2>());
+  f(parameters.Parameter3, vtkm::internal::IndexTag<3>());
 }
 
 template<typename Functor,
@@ -3118,9 +3209,9 @@ void DoForEachExec(
       const Functor &f,
       const ParameterContainer<R(P1,P2,P3)> &parameters)
 {
-  f(parameters.Parameter1);
-  f(parameters.Parameter2);
-  f(parameters.Parameter3);
+  f(parameters.Parameter1, vtkm::internal::IndexTag<1>());
+  f(parameters.Parameter2, vtkm::internal::IndexTag<2>());
+  f(parameters.Parameter3, vtkm::internal::IndexTag<3>());
 }
 
 template<typename Functor,
@@ -3133,9 +3224,9 @@ void DoForEachExec(
       const Functor &f,
       ParameterContainer<R(P1,P2,P3)> &parameters)
 {
-  f(parameters.Parameter1);
-  f(parameters.Parameter2);
-  f(parameters.Parameter3);
+  f(parameters.Parameter1, vtkm::internal::IndexTag<1>());
+  f(parameters.Parameter2, vtkm::internal::IndexTag<2>());
+  f(parameters.Parameter3, vtkm::internal::IndexTag<3>());
 }
 
 template<typename Functor,
@@ -3149,10 +3240,10 @@ void DoForEachCont(
       const Functor &f,
       const ParameterContainer<R(P1,P2,P3,P4)> &parameters)
 {
-  f(parameters.Parameter1);
-  f(parameters.Parameter2);
-  f(parameters.Parameter3);
-  f(parameters.Parameter4);
+  f(parameters.Parameter1, vtkm::internal::IndexTag<1>());
+  f(parameters.Parameter2, vtkm::internal::IndexTag<2>());
+  f(parameters.Parameter3, vtkm::internal::IndexTag<3>());
+  f(parameters.Parameter4, vtkm::internal::IndexTag<4>());
 }
 
 template<typename Functor,
@@ -3166,10 +3257,10 @@ void DoForEachCont(
       const Functor &f,
       ParameterContainer<R(P1,P2,P3,P4)> &parameters)
 {
-  f(parameters.Parameter1);
-  f(parameters.Parameter2);
-  f(parameters.Parameter3);
-  f(parameters.Parameter4);
+  f(parameters.Parameter1, vtkm::internal::IndexTag<1>());
+  f(parameters.Parameter2, vtkm::internal::IndexTag<2>());
+  f(parameters.Parameter3, vtkm::internal::IndexTag<3>());
+  f(parameters.Parameter4, vtkm::internal::IndexTag<4>());
 }
 
 template<typename Functor,
@@ -3183,10 +3274,10 @@ void DoForEachExec(
       const Functor &f,
       const ParameterContainer<R(P1,P2,P3,P4)> &parameters)
 {
-  f(parameters.Parameter1);
-  f(parameters.Parameter2);
-  f(parameters.Parameter3);
-  f(parameters.Parameter4);
+  f(parameters.Parameter1, vtkm::internal::IndexTag<1>());
+  f(parameters.Parameter2, vtkm::internal::IndexTag<2>());
+  f(parameters.Parameter3, vtkm::internal::IndexTag<3>());
+  f(parameters.Parameter4, vtkm::internal::IndexTag<4>());
 }
 
 template<typename Functor,
@@ -3200,10 +3291,10 @@ void DoForEachExec(
       const Functor &f,
       ParameterContainer<R(P1,P2,P3,P4)> &parameters)
 {
-  f(parameters.Parameter1);
-  f(parameters.Parameter2);
-  f(parameters.Parameter3);
-  f(parameters.Parameter4);
+  f(parameters.Parameter1, vtkm::internal::IndexTag<1>());
+  f(parameters.Parameter2, vtkm::internal::IndexTag<2>());
+  f(parameters.Parameter3, vtkm::internal::IndexTag<3>());
+  f(parameters.Parameter4, vtkm::internal::IndexTag<4>());
 }
 
 template<typename Functor,
@@ -3218,11 +3309,11 @@ void DoForEachCont(
       const Functor &f,
       const ParameterContainer<R(P1,P2,P3,P4,P5)> &parameters)
 {
-  f(parameters.Parameter1);
-  f(parameters.Parameter2);
-  f(parameters.Parameter3);
-  f(parameters.Parameter4);
-  f(parameters.Parameter5);
+  f(parameters.Parameter1, vtkm::internal::IndexTag<1>());
+  f(parameters.Parameter2, vtkm::internal::IndexTag<2>());
+  f(parameters.Parameter3, vtkm::internal::IndexTag<3>());
+  f(parameters.Parameter4, vtkm::internal::IndexTag<4>());
+  f(parameters.Parameter5, vtkm::internal::IndexTag<5>());
 }
 
 template<typename Functor,
@@ -3237,11 +3328,11 @@ void DoForEachCont(
       const Functor &f,
       ParameterContainer<R(P1,P2,P3,P4,P5)> &parameters)
 {
-  f(parameters.Parameter1);
-  f(parameters.Parameter2);
-  f(parameters.Parameter3);
-  f(parameters.Parameter4);
-  f(parameters.Parameter5);
+  f(parameters.Parameter1, vtkm::internal::IndexTag<1>());
+  f(parameters.Parameter2, vtkm::internal::IndexTag<2>());
+  f(parameters.Parameter3, vtkm::internal::IndexTag<3>());
+  f(parameters.Parameter4, vtkm::internal::IndexTag<4>());
+  f(parameters.Parameter5, vtkm::internal::IndexTag<5>());
 }
 
 template<typename Functor,
@@ -3256,11 +3347,11 @@ void DoForEachExec(
       const Functor &f,
       const ParameterContainer<R(P1,P2,P3,P4,P5)> &parameters)
 {
-  f(parameters.Parameter1);
-  f(parameters.Parameter2);
-  f(parameters.Parameter3);
-  f(parameters.Parameter4);
-  f(parameters.Parameter5);
+  f(parameters.Parameter1, vtkm::internal::IndexTag<1>());
+  f(parameters.Parameter2, vtkm::internal::IndexTag<2>());
+  f(parameters.Parameter3, vtkm::internal::IndexTag<3>());
+  f(parameters.Parameter4, vtkm::internal::IndexTag<4>());
+  f(parameters.Parameter5, vtkm::internal::IndexTag<5>());
 }
 
 template<typename Functor,
@@ -3275,11 +3366,11 @@ void DoForEachExec(
       const Functor &f,
       ParameterContainer<R(P1,P2,P3,P4,P5)> &parameters)
 {
-  f(parameters.Parameter1);
-  f(parameters.Parameter2);
-  f(parameters.Parameter3);
-  f(parameters.Parameter4);
-  f(parameters.Parameter5);
+  f(parameters.Parameter1, vtkm::internal::IndexTag<1>());
+  f(parameters.Parameter2, vtkm::internal::IndexTag<2>());
+  f(parameters.Parameter3, vtkm::internal::IndexTag<3>());
+  f(parameters.Parameter4, vtkm::internal::IndexTag<4>());
+  f(parameters.Parameter5, vtkm::internal::IndexTag<5>());
 }
 
 template<typename Functor,
@@ -3295,12 +3386,12 @@ void DoForEachCont(
       const Functor &f,
       const ParameterContainer<R(P1,P2,P3,P4,P5,P6)> &parameters)
 {
-  f(parameters.Parameter1);
-  f(parameters.Parameter2);
-  f(parameters.Parameter3);
-  f(parameters.Parameter4);
-  f(parameters.Parameter5);
-  f(parameters.Parameter6);
+  f(parameters.Parameter1, vtkm::internal::IndexTag<1>());
+  f(parameters.Parameter2, vtkm::internal::IndexTag<2>());
+  f(parameters.Parameter3, vtkm::internal::IndexTag<3>());
+  f(parameters.Parameter4, vtkm::internal::IndexTag<4>());
+  f(parameters.Parameter5, vtkm::internal::IndexTag<5>());
+  f(parameters.Parameter6, vtkm::internal::IndexTag<6>());
 }
 
 template<typename Functor,
@@ -3316,12 +3407,12 @@ void DoForEachCont(
       const Functor &f,
       ParameterContainer<R(P1,P2,P3,P4,P5,P6)> &parameters)
 {
-  f(parameters.Parameter1);
-  f(parameters.Parameter2);
-  f(parameters.Parameter3);
-  f(parameters.Parameter4);
-  f(parameters.Parameter5);
-  f(parameters.Parameter6);
+  f(parameters.Parameter1, vtkm::internal::IndexTag<1>());
+  f(parameters.Parameter2, vtkm::internal::IndexTag<2>());
+  f(parameters.Parameter3, vtkm::internal::IndexTag<3>());
+  f(parameters.Parameter4, vtkm::internal::IndexTag<4>());
+  f(parameters.Parameter5, vtkm::internal::IndexTag<5>());
+  f(parameters.Parameter6, vtkm::internal::IndexTag<6>());
 }
 
 template<typename Functor,
@@ -3337,12 +3428,12 @@ void DoForEachExec(
       const Functor &f,
       const ParameterContainer<R(P1,P2,P3,P4,P5,P6)> &parameters)
 {
-  f(parameters.Parameter1);
-  f(parameters.Parameter2);
-  f(parameters.Parameter3);
-  f(parameters.Parameter4);
-  f(parameters.Parameter5);
-  f(parameters.Parameter6);
+  f(parameters.Parameter1, vtkm::internal::IndexTag<1>());
+  f(parameters.Parameter2, vtkm::internal::IndexTag<2>());
+  f(parameters.Parameter3, vtkm::internal::IndexTag<3>());
+  f(parameters.Parameter4, vtkm::internal::IndexTag<4>());
+  f(parameters.Parameter5, vtkm::internal::IndexTag<5>());
+  f(parameters.Parameter6, vtkm::internal::IndexTag<6>());
 }
 
 template<typename Functor,
@@ -3358,12 +3449,12 @@ void DoForEachExec(
       const Functor &f,
       ParameterContainer<R(P1,P2,P3,P4,P5,P6)> &parameters)
 {
-  f(parameters.Parameter1);
-  f(parameters.Parameter2);
-  f(parameters.Parameter3);
-  f(parameters.Parameter4);
-  f(parameters.Parameter5);
-  f(parameters.Parameter6);
+  f(parameters.Parameter1, vtkm::internal::IndexTag<1>());
+  f(parameters.Parameter2, vtkm::internal::IndexTag<2>());
+  f(parameters.Parameter3, vtkm::internal::IndexTag<3>());
+  f(parameters.Parameter4, vtkm::internal::IndexTag<4>());
+  f(parameters.Parameter5, vtkm::internal::IndexTag<5>());
+  f(parameters.Parameter6, vtkm::internal::IndexTag<6>());
 }
 
 template<typename Functor,
@@ -3380,13 +3471,13 @@ void DoForEachCont(
       const Functor &f,
       const ParameterContainer<R(P1,P2,P3,P4,P5,P6,P7)> &parameters)
 {
-  f(parameters.Parameter1);
-  f(parameters.Parameter2);
-  f(parameters.Parameter3);
-  f(parameters.Parameter4);
-  f(parameters.Parameter5);
-  f(parameters.Parameter6);
-  f(parameters.Parameter7);
+  f(parameters.Parameter1, vtkm::internal::IndexTag<1>());
+  f(parameters.Parameter2, vtkm::internal::IndexTag<2>());
+  f(parameters.Parameter3, vtkm::internal::IndexTag<3>());
+  f(parameters.Parameter4, vtkm::internal::IndexTag<4>());
+  f(parameters.Parameter5, vtkm::internal::IndexTag<5>());
+  f(parameters.Parameter6, vtkm::internal::IndexTag<6>());
+  f(parameters.Parameter7, vtkm::internal::IndexTag<7>());
 }
 
 template<typename Functor,
@@ -3403,13 +3494,13 @@ void DoForEachCont(
       const Functor &f,
       ParameterContainer<R(P1,P2,P3,P4,P5,P6,P7)> &parameters)
 {
-  f(parameters.Parameter1);
-  f(parameters.Parameter2);
-  f(parameters.Parameter3);
-  f(parameters.Parameter4);
-  f(parameters.Parameter5);
-  f(parameters.Parameter6);
-  f(parameters.Parameter7);
+  f(parameters.Parameter1, vtkm::internal::IndexTag<1>());
+  f(parameters.Parameter2, vtkm::internal::IndexTag<2>());
+  f(parameters.Parameter3, vtkm::internal::IndexTag<3>());
+  f(parameters.Parameter4, vtkm::internal::IndexTag<4>());
+  f(parameters.Parameter5, vtkm::internal::IndexTag<5>());
+  f(parameters.Parameter6, vtkm::internal::IndexTag<6>());
+  f(parameters.Parameter7, vtkm::internal::IndexTag<7>());
 }
 
 template<typename Functor,
@@ -3426,13 +3517,13 @@ void DoForEachExec(
       const Functor &f,
       const ParameterContainer<R(P1,P2,P3,P4,P5,P6,P7)> &parameters)
 {
-  f(parameters.Parameter1);
-  f(parameters.Parameter2);
-  f(parameters.Parameter3);
-  f(parameters.Parameter4);
-  f(parameters.Parameter5);
-  f(parameters.Parameter6);
-  f(parameters.Parameter7);
+  f(parameters.Parameter1, vtkm::internal::IndexTag<1>());
+  f(parameters.Parameter2, vtkm::internal::IndexTag<2>());
+  f(parameters.Parameter3, vtkm::internal::IndexTag<3>());
+  f(parameters.Parameter4, vtkm::internal::IndexTag<4>());
+  f(parameters.Parameter5, vtkm::internal::IndexTag<5>());
+  f(parameters.Parameter6, vtkm::internal::IndexTag<6>());
+  f(parameters.Parameter7, vtkm::internal::IndexTag<7>());
 }
 
 template<typename Functor,
@@ -3449,13 +3540,13 @@ void DoForEachExec(
       const Functor &f,
       ParameterContainer<R(P1,P2,P3,P4,P5,P6,P7)> &parameters)
 {
-  f(parameters.Parameter1);
-  f(parameters.Parameter2);
-  f(parameters.Parameter3);
-  f(parameters.Parameter4);
-  f(parameters.Parameter5);
-  f(parameters.Parameter6);
-  f(parameters.Parameter7);
+  f(parameters.Parameter1, vtkm::internal::IndexTag<1>());
+  f(parameters.Parameter2, vtkm::internal::IndexTag<2>());
+  f(parameters.Parameter3, vtkm::internal::IndexTag<3>());
+  f(parameters.Parameter4, vtkm::internal::IndexTag<4>());
+  f(parameters.Parameter5, vtkm::internal::IndexTag<5>());
+  f(parameters.Parameter6, vtkm::internal::IndexTag<6>());
+  f(parameters.Parameter7, vtkm::internal::IndexTag<7>());
 }
 
 template<typename Functor,
@@ -3473,14 +3564,14 @@ void DoForEachCont(
       const Functor &f,
       const ParameterContainer<R(P1,P2,P3,P4,P5,P6,P7,P8)> &parameters)
 {
-  f(parameters.Parameter1);
-  f(parameters.Parameter2);
-  f(parameters.Parameter3);
-  f(parameters.Parameter4);
-  f(parameters.Parameter5);
-  f(parameters.Parameter6);
-  f(parameters.Parameter7);
-  f(parameters.Parameter8);
+  f(parameters.Parameter1, vtkm::internal::IndexTag<1>());
+  f(parameters.Parameter2, vtkm::internal::IndexTag<2>());
+  f(parameters.Parameter3, vtkm::internal::IndexTag<3>());
+  f(parameters.Parameter4, vtkm::internal::IndexTag<4>());
+  f(parameters.Parameter5, vtkm::internal::IndexTag<5>());
+  f(parameters.Parameter6, vtkm::internal::IndexTag<6>());
+  f(parameters.Parameter7, vtkm::internal::IndexTag<7>());
+  f(parameters.Parameter8, vtkm::internal::IndexTag<8>());
 }
 
 template<typename Functor,
@@ -3498,14 +3589,14 @@ void DoForEachCont(
       const Functor &f,
       ParameterContainer<R(P1,P2,P3,P4,P5,P6,P7,P8)> &parameters)
 {
-  f(parameters.Parameter1);
-  f(parameters.Parameter2);
-  f(parameters.Parameter3);
-  f(parameters.Parameter4);
-  f(parameters.Parameter5);
-  f(parameters.Parameter6);
-  f(parameters.Parameter7);
-  f(parameters.Parameter8);
+  f(parameters.Parameter1, vtkm::internal::IndexTag<1>());
+  f(parameters.Parameter2, vtkm::internal::IndexTag<2>());
+  f(parameters.Parameter3, vtkm::internal::IndexTag<3>());
+  f(parameters.Parameter4, vtkm::internal::IndexTag<4>());
+  f(parameters.Parameter5, vtkm::internal::IndexTag<5>());
+  f(parameters.Parameter6, vtkm::internal::IndexTag<6>());
+  f(parameters.Parameter7, vtkm::internal::IndexTag<7>());
+  f(parameters.Parameter8, vtkm::internal::IndexTag<8>());
 }
 
 template<typename Functor,
@@ -3523,14 +3614,14 @@ void DoForEachExec(
       const Functor &f,
       const ParameterContainer<R(P1,P2,P3,P4,P5,P6,P7,P8)> &parameters)
 {
-  f(parameters.Parameter1);
-  f(parameters.Parameter2);
-  f(parameters.Parameter3);
-  f(parameters.Parameter4);
-  f(parameters.Parameter5);
-  f(parameters.Parameter6);
-  f(parameters.Parameter7);
-  f(parameters.Parameter8);
+  f(parameters.Parameter1, vtkm::internal::IndexTag<1>());
+  f(parameters.Parameter2, vtkm::internal::IndexTag<2>());
+  f(parameters.Parameter3, vtkm::internal::IndexTag<3>());
+  f(parameters.Parameter4, vtkm::internal::IndexTag<4>());
+  f(parameters.Parameter5, vtkm::internal::IndexTag<5>());
+  f(parameters.Parameter6, vtkm::internal::IndexTag<6>());
+  f(parameters.Parameter7, vtkm::internal::IndexTag<7>());
+  f(parameters.Parameter8, vtkm::internal::IndexTag<8>());
 }
 
 template<typename Functor,
@@ -3548,14 +3639,14 @@ void DoForEachExec(
       const Functor &f,
       ParameterContainer<R(P1,P2,P3,P4,P5,P6,P7,P8)> &parameters)
 {
-  f(parameters.Parameter1);
-  f(parameters.Parameter2);
-  f(parameters.Parameter3);
-  f(parameters.Parameter4);
-  f(parameters.Parameter5);
-  f(parameters.Parameter6);
-  f(parameters.Parameter7);
-  f(parameters.Parameter8);
+  f(parameters.Parameter1, vtkm::internal::IndexTag<1>());
+  f(parameters.Parameter2, vtkm::internal::IndexTag<2>());
+  f(parameters.Parameter3, vtkm::internal::IndexTag<3>());
+  f(parameters.Parameter4, vtkm::internal::IndexTag<4>());
+  f(parameters.Parameter5, vtkm::internal::IndexTag<5>());
+  f(parameters.Parameter6, vtkm::internal::IndexTag<6>());
+  f(parameters.Parameter7, vtkm::internal::IndexTag<7>());
+  f(parameters.Parameter8, vtkm::internal::IndexTag<8>());
 }
 
 template<typename Functor,
@@ -3574,15 +3665,15 @@ void DoForEachCont(
       const Functor &f,
       const ParameterContainer<R(P1,P2,P3,P4,P5,P6,P7,P8,P9)> &parameters)
 {
-  f(parameters.Parameter1);
-  f(parameters.Parameter2);
-  f(parameters.Parameter3);
-  f(parameters.Parameter4);
-  f(parameters.Parameter5);
-  f(parameters.Parameter6);
-  f(parameters.Parameter7);
-  f(parameters.Parameter8);
-  f(parameters.Parameter9);
+  f(parameters.Parameter1, vtkm::internal::IndexTag<1>());
+  f(parameters.Parameter2, vtkm::internal::IndexTag<2>());
+  f(parameters.Parameter3, vtkm::internal::IndexTag<3>());
+  f(parameters.Parameter4, vtkm::internal::IndexTag<4>());
+  f(parameters.Parameter5, vtkm::internal::IndexTag<5>());
+  f(parameters.Parameter6, vtkm::internal::IndexTag<6>());
+  f(parameters.Parameter7, vtkm::internal::IndexTag<7>());
+  f(parameters.Parameter8, vtkm::internal::IndexTag<8>());
+  f(parameters.Parameter9, vtkm::internal::IndexTag<9>());
 }
 
 template<typename Functor,
@@ -3601,15 +3692,15 @@ void DoForEachCont(
       const Functor &f,
       ParameterContainer<R(P1,P2,P3,P4,P5,P6,P7,P8,P9)> &parameters)
 {
-  f(parameters.Parameter1);
-  f(parameters.Parameter2);
-  f(parameters.Parameter3);
-  f(parameters.Parameter4);
-  f(parameters.Parameter5);
-  f(parameters.Parameter6);
-  f(parameters.Parameter7);
-  f(parameters.Parameter8);
-  f(parameters.Parameter9);
+  f(parameters.Parameter1, vtkm::internal::IndexTag<1>());
+  f(parameters.Parameter2, vtkm::internal::IndexTag<2>());
+  f(parameters.Parameter3, vtkm::internal::IndexTag<3>());
+  f(parameters.Parameter4, vtkm::internal::IndexTag<4>());
+  f(parameters.Parameter5, vtkm::internal::IndexTag<5>());
+  f(parameters.Parameter6, vtkm::internal::IndexTag<6>());
+  f(parameters.Parameter7, vtkm::internal::IndexTag<7>());
+  f(parameters.Parameter8, vtkm::internal::IndexTag<8>());
+  f(parameters.Parameter9, vtkm::internal::IndexTag<9>());
 }
 
 template<typename Functor,
@@ -3628,15 +3719,15 @@ void DoForEachExec(
       const Functor &f,
       const ParameterContainer<R(P1,P2,P3,P4,P5,P6,P7,P8,P9)> &parameters)
 {
-  f(parameters.Parameter1);
-  f(parameters.Parameter2);
-  f(parameters.Parameter3);
-  f(parameters.Parameter4);
-  f(parameters.Parameter5);
-  f(parameters.Parameter6);
-  f(parameters.Parameter7);
-  f(parameters.Parameter8);
-  f(parameters.Parameter9);
+  f(parameters.Parameter1, vtkm::internal::IndexTag<1>());
+  f(parameters.Parameter2, vtkm::internal::IndexTag<2>());
+  f(parameters.Parameter3, vtkm::internal::IndexTag<3>());
+  f(parameters.Parameter4, vtkm::internal::IndexTag<4>());
+  f(parameters.Parameter5, vtkm::internal::IndexTag<5>());
+  f(parameters.Parameter6, vtkm::internal::IndexTag<6>());
+  f(parameters.Parameter7, vtkm::internal::IndexTag<7>());
+  f(parameters.Parameter8, vtkm::internal::IndexTag<8>());
+  f(parameters.Parameter9, vtkm::internal::IndexTag<9>());
 }
 
 template<typename Functor,
@@ -3655,15 +3746,15 @@ void DoForEachExec(
       const Functor &f,
       ParameterContainer<R(P1,P2,P3,P4,P5,P6,P7,P8,P9)> &parameters)
 {
-  f(parameters.Parameter1);
-  f(parameters.Parameter2);
-  f(parameters.Parameter3);
-  f(parameters.Parameter4);
-  f(parameters.Parameter5);
-  f(parameters.Parameter6);
-  f(parameters.Parameter7);
-  f(parameters.Parameter8);
-  f(parameters.Parameter9);
+  f(parameters.Parameter1, vtkm::internal::IndexTag<1>());
+  f(parameters.Parameter2, vtkm::internal::IndexTag<2>());
+  f(parameters.Parameter3, vtkm::internal::IndexTag<3>());
+  f(parameters.Parameter4, vtkm::internal::IndexTag<4>());
+  f(parameters.Parameter5, vtkm::internal::IndexTag<5>());
+  f(parameters.Parameter6, vtkm::internal::IndexTag<6>());
+  f(parameters.Parameter7, vtkm::internal::IndexTag<7>());
+  f(parameters.Parameter8, vtkm::internal::IndexTag<8>());
+  f(parameters.Parameter9, vtkm::internal::IndexTag<9>());
 }
 
 
diff --git a/vtkm/internal/FunctionInterfaceDetailPre.h.in b/vtkm/internal/FunctionInterfaceDetailPre.h.in
index 9665d6683..294de2016 100644
--- a/vtkm/internal/FunctionInterfaceDetailPre.h.in
+++ b/vtkm/internal/FunctionInterfaceDetailPre.h.in
@@ -40,6 +40,7 @@ $# Ignore the following comment. It is meant for the generated file.
 #endif
 
 #include <vtkm/Types.h>
+#include <vtkm/internal/IndexTag.h>
 
 #include <boost/function_types/function_type.hpp>
 #include <boost/mpl/at.hpp>
@@ -228,7 +229,8 @@ $if(num_params < 1)\
   (void)transformedParameters;
 $else\
 $for(param_index in xrange(1, num_params+1))\
-  transformedParameters.Parameter$(param_index) = transform(originalParameters.Parameter$(param_index));
+  transformedParameters.Parameter$(param_index) =
+    transform(originalParameters.Parameter$(param_index), vtkm::internal::IndexTag<$(param_index)>());
 $endfor\
 $endif\
 }
@@ -255,7 +257,7 @@ $if(num_params < 1)\
   (void)parameters;
 $else\
 $for(param_index in xrange(1, num_params+1))\
-  f(parameters.Parameter$(param_index));
+  f(parameters.Parameter$(param_index), vtkm::internal::IndexTag<$(param_index)>());
 $endfor\
 $endif\
 }
diff --git a/vtkm/internal/IndexTag.h b/vtkm/internal/IndexTag.h
new file mode 100644
index 000000000..8ce83c728
--- /dev/null
+++ b/vtkm/internal/IndexTag.h
@@ -0,0 +1,46 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//
+//  Copyright 2014 Sandia Corporation.
+//  Copyright 2014 UT-Battelle, LLC.
+//  Copyright 2014. Los Alamos National Security
+//
+//  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//  the U.S. Government retains certain rights in this software.
+//
+//  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+//  Laboratory (LANL), the U.S. Government retains certain rights in
+//  this software.
+//============================================================================
+#ifndef vtk_m_internal_StaticIndex_h
+#define vtk_m_internal_StaticIndex_h
+
+#include <vtkm/Types.h>
+
+namespace vtkm {
+namespace internal {
+
+/// \brief A convenience tag to represent static indices.
+///
+/// Some classes like \c FunctionInterface have a list of items that have
+/// numeric indices that must be resolved at compile time. Typically these are
+/// referenced with an integer template argument. However, such template
+/// arguments have to be explicitly defined in the template. They cannot be
+/// resolved through function or method arguments. In such cases, it is
+/// convenient to use this tag to encapsulate the index.
+///
+template<vtkm::IdComponent Index>
+struct IndexTag
+{
+  static const vtkm::IdComponent INDEX = Index;
+};
+
+}
+} // namespace vtkm::internal
+
+#endif //vtk_m_internal_StaticIndex_h
diff --git a/vtkm/internal/testing/UnitTestFunctionInterface.cxx b/vtkm/internal/testing/UnitTestFunctionInterface.cxx
index 847251588..faba9cc5a 100644
--- a/vtkm/internal/testing/UnitTestFunctionInterface.cxx
+++ b/vtkm/internal/testing/UnitTestFunctionInterface.cxx
@@ -83,13 +83,13 @@ struct GetReferenceFunctor
 };
 
 struct PointerTransform {
-  template<typename T>
+  template<typename T, vtkm::IdComponent Index>
   struct ReturnType {
     typedef const T *type;
   };
 
-  template<typename T>
-  const T *operator()(const T &x) const {
+  template<typename T, typename IndexTag>
+  const T *operator()(const T &x, IndexTag) const {
     return &x;
   }
 };
@@ -216,15 +216,19 @@ struct ThreeArgStringFunctorWithReturn
 
 struct DynamicTransformFunctor
 {
-  template<typename T, typename ContinueFunctor>
-  void operator()(const T &input, const ContinueFunctor continueFunc) const
+  template<typename T, typename ContinueFunctor, vtkm::IdComponent Index>
+  void operator()(const T &input,
+                  const ContinueFunctor continueFunc,
+                  vtkm::internal::IndexTag<Index>) const
   {
-    continueFunc(input);
-    continueFunc(ToString(input));
+    continueFunc(input+T(Index));
+    continueFunc(ToString(input+T(Index)));
   }
 
-  template<typename ContinueFunctor>
-  void operator()(const std::string &input, const ContinueFunctor continueFunc) const
+  template<typename ContinueFunctor, vtkm::IdComponent Index>
+  void operator()(const std::string &input,
+                  const ContinueFunctor continueFunc,
+                  vtkm::internal::IndexTag<Index>) const
   {
     continueFunc(input);
   }
@@ -238,9 +242,9 @@ struct DynamicTransformFinish
   void operator()(vtkm::internal::FunctionInterface<Signature> &funcInterface) const
   {
     g_DynamicTransformFinishCalls++;
-    VTKM_TEST_ASSERT(ToString(funcInterface.template GetParameter<1>()) == ToString(Arg1),
+    VTKM_TEST_ASSERT(ToString(funcInterface.template GetParameter<1>()) == ToString(Arg1+1),
                      "Arg 1 incorrect");
-    VTKM_TEST_ASSERT(ToString(funcInterface.template GetParameter<2>()) == ToString(Arg2),
+    VTKM_TEST_ASSERT(ToString(funcInterface.template GetParameter<2>()) == ToString(Arg2+2),
                      "Arg 2 incorrect");
     VTKM_TEST_ASSERT(ToString(funcInterface.template GetParameter<3>()) == ToString(Arg3),
                      "Arg 3 incorrect");
@@ -249,10 +253,17 @@ struct DynamicTransformFinish
 
 struct ForEachFunctor
 {
-  template<typename T>
-  void operator()(T &x) const { x = T(2)*x; }
+  template<typename T, vtkm::IdComponent Index>
+  void operator()(T &x, vtkm::internal::IndexTag<Index>) const {
+    x = T(Index)+x;
+  }
 
-  void operator()(std::string &x) const { x.append("*2"); }
+  template<vtkm::IdComponent Index>
+  void operator()(std::string &x, vtkm::internal::IndexTag<Index>) const {
+    std::stringstream message;
+    message << x << "+" << Index;
+    x = message.str();
+  }
 };
 
 void TryFunctionInterface5(
@@ -273,7 +284,7 @@ void TryFunctionInterface5(
 
   std::cout << "Swizzling parameters with replace." << std::endl;
   funcInterface.Replace<1>(Arg5)
-      .Replace<2>(Arg1)
+      .Replace(Arg1, vtkm::internal::IndexTag<2>())
       .Replace<5>(Arg2)
       .InvokeCont(FiveArgSwizzledFunctor());
 }
@@ -288,7 +299,7 @@ void TestBasicFunctionInterface()
   VTKM_TEST_ASSERT(funcInterface.GetArity() == 3,
                    "Got wrong number of parameters.");
   VTKM_TEST_ASSERT(funcInterface.GetParameter<1>() == Arg1, "Arg 1 incorrect.");
-  VTKM_TEST_ASSERT(funcInterface.GetParameter<2>() == Arg2, "Arg 2 incorrect.");
+  VTKM_TEST_ASSERT(funcInterface.GetParameter(vtkm::internal::IndexTag<2>()) == Arg2, "Arg 2 incorrect.");
   VTKM_TEST_ASSERT(funcInterface.GetParameter<3>() == Arg3, "Arg 3 incorrect.");
 
   std::cout << "Checking invocation." << std::endl;
@@ -297,7 +308,7 @@ void TestBasicFunctionInterface()
 
   std::cout << "Checking invocation with argument modification." << std::endl;
   funcInterface.SetParameter<1>(Type1());
-  funcInterface.SetParameter<2>(Type2());
+  funcInterface.SetParameter(Type2(), vtkm::internal::IndexTag<2>());
   funcInterface.SetParameter<3>(Type3());
   VTKM_TEST_ASSERT(funcInterface.GetParameter<1>() != Arg1, "Arg 1 not cleared.");
   VTKM_TEST_ASSERT(funcInterface.GetParameter<2>() != Arg2, "Arg 2 not cleared.");
@@ -440,18 +451,18 @@ void TestForEach()
   VTKM_TEST_ASSERT(funcInterface.GetParameter<5>() == Arg5, "Arg 5 incorrect.");
 
   funcInterface.ForEachCont(ForEachFunctor());
-  VTKM_TEST_ASSERT(funcInterface.GetParameter<1>() == 2*Arg1, "Arg 1 incorrect.");
-  VTKM_TEST_ASSERT(funcInterface.GetParameter<2>() == 2*Arg2, "Arg 2 incorrect.");
-  VTKM_TEST_ASSERT(funcInterface.GetParameter<3>() == Arg3+"*2", "Arg 3 incorrect.");
-  VTKM_TEST_ASSERT(funcInterface.GetParameter<4>() == 2.0f*Arg4, "Arg 4 incorrect.");
-  VTKM_TEST_ASSERT(funcInterface.GetParameter<5>() == 2*Arg5, "Arg 5 incorrect.");
+  VTKM_TEST_ASSERT(funcInterface.GetParameter<1>() == Type1(1)+Arg1, "Arg 1 incorrect.");
+  VTKM_TEST_ASSERT(funcInterface.GetParameter<2>() == Type2(2)+Arg2, "Arg 2 incorrect.");
+  VTKM_TEST_ASSERT(funcInterface.GetParameter<3>() == Arg3+"+3", "Arg 3 incorrect.");
+  VTKM_TEST_ASSERT(funcInterface.GetParameter<4>() == Type4(4)+Arg4, "Arg 4 incorrect.");
+  VTKM_TEST_ASSERT(funcInterface.GetParameter<5>() == Type5(5)+Arg5, "Arg 5 incorrect.");
 
   funcInterface.ForEachExec(ForEachFunctor());
-  VTKM_TEST_ASSERT(funcInterface.GetParameter<1>() == 4*Arg1, "Arg 1 incorrect.");
-  VTKM_TEST_ASSERT(funcInterface.GetParameter<2>() == 4*Arg2, "Arg 2 incorrect.");
-  VTKM_TEST_ASSERT(funcInterface.GetParameter<3>() == Arg3+"*2*2", "Arg 3 incorrect.");
-  VTKM_TEST_ASSERT(funcInterface.GetParameter<4>() == 4.0f*Arg4, "Arg 4 incorrect.");
-  VTKM_TEST_ASSERT(funcInterface.GetParameter<5>() == 4*Arg5, "Arg 5 incorrect.");
+  VTKM_TEST_ASSERT(funcInterface.GetParameter<1>() == Type1(2)+Arg1, "Arg 1 incorrect.");
+  VTKM_TEST_ASSERT(funcInterface.GetParameter<2>() == Type2(4)+Arg2, "Arg 2 incorrect.");
+  VTKM_TEST_ASSERT(funcInterface.GetParameter<3>() == Arg3+"+3+3", "Arg 3 incorrect.");
+  VTKM_TEST_ASSERT(funcInterface.GetParameter<4>() == Type4(8)+Arg4, "Arg 4 incorrect.");
+  VTKM_TEST_ASSERT(funcInterface.GetParameter<5>() == Type5(10)+Arg5, "Arg 5 incorrect.");
 }
 
 #ifdef TEST_INVOKE_TIME
diff --git a/vtkm/worklet/internal/DispatcherBase.h b/vtkm/worklet/internal/DispatcherBase.h
index db2716ac3..0a8f44f01 100644
--- a/vtkm/worklet/internal/DispatcherBase.h
+++ b/vtkm/worklet/internal/DispatcherBase.h
@@ -53,7 +53,7 @@ namespace detail {
 // tag. Causes a compile error otherwise.
 struct DispatcherBaseControlSignatureTagCheck
 {
-  template<typename ControlSignatureTag>
+  template<typename ControlSignatureTag, vtkm::IdComponent Index>
   struct ReturnType {
     // If you get a compile error here, it means there is something that is
     // not a valid control signature tag in a worklet's ControlSignature.
@@ -66,7 +66,7 @@ struct DispatcherBaseControlSignatureTagCheck
 // signature tag. Causes a compile error otherwise.
 struct DispatcherBaseExecutionSignatureTagCheck
 {
-  template<typename ExecutionSignatureTag>
+  template<typename ExecutionSignatureTag, vtkm::IdComponent Index>
   struct ReturnType {
     // If you get a compile error here, it means there is something that is not
     // a valid execution signature tag in a worklet's ExecutionSignature.
@@ -77,16 +77,16 @@ struct DispatcherBaseExecutionSignatureTagCheck
 
 // Used in the dynamic cast to check to make sure that the type passed into
 // the Invoke method matches the type accepted by the ControlSignature.
-template<typename ContinueFunctor, typename TypeCheckTag>
+template<typename ContinueFunctor,
+         typename TypeCheckTag,
+         vtkm::IdComponent Index>
 struct DispatcherBaseTypeCheckFunctor
 {
   const ContinueFunctor &Continue;
-  vtkm::IdComponent ParameterIndex;
 
   VTKM_CONT_EXPORT
-  DispatcherBaseTypeCheckFunctor(const ContinueFunctor &continueFunc,
-                                 vtkm::IdComponent parameterIndex)
-    : Continue(continueFunc), ParameterIndex(parameterIndex) {  }
+  DispatcherBaseTypeCheckFunctor(const ContinueFunctor &continueFunc)
+    : Continue(continueFunc) {  }
 
   template<typename T>
   VTKM_CONT_EXPORT
@@ -111,7 +111,7 @@ struct DispatcherBaseTypeCheckFunctor
   {
     std::stringstream message;
     message << "Encountered bad type for parameter "
-            << this->ParameterIndex
+            << Index
             << " when calling Invoke on a dispatcher.";
     throw vtkm::cont::ErrorControlBadType(message.str());
   }
@@ -120,33 +120,27 @@ struct DispatcherBaseTypeCheckFunctor
 // Uses vtkm::cont::internal::DynamicTransform and the DynamicTransformCont
 // method of FunctionInterface to convert all DynamicArrayHandles and any
 // other arguments declaring themselves as dynamic to static versions.
+template<typename ControlInterface>
 struct DispatcherBaseDynamicTransform
 {
-  vtkm::cont::internal::DynamicTransform BasicDynamicTransform;
-  vtkm::IdComponent *ParameterCounter;
-
+  template<typename InputType,
+           typename ContinueFunctor,
+           vtkm::IdComponent Index>
   VTKM_CONT_EXPORT
-  DispatcherBaseDynamicTransform(vtkm::IdComponent *parameterCounter)
-    : ParameterCounter(parameterCounter)
+  void operator()(const InputType &input,
+                  const ContinueFunctor &continueFunc,
+                  vtkm::internal::IndexTag<Index> indexTag) const
   {
-    *this->ParameterCounter = 0;
-  }
-
-  template<typename ControlSignatureTag,
-           typename InputType,
-           typename ContinueFunctor>
-  VTKM_CONT_EXPORT
-  void operator()(const vtkm::Pair<ControlSignatureTag, InputType> &input,
-                  const ContinueFunctor &continueFunc) const
-  {
-    (*this->ParameterCounter)++;
+    typedef typename ControlInterface::template ParameterType<Index>::type
+        ControlSignatureTag;
 
     typedef DispatcherBaseTypeCheckFunctor<
-        ContinueFunctor, typename ControlSignatureTag::TypeCheckTag>
+        ContinueFunctor, typename ControlSignatureTag::TypeCheckTag, Index>
         TypeCheckFunctor;
-    this->BasicDynamicTransform(input.second,
-                                TypeCheckFunctor(continueFunc,
-                                                 *this->ParameterCounter));
+
+    vtkm::cont::internal::DynamicTransform basicDynamicTransform;
+
+    basicDynamicTransform(input, TypeCheckFunctor(continueFunc), indexTag);
   }
 };
 
@@ -170,7 +164,7 @@ struct DispatcherBaseDynamicTransformHelper
 
 // A functor used in a StaticCast of a FunctionInterface to transport arguments
 // from the control environment to the execution environment.
-template<typename Device>
+template<typename ControlInterface, typename Device>
 struct DispatcherBaseTransportFunctor
 {
   vtkm::Id NumInstances;
@@ -178,25 +172,28 @@ struct DispatcherBaseTransportFunctor
   DispatcherBaseTransportFunctor(vtkm::Id numInstances)
     : NumInstances(numInstances) {  }
 
-  template<typename T>
+  template<typename ControlParameter, vtkm::IdComponent Index>
   struct InvokeTypes {
-    typedef typename T::FirstType::TransportTag TransportTag;
-    typedef typename T::SecondType ControlParameter;
+    typedef typename ControlInterface::template ParameterType<Index>::type
+        ControlSignatureTag;
+    typedef typename ControlSignatureTag::TransportTag TransportTag;
     typedef vtkm::cont::arg::Transport<TransportTag,ControlParameter,Device>
         TransportType;
   };
 
-  template<typename T>
+  template<typename ControlParameter, vtkm::IdComponent Index>
   struct ReturnType {
-    typedef typename InvokeTypes<T>::TransportType::ExecObjectType type;
+    typedef typename InvokeTypes<ControlParameter, Index>::
+        TransportType::ExecObjectType type;
   };
 
-  template<typename T>
+  template<typename ControlParameter, vtkm::IdComponent Index>
   VTKM_CONT_EXPORT
-  typename ReturnType<T>::type
-  operator()(const T &invokeData) const {
-    typename InvokeTypes<T>::TransportType transport;
-    return transport(invokeData.second, this->NumInstances);
+  typename ReturnType<ControlParameter, Index>::type
+  operator()(const ControlParameter &invokeData,
+             vtkm::internal::IndexTag<Index>) const {
+    typename InvokeTypes<ControlParameter, Index>::TransportType transport;
+    return transport(invokeData, this->NumInstances);
   }
 };
 
@@ -251,20 +248,13 @@ private:
     // type against the TypeCheckTag in the ControlSignature tags. To do this,
     // the check needs access to both the parameter (in the parameters
     // argument) and the ControlSignature tags (in the ControlInterface type).
-    // To make this possible, we use the zip mechanism of FunctionInterface to
-    // combine these two separate function interfaces into a single
-    // FunctionInterface with each parameter being a Pair containing both
-    // the ControlSignature tag and the control object itself.
-    typedef typename vtkm::internal::FunctionInterfaceZipType<
-        ControlInterface, ParameterInterface>::type ZippedInterface;
-    ZippedInterface zippedInterface =
-        vtkm::internal::make_FunctionInterfaceZip(ControlInterface(),
-                                                  parameters);
-
-    vtkm::IdComponent parameterIndexCounter;
-
-    zippedInterface.DynamicTransformCont(
-          detail::DispatcherBaseDynamicTransform(&parameterIndexCounter),
+    // To make this possible, we call DynamicTransform with a functor containing
+    // the control signature tags. It uses the index provided by the
+    // dynamic transform mechanism to get the right tag and make sure that
+    // the dynamic type is correct. (This prevents the compiler from expanding
+    // worklets with types that should not be.)
+    parameters.DynamicTransformCont(
+          detail::DispatcherBaseDynamicTransform<ControlInterface>(),
           detail::DispatcherBaseDynamicTransformHelper<MyType>(this));
   }
 
@@ -308,38 +298,25 @@ private:
   void InvokeTransportParameters(const Invocation &invocation,
                                  vtkm::Id numInstances) const
   {
-    // The first step in invoking a worklet is transport the arguments to the
-    // execution environment. The invocation object passed to this function
+    // The first step in invoking a worklet is to transport the arguments to
+    // the execution environment. The invocation object passed to this function
     // contains the parameters passed to Invoke in the control environment. We
     // will use the template magic in the FunctionInterface class to invoke the
-    // appropriate Transport class on each parameter to get a list of execution
-    // objects (corresponding to the arguments of the Invoke in the control
-    // environment) in a FunctionInterface.
+    // appropriate Transport class on each parameter and get a list of
+    // execution objects (corresponding to the arguments of the Invoke in the
+    // control environment) in a FunctionInterface. Specifically, we use a
+    // static transform of the FunctionInterface to call the transport on each
+    // argument and return the corresponding execution environment object.
+    typedef typename Invocation::ParameterInterface ParameterInterfaceType;
+    const ParameterInterfaceType &parameters = invocation.Parameters;
 
-    // The Transport relies on both the ControlSignature tag and the control
-    // object itself. To make it easier to work with each parameter, use the
-    // zip mechanism of FunctionInterface to combine the separate function
-    // interfaces of the ControlSignature and the parameters into one. This
-    // will make a FunctionInterface with each parameter being a Pair
-    // containing both the ControlSignature tag and the control object itself.
-    typedef typename vtkm::internal::FunctionInterfaceZipType<
-        typename Invocation::ControlInterface,
-        typename Invocation::ParameterInterface>::type ZippedInterface;
-    ZippedInterface zippedInterface =
-        vtkm::internal::make_FunctionInterfaceZip(
-          typename Invocation::ControlInterface(), invocation.Parameters);
+    typedef detail::DispatcherBaseTransportFunctor<
+        typename Invocation::ControlInterface, Device> TransportFunctorType;
+    typedef typename ParameterInterfaceType::template StaticTransformType<
+        TransportFunctorType>::type ExecObjectParameters;
 
-    // Use the StaticTransform mechanism to run the
-    // DispatcherBaseTransportFunctor on each parameter of the zipped
-    // interface. This functor will in turn run the appropriate Transform on
-    // the parameter and return the associated execution object. The end result
-    // of the transform is a FunctionInterface containing execution objects
-    // corresponding to each Invoke argument.
-    typedef detail::DispatcherBaseTransportFunctor<Device> TransportFunctor;
-    typedef typename ZippedInterface::template StaticTransformType<
-        TransportFunctor>::type ExecObjectParameters;
     ExecObjectParameters execObjectParameters =
-        zippedInterface.StaticTransformCont(TransportFunctor(numInstances));
+        parameters.StaticTransformCont(TransportFunctorType(numInstances));
 
     // Replace the parameters in the invocation with the execution object and
     // pass to next step of Invoke.