Find a value in a mountain array

def find_in_mountain(a, target):
    def first(lo, hi, test):           # first i in [lo, hi] with test(i), or hi if none before it
        while lo < hi:
            mid = (lo + hi) // 2
            if test(mid):
                hi = mid
            else:
                lo = mid + 1
        return lo

    n = len(a)
    peak = first(0, n - 1, lambda i: a[i] > a[i + 1])
    i = first(0, peak, lambda i: a[i] >= target)              # ascending side
    if a[i] == target:
        return i
    j = first(peak + 1, n - 1, lambda i: a[i] <= target)      # descending side
    return j if a[j] == target else -1

#include <vector>
#include <functional>

// first i in [lo, hi] with test(i), or hi if none before it
static int first(int lo, int hi, const std::function<bool(int)>& test) {
    while (lo < hi) {
        int mid = lo + (hi - lo) / 2;
        if (test(mid)) hi = mid; else lo = mid + 1;
    }
    return lo;
}

int solve(const std::vector<int>& a, int target) {
    const int n = (int)a.size();
    int peak = first(0, n - 1, [&](int i) { return a[i] > a[i + 1]; });
    int i = first(0, peak, [&](int k) { return a[k] >= target; });          // ascending side
    if (a[i] == target) return i;
    int j = first(peak + 1, n - 1, [&](int k) { return a[k] <= target; });  // descending side
    return a[j] == target ? j : -1;
}

import java.util.function.IntPredicate;

class Solution {
    // first i in [lo, hi] with test(i), or hi if none before it
    private int first(int lo, int hi, IntPredicate test) {
        while (lo < hi) {
            int mid = lo + (hi - lo) / 2;
            if (test.test(mid)) hi = mid; else lo = mid + 1;
        }
        return lo;
    }

    public int findInMountain(int[] a, int target) {
        int n = a.length;
        int peak = first(0, n - 1, i -> a[i] > a[i + 1]);
        int i = first(0, peak, k -> a[k] >= target);              // ascending side
        if (a[i] == target) return i;
        int j = first(peak + 1, n - 1, k -> a[k] <= target);      // descending side
        return a[j] == target ? j : -1;
    }
}

function findInMountain(a, target) {
  // first i in [lo, hi] with test(i), or hi if none before it
  const first = (lo, hi, test) => {
    while (lo < hi) {
      const mid = (lo + hi) >> 1;
      if (test(mid)) hi = mid; else lo = mid + 1;
    }
    return lo;
  };
  const n = a.length;
  const peak = first(0, n - 1, i => a[i] > a[i + 1]);
  const i = first(0, peak, k => a[k] >= target);             // ascending side
  if (a[i] === target) return i;
  const j = first(peak + 1, n - 1, k => a[k] <= target);      // descending side
  return a[j] === target ? j : -1;
}

// first i in [lo, hi] with test(i), or hi if none before it
fn first(mut lo: usize, mut hi: usize, test: impl Fn(usize) -> bool) -> usize {
    while lo < hi {
        let mid = lo + (hi - lo) / 2;
        if test(mid) { hi = mid } else { lo = mid + 1 }
    }
    lo
}

fn solve(a: &[i64], target: i64) -> i64 {
    let n = a.len();
    let peak = first(0, n - 1, |i| a[i] > a[i + 1]);
    let i = first(0, peak, |k| a[k] >= target);               // ascending side
    if a[i] == target {
        return i as i64;
    }
    let j = first(peak + 1, n - 1, |k| a[k] <= target);       // descending side
    if a[j] == target { j as i64 } else { -1 }
}

import Data.Array

-- first i in [lo, hi] with test i, or hi if none before it
firstIn :: Int -> Int -> (Int -> Bool) -> Int
firstIn lo hi test
  | lo >= hi   = lo
  | test mid   = firstIn lo mid test
  | otherwise  = firstIn (mid + 1) hi test
  where mid = lo + (hi - lo) `div` 2

solve :: [Int] -> Int -> Int
solve xs target
  | a ! i == target = i
  | a ! j == target = j
  | otherwise       = -1
  where
    n = length xs
    a = listArray (0, n - 1) xs
    peak = firstIn 0 (n - 1) (\k -> a ! k > a ! (k + 1))
    i = firstIn 0 peak (\k -> a ! k >= target)               -- ascending side
    j = firstIn (peak + 1) (n - 1) (\k -> a ! k <= target)    -- descending side