diff --git a/reclass/datatypes/exports.py b/reclass/datatypes/exports.py
index ea81912..dcd4976 100644
--- a/reclass/datatypes/exports.py
+++ b/reclass/datatypes/exports.py
@@ -7,8 +7,8 @@
 
 class Exports(Parameters):
 
-    def __init__(self, mapping=None, delimiter=None):
-        super(Exports, self).__init__(mapping, delimiter)
+    def __init__(self, mapping=None, delimiter=None, options=None):
+        super(Exports, self).__init__(mapping, delimiter, options)
 
     def __repr__(self):
         return '%s(%r, %r)' % (self.__class__.__name__, self._base,
@@ -22,9 +22,9 @@
         overdict = {'~' + key: value for key, value in other.iteritems()}
         self.merge(overdict)
 
-    def interpolate_from_external(self, external, options=None):
-        self._initialise_interpolate(options)
-        external._initialise_interpolate(options)
+    def interpolate_from_external(self, external):
+        self._initialise_interpolate()
+        external._initialise_interpolate()
         while len(self._unrendered) > 0:
             path, v = self._unrendered.iteritems().next()
             value = path.get_value(self._base)
diff --git a/reclass/datatypes/parameters.py b/reclass/datatypes/parameters.py
index 711db88..c935000 100644
--- a/reclass/datatypes/parameters.py
+++ b/reclass/datatypes/parameters.py
@@ -44,15 +44,17 @@
     DEFAULT_PATH_DELIMITER = PARAMETER_INTERPOLATION_DELIMITER
     DICT_KEY_OVERRIDE_PREFIX = PARAMETER_DICT_KEY_OVERRIDE_PREFIX
 
-    def __init__(self, mapping=None, delimiter=None):
+    def __init__(self, mapping=None, delimiter=None, options=None):
         if delimiter is None:
             delimiter = Parameters.DEFAULT_PATH_DELIMITER
+        if options is None:
+            options = MergeOptions()
         self._delimiter = delimiter
         self._base = {}
         self._unrendered = None
         self._escapes_handled = {}
-        self._options = None
         self._has_inv_query = False
+        self._options = options
         if mapping is not None:
             # we initialise by merging
             self._keep_overrides = True
@@ -228,7 +230,7 @@
             self._render_simple_container(item_list, n, value, path)
 
     def interpolate(self, inventory=None):
-        self._initialise_interpolate(self._options)
+        self._initialise_interpolate()
         while len(self._unrendered) > 0:
             # we could use a view here, but this is simple enough:
             # _interpolate_inner removes references from the refs hash after
@@ -236,16 +238,11 @@
             path, v = self._unrendered.iteritems().next()
             self._interpolate_inner(path, inventory)
 
-    def initialise_interpolation(self, options=None):
+    def initialise_interpolation(self):
         self._unrendered = None
-        self._initialise_interpolate(options)
+        self._initialise_interpolate()
 
-    def _initialise_interpolate(self, options):
-        if options is None:
-            self._options = MergeOptions()
-        else:
-            self._options = options
-
+    def _initialise_interpolate(self):
         if self._unrendered is None:
             self._unrendered = {}
             self._has_inv_query = False
diff --git a/reclass/datatypes/tests/test_parameters.py b/reclass/datatypes/tests/test_parameters.py
index 0eb7815..9ae854b 100644
--- a/reclass/datatypes/tests/test_parameters.py
+++ b/reclass/datatypes/tests/test_parameters.py
@@ -172,18 +172,18 @@
         l = ['foo', 1, 2]
         options = MergeOptions()
         options.allow_list_over_scalar = True
-        p1 = Parameters(dict(key=l[0]))
+        p1 = Parameters(dict(key=l[0]), options=options)
         p1.merge(Parameters(dict(key=l[1:])))
-        p1.initialise_interpolation(options)
+        p1.initialise_interpolation()
         self.assertListEqual(p1.as_dict()['key'], l)
 
     def test_merge_scalar_over_list(self):
         l = ['foo', 1, 2]
         options = MergeOptions()
         options.allow_scalar_over_list = True
-        p1 = Parameters(dict(key=l[:2]))
+        p1 = Parameters(dict(key=l[:2]), options=options)
         p1.merge(Parameters(dict(key=l[2])))
-        p1.initialise_interpolation(options)
+        p1.initialise_interpolation()
         self.assertEqual(p1.as_dict()['key'], l[2])
 
     def test_merge_dicts(self):
@@ -224,12 +224,12 @@
             p.interpolate()
 
     def test_merge_scalar_over_dict(self):
-        p = Parameters(dict(base=SIMPLE))
-        mergee = {'base':'foo'}
         options = MergeOptions()
         options.allow_scalar_over_dict = True
+        p = Parameters(dict(base=SIMPLE), options=options)
+        mergee = {'base':'foo'}
         p.merge(Parameters(mergee))
-        p.initialise_interpolation(options)
+        p.initialise_interpolation()
         self.assertDictEqual(p.as_dict(), mergee)
 
     def test_interpolate_single(self):