diff --git a/spec/unit/functions/shared.rb b/spec/shared_behaviours/iterative_functions.rb
similarity index 100%
rename from spec/unit/functions/shared.rb
rename to spec/shared_behaviours/iterative_functions.rb
diff --git a/spec/unit/functions/each_spec.rb b/spec/unit/functions/each_spec.rb
index 8276587c9..d6651cf5a 100644
--- a/spec/unit/functions/each_spec.rb
+++ b/spec/unit/functions/each_spec.rb
@@ -1,111 +1,111 @@
 require 'puppet'
 require 'spec_helper'
 require 'puppet_spec/compiler'
 
-require 'unit/functions/shared'
+require 'shared_behaviours/iterative_functions'
 
 describe 'the each method' do
   include PuppetSpec::Compiler
 
   before :each do
     Puppet[:parser] = 'future'
   end
 
   context "should be callable as" do
     it 'each on an array selecting each value' do
       catalog = compile_to_catalog(<<-MANIFEST)
         $a = [1,2,3]
         $a.each |$v| {
           file { "/file_$v": ensure => present }
         }
       MANIFEST
 
       catalog.resource(:file, "/file_1")['ensure'].should == 'present'
       catalog.resource(:file, "/file_2")['ensure'].should == 'present'
       catalog.resource(:file, "/file_3")['ensure'].should == 'present'
     end
 
     it 'each on an array selecting each value - function call style' do
       catalog = compile_to_catalog(<<-MANIFEST)
         $a = [1,2,3]
         each ($a) |$index, $v| {
           file { "/file_$v": ensure => present }
         }
       MANIFEST
 
       catalog.resource(:file, "/file_1")['ensure'].should == 'present'
       catalog.resource(:file, "/file_2")['ensure'].should == 'present'
       catalog.resource(:file, "/file_3")['ensure'].should == 'present'
     end
 
     it 'each on an array with index' do
       catalog = compile_to_catalog(<<-MANIFEST)
         $a = [present, absent, present]
         $a.each |$k,$v| {
           file { "/file_${$k+1}": ensure => $v }
         }
       MANIFEST
 
       catalog.resource(:file, "/file_1")['ensure'].should == 'present'
       catalog.resource(:file, "/file_2")['ensure'].should == 'absent'
       catalog.resource(:file, "/file_3")['ensure'].should == 'present'
     end
 
     it 'each on a hash selecting entries' do
       catalog = compile_to_catalog(<<-MANIFEST)
         $a = {'a'=>'present','b'=>'absent','c'=>'present'}
         $a.each |$e| {
         file { "/file_${e[0]}": ensure => $e[1] }
         }
       MANIFEST
 
       catalog.resource(:file, "/file_a")['ensure'].should == 'present'
       catalog.resource(:file, "/file_b")['ensure'].should == 'absent'
       catalog.resource(:file, "/file_c")['ensure'].should == 'present'
     end
 
     it 'each on a hash selecting key and value' do
       catalog = compile_to_catalog(<<-MANIFEST)
         $a = {'a'=>present,'b'=>absent,'c'=>present}
         $a.each |$k, $v| {
           file { "/file_$k": ensure => $v }
         }
       MANIFEST
 
       catalog.resource(:file, "/file_a")['ensure'].should == 'present'
       catalog.resource(:file, "/file_b")['ensure'].should == 'absent'
       catalog.resource(:file, "/file_c")['ensure'].should == 'present'
     end
 
     it 'each on a hash selecting key and value (using captures-last parameter)' do
       catalog = compile_to_catalog(<<-MANIFEST)
         $a = {'a'=>present,'b'=>absent,'c'=>present}
         $a.each |*$kv| {
           file { "/file_${kv[0]}": ensure => $kv[1] }
         }
       MANIFEST
 
       catalog.resource(:file, "/file_a")['ensure'].should == 'present'
       catalog.resource(:file, "/file_b")['ensure'].should == 'absent'
       catalog.resource(:file, "/file_c")['ensure'].should == 'present'
     end
   end
 
   context "should produce receiver" do
     it 'each checking produced value using single expression' do
       catalog = compile_to_catalog(<<-MANIFEST)
         $a = [1, 3, 2]
         $b = $a.each |$x| { "unwanted" }
         file { "/file_${b[1]}":
           ensure => present
         }
       MANIFEST
 
       catalog.resource(:file, "/file_3")['ensure'].should == 'present'
     end
 
   end
   it_should_behave_like 'all iterative functions argument checks', 'each'
   it_should_behave_like 'all iterative functions hash handling', 'each'
 
 end
