Re: Command Languages Versus Programming Languages

Janis Papanagnou <janis_papanagnou+ng@hotmail.com> writes:

On 20.11.2024 18:50, Rainer Weikusat wrote:

Janis Papanagnou <janis_papanagnou+ng@hotmail.com> writes:
 

Personally I think that writing bulky procedural stuff for something
like [0-9]+ can only be much worse, and that further abbreviations
like \d+ are the better direction to go if targeting a good interface.
YMMV.

 
Assuming that p is a pointer to the current position in a string, e is a
pointer to the end of it (ie, point just past the last byte) and -
that's important - both are pointers to unsigned quantities, the 'bulky'
C equivalent of [0-9]+ is
 
while (p < e && *p - '0' < 10) ++p;
 
That's not too bad. And it's really a hell lot faster than a
general-purpose automaton programmed to recognize the same pattern
(which might not matter most of the time, but sometimes, it does).

>
Okay, I see where you're coming from (and especially in that simple
case).
>
Personally (and YMMV), even here in this simple case I think that
using pointers is not better but worse - and anyway isn't [in this
form] available in most languages;

That's a question of using the proper tool for the job. In C, that's
pointer and pointer arithmetic because it's the simplest way to express
something like this.

in other cases (and languages)
such constructs get yet more clumsy, and for my not very complex
example - /[0-9]+(ABC)?x*foo/ - even a "catastrophe" concerning
readability, error-proneness, and maintainability.

Procedural code for matching strings constructed in this way is
certainly much simpler¹ than the equally procedural code for a
programmable automaton capable of interpreting regexes. Your statement
is basically "If we assume that the code interpreting regexes doesn't
exist, regexes need much less code than something equivalent which does
exist." Without this assumption, the picture becomes a different one
altogether.

¹ This doesn't even need a real state machine, just four subroutines
executed in succession (and two of these can share an implementation as
"matching ABC" and "matching foo" are both cases of matching a constant
string.

If that is what the other poster meant I'm fine with your answer;
there's no need to even consider abandoning regular expressions
in favor of explicitly codified parsing.

This depends on the specific problem and the constraints applicable to a
solution. For the common case, regexes, if easily available, are an
obvious good solution. But not all cases are common.