###
You call *that* a cleanup?

OK, over on Reddit they make a good point, echoing Simon Thompson in the intro to the second edition of

So, let's review the main idea: given two

What drove us down the road we took is that one's first thought,

has to copy a prefix of the list of powers of

So perhaps what we need is a

More when I have time

*Haskell: The Craft of Functional Programming*. He mentions there emphasizing the higher-order functions of the Standard Prelude because (I'm paraphrasing here, and working from memory) otherwise students tend to stay at the lower level, churning out the same recursive schema over and over again... and I'm certainly People's Exhibit #1 of that with**bdigits**and**lastLE**. I mean, good grief.So, let's review the main idea: given two

**Integer**values**n**and**b**, where**b > 1**, we want to know how many digits it takes to write**n**in base**b**. The thing is that**n**may be big, so rather than the stock counting digits one at a time, comparing against**b**each time, we compare with the values of**iterate square b**, i.e.**[b ^ (2 ^ i) | i <- [0..]]**. Only a finite number will be less than or equal to**n**. If none are, then obviously one base**b**digit will do. Otherwise, divide by the last one, which will have the form**b ^ (2 ^ j)**for some**j**, add**2 ^ j**to a running total of digits required, and do it again.What drove us down the road we took is that one's first thought,

**takeWhile (<= n)**has to copy a prefix of the list of powers of

**b**, and we really only care about the last element of that prefix.So perhaps what we need is a

**foldWhile**. That would let us prime the pump with what we want for the base case, and walks the list rather than chopping off a prefix.More when I have time

## Comments