diff --git a/spec/unit/functions/filter_spec.rb b/spec/unit/functions/filter_spec.rb
index d33320149..e904c6751 100644
--- a/spec/unit/functions/filter_spec.rb
+++ b/spec/unit/functions/filter_spec.rb
@@ -1,131 +1,131 @@
 require 'puppet'
 require 'spec_helper'
 require 'puppet_spec/compiler'
 require 'matchers/resource'
 
-require 'unit/functions/shared'
+require 'shared_behaviours/iterative_functions'
 
 describe 'the filter method' do
   include PuppetSpec::Compiler
   include Matchers::Resource
 
   before :each do
     Puppet[:parser] = 'future'
   end
 
   it 'should filter on an array (all berries)' do
     catalog = compile_to_catalog(<<-MANIFEST)
       $a = ['strawberry','blueberry','orange']
       $a.filter |$x|{ $x  =~ /berry$/}.each |$v|{
         file { "/file_$v": ensure => present }
       }
     MANIFEST
 
     expect(catalog).to have_resource("File[/file_strawberry]").with_parameter(:ensure, 'present')
     expect(catalog).to have_resource("File[/file_blueberry]").with_parameter(:ensure, 'present')
   end
 
   it 'should filter on enumerable type (Integer)' do
     catalog = compile_to_catalog(<<-MANIFEST)
       $a = Integer[1,10]
       $a.filter |$x|{ $x  % 3 == 0}.each |$v|{
         file { "/file_$v": ensure => present }
       }
     MANIFEST
 
     expect(catalog).to have_resource("File[/file_3]").with_parameter(:ensure, 'present')
     expect(catalog).to have_resource("File[/file_6]").with_parameter(:ensure, 'present')
     expect(catalog).to have_resource("File[/file_9]").with_parameter(:ensure, 'present')
   end
 
   it 'should filter on enumerable type (Integer) using two args index/value' do
     catalog = compile_to_catalog(<<-MANIFEST)
       $a = Integer[10,18]
       $a.filter |$i, $x|{ $i  % 3 == 0}.each |$v|{
         file { "/file_$v": ensure => present }
       }
     MANIFEST
 
     expect(catalog).to have_resource("File[/file_10]").with_parameter(:ensure, 'present')
     expect(catalog).to have_resource("File[/file_13]").with_parameter(:ensure, 'present')
     expect(catalog).to have_resource("File[/file_16]").with_parameter(:ensure, 'present')
   end
 
   it 'should produce an array when acting on an array' do
     catalog = compile_to_catalog(<<-MANIFEST)
       $a = ['strawberry','blueberry','orange']
       $b = $a.filter |$x|{ $x  =~ /berry$/}
       file { "/file_${b[0]}": ensure => present }
       file { "/file_${b[1]}": ensure => present }
     MANIFEST
 
     expect(catalog).to have_resource("File[/file_strawberry]").with_parameter(:ensure, 'present')
     expect(catalog).to have_resource("File[/file_blueberry]").with_parameter(:ensure, 'present')
   end
 
   it 'can filter array using index and value' do
     catalog = compile_to_catalog(<<-MANIFEST)
       $a = ['strawberry','blueberry','orange']
       $b = $a.filter |$index, $x|{ $index  == 0 or $index ==2}
       file { "/file_${b[0]}": ensure => present }
       file { "/file_${b[1]}": ensure => present }
     MANIFEST
 
     expect(catalog).to have_resource("File[/file_strawberry]").with_parameter(:ensure, 'present')
     expect(catalog).to have_resource("File[/file_orange]").with_parameter(:ensure, 'present')
   end
 
   it 'can filter array using index and value (using captures-rest)' do
     catalog = compile_to_catalog(<<-MANIFEST)
       $a = ['strawberry','blueberry','orange']
       $b = $a.filter |*$ix|{ $ix[0]  == 0 or $ix[0] ==2}
       file { "/file_${b[0]}": ensure => present }
       file { "/file_${b[1]}": ensure => present }
     MANIFEST
 
     expect(catalog).to have_resource("File[/file_strawberry]").with_parameter(:ensure, 'present')
     expect(catalog).to have_resource("File[/file_orange]").with_parameter(:ensure, 'present')
   end
 
   it 'filters on a hash (all berries) by key' do
     catalog = compile_to_catalog(<<-MANIFEST)
       $a = {'strawberry'=>'red','blueberry'=>'blue','orange'=>'orange'}
       $a.filter |$x|{ $x[0]  =~ /berry$/}.each |$v|{
         file { "/file_${v[0]}": ensure => present }
       }
     MANIFEST
 
     expect(catalog).to have_resource("File[/file_strawberry]").with_parameter(:ensure, 'present')
     expect(catalog).to have_resource("File[/file_blueberry]").with_parameter(:ensure, 'present')
   end
 
   it 'should produce a hash when acting on a hash' do
     catalog = compile_to_catalog(<<-MANIFEST)
       $a = {'strawberry'=>'red','blueberry'=>'blue','orange'=>'orange'}
       $b = $a.filter |$x|{ $x[0]  =~ /berry$/}
       file { "/file_${b['strawberry']}": ensure => present }
       file { "/file_${b['blueberry']}": ensure => present }
       file { "/file_${b['orange']}": ensure => present }
 
     MANIFEST
 
     expect(catalog).to have_resource("File[/file_red]").with_parameter(:ensure, 'present')
     expect(catalog).to have_resource("File[/file_blue]").with_parameter(:ensure, 'present')
     expect(catalog).to have_resource("File[/file_]").with_parameter(:ensure, 'present')
   end
 
   it 'filters on a hash (all berries) by value' do
     catalog = compile_to_catalog(<<-MANIFEST)
       $a = {'strawb'=>'red berry','blueb'=>'blue berry','orange'=>'orange fruit'}
       $a.filter |$x|{ $x[1]  =~ /berry$/}.each |$v|{
         file { "/file_${v[0]}": ensure => present }
       }
     MANIFEST
 
     expect(catalog).to have_resource("File[/file_strawb]").with_parameter(:ensure, 'present')
     expect(catalog).to have_resource("File[/file_blueb]").with_parameter(:ensure, 'present')
   end
 
   it_should_behave_like 'all iterative functions argument checks', 'filter'
   it_should_behave_like 'all iterative functions hash handling', 'filter'
 end
