openvox 7.37.1

data/lib/puppet/functions/next.rb

@@ -0,0 +1,33 @@
+# Makes iteration continue with the next value, optionally with a given value for this iteration.
+# If a value is not given it defaults to `undef`
+# 
+# @example Using the `next()` function
+#
+# ```puppet
+# $data = ['a','b','c']
+# $data.each |Integer $index, String $value| {
+#   if $index == 1 {
+#     next()
+#   }
+#   notice ("${index} = ${value}")
+# }
+# ```
+#
+# Would notice:
+# ```
+# Notice: Scope(Class[main]): 0 = a
+# Notice: Scope(Class[main]): 2 = c
+# ```
+#
+# @since 4.7.0
+Puppet::Functions.create_function(:next) do
+  dispatch :next_impl do
+    optional_param 'Any', :value
+  end
+
+  def next_impl(value = nil)
+    file, line = Puppet::Pops::PuppetStack.top_of_stack
+    exc = Puppet::Pops::Evaluator::Next.new(value, file, line)
+    raise exc
+  end
+end

data/lib/puppet/functions/notice.rb

@@ -0,0 +1,14 @@
+# Logs a message on the server at level `notice`.
+Puppet::Functions.create_function(:notice, Puppet::Functions::InternalFunction) do
+  # @param values The values to log.
+  # @return [Undef]
+  dispatch :notice do
+    scope_param
+    repeated_param 'Any', :values
+    return_type 'Undef'
+  end
+
+  def notice(scope, *values)
+    Puppet::Util::Log.log_func(scope, :notice, values)
+  end
+end

data/lib/puppet/functions/partition.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+# Returns two arrays, the first containing the elements of enum for which the block evaluates to true,
+# the second containing the rest.
+Puppet::Functions.create_function(:partition) do
+  # @param collection A collection of things to partition.
+  # @example Partition array of empty strings, results in e.g. `[[''], [b, c]]`
+  #   ```puppet
+  #   ['', b, c].partition |$s| { $s.empty }
+  #   ```
+  # @example Partition array of strings using index, results in e.g. `[['', 'ab'], ['b']]`
+  #   ```puppet
+  #   ['', b, ab].partition |$i, $s| { $i == 2 or $s.empty }
+  #   ```
+  # @example Partition hash of strings by key-value pair, results in e.g. `[[['b', []]], [['a', [1, 2]]]]`
+  #   ```puppet
+  #   { a => [1, 2], b => [] }.partition |$kv| { $kv[1].empty }
+  #   ```
+  # @example Partition hash of strings by key and value, results in e.g. `[[['b', []]], [['a', [1, 2]]]]`
+  #   ```puppet
+  #   { a => [1, 2], b => [] }.partition |$k, $v| { $v.empty }
+  #   ```
+  dispatch :partition_1 do
+    required_param 'Collection', :collection
+    block_param 'Callable[1,1]', :block
+    return_type 'Tuple[Array, Array]'
+  end
+
+  dispatch :partition_2a do
+    required_param 'Array', :array
+    block_param 'Callable[2,2]', :block
+    return_type 'Tuple[Array, Array]'
+  end
+
+  dispatch :partition_2 do
+    required_param 'Collection', :collection
+    block_param 'Callable[2,2]', :block
+    return_type 'Tuple[Array, Array]'
+  end
+
+  def partition_1(collection)
+    collection.partition do |item|
+      yield(item)
+    end.freeze
+  end
+
+  def partition_2a(array)
+    partitioned = array.size.times.zip(array).partition do |k, v|
+      yield(k, v)
+    end
+
+    partitioned.map do |part|
+      part.map { |item| item[1] }
+    end.freeze
+  end
+
+  def partition_2(collection)
+    collection.partition do |k, v|
+      yield(k, v)
+    end.freeze
+  end
+end

data/lib/puppet/functions/reduce.rb

