can you get a count on matches in a list comprehension (trying to insertionSort on a qsort after threshold)
===

I come from a C++ background so I'm not sure if I'm even going about this properly. But what I'm trying to do is write up quick sort but fallback to insertion sort if the length of a list is less than a certain threshold. So far I have this code:

    insertionSort :: (Ord a) => [a] -> [a]
    insertionSort [] = []
    insertionSort (x:xs) = insert x (insertionSort xs)
    
    quickSort :: (Ord a) => [a] -> [a]
    quickSort x = qsHelper x (length x)
    
    qsHelper :: (Ord a) => [a] -> Int -> [a]
    qsHelper [] _ = []
    qsHelper (x:xs) n 
        | n <= 10 = insertionSort xs
        | otherwise =  qsHelper before (length before) ++ [x] ++ qsHelper after (length after)
            where
                before = [a | a <- xs, a < x]
                after = [a | a <- xs, a >= x]

Now what I'm concerned about is calculating the length of each list every time. I don't fully understand how Haskell optimizes things or the complete effects of lazy evaluation on code like the above. But it seems like calculating the length of the list for each before and after list comprehension is not a good thing? Is there a way for you to extract the number of matches that occurred in a list comprehension while performing the list comprehension?

I.e. if we had `[x | x <- [1,2,3,4,5], x > 3]` (which results in [4,5]) could I get the count of [4,5] without using a call to length?

Thanks for any help/explanations!