diff --git a/spec/unit/functions/map_spec.rb b/spec/unit/functions/map_spec.rb
index 6c482066d..e1b09cf24 100644
--- a/spec/unit/functions/map_spec.rb
+++ b/spec/unit/functions/map_spec.rb
@@ -1,169 +1,169 @@
 require 'puppet'
 require 'spec_helper'
 require 'puppet_spec/compiler'
 require 'matchers/resource'
 
-require 'unit/functions/shared'
+require 'shared_behaviours/iterative_functions'
 
 describe 'the map method' do
   include PuppetSpec::Compiler
   include Matchers::Resource
 
   before :each do
     Puppet[:parser] = "future"
   end
 
   context "using future parser" do
     it 'map on an array (multiplying each value by 2)' do
       catalog = compile_to_catalog(<<-MANIFEST)
         $a = [1,2,3]
         $a.map |$x|{ $x*2}.each |$v|{
           file { "/file_$v": ensure => present }
         }
       MANIFEST
 
       expect(catalog).to have_resource("File[/file_2]").with_parameter(:ensure, 'present')
       expect(catalog).to have_resource("File[/file_4]").with_parameter(:ensure, 'present')
       expect(catalog).to have_resource("File[/file_6]").with_parameter(:ensure, 'present')
     end
 
     it 'map on an enumerable type (multiplying each value by 2)' do
       catalog = compile_to_catalog(<<-MANIFEST)
         $a = Integer[1,3]
         $a.map |$x|{ $x*2}.each |$v|{
           file { "/file_$v": ensure => present }
         }
       MANIFEST
 
       expect(catalog).to have_resource("File[/file_2]").with_parameter(:ensure, 'present')
       expect(catalog).to have_resource("File[/file_4]").with_parameter(:ensure, 'present')
       expect(catalog).to have_resource("File[/file_6]").with_parameter(:ensure, 'present')
     end
 
     it 'map on an integer (multiply each by 3)' do
       catalog = compile_to_catalog(<<-MANIFEST)
         3.map |$x|{ $x*3}.each |$v|{
           file { "/file_$v": ensure => present }
         }
       MANIFEST
 
       expect(catalog).to have_resource("File[/file_0]").with_parameter(:ensure, 'present')
       expect(catalog).to have_resource("File[/file_3]").with_parameter(:ensure, 'present')
       expect(catalog).to have_resource("File[/file_6]").with_parameter(:ensure, 'present')
     end
 
     it 'map on a string' do
       catalog = compile_to_catalog(<<-MANIFEST)
         $a = {a=>x, b=>y}
         "ab".map |$x|{$a[$x]}.each |$v|{
           file { "/file_$v": ensure => present }
         }
       MANIFEST
 
       expect(catalog).to have_resource("File[/file_x]").with_parameter(:ensure, 'present')
       expect(catalog).to have_resource("File[/file_y]").with_parameter(:ensure, 'present')
     end
 
     it 'map on an array (multiplying value by 10 in even index position)' do
       catalog = compile_to_catalog(<<-MANIFEST)
         $a = [1,2,3]
         $a.map |$i, $x|{ if $i % 2 == 0 {$x} else {$x*10}}.each |$v|{
           file { "/file_$v": ensure => present }
         }
       MANIFEST
 
       expect(catalog).to have_resource("File[/file_1]").with_parameter(:ensure, 'present')
       expect(catalog).to have_resource("File[/file_20]").with_parameter(:ensure, 'present')
       expect(catalog).to have_resource("File[/file_3]").with_parameter(:ensure, 'present')
     end
 
     it 'map on a hash selecting keys' do
       catalog = compile_to_catalog(<<-MANIFEST)
       $a = {'a'=>1,'b'=>2,'c'=>3}
       $a.map |$x|{ $x[0]}.each |$k|{
           file { "/file_$k": ensure => present }
         }
       MANIFEST
 
       expect(catalog).to have_resource("File[/file_a]").with_parameter(:ensure, 'present')
       expect(catalog).to have_resource("File[/file_b]").with_parameter(:ensure, 'present')
       expect(catalog).to have_resource("File[/file_c]").with_parameter(:ensure, 'present')
     end
 
     it 'map on a hash selecting keys - using two block parameters' do
       catalog = compile_to_catalog(<<-MANIFEST)
       $a = {'a'=>1,'b'=>2,'c'=>3}
       $a.map |$k,$v|{ file { "/file_$k": ensure => present }
         }
       MANIFEST
 
       expect(catalog).to have_resource("File[/file_a]").with_parameter(:ensure, 'present')
       expect(catalog).to have_resource("File[/file_b]").with_parameter(:ensure, 'present')
       expect(catalog).to have_resource("File[/file_c]").with_parameter(:ensure, 'present')
     end
 
     it 'map on a hash using captures-last parameter' do
       catalog = compile_to_catalog(<<-MANIFEST)
       $a = {'a'=>present,'b'=>absent,'c'=>present}
       $a.map |*$kv|{ file { "/file_${kv[0]}": ensure => $kv[1] } }
       MANIFEST
 
       expect(catalog).to have_resource("File[/file_a]").with_parameter(:ensure, 'present')
       expect(catalog).to have_resource("File[/file_b]").with_parameter(:ensure, 'absent')
       expect(catalog).to have_resource("File[/file_c]").with_parameter(:ensure, 'present')
     end
 
     it 'each on a hash selecting value' do
       catalog = compile_to_catalog(<<-MANIFEST)
       $a = {'a'=>1,'b'=>2,'c'=>3}
       $a.map |$x|{ $x[1]}.each |$k|{ file { "/file_$k": ensure => present } }
       MANIFEST
 
       expect(catalog).to have_resource("File[/file_1]").with_parameter(:ensure, 'present')
       expect(catalog).to have_resource("File[/file_2]").with_parameter(:ensure, 'present')
       expect(catalog).to have_resource("File[/file_3]").with_parameter(:ensure, 'present')
     end
 
     it 'each on a hash selecting value - using two block parameters' do
       catalog = compile_to_catalog(<<-MANIFEST)
       $a = {'a'=>1,'b'=>2,'c'=>3}
       $a.map |$k,$v|{ file { "/file_$v": ensure => present } }
       MANIFEST
 
       expect(catalog).to have_resource("File[/file_1]").with_parameter(:ensure, 'present')
       expect(catalog).to have_resource("File[/file_2]").with_parameter(:ensure, 'present')
       expect(catalog).to have_resource("File[/file_3]").with_parameter(:ensure, 'present')
     end
 
     context "handles data type corner cases" do
       it "map gets values that are false" do
         catalog = compile_to_catalog(<<-MANIFEST)
           $a = [false,false]
           $a.map |$x| { $x }.each |$i, $v| {
             file { "/file_$i.$v": ensure => present }
           }
         MANIFEST
 
         expect(catalog).to have_resource("File[/file_0.false]").with_parameter(:ensure, 'present')
         expect(catalog).to have_resource("File[/file_1.false]").with_parameter(:ensure, 'present')
       end
 
       it "map gets values that are nil" do
         Puppet::Parser::Functions.newfunction(:nil_array, :type => :rvalue) do |args|
           [nil]
         end
         catalog = compile_to_catalog(<<-MANIFEST)
           $a = nil_array()
           $a.map |$x| { $x }.each |$i, $v| {
             file { "/file_$i.$v": ensure => present }
           }
         MANIFEST
 
         expect(catalog).to have_resource("File[/file_0.]").with_parameter(:ensure, 'present')
       end
     end
 
   it_should_behave_like 'all iterative functions argument checks', 'map'
   it_should_behave_like 'all iterative functions hash handling', 'map'
   end
 end