@@ -0,0 +1,162 @@
+# 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
+# argument's data structure.
+#
+# This function takes two mandatory arguments, in this order:
+#
+# 1. An array, hash, or other iterable object that the function will iterate over.
+# 2. A lambda, which the function calls for each element in the first argument. It takes
+# two mandatory parameters:
+#     1. A memo value that is overwritten after each iteration with the iteration's result.
+#     2. A second value that is overwritten after each iteration with the next value in the
+#     function's first argument.
+#
+# @example Using the `reduce` function
+#
+# `$data.reduce |$memo, $value| { ... }`
+#
+# or
+#
+# `reduce($data) |$memo, $value| { ... }`
+#
+# You can also pass an optional "start memo" value as an argument, such as `start` below:
+#
+# `$data.reduce(start) |$memo, $value| { ... }`
+#
+# or
+#
+# `reduce($data, start) |$memo, $value| { ... }`
+#
+# When the first argument (`$data` in the above example) is an array, Puppet passes each
+# of the data structure's values in turn to the lambda's parameters. When the first
+# argument is a hash, Puppet converts each of the hash's values to an array in the form
+# `[key, value]`.
+#
+# If you pass a start memo value, Puppet executes the lambda with the provided memo value
+# and the data structure's first value. Otherwise, Puppet passes the structure's first two
+# values to the lambda.
+#
+# Puppet calls the lambda for each of the data structure's remaining values. For each
+# call, it passes the result of the previous call as the first parameter (`$memo` in the
+# above examples) and the next value from the data structure as the second parameter
+# (`$value`).
+#
+# @example Using the `reduce` function
+#
+# ```puppet
+# # Reduce the array $data, returning the sum of all values in the array.
+# $data = [1, 2, 3]
+# $sum = $data.reduce |$memo, $value| { $memo + $value }
+# # $sum contains 6
+#
+# # Reduce the array $data, returning the sum of a start memo value and all values in the
+# # array.
+# $data = [1, 2, 3]
+# $sum = $data.reduce(4) |$memo, $value| { $memo + $value }
+# # $sum contains 10
+#
+# # Reduce the hash $data, returning the sum of all values and concatenated string of all
+# # keys.
+# $data = {a => 1, b => 2, c => 3}
+# $combine = $data.reduce |$memo, $value| {
+#   $string = "${memo[0]}${value[0]}"
+#   $number = $memo[1] + $value[1]
+#   [$string, $number]
+# }
+# # $combine contains [abc, 6]
+# ```
+#
+# @example Using the `reduce` function with a start memo and two-parameter lambda
+#
+# ```puppet
+# # Reduce the array $data, returning the sum of all values in the array and starting
+# # with $memo set to an arbitrary value instead of $data's first value.
+# $data = [1, 2, 3]
+# $sum = $data.reduce(4) |$memo, $value| { $memo + $value }
+# # At the start of the lambda's first iteration, $memo contains 4 and $value contains 1.
+# # After all iterations, $sum contains 10.
+#
+# # Reduce the hash $data, returning the sum of all values and concatenated string of
+# # all keys, and starting with $memo set to an arbitrary array instead of $data's first
+# # key-value pair.
+# $data = {a => 1, b => 2, c => 3}
+# $combine = $data.reduce( [d, 4] ) |$memo, $value| {
+#   $string = "${memo[0]}${value[0]}"
+#   $number = $memo[1] + $value[1]
+#   [$string, $number]
+# }
+# # At the start of the lambda's first iteration, $memo contains [d, 4] and $value
+# # contains [a, 1].
+# # $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
+#
+Puppet::Functions.create_function(:reduce) do
+
+  dispatch :reduce_without_memo do
+    param 'Iterable', :enumerable
+    block_param 'Callable[2,2]', :block
+  end
+
+  dispatch :reduce_with_memo do
+    param 'Iterable', :enumerable
+    param 'Any', :memo
+    block_param 'Callable[2,2]', :block
+  end
+
+  def reduce_without_memo(enumerable)
+    enum = Puppet::Pops::Types::Iterable.asserted_iterable(self, enumerable)
+    enum.reduce do |memo, x|
+      begin
+        yield(memo, x)
+      rescue StopIteration
+        return memo
+      end
+    end
+  end
+
+  def reduce_with_memo(enumerable, given_memo)
+    enum = Puppet::Pops::Types::Iterable.asserted_iterable(self, enumerable)
+    enum.reduce(given_memo) do |memo, x|
+      begin
+        yield(memo, x)
+      rescue StopIteration
+        return memo
+      end
+    end
+  end
+end

