The Lounge - CodeProject

Re: Wordle 657

StarNamer@work6-Apr-23 23:26

StarNamer@work

6-Apr-23 23:26

Wordle 657 3/6

🟨🟨⬛⬛⬛
⬛🟩⬛🟨🟩
🟩🟩🟩🟩🟩

Re: Wordle 657

Cp-Coder7-Apr-23 1:16

Cp-Coder

7-Apr-23 1:16

Wordle 657 4/6

⬛🟨🟨⬛⬛
⬛🟩🟨⬛🟩
🟩🟩⬛🟩🟩
🟩🟩🟩🟩🟩

Get me coffee and no one gets hurt!

Re: Wordle 657 (I got lucky)

Jeremy Falcon7-Apr-23 4:58

Jeremy Falcon

7-Apr-23 4:58

Wordle 657 3/6

⬛⬛🟩🟨🟩
⬛🟩🟩🟩🟩
🟩🟩🟩🟩🟩

Yeah like, nobody uses that word yo.

Jeremy Falcon

Re: Wordle 657

Amarnath S7-Apr-23 5:28

Amarnath S

7-Apr-23 5:28

Wordle 657 6/6

⬜⬜⬜⬜🟨
🟨⬜🟨🟨⬜
🟨🟨⬜🟨⬜
🟨🟨⬜⬜⬜
⬜🟩🟩🟩🟩
🟩🟩🟩🟩🟩

worldle 440

jmaida6-Apr-23 6:25

jmaida

6-Apr-23 6:25

#Worldle #440 2/6 (100%)
🟩🟩🟩🟨⬜⬅️
🟩🟩🟩🟩🟩🎉
https://worldle.teuteuf.fr
lucky

"A little time, a little trouble, your better day"
Badfinger

modified 7-Apr-23 15:26pm.

Worldle 440

OriginalGriff6-Apr-23 19:08

OriginalGriff

6-Apr-23 19:08

Title corrected!

"I have no idea what I did, but I'm taking full credit for it." - ThisOldTony
"Common sense is so rare these days, it should be classified as a super power" - Random T-shirt
AntiTwitter: @DalekDave is now a follower!

C# Embedded Regex

jschell6-Apr-23 6:15

jschell

6-Apr-23 6:15

Odd new feature for C# is that it can compile Regex right into the code.

Steven Giesel[^]

"The advantage over the traditional approach is that we can get the same performance as new Regex("...", RegexOptions.Compiled) and the startup benefit of Regex.CompileToAssembly, but without the complexity of CompileToAssembly. As the code is generated it can be viewed and debugged."

So excluding perhaps the "startup" part all I can think about is the simpler thing with linq expressions (no idea what they are called).

The problem with those is in production systems where one wants to log a stack trace from the exception. And now, with the above feature, one is likely going to see 20 lines of internal code (like linq) which makes no sense to anyone.

Also doubt the "viewed and debugged" claim. The article provides a sample, I believe, of what one sees but in my experience most developers who attempt to touch regexes are walking in a mine field with no idea a mine field even exists. So showing them a failed regex isn't going to help much.

But I have no doubt that developers will use this because they think it is 'better'. While ignoring the only feature advantage from the above which is about the "startup" speed.

Anyone want to provide an alternative take?

Re: C# Embedded Regex

PIEBALDconsult6-Apr-23 7:12

PIEBALDconsult

6-Apr-23 7:12

That may help in a very few use cases. I may need to try it in one such case. But generally, I doubt it will be beneficial to many users.

As you say, I don't think having stack trace or debug information will be very beneficial.

I use Regular Expressions a lot -- and I nearly always specify Compiled even when I know it will be used only once, never CompileToAssembly.
When I have a Regular Expression which executes once when I run a utility which runs for only a few seconds, then the "startup" cost is unimportant.
When I have a Regular Expression which executes millions of times when I run a utility which runs for an extended period (several minutes, an hour, etc.), then the "startup" cost is unimportant.

The one place I can think of immediately where maybe this could be of benefit is when I use a Regular Expressions in an SQL Server CLR function -- which is quite a bit actually.
If it can speed that up, then I would use it in that one use case. But it would still affect only static Regular Expressions, not dynamic ones.

Re: C# Embedded Regex

Dan Neely6-Apr-23 13:03

Dan Neely

6-Apr-23 13:03

