Can a subset reach the target?

def subset_sum(nums, target):
    reach = [True] + [False] * target         # reach[t]: some subset sums to t
    for x in nums:
        for t in range(target, x - 1, -1):     # downwards: x used at most once
            if reach[t - x]:
                reach[t] = True
    return reach[target]

#include <vector>

bool solve(const std::vector<int>& nums, int target) {
    std::vector<bool> reach(target + 1, false);
    reach[0] = true;
    for (int x : nums)
        for (int t = target; t >= x; --t)           // downwards
            if (reach[t - x]) reach[t] = true;
    return reach[target];
}

class Solution {
    public boolean subsetSum(int[] nums, int target) {
        boolean[] reach = new boolean[target + 1];
        reach[0] = true;
        for (int x : nums)
            for (int t = target; t >= x; t--)          // downwards
                if (reach[t - x]) reach[t] = true;
        return reach[target];
    }
}

function subsetSum(nums, target) {
  const reach = [true, ...new Array(target).fill(false)];
  for (const x of nums)
    for (let t = target; t >= x; t--) if (reach[t - x]) reach[t] = true;   // downwards
  return reach[target];
}

fn solve(nums: &[i64], target: i64) -> bool {
    let target = target as usize;
    let mut reach = vec![false; target + 1];
    reach[0] = true;
    for &x in nums {
        let x = x as usize;
        if x > target {
            continue;
        }
        for t in (x..=target).rev() {                  // downwards
            if reach[t - x] {
                reach[t] = true;
            }
        }
    }
    reach[target]
}

import qualified Data.Set as S

solve :: [Int] -> Int -> Bool
solve nums target = S.member target (foldl add (S.singleton 0) nums)
  where
    -- every reachable total, with or without x (capped at the target)
    add reach x = S.union reach (S.fromList [t + x | t <- S.toList reach, t + x <= target])