Pengenalan F#
Cara terbaik untuk mempelajari tentang F# adalah dengan membaca dan menulis kode F#. Artikel ini akan bertindak sebagai tur untuk menjelajahi beberapa fitur utama F# dan memberikan beberapa cuplikan kode yang dapat Anda jalankan di komputer. Untuk mempelajari tentang menyiapkan lingkungan pengembangan, lihat Memulai.
Ada dua konsep utama dalam F#: fungsi dan jenis. Tur ini menekankan fitur bahasa yang termasuk dalam kedua konsep ini.
Menjalankan kode secara online
Jika Anda tidak menginstal F# di komputer, Anda dapat menjalankan semua sampel di browser dengan Coba F# di Fable. Fable adalah dialek F# yang dijalankan langsung di browser Anda. Untuk melihat sampel yang mengikuti di REPL, lihat Samples (Sampel) > Learn (Belajar) > Tour of F# (Tur F#) di bilah menu sebelah kiri REPL Fable.
Fungsi dan Modul
Bagian paling mendasar dari setiap program F# adalah fungsi yang diatur ke dalam modul. Fungsi menjalankan pekerjaan pada input untuk menghasilkan output, dan diatur dalam Modul, yang merupakan cara utama untuk mengelompokkan hal-hal di F#. Mereka ditentukan menggunakan pengikatan let, yang memberi nama fungsi dan menentukan argumennya.
module BasicFunctions =
/// You use 'let' to define a function. This one accepts an integer argument and returns an integer.
/// Parentheses are optional for function arguments, except for when you use an explicit type annotation.
let sampleFunction1 x = x*x + 3
/// Apply the function, naming the function return result using 'let'.
/// The variable type is inferred from the function return type.
let result1 = sampleFunction1 4573
// This line uses '%d' to print the result as an integer. This is type-safe.
// If 'result1' were not of type 'int', then the line would fail to compile.
printfn $"The result of squaring the integer 4573 and adding 3 is %d{result1}"
/// When needed, annotate the type of a parameter name using '(argument:type)'. Parentheses are required.
let sampleFunction2 (x:int) = 2*x*x - x/5 + 3
let result2 = sampleFunction2 (7 + 4)
printfn $"The result of applying the 2nd sample function to (7 + 4) is %d{result2}"
/// Conditionals use if/then/elif/else.
///
/// Note that F# uses white space indentation-aware syntax, similar to languages like Python.
let sampleFunction3 x =
if x < 100.0 then
2.0*x*x - x/5.0 + 3.0
else
2.0*x*x + x/5.0 - 37.0
let result3 = sampleFunction3 (6.5 + 4.5)
// This line uses '%f' to print the result as a float. As with '%d' above, this is type-safe.
printfn $"The result of applying the 3rd sample function to (6.5 + 4.5) is %f{result3}"
Pengikatan let juga merupakan cara mengikat nilai ke nama, mirip dengan variabel dalam bahasa lain. Pengikatan lettidak dapat diubah secara default, artinya nilai atau fungsi tidak dapat diubah di tempat setelah terikat ke nama. Ini berbeda dengan variabel dalam bahasa lain, yang dapat diubah, yang berarti nilainya dapat diubah kapan saja. Jika memerlukan pengikatan yang dapat diubah, Anda dapat menggunakan sintaks let mutable ....
module Immutability =
/// Binding a value to a name via 'let' makes it immutable.
///
/// The second line of code compiles, but 'number' from that point onward will shadow the previous definition.
/// There is no way to access the previous definition of 'number' due to shadowing.
let number = 2
// let number = 3
/// A mutable binding. This is required to be able to mutate the value of 'otherNumber'.
let mutable otherNumber = 2
printfn $"'otherNumber' is {otherNumber}"
// When mutating a value, use '<-' to assign a new value.
//
// Note that '=' is not the same as this. Outside binding values via 'let', '=' is used to test equality.
otherNumber <- otherNumber + 1
printfn $"'otherNumber' changed to be {otherNumber}"
Angka, Boolean, dan String
Sebagai bahasa .NET, F# mendukung jenis primitif dasar yang sama yang ada di .NET.
Berikut adalah bagaimana berbagai jenis numerik diwakili dalam F#:
module IntegersAndNumbers =
/// This is a sample integer.
let sampleInteger = 176
/// This is a sample floating point number.
let sampleDouble = 4.1
/// This computed a new number by some arithmetic. Numeric types are converted using
/// functions 'int', 'double' and so on.
let sampleInteger2 = (sampleInteger/4 + 5 - 7) * 4 + int sampleDouble
/// This is a list of the numbers from 0 to 99.
let sampleNumbers = [ 0 .. 99 ]
/// This is a list of all tuples containing all the numbers from 0 to 99 and their squares.
let sampleTableOfSquares = [ for i in 0 .. 99 -> (i, i*i) ]
// The next line prints a list that includes tuples, using an interpolated string.
printfn $"The table of squares from 0 to 99 is:\n{sampleTableOfSquares}"
Berikut adalah tampilan nilai Boolean dan logika kondisional dasar yang dijalankan:
module Booleans =
/// Booleans values are 'true' and 'false'.
let boolean1 = true
let boolean2 = false
/// Operators on booleans are 'not', '&&' and '||'.
let boolean3 = not boolean1 && (boolean2 || false)
// This line uses '%b'to print a boolean value. This is type-safe.
printfn $"The expression 'not boolean1 && (boolean2 || false)' is %b{boolean3}"
Dan ini adalahlah tampilan manipulasi string dasar:
module StringManipulation =
/// Strings use double quotes.
let string1 = "Hello"
let string2 = "world"
/// Strings can also use @ to create a verbatim string literal.
/// This will ignore escape characters such as '\', '\n', '\t', etc.
let string3 = @"C:\Program Files\"
/// String literals can also use triple-quotes.
let string4 = """The computer said "hello world" when I told it to!"""
/// String concatenation is normally done with the '+' operator.
let helloWorld = string1 + " " + string2
// This line uses '%s' to print a string value. This is type-safe.
printfn "%s" helloWorld
/// Substrings use the indexer notation. This line extracts the first 7 characters as a substring.
/// Note that like many languages, Strings are zero-indexed in F#.
let substring = helloWorld[0..6]
printfn $"{substring}"
Tupel
Tuple adalah fitur hebat di dalam F#. Mereka adalah pengelompokan nilai yang tidak memiliki nama tetapi berurutan dan dapat diperlakukan sebagai nilai itu sendiri. Anggap saja sebagai nilai yang diagregat dari nilai lain. Mereka memiliki banyak kegunaan, seperti mengembalikan beberapa nilai dengan mudah dari fungsi, atau mengelompokkan nilai untuk beberapa kenyamanan ad-hoc.
module Tuples =
/// A simple tuple of integers.
let tuple1 = (1, 2, 3)
/// A function that swaps the order of two values in a tuple.
///
/// F# Type Inference will automatically generalize the function to have a generic type,
/// meaning that it will work with any type.
let swapElems (a, b) = (b, a)
printfn $"The result of swapping (1, 2) is {(swapElems (1,2))}"
/// A tuple consisting of an integer, a string,
/// and a double-precision floating point number.
let tuple2 = (1, "fred", 3.1415)
printfn $"tuple1: {tuple1}\ttuple2: {tuple2}"
Anda juga dapat membuat tuple struct. Tuple juga beroperasi penuh dengan 15 tuple C#7/Visual Basic, yang juga merupakan tuple struct:
/// Tuples are normally objects, but they can also be represented as structs.
///
/// These interoperate completely with structs in C# and Visual Basic.NET; however,
/// struct tuples are not implicitly convertible with object tuples (often called reference tuples).
///
/// The second line below will fail to compile because of this. Uncomment it to see what happens.
let sampleStructTuple = struct (1, 2)
//let thisWillNotCompile: (int*int) = struct (1, 2)
// Although you can
let convertFromStructTuple (struct(a, b)) = (a, b)
let convertToStructTuple (a, b) = struct(a, b)
printfn $"Struct Tuple: {sampleStructTuple}\nReference tuple made from the Struct Tuple: {(sampleStructTuple |> convertFromStructTuple)}"
Penting untuk dicatat bahwa karena tuple struct adalah jenis nilai, tuple tidak dapat dikonversi secara implisit ke tuple referensi, atau sebaliknya. Anda harus secara eksplisit mengonversi antara referensi dan tuple struct.
Pipelines
Operator alur |> digunakan secara ekstensif saat memproses data di F#. Operator ini memungkinkan Anda untuk membuat "alur" fungsi dengan cara yang fleksibel. Contoh berikut menjelaskan cara memanfaatkan operator ini untuk membangun alur fungsional sederhana:
module PipelinesAndComposition =
/// Squares a value.
let square x = x * x
/// Adds 1 to a value.
let addOne x = x + 1
/// Tests if an integer value is odd via modulo.
///
/// '<>' is a binary comparison operator that means "not equal to".
let isOdd x = x % 2 <> 0
/// A list of 5 numbers. More on lists later.
let numbers = [ 1; 2; 3; 4; 5 ]
/// Given a list of integers, it filters out the even numbers,
/// squares the resulting odds, and adds 1 to the squared odds.
let squareOddValuesAndAddOne values =
let odds = List.filter isOdd values
let squares = List.map square odds
let result = List.map addOne squares
result
printfn $"processing {numbers} through 'squareOddValuesAndAddOne' produces: {squareOddValuesAndAddOne numbers}"
/// A shorter way to write 'squareOddValuesAndAddOne' is to nest each
/// sub-result into the function calls themselves.
///
/// This makes the function much shorter, but it's difficult to see the
/// order in which the data is processed.
let squareOddValuesAndAddOneNested values =
List.map addOne (List.map square (List.filter isOdd values))
printfn $"processing {numbers} through 'squareOddValuesAndAddOneNested' produces: {squareOddValuesAndAddOneNested numbers}"
/// A preferred way to write 'squareOddValuesAndAddOne' is to use F# pipe operators.
/// This allows you to avoid creating intermediate results, but is much more readable
/// than nesting function calls like 'squareOddValuesAndAddOneNested'
let squareOddValuesAndAddOnePipeline values =
values
|> List.filter isOdd
|> List.map square
|> List.map addOne
printfn $"processing {numbers} through 'squareOddValuesAndAddOnePipeline' produces: {squareOddValuesAndAddOnePipeline numbers}"
/// You can shorten 'squareOddValuesAndAddOnePipeline' by moving the second `List.map` call
/// into the first, using a Lambda Function.
///
/// Note that pipelines are also being used inside the lambda function. F# pipe operators
/// can be used for single values as well. This makes them very powerful for processing data.
let squareOddValuesAndAddOneShorterPipeline values =
values
|> List.filter isOdd
|> List.map(fun x -> x |> square |> addOne)
printfn $"processing {numbers} through 'squareOddValuesAndAddOneShorterPipeline' produces: {squareOddValuesAndAddOneShorterPipeline numbers}"
/// Lastly, you can eliminate the need to explicitly take 'values' in as a parameter by using '>>'
/// to compose the two core operations: filtering out even numbers, then squaring and adding one.
/// Likewise, the 'fun x -> ...' bit of the lambda expression is also not needed, because 'x' is simply
/// being defined in that scope so that it can be passed to a functional pipeline. Thus, '>>' can be used
/// there as well.
///
/// The result of 'squareOddValuesAndAddOneComposition' is itself another function which takes a
/// list of integers as its input. If you execute 'squareOddValuesAndAddOneComposition' with a list
/// of integers, you'll notice that it produces the same results as previous functions.
///
/// This is using what is known as function composition. This is possible because functions in F#
/// use Partial Application and the input and output types of each data processing operation match
/// the signatures of the functions we're using.
let squareOddValuesAndAddOneComposition =
List.filter isOdd >> List.map (square >> addOne)
printfn $"processing {numbers} through 'squareOddValuesAndAddOneComposition' produces: {squareOddValuesAndAddOneComposition numbers}"
Sampel sebelumnya menggunakan banyak fitur F#, termasuk fungsi pemrosesan daftar, fungsi kelas satu, dan aplikasi parsial. Meski ini adalah konsep lanjutan, harus jelas seberapa mudah fungsi dapat digunakan dalam memproses data saat membangun alur.
Daftar, Array, dan Urutan
Daftar, Array, dan Urutan adalah tiga jenis kumpulan utama di pustaka inti F#.
Daftar adalah kumpulan elemen berurutan yang tidak dapat diubah dengan jenis yang sama. Mereka adalah daftar tertaut tunggal, yang berarti mereka dimaksudkan untuk enumerasi, tetapi pilihan yang buruk untuk akses acak dan perangkaian jika ukurannya besar. Ini berbeda dengan Daftar dalam bahasa populer lainnya, yang biasanya tidak menggunakan daftar tertaut tunggal untuk mewakili Daftar.
module Lists =
/// Lists are defined using [ ... ]. This is an empty list.
let list1 = [ ]
/// This is a list with 3 elements. ';' is used to separate elements on the same line.
let list2 = [ 1; 2; 3 ]
/// You can also separate elements by placing them on their own lines.
let list3 = [
1
2
3
]
/// This is a list of integers from 1 to 1000
let numberList = [ 1 .. 1000 ]
/// Lists can also be generated by computations. This is a list containing
/// all the days of the year.
///
/// 'yield' is used for on-demand evaluation. More on this later in Sequences.
let daysList =
[ for month in 1 .. 12 do
for day in 1 .. System.DateTime.DaysInMonth(2017, month) do
yield System.DateTime(2017, month, day) ]
// Print the first 5 elements of 'daysList' using 'List.take'.
printfn $"The first 5 days of 2017 are: {daysList |> List.take 5}"
/// Computations can include conditionals. This is a list containing the tuples
/// which are the coordinates of the black squares on a chess board.
let blackSquares =
[ for i in 0 .. 7 do
for j in 0 .. 7 do
if (i+j) % 2 = 1 then
yield (i, j) ]
/// Lists can be transformed using 'List.map' and other functional programming combinators.
/// This definition produces a new list by squaring the numbers in numberList, using the pipeline
/// operator to pass an argument to List.map.
let squares =
numberList
|> List.map (fun x -> x*x)
/// There are many other list combinations. The following computes the sum of the squares of the
/// numbers divisible by 3.
let sumOfSquares =
numberList
|> List.filter (fun x -> x % 3 = 0)
|> List.sumBy (fun x -> x * x)
printfn $"The sum of the squares of numbers up to 1000 that are divisible by 3 is: %d{sumOfSquares}"
Array adalah kumpulan elemen berukuran tetap dan dapat diubah dari jenis yang sama. Mereka mendukung akses acak elemen yang cepat, dan lebih cepat dibandingkan daftar F# karena hanya berupa blok memori yang bersebelahan.
module Arrays =
/// This is The empty array. Note that the syntax is similar to that of Lists, but uses `[| ... |]` instead.
let array1 = [| |]
/// Arrays are specified using the same range of constructs as lists.
let array2 = [| "hello"; "world"; "and"; "hello"; "world"; "again" |]
/// This is an array of numbers from 1 to 1000.
let array3 = [| 1 .. 1000 |]
/// This is an array containing only the words "hello" and "world".
let array4 =
[| for word in array2 do
if word.Contains("l") then
yield word |]
/// This is an array initialized by index and containing the even numbers from 0 to 2000.
let evenNumbers = Array.init 1001 (fun n -> n * 2)
/// Sub-arrays are extracted using slicing notation.
let evenNumbersSlice = evenNumbers[0..500]
/// You can loop over arrays and lists using 'for' loops.
for word in array4 do
printfn $"word: {word}"
// You can modify the contents of an array element by using the left arrow assignment operator.
//
// To learn more about this operator, see: https://learn.microsoft.com/dotnet/fsharp/language-reference/values/index#mutable-variables
array2[1] <- "WORLD!"
/// You can transform arrays using 'Array.map' and other functional programming operations.
/// The following calculates the sum of the lengths of the words that start with 'h'.
///
/// Note that in this case, similar to Lists, array2 is not mutated by Array.filter.
let sumOfLengthsOfWords =
array2
|> Array.filter (fun x -> x.StartsWith "h")
|> Array.sumBy (fun x -> x.Length)
printfn $"The sum of the lengths of the words in Array 2 is: %d{sumOfLengthsOfWords}"
Urutan adalah rangkaian elemen logis dari jenis yang sama. Urutan adalah jenis yang lebih umum daripada Daftar dan Array, serta mampu menjadi "tampilan" Anda ke dalam serangkaian elemen logis apa pun. Urutan juga menonjol karena bisa menjadi lazy (malas), yang berarti bahwa elemen dapat dikomputasi hanya ketika diperlukan.
module Sequences =
/// This is the empty sequence.
let seq1 = Seq.empty
/// This a sequence of values.
let seq2 = seq { yield "hello"; yield "world"; yield "and"; yield "hello"; yield "world"; yield "again" }
/// This is an on-demand sequence from 1 to 1000.
let numbersSeq = seq { 1 .. 1000 }
/// This is a sequence producing the words "hello" and "world"
let seq3 =
seq { for word in seq2 do
if word.Contains("l") then
yield word }
/// This is a sequence producing the even numbers up to 2000.
let evenNumbers = Seq.init 1001 (fun n -> n * 2)
let rnd = System.Random()
/// This is an infinite sequence which is a random walk.
/// This example uses yield! to return each element of a subsequence.
let rec randomWalk x =
seq { yield x
yield! randomWalk (x + rnd.NextDouble() - 0.5) }
/// This example shows the first 100 elements of the random walk.
let first100ValuesOfRandomWalk =
randomWalk 5.0
|> Seq.truncate 100
|> Seq.toList
printfn $"First 100 elements of a random walk: {first100ValuesOfRandomWalk}"
Fungsi Rekursif
Pemrosesan kumpulan atau urutan elemen biasanya dilakukan dengan rekursi di F#. Meskipun F# memiliki dukungan untuk perulangan dan pemrograman imperatif, rekursi lebih disukai karena lebih mudah untuk menjamin kebenaran.
Catatan
Contoh berikut menggunakan pencocokan pola melalui ekspresi match. Konstruksi dasar ini akan dibahas nanti di dalam artikel.
module RecursiveFunctions =
/// This example shows a recursive function that computes the factorial of an
/// integer. It uses 'let rec' to define a recursive function.
let rec factorial n =
if n = 0 then 1 else n * factorial (n-1)
printfn $"Factorial of 6 is: %d{factorial 6}"
/// Computes the greatest common factor of two integers.
///
/// Since all of the recursive calls are tail calls,
/// the compiler will turn the function into a loop,
/// which improves performance and reduces memory consumption.
let rec greatestCommonFactor a b =
if a = 0 then b
elif a < b then greatestCommonFactor a (b - a)
else greatestCommonFactor (a - b) b
printfn $"The Greatest Common Factor of 300 and 620 is %d{greatestCommonFactor 300 620}"
/// This example computes the sum of a list of integers using recursion.
///
/// '::' is used to split a list into the head and tail of the list,
/// the head being the first element and the tail being the rest of the list.
let rec sumList xs =
match xs with
| [] -> 0
| y::ys -> y + sumList ys
/// This makes 'sumList' tail recursive, using a helper function with a result accumulator.
let rec private sumListTailRecHelper accumulator xs =
match xs with
| [] -> accumulator
| y::ys -> sumListTailRecHelper (accumulator+y) ys
/// This invokes the tail recursive helper function, providing '0' as a seed accumulator.
/// An approach like this is common in F#.
let sumListTailRecursive xs = sumListTailRecHelper 0 xs
let oneThroughTen = [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]
printfn $"The sum 1-10 is %d{sumListTailRecursive oneThroughTen}"
F# juga memiliki dukungan penuh untuk Optimalisasi Panggilan Tail, yang merupakan cara untuk mengoptimalkan panggilan rekursif agar secepat konstruksi perulangan.
Jenis Rekaman dan Gabungan Terdiskriminasi
Jenis Rekaman dan Gabungan adalah dua jenis data mendasar yang digunakan dalam kode F#, dan umumnya merupakan cara terbaik untuk mewakili data dalam program F#. Meski ini membuatnya mirip dengan kelas dalam bahasa lain, salah satu perbedaan utamanya adalah bahwa mereka memiliki semantik persamaan struktural. Artinya mereka "secara asli" sebanding dan persamaannya sederhana - cukup periksa apakah satu sama dengan yang lain.
Rekaman adalah agregat nilai yang memiliki nama dengan anggota opsional (seperti metode). Jika Anda familier dengan C# atau Java, ini akan terasa mirip dengan POCO atau POJO - hanya dengan persamaan struktural dan lebih sedikit seremoni.
module RecordTypes =
/// This example shows how to define a new record type.
type ContactCard =
{ Name : string
Phone : string
Verified : bool }
/// This example shows how to instantiate a record type.
let contact1 =
{ Name = "Alf"
Phone = "(206) 555-0157"
Verified = false }
/// You can also do this on the same line with ';' separators.
let contactOnSameLine = { Name = "Alf"; Phone = "(206) 555-0157"; Verified = false }
/// This example shows how to use "copy-and-update" on record values. It creates
/// a new record value that is a copy of contact1, but has different values for
/// the 'Phone' and 'Verified' fields.
///
/// To learn more, see: https://learn.microsoft.com/dotnet/fsharp/language-reference/copy-and-update-record-expressions
let contact2 =
{ contact1 with
Phone = "(206) 555-0112"
Verified = true }
/// This example shows how to write a function that processes a record value.
/// It converts a 'ContactCard' object to a string.
let showContactCard (c: ContactCard) =
c.Name + " Phone: " + c.Phone + (if not c.Verified then " (unverified)" else "")
printfn $"Alf's Contact Card: {showContactCard contact1}"
/// This is an example of a Record with a member.
type ContactCardAlternate =
{ Name : string
Phone : string
Address : string
Verified : bool }
/// Members can implement object-oriented members.
member this.PrintedContactCard =
this.Name + " Phone: " + this.Phone + (if not this.Verified then " (unverified)" else "") + this.Address
let contactAlternate =
{ Name = "Alf"
Phone = "(206) 555-0157"
Verified = false
Address = "111 Alf Street" }
// Members are accessed via the '.' operator on an instantiated type.
printfn $"Alf's alternate contact card is {contactAlternate.PrintedContactCard}"
Anda juga dapat mewakili Rekaman sebagai struct. Hal ini dilakukan dengan atribut [<Struct>]:
[<Struct>]
type ContactCardStruct =
{ Name : string
Phone : string
Verified : bool }
Gabungan Terdiskriminasi (Discriminated Unions (DU)) adalah nilai yang bisa berupa sejumlah formulir atau kasus yang memiliki nama. Data yang disimpan dalam jenis ini dapat berupa salah satu dari beberapa nilai yang berbeda.
module DiscriminatedUnions =
/// The following represents the suit of a playing card.
type Suit =
| Hearts
| Clubs
| Diamonds
| Spades
/// A Discriminated Union can also be used to represent the rank of a playing card.
type Rank =
/// Represents the rank of cards 2 .. 10
| Value of int
| Ace
| King
| Queen
| Jack
/// Discriminated Unions can also implement object-oriented members.
static member GetAllRanks() =
[ yield Ace
for i in 2 .. 10 do yield Value i
yield Jack
yield Queen
yield King ]
/// This is a record type that combines a Suit and a Rank.
/// It's common to use both Records and Discriminated Unions when representing data.
type Card = { Suit: Suit; Rank: Rank }
/// This computes a list representing all the cards in the deck.
let fullDeck =
[ for suit in [ Hearts; Diamonds; Clubs; Spades] do
for rank in Rank.GetAllRanks() do
yield { Suit=suit; Rank=rank } ]
/// This example converts a 'Card' object to a string.
let showPlayingCard (c: Card) =
let rankString =
match c.Rank with
| Ace -> "Ace"
| King -> "King"
| Queen -> "Queen"
| Jack -> "Jack"
| Value n -> string n
let suitString =
match c.Suit with
| Clubs -> "clubs"
| Diamonds -> "diamonds"
| Spades -> "spades"
| Hearts -> "hearts"
rankString + " of " + suitString
/// This example prints all the cards in a playing deck.
let printAllCards() =
for card in fullDeck do
printfn $"{showPlayingCard card}"
Anda juga dapat menggunakan DU sebagai Gabungan Terdiskriminasi Kasus Tunggal untuk membantu pemodelan domain pada jenis primitif. Sering kali, string dan jenis primitif lainnya digunakan untuk mewakili sesuatu sehingga diberikan arti tertentu. Namun, hanya menggunakan representasi primitif data yang dapat mengakibatkan kesalahan dalam menetapkan nilai! Mewakili setiap jenis informasi sebagai gabungan kasus tunggal yang berbeda dapat menerapkan kebenaran dalam skenario ini.
// Single-case DUs are often used for domain modeling. This can buy you extra type safety
// over primitive types such as strings and ints.
//
// Single-case DUs cannot be implicitly converted to or from the type they wrap.
// For example, a function which takes in an Address cannot accept a string as that input,
// or vice versa.
type Address = Address of string
type Name = Name of string
type SSN = SSN of int
// You can easily instantiate a single-case DU as follows.
let address = Address "111 Alf Way"
let name = Name "Alf"
let ssn = SSN 1234567890
/// When you need the value, you can unwrap the underlying value with a simple function.
let unwrapAddress (Address a) = a
let unwrapName (Name n) = n
let unwrapSSN (SSN s) = s
// Printing single-case DUs is simple with unwrapping functions.
printfn $"Address: {address |> unwrapAddress}, Name: {name |> unwrapName}, and SSN: {ssn |> unwrapSSN}"
Seperti yang ditunjukkan oleh sampel di atas, untuk mendapatkan nilai yang mendasari dalam Gabungan Terdiskriminasi kasus tunggal, Anda harus membongkarnya secara eksplisit.
Selain itu, DU juga mendukung definisi rekursif, memungkinkan Anda untuk mewakili pohon dengan mudah dan data rekursif secara inheren. Misalnya, berikut adalah cara mewakili Pohon Pencarian Biner dengan fungsi exists dan insert.
/// Discriminated Unions also support recursive definitions.
///
/// This represents a Binary Search Tree, with one case being the Empty tree,
/// and the other being a Node with a value and two subtrees.
///
/// Note 'T here is a type parameter, indicating that 'BST' is a generic type.
/// More on generics later.
type BST<'T> =
| Empty
| Node of value:'T * left: BST<'T> * right: BST<'T>
/// Check if an item exists in the binary search tree.
/// Searches recursively using Pattern Matching. Returns true if it exists; otherwise, false.
let rec exists item bst =
match bst with
| Empty -> false
| Node (x, left, right) ->
if item = x then true
elif item < x then (exists item left) // Check the left subtree.
else (exists item right) // Check the right subtree.
/// Inserts an item in the Binary Search Tree.
/// Finds the place to insert recursively using Pattern Matching, then inserts a new node.
/// If the item is already present, it does not insert anything.
let rec insert item bst =
match bst with
| Empty -> Node(item, Empty, Empty)
| Node(x, left, right) as node ->
if item = x then node // No need to insert, it already exists; return the node.
elif item < x then Node(x, insert item left, right) // Call into left subtree.
else Node(x, left, insert item right) // Call into right subtree.
Karena DU memungkinkan Anda untuk mewakili struktur rekursif pohon dalam jenis data, pengoperasian pada struktur rekursif ini mudah dan menjamin kebenaran. Ini juga didukung dalam pencocokan pola, seperti yang ditunjukkan di bawah ini.
Pencocokan Pola
Pencocokan Pola adalah fitur F# yang memungkinkan kebenaran untuk beroperasi pada jenis F#. Pada sampel di atas, Anda mungkin melihat sedikit sintaks match x with .... Konstruksi ini memungkinkan pengompilasi, yang dapat memahami "bentuk" jenis data, untuk memaksa Anda mempertanggungjawabkan semua kemungkinan kasus saat menggunakan jenis data melalui apa yang dikenal sebagai Pencocokan Pola Lengkap. Ini sangat bermanfaat untuk kebenaran, dan dapat digunakan dengan cerdik untuk "mengangkat" hal yang biasanya merupakan perhatian run-time menjadi perhatian waktu kompilasi.
module PatternMatching =
/// A record for a person's first and last name
type Person = {
First : string
Last : string
}
/// A Discriminated Union of 3 different kinds of employees
type Employee =
| Engineer of engineer: Person
| Manager of manager: Person * reports: List<Employee>
| Executive of executive: Person * reports: List<Employee> * assistant: Employee
/// Count everyone underneath the employee in the management hierarchy,
/// including the employee. The matches bind names to the properties
/// of the cases so that those names can be used inside the match branches.
/// Note that the names used for binding do not need to be the same as the
/// names given in the DU definition above.
let rec countReports(emp : Employee) =
1 + match emp with
| Engineer(person) ->
0
| Manager(person, reports) ->
reports |> List.sumBy countReports
| Executive(person, reports, assistant) ->
(reports |> List.sumBy countReports) + countReports assistant
Hal yang mungkin telah Anda perhatikan adalah penggunaan pola _. Ini dikenal sebagai Pola Wildcard, yang merupakan cara untuk mengatakan "Saya tidak peduli hal apakah itu". Meski nyaman, Anda dapat secara tidak sengaja melewati Pencocokan Pola Lengkap dan tidak lagi mendapat manfaat dari penegakan waktu kompilasi jika Anda tidak berhati-hati dalam menggunakan _. Ini paling baik digunakan ketika Anda tidak peduli dengan potongan tertentu dari jenis yang diurai saat pencocokan pola, atau klausa akhir ketika Anda telah melakukan enumerasi semua kasus yang bermakna dalam ekspresi pencocokan pola.
Dalam contoh berikut, kasus _ ini digunakan saat operasi penguraian gagal.
/// Find all managers/executives named "Dave" who do not have any reports.
/// This uses the 'function' shorthand to as a lambda expression.
let findDaveWithOpenPosition(emps : List<Employee>) =
emps
|> List.filter(function
| Manager({First = "Dave"}, []) -> true // [] matches an empty list.
| Executive({First = "Dave"}, [], _) -> true
| _ -> false) // '_' is a wildcard pattern that matches anything.
// This handles the "or else" case.
/// You can also use the shorthand function construct for pattern matching,
/// which is useful when you're writing functions which make use of Partial Application.
let private parseHelper (f: string -> bool * 'T) = f >> function
| (true, item) -> Some item
| (false, _) -> None
let parseDateTimeOffset = parseHelper DateTimeOffset.TryParse
let result = parseDateTimeOffset "1970-01-01"
match result with
| Some dto -> printfn "It parsed!"
| None -> printfn "It didn't parse!"
// Define some more functions which parse with the helper function.
let parseInt = parseHelper Int32.TryParse
let parseDouble = parseHelper Double.TryParse
let parseTimeSpan = parseHelper TimeSpan.TryParse
Pola Aktif adalah konstruksi lain yang kuat untuk digunakan dengan pencocokan pola. Pola ini memungkinkan Anda mempartisi data input ke dalam formulir kustom, menguraikannya di situs panggilan kecocokan pola. Pola ini juga dapat diparameterkan, sehingga memungkinkan penentuan partisi sebagai fungsi. Memperluas contoh sebelumnya untuk mendukung Pola Aktif terlihat seperti ini:
let (|Int|_|) = parseInt
let (|Double|_|) = parseDouble
let (|Date|_|) = parseDateTimeOffset
let (|TimeSpan|_|) = parseTimeSpan
/// Pattern Matching via 'function' keyword and Active Patterns often looks like this.
let printParseResult = function
| Int x -> printfn $"%d{x}"
| Double x -> printfn $"%f{x}"
| Date d -> printfn $"%O{d}"
| TimeSpan t -> printfn $"%O{t}"
| _ -> printfn "Nothing was parse-able!"
// Call the printer with some different values to parse.
printParseResult "12"
printParseResult "12.045"
printParseResult "12/28/2016"
printParseResult "9:01PM"
printParseResult "banana!"
Opsi
Salah satu kasus khusus jenis Gabungan Terdiskriminasi adalah Jenis Opsi, yang sangat berguna sehingga merupakan bagian dari pustaka inti F#.
Jenis Opsi adalah jenis yang mewakili salah satu dari dua kasus: nilai, atau tidak sama sekali. Jenis ini digunakan dalam skenario di mana nilai mungkin atau mungkin tidak dihasilkan dari operasi tertentu. Jenis ini kemudian memaksa Anda untuk mempertimbangan kedua kasus, menjadikannya kekhawatiran waktu kompilasi daripada masalah runtime. Jenis ini sering digunakan dalam API di mana null digunakan untuk mewakili "tidak ada" sebagai gantinya, sehingga menghilangkan kebutuhan untuk khawatir tentang NullReferenceException di banyak keadaan.
module OptionValues =
/// First, define a zip code defined via Single-case Discriminated Union.
type ZipCode = ZipCode of string
/// Next, define a type where the ZipCode is optional.
type Customer = { ZipCode: ZipCode option }
/// Next, define an interface type that represents an object to compute the shipping zone for the customer's zip code,
/// given implementations for the 'getState' and 'getShippingZone' abstract methods.
type IShippingCalculator =
abstract GetState : ZipCode -> string option
abstract GetShippingZone : string -> int
/// Next, calculate a shipping zone for a customer using a calculator instance.
/// This uses combinators in the Option module to allow a functional pipeline for
/// transforming data with Optionals.
let CustomerShippingZone (calculator: IShippingCalculator, customer: Customer) =
customer.ZipCode
|> Option.bind calculator.GetState
|> Option.map calculator.GetShippingZone
Satuan Ukuran
Sistem jenis F#mencakup kemampuan untuk menyediakan konteks bagi harfiah numerik melalui Satuan Ukuran. Satuan ukuran memungkinkan Anda mengaitkan jenis numerik ke unit, seperti Meter, dan memiliki fungsi yang melakukan pekerjaan pada satuan, bukan harfiah numerik. Ini memungkinkan pengompilasi memverifikasi bahwa jenis harfiah numerik yang diteruskan masuk akal dalam konteks tertentu, sehingga menghilangkan kesalahan run-time yang terkait dengan pekerjaan semacam itu.
module UnitsOfMeasure =
/// First, open a collection of common unit names
open Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// Define a unitized constant
let sampleValue1 = 1600.0<meter>
/// Next, define a new unit type
[<Measure>]
type mile =
/// Conversion factor mile to meter.
static member asMeter = 1609.34<meter/mile>
/// Define a unitized constant
let sampleValue2 = 500.0<mile>
/// Compute metric-system constant
let sampleValue3 = sampleValue2 * mile.asMeter
// Values using Units of Measure can be used just like the primitive numeric type for things like printing.
printfn $"After a %f{sampleValue1} race I would walk %f{sampleValue2} miles which would be %f{sampleValue3} meters"
Pustaka F# Core menentukan banyak jenis unit SI dan konversi unit. Untuk mempelajari selengkapnya, lihat NamespaceFSharp.Data.UnitSystems.SI.UnitSymbols.
Pemrograman Objek
F# memiliki dukungan penuh untuk pemrograman objek melalui kelas, Antarmuka, Kelas Abstrak, Warisan, dan sebagainya.
Kelas adalah jenis yang mewakili objek .NET, yang dapat memiliki properti, metode, dan peristiwa sebagai Anggotanya.
module DefiningClasses =
/// A simple two-dimensional Vector class.
///
/// The class's constructor is on the first line,
/// and takes two arguments: dx and dy, both of type 'double'.
type Vector2D(dx : double, dy : double) =
/// This internal field stores the length of the vector, computed when the
/// object is constructed
let length = sqrt (dx*dx + dy*dy)
// 'this' specifies a name for the object's self-identifier.
// In instance methods, it must appear before the member name.
member this.DX = dx
member this.DY = dy
member this.Length = length
/// This member is a method. The previous members were properties.
member this.Scale(k) = Vector2D(k * this.DX, k * this.DY)
/// This is how you instantiate the Vector2D class.
let vector1 = Vector2D(3.0, 4.0)
/// Get a new scaled vector object, without modifying the original object.
let vector2 = vector1.Scale(10.0)
printfn $"Length of vector1: %f{vector1.Length}\nLength of vector2: %f{vector2.Length}"
Penentuan kelas generik juga mudah dilakukan.
module DefiningGenericClasses =
type StateTracker<'T>(initialElement: 'T) =
/// This internal field store the states in a list.
let mutable states = [ initialElement ]
/// Add a new element to the list of states.
member this.UpdateState newState =
states <- newState :: states // use the '<-' operator to mutate the value.
/// Get the entire list of historical states.
member this.History = states
/// Get the latest state.
member this.Current = states.Head
/// An 'int' instance of the state tracker class. Note that the type parameter is inferred.
let tracker = StateTracker 10
// Add a state
tracker.UpdateState 17
Untuk mengimplementasikan Antarmuka, Anda dapat menggunakan sintaks interface ... with atau Ekspresi Objek.
module ImplementingInterfaces =
/// This is a type that implements IDisposable.
type ReadFile() =
let file = new System.IO.StreamReader("readme.txt")
member this.ReadLine() = file.ReadLine()
// This is the implementation of IDisposable members.
interface System.IDisposable with
member this.Dispose() = file.Close()
/// This is an object that implements IDisposable via an Object Expression
/// Unlike other languages such as C# or Java, a new type definition is not needed
/// to implement an interface.
let interfaceImplementation =
{ new System.IDisposable with
member this.Dispose() = printfn "disposed" }
Jenis Mana yang Harus Digunakan
Kehadiran Classes, Rekaman, Gabungan Terdiskriminasi, dan Tuple menimbulkan pertanyaan penting: mana yang harus Anda gunakan? Seperti kebanyakan hal dalam hidup, jawabannya tergantung pada keadaan Anda.
Tuple sangat bagus untuk mengembalikan beberapa nilai dari fungsi, dan menggunakan agregat nilai ad-hoc sebagai nilai itu sendiri.
Rekaman adalah "peningkatan" dari Tuple, yang memiliki label bernama dan dukungan untuk anggota opsional. Mereka sangat bagus untuk representasi data dalam transit yang rendah melalui program Anda. Karena memiliki persamaan struktural, mereka mudah digunakan dengan perbandingan.
Gabungan Terdiskriminasi memiliki banyak kegunaan, tetapi manfaat intinya adalah untuk dapat menggunakannya bersama dengan Pencocokan Pola guna memperhitungkan semua kemungkinan "bentuk" yang dapat dimiliki data.
Kelas sangat bagus karena sejumlah besar alasan, seperti ketika Anda perlu mewakili informasi dan juga mengikat informasi tersebut dengan fungsionalitas. Sebagai aturan praktis, ketika Anda memiliki fungsionalitas yang secara konseptual terikat dengan beberapa data, menggunakan Kelas dan prinsip-prinsip Pemrograman Berorientasi Objek adalah manfaat yang signifikan. Kelas juga merupakan jenis data pilihan saat beroperasi dengan C# dan Visual Basic, karena bahasa ini menggunakan kelas untuk hampir semua hal.
Langkah berikutnya
Sekarang setelah Anda melihat beberapa fitur utama bahasa, seharusnya Anda sudah siap untuk menulis program F# pertama Anda! Lihat Memulai untuk mempelajari cara menyiapkan lingkungan pengembangan dan menulis beberapa kode.
Selain itu, lihat Referensi Bahasa F# untuk melihat kumpulan konten konseptual yang komprehensif di F#.
Saran dan Komentar
Segera hadir: Sepanjang tahun 2024 kami akan menghentikan penggunaan GitHub Issues sebagai mekanisme umpan balik untuk konten dan menggantinya dengan sistem umpan balik baru. Untuk mengetahui informasi selengkapnya, lihat: https://aka.ms/ContentUserFeedback.
Kirim dan lihat umpan balik untuk