Sum of every subset’s XOR

def subset_xor_total(nums):
    def walk(i, x):
        if i == len(nums):
            return x                               # one subset's XOR total
        return walk(i + 1, x) + walk(i + 1, x ^ nums[i])   # skip it, or take it
    return walk(0, 0)

#include <vector>

static int walk(const std::vector<int>& a, size_t i, int x) {
    if (i == a.size()) return x;                   // one subset's XOR total
    return walk(a, i + 1, x) + walk(a, i + 1, x ^ a[i]);   // skip it, or take it
}

int solve(const std::vector<int>& nums) {
    return walk(nums, 0, 0);
}

class Solution {
    public int subsetXorTotal(int[] nums) {
        return walk(nums, 0, 0);
    }
    private int walk(int[] a, int i, int x) {
        if (i == a.length) return x;               // one subset's XOR total
        return walk(a, i + 1, x) + walk(a, i + 1, x ^ a[i]);   // skip it, or take it
    }
}

function subsetXorTotal(nums) {
  const walk = (i, x) =>
    i === nums.length ? x                          // one subset's XOR total
      : walk(i + 1, x) + walk(i + 1, x ^ nums[i]); // skip it, or take it
  return walk(0, 0);
}

fn walk(a: &[i64], i: usize, x: i64) -> i64 {
    if i == a.len() {
        return x;                                  // one subset's XOR total
    }
    walk(a, i + 1, x) + walk(a, i + 1, x ^ a[i])   // skip it, or take it
}

fn solve(nums: &[i64]) -> i64 {
    walk(nums, 0, 0)
}

import Data.Bits (xor)

-- Each element is either skipped or XOR-ed in; the leaves are the 2^n subsets.
solve :: [Int] -> Int
solve = go 0
  where
    go x []       = x
    go x (v : vs) = go x vs + go (x `xor` v) vs