4 ms·
my preference is to only use rebinding if I need to rename something more than once (can happen, in with blocks), and when I do it I postfix-sigil with ! as a c
by dnautics 6y ago
my preference is to only use rebinding if I need to rename something more than once (can happen, in with blocks), and when I do it I postfix-sigil with ! as a code annotation to remind myself to watch out when refactoring the code.
def foo(bar!) do
bar! = decorate(bar!)
bar! = some_more(bar!)
{:ok, bar!}
end
- sodapopcan 6y agoHa! That's a new use of `!` I haven't seen :) But I suppose we are saying completely opposite things. I use rebinding only when I re-bind once. In your example, I would use pipes with a single re-bind: def foo(bar) do bar = bar |> decorate() |> some_more() {:ok, bar} end
- dnautics 6y agowell, I guess I gave a poor example, suppose you needed to destructure that bar! out of an ok tuple. def foo(bar!) do with {:ok, bar!} <- thing1(bar!), {:ok, bar!} <- thing2(bar!), {:ok, bar!} <- thing3(bar!) do bar! end end Inspiration came from julia, where ! at the end of the function means "watch out, one of the parameters is gonna be mutated!"
- sodapopcan 6y agoAh ok, I see! I didn't think of this situation. I'm pretty new to the language and only have done hobby projects so I haven't run into this specific scenario. I think here I would just use different names, even if ugly. To me the only "danger" is just in getting confused about what is what. There is otherwise no danger from a memory standpoint since Elixir is immutable. But I can appreciate your use of it here. [edited to add a missing word]
- PopeDotNinja 6y agoIf I get to choose the style, I like doing this... bar |> decorate() |> some_more() |> case do result -> {:ok, result} end
- sodapopcan 6y agoI like that. I never occurred to me to pipe into `case`.