Apa tips umum yang Anda miliki untuk bermain golf di F #? Saya mencari ide yang dapat diterapkan pada masalah kode golf secara umum yang setidaknya agak spesifik untuk F # (mis. "Hapus komentar" bukan jawaban). Silakan kirim satu tip per jawaban.

Gunakan functionalih-alih matchbila memungkinkan; itu akan menghemat 6 karakter untuk variabel 1 karakter:

let f=function // ... (14 chars)

vs.

let f x=match x with // ... (20 chars)

Itu juga dapat mengganti kecocokan pola apa pun untuk secara konsisten menyimpan 1 karakter:

match a with|          // ... (13 chars)
a|>function|           // ... (12 chars)
(function| (* ... *))a // (12 chars)

Perlu menggunakan metode pada variabel yang Anda belum membatasi jenisnya? Bandingkan saja dengan literal dari tipe yang Anda inginkan lalu buang hasilnya untuk mencatat tipe variabel itu:

let f (x:string)=x.Length
let f x=x="";x.Length

Gunakan notasi awalan untuk operator infiks ketika Anda bisa - itu akan menyelamatkan Anda dari keharusan mendefinisikan fungsi untuk menggunakannya.

Misalnya, Anda dapat mengubah ini:

List.map(fun i->i+2)[1;1;2;3;5;8]

dalam hal ini:

List.map((+)2)[1;1;2;3;5;8]

Dekonstruksi Tuple

Jika Anda tidak bisa menggunakan variabel, gunakan dekonstruksi tuple alih-alih beberapa ekspresi let

let a,b ="",[]

dari pada

let a=""
let b=[]

Membaca dari stdin

F # core library mendefinisikan alias untuk System.Console.Indipanggil stdin. Ini memungkinkan Anda membaca input.

// Signature:
stdin<'T> :  TextReader

TextReader di msdn

Keuntungan besar selain fakta bahwa ini lebih pendek daripada Consoleadalah, Anda tidak harus membuka Sistem juga

Iterasi melalui string

string pada dasarnya adalah char seq, ini memungkinkan Anda untuk menggunakan Seq.maplangsung dengan string. Dimungkinkan juga untuk menggunakannya dalam pemahaman[for c in "" do]

Mutables / Referensi sel

Menggunakan sel referensi tidak selalu lebih pendek karena setiap operasi baca disertai dengan karakter tambahan untuk melakukan sel.

Kiat umum

• Dimungkinkan untuk menulis match .. withinline lengkap

  function|'a'->()|'b'->()|_->()
  

• Tidak perlu spasi putih sebelum dan sesudah karakter non alfanumerik.

  String.replicate 42" "
  if Seq.exists((<>)'@')s then
  if(Seq.exists((<>)'@')s)then
  

• Jika Anda perlu ke kiri atau kanan pad string dengan spasi, Anda dapat menggunakan flag [s] printf [n] untuk itu.

  > sprintf "%20s" "Hello, World!";;
  val it : string = "       Hello, World!"
  

  Modul Core.Printf

Gunakan id daripada x-> x

id adalah singkatan dari fungsi identitas.

let u x=x|>Seq.countBy (fun x->x)

dapat ditulis

let u x=x|>Seq.countBy id

sumber

Saya menggunakannya di sini

Eta-konversi untuk fungsi

Terima kasih banyak kepada Laikoni untuk tip ini di salah satu solusi saya .

Pertimbangkan fungsi untuk, katakanlah, menjumlahkan string dengan 3 untuk huruf besar dan 1 untuk semua karakter lainnya. Begitu:

let counter input = Seq.sumBy (fun x -> if Char.IsUpper x then 3 else 1) input

Dengan eta-konversi, ini dapat ditulis ulang sebagai:

let counter = Seq.sumBy (fun x -> if Char.IsUpper x then 3 else 1)

dan memanggil dengan cara yang sama seperti sebelumnya:

counter "Hello world!" |> printfn "%i"

Operator komposisi maju fungsi >>

Sekarang anggaplah tantangan awal kita adalah menjumlahkan string dengan 3 untuk huruf besar dan 1 untuk huruf kecil, dan semua karakter lain dikecualikan.

Kami mungkin menulis ini sebagai:

let counter input = Seq.filter Char.IsLetter input |> Seq.sumBy (fun x -> if Char.IsUpper x then 3 else 1)

Kita dapat menggunakan operator komposisi-maju ( >>) untuk menghubungkan kedua fungsi ( Seq.filterdan Seq.sumBy) bersama-sama. Dengan eta-konversi, definisi fungsi akan menjadi:

let counter = Seq.filter Char.IsLetter >> Seq.sumBy (fun x -> if Char.IsUpper x then 3 else 1)

Chris Smith melakukan penulisan besar-besaran >>pada operator di blog MSDN-nya .

Bila mungkin Seqlebih pendek dari List:

[[1];[2;3];[4];[5]|>List.collect

[[1];[2;3];[4];[5]|>Seq.collect

adalah salah satu char lebih pendek ...

Hindari tanda kurung saat menggunakan satu parameter dan pada tupel

let f = [(0,1);(1,4)]|>Seq.map(fst)
printfn "%A" f

dapat ditulis

let f = [0,1;1,4]|>Seq.map fst
printfn "%A" f

Lebih suka string baris baru daripada "\ n"

Ini akan mulai menghasilkan bahkan pada satu baris karakter baru dalam kode Anda. Satu use case mungkin:

(18 byte)

string.Concat"\n"

(17 byte)

string.Concat"
"

Terinspirasi dari jawaban Chiru untuk es6 .

Digunakan di sini

Gunakan .NET

.NET menawarkan banyak builtin yang bagus. F # bisa menggunakannya, jadi jangan lupakan mereka!

Contoh:

open System.Linq

Ini bisa membantu!

Gunakan lambdas untuk menyimpan byte. Sebagai contoh, ini:

let f x=x*x

Dapat dinyatakan sebagai ini:

fun x->x*x

Gunakan untuk ... untuk menggantikan ... untuk berjalan dalam jarak jangkau

for i in[0..2]
for i=0 to 2

• untuk masuk
• untuk

Kata modulekunci dapat digunakan untuk mempersingkat nama modul saat digunakan berulang kali. Sebagai contoh:

Array.fold ...
Seq.iter ...
List.map ...

bisa menjadi

module A=Array
A.fold ...
module S=Seq
S.iter ...
module L=List
L.map ...

Ini lebih berguna untuk program yang lebih lama di mana metode modul digunakan berulang kali (dan harus sepenuhnya dinamai setiap kali karena mereka memiliki RequireQualifiedAccesspengubah), dan memungkinkan mencukur beberapa karakter, terutama ketika lebih berguna untuk menggunakan array CLR biasa (misalnya, mutabilitas ) daripada F # seqatau list.