data/lib/puppet/functions/regsubst.rb

@@ -0,0 +1,101 @@
+# Performs regexp replacement on a string or array of strings.
+Puppet::Functions.create_function(:regsubst) do
+  # @param target [String]
+  #      The string or array of strings to operate on.  If an array, the replacement will be
+  #      performed on each of the elements in the array, and the return value will be an array.
+  # @param pattern [String, Regexp, Type[Regexp]]
+  #      The regular expression matching the target string.  If you want it anchored at the start
+  #      and or end of the string, you must do that with ^ and $ yourself.
+  # @param replacement [String, Hash[String, String]]
+  #      Replacement string. Can contain backreferences to what was matched using \\0 (whole match),
+  #      \\1 (first set of parentheses), and so on.
+  #      If the second argument is a Hash, and the matched text is one of its keys, the corresponding value is the replacement string.
+  # @param flags [Optional[Pattern[/^[GEIM]*$/]], Pattern[/^G?$/]]
+  #      Optional. String of single letter flags for how the regexp is interpreted (E, I, and M cannot be used
+  #      if pattern is a precompiled regexp):
+  #        - *E*         Extended regexps
+  #        - *I*         Ignore case in regexps
+  #        - *M*         Multiline regexps
+  #        - *G*         Global replacement; all occurrences of the regexp in each target string will be replaced.  Without this, only the first occurrence will be replaced.
+  # @param encoding [Enum['N','E','S','U']]
+  #      Optional. How to handle multibyte characters when compiling the regexp (must not be used when pattern is a
+  #      precompiled regexp). A single-character string with the following values:
+  #        - *N*         None
+  #        - *E*         EUC
+  #        - *S*         SJIS
+  #        - *U*         UTF-8
+  # @return [Array[String], String] The result of the substitution. Result type is the same as for the target parameter.
+  # @example Get the third octet from the node's IP address:
+  #   ```puppet
+  #   $i3 = regsubst($ipaddress,'^(\\d+)\\.(\\d+)\\.(\\d+)\\.(\\d+)$','\\3')
+  #   ```
+  dispatch :regsubst_string do
+    param          'Variant[Array[String],String]',       :target
+    param          'String',                              :pattern
+    param          'Variant[String,Hash[String,String]]', :replacement
+    optional_param 'Optional[Pattern[/^[GEIM]*$/]]',      :flags
+    optional_param "Enum['N','E','S','U']",               :encoding
+  end
+
+  # @param target [String, Array[String]]
+  #      The string or array of strings to operate on.  If an array, the replacement will be
+  #      performed on each of the elements in the array, and the return value will be an array.
+  # @param pattern [Regexp, Type[Regexp]]
+  #      The regular expression matching the target string.  If you want it anchored at the start
+  #      and or end of the string, you must do that with ^ and $ yourself.
+  # @param replacement [String, Hash[String, String]]
+  #      Replacement string. Can contain backreferences to what was matched using \\0 (whole match),
+  #      \\1 (first set of parentheses), and so on.
+  #      If the second argument is a Hash, and the matched text is one of its keys, the corresponding value is the replacement string.
+  # @param flags [Optional[Pattern[/^[GEIM]*$/]], Pattern[/^G?$/]]
+  #      Optional. String of single letter flags for how the regexp is interpreted (E, I, and M cannot be used
+  #      if pattern is a precompiled regexp):
+  #        - *E*         Extended regexps
+  #        - *I*         Ignore case in regexps
+  #        - *M*         Multiline regexps
+  #        - *G*         Global replacement; all occurrences of the regexp in each target string will be replaced.  Without this, only the first occurrence will be replaced.
+  # @param encoding [Enum['N','E','S','U']]
+  #      Optional. How to handle multibyte characters when compiling the regexp (must not be used when pattern is a
+  #      precompiled regexp). A single-character string with the following values:
+  #        - *N*         None
+  #        - *E*         EUC
+  #        - *S*         SJIS
+  #        - *U*         UTF-8
+  # @return [Array[String], String] The result of the substitution. Result type is the same as for the target parameter.
+  # @example Put angle brackets around each octet in the node's IP address:
+  #   ```puppet
+  #   $x = regsubst($ipaddress, /([0-9]+)/, '<\\1>', 'G')
+  #   ```
+  dispatch :regsubst_regexp do
+    param          'Variant[Array[String],String]',       :target
+    param          'Variant[Regexp,Type[Regexp]]',        :pattern
+    param          'Variant[String,Hash[String,String]]', :replacement
+    optional_param 'Pattern[/^G?$/]',                     :flags
+  end
+
+  def regsubst_string(target, pattern, replacement, flags = nil, encoding = nil)
+    re_flags = 0
+    operation = :sub
+    if !flags.nil?
+      flags.split(//).each do |f|
+        case f
+        when 'G' then operation = :gsub
+        when 'E' then re_flags |= Regexp::EXTENDED
+        when 'I' then re_flags |= Regexp::IGNORECASE
+        when 'M' then re_flags |= Regexp::MULTILINE
+        end
+      end
+    end
+    inner_regsubst(target, Regexp.compile(pattern, re_flags, encoding), replacement, operation)
+  end
+
+  def regsubst_regexp(target, pattern, replacement, flags = nil)
+    pattern = (pattern.pattern || '') if pattern.is_a?(Puppet::Pops::Types::PRegexpType)
+    inner_regsubst(target, pattern, replacement, flags == 'G' ? :gsub : :sub)
+  end
+
+  def inner_regsubst(target, re, replacement, op)
+    target.respond_to?(op) ? target.send(op, re, replacement) : target.collect { |e| e.send(op, re, replacement) }
+  end
+  private :inner_regsubst
+end

data/lib/puppet/functions/require.rb

@@ -0,0 +1,77 @@
+# Requires the specified classes.
+# Evaluate one or more classes, adding the required class as a dependency.
+#
+# The relationship metaparameters work well for specifying relationships
+# between individual resources, but they can be clumsy for specifying
+# relationships between classes.  This function is a superset of the
+# `include` function, adding a class relationship so that the requiring
+# class depends on the required class.
+#
+# Warning: using `require` in place of `include` can lead to unwanted dependency cycles.
+#
+# For instance, the following manifest, with `require` instead of `include`, would produce a nasty
+# dependence cycle, because `notify` imposes a `before` between `File[/foo]` and `Service[foo]`:
+#
+# ```puppet
+# class myservice {
+#   service { foo: ensure => running }
+# }
+#
+# class otherstuff {
+#    include myservice
+#    file { '/foo': notify => Service[foo] }
+# }
+# ```
+#
+# Note that this function only works with clients 0.25 and later, and it will
+# fail if used with earlier clients.
+#
+# You must use the class's full name;
+# relative names are not allowed. In addition to names in string form,
+# you may also directly use Class and Resource Type values that are produced when evaluating
+# resource and relationship expressions.
+#
+# - Since 4.0.0 Class and Resource types, absolute names
+# - Since 4.7.0 Returns an `Array[Type[Class]]` with references to the required classes
+#
+Puppet::Functions.create_function(:require, Puppet::Functions::InternalFunction) do
+  dispatch :require_impl do
+    scope_param
+    # The function supports what the type system sees as Ruby runtime objects, and
+    # they cannot be parameterized to find what is actually valid instances.
+    # The validation is instead done in the function body itself via a call to
+    # `transform_and_assert_classnames` on the calling scope.
+    required_repeated_param 'Any', :names
+  end
+
+  def require_impl(scope, *classes)
+    if Puppet[:tasks]
+      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
+        Puppet::Pops::Issues::CATALOG_OPERATION_NOT_SUPPORTED_WHEN_SCRIPTING,
+        {:operation => 'require'})
+    end
+
+    # Make call patterns uniform and protected against nested arrays, also make
+    # names absolute if so desired.
+    classes = scope.transform_and_assert_classnames(classes.flatten)
+
+    result = classes.map {|name| Puppet::Pops::Types::TypeFactory.host_class(name) }
+
+    # This is the same as calling the include function (but faster) since it again
+    # would otherwise need to perform the optional absolute name transformation
+    # (for no reason since they are already made absolute here).
+    #
+    scope.compiler.evaluate_classes(classes, scope, false)
+    krt = scope.environment.known_resource_types
+
+    classes.each do |klass|
+      # lookup the class in the scopes
+      klass = (classobj = krt.find_hostclass(klass)) ? classobj.name : nil
+      raise Puppet::ParseError.new(_("Could not find class %{klass}") % { klass: klass }) unless klass
+      ref = Puppet::Resource.new(:class, klass)
+      resource = scope.resource
+      resource.set_parameter(:require, [resource[:require]].flatten.compact << ref)
+    end
+    result
+  end
+end

