Rename RequireNoValue to ForceNoValue

README.md

@@ -87,6 +87,17 @@
     .AllowNoValue("myvalue")
   ```
 
+* `RequireNoValue` is renamed to `ForceNoValue` and now accepts a value as run-time parameter, not as template parameter.
+
+  For example, replace this
+  ```d
+    .RequireNoValue!"myvalue"
+  ```
+  with
+  ```d
+    .ForceNoValue("myvalue")
+  ```
+
 * Dropped support for DMD-2.099.
 
 ### Enhancements and bug fixes

docs/code_snippets/arity_no_values.d

@@ -3,7 +3,7 @@ import argparse;
 struct T
 {
     @(NamedArgument.AllowNoValue(10)) int a;
-    @(NamedArgument.RequireNoValue!20) int b;
+    @(NamedArgument.ForceNoValue(20)) int b;
 }
 
 T t;

docs/topics/Arity.md

@@ -48,9 +48,9 @@ Sometimes named arguments can have no values in command line. Here are two cases
 
 - If value is optional and argument should get specific value in this case then use `AllowNoValue`.
 
-- Argument must not have any values in command line. Use `RequireNoValue` in this case.
+- If argument must not have any value in command line then use `ForceNoValue` in this case.
 
-Both `AllowNoValue` and `RequireNoValue` accept a value that should be used when no value is provided in the command line.
+Both `AllowNoValue` and `ForceNoValue` accept a value that should be used when no value is provided in the command line.
 The difference between them can be seen in this example:
 
 <code-block src="code_snippets/arity_no_values.d" lang="c++"/>

docs/topics/reference/PositionalNamedArgument.md

@@ -250,7 +250,7 @@ struct my_command
 **Signature**
 
 ```C++
-AllowNoValue(alias valueToUse)(auto ref ... argument)
+AllowNoValue(VALUE)(auto ref ... argument, VALUE valueToUse)
 ```
 
 **Parameters**
@@ -269,15 +269,15 @@ struct my_command
 }
 ```
 
-### RequireNoValue
+### ForceNoValue
 
-`RequireNoValue` requires an argument to have no value in the command line. The argument is behaving like a boolean flag
-but instead of `true`/`false` values, there can be either a value provided to this function or a default one (`.init`).
+`ForceNoValue` forces an argument to have no value in the command line. The argument is behaving like a boolean flag
+but instead of `true`/`false` values, there can be either a value provided to `ForceNoValue` or a default one (`.init`).
 
 **Signature**
 
 ```C++
-RequireNoValue(alias valueToUse)(auto ref ... argument)
+ForceNoValue(VALUE)(auto ref ... argument, VALUE valueToUse)
 ```
 
 **Parameters**
@@ -291,7 +291,7 @@ RequireNoValue(alias valueToUse)(auto ref ... argument)
 ```C++
 struct my_command
 {
-  @(NamedArgument.RequireNoValue!10)
+  @(NamedArgument.ForceNoValue!10)
   int a;
 }
 ```

source/argparse/api/argument.d

@@ -173,9 +173,9 @@ auto AllowNoValue(VALUE, T)(ArgumentUDA!T uda, VALUE valueToUse)
     return ActionNoValueImpl(uda,SetValue(valueToUse));
 }
 
-auto RequireNoValue(alias valueToUse, T)(ArgumentUDA!T uda)
+auto ForceNoValue(VALUE, T)(ArgumentUDA!T uda, VALUE valueToUse)
 {
-    auto desc = uda.AllowNoValue(valueToUse);
+    auto desc = AllowNoValue(uda, valueToUse);
     desc.info.minValuesCount = 0;
     desc.info.maxValuesCount = 0;
     return desc;
@@ -190,8 +190,8 @@ unittest
 
 unittest
 {
-    auto uda = NamedArgument.RequireNoValue!"value";
-    assert(is(typeof(uda) : ArgumentUDA!(ValueParser!(P, R)), P, R));
+    auto uda = NamedArgument.ForceNoValue("value");
+    assert(is(typeof(uda) : ArgumentUDA!(ValueParser!(void, string))));
     assert(uda.info.minValuesCount == 0);
     assert(uda.info.maxValuesCount == 0);
 }

source/argparse/package.d

@@ -458,7 +458,7 @@ unittest
     struct T
     {
         @(NamedArgument.AllowNoValue(10)) int a;
-        @(NamedArgument.RequireNoValue!20) int b;
+        @(NamedArgument.ForceNoValue(20)) int b;
     }
 
     assert(CLI!T.parseArgs!((T t) { assert(t.a == 10); return 12345; })(["-a"]) == 12345);