The match expressions are gone. Based on the feedback, people didn't want D to adopt perl'ish notation or implicitly defined variables. Instead, foreach statements now allow implicit typing of the key/value declarations, and the if statement now can declare a variable for the result (an adaptation of Ben Hinkle's idea).

Walter Bright schrieb am 2006-02-26:
> Instead, foreach statements now allow implicit typing of the key/value declarations
[snip]

The only missing implicit typing:

# template square(auto x)
# {
# 	auto square = x * x;
# }

<g>

Thomas

Walter Bright wrote:

> The match expressions are gone. Based on the feedback, people didn't want D to adopt perl'ish notation or implicitly defined variables. Instead, foreach statements now allow implicit typing of the key/value declarations, and the if statement now can declare a variable for the result (an adaptation of Ben Hinkle's idea).

I liked the idea (match expressions), just not the operator, and I thought that was a common opinion...

Lars Ivar Igesund wrote:
> Walter Bright wrote:
> 
> 
>>The match expressions are gone. Based on the feedback, people didn't want
>>D to adopt perl'ish notation or implicitly defined variables. Instead,
>>foreach statements now allow implicit typing of the key/value
>>declarations, and the if statement now can declare a variable for the
>>result (an adaptation of Ben Hinkle's idea).
> 
> 
> I liked the idea (match expressions), just not the operator, and I thought
> that was a common opinion...

Me too (except I even liked the operator) :)

In article <dts7qi$18b0$1@digitaldaemon.com>, Ivan Senji says...
>
>Lars Ivar Igesund wrote:
>> Walter Bright wrote:
>> 
>> 
>>>The match expressions are gone. Based on the feedback, people didn't want D to adopt perl'ish notation or implicitly defined variables. Instead, foreach statements now allow implicit typing of the key/value declarations, and the if statement now can declare a variable for the result (an adaptation of Ben Hinkle's idea).
>> 
>> 
>> I liked the idea (match expressions), just not the operator, and I thought that was a common opinion...
>
>Me too (except I even liked the operator) :)

There was a common opinion but on the opposed. I felt the same as Walter about match expressions in the NG.

My own thought about match expressions is that they introduce TOO MUCH lib functionality (common only for certain types of apps), making D *very* overloaded (think about future writers of the compiler). The most of the people felt that introducing match expressions really introduces NO NEW functionality. Rather it just saves you the time of writing "import std.regexp;" (i guess). And also they introduced more complexity than needed and new bugs to fix. Match expressions was a luxury that D couldn't afford as D has many other *really-prior-and-crucial* things to work out if it want's to become 1.0.

JMHO


Tom;

Tom wrote:

> In article <dts7qi$18b0$1@digitaldaemon.com>, Ivan Senji says...
>>
>>Lars Ivar Igesund wrote:
>>> Walter Bright wrote:
>>> 
>>> 
>>>>The match expressions are gone. Based on the feedback, people didn't want D to adopt perl'ish notation or implicitly defined variables. Instead, foreach statements now allow implicit typing of the key/value declarations, and the if statement now can declare a variable for the result (an adaptation of Ben Hinkle's idea).
>>> 
>>> 
>>> I liked the idea (match expressions), just not the operator, and I thought that was a common opinion...
>>
>>Me too (except I even liked the operator) :)
> 
> There was a common opinion but on the opposed. I felt the same as Walter about match expressions in the NG.
> 
> My own thought about match expressions is that they introduce TOO MUCH lib functionality (common only for certain types of apps), making D *very* overloaded (think about future writers of the compiler). The most of the people felt that introducing match expressions really introduces NO NEW functionality. Rather it just saves you the time of writing "import std.regexp;" (i guess). And also they introduced more complexity than needed and new bugs to fix. Match expressions was a luxury that D couldn't afford as D has many other *really-prior-and-crucial* things to work out if it want's to become 1.0.
> 
> JMHO
> 
> 
> Tom;

I think the "common opinion" was too coloured by the fact that we didn't really expect it to go away (but maybe change), thus many of those having positive feelings toward the match expressions didn't voice their opinion at all (at least I didn't). But I guess a vote would give a 50/50 result :)

Lars Ivar Igesund wrote:
> Tom wrote:
> 
>> In article <dts7qi$18b0$1@digitaldaemon.com>, Ivan Senji says...
>>> Lars Ivar Igesund wrote:
>>>> Walter Bright wrote:
>>>>
>>>>
>>>>> The match expressions are gone. Based on the feedback, people didn't
>>>>> want D to adopt perl'ish notation or implicitly defined variables.
>>>>> Instead, foreach statements now allow implicit typing of the key/value
>>>>> declarations, and the if statement now can declare a variable for the
>>>>> result (an adaptation of Ben Hinkle's idea).
>>>>
>>>> I liked the idea (match expressions), just not the operator, and I
>>>> thought that was a common opinion...
>>> Me too (except I even liked the operator) :)
>> There was a common opinion but on the opposed. I felt the same as Walter
>> about match expressions in the NG.
>>
>> My own thought about match expressions is that they introduce TOO MUCH lib
>> functionality (common only for certain types of apps), making D *very*
>> overloaded (think about future writers of the compiler). The most of the
>> people felt that introducing match expressions really introduces NO NEW
>> functionality. Rather it just saves you the time of writing "import
>> std.regexp;" (i guess). And also they introduced more complexity than
>> needed and new bugs to fix. Match expressions was a luxury that D couldn't
>> afford as D has many other *really-prior-and-crucial* things to work out
>> if it want's to become 1.0.
>>
>> JMHO
>>
>>
>> Tom;
> 
> I think the "common opinion" was too coloured by the fact that we didn't
> really expect it to go away (but maybe change), thus many of those having
> positive feelings toward the match expressions didn't voice their opinion
> at all (at least I didn't). But I guess a vote would give a 50/50 result :)

IMHO, match expressions are not a natural part of a language that claims to be for systems programming.

In article <dtse93$1fou$1@digitaldaemon.com>, Lars Ivar Igesund says...
>
>Tom wrote:
>
>> In article <dts7qi$18b0$1@digitaldaemon.com>, Ivan Senji says...
>>>
>>>Lars Ivar Igesund wrote:
>>>> Walter Bright wrote:
>>>> 
>>>> 
>>>>>The match expressions are gone. Based on the feedback, people didn't want D to adopt perl'ish notation or implicitly defined variables. Instead, foreach statements now allow implicit typing of the key/value declarations, and the if statement now can declare a variable for the result (an adaptation of Ben Hinkle's idea).
>>>> 
>>>> 
>>>> I liked the idea (match expressions), just not the operator, and I thought that was a common opinion...
>>>
>>>Me too (except I even liked the operator) :)
>> 
>> There was a common opinion but on the opposed. I felt the same as Walter about match expressions in the NG.
>> 
>> My own thought about match expressions is that they introduce TOO MUCH lib functionality (common only for certain types of apps), making D *very* overloaded (think about future writers of the compiler). The most of the people felt that introducing match expressions really introduces NO NEW functionality. Rather it just saves you the time of writing "import std.regexp;" (i guess). And also they introduced more complexity than needed and new bugs to fix. Match expressions was a luxury that D couldn't afford as D has many other *really-prior-and-crucial* things to work out if it want's to become 1.0.
>> 
>> JMHO
>> 
>> 
>> Tom;
>
>I think the "common opinion" was too coloured by the fact that we didn't really expect it to go away (but maybe change), thus many of those having positive feelings toward the match expressions didn't voice their opinion at all (at least I didn't). But I guess a vote would give a 50/50 result :)

Maybe (don't think so) but we'll have to see it to believe it. ;-)

Tom;

In article <dts47r$14c0$1@digitaldaemon.com>, Lars Ivar Igesund says...
>
>Walter Bright wrote:
>
>> The match expressions are gone. Based on the feedback, people didn't want D to adopt perl'ish notation or implicitly defined variables. Instead, foreach statements now allow implicit typing of the key/value declarations, and the if statement now can declare a variable for the result (an adaptation of Ben Hinkle's idea).
>
>I liked the idea (match expressions), just not the operator, and I thought that was a common opinion...

So did I (but the operators didn't bother me). I was surprised to see the 'built-in' behaviour removed. From my understanding, it wasn't terribly complicated to implement and there wasn't any overhead unless it was used. There really wasn't any 'perl'ish notation' to speak of, and the recent addition of if statement result variables would have taken care of the implicitly defined variable issue.

I think it was a mistake to remove the built-in's. Now I bet they're gone for good. Arrrgh. I think D would better appeal to a large segment of developers (using scripting languages like Perl) with the built-in regex match functionality.

IIRC, most of the posts liked the built-in idea but took issue with a few of the details. We've gone from talk about how the compiler can optimize matching behaviour to removing the built-in's entirely. I don't get it..

- Dave

In article <dtsge2$1i5t$1@digitaldaemon.com>, Tom says...
>
>In article <dtse93$1fou$1@digitaldaemon.com>, Lars Ivar Igesund says...
>>
>>Tom wrote:
>>
>>> In article <dts7qi$18b0$1@digitaldaemon.com>, Ivan Senji says...
>>>>
>>>>Lars Ivar Igesund wrote:
>>>>> Walter Bright wrote:
>>>>> 
>>>>> 
>>>>>>The match expressions are gone. Based on the feedback, people didn't want D to adopt perl'ish notation or implicitly defined variables. Instead, foreach statements now allow implicit typing of the key/value declarations, and the if statement now can declare a variable for the result (an adaptation of Ben Hinkle's idea).
>>>>> 
>>>>> 
>>>>> I liked the idea (match expressions), just not the operator, and I thought that was a common opinion...
>>>>
>>>>Me too (except I even liked the operator) :)
>>> 
>>> There was a common opinion but on the opposed. I felt the same as Walter about match expressions in the NG.
>>> 
>>> My own thought about match expressions is that they introduce TOO MUCH lib functionality (common only for certain types of apps), making D *very* overloaded (think about future writers of the compiler). The most of the people felt that introducing match expressions really introduces NO NEW functionality. Rather it just saves you the time of writing "import std.regexp;" (i guess). And also they introduced more complexity than needed and new bugs to fix. Match expressions was a luxury that D couldn't afford as D has many other *really-prior-and-crucial* things to work out if it want's to become 1.0.
>>> 
>>> JMHO
>>> 
>>> 
>>> Tom;
>>
>>I think the "common opinion" was too coloured by the fact that we didn't really expect it to go away (but maybe change), thus many of those having positive feelings toward the match expressions didn't voice their opinion at all (at least I didn't). But I guess a vote would give a 50/50 result :)
>
>Maybe (don't think so) but we'll have to see it to believe it. ;-)
>
>Tom;

IMHO, the vote would be about 70 - 30 for the built-in's, especially with the addition of 'if statement result declarations' that would get rid of the implicit variables.

Since AFAIK they don't complicate the compiler that much, they don't have any overhead if they aren't used and don't prevent the direct use of a regex library, I don't see any downside of making them built-in.

- Dave