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@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@swift.org> wrote:
>>> On 27 Dec 2015, at 07:12, Developer via swift-evolution
>>> <swift-evolution@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@swift.org
>> https://lists.swift.org/mailman/listinfo/swift-evolution
>
>
> _______________________________________________
> swift-evolution mailing list
> swift-evolution@swift.org
> https://lists.swift.org/mailman/listinfo/swift-evolution
_______________________________________________
swift-evolution mailing list
swift-evolution@swift.org
https://lists.swift.org/mailman/listinfo/swift-evolution
