puppet 5.0.0 → 6.0.0

data/lib/puppet/parser/functions/inline_template.rb

@@ -1,9 +1,15 @@
 Puppet::Parser::Functions::newfunction(:inline_template, :type => :rvalue, :arity => -2, :doc =>
   "Evaluate a template string and return its value.  See
-  [the templating docs](https://docs.puppetlabs.com/puppet/latest/reference/lang_template.html) for
+  [the templating docs](https://puppet.com/docs/puppet/latest/lang_template.html) for
   more information. Note that if multiple template strings are specified, their
   output is all concatenated and returned as the output of the function.") do |vals|
 
+  if Puppet[:tasks]
+    raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
+      Puppet::Pops::Issues::FEATURE_NOT_SUPPORTED_WHEN_SCRIPTING,
+      {:feature => 'ERB inline_template'})
+  end
+
   require 'erb'
 
     vals.collect do |string|
@@ -14,8 +20,7 @@ Puppet::Parser::Functions::newfunction(:inline_template, :type => :rvalue, :arit
       begin
         wrapper.result(string)
       rescue => detail
-        raise Puppet::ParseError,
-          _("Failed to parse inline template: %{detail}") % { detail: detail }, detail.backtrace
+        raise Puppet::ParseError, _("Failed to parse inline template: %{detail}") % { detail: detail }, detail.backtrace
       end
     end.join("")
 end

data/lib/puppet/parser/functions/lest.rb

@@ -3,7 +3,7 @@ Puppet::Parser::Functions::newfunction(
   :type => :rvalue,
   :arity => -2,
   :doc => <<-DOC
-Call a [lambda](https://docs.puppet.com/puppet/latest/reference/lang_lambdas.html)
+Call a [lambda](https://puppet.com/docs/puppet/latest/lang_lambdas.html)
 (which should accept no arguments) if the argument given to the function is `undef`.
 Returns the result of calling the lambda if the argument is `undef`, otherwise the
 given argument.
@@ -45,5 +45,5 @@ Would notice the value `20`
 * Since 4.5.0
 DOC
 ) do |args|
-  Error.is4x('lest')
+  Puppet::Parser::Functions::Error.is4x('lest')
 end

data/lib/puppet/parser/functions/lookup.rb

@@ -31,7 +31,7 @@ The arguments accepted by `lookup` are as follows:
     first key, it will try again with the subsequent ones, only resorting to a
     default value if none of them succeed.
 2. `<VALUE TYPE>` (data type) --- A
-[data type](https://docs.puppetlabs.com/puppet/latest/reference/lang_data_type.html)
+[data type](https://puppet.com/docs/puppet/latest/lang_data_type.html)
 that must match the retrieved value; if not, the lookup (and catalog
 compilation) will fail. Defaults to `Data` (accepts any normal value).
 3. `<MERGE BEHAVIOR>` (string or hash; see **"Merge Behaviors"** below) ---

data/lib/puppet/parser/functions/map.rb

@@ -3,7 +3,7 @@ Puppet::Parser::Functions::newfunction(
   :type => :rvalue,
   :arity => -3,
   :doc => <<-DOC
-Applies a [lambda](https://docs.puppetlabs.com/puppet/latest/reference/lang_lambdas.html)
+Applies a [lambda](https://puppet.com/docs/puppet/latest/lang_lambdas.html)
 to every value in a data structure and returns an array containing the results.
 
 This function takes two mandatory arguments, in this order:
@@ -72,5 +72,5 @@ $transformed_data = $data.map |$key,$value| { $value }
 - Since 4.0.0
 DOC
 ) do |args|
-  Error.is4x('map')
+  Puppet::Parser::Functions::Error.is4x('map')
 end

data/lib/puppet/parser/functions/match.rb

@@ -39,5 +39,5 @@ $matches = ["abc123","def456"].match(/([a-z]+)([1-9]+)/)
 - Since 4.0.0
 DOC
 ) do |args|
-  Error.is4x('match')
+  Puppet::Parser::Functions::Error.is4x('match')
 end

data/lib/puppet/parser/functions/new.rb

@@ -56,16 +56,14 @@ Would fail with an assertion error (since value is less than 0).
 The following sections show the arguments and conversion rules
 per data type built into the Puppet Type System.
 
-Conversion to Optional[T] and NotUndef[T]
------------------------------------------
+### Conversion to Optional[T] and NotUndef[T]
 
 Conversion to these data types is the same as a conversion to the type argument `T`.
 In the case of `Optional[T]` it is accepted that the argument to convert may be `undef`.
 It is however not acceptable to give other arguments (than `undef`) that cannot be
 converted to `T`.
 
-Conversion to Integer
----------------------
+### Conversion to Integer
 
 A new `Integer` can be created from `Integer`, `Float`, `Boolean`, and `String` values.
 For conversion from `String` it is possible to specify the radix (base).
@@ -113,8 +111,7 @@ $a_number = Integer(true)          # results in 1
 $a_number = Integer(-38, 10, true) # results in 38
 ```
 
-Conversion to Float
--------------------
+### Conversion to Float
 
 A new `Float` can be created from `Integer`, `Float`, `Boolean`, and `String` values.
 For conversion from `String` both float and integer formats are supported.
@@ -126,15 +123,13 @@ function Float.new(
 )
 ```
 
-
 * For an integer, the floating point fraction of `.0` is added to the value.
 * A `Boolean` `true` is converted to 1.0, and a `false` to 0.0
 * In `String` format, integer prefixes for hex and binary are understood (but not octal since
   floating point in string format may start with a '0').
 * When `abs` is set to `true`, the result will be an absolute floating point value.
 
-Conversion to Numeric
----------------------
+### Conversion to Numeric
 
 A new `Integer` or `Float` can be created from `Integer`, `Float`, `Boolean` and
 `String` values.
@@ -163,8 +158,7 @@ $a_number = Numeric(-42.3, true) # results in 42.3
 $a_number = Numeric(-42, true)   # results in 42
 ```
 
-Conversion to Timespan
--------------------
+### Conversion to Timespan
 
 A new `Timespan` can be created from `Integer`, `Float`, `String`, and `Hash` values. Several variants of the constructor are provided.
 
@@ -178,7 +172,7 @@ function Timespan.new(
 )
 ```
 
-#### Timespan from days, hours, mintues, seconds, and fractions of a second
+#### Timespan from days, hours, minutes, seconds, and fractions of a second
 
 The arguments can be passed separately in which case the first four, days, hours, minutes, and seconds are mandatory and the rest are optional.
 All values may overflow and/or be negative. The internal 128-bit nano-second integer is calculated as:
@@ -221,7 +215,7 @@ An exception is raised when no format was able to parse the given string.
 
 ```puppet
 function Timespan.new(
-  String $string, Variant[String[2],Array[String[2]], 1] $format = <default format>)
+  String $string, Variant[String[2],Array[String[2], 1]] $format = <default format>)
 )
 ```
 
@@ -231,7 +225,7 @@ the arguments may also be passed as a `Hash`:
 function Timespan.new(
   Struct[{
     string => String[1],
-    Optional[format] => Variant[String[2],Array[String[2]], 1]
+    Optional[format] => Variant[String[2],Array[String[2], 1]]
   }] $hash
 )
 ```
@@ -281,8 +275,7 @@ $duration = Timespan('10:03.5', '%M:%S.%L') # 10 minutes, 3 seconds, and 5 milli
 $duration = Timespan('10:03.5', '%M:%S.%N') # 10 minutes, 3 seconds, and 5 nano-seconds
 ```
 
-Conversion to Timestamp
--------------------
+### Conversion to Timestamp
 
 A new `Timestamp` can be created from `Integer`, `Float`, `String`, and `Hash` values. Several variants of the constructor are provided.
 
@@ -316,7 +309,7 @@ An exception is raised when no format was able to parse the given string.
 ```puppet
 function Timestamp.new(
   String $string,
-  Variant[String[2],Array[String[2]], 1] $format = <default format>,
+  Variant[String[2],Array[String[2], 1]] $format = <default format>,
   String $timezone = default)
 )
 ```
@@ -327,7 +320,7 @@ the arguments may also be passed as a `Hash`:
 function Timestamp.new(
   Struct[{
     string => String[1],
-    Optional[format] => Variant[String[2],Array[String[2]], 1],
+    Optional[format] => Variant[String[2],Array[String[2], 1]],
     Optional[timezone] => String[1]
   }] $hash
 )
@@ -475,8 +468,17 @@ $ts = Timestamp('2016-08-24T12:13:14', default, 'PST')   # 2016-08-24 20:13:14.0
 
 ```
 
-Conversion to String
---------------------
+### Conversion to Type
+
+A new `Type` can be create from its `String` representation.
+
+**Example:** Creating a type from a string
+
+```puppet
+$t = Type.new('Integer[10]')
+```
+
+### Conversion to String
 
 Conversion to `String` is the most comprehensive conversion as there are many
 use cases where a string representation is wanted. The defaults for the many options
@@ -519,7 +521,7 @@ included in a string format.
 Note that all data type supports the formats `s` and `p` with the meaning "default string representation" and
 "default programmatic string representation" (which for example means that a String is quoted in 'p' format).
 
-### Signatures of String conversion
+#### Signatures of String conversion
 
 ```puppet
 type Format = Pattern[/^%([\s\+\-#0\[\{<\(\|]*)([1-9][0-9]*)?(?:\.([0-9]+))?([a-zA-Z])/]
@@ -577,7 +579,7 @@ $str = String([1,2,3], $formats) # produces '(0x1, 0x2, 0x3)'
 The given formats are merged with the default formats, and matching of values to convert against format is based on
 the specificity of the mapped type; for example, different formats can be used for short and long arrays.
 
-### Integer to String
+#### Integer to String
 
 | Format  | Integer Formats
 | ------  | ---------------
@@ -592,7 +594,7 @@ the specificity of the mapped type; for example, different formats can be used f
 
 Defaults to `d`.
 
-### Float to String
+#### Float to String
 
 | Format  | Float formats
 | ------  | -------------
@@ -606,7 +608,7 @@ Defaults to `d`.
 
 Defaults to `p`.
 
-### String to String
+#### String to String
 
 | Format | String
 | ------ | ------
@@ -620,7 +622,7 @@ Defaults to `p`.
 
 Defaults to `s` at top level and `p` inside array or hash.
 
-### Boolean to String
+#### Boolean to String
 
 | Format    | Boolean Formats
 | ----      | -------------------
@@ -631,14 +633,14 @@ Defaults to `s` at top level and `p` inside array or hash.
 | s         | String 'true' / 'false'.
 | p         | String 'true' / 'false'.
 
-### Regexp to String
+#### Regexp to String
 
 | Format    | Regexp Formats
 | ----      | --------------
 | s         | No delimiters, quoted if alternative flag `#` is used.
 | p         | Delimiters `/ /`.
 
-### Undef to String
+#### Undef to String
 
 | Format    | Undef formats
 | ------    | -------------
@@ -651,7 +653,7 @@ Defaults to `s` at top level and `p` inside array or hash.
 | V         | String 'N/A'.
 | u         | String 'undef', or 'undefined' if alternative `#` flag is used.
 
-### Default value to String
+#### Default value to String
 
 | Format    | Default formats
 | ------    | ---------------
@@ -659,7 +661,7 @@ Defaults to `s` at top level and `p` inside array or hash.
 | s         | Same as d.
 | p         | Same as d.
 
-### Binary value to String
+#### Binary value to String
 
 | Format    | Default formats
 | ------    | ---------------
@@ -676,7 +678,7 @@ Defaults to `s` at top level and `p` inside array or hash.
   as hex escaped characters on the form `\\xHH` where `H` is a hex digit.
 * The width and precision values are applied to the text part only in `%p` format.
 
-### Array & Tuple to String
+#### Array & Tuple to String
 
 | Format    | Array/Tuple Formats
 | ------    | -------------
@@ -691,7 +693,7 @@ The alternate form flag `#` will cause indentation of nested array or hash conta
 it is taken as the maximum allowed length of a sequence of elements (not including delimiters). If this max length
 is exceeded, each element will be indented.
 
-### Hash & Struct to String
+#### Hash & Struct to String
 
 | Format    | Hash/Struct Formats
 | ------    | -------------
@@ -705,14 +707,14 @@ more information about options.
 
 The alternate form flag `#` will format each hash key/value entry indented on a separate line.
 
-### Type to String
+#### Type to String
 
 | Format    | Array/Tuple Formats
 | ------    | -------------
 | s         | The same as `p`, quoted if alternative flag `#` is used.
 | p         | Outputs the type in string form as specified by the Puppet Language.
 
-### Flags
+#### Flags
 
 | Flag     | Effect
 | ------   | ------
@@ -723,8 +725,7 @@ The alternate form flag `#` will format each hash key/value entry indented on a
 | 0        | Pad with 0 instead of space for widths larger than value.
 | <[({\|   | Defines an enclosing pair <> [] () {} or \| \| when used with a container type.
 
-Conversion to Boolean
----
+### Conversion to Boolean
 
 Accepts a single value as argument:
 
@@ -735,8 +736,7 @@ Accepts a single value as argument:
   * `false` if 'false', 'no', 'n' (case independent compare)
 * Boolean is already boolean and is simply returned
 
-Conversion to Array and Tuple
----
+### Conversion to Array and Tuple
 
 When given a single value as argument:
 
@@ -761,8 +761,7 @@ $arr = Array($value, true)
 Conversion to a `Tuple` works exactly as conversion to an `Array`, only that the constructed array is
 asserted against the given tuple type.
 
-Conversion to Hash and Struct
----
+### Conversion to Hash and Struct
 
 Accepts a single value as argument:
 
@@ -772,11 +771,37 @@ Accepts a single value as argument:
 * An `Iterable` is turned into an `Array` and then converted to hash as per the array rules
 * A `Hash` is simply returned
 
+Alternatively, a tree can be constructed by giving two values; an array of tuples on the form `[path, value]`
+(where the `path` is the path from the root of a tree, and `value` the value at that position in the tree), and
+either the option `'tree'` (do not convert arrays to hashes except the top level), or
+`'hash_tree'` (convert all arrays to hashes).
+
+The tree/hash_tree forms of Hash creation are suited for transforming the result of an iteration
+using `tree_each` and subsequent filtering or mapping.
+
+**Example:** Mapping a hash tree
+
+Mapping an arbitrary structure in a way that keeps the structure, but where some values are replaced
+can be done by using the `tree_each` function, mapping, and then constructing a new Hash from the result:
+
+```puppet
+# A hash tree with 'water' at different locations
+$h = { a => { b => { x => 'water'}}, b => { y => 'water'} }
+# a helper function that turns water into wine
+function make_wine($x) { if $x == 'water' { 'wine' } else { $x } }
+# create a flattened tree with water turned into wine
+$flat_tree = $h.tree_each.map |$entry| { [$entry[0], make_wine($entry[1])] }
+# create a new Hash and log it
+notice Hash($flat_tree, 'hash_tree')
+```
+
+Would notice the hash `{a => {b => {x => wine}}, b => {y => wine}}`
+
 Conversion to a `Struct` works exactly as conversion to a `Hash`, only that the constructed hash is
 asserted against the given struct type.
 
-Conversion to a Regexp
----
+### Conversion to a Regexp
+
 A `String` can be converted into a `Regexp`
 
 **Example**: Converting a String into a Regexp
@@ -788,8 +813,7 @@ if('foo.com' =~ $r) {
 }
 ```
 
-Creating a SemVer
----
+### Creating a SemVer
 
 A SemVer object represents a single [Semantic Version](http://semver.org/).
 It can be created from a String, individual values for its parts, or a hash specifying the value per part.
@@ -838,8 +862,7 @@ notice(SemVer('2.3.4') =~ $t) # false
 notice(SemVer('3.4.5') =~ $t) # true
 ```
 
-Creating a SemVerRange
----
+### Creating a SemVerRange
 
 A `SemVerRange` object represents a range of `SemVer`. It can be created from
 a `String`, or from two `SemVer` instances, where either end can be given as
@@ -853,8 +876,8 @@ The signatures are:
 ```puppet
 type SemVerRangeString = String[1]
 type SemVerRangeHash = Struct[{
-  min                   => Variant[default, SemVer],
-  Optional[max]         => Variant[default, SemVer],
+  min                   => Variant[Default, SemVer],
+  Optional[max]         => Variant[Default, SemVer],
   Optional[exclude_max] => Boolean
 }]
 
@@ -863,8 +886,8 @@ function SemVerRange.new(
 )
 
 function SemVerRange.new(
-  Variant[default,SemVer] $min
-  Variant[default,SemVer] $max
+  Variant[Default,SemVer] $min
+  Variant[Default,SemVer] $max
   Optional[Boolean]       $exclude_max = undef
 )
 
@@ -873,10 +896,9 @@ function SemVerRange.new(
 )
 ```
 
-For examples of `SemVerRange` use see "Creating a SemVer"
+For examples of `SemVerRange` use, see "Creating a SemVer".
 
-Creating a Binary
----
+### Creating a Binary
 
 A `Binary` object represents a sequence of bytes and it can be created from a String in Base64 format,
 an Array containing byte values. A Binary can also be created from a Hash containing the value to convert to
@@ -896,7 +918,6 @@ function Binary.new(
   Optional[Base64Format] $format
 )
 
-
 function Binary.new(
   Array[ByteInteger] $byte_array
 }
@@ -932,8 +953,39 @@ $b = binary_file('mymodule/mypicture.jpg')
 * Since 4.5.0
 * Binary type since 4.8.0
 
+Creating an instance of a `Type` using the `Init` type.
+-------
+
+The type `Init[T]` describes a value that can be used when instantiating a type. When used as the first argument in a call to `new`, it
+will dispatch the call to its contained type and optionally augment the parameter list with additional arguments.
+
+**Example:** Creating an instance of Integer using Init[Integer]
+
+```puppet
+# The following declaration
+$x = Init[Integer].new('128')
+# is exactly the same as
+$x = Integer.new('128')
+```
+
+or, with base 16 and using implicit new
+
+```puppet
+# The following declaration
+$x = Init[Integer,16]('80')
+# is exactly the same as
+$x = Integer('80', 16)
+```
+
+**Example:** Creating an instance of String using a predefined format
+
+```puppet
+$fmt = Init[String,'%#x']
+notice($fmt(256)) # will notice '0x100'
+```
+
 DOC
 ) do |args|
-  Error.is4x('new')
+  Puppet::Parser::Functions::Error.is4x('new')
 end
 

data/lib/puppet/parser/functions/next.rb

@@ -34,5 +34,5 @@ Would notice the value `[10, 200, 30]`
 * Since 4.8.0
 DOC
 ) do |args|
-  Error.is4x('next')
+  Puppet::Parser::Functions::Error.is4x('next')
 end

data/lib/puppet/parser/functions/realize.rb

@@ -7,6 +7,12 @@ Puppet::Parser::Functions::newfunction(:realize, :arity => -2, :doc => "Make a v
     and, of course, is a bit shorter.  You must pass the object using a
     reference; e.g.: `realize User[luke]`." ) do |vals|
 
+    if Puppet[:tasks]
+      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
+        Puppet::Pops::Issues::CATALOG_OPERATION_NOT_SUPPORTED_WHEN_SCRIPTING,
+        {:operation => 'realize'})
+    end
+
     vals = [vals] unless vals.is_a?(Array)
 
     coll = Puppet::Pops::Evaluator::Collectors::FixedSetCollector.new(self, vals.flatten)

data/lib/puppet/parser/functions/reduce.rb

@@ -3,7 +3,7 @@ Puppet::Parser::Functions::newfunction(
   :type => :rvalue,
   :arity => -3,
   :doc => <<-DOC
-Applies a [lambda](https://docs.puppetlabs.com/puppet/latest/reference/lang_lambdas.html)
+Applies a [lambda](https://puppet.com/docs/puppet/latest/lang_lambdas.html)
 to every value in a data structure from the first argument, carrying over the returned
 value of each iteration, and returns the result of the lambda's final iteration. This
 lets you create a new value or data structure by combining values from the first
@@ -99,8 +99,39 @@ $combine = $data.reduce( [d, 4] ) |$memo, $value| {
 # $combine contains [dabc, 10]
 ~~~
 
+**Example**: Using the `reduce` function to reduce a hash of hashes
+
+~~~ puppet
+# Reduce a hash of hashes $data, merging defaults into the inner hashes.
+$data = {
+  'connection1' => {
+    'username' => 'user1',
+    'password' => 'pass1',
+  },
+  'connection_name2' => {
+    'username' => 'user2',
+    'password' => 'pass2',
+  },
+}
+
+$defaults = {
+  'maxActive' => '20',
+  'maxWait'   => '10000',
+  'username'  => 'defaultuser',
+  'password'  => 'defaultpass',
+}
+
+$merged = $data.reduce( {} ) |$memo, $x| {
+  $memo + { $x[0] => $defaults + $data[$x[0]] }
+}
+# At the start of the lambda's first iteration, $memo is set to {}, and $x is set to
+# the first [key, value] tuple. The key in $data is, therefore, given by $x[0]. In
+# subsequent rounds, $memo retains the value returned by the expression, i.e.
+# $memo + { $x[0] => $defaults + $data[$x[0]] }.
+~~~
+
 - Since 4.0.0
 DOC
 ) do |args|
-  Error.is4x('reduce')
+  Puppet::Parser::Functions::Error.is4x('reduce')
 end

data/lib/puppet/parser/functions/return.rb

@@ -4,7 +4,8 @@ Puppet::Parser::Functions::newfunction(
   :doc => <<-DOC
 Immediately returns the given optional value from a function, class body or user defined type body.
 If a value is not given, an `undef` value is returned. This function does not return to the immediate caller.
-If called from within a lambda the return will return from the function evaluating the lambda.
+If this function is called from within a lambda, the return action is from the scope of the
+function containing the lambda (top scope), not the function accepting the lambda (local scope).
 
 The signal produced to return a value bubbles up through
 the call stack until reaching a function, class definition or
@@ -63,9 +64,29 @@ The code would notice `'bar'` but not `'foo'`
 
 Note that the returned value is ignored if used in a class or user defined type.
 
+**Example:** Using `return` in a lambda
+
+```puppet
+# Concatenate three strings into a single string formatted as a list.
+function getFruit() {
+  with("apples", "oranges", "bananas") |$x, $y, $z| {
+    return("${x}, ${y}, and ${z}")
+  }
+  notice "not reached"
+}
+$fruit = getFruit()
+notice $fruit
+
+# The output contains "apples, oranges, and bananas".
+# "not reached" is not output because the function returns its value within the
+# calling function's scope, which stops processing the calling function before
+# the `notice "not reached"` statement.
+# Using `return()` outside of a calling function results in an error.
+```
+
 * Also see functions `return` and `break`
 * Since 4.8.0
 DOC
 ) do |args|
-  Error.is4x('return')
+  Puppet::Parser::Functions::Error.is4x('return')
 end

data/lib/puppet/parser/functions/reverse_each.rb

@@ -4,7 +4,7 @@ Puppet::Parser::Functions::newfunction(
   :arity => -1,
   :doc => <<-DOC
 Reverses the order of the elements of something that is iterable and optionally runs a
-[lambda](http://docs.puppetlabs.com/puppet/latest/reference/lang_lambdas.html) for each
+[lambda](https://puppet.com/docs/puppet/latest/lang_lambdas.html) for each
 element.
 
 This function takes one to two arguments:
@@ -40,7 +40,7 @@ $reverse_data = reverse_each($data)
 When no second argument is present, Puppet returns an `Iterable` that represents the reverse
 order of its first argument. This allows methods on `Iterable` to be chained.
 
-When a lamdba is given as the second argument, Puppet iterates the first argument in reverse
+When a lambda is given as the second argument, Puppet iterates the first argument in reverse
 order and passes each value in turn to the lambda, then returns `undef`.
 
 **Example:** Using the `reverse_each` function with an array and a one-parameter lambda
@@ -79,5 +79,5 @@ $transformed_data = map(reverse_each($data)) |$item| { $item * 10 }
 
 DOC
 ) do |args|
-  Error.is4x('reverse_each')
+  Puppet::Parser::Functions::Error.is4x('reverse_each')
 end

data/lib/puppet/parser/functions/scanf.rb

@@ -34,5 +34,5 @@ DOC
 ) do |args|
   data = args[0]
   format = args[1]
-  result = data.scanf(format)
+  data.scanf(format)
 end

data/lib/puppet/parser/functions/sha256.rb

@@ -0,0 +1,5 @@
+require 'digest/sha2'
+
+Puppet::Parser::Functions::newfunction(:sha256, :type => :rvalue, :arity => 1, :doc => "Returns a SHA256 hash value from a provided string.") do |args|
+  Digest::SHA256.hexdigest(args[0])
+end

data/lib/puppet/parser/functions/slice.rb

@@ -35,5 +35,5 @@ to empty arrays for a hash.
 - Since 4.0.0
 DOC
 ) do |args|
-  Error.is4x('slice')
+  Puppet::Parser::Functions::Error.is4x('slice')
 end