Tur F#
Cara terbaik untuk mempelajari tentang F# adalah dengan membaca dan menulis kode F#. Artikel ini akan bertindak sebagai tur melalui beberapa fitur utama F# dan memberi Anda beberapa cuplikan kode yang dapat Anda jalankan di komputer Anda. 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 dua konsep ini.
Menjalankan kode secara online
Jika Anda tidak menginstal F# di komputer, Anda dapat menjalankan semua sampel di browser Anda dengan Coba F# di Fable. Fable adalah dialek F# yang dijalankan langsung di browser Anda. Untuk melihat sampel berikut di REPL, periksa Sampel > Learn > Tour of F# di bilah menu sebelah kiri Fable REPL.
Fungsi dan Modul
Potongan paling mendasar dari setiap program F# adalah fungsi diatur ke dalam modul .
Fungsi melakukan tugas pada masukan untuk menghasilkan keluaran, dan diatur di bawah Modul , yang merupakan cara utama Anda mengelompokkan hal-hal di F#. Mereka didefinisikan menggunakanpengikatan
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}"
let pengikatan juga merupakan cara Anda mengikat nilai ke nama, mirip dengan variabel dalam bahasa lain.
let pengikatan tidak dapat diubah secara default, yang berarti bahwa setelah nilai atau fungsi terikat ke nama, pengikatan tersebut tidak dapat diubah secara langsung. Ini berbeda dengan variabel dalam bahasa lain, yang yang dapat diubah , yang berarti nilainya dapat diubah kapan saja. Jika Anda 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 nilai Boolean dan penerapan logika bersyarat dasar:
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 inilah tampilan string dasar manipulasi:
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}"
Tuple
Tuples adalah hal yang signifikan dalam F#. Mereka adalah pengelompokan nilai yang tidak disebutkan namanya tetapi diurutkan yang dapat diperlakukan sebagai nilai itu sendiri. Anggap saja sebagai nilai yang dikumpulkan dari nilai lain. Mereka memiliki banyak kegunaan, seperti dengan mudah mengembalikan beberapa nilai dari fungsi, atau mengelompokkan nilai untuk kemudahan 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. Ini juga berinteroperasi sepenuhnya dengan tuple C#7/Visual Basic 15, yang juga merupakan struct tuple.
/// 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 struct tuple adalah tipe nilai, mereka tidak dapat secara implisit dikonversi menjadi tuple referensi, atau sebaliknya. Anda harus secara eksplisit mengonversi antara referensi dan struct tuple.
Jalur Pipa
Operator pipa |> digunakan secara ekstensif saat memproses data di F#. Operator ini memungkinkan Anda untuk membuat "alur" fungsi dengan cara yang fleksibel. Contoh berikut menjelaskan bagaimana Anda dapat memanfaatkan operator ini untuk membangun alur fungsi 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 . Meskipun ini adalah konsep lanjutan, harus jelas seberapa mudah fungsi dapat digunakan untuk memproses data saat membangun alur.
Daftar, Array, dan Urutan
Daftar, Array, dan Urutan adalah tiga jenis koleksi utama di pustaka inti F#.
Daftar adalah kumpulan elemen yang diurutkan dan tidak dapat diubah, dengan jenis yang sama. Mereka adalah daftar tertaut tunggal, yang berarti ini dimaksudkan untuk enumerasi, tetapi pilihan yang buruk untuk akses acak dan penggabungan jika ukurannya besar. Ini berbeda dengan Daftar dalam bahasa populer lainnya, yang biasanya tidak menggunakan daftar yang ditautkan secara senyap 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 berukuran tetap, kumpulan elemen yang dapat diubah dengan jenis yang sama. Mereka mendukung akses acak elemen yang cepat, dan lebih cepat daripada daftar F# karena mereka hanya 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 serangkaian elemen logis, semua jenis yang sama. Ini adalah jenis yang lebih umum daripada Daftar-daftar dan Array, yang dapat berfungsi sebagai "tampilan" Anda ke dalam serangkaian elemen logis apa pun. Mereka juga menonjol karena mereka dapat malas, yang berarti bahwa elemen hanya dapat dihitung 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
Memproses koleksi 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.
Nota
Contoh berikut menggunakan pencocokan pola melalui ekspresi match. Konstruksi mendasar ini dibahas nanti dalam artikel ini.
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 Pengoptimalan Panggilan Ekor, yang merupakan cara untuk mengoptimalkan panggilan rekursif sehingga mereka sama cepatnya dengan konstruksi perulangan.
Jenis Tipe Catatan dan Tipe Union Diskriminatif
Jenis Rekaman dan Union adalah dua jenis data dasar yang digunakan dalam kode F#, dan umumnya merupakan cara terbaik untuk mewakili data dalam program F#. Meskipun ini membuat mereka mirip dengan kelas dalam bahasa lain, salah satu perbedaan utamanya adalah bahwa mereka memiliki semantik kesetaraan struktural. Ini berarti bahwa mereka sebanding secara alami dan kesetaraannya langsung - cuma periksa apakah satu sama dengan yang lain.
Rekaman (atau struktur data) adalah sekumpulan nilai bernama, dengan anggota opsional (seperti metode). Jika Anda terbiasa dengan C# atau Java, maka ini akan terasa mirip dengan POCO atau POJO - hanya dengan kesetaraan struktural dan lebih sedikit upacara.
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. Ini dilakukan dengan atribut [<Struct>]:
[<Struct>]
type ContactCardStruct =
{ Name : string
Phone : string
Verified : bool }
Discriminated Unions (DUs) adalah nilai yang dapat berupa sejumlah bentuk atau kasus khusus. Data yang disimpan dalam jenis dapat menjadi 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 DUs sebagai Single-CaseUnions Diskriminasi , untuk membantu pemodelan domain atas jenis primitif. Seringkali, string dan jenis primitif lainnya digunakan untuk mewakili sesuatu, dan dengan demikian diberi arti tertentu. Namun, hanya menggunakan representasi primitif data yang dapat mengakibatkan kesalahan menetapkan nilai yang salah! Mewakili setiap jenis informasi sebagai union kasus tunggal yang berbeda dapat memastikan kebenaran pada 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 contoh di atas, untuk mendapatkan nilai dasar dalam Discriminated Union satu kasus, Anda harus membongkarnya secara eksplisit.
Selain itu, DUs juga mendukung definisi rekursif, memungkinkan Anda untuk dengan mudah mewakili pohon dan data rekursif secara inheren. Misalnya, berikut 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 DUs 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#. Dalam sampel di atas, Anda mungkin melihat cukup banyak sintaks match x with .... Konstruksi ini memungkinkan pengkompilasi, yang dapat memahami "bentuk" jenis data, untuk memaksa Anda memperhitungkan semua kemungkinan kasus saat menggunakan jenis data melalui apa yang dikenal sebagai Pencocokan Pola Lengkap. Ini sangat kuat untuk memastikan ketepatan, dan dapat digunakan dengan cerdik untuk "mengangkat" apa yang biasanya menjadi masalah saat menjalankan menjadi masalah saat 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
Sampel berikut memperkenalkan pola _, yang mungkin telah Anda perhatikan sebelumnya. Ini dikenal sebagai Pola Kartu Bebas , yang merupakan cara untuk mengatakan "Saya tidak peduli apa itu". Meskipun nyaman, Anda dapat secara tidak sengaja melewati Pencocokan Pola Lengkap dan tidak lagi mendapat manfaat dari penegakan waktu kompilasi jika Anda tidak hati-hati saat menggunakan _. Paling baik digunakan ketika Anda tidak mempermasalahkan elemen-elemen tertentu dari tipe yang diurai saat melakukan pencocokan pola, atau pada klausa terakhir ketika Anda telah mencakup semua kasus yang relevan dalam ekspresi pencocokan pola.
Dalam contoh berikut, kasus _ 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. Mereka memungkinkan Anda untuk mempartisi data input ke dalam formulir kustom, menguraikannya di situs panggilan kecocokan pola. Mereka juga dapat diparameterkan, sehingga memungkinkan untuk menentukan 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!"
Pilihan
Salah satu kasus khusus dari union yang dibatasi adalah tipe opsi, yang sangat berguna sehingga menjadi bagian dari pustaka inti F#.
Jenis Opsi adalah jenis yang mewakili salah satu dari dua kasus: nilai, atau tidak sama sekali. Ini digunakan dalam skenario apa pun di mana nilai mungkin atau mungkin tidak dihasilkan dari operasi tertentu. Ini kemudian memaksa Anda untuk memperhitungkan kedua kasus, menjadikannya masalah waktu kompilasi daripada masalah runtime. Ini sering digunakan dalam API di mana null digunakan untuk mewakili "tidak ada" sebagai gantinya, sehingga menghilangkan kebutuhan untuk khawatir tentang NullReferenceException dalam 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 tipe F# mencakup kemampuan memberikan konteks pada literal numerik melalui Unit Pengukuran. Satuan ukuran memungkinkan Anda mengaitkan tipe numerik ke satuan, seperti Meter, agar fungsi bekerja pada satuan daripada literal numerik. Ini memungkinkan pengkompilasi untuk memverifikasi bahwa jenis literal numerik yang diteruskan masuk akal di bawah konteks tertentu, sehingga menghilangkan kesalahan run-time yang terkait dengan jenis pekerjaan tersebut.
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 mendefinisikan banyak jenis unit SI dan konversi unit. Untuk mempelajari lebih lanjut, lihat FSharp.Data.UnitSystems.SI.UnitSymbols Namespace.
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 event sebagai anggota .
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}"
Menentukan kelas generik juga mudah.
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 menerapkan Antarmuka, Anda dapat menggunakan sintaks interface ... with atau Object Expression.
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 akan Digunakan
Kehadiran Kelas, Rekaman, Serikat Terdiskriminasi, dan Tuples mengarah pada pertanyaan penting: mana yang harus Anda gunakan? Seperti kebanyakan segala sesuatu dalam hidup, jawabannya tergantung pada keadaan Anda.
Tuple sangat bagus untuk mengembalikan beberapa nilai dari fungsi, dan untuk menggunakan kumpulan sementara dari beberapa nilai sebagai satu nilai tersendiri.
Rekord adalah "peningkatan" dari Tuples, yang memiliki label yang diberi nama dan dukungan untuk anggota opsional. Mereka bagus untuk representasi seremoni rendah data saat transit melalui program Anda. Karena mereka memiliki kesetaraan struktural, mereka mudah digunakan dengan perbandingan.
Serikat Diskriminatif memiliki berbagai kegunaan, tetapi keuntungan utamanya adalah dapat menggunakannya bersama dengan Pencocokan Pola untuk menangani semua kemungkinan "bentuk" yang mungkin dimiliki oleh 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 terkait dengan beberapa data, menggunakan Kelas dan prinsip-prinsip pemrograman Object-Oriented adalah manfaat yang signifikan. Kelas juga merupakan jenis data pilihan saat beroperasi dengan C# dan Visual Basic, karena bahasa ini menggunakan kelas untuk hampir semuanya.
Langkah Berikutnya
Sekarang setelah Anda melihat beberapa fitur utama bahasa, Anda harus siap untuk menulis program F# pertama Anda! Lihat Memulai untuk mempelajari cara menyiapkan lingkungan pengembangan Anda dan menulis beberapa kode.
Selain itu, lihat Referensi Bahasa F# untuk melihat kumpulan konten konseptual yang komprehensif di F#.
