Pair with a given sum in an unsorted array

def pair_sum_unsorted(nums, target):
    seen = {}                       # value -> index
    for i, x in enumerate(nums):
        if target - x in seen:      # look up first...
            return [seen[target - x], i]
        seen[x] = i                 # ...then record, so x cannot pair with itself
    return []

#include <unordered_map>
#include <vector>
using namespace std;

vector<int> solve(vector<int> nums, long long target) {
    unordered_map<long long, int> seen;          // value -> index
    for (int i = 0; i < (int)nums.size(); i++) {
        auto it = seen.find(target - nums[i]);   // look up first...
        if (it != seen.end()) return {it->second, i};
        seen[nums[i]] = i;                       // ...then record
    }
    return {};
}

import java.util.*;

class Solution {
    public int[] pairSumUnsorted(int[] nums, long target) {
        Map<Long, Integer> seen = new HashMap<>();   // value -> index
        for (int i = 0; i < nums.length; i++) {
            Integer j = seen.get(target - nums[i]);  // look up first...
            if (j != null) return new int[]{j, i};
            seen.put((long) nums[i], i);             // ...then record
        }
        return new int[0];
    }
}

function pairSumUnsorted(nums, target) {
  const seen = new Map();           // value -> index
  for (let i = 0; i < nums.length; i++) {
    const want = target - nums[i];
    if (seen.has(want)) return [seen.get(want), i];   // look up first...
    seen.set(nums[i], i);                              // ...then record
  }
  return [];
}

use std::collections::HashMap;

fn solve(nums: &[i64], target: i64) -> Option<(usize, usize)> {
    let mut seen: HashMap<i64, usize> = HashMap::new();   // value -> index
    for (i, &x) in nums.iter().enumerate() {
        if let Some(&j) = seen.get(&(target - x)) {       // look up first...
            return Some((j, i));
        }
        seen.insert(x, i);                                // ...then record
    }
    None
}

import qualified Data.Map.Strict as M

solve :: [Int] -> Int -> Maybe (Int, Int)
solve xs target = go M.empty (zip [0 ..] xs)
  where
    go _ [] = Nothing
    go seen ((i, x) : rest) =
      case M.lookup (target - x) seen of        -- look up first...
        Just j  -> Just (j, i)
        Nothing -> go (M.insert x i seen) rest  -- ...then record