I want someone who's playing with the beta compiler to test it on the regex that can validate almost all of the disgusting edge cases that the email spec actually allows not just a basic user+suffix@domain.tld matching pattern that most of call good enough and share the explanations output.

Consider it a stress test. Can the explain function actually output a full explanation without truncating it, and will CP allow a message that long. Laugh | :laugh:

(?:(?:\r\n)?[ \t])(?:(?:(?:[^()<>@,;:\".[] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[["()<>@,;:\".[]]))|"(?:[^\"\r\]|\.|(?:(?:\r\n)?[ \t]))"(?:(?:\r\n)?[ \t]))(?:.(?:(?:\r\n)?[ \t])(?:[^()<>@,;:\".[] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[["()<>@,;:\".[]]))|"(?:[^\"\r\]|\.|(?:(?:\r\n)?[ \t]))"(?:(?:\r\n)?[ \t])))@(?:(?:\r\n)?[ \t])(?:[^()<>@,;:\".[] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[["()<>@,;:\".[]]))|[([^[]\r\]|\.)](?:(?:\r\n)?[ \t]))(?:.(?:(?:\r\n)?[ \t])(?:[^()<>@,;:\".[] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[["()<>@,;:\".[]]))|[([^[]\r\]|\.)](?:(?:\r\n)?[ \t])))|(?:[^()<>@,;:\".[] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[["()<>@,;:\".[]]))|"(?:[^\"\r\]|\.|(?:(?:\r\n)?[ \t]))"(?:(?:\r\n)?[ \t]))\<(?:(?:\r\n)?[ \t])(?:@(?:[^()<>@,;:\".[] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[["()<>@,;:\".[]]))|[([^[]\r\]|\.)](?:(?:\r\n)?[ \t]))(?:.(?:(?:\r\n)?[ \t])(?:[^()<>@,;:\".[] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[["()<>@,;:\".[]]))|[([^[]\r\]|\.)](?:(?:\r\n)?[ \t])))(?:,@(?:(?:\r\n)?[ \t])(?:[^()<>@,;:\".[] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[["()<>@,;:\".[]]))|[([^[]\r\]|\.)](?:(?:\r\n)?[ \t]))(?:.(?:(?:\r\n)?[ \t])(?:[^()<>@,;:\".[] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[["()<>@,;:\".[]]))|[([^[]\r\]|\.)](?:(?:\r\n)?[ \t])))):(?:(?:\r\n)?[ \t]))?(?:[^()<>@,;:\".[] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[["()<>@,;:\".[]]))|"(?:[^\"\r\]|\.|(?:(?:\r\n)?[ \t]))"(?:(?:\r\n)?[ \t]))(?:.(?:(?:\r\n)?[ \t])(?:[^()<>@,;:\".[] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[["()<>@,;:\".[]]))|"(?:[^\"\r\]|\.|(?:(?:\r\n)?[ \t]))"(?:(?:\r\n)?[ \t])))@(?:(?:\r\n)?[ \t])(?:[^()<>@,;:\".[] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[["()<>@,;:\".[]]))|[([^[]\r\]|\.)](?:(?:\r\n)?[ \t]))(?:.(?:(?:\r\n)?[ \t])(?:[^()<>@,;:\".[] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[["()<>@,;:\".[]]))|[([^[]\r\]|\.)](?:(?:\r\n)?[ \t])))>(?:(?:\r\n)?[ \t]))|(?:[^()<>@,;:\".[] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[["()<>@,;:\".[]]))|"(?:[^\"\r\]|\.|(?:(?:\r\n)?[ \t]))"(?:(?:\r\n)?[ \t])):(?:(?:\r\n)?[ \t])(?:(?:(?:[^()<>@,;:\".[] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[["()<>@,;:\".[]]))|"(?:[^\"\r\]|\.|(?:(?:\r\n)?[ \t]))"(?:(?:\r\n)?[ \t]))(?:.(?:(?:\r\n)?[ \t])(?:[^()<>@,;:\".[] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[["()<>@,;:\".[]]))|"(?:[^\"\r\]|\.|(?:(?:\r\n)?[ \t]))"(?:(?:\r\n)?[ \t])))@(?:(?:\r\n)?[ \t])(?:[^()<>@,;:\".[] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[["()<>@,;:\".[]]))|[([^[]\r\]|\.)](?:(?:\r\n)?[ \t]))(?:.(?:(?:\r\n)?[ \t])(?:[^()<>@,;:\".[] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[["()<>@,;:\".[]]))|[([^[]\r\]|\.)](?:(?:\r\n)?[ \t])))|(?:[^()<>@,;:\".[] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[["()<>@,;:\".[]]))|"(?:[^\"\r\]|\.|(?:(?:\r\n)?[ \t]))"(?:(?:\r\n)?[ \t]))\<(?:(?:\r\n)?[ \t])(?:@(?:[^()<>@,;:\".[] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[["()<>@,;:\".[]]))|[([^[]\r\]|\.)](?:(?:\r\n)?[ \t]))(?:.(?:(?:\r\n)?[ \t])(?:[^()<>@,;:\".[] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[["()<>@,;:\".[]]))|[([^[]\r\]|\.)](?:(?:\r\n)?[ \t])))(?:,@(?:(?:\r\n)?[ \t])(?:[^()<>@,;:\".[] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[["()<>@,;:\".[]]))|[([^[]\r\]|\.)](?:(?:\r\n)?[ \t]))(?:.(?:(?:\r\n)?[ \t])(?:[^()<>@,;:\".[] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[["()<>@,;:\".[]]))|[([^[]\r\]|\.)](?:(?:\r\n)?[ \t])))):(?:(?:\r\n)?[ \t]))?(?:[^()<>@,;:\".[] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[["()<>@,;:\".[]]))|"(?:[^\"\r\]|\.|(?:(?:\r\n)?[ \t]))"(?:(?:\r\n)?[ \t]))(?:.(?:(?:\r\n)?[ \t])(?:[^()<>@,;:\".[] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[["()<>@,;:\".[]]))|"(?:[^\"\r\]|\.|(?:(?:\r\n)?[ \t]))"(?:(?:\r\n)?[ \t])))@(?:(?:\r\n)?[ \t])(?:[^()<>@,;:\".[] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[["()<>@,;:\".[]]))|[([^[]\r\]|\.)](?:(?:\r\n)?[ \t]))(?:.(?:(?:\r\n)?[ \t])(?:[^()<>@,;:\".[] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[["()<>@,;:\".[]]))|[([^[]\r\]|\.)](?:(?:\r\n)?[ \t])))>(?:(?:\r\n)?[ \t]))(?:,\s(?:(?:[^()<>@,;:\".[] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[["()<>@,;:\".[]]))|"(?:[^\"\r\]|\.|(?:(?:\r\n)?[ \t]))"(?:(?:\r\n)?[ \t]))(?:.(?:(?:\r\n)?[ \t])(?:[^()<>@,;:\".[] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[["()<>@,;:\".[]]))|"(?:[^\"\r\]|\.|(?:(?:\r\n)?[ \t]))"(?:(?:\r\n)?[ \t])))@(?:(?:\r\n)?[ \t])(?:[^()<>@,;:\".[] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[["()<>@,;:\".[]]))|[([^[]\r\]|\.)](?:(?:\r\n)?[ \t]))(?:.(?:(?:\r\n)?[ \t])(?:[^()<>@,;:\".[] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[["()<>@,;:\".[]]))|[([^[]\r\]|\.)](?:(?:\r\n)?[ \t])))|(?:[^()<>@,;:\".[] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[["()<>@,;:\".[]]))|"(?:[^\"\r\]|\.|(?:(?:\r\n)?[ \t]))"(?:(?:\r\n)?[ \t]))\<(?:(?:\r\n)?[ \t])(?:@(?:[^()<>@,;:\".[] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[["()<>@,;:\".[]]))|[([^[]\r\]|\.)](?:(?:\r\n)?[ \t]))(?:.(?:(?:\r\n)?[ \t])(?:[^()<>@,;:\".[] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[["()<>@,;:\".[]]))|[([^[]\r\]|\.)](?:(?:\r\n)?[ \t])))(?:,@(?:(?:\r\n)?[ \t])(?:[^()<>@,;:\".[] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[["()<>@,;:\".[]]))|[([^[]\r\]|\.)](?:(?:\r\n)?[ \t]))(?:.(?:(?:\r\n)?[ \t])(?:[^()<>@,;:\".[] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[["()<>@,;:\".[]]))|[([^[]\r\]|\.)](?:(?:\r\n)?[ \t])))):(?:(?:\r\n)?[ \t]))?(?:[^()<>@,;:\".[] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[["()<>@,;:\".[]]))|"(?:[^\"\r\]|\.|(?:(?:\r\n)?[ \t]))"(?:(?:\r\n)?[ \t]))(?:.(?:(?:\r\n)?[ \t])(?:[^()<>@,;:\".[] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[["()<>@,;:\".[]]))|"(?:[^\"\r\]|\.|(?:(?:\r\n)?[ \t]))"(?:(?:\r\n)?[ \t])))@(?:(?:\r\n)?[ \t])(?:[^()<>@,;:\".[] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[["()<>@,;:\".[]]))|[([^[]\r\]|\.)](?:(?:\r\n)?[ \t]))(?:.(?:(?:\r\n)?[ \t])(?:[^()<>@,;:\".[] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[["()<>@,;:\".[]]))|[([^[]\r\]|\.)](?:(?:\r\n)?[ \t])))>(?:(?:\r\n)?[ \t]))))?;\s)

https://stackoverflow.com/a/20773069/85661

And as always remember Codethulu fhtagn and be happy you're not trying to match HTML. Dead | X|

Did you ever see history portrayed as an old man with a wise brow and pulseless heart, weighing all things in the balance of reason?
Is not rather the genius of history like an eternal, imploring maiden, full of fire, with a burning heart and flaming soul, humanly warm and humanly beautiful?
--Zachris Topelius

Re: C# Embedded Regex

jschell7-Apr-23 8:56

jschell

7-Apr-23 8:56

I have seen at least one and perhaps several ways of defining that regex which makes it easier to understand. It involves breaking it into pieces and then commenting on each one. For actual usage the pieces are then put together.

Re: C# Embedded Regex

lmoelleb6-Apr-23 19:19

lmoelleb

6-Apr-23 19:19

One advantage: invalid regex syntax is a compile time warning instead of a runtime error.

I am not arguing this outweigh the disadvantages.

Re: C# Embedded Regex

PIEBALDconsult8-Apr-23 6:19

PIEBALDconsult

8-Apr-23 6:19

On the other hand, by the time the application gets to production, it will have been tested. It's only in development where a compile time error would be beneficial.
Frequently, a Regular Expression will have been developed and tested in Expresso or similar, so I wouldn't say that a compiler error is that much of a benefit.

Re: C# Embedded Regex

honey the codewitch6-Apr-23 22:40

honey the codewitch

6-Apr-23 22:40

I think your criticisms are valid, but personally, I love regex and state machines, and feel right at home dealing with that sort of code. I'd love to have it opened up for me the way my own regex code generators work in .NET.

But in general, I think you're right. I would consider this feature for my own projects, but might think twice before I'd like to use it in a team development environment for the reasons you mention.

To err is human. Fortune favors the monsters.

Re: C# Embedded Regex

jschell7-Apr-23 9:04

jschell

7-Apr-23 9:04

honey the codewitch wrote:
I love regex and state machines

I have been using perl since early 90s and never had a co-worker that was as comfortable with regexes as I am. And definitely seen some that didn't know what they were doing.

honey the codewitch wrote:
I'd love to have it opened up for me

I wrote my own basic regex (characters classes and such) and modified another. So at least for the basics I know how they work. But also know the complexities and I would not want to program those.

Pretty sure that the source for .Net that implements it right now is available. And I know that the java source code for that is available. The code needed for both are going to be conceptually the same because both use the same regex. Same would be true of javascript.

Re: C# Embedded Regex

honey the codewitch7-Apr-23 10:50

honey the codewitch

7-Apr-23 10:50

Right, but then I'm stuck reimplementing their regex engine if I want this feature.

I have no interest in doing that. I've already done it. It's boring.

To err is human. Fortune favors the monsters.

Re: C# Embedded Regex

lmoelleb7-Apr-23 22:48

lmoelleb

7-Apr-23 22:48

Not quite sure what you are after? Nothing stops you from implementing your own regex attributes and source generators - so what is it you are missing? Hooking your own engine into Microsoft's existing attributes?

Re: C# Embedded Regex

honey the codewitch8-Apr-23 1:06

honey the codewitch

8-Apr-23 1:06

Nothing. I'm missing nothing, since Microsoft implemented the feature in the OP.

To err is human. Fortune favors the monsters.

We just put up a sign on our private path ....

0x01AA6-Apr-23 6:08

0x01AA

6-Apr-23 6:08

...'Private way! Only for residents and riders'
In English that would probably be enough.

But in German we would have also to mention female residents and also female riders as well. And of course all those who are not gender-specific.

Not to mention the gender of the horse Cry | :((