diff --git a/lib/puppet/functions/epp.rb b/lib/puppet/functions/epp.rb
index 30f83d44b..baa0c1bed 100644
--- a/lib/puppet/functions/epp.rb
+++ b/lib/puppet/functions/epp.rb
@@ -1,46 +1,54 @@
 # Evaluates an Embedded Puppet Template (EPP) file and returns the rendered text result as a String.
 #
-# EPP support the following tags:
+# The first argument to this function should be a `<MODULE NAME>/<TEMPLATE FILE>`
+# reference, which will load `<TEMPLATE FILE>` from a module's `templates`
+# directory. (For example, the reference `apache/vhost.conf.epp` will load the
+# file `<MODULES DIRECTORY>/apache/templates/vhost.conf.epp`.)
+#
+# The second argument is optional; if present, it should be a hash containing parameters for the
+# template. (See below.)
+#
+# EPP supports the following tags:
 #
 # * `<%= puppet expression %>` - This tag renders the value of the expression it contains.
 # * `<% puppet expression(s) %>` - This tag will execute the expression(s) it contains, but renders nothing.
 # * `<%# comment %>` - The tag and its content renders nothing.
 # * `<%%` or `%%>` - Renders a literal `<%` or `%>` respectively.
 # * `<%-` - Same as `<%` but suppresses any leading whitespace.
 # * `-%>` - Same as `%>` but suppresses any trailing whitespace on the same line (including line break).
 # * `<%- |parameters| -%>` - When placed as the first tag declares the template's parameters.
 #
 # File based EPP supports the following visibilities of variables in scope:
 #
 # * Global scope (i.e. top + node scopes) - global scope is always visible
 # * Global + all given arguments - if the EPP template does not declare parameters, and arguments are given
 # * Global + declared parameters - if the EPP declares parameters, given argument names must match
 #
 # EPP supports parameters by placing an optional parameter list as the very first element in the EPP. As an example,
 # `<%- |$x, $y, $z = 'unicorn'| -%>` when placed first in the EPP text declares that the parameters `x` and `y` must be
 # given as template arguments when calling `inline_epp`, and that `z` if not given as a template argument
 # defaults to `'unicorn'`. Template parameters are available as variables, e.g.arguments `$x`, `$y` and `$z` in the example.
 # Note that `<%-` must be used or any leading whitespace will be interpreted as text
 #
 # Arguments are passed to the template by calling `epp` with a Hash as the last argument, where parameters
 # are bound to values, e.g. `epp('...', {'x'=>10, 'y'=>20})`. Excess arguments may be given
 # (i.e. undeclared parameters) only if the EPP templates does not declare any parameters at all.
 # Template parameters shadow variables in outer scopes. File based epp does never have access to variables in the
 # scope where the `epp` function is called from.
 #
 # @see function inline_epp for examples of EPP
 # @since 3.5
 # @note Requires Future Parser
 Puppet::Functions.create_function(:epp, Puppet::Functions::InternalFunction) do
 
   dispatch :epp do
     scope_param()
     param 'String', 'path'
     param 'Hash[Pattern[/^\w+$/], Any]', 'parameters'
     arg_count(1, 2)
   end
 
   def epp(scope, path, parameters = nil)
     Puppet::Pops::Evaluator::EppEvaluator.epp(scope, path, scope.compiler.environment, parameters)
   end
 end
