Count substrings holding a, b and c

def count_all_three(s):
    count = {"a": 0, "b": 0, "c": 0}
    total = lo = 0
    for ch in s:
        count[ch] += 1
        while count["a"] and count["b"] and count["c"]:   # still valid: shrink
            count[s[lo]] -= 1
            lo += 1
        total += lo                    # starts 0 .. lo - 1 all work for this end
    return total

#include <string>

long long solve(const std::string& s) {
    int count[3] = {0, 0, 0}, lo = 0;
    long long total = 0;
    for (char ch : s) {
        ++count[ch - 'a'];
        while (count[0] && count[1] && count[2]) --count[s[lo++] - 'a'];   // still valid: shrink
        total += lo;                     // starts 0 .. lo - 1 all work for this end
    }
    return total;
}

class Solution {
    public long countAllThree(String s) {
        int[] count = new int[3];
        int lo = 0;
        long total = 0;
        for (int hi = 0; hi < s.length(); hi++) {
            count[s.charAt(hi) - 'a']++;
            while (count[0] > 0 && count[1] > 0 && count[2] > 0) count[s.charAt(lo++) - 'a']--;
            total += lo;                 // starts 0 .. lo - 1 all work for this end
        }
        return total;
    }
}

function countAllThree(s) {
  const count = { a: 0, b: 0, c: 0 };
  let total = 0, lo = 0;
  for (const ch of s) {
    count[ch]++;
    while (count.a && count.b && count.c) count[s[lo++]]--;   // still valid: shrink
    total += lo;                       // starts 0 .. lo - 1 all work for this end
  }
  return total;
}

fn solve(s: &str) -> i64 {
    let b = s.as_bytes();
    let mut count = [0usize; 3];
    let (mut lo, mut total) = (0usize, 0i64);
    for &ch in b {
        count[(ch - b'a') as usize] += 1;
        while count.iter().all(|&c| c > 0) {   // still valid: shrink
            count[(b[lo] - b'a') as usize] -= 1;
            lo += 1;
        }
        total += lo as i64;                    // starts 0 .. lo - 1 all work for this end
    }
    total
}

import qualified Data.Map.Strict as M

-- Fold carrying (counts, letters from the window's left end, lo, total).
solve :: String -> Int
solve s = total
  where
    (_, _, _, total) = foldl step (M.fromList [(c, 0) | c <- "abc"], s, 0, 0) s
    step (m, win, lo, t) ch =
      let (m', win', lo') = shrink (M.adjust (+ 1) ch m) win lo
      in (m', win', lo', t + lo')
    shrink m win lo
      | all (> 0) (M.elems m), (x:xs) <- win = shrink (M.adjust (subtract 1) x m) xs (lo + 1)
      | otherwise = (m, win, lo)