Làm thế nào để nhập khẩu các lớp bên trong mà không phụ thuộc đường dẫn trong Scala?

Question

TL & DR: Có thể (cục bộ?) Vô hiệu hóa nhập đường dẫn phụ thuộc không? Tôi muốn đưa ra một tuyên bố nhập đơn lẻ tương tự như import x._, nhưng để thực hiện C, hãy tham khảo X#C thay vì x.C (X là loại x)?

tôi có một loạt các loại:

class Button[M] { ... } 
class Label[M] { ... } 
... 

Và tôi xảy ra để sử dụng chúng cùng nhau đi qua các đối số kiểu tương tự cho tất cả trong số họ:

class UseSite[M] (
    btn1 : Button[M] 
, btn2 : Button[M] 
, lbl1 : Label[M]) { 
    ... 
} 

tôi nghĩ rằng nó sẽ được tốt đẹp để đóng gói tất cả các loại đó để tôi chỉ cần chuyển thông số loại một lần:

class Swing[M] { 
    class Button { ... } 
    class Label { ...} 
} 

Sau đó, trên trang web sử dụng I 'Muốn để có thể làm điều này:

class WithSwing[M] { 
    val swing = new Swing[M] 
    import swing._ 
    class UseSite(
    btn1 : Button 
    , btn2 : Button 
    , lbl1 : Label) { 
    ... 
    } 
} 

Tuy nhiên, điều này không hoạt động đúng vì gõ đường dẫn phụ thuộc: Button đề cập đến swing.Button thay vì Swing[M]#Button nên mã bên ngoài có một thời gian rất vất vả vượt qua đúng đối số cho hàm tạo UseSite.

Có cách nào tốt đẹp để thực hiện Button tham chiếu đến Swing[M]#Button thay vì để swing.Button?

Answer 1

Người ta có thể tưởng tượng một cái gì đó giống như

import Swing[M]#_ 

để mang lại tất cả các thành viên loại loại Swing[M] vào phạm vi, nhưng điều này không tồn tại (import hy vọng một giá trị, không phải là một loại). Đối với mục đích thực tế, làm thế nào về một loại bí danh để giảm nồi hơi-tấm,

type S = Swing[M] 
val b: S#Button = ... // Shorter than Swing[M]#Button 

Answer 2

Giả sử rằng con đường phụ thuộc nào thực sự được tình cờ, sau đó chứ không phải là dự báo kiểu đuổi theo tất cả các cách thức thông qua codebase của bạn, bạn có thể thử một cái gì đó như thế này ,

class Button[M] 
class Label[M] 

trait Swing[M] { 
    type ButtonM = Button[M] 
    type LabelM = Label[M] 
} 

class WithSwing[M] { 
    val swing = new Swing[M] {} 
    import swing._ 
    class UseSite(btn1 : ButtonM, btn2 : ButtonM, lbl1 : LabelM) 
} 

Bên ngoài WithSwing sử dụng sẽ như thế nào,

val ws = new WithSwing[String] 
import ws.swing._ 
new ws.UseSite(new ButtonM {}, new ButtonM {}, new LabelM {}) 

Inheritance tăng ngắn gọn một chút,

class WithSwing[M] extends Swing[M] { 
    class UseSite(btn1 : ButtonM, btn2 : ButtonM, lbl1 : LabelM) 
} 

// Usage ... 
val ws = new WithSwing[String] 
import ws._ 
new ws.UseSite(new ButtonM {}, new ButtonM {}, new LabelM {})