[#105450] [Ruby master Feature#18228] Add a `timeout` option to `IO.copy_stream` — "byroot (Jean Boussier)" <noreply@...>
Issue #18228 has been reported by byroot (Jean Boussier).
11 messages
2021/09/27
[ruby-core:105209] [Ruby master Feature#17355] Using same set of names in or-patterns (pattern matching with Foo(x) | Bar(x))
From:
duerst <noreply@...>
Date:
2021-09-12 22:54:31 UTC
List:
ruby-core #105209
Issue #17355 has been updated by duerst (Martin Dst). I'm confused by this code: ``` case [1, 2] in [1, a] | [a, 3] => a then a end # duplicated variable name ``` The variable isn't used twice, it's used four times. We can ignore the last one, because this is just to give a result back, and of course we should be able to give a back if we matched it. But the third `a` is very confusing. We match `a` to 2 because `[1, 2]` matches `[1, a]` and not `[a, 2]`, but then we match `[1, a]` again to `a`? It looks like an attempt to some kind of recursive unification, which is definitely not possible in Ruby. So I would be okay to allow ``` case [1, 2] in [1, a] | [a, 3] => b then a end # duplicated variable name ``` or of course also ``` case [1, 2] in [1, a] | [a, 3] => b then b end # duplicated variable name ``` but anything that comes close to ``` in [1, a] | [a, 3] => a ``` seems confusing and dangerous. ---------------------------------------- Feature #17355: Using same set of names in or-patterns (pattern matching with Foo(x) | Bar(x)) https://bugs.ruby-lang.org/issues/17355#change-93617 * Author: decuplet (Nikita Shilnikov) * Status: Assigned * Priority: Normal * Assignee: ktsj (Kazuki Tsujimoto) ---------------------------------------- Given pattern matching is officially supported in Ruby 3, I have an idea about making it more flexible. Currently, this piece of code produces a syntax error ```ruby case [1, 2] in [1, a] | [a, 3] => a then a end # duplicated variable name ``` Duplications don't seem to be a problem here, semantically-wise. We just need to check if all patterns have the same set of names. It's supported in OCaml (also here's an RFC in Rust https://github.com/rust-lang/rust/issues/54883) so I think it can work in Ruby too. I've been using pattern matching in Ruby since day 1 and it worked great so far. Since I use OCaml daily too I miss this feature every once in a while :) A more practical example: imagine you have code like this ```ruby def user_email(user) case user in User(email:) then email in Admin(email:) then email in Moderator(email:) then email end end ``` Clearly, it could be simplified if or-patterns were supported: ```ruby def user_email(user) case user in User(email:) | Admin(email:) | Moderator(email:) then email end end ``` I'd like to know @ktsj's thoughts on this. -- https://bugs.ruby-lang.org/ Unsubscribe: <mailto:[email protected]?subject=unsubscribe> <http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-core>