[TODO] strutils.countWhile: counts while a predicate is true, starting from either end

[timotheecour]

• needed for subsequent PR's
• it's a useful and versatile proc that generalizes other procs

in other languages

• D: countUntil closely related
• go: https://golang.org/pkg/strings/#TrimRightFunc and https://golang.org/pkg/strings/#TrimLeftFunc
  in go, strings can be sliced so they return a slice, but nim strings can't be sliced (with reference semantics) so returning a count is the best thing we can do here

[Araq]

I'll accept this since I happen to know where you want to use it, but I'm not convinced strutils.countWhile is useful enough. strutils is full of stuff that I never use, yet strutils is one of the few modules that is used in every program.

[Araq]

Nitpick: Watch the spacing around your colons.

[Araq]

prefix should instead be countdown=false.

[Araq]

And I think s instead of str is more common in the stdlib.

[Araq]

And I think the signature should be this, there is little you can do in this callback that receives a single char...

proc countWhile*(s: string; x: set[char]; countdown = false): int

Or maybe

template countWhileIt*(s: string; e: untyped; countdown = false): int

[Araq]

This code looks better without the helper lenS, use s.len instead.

[Araq]

Use a countdown loop here instead.

[dom96]

I believe I already explained why I don't think this function should make it into the stdlib.

Just to reiterate:

• It's incredibly specific thus unlikely to be used by many people.
• It can be easily emulated using functions defined in parseutils or using a simple for loop.
• I've searched a little and don't see a similar function in the stdlib of other languages. Most functional programming languages offer a filter function which would emulate the functionality of this procedure very well.

Nim actually already has a filter function but it only supports openarrays. A nice improvement would be to implement filter for strings.

[timotheecour]

/cc @Araq Please re-open this PR; it's good etiquette in open source to wait for an answer from PR author before closing.

It can be easily emulated using functions defined in parseutils

In here https://github.com/nim-lang/Nim/pull/8351/files#r203705914 you mentioned parseutils.parseWhile [1] ; that doesn't work:

• I need to allow going from either end (parseWhile doesn't, nor does anything in parseutils)
• parseWhile allocates; countWhile doesn't
• a set[char] is just not flexible enough, eg, there's no efficient or simple way to write countWhile("abcDEF", isLowerAscii) with parseWhile (would require precomputing a set of valid chars, which is both inefficient and unwieldy)

Yes, it can be emulated with a for loop; but that's less readable, and tricky to use, especially for the countdown (backwards) version

It's incredibly specific thus unlikely to be used by many people.

I'm using it in my projects in a number of places (as well as upcoming PR's), it simplifies code.

I've searched a little and don't see a similar function in the stdlib of other languages

I added such examples in top-level msg of this PR

Most functional programming languages offer a filter function which would emulate the functionality of this procedure very well

no, filter is completely different: countWhile terminates when condition stops being true; filter terminates at end of input. There are lots of other differences.

[1] proc parseWhile(s: string; token: var string; validChars: set[char]; start = 0): int {..}

[dom96]

parseWhile allocates; countWhile doesn't

Okay, but couldn't you use skipUntil instead?

import parseutils

doAssert(skipUntil("abcDEF", {'A' .. 'Z'}) == 3)

a set[char] is just not flexible enough, eg, there's no efficient or simple way to write countWhile("abcDEF", isLowerAscii) with parseWhile (would require precomputing a set of valid chars, which is both inefficient and unwieldy)

This is not inefficient nor unwieldy: {'a' .. 'z'}.

I need to allow going from either end (parseWhile doesn't, nor does anything in parseutils)

That is a problem. Reverse the string? :)

If that's too much of a performance hit then you can implement "prefix" mode for the parseutils procs.