data/lib/puppet/functions/return.rb

@@ -0,0 +1,15 @@
+# Makes iteration continue with the next value, optionally with a given value for this iteration.
+# If a value is not given it defaults to `undef`
+#
+# @since 4.7.0
+#
+Puppet::Functions.create_function(:return, Puppet::Functions::InternalFunction) do
+  dispatch :return_impl do
+    optional_param 'Any', :value
+  end
+
+  def return_impl(value = nil)
+    file, line = Puppet::Pops::PuppetStack.top_of_stack
+    raise Puppet::Pops::Evaluator::Return.new(value, file, line)
+  end
+end

data/lib/puppet/functions/reverse_each.rb

@@ -0,0 +1,94 @@
+# Reverses the order of the elements of something that is iterable and optionally runs a
+# [lambda](https://puppet.com/docs/puppet/latest/lang_lambdas.html) for each
+# element.
+#
+# This function takes one to two arguments:
+#
+# 1. An `Iterable` that the function will iterate over.
+# 2. An optional lambda, which the function calls for each element in the first argument. It must
+#    request one parameter.
+#
+# @example Using the `reverse_each` function
+#
+# ```puppet
+# $data.reverse_each |$parameter| { <PUPPET CODE BLOCK> }
+# ```
+#
+# or
+#
+# ```puppet
+# $reverse_data = $data.reverse_each
+# ```
+#
+# or
+#
+# ```puppet
+# reverse_each($data) |$parameter| { <PUPPET CODE BLOCK> }
+# ```
+#
+# or
+#
+# ```puppet
+# $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 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
+#
+# ```puppet
+# # Puppet will log a notice for each of the three items
+# # in $data in reverse order.
+# $data = [1,2,3]
+# $data.reverse_each |$item| { notice($item) }
+# ```
+#
+# When no second argument is present, Puppet returns a new `Iterable` which allows it to
+# be directly chained into another function that takes an `Iterable` as an argument.
+#
+# @example Using the `reverse_each` function chained with a `map` function.
+#
+# ```puppet
+# # For the array $data, return an array containing each
+# # value multiplied by 10 in reverse order
+# $data = [1,2,3]
+# $transformed_data = $data.reverse_each.map |$item| { $item * 10 }
+# # $transformed_data is set to [30,20,10]
+# ```
+#
+# @example Using `reverse_each` function chained with a `map` in alternative syntax
+#
+# ```puppet
+# # For the array $data, return an array containing each
+# # value multiplied by 10 in reverse order
+# $data = [1,2,3]
+# $transformed_data = map(reverse_each($data)) |$item| { $item * 10 }
+# # $transformed_data is set to [30,20,10]
+# ```
+#
+# @since 4.4.0
+#
+Puppet::Functions.create_function(:reverse_each) do
+  dispatch :reverse_each do
+    param 'Iterable', :iterable
+  end
+
+  dispatch :reverse_each_block do
+    param 'Iterable', :iterable
+    block_param 'Callable[1,1]', :block
+  end
+
+  def reverse_each(iterable)
+    # produces an Iterable
+    Puppet::Pops::Types::Iterable.asserted_iterable(self, iterable, true).reverse_each
+  end
+
+  def reverse_each_block(iterable, &block)
+    Puppet::Pops::Types::Iterable.asserted_iterable(self, iterable).reverse_each(&block)
+    nil
+  end
+end

