Tips bermain golf di Dotty

Question

Apa tip umum yang Anda miliki untuk bermain golf di Dotty ? Saya sedang mencari ide yang dapat diterapkan pada masalah kode golf secara umum yang setidaknya agak spesifik untuk Dotty (misalnya "hapus komentar" bukan jawaban). Harap posting satu tip untuk setiap jawaban.

Lihat juga Tips bermain golf di Scala

Answer 1

Gunakan parameter untupling

Penguraian parameter memungkinkan Anda untuk menulis fungsi yang menerima satu tupel sebagai input seolah-olah fungsi tersebut menerima 2 parameter. Pada dasarnya, Anda bisa mengganti ini

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))

dengan ini, yang lebih pendek dan lebih indah.

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

Answer 2

Gunakan fungsi @main dan toplevel

Jika Anda perlu membuat program lengkap, gunakan @mainanotasi pada metode utama tingkat atas.

@main def main={code}

Ini jauh lebih pendek dari 2 pendekatan ini:

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

Answer 3

Literal Numerik

Anda sekarang dapat menulis literal angka untuk tipe yang ditentukan pengguna dengan turunan tertentu / implisit dari FromDigitssifat tersebut, seperti BigIntdan BigDecimal.

Di Scala 2, untuk meneruskan nomor 9.999.999.999.999.999 ke fungsi yang menerima BigInts, Anda harus menggunakan BigInt("9999999999999999"), tapi sekarang Anda bisa langsung mengatakan 9999999999999999tanpa menggunakan metode atau konstruktor apply secara eksplisit.

Anda juga dapat menggunakan garis bawah, notasi ilmiah, hex, dll., Seperti literal bilangan normal lainnya, selama FromDigitsinstance untuk jenis tersebut mendukung notasi tersebut, tentunya. Keduanya boleh BigIntdan BigDecimalboleh menggunakan garis bawah, tetapi hanya BigIntmengizinkan hex, dan hanya BigDecimalmengizinkan notasi ilmiah (dengan desimal).

Answer 4

Kawat gigi opsional

Dalam ekspresi pertandingan, setidaknya, Anda dapat menghemat satu byte dengan menggunakan sintaks berbasis indentasi.

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

adalah 27 byte, sedangkan kode di bawah ini adalah 28.

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

Sebagai catatan tambahan, matchjuga mendapat perlakuan khusus dalam hal chaining. Kode Scala 2 berikut:

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

sekarang dapat ditulis tanpa tanda kurung:

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

Answer 5

Meninggalkan newdengan aplikasi pencipta

Anda bisa memanggil konstruktor tanpa menggunakan new(seperti Kotlin), memperlakukan semua kelas seolah-olah mereka memiliki applymetode dalam pengiringnya. Ini menghemat 4 byte setiap kali Anda membuat contoh sesuatu, karena new Foo()menjadi adil Foo().

Ini juga berlaku untuk givens (meskipun Anda jarang membutuhkannya untuk kode golf):

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

Answer 6

Gunakan jenis pencocokan untuk fungsi rekursif yang pola cocok

Membuat typealias dengan jenis yang cocok terkadang lebih pendek daripada menggunakan fungsi yang tepat. Misalnya, ambil implementasi kalkulus KI ini (bukan hal yang sebenarnya). Jenisnya tidak perlu :Any, jadi Anda menghemat 7 byte secara keseluruhan ( type1 byte lebih dari 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}

Memang, dalam contoh khusus ini, Anda dapat menggunakan auto-tupling`` ->literal fungsi pencocokan pola, dll. Untuk membuat def lebih pendek, tetapi ini hanya satu kasus. Saat Anda tidak berurusan dengan tupel, atau tipe kembaliannya lebih kompleks dari sekadar Any, atau Anda memiliki banyak parameter, tip ini menjadi lebih berguna.

Answer 7

Sintaks Kontrol Baru

Dalam kebanyakan kasus, sintaks kontrol baru tidak mempersingkat kode (dan sebenarnya lebih bertele-tele), ini berguna untuk pemahaman. Jika ekspresi atau pola Anda diakhiri atau dimulai dengan tanda kurung atau tanda kutip ganda, Anda dapat menyimpan satu atau dua 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

Ini tidak berguna seperti beberapa hal lain, seperti parameter untupling, tetapi saya sering menemukan diri saya menggunakan untuk pemahaman untuk pemanggilan fungsi seperti f(foo)atau Seq(1,2), yang diakhiri dengan tanda kurung.

Lihat itu berjalan di Scastie .