Is there a way in Ruby to make just any one out of many keyword arguments required? [on hold] Planned maintenance scheduled April 23, 2019 at 23:30 UTC (7:30pm US/Eastern) Announcing the arrival of Valued Associate #679: Cesar Manara Unicorn Meta Zoo #1: Why another podcast?Ruby on rails complex select statement…there has to be a better way!What if any design issues are there in this method of loading configuration data from YAML in Ruby?Is there a more succinct way to write this Ruby function?Are there any glaring issues with the way I write and test my Ruby classes?Pretty way of keeping sensitive info out of a logged command string in Ruby?Machi Koro card/dice game
What does it mean that physics no longer uses mechanical models to describe phenomena?
Why does it sometimes sound good to play a grace note as a lead in to a note in a melody?
How would a mousetrap for use in space work?
How were pictures turned from film to a big picture in a picture frame before digital scanning?
How to compare two different files line by line in unix?
Is there hard evidence that the grant peer review system performs significantly better than random?
An adverb for when you're not exaggerating
Strange behavior of Object.defineProperty() in JavaScript
Central Vacuuming: Is it worth it, and how does it compare to normal vacuuming?
Time evolution of a Gaussian wave packet, why convert to k-space?
Deconstruction is ambiguous
Should a wizard buy fine inks every time he want to copy spells into his spellbook?
Significance of Cersei's obsession with elephants?
Why are vacuum tubes still used in amateur radios?
What is best way to wire a ceiling receptacle in this situation?
AppleTVs create a chatty alternate WiFi network
What does this say in Elvish?
What does 丫 mean? 丫是什么意思?
Did any compiler fully use 80-bit floating point?
What do you call the main part of a joke?
Can a sorcerer use careful spell on himself?
Is multiple magic items in one inherently imbalanced?
Why do aircraft stall warning systems use angle-of-attack vanes rather than detecting airflow separation directly?
How many time has Arya actually used Needle?
Is there a way in Ruby to make just any one out of many keyword arguments required? [on hold]
Planned maintenance scheduled April 23, 2019 at 23:30 UTC (7:30pm US/Eastern)
Announcing the arrival of Valued Associate #679: Cesar Manara
Unicorn Meta Zoo #1: Why another podcast?Ruby on rails complex select statement…there has to be a better way!What if any design issues are there in this method of loading configuration data from YAML in Ruby?Is there a more succinct way to write this Ruby function?Are there any glaring issues with the way I write and test my Ruby classes?Pretty way of keeping sensitive info out of a logged command string in Ruby?Machi Koro card/dice game
.everyoneloves__top-leaderboard:empty,.everyoneloves__mid-leaderboard:empty,.everyoneloves__bot-mid-leaderboard:empty margin-bottom:0;
$begingroup$
I am trying to write a method, that works with three types of arguments, but requires only one of them.
def convert(arg_a: 1, arg_b: 2, arg_c: 'foo')
end
Please note, that both: arg_a, and arg_b are the same type (let's say Numeric), so using one mandatory argument, and then making decision based on the input type won't work here.
At this point my code looks like this:
def convert(arg_a: nil, arg_b: nil, arg_c: nil)
if arg_b.nil? && arg_c.nil? && arg_a
# do something with arg_a
elsif arg_a.nil? && arg_c.nil? && arg_b
# do something with arg_b
elsif arg_a.nil? && arg_b.nil? && arg_c
# do something with arg_c
else
raise ArgumentError
end
In my opinion this code smells a little, and can be improved. Any thoughts?
ruby
$endgroup$
migration rejected from stackoverflow.com Apr 16 at 15:54
This question came from our site for professional and enthusiast programmers. Votes, comments, and answers are locked due to the question being closed here, but it may be eligible for editing and reopening on the site where it originated.
put on hold as off-topic by 200_success, Graipher, Vogel612♦ Apr 16 at 15:54
This question appears to be off-topic. The users who voted to close gave this specific reason:
- "Lacks concrete context: Code Review requires concrete code from a project, with sufficient context for reviewers to understand how that code is used. Pseudocode, stub code, hypothetical code, obfuscated code, and generic best practices are outside the scope of this site." – 200_success, Graipher, Vogel612
comments disabled on deleted / locked posts / reviews |
$begingroup$
I am trying to write a method, that works with three types of arguments, but requires only one of them.
def convert(arg_a: 1, arg_b: 2, arg_c: 'foo')
end
Please note, that both: arg_a, and arg_b are the same type (let's say Numeric), so using one mandatory argument, and then making decision based on the input type won't work here.
At this point my code looks like this:
def convert(arg_a: nil, arg_b: nil, arg_c: nil)
if arg_b.nil? && arg_c.nil? && arg_a
# do something with arg_a
elsif arg_a.nil? && arg_c.nil? && arg_b
# do something with arg_b
elsif arg_a.nil? && arg_b.nil? && arg_c
# do something with arg_c
else
raise ArgumentError
end
In my opinion this code smells a little, and can be improved. Any thoughts?
ruby
$endgroup$
migration rejected from stackoverflow.com Apr 16 at 15:54
This question came from our site for professional and enthusiast programmers. Votes, comments, and answers are locked due to the question being closed here, but it may be eligible for editing and reopening on the site where it originated.
put on hold as off-topic by 200_success, Graipher, Vogel612♦ Apr 16 at 15:54
This question appears to be off-topic. The users who voted to close gave this specific reason:
- "Lacks concrete context: Code Review requires concrete code from a project, with sufficient context for reviewers to understand how that code is used. Pseudocode, stub code, hypothetical code, obfuscated code, and generic best practices are outside the scope of this site." – 200_success, Graipher, Vogel612
comments disabled on deleted / locked posts / reviews |
$begingroup$
I am trying to write a method, that works with three types of arguments, but requires only one of them.
def convert(arg_a: 1, arg_b: 2, arg_c: 'foo')
end
Please note, that both: arg_a, and arg_b are the same type (let's say Numeric), so using one mandatory argument, and then making decision based on the input type won't work here.
At this point my code looks like this:
def convert(arg_a: nil, arg_b: nil, arg_c: nil)
if arg_b.nil? && arg_c.nil? && arg_a
# do something with arg_a
elsif arg_a.nil? && arg_c.nil? && arg_b
# do something with arg_b
elsif arg_a.nil? && arg_b.nil? && arg_c
# do something with arg_c
else
raise ArgumentError
end
In my opinion this code smells a little, and can be improved. Any thoughts?
ruby
$endgroup$
I am trying to write a method, that works with three types of arguments, but requires only one of them.
def convert(arg_a: 1, arg_b: 2, arg_c: 'foo')
end
Please note, that both: arg_a, and arg_b are the same type (let's say Numeric), so using one mandatory argument, and then making decision based on the input type won't work here.
At this point my code looks like this:
def convert(arg_a: nil, arg_b: nil, arg_c: nil)
if arg_b.nil? && arg_c.nil? && arg_a
# do something with arg_a
elsif arg_a.nil? && arg_c.nil? && arg_b
# do something with arg_b
elsif arg_a.nil? && arg_b.nil? && arg_c
# do something with arg_c
else
raise ArgumentError
end
In my opinion this code smells a little, and can be improved. Any thoughts?
ruby
ruby
asked Apr 15 at 16:54
ciejjciejj
214
214
migration rejected from stackoverflow.com Apr 16 at 15:54
This question came from our site for professional and enthusiast programmers. Votes, comments, and answers are locked due to the question being closed here, but it may be eligible for editing and reopening on the site where it originated.
put on hold as off-topic by 200_success, Graipher, Vogel612♦ Apr 16 at 15:54
This question appears to be off-topic. The users who voted to close gave this specific reason:
- "Lacks concrete context: Code Review requires concrete code from a project, with sufficient context for reviewers to understand how that code is used. Pseudocode, stub code, hypothetical code, obfuscated code, and generic best practices are outside the scope of this site." – 200_success, Graipher, Vogel612
migration rejected from stackoverflow.com Apr 16 at 15:54
This question came from our site for professional and enthusiast programmers. Votes, comments, and answers are locked due to the question being closed here, but it may be eligible for editing and reopening on the site where it originated.
put on hold as off-topic by 200_success, Graipher, Vogel612♦ Apr 16 at 15:54
This question appears to be off-topic. The users who voted to close gave this specific reason:
- "Lacks concrete context: Code Review requires concrete code from a project, with sufficient context for reviewers to understand how that code is used. Pseudocode, stub code, hypothetical code, obfuscated code, and generic best practices are outside the scope of this site." – 200_success, Graipher, Vogel612
comments disabled on deleted / locked posts / reviews |
comments disabled on deleted / locked posts / reviews |
2 Answers
2
active
oldest
votes
$begingroup$
There are lots of ways of improving this; at a high level, I'd say it's possible the method itself should be broken up into multiple methods with distinct names, because a method that accepts three different inputs and does three different things with them probably doesn't have a single responsibility.
That not withstanding, you can clean this method up by separating the argument validation from the rest of the logic. There are lots of ways of doing this, but if you just need exactly one non-nil argument, you can use something along these lines:
def convert(arg_a: nil, arg_b: nil, arg_c: nil)
raise ArgumentError unless [arg_a, arg_b, arg_c].compact.one?
if arg_a
# do something with arg_a
elsif arg_b
# do something with arg_b
elsif arg_c
# do something with arg_c
end
end
$endgroup$
$begingroup$
The solution proposed by you does makes the code much clearer - I think this is the answer I was looking for. This convert method is only for argument validation - based on it other methods are called.
$endgroup$
– ciejj
Apr 15 at 17:30
add a comment |
$begingroup$
From what I can tell, your implementation only makes use of one of the three arguments, and only really expects (or allows) a single argument at a time.
i.e., with your current implementation, this is what an error-free call-site looks like:
convert(arg_a: 1)
convert(arg_b: 2)
convert(arg_c: 'foo')
If the method were called with two or more arguments (any of them), it would raise an ArgumentError
, so really, this method can only be called with a single argument.
Given that you're already using keyword arguments with a default value of nil
, I cannot see how this is any better than simply writing three different methods that handle the three values. Therefore, something like...
def convert_arg_a(a)
# Handle a...
end
def convert_arg_b(b)
# Handle b...
end
def convert_arg_c(c)
# Handle c...
end
...should be able to do exactly what is possible with the implementation you've described, with none of the branching.
New contributor
$endgroup$
add a comment |
2 Answers
2
active
oldest
votes
2 Answers
2
active
oldest
votes
active
oldest
votes
active
oldest
votes
$begingroup$
There are lots of ways of improving this; at a high level, I'd say it's possible the method itself should be broken up into multiple methods with distinct names, because a method that accepts three different inputs and does three different things with them probably doesn't have a single responsibility.
That not withstanding, you can clean this method up by separating the argument validation from the rest of the logic. There are lots of ways of doing this, but if you just need exactly one non-nil argument, you can use something along these lines:
def convert(arg_a: nil, arg_b: nil, arg_c: nil)
raise ArgumentError unless [arg_a, arg_b, arg_c].compact.one?
if arg_a
# do something with arg_a
elsif arg_b
# do something with arg_b
elsif arg_c
# do something with arg_c
end
end
$endgroup$
$begingroup$
The solution proposed by you does makes the code much clearer - I think this is the answer I was looking for. This convert method is only for argument validation - based on it other methods are called.
$endgroup$
– ciejj
Apr 15 at 17:30
add a comment |
$begingroup$
There are lots of ways of improving this; at a high level, I'd say it's possible the method itself should be broken up into multiple methods with distinct names, because a method that accepts three different inputs and does three different things with them probably doesn't have a single responsibility.
That not withstanding, you can clean this method up by separating the argument validation from the rest of the logic. There are lots of ways of doing this, but if you just need exactly one non-nil argument, you can use something along these lines:
def convert(arg_a: nil, arg_b: nil, arg_c: nil)
raise ArgumentError unless [arg_a, arg_b, arg_c].compact.one?
if arg_a
# do something with arg_a
elsif arg_b
# do something with arg_b
elsif arg_c
# do something with arg_c
end
end
$endgroup$
$begingroup$
The solution proposed by you does makes the code much clearer - I think this is the answer I was looking for. This convert method is only for argument validation - based on it other methods are called.
$endgroup$
– ciejj
Apr 15 at 17:30
add a comment |
$begingroup$
There are lots of ways of improving this; at a high level, I'd say it's possible the method itself should be broken up into multiple methods with distinct names, because a method that accepts three different inputs and does three different things with them probably doesn't have a single responsibility.
That not withstanding, you can clean this method up by separating the argument validation from the rest of the logic. There are lots of ways of doing this, but if you just need exactly one non-nil argument, you can use something along these lines:
def convert(arg_a: nil, arg_b: nil, arg_c: nil)
raise ArgumentError unless [arg_a, arg_b, arg_c].compact.one?
if arg_a
# do something with arg_a
elsif arg_b
# do something with arg_b
elsif arg_c
# do something with arg_c
end
end
$endgroup$
There are lots of ways of improving this; at a high level, I'd say it's possible the method itself should be broken up into multiple methods with distinct names, because a method that accepts three different inputs and does three different things with them probably doesn't have a single responsibility.
That not withstanding, you can clean this method up by separating the argument validation from the rest of the logic. There are lots of ways of doing this, but if you just need exactly one non-nil argument, you can use something along these lines:
def convert(arg_a: nil, arg_b: nil, arg_c: nil)
raise ArgumentError unless [arg_a, arg_b, arg_c].compact.one?
if arg_a
# do something with arg_a
elsif arg_b
# do something with arg_b
elsif arg_c
# do something with arg_c
end
end
edited Apr 15 at 17:22
answered Apr 15 at 17:16
meagarmeagar
878513
878513
$begingroup$
The solution proposed by you does makes the code much clearer - I think this is the answer I was looking for. This convert method is only for argument validation - based on it other methods are called.
$endgroup$
– ciejj
Apr 15 at 17:30
add a comment |
$begingroup$
The solution proposed by you does makes the code much clearer - I think this is the answer I was looking for. This convert method is only for argument validation - based on it other methods are called.
$endgroup$
– ciejj
Apr 15 at 17:30
$begingroup$
The solution proposed by you does makes the code much clearer - I think this is the answer I was looking for. This convert method is only for argument validation - based on it other methods are called.
$endgroup$
– ciejj
Apr 15 at 17:30
$begingroup$
The solution proposed by you does makes the code much clearer - I think this is the answer I was looking for. This convert method is only for argument validation - based on it other methods are called.
$endgroup$
– ciejj
Apr 15 at 17:30
add a comment |
$begingroup$
From what I can tell, your implementation only makes use of one of the three arguments, and only really expects (or allows) a single argument at a time.
i.e., with your current implementation, this is what an error-free call-site looks like:
convert(arg_a: 1)
convert(arg_b: 2)
convert(arg_c: 'foo')
If the method were called with two or more arguments (any of them), it would raise an ArgumentError
, so really, this method can only be called with a single argument.
Given that you're already using keyword arguments with a default value of nil
, I cannot see how this is any better than simply writing three different methods that handle the three values. Therefore, something like...
def convert_arg_a(a)
# Handle a...
end
def convert_arg_b(b)
# Handle b...
end
def convert_arg_c(c)
# Handle c...
end
...should be able to do exactly what is possible with the implementation you've described, with none of the branching.
New contributor
$endgroup$
add a comment |
$begingroup$
From what I can tell, your implementation only makes use of one of the three arguments, and only really expects (or allows) a single argument at a time.
i.e., with your current implementation, this is what an error-free call-site looks like:
convert(arg_a: 1)
convert(arg_b: 2)
convert(arg_c: 'foo')
If the method were called with two or more arguments (any of them), it would raise an ArgumentError
, so really, this method can only be called with a single argument.
Given that you're already using keyword arguments with a default value of nil
, I cannot see how this is any better than simply writing three different methods that handle the three values. Therefore, something like...
def convert_arg_a(a)
# Handle a...
end
def convert_arg_b(b)
# Handle b...
end
def convert_arg_c(c)
# Handle c...
end
...should be able to do exactly what is possible with the implementation you've described, with none of the branching.
New contributor
$endgroup$
add a comment |
$begingroup$
From what I can tell, your implementation only makes use of one of the three arguments, and only really expects (or allows) a single argument at a time.
i.e., with your current implementation, this is what an error-free call-site looks like:
convert(arg_a: 1)
convert(arg_b: 2)
convert(arg_c: 'foo')
If the method were called with two or more arguments (any of them), it would raise an ArgumentError
, so really, this method can only be called with a single argument.
Given that you're already using keyword arguments with a default value of nil
, I cannot see how this is any better than simply writing three different methods that handle the three values. Therefore, something like...
def convert_arg_a(a)
# Handle a...
end
def convert_arg_b(b)
# Handle b...
end
def convert_arg_c(c)
# Handle c...
end
...should be able to do exactly what is possible with the implementation you've described, with none of the branching.
New contributor
$endgroup$
From what I can tell, your implementation only makes use of one of the three arguments, and only really expects (or allows) a single argument at a time.
i.e., with your current implementation, this is what an error-free call-site looks like:
convert(arg_a: 1)
convert(arg_b: 2)
convert(arg_c: 'foo')
If the method were called with two or more arguments (any of them), it would raise an ArgumentError
, so really, this method can only be called with a single argument.
Given that you're already using keyword arguments with a default value of nil
, I cannot see how this is any better than simply writing three different methods that handle the three values. Therefore, something like...
def convert_arg_a(a)
# Handle a...
end
def convert_arg_b(b)
# Handle b...
end
def convert_arg_c(c)
# Handle c...
end
...should be able to do exactly what is possible with the implementation you've described, with none of the branching.
New contributor
New contributor
answered Apr 15 at 17:21
Hari GopalHari Gopal
1211
1211
New contributor
New contributor
add a comment |
add a comment |