Mẹo chơi gôn ở Dotty

Question

Bạn có những lời khuyên chung nào để chơi gôn trong Dotty ? Tôi đang tìm kiếm những ý tưởng có thể áp dụng cho các bài toán chơi gôn mã nói chung mà ít nhất là phần nào cụ thể cho Dotty (ví dụ: "xóa nhận xét" không phải là câu trả lời). Vui lòng đăng một mẹo cho mỗi câu trả lời.

Cũng xem Mẹo chơi gôn ở Scala

Answer 1

Sử dụng gỡ rối tham số

Việc gỡ rối tham số cho phép bạn viết các hàm chấp nhận một bộ giá trị duy nhất làm đầu vào như thể chúng là các hàm chấp nhận 2 tham số. Về cơ bản, bạn có thể thay thế những

list.map{case(a,b)=>a+b}
//and
list.map{case(a,b)=>Seq(a,b)}
//or
list.map(t=>t._1+t._2)
//and
list.map(t=>Seq(t._1,t._2))

với cái này, vừa ngắn hơn vừa đẹp hơn.

list.map(_+_)
//and
list.map(Seq(_,_))

Answer 2

Sử dụng các hàm @main và toplevel

Nếu bạn cần tạo một chương trình đầy đủ, hãy sử dụng @mainchú thích trên phương thức chính của cấp cao nhất.

@main def main={code}

Nó ngắn hơn rất nhiều so với 2 cách tiếp cận sau:

object M extends App{code}
object M{def main(a:Array[String])={code}}

Answer 3

Chữ số

Bây giờ bạn có thể viết một chữ số cho bất kỳ kiểu nào do người dùng xác định với một trường hợp cụ thể / ngầm định của FromDigitsđặc điểm, chẳng hạn như BigIntvà BigDecimal.

Trong Scala 2, để chuyển số 9.999.999.999.999.999 cho một hàm chấp nhận BigInts, bạn sẽ phải sử dụng BigInt("9999999999999999"), nhưng bây giờ bạn chỉ có thể nói trực tiếp 9999999999999999mà không cần sử dụng phương thức áp dụng hoặc hàm tạo một cách rõ ràng.

Bạn cũng có thể sử dụng dấu gạch dưới, ký hiệu khoa học, hex, v.v., giống như bất kỳ chữ số bình thường nào, tất nhiên, miễn là FromDigitsví dụ cho kiểu đó hỗ trợ ký hiệu đó. Cả hai BigIntvà BigDecimalđều được với dấu gạch dưới, nhưng chỉ BigIntcho phép hex và chỉ BigDecimalcho phép ký hiệu khoa học (với số thập phân).

Answer 4

Niềng răng tùy chọn

Trong các biểu thức so khớp, ít nhất, bạn có thể lưu một byte bằng cách sử dụng cú pháp dựa trên thụt lề.

a match
case b=>c
case d=>e

là 27 byte, trong khi mã bên dưới là 28.

a match{case b=>c case d=>e}

Như một lưu ý phụ, matchcũng được đối xử đặc biệt khi nói đến chuỗi. Mã Scala 2 sau:

("foo"match{case x=>x})match{case x=>x}

bây giờ có thể được viết mà không có dấu ngoặc đơn:

"foo"match{case x=>x}match{case x=>x}

Answer 5

Bỏ qua newvới các ứng dụng sáng tạo

Bạn có thể gọi các hàm tạo mà không cần sử dụng new(như Kotlin), coi tất cả các lớp như thể chúng có applycác phương thức trong đồng hành của chúng. Điều này giúp tiết kiệm 4 byte mỗi khi bạn khởi tạo nội dung nào đó, vì nó new Foo()trở nên đơn giản Foo().

Điều này cũng áp dụng cho quà tặng (mặc dù bạn hiếm khi cần chúng cho chơi gôn mã):

given foo as Foo=new Foo() //bad
given foo as Foo=Foo()     //better
given foo as Foo           //great

Answer 6

Sử dụng các loại đối sánh cho các hàm đệ quy phù hợp với mẫu

Tạo một kiểu chữ với một kiểu so khớp đôi khi ngắn hơn so với việc sử dụng một hàm thích hợp. Ví dụ, thực hiện này của phép tính KI (không phải là một điều thực tế). Loại không cần thiết :Any, vì vậy bạn tiết kiệm được 7 byte tất cả ( typenhiều hơn 1 byte def).

//A normal function
def r(t:Any):Any=t match{case(('K',x),y)=>r(x)case('I',x)=>r(x)case t=>t}
//With match types
type R[T]=T match{case(('K',x),y)=>R[x]case('I',x)=>R[x]case _=>T}

Phải thừa nhận rằng, trong ví dụ cụ thể này, bạn có thể sử dụng auto-tupling,, ->các ký tự hàm đối sánh mẫu, v.v. để làm cho độ lệch ngắn hơn, nhưng đây chỉ là một trường hợp. Khi bạn không xử lý các bộ giá trị, hoặc kiểu trả về phức tạp hơn chỉ Anyhoặc bạn có nhiều tham số, mẹo này sẽ trở nên hữu ích hơn.

Answer 7

Cú pháp điều khiển mới

Trong hầu hết các trường hợp, cú pháp điều khiển mới không rút ngắn mã (và thực sự dài dòng hơn), nó có ích cho việc hiểu. Nếu biểu thức hoặc mẫu của bạn kết thúc hoặc bắt đầu bằng dấu ngoặc đơn hoặc dấu ngoặc kép, bạn có thể lưu một hoặc hai byte:

for((x,y,z)<-Seq((1,2,3),(3,4,5));y<-"foo")yield y+x  //Old-style syntax
for(x,y,z)<-Seq((1,2,3),(3,4,5));y<-"foo"yield y+x    //New control syntax

Nó không hữu ích như một số thứ khác, như gỡ bỏ tham số, nhưng tôi thường thấy mình sử dụng để hiểu cho các lệnh gọi hàm như f(foo)hoặc Seq(1,2), kết thúc bằng dấu ngoặc đơn.

Xem nó chạy trong Scastie .