data/lib/puppet/functions/round.rb

@@ -0,0 +1,24 @@
+# Returns an `Integer` value rounded to the nearest value.
+# Takes a single `Numeric` value as an argument.
+#
+# @example 'rounding a value'
+#
+# ```puppet
+# notice(round(2.9)) # would notice 3
+# notice(round(2.1)) # would notice 2
+# notice(round(-2.9)) # would notice -3
+# ```
+#
+Puppet::Functions.create_function(:round) do
+  dispatch :on_numeric do
+    param 'Numeric', :val
+  end
+
+  def on_numeric(x)
+    if x > 0
+      Integer(x + 0.5)
+    else
+      Integer(x - 0.5)
+    end
+  end
+end

data/lib/puppet/functions/rstrip.rb

@@ -0,0 +1,58 @@
+# Strips trailing spaces from a String
+#
+# This function is compatible with the stdlib function with the same name.
+#
+# The function does the following:
+# * For a `String` the conversion removes all trailing ASCII white space characters such as space, tab, newline, and return.
+#   It does not remove other space-like characters like hard space (Unicode U+00A0). (Tip, `/^[[:space:]]/` regular expression
+#   matches all space-like characters).
+# * For an `Iterable[Variant[String, Numeric]]` (for example an `Array`) each value is processed and the conversion is not recursive.
+# * If the value is `Numeric` it is simply returned (this is for backwards compatibility).
+# * An error is raised for all other data types.
+#
+# @example Removing trailing space from a String
+# ```puppet
+# " hello\n\t".rstrip()
+# rstrip(" hello\n\t")
+# ```
+# Would both result in `"hello"`
+#
+# @example Removing trailing space from strings in an Array
+# ```puppet
+# [" hello\n\t", " hi\n\t"].rstrip()
+# rstrip([" hello\n\t", " hi\n\t"])
+# ```
+# Would both result in `['hello', 'hi']`
+#
+Puppet::Functions.create_function(:rstrip) do
+
+  dispatch :on_numeric do
+    param 'Numeric', :arg
+  end
+
+  dispatch :on_string do
+    param 'String', :arg
+  end
+
+  dispatch :on_iterable do
+    param 'Iterable[Variant[String, Numeric]]', :arg
+  end
+
+  # unit function - since the old implementation skipped Numeric values
+  def on_numeric(n)
+    n
+  end
+
+  def on_string(s)
+    s.rstrip
+  end
+
+  def on_iterable(a)
+    a.map {|x| do_rstrip(x) }
+  end
+
+  def do_rstrip(x)
+    # x can only be a String or Numeric because type constraints have been automatically applied
+    x.is_a?(String) ? x.rstrip : x
+  end
+end