diff --git a/spec/unit/functions/reduce_spec.rb b/spec/unit/functions/reduce_spec.rb
index e3442fc2a..032f6ccc4 100644
--- a/spec/unit/functions/reduce_spec.rb
+++ b/spec/unit/functions/reduce_spec.rb
@@ -1,95 +1,96 @@
 require 'puppet'
 require 'spec_helper'
 require 'puppet_spec/compiler'
 require 'matchers/resource'
+require 'shared_behaviours/iterative_functions'
 
 describe 'the reduce method' do
   include PuppetSpec::Compiler
   include Matchers::Resource
 
   before :all do
     # enable switching back 
     @saved_parser = Puppet[:parser]
     # These tests only work with future parser
   end
   after :all do
     # switch back to original 
     Puppet[:parser] = @saved_parser
   end
 
   before :each do
     node      = Puppet::Node.new("floppy", :environment => 'production')
     @compiler = Puppet::Parser::Compiler.new(node)
     @scope    = Puppet::Parser::Scope.new(@compiler)
     @topscope = @scope.compiler.topscope
     @scope.parent = @topscope
     Puppet[:parser] = 'future'
   end
 
   context "should be callable as" do
     it 'reduce on an array' do
       catalog = compile_to_catalog(<<-MANIFEST)
         $a = [1,2,3]
         $b = $a.reduce |$memo, $x| { $memo + $x }
         file { "/file_$b": ensure => present }
       MANIFEST
 
       expect(catalog).to have_resource("File[/file_6]").with_parameter(:ensure, 'present')
     end
 
     it 'reduce on an array with captures rest in lambda' do
       catalog = compile_to_catalog(<<-MANIFEST)
         $a = [1,2,3]
         $b = $a.reduce |*$mx| { $mx[0] + $mx[1] }
         file { "/file_$b": ensure => present }
       MANIFEST
 
       expect(catalog).to have_resource("File[/file_6]").with_parameter(:ensure, 'present')
     end
 
     it 'reduce on enumerable type' do
       catalog = compile_to_catalog(<<-MANIFEST)
         $a = Integer[1,3]
         $b = $a.reduce |$memo, $x| { $memo + $x }
         file { "/file_$b": ensure => present }
       MANIFEST
 
       expect(catalog).to have_resource("File[/file_6]").with_parameter(:ensure, 'present')
     end
 
     it 'reduce on an array with start value' do
       catalog = compile_to_catalog(<<-MANIFEST)
         $a = [1,2,3]
         $b = $a.reduce(4) |$memo, $x| { $memo + $x }
         file { "/file_$b": ensure => present }
       MANIFEST
 
       expect(catalog).to have_resource("File[/file_10]").with_parameter(:ensure, 'present')
     end
 
     it 'reduce on a hash' do
       catalog = compile_to_catalog(<<-MANIFEST)
         $a = {a=>1, b=>2, c=>3}
         $start = [ignored, 4]
         $b = $a.reduce |$memo, $x| {['sum', $memo[1] + $x[1]] }
         file { "/file_${$b[0]}_${$b[1]}": ensure => present }
       MANIFEST
 
       expect(catalog).to have_resource("File[/file_sum_6]").with_parameter(:ensure, 'present')
     end
 
     it 'reduce on a hash with start value' do
       catalog = compile_to_catalog(<<-MANIFEST)
         $a = {a=>1, b=>2, c=>3}
         $start = ['ignored', 4]
         $b = $a.reduce($start) |$memo, $x| { ['sum', $memo[1] + $x[1]] }
         file { "/file_${$b[0]}_${$b[1]}": ensure => present }
       MANIFEST
 
       expect(catalog).to have_resource("File[/file_sum_10]").with_parameter(:ensure, 'present')
     end
   end
 
   it_should_behave_like 'all iterative functions argument checks', 'reduce'
 
 end