Well, arguments are always passed. Default parameter values just ensure that the user doesn’t have to explicitly specify them when calling the function. When the compiler sees a call like this: ExampleMethod(1); It silently converts it to: ExampleMethod(1, “default string”, 10); So it’s not techically possible to determine if the argument was passed at run-time. … Read more
You can simply use: mvn –settings YourOwnSettings.xml clean install or mvn -s YourOwnSettings.xml clean install
You should enclose the optional closure in parentheses. This will properly scope the ? operator. func then(onFulfilled: ()->(), onReject: (()->())?){ if let callableRjector = onReject { // do stuff! } }
You can use exclude_none param of Pydantic’s model.dict(…): class Text(BaseModel): id: str text: str = None class TextsRequest(BaseModel): data: list[Text] n_processes: Optional[int] request = TextsRequest(**{“data”: [{“id”: “1”, “text”: “The text 1”}]}) print(request.dict(exclude_none=True)) Output: {‘data’: [{‘id’: ‘1’, ‘text’: ‘The text 1′}]} Also, it’s more idiomatic to write Optional[int] instead of Union[int, None].
Not really. The standard way is to use a default value that the user would not be expected to pass, e.g. an object instance: DEFAULT = object() def foo(param=DEFAULT): if param is DEFAULT: … Usually you can just use None as the default value, if it doesn’t make sense as a value the user would … Read more
1. Using default implementations (preferred). protocol MyProtocol { func doSomething() } extension MyProtocol { func doSomething() { /* return a default value or just leave empty */ } } struct MyStruct: MyProtocol { /* no compile error */ } Advantages No Objective-C runtime is involved (well, no explicitly at least). This means you can conform … Read more
PHP does not support named parameters for functions per se. However, there are some ways to get around this: Use an array as the only argument for the function. Then you can pull values from the array. This allows for using named arguments in the array. If you want to allow optional number of arguments … Read more
You can work around this very easily by changing your signature. void Foo(TimeSpan? span = null) { if (span == null) { span = TimeSpan.FromSeconds(2); } … } I should elaborate – the reason those expressions in your example are not compile-time constants is because at compile time, the compiler can’t simply execute TimeSpan.FromSeconds(2.0) and … Read more
No. A workaround is to overload with another method that doesn’t have out / ref parameters, and which just calls your current method. public bool SomeMethod(out string input) { … } // new overload public bool SomeMethod() { string temp; return SomeMethod(out temp); } If you have C# 7.0, you can simplify: // new overload … Read more
One good use case for ‘Optional parameters’ in conjunction with ‘Named Parameters’ in C# 4.0 is that it presents us with an elegant alternative to method overloading where you overload method based on the number of parameters. For example say you want a method foo to be be called/used like so, foo(), foo(1), foo(1,2), foo(1,2, … Read more