[swift-evolution] Beef up Imports

[Developer]

The 'except' change is interesting, but it's still a context switch that can wind up confusing people.  I think that's partly why Agda has the 'renaming' operation separate in the first place.

~Robert Widmann

2015/12/27 10:30、T.J. Usiyan via swift-evolution <swift-evolution at swift.org> のメッセージ:

> import Foo using (bar, Baz, qux, waldo as fred)  // a "whitelist import"
> import Foo hiding (bar, Baz, qux, waldo as fred) // a "blacklist import"
> 
> 
> Is nice but `hiding… (waldo as fred)` is confusing. Am I hiding waldo? It is also strange to look in that list for things that I am hiding and things that I am importing. Context switches after the item that I am importing because `as` follows the item in question.
> 
> import Foo (waldo as fred) using (bar, Baz, qux)  // a "whitelist import"
> import Foo (waldo as fred) hiding (bar, Baz, qux) // a "blacklist import"
> 
> `using` didn't actually need the syntax change but maintaining one consistent form might be worth it. If not, `import Foo using (bar, Baz, waldo as fred)` is fine. 
> 
> On Sun, Dec 27, 2015 at 7:44 AM, Pyry Jahkola via swift-evolution <swift-evolution at swift.org> wrote:
>>> On 27 Dec 2015, at 07:12, Developer via swift-evolution <swift-evolution at swift.org> wrote:
>>> 
>>> Therefore, I propose the introduction of 3 agda-esque operations for imports to replace the usual `import {func|typealias|struct|class|enum|etc.}` syntax:
>>> 
>>> 	• import Foo using (bar, Baz, qux, corge, …)
>>> 	• import Foo hiding (bar, baz, qux, corge, …)
>>> 	• import Foo renaming (grault to garply, waldo to fred, …)
>> 
>> +1, but why not just…?
>> 
>> import Foo using (bar, Baz, qux, waldo as fred)  // a "whitelist import"
>> import Foo hiding (bar, Baz, qux, waldo as fred) // a "blacklist import"
>> 
>> I've been able to work around identifier conflicts with the present import syntax but it gets clumsy with larger modules. I think both import-using and import-hiding would be very welcome in Swift, but the third notation made me double check its semantics from The Agda Wiki. Turns out the renaming (...) syntax is actually an extension to the other two and is often used as a part of the one or the other:
>> 
>> import Foo using (bar, Baz, qux) renaming (waldo to fred)
>> import Foo hiding (bar, Baz, qux) renaming (waldo to fred)
>> 
>> Why not do without renaming? Just allow both import-using and import-hiding to optionally rename imported identifiers. Further, while these keywords can and should be made context-specific, I think it's simplest to reuse "as" as the associating keyword.
>> 
>> That would lead us to the proposed syntax:
>> 
>> import Foo using (bar, Baz, qux, waldo as fred)  // a "whitelist import"
>> import Foo hiding (bar, Baz, qux, waldo as fred) // a "blacklist import"
>> 
>> where the tuple-like parentheses enclose a potentially empty list of identifiers or "identifier as identifier" mappings. The examples below should clarify the meaning and intended use of these two statements.
>> 
>>> Again, it should be obvious by uniqueness of identifiers what each one is referencing, so qualification of each identifier is unnecessary.
>> 
>> 
>> Agreed. In addition, extending the import statement to class/enum/struct members doesn't make sense to me. Those don't conflict with the global scope at all.
>> 
>> — Pyry Jahkola
>> 
>> 
>> P.S. If this turns into a formal proposal, should we also address how imported operators should be dealt with? Can operators be selectively imported, hidden, or renamed? If renaming is made possible, we should be explicit on how the renamed operator inherits its associativity and precedence from the original one.
>> 
>> 
>> Examples
>> 
>> Suppose the module Foo contains the following identifiers:
>> 
>> // module Foo:
>> // - bar, Baz, qux, waldo
>> 
>> The "import-all" remains as it is in Swift 2:
>> 
>> import Foo
>> 
>> _ = (bar, Baz.self, qux, waldo) // All identifiers can be unqualified.
>> 
>> The "import-all" is synonymous with the longer "hide-nothing":
>> 
>> import Foo hiding ()
>> 
>> To hide or rename an identifier, fill in the parentheses:
>> 
>> import Foo hiding (Baz, waldo as fred)
>> 
>> _ = (bar, qux, fred)            // These names can be unqualified.
>> _ = (Foo.Baz.self, Foo.waldo)   // These names must be qualified.
>> _ = Foo.fred                    // Compiler error!
>> 
>> To import selectively, potentially renaming identifiers, use the import-using syntax:
>> 
>> import Foo using (Baz as FooBaz, qux, waldo as fred)
>> 
>> _ = (FooBaz.self, qux, fred)    // These names can be unqualified.
>> _ = (Foo.Baz.self, Foo.bar)     // These names must be qualified.
>> 
>> Finally, it's possible to require qualified use of the Foo module:
>> 
>> import Foo using ()
>> 
>> _ = (Foo.bar, Foo.Baz.self, Foo.qux, Foo.waldo) // OK.
>> _ = (bar, Baz.self, qux, waldo) // Compiler error x 4!
>> 
>> End.
>> 
>> _______________________________________________
>> swift-evolution mailing list
>> swift-evolution at swift.org
>> https://lists.swift.org/mailman/listinfo/swift-evolution
> 
> 
> _______________________________________________
> swift-evolution mailing list
> swift-evolution at swift.org
> https://lists.swift.org/mailman/listinfo/swift-evolution
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <https://lists.swift.org/pipermail/swift-evolution/attachments/20151227/0043bea6/attachment.html>