Functional Transformations with Higher-Order Functions in Go

Higher-order functions are a powerful tool in functional programming, allowing you to abstract common operations and create more reusable code. This challenge asks you to implement a higher-order function in Go that applies a given function to each element of a slice, demonstrating your understanding of function types and closures. This is useful for creating flexible and concise data processing pipelines.

Problem Description

You are tasked with creating a function called Map that takes a slice of integers and a function as input. The function should apply the provided function to each element of the slice and return a new slice containing the results. The input function should accept an integer and return an integer. The Map function itself should not modify the original slice.

Key Requirements:

• The Map function must accept a slice of integers ([]int) and a function (func(int) int) as arguments.
• The function passed as an argument should be applied to each element of the input slice.
• The Map function must return a new slice of integers containing the results of applying the function to each element.
• The original slice must remain unchanged.
• Handle the case where the input slice is empty gracefully (return an empty slice).

Expected Behavior:

The Map function should iterate through the input slice, apply the provided function to each element, and collect the results into a new slice. The order of elements in the output slice should match the order of elements in the input slice.

Edge Cases to Consider:

• Empty input slice: The function should return an empty slice.
• Nil input slice: The function should return an empty slice.
• Function returning non-integer values: The function should return an error. (While not explicitly required, consider this for robustness).

Examples

Example 1:

Input: []int{1, 2, 3, 4, 5}, func(x int) int { return x * 2 }
Output: []int{2, 4, 6, 8, 10}
Explanation: The function doubles each element of the input slice.

Example 2:

Input: []int{}, func(x int) int { return x + 1 }
Output: []int{}
Explanation: The input slice is empty, so an empty slice is returned.

Example 3:

Input: []int{1, -2, 3}, func(x int) int { return x > 0 }
Output: []int{1, 0, 1}
Explanation: The function returns 1 if the element is positive, 0 otherwise.

Constraints

• The input slice will contain only integers.
• The input function will accept an integer and return an integer.
• The time complexity of the Map function should be O(n), where n is the length of the input slice.
• The space complexity of the Map function should be O(n), where n is the length of the input slice (due to the creation of a new slice).

Notes

Consider using a for...range loop to iterate through the input slice. Think about how to create a new slice to store the results without modifying the original. While error handling isn't strictly required, it's good practice to consider how your function would behave if the input function returned a value of the wrong type.