data/lib/puppet/functions/scanf.rb

@@ -0,0 +1,44 @@
+# Scans a string and returns an array of one or more converted values based on the given format string.
+# See the documentation of Ruby's String#scanf method for details about the supported formats (which
+# are similar but not identical to the formats used in Puppet's `sprintf` function.)
+#
+# This function takes two mandatory arguments: the first is the string to convert, and the second is
+# the format string. The result of the scan is an array, with each successfully scanned and transformed value.
+# The scanning stops if a scan is unsuccessful, and the scanned result up to that point is returned. If there
+# was no successful scan, the result is an empty array.
+#
+#    "42".scanf("%i")
+#
+# You can also optionally pass a lambda to scanf, to do additional validation or processing.
+#
+#
+#     "42".scanf("%i") |$x| {
+#       unless $x[0] =~ Integer {
+#         fail "Expected a well formed integer value, got '$x[0]'"
+#       }
+#       $x[0]
+#     }
+#
+#
+#
+#
+#
+# @since 4.0.0
+#
+Puppet::Functions.create_function(:scanf) do
+  require 'scanf'
+
+  dispatch :scanf do
+    param 'String', :data
+    param 'String', :format
+    optional_block_param
+  end
+
+  def scanf(data, format)
+    result = data.scanf(format)
+    if block_given?
+      result = yield(result)
+    end
+    result
+  end
+end