Bạn có lời khuyên chung nào cho việc chơi golf trong F #? Tôi đang tìm kiếm những ý tưởng có thể được áp dụng cho các vấn đề về golf nói chung ít nhất là cụ thể đối với F # (ví dụ: "xóa bình luận" không phải là một câu trả lời). Xin vui lòng gửi một lời khuyên cho mỗi câu trả lời.

Sử dụng functionthay vì matchkhi có thể; nó sẽ lưu 6 ký tự cho các biến 1 ký tự:

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

đấu với

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

Nó cũng có thể thay thế bất kỳ mẫu khớp nào để lưu 1 ký tự:

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

Cần sử dụng một phương thức trên biến mà bạn chưa ràng buộc loại? Chỉ cần so sánh nó với một nghĩa đen của loại bạn muốn sau đó loại bỏ kết quả để chú thích loại của biến đó:

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

Sử dụng ký hiệu tiền tố cho các toán tử infix khi bạn có thể - nó sẽ giúp bạn không phải xác định hàm để sử dụng chúng.

Ví dụ: bạn có thể biến điều này:

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

vào đây:

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

Tuple decon cấu trúc

Trong trường hợp bạn không thể sử dụng các biến, hãy sử dụng giải cấu trúc thay vì nhiều biểu thức cho phép

let a,b ="",[]

thay vì

let a=""
let b=[]

Đọc từ stdin

Thư viện lõi F # định nghĩa một bí danh cho cuộc System.Console.Ingọi stdin. Những thứ này cho phép bạn đọc đầu vào.

// Signature:
stdin<'T> :  TextReader

Trình soạn thảo văn bản trên msd

Lợi thế lớn bên cạnh thực tế là nó ngắn hơn Console là, bạn cũng không phải mở Hệ thống

Lặp lại qua chuỗi

chuỗi về cơ bản là một char seq, điều này cho phép bạn sử dụng Seq.maptrực tiếp với chuỗi. Cũng có thể sử dụng chúng trong việc hiểu[for c in "" do]

Mutables / ô tham chiếu

Việc sử dụng các ô tham chiếu không phải lúc nào cũng ngắn hơn vì mọi thao tác đọc đều đi kèm với một ký tự bổ sung để hủy bỏ ô.

Mẹo chung

• Có thể viết match .. withnội tuyến hoàn chỉnh

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

• Không cần khoảng trắng trước và sau các ký tự không chữ và số.

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

• Trong trường hợp bạn cần đệm trái hoặc phải một chuỗi có khoảng trắng, bạn có thể sử dụng cờ [s] printf [n] cho điều đó.

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

  Mô-đun Core.Printf

Sử dụng id thay vì x-> x

id là một toán tử đứng cho chức năng nhận dạng.

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

có thể được viết

let u x=x|>Seq.countBy id

nguồn

Tôi sử dụng nó ở đây

Chuyển đổi Eta cho các chức năng

Rất cám ơn Laikoni cho mẹo này trong một trong những giải pháp của tôi .

Hãy xem xét một hàm để, tổng hợp một chuỗi có 3 cho chữ in hoa và 1 cho tất cả các ký tự khác. Vì thế:

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

Bằng cách chuyển đổi eta, điều này có thể được viết lại thành:

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

và được gọi theo cùng một cách như trước đây:

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

Hàm toán tử chuyển tiếp thành phần >>

Bây giờ, giả sử thử thách ban đầu của chúng tôi là tổng hợp một chuỗi có 3 chữ cái in hoa và 1 cho chữ cái viết thường và tất cả các ký tự khác đều bị loại trừ.

Chúng tôi có thể viết điều này như:

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

Chúng ta có thể sử dụng toán tử chuyển tiếp thành phần ( >>) để xâu chuỗi hai hàm ( Seq.filtervà Seq.sumBy) lại với nhau. Với chuyển đổi eta, định nghĩa hàm sẽ trở thành:

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

Chris Smith đã viết một bài tuyệt vời về >>nhà điều hành trên blog MSDN của mình .

Khi có thể Seqngắn hơn List:

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

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

là một char ngắn hơn ...

Tránh dấu ngoặc đơn khi sử dụng một tham số và trên tuple

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

có thể được viết

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

Thích chuỗi dòng mới hơn "\ n"

Điều này sẽ bắt đầu trả hết ngay cả một ký tự dòng mới trong mã của bạn. Một trường hợp sử dụng có thể là:

(18 byte)

string.Concat"\n"

(17 byte)

string.Concat"
"

Lấy cảm hứng từ câu trả lời của Chiru cho es6 .

Sử dụng ở đây

Sử dụng .NET

.NET cung cấp rất nhiều nội dung đẹp. F # có thể sử dụng chúng, vì vậy đừng quên chúng!

Thí dụ:

open System.Linq

Nó có thể hữu ích!

Sử dụng lambdas để lưu một byte. Ví dụ: cái này:

let f x=x*x

Có thể được thể hiện như thế này:

fun x->x*x

Sử dụng cho ... để thay vì ... vào để đi bộ một phạm vi

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

• tại
• cho

Các module từ khóa có thể được sử dụng để rút ngắn tên mô-đun khi sử dụng nhiều lần. Ví dụ:

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

có thể trở thành

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

Điều này hữu ích hơn cho các chương trình dài hơn khi các phương thức mô-đun được sử dụng nhiều lần (và phải được đặt tên đầy đủ mỗi lần vì chúng có công cụ RequireQualifiedAccesssửa đổi) và cho phép cạo một vài ký tự đặc biệt là khi sử dụng mảng CLR thông thường (ví dụ: tính biến đổi ) hơn một F # seqhoặc list.