An issue I encountered recently with argparse was when I tried running a script with its argument changed from something like:
```
parser.add_argument('--please_work')
```
and was replaced with:
```
parser.add_argument('--please-work')
```

I have not ever seen anyone add an argument where a function has two arguments existing in a function, such as please_work and please-work. I think this is a pretty safe feature to implement, plus it enforces good practices. So if I wrote something such as:

```
parser = argparse.ArgumentParser(description="check this out")
parser.add_argument('--please-work')
```

Then I could call the program using:
```
python3 test.py --please_work True
```
or:
```
python3 test.py --please-work True
```

Your PR doesn't include any tests... but I like the idea enough to create the tests for you if you prefer.

However, first I'd like to see whether the core devs like the idea.  I could see saying either "yes, why not make things easy" or "no, there should be only one way to do it".

I'm glad someone else thinks it's a good idea. If you have some ideas for tests, I'd be happy to help write them in order to spare the inconvenience (unless the tests are that easy to write then by all means please do). 

I can appreciate why the core developers could be polarized. One side could say it's safer to just take better care of our Python scripts and have them in wrapper functions. But people don't always do this.

In favor of the idea: This method can be used to spare developers from agony when a "_" is changed to a "-" when they aren't informed of the change. As a result, this can allow for code to remain usable since most developers are more interested in the letters of arguments and not so much special characters. But then again, a --help option could be all that's needed to fix this issue.

I think a solution that satisfies both parties would be creating some safe guard for adding arguments that are named identically, containing "_" or "-" in the middle, and raising an exception when the regexes of the arguments are conflicting. Such as if I wrote:
```
parser.add_argument('--please_work')
parser.add_argument('--please-work')
```
then an exception should be raised with an error for conflicting argument names.

Ideally, we should keep argparse in line with common practices.  AFAICT, treating '-' and '_' the same isn't a norm.  Click, for example, doesn't do this.

I agree with Raymond: I've never seen this behavior anywhere. In general, I think being looser with allowed inputs is not a good idea.

William, thank you for the suggestion, but we're going to decline for the reasons listed by Eric and me.

All that said, it's easy to imagine a PyPI package that would give this functionality for those who want it.  Maybe even one that could also alter the behavior of Click and Typer.  If you want to go that route, let me know.