Hi.

I have written the following function for "iterating" over all set bits

in a Bits instance:

foldBits :: (Bits bits, Num bits) => (a -> Int -> a) -> a -> bits -> a

foldBits _ a 0 = a

foldBits f a n = foldBits f (f a lsb) (n `clearBit` lsb) where

lsb = countTrailingZeros n

The type signature mimmicks foldl.

However, composing several calls to foldBits ends up pretty messy:

foldBits f (foldBits f (foldBits f [] value1) value2) value3

So I was thinking, maybe I should just flip the final arguments to make

composition easier:

fooBits :: (Bits bits, Num bits) => (a -> Int -> a) -> bits -> a -> a

fooBits _ 0 a = a

foldBits f n a = foldBits f (n `clearBit` lsb) (f a lsb) where

lsb = countTrailingZeros n

fooBits f value3 . fooBits f value2 . fooBits f value1 $ []

This looks more tidy. However, now that I am no longer mimmicking

foldl, I am sort of at a loss how to name this beast.

iterBits comes to bind, but this isn't really like iterate.

I know, this question might look silly, but good naming conventions seem

to make it easier for me to reason about the code.

Any suggestions?

P.S.: Mimmicking foldl is probably wrong as well, since this isn't

really a fold, is it?

--

CYa,

⡍⠁⠗⠊⠕

_______________________________________________

Beginners mailing list

[hidden email]
http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners