High order functions assignation - swift

Question

I'm learning about High Order functions in Swift (like .map .filter .reduce...) and generics types.
Here is my function :
func max<T: Comparable>(_ array: [T]) -> T {
var max = 0 as! T
for value in array {
if value > max { max = value }
}
return max
}
How can I replace my for loop with high order function to get the same result ?
Im looking to do something like this (or better) :
max = array.map { $0 > max ? $0 : max }

Answer 1

Reduce!
return array.reduce(nil)
{
(max: T?, current: T) -> T? in
guard let max = max else { return current }
return max > current ? max : current
}
That will return an optional but that is probably sensible given you might pass in an empty array.
Of course there is also this
https://developer.apple.com/documentation/swift/array/1688806-max
The implication of tyour question is that this is a learning exercise. So here is a generalisation of the solution that makes use of higher order functions. Note that the Swft Strandard Library already contains a function that does this.
extension Array
{
func pickOne(choose: (Element, Element) -> Element) -> Element?
{
return self.reduce(nil)
{
(bestSoFar: Element?, current: Element) -> Element? in
guard let bestSoFar = bestSoFar else { return current }
return choose(bestSoFar, current)
}
}
}
So the functionality of max is now defined like this:
array.pickOne { $0 > $1 ? $0 : $1 }
and min would be
array.pickOne { $0 < $1 ? $0 : $1 }

Answer 2

First note that your approach for the "initial value" and the forced
cast
var max = 0 as! T
has two problems:
It will crash for arrays not containing integers, e.g. max(["a", "b"]).
Even for integer arrays, it is wrong if all array elements are
negative, e.g. max([-2, -3]) should be -2 and not zero.
So you better choose the first array element as initial value instead
of the "forced zero".
That leads to the next question: What if the array
is empty? There are two valid approaches: You can require that the
function is called with a non-empty array (and document that
precondition):
/// Compute the maximal element in an array.
///
/// - Returns: The maximal element.
///
/// - Note: The array must not be empty.
func max<T: Comparable>(_ array: [T]) -> T {
precondition(!array.isEmpty, "`max` called with empty array")
var max = array[0]
for value in array {
if value > max { max = value }
}
return max
}
Or (as also suggested in the other answers) make the return value
optional:
/// Compute the maximal element in an array.
///
/// - Returns: `nil` if the array is empty, and the maximal element otherwise.
func max<T: Comparable>(_ array: [T]) -> T? {
guard var max = array.first else { return nil }
for value in array {
if value > max { max = value }
}
return max
}
Both approaches can be implemented with reduce().
The first one would be
/// Compute the maximal element in an array.
///
/// - Returns: The maximal element.
///
/// - Note: The array must not be empty.
func max<T: Comparable>(_ array: [T]) -> T {
precondition(!array.isEmpty, "`max` called with empty array")
return array.reduce(array[0]) { $0 > $1 ? $0 : $1 }
}
and the second one
/// Compute the maximal element in an array.
///
/// - Returns: `nil` if the array is empty, and the maximal element otherwise.
func max<T: Comparable>(_ array: [T]) -> T? {
guard let first = array.first else { return nil }
return array.reduce(first) { $0 > $1 ? $0 : $1 }
}
This can be further shortened using the flatMap() method
of Optional:
/// Compute the maximal element in an array.
///
/// - Returns: `nil` if the array is empty, and the maximal element otherwise.
func max<T: Comparable>(_ array: [T]) -> T? {
return array.first.flatMap { array.reduce($0) { $0 > $1 ? $0 : $1 } }
}
Finally you can use the existing
func max<T : Comparable>(_ x: T, _ y: T) -> T
function instead of a literal closure in all of the above examples, e.g.
/// Compute the maximal element in an array.
///
/// - Returns: `nil` if the array is empty, and the maximal element otherwise.
func max<T: Comparable>(_ array: [T]) -> T? {
return array.first.flatMap { array.reduce($0, max) }
}

Answer 3

For Ints you would want to use reduce for this like so:
// Reduce with initial value the first value of the array if available,
// or 0 otherwise
let max = array.reduce(array.first ?? 0) { (max, newValue) -> T in
return newValue > max ? newValue : max
}
UPDATE
You want JeremyP's answer for a proper handling of all Comparable!