Jérôme M. Berger wrote:
Andrei Alexandrescu wrote:
Jérôme M. Berger wrote:
Andrei Alexandrescu wrote:
Jérôme M. Berger wrote:
Andrei Alexandrescu wrote:
Jérôme M. Berger wrote:
Andrei Alexandrescu wrote:
Derek Parnell wrote:
It seems that D would benefit from having a standard syntax
format for
expressing various range sets;
a. Include begin Include end, i.e. []
b. Include begin Exclude end, i.e. [)
c. Exclude begin Include end, i.e. (]
d. Exclude begin Exclude end, i.e. ()
I'm afraid this would majorly mess with pairing of parens.
I think Derek's point was to have *some* syntax to mean this,
not necessarily the one he showed (which he showed because I
believe that's the "standard" mathematical way to express it for
English speakers). For example, we could say that [] is always
inclusive and have another character which makes it exclusive like:
a. Include begin Include end, i.e. [ a .. b ]
b. Include begin Exclude end, i.e. [ a .. b ^]
c. Exclude begin Include end, i.e. [^ a .. b ]
d. Exclude begin Exclude end, i.e. [^ a .. b ^]
I think Walter's message really rendered the whole discussion
moot. Post of the year:
=========================
I like:
a .. b+1
to mean inclusive range.
=========================
Consider "+1]" a special symbol that means the range is to be
closed to the right :o).
Ah, but:
- This is inconsistent between the left and right limit;
- This only works for integers, not for floating point numbers.
How does it not work for floating point numbers?
Is that a trick question? Depending on the actual value of b, you
might have b+1 == b (if b is large enough). Conversely, range a ..
b+1 may contain a lot of extra numbers I may not want to include
(like b+0.5)...
It wasn't a trick question, or it was of sorts. If you iterate with
e.g. foreach through a floating-point range that has b == b + 1,
you're bound to get in a lot of trouble because the running variable
will be incremented.
Well:
- A floating point range should allow you to specify the iteration
step, or else it should allow you to iterate through all numbers that
can be represented with the corresponding precision;
- The second issue remains: what if I want to include b but not b+ε for
any ε>0?
Jerome
I'd say that a floating point range requires a lazy interpretation, and
should only get evaluated on an as-needed basis. But clearly open,
half-open, and closed intervals aren't the same kind of thing as ranges.
They are more frequently used for making assertions about when
something is true (or false). I.e., they're used as an integral part of
standard mathematics, but not at all in computer science (except in VERY
peculiar cases). In math one makes a assertion that, say, a particular
equation holds for all members of an interval, and open or closed is
only a statement about whether the end-points are included in the
interval. Proof isn't usually be exhaustive calculation, but rather by
more abstract reasoning.
It would be nice to be able to express mathematical reasoning as parts
of a computer program, but it's not something that's likely to be
efficiently implementable, and certainly not executable. Mathematica
can do that kind of thing, I believe, but it's a bit distant from a
normal computer language.
