The largest product of a subarray

def max_product(nums):
    hi = lo = best = nums[0]            # largest and smallest product ending here
    for x in nums[1:]:
        candidates = (x, hi * x, lo * x)
        hi, lo = max(candidates), min(candidates)   # both from the old hi and lo
        best = max(best, hi)
    return best

#include <algorithm>
#include <vector>

long long solve(const std::vector<int>& nums) {
    long long hi = nums[0], lo = nums[0], best = nums[0];
    for (size_t i = 1; i < nums.size(); ++i) {
        long long x = nums[i], a = hi * x, b = lo * x;
        hi = std::max({x, a, b});                 // a negative x swaps the roles
        lo = std::min({x, a, b});
        best = std::max(best, hi);
    }
    return best;
}

class Solution {
    public long maxProduct(int[] nums) {
        long hi = nums[0], lo = nums[0], best = nums[0];
        for (int i = 1; i < nums.length; i++) {
            long x = nums[i], a = hi * x, b = lo * x;
            hi = Math.max(x, Math.max(a, b));         // a negative x swaps the roles
            lo = Math.min(x, Math.min(a, b));
            best = Math.max(best, hi);
        }
        return best;
    }
}

function maxProduct(nums) {
  let hi = nums[0], lo = nums[0], best = nums[0];
  for (let i = 1; i < nums.length; i++) {
    const x = nums[i], a = hi * x, b = lo * x;
    hi = Math.max(x, a, b);                   // a negative x swaps the roles
    lo = Math.min(x, a, b);
    best = Math.max(best, hi);
  }
  return best;
}

fn solve(nums: &[i64]) -> i64 {
    let (mut hi, mut lo, mut best) = (nums[0], nums[0], nums[0]);
    for &x in &nums[1..] {
        let (a, b) = (hi * x, lo * x);
        hi = x.max(a).max(b);                         // a negative x swaps the roles
        lo = x.min(a).min(b);
        best = best.max(hi);
    }
    best
}

solve :: [Int] -> Int
solve (x : xs) = (\(best, _, _) -> best) (foldl step (x, x, x) xs)
  where
    -- (best so far, largest ending here, smallest ending here)
    step (best, hi, lo) y = let c = [y, hi * y, lo * y]; hi' = maximum c in (max best hi', hi', minimum c)
solve [] = 0