\ No newline at end of file
diff --git a/lib/puppet/parser/functions/epp.rb b/lib/puppet/parser/functions/epp.rb
index d15c3372a..5127aec71 100644
--- a/lib/puppet/parser/functions/epp.rb
+++ b/lib/puppet/parser/functions/epp.rb
@@ -1,37 +1,45 @@
 Puppet::Parser::Functions::newfunction(:epp, :type => :rvalue, :arity => -2, :doc =>
 "Evaluates an Embedded Puppet Template (EPP) file and returns the rendered text result as a String.
 
-EPP support the following tags:
+The first argument to this function should be a `<MODULE NAME>/<TEMPLATE FILE>`
+reference, which will load `<TEMPLATE FILE>` from a module's `templates`
+directory. (For example, the reference `apache/vhost.conf.epp` will load the
+file `<MODULES DIRECTORY>/apache/templates/vhost.conf.epp`.)
+
+The second argument is optional; if present, it should be a hash containing parameters for the
+template. (See below.)
+
+EPP supports the following tags:
 
 * `<%= puppet expression %>` - This tag renders the value of the expression it contains.
 * `<% puppet expression(s) %>` - This tag will execute the expression(s) it contains, but renders nothing.
 * `<%# comment %>` - The tag and its content renders nothing.
 * `<%%` or `%%>` - Renders a literal `<%` or `%>` respectively.
 * `<%-` - Same as `<%` but suppresses any leading whitespace.
 * `-%>` - Same as `%>` but suppresses any trailing whitespace on the same line (including line break).
 * `<%- |parameters| -%>` - When placed as the first tag declares the template's parameters.
 
 File based EPP supports the following visibilities of variables in scope:
 
 * Global scope (i.e. top + node scopes) - global scope is always visible
 * Global + all given arguments - if the EPP template does not declare parameters, and arguments are given
 * Global + declared parameters - if the EPP declares parameters, given argument names must match
 
 EPP supports parameters by placing an optional parameter list as the very first element in the EPP. As an example,
 `<%- |$x, $y, $z = 'unicorn'| -%>` when placed first in the EPP text declares that the parameters `x` and `y` must be
 given as template arguments when calling `inline_epp`, and that `z` if not given as a template argument
 defaults to `'unicorn'`. Template parameters are available as variables, e.g.arguments `$x`, `$y` and `$z` in the example.
 Note that `<%-` must be used or any leading whitespace will be interpreted as text
 
 Arguments are passed to the template by calling `epp` with a Hash as the last argument, where parameters
 are bound to values, e.g. `epp('...', {'x'=>10, 'y'=>20})`. Excess arguments may be given
 (i.e. undeclared parameters) only if the EPP templates does not declare any parameters at all.
 Template parameters shadow variables in outer scopes. File based epp does never have access to variables in the
 scope where the `epp` function is called from.
 
 - See function inline_epp for examples of EPP
 - Since 3.5
 - Requires Future Parser") do |args|
 
   function_fail(["epp() is only available when parser/evaluator future is in effect"])
 end
diff --git a/lib/puppet/parser/functions/file.rb b/lib/puppet/parser/functions/file.rb
index 23c27202b..cde496ab4 100644
--- a/lib/puppet/parser/functions/file.rb
+++ b/lib/puppet/parser/functions/file.rb
@@ -1,27 +1,31 @@
 Puppet::Parser::Functions::newfunction(
   :file, :arity => -2, :type => :rvalue,
-  :doc => "Return the contents of a single file from a list of file selectors.
-  The file selectors are used in turn to find a file. The first file that is
-  found is read and the contents are returned. If no files are found an error
-  is raised.
+  :doc => "Loads a file from a module and returns its contents as a string.
 
-  A file selector can either be an absolute path or be a module reference in
-  the form `modulename/filename`. A module reference will find the `filename`
-  relative the files directory of a module with the given `modulename`.
+  The argument to this function should be a `<MODULE NAME>/<FILE>`
+  reference, which will load `<FILE>` from a module's `files`
+  directory. (For example, the reference `mysql/mysqltuner.pl` will load the
+  file `<MODULES DIRECTORY>/mysql/files/mysqltuner.pl`.)
+
+  This function can also accept:
+
+  * An absolute path, which can load a file from anywhere on disk.
+  * Multiple arguments, which will return the contents of the **first** file
+  found, skipping any files that don't exist.
   "
 ) do |vals|
     path = nil
     vals.each do |file|
       found = Puppet::Parser::Files.find_file(file, compiler.environment)
       if found && Puppet::FileSystem.exist?(found)
         path = found
         break
       end
     end
 
     if path
       File.read(path)
     else
       raise Puppet::ParseError, "Could not find any files from #{vals.join(", ")}"
     end
 end
diff --git a/lib/puppet/parser/functions/template.rb b/lib/puppet/parser/functions/template.rb
index 0bd5a5424..c789347ac 100644
--- a/lib/puppet/parser/functions/template.rb
+++ b/lib/puppet/parser/functions/template.rb
@@ -1,23 +1,30 @@
 Puppet::Parser::Functions::newfunction(:template, :type => :rvalue, :arity => -2, :doc =>
-  "Evaluate a template and return its value.  See
-  [the templating docs](http://docs.puppetlabs.com/guides/templating.html) for
-  more information.
+  "Loads an ERB template from a module, evaluates it, and returns the resulting
+  value as a string.
 
-  Note that if multiple templates are specified, their output is all
-  concatenated and returned as the output of the function.") do |vals|
+  The argument to this function should be a `<MODULE NAME>/<TEMPLATE FILE>`
+  reference, which will load `<TEMPLATE FILE>` from a module's `templates`
+  directory. (For example, the reference `apache/vhost.conf.erb` will load the
+  file `<MODULES DIRECTORY>/apache/templates/vhost.conf.erb`.)
+
+  This function can also accept:
+
+  * An absolute path, which can load a template file from anywhere on disk.
+  * Multiple arguments, which will evaluate all of the specified templates and
+  return their outputs concatenated into a single string.") do |vals|
     vals.collect do |file|
       # Use a wrapper, so the template can't get access to the full
       # Scope object.
       debug "Retrieving template #{file}"
 
       wrapper = Puppet::Parser::TemplateWrapper.new(self)
       wrapper.file = file
       begin
         wrapper.result
       rescue => detail
         info = detail.backtrace.first.split(':')
         raise Puppet::ParseError,
           "Failed to parse template #{file}:\n  Filepath: #{info[0]}\n  Line: #{info[1]}\n  Detail: #{detail}\n"
       end
     end.join("")
 end
diff --git a/lib/puppet/type/file/content.rb b/lib/puppet/type/file/content.rb
index 87231a95f..2ac13becb 100644
--- a/lib/puppet/type/file/content.rb
+++ b/lib/puppet/type/file/content.rb
@@ -1,240 +1,241 @@
 require 'net/http'
 require 'uri'
 require 'tempfile'
 
 require 'puppet/util/checksums'
 require 'puppet/network/http'
 require 'puppet/network/http/compression'
 
 module Puppet
   Puppet::Type.type(:file).newproperty(:content) do
     include Puppet::Util::Diff
     include Puppet::Util::Checksums
     include Puppet::Network::HTTP::Compression.module
 
     attr_reader :actual_content
 
     desc <<-'EOT'
       The desired contents of a file, as a string. This attribute is mutually
       exclusive with `source` and `target`.
 
       Newlines and tabs can be specified in double-quoted strings using
       standard escaped syntax --- \n for a newline, and \t for a tab.
 
       With very small files, you can construct content strings directly in
       the manifest...
 
           define resolve(nameserver1, nameserver2, domain, search) {
               $str = "search $search
                   domain $domain
                   nameserver $nameserver1
                   nameserver $nameserver2
                   "
 
               file { "/etc/resolv.conf":
                 content => "$str",
               }
           }
 
       ...but for larger files, this attribute is more useful when combined with the
       [template](http://docs.puppetlabs.com/references/latest/function.html#template)
+      or [file](http://docs.puppetlabs.com/references/latest/function.html#file)
       function.
     EOT
 
     # Store a checksum as the value, rather than the actual content.
     # Simplifies everything.
     munge do |value|
       if value == :absent
         value
       elsif checksum?(value)
         # XXX This is potentially dangerous because it means users can't write a file whose
         # entire contents are a plain checksum
         value
       else
         @actual_content = value
         resource.parameter(:checksum).sum(value)
       end
     end
 
     # Checksums need to invert how changes are printed.
     def change_to_s(currentvalue, newvalue)
       # Our "new" checksum value is provided by the source.
       if source = resource.parameter(:source) and tmp = source.checksum
         newvalue = tmp
       end
       if currentvalue == :absent
         return "defined content as '#{newvalue}'"
       elsif newvalue == :absent
         return "undefined content from '#{currentvalue}'"
       else
         return "content changed '#{currentvalue}' to '#{newvalue}'"
       end
     end
 
     def checksum_type
       if source = resource.parameter(:source)
         result = source.checksum
       else
         result = resource[:checksum]
       end
       if result =~ /^\{(\w+)\}.+/
         return $1.to_sym
       else
         return result
       end
     end
 
     def length
       (actual_content and actual_content.length) || 0
     end
 
     def content
       self.should
     end
 
     # Override this method to provide diffs if asked for.
     # Also, fix #872: when content is used, and replace is true, the file
     # should be insync when it exists
     def insync?(is)
       if resource.should_be_file?
         return false if is == :absent
       else
         if resource[:ensure] == :present and resource[:content] and s = resource.stat
           resource.warning "Ensure set to :present but file type is #{s.ftype} so no content will be synced"
         end
         return true
       end
 
       return true if ! @resource.replace?
 
       result = super
 
       if ! result and Puppet[:show_diff] and resource.show_diff?
         write_temporarily do |path|
           send @resource[:loglevel], "\n" + diff(@resource[:path], path)
         end
       end
       result
     end
 
     def retrieve
       return :absent unless stat = @resource.stat
       ftype = stat.ftype
       # Don't even try to manage the content on directories or links
       return nil if ["directory","link"].include?(ftype)
 
       begin
         resource.parameter(:checksum).sum_file(resource[:path])
       rescue => detail
         raise Puppet::Error, "Could not read #{ftype} #{@resource.title}: #{detail}", detail.backtrace
       end
     end
 
     # Make sure we're also managing the checksum property.
     def should=(value)
       # treat the value as a bytestring, in Ruby versions that support it, regardless of the encoding
       # in which it has been supplied
       value = value.clone.force_encoding(Encoding::ASCII_8BIT) if value.respond_to?(:force_encoding)
       @resource.newattr(:checksum) unless @resource.parameter(:checksum)
       super
     end
 
     # Just write our content out to disk.
     def sync
       return_event = @resource.stat ? :file_changed : :file_created
 
       # We're safe not testing for the 'source' if there's no 'should'
       # because we wouldn't have gotten this far if there weren't at least
       # one valid value somewhere.
       @resource.write(:content)
 
       return_event
     end
 
     def write_temporarily
       tempfile = Tempfile.new("puppet-file")
       tempfile.open
 
       write(tempfile)
 
       tempfile.close
 
       yield tempfile.path
 
       tempfile.delete
     end
 
     def write(file)
       resource.parameter(:checksum).sum_stream { |sum|
         each_chunk_from(actual_content || resource.parameter(:source)) { |chunk|
           sum << chunk
           file.print chunk
         }
       }
     end
 
     # the content is munged so if it's a checksum source_or_content is nil
     # unless the checksum indirectly comes from source
     def each_chunk_from(source_or_content)
       if source_or_content.is_a?(String)
         yield source_or_content
       elsif content_is_really_a_checksum? && source_or_content.nil?
         yield read_file_from_filebucket
       elsif source_or_content.nil?
         yield ''
       elsif Puppet[:default_file_terminus] == :file_server
         yield source_or_content.content
       elsif source_or_content.local?
         chunk_file_from_disk(source_or_content) { |chunk| yield chunk }
       else
         chunk_file_from_source(source_or_content) { |chunk| yield chunk }
       end
     end
 
     private
 
     def content_is_really_a_checksum?
       checksum?(should)
     end
 
     def chunk_file_from_disk(source_or_content)
       File.open(source_or_content.full_path, "rb") do |src|
         while chunk = src.read(8192)
           yield chunk
         end
       end
     end
 
     def get_from_source(source_or_content, &block)
       source = source_or_content.metadata.source
       request = Puppet::Indirector::Request.new(:file_content, :find, source, nil, :environment => resource.catalog.environment)
 
       request.do_request(:fileserver) do |req|
         connection = Puppet::Network::HttpPool.http_instance(req.server, req.port)
         connection.request_get(Puppet::Network::HTTP::API::V1.indirection2uri(req), add_accept_encoding({"Accept" => "raw"}), &block)
       end
     end
 
 
     def chunk_file_from_source(source_or_content)
       get_from_source(source_or_content) do |response|
         case response.code
         when /^2/;  uncompress(response) { |uncompressor| response.read_body { |chunk| yield uncompressor.uncompress(chunk) } }
         else
           # Raise the http error if we didn't get a 'success' of some kind.
           message = "Error #{response.code} on SERVER: #{(response.body||'').empty? ? response.message : uncompress_body(response)}"
           raise Net::HTTPError.new(message, response)
         end
       end
     end
 
     def read_file_from_filebucket
       raise "Could not get filebucket from file" unless dipper = resource.bucket
       sum = should.sub(/\{\w+\}/, '')
 
       dipper.getfile(sum)
     rescue => detail
       self.fail Puppet::Error, "Could not retrieve content for #{should} from filebucket: #{detail}", detail
     end
   end
 end