F # - Panduan Cepat

F # adalah bahasa pemrograman fungsional. Untuk memahami konstruksi F #, Anda perlu membaca beberapa baris tentang paradigma pemrograman bernamaFunctional Programming.

Pemrograman fungsional memperlakukan program komputer sebagai fungsi matematika. Dalam pemrograman fungsional, fokusnya adalah pada konstanta dan fungsi, bukan variabel dan status. Karena fungsi dan konstanta adalah hal yang tidak berubah.

Dalam pemrograman fungsional, Anda akan menulis program modular, yaitu program akan terdiri dari fungsi-fungsi yang akan mengambil fungsi lain sebagai input.

Program yang ditulis dalam bahasa pemrograman fungsional cenderung ringkas.

Tentang F #

Berikut adalah informasi dasar tentang F # -

Ini dikembangkan pada tahun 2005 di Microsoft Research.
Ini adalah bagian dari keluarga bahasa .Net Microsoft.
Ini adalah bahasa pemrograman fungsional.
Ini didasarkan pada bahasa pemrograman fungsional OCaml.

Fitur F #

Ini adalah implementasi bersih dari OCaml.
Ini mengkompilasi .Net CLI (Common Language Interface) kode byte atau MSIL (Microsoft Intermediate Language) yang berjalan di CLR (Common Language Runtime).
Ini memberikan inferensi tipe.
Ini menyediakan konstruksi pencocokan pola yang kaya.
Ini memiliki skrip interaktif dan kemampuan debugging.
Ini memungkinkan penulisan fungsi urutan yang lebih tinggi.
Ini menyediakan model objek yang dikembangkan dengan baik.

Penggunaan F #

F # biasanya digunakan di area berikut -

Membuat model ilmiah
Pemecahan masalah matematika
Pekerjaan penelitian kecerdasan buatan
Pemodelan keuangan
Desain grafis
Desain CPU
Pemrograman kompiler
Telecommunications

Ini juga digunakan dalam aplikasi CRUD, halaman web, game GUI dan program tujuan umum lainnya.

Alat-alat yang diperlukan untuk pemrograman F # dibahas dalam bab ini.

Lingkungan Pengembangan Terintegrasi (IDE) untuk F #

Microsoft menyediakan Visual Studio 2013 untuk pemrograman F #.

Visual Studio 2013 Community Edition gratis tersedia dari situs web resmi Microsoft. Komunitas Visual Studio 2013 dan yang lebih baru dilengkapi dengan Visual F # Tools. Detail penginstalan tersedia di Tutorial Asp.net . Alat Visual F # menyertakan kompiler baris perintah (fsc.exe) dan F # Interactive (fsi.exe).

Dengan menggunakan alat ini, Anda dapat menulis semua jenis program F # dari aplikasi baris perintah sederhana hingga aplikasi yang lebih kompleks. Anda juga dapat menulis file kode sumber F # menggunakan editor teks dasar, seperti Notepad, dan mengkompilasi kode tersebut menjadi rakitan menggunakan kompiler baris perintah.

Anda dapat mengunduhnya dari Microsoft Visual Studio. Ini terinstal secara otomatis di mesin Anda.

Menulis Program F # Pada Link

Silakan kunjungi situs web resmi F # untuk instruksi terbaru tentang mendapatkan alat sebagai paket Debian atau mengkompilasinya langsung dari sumbernya - https://fsharp.org/use/linux/.

F # adalah bahasa Pemrograman Fungsional.

Di F #, fungsi bekerja seperti tipe data. Anda dapat mendeklarasikan dan menggunakan fungsi dengan cara yang sama seperti variabel lainnya.

Secara umum, aplikasi F # tidak memiliki titik masuk khusus. Kompilator mengeksekusi semua pernyataan level atas dalam file dari atas ke bawah.

Namun, untuk mengikuti gaya pemrograman prosedural, banyak aplikasi menyimpan pernyataan tingkat atas tunggal yang memanggil loop utama.

Kode berikut menunjukkan program F # sederhana -

open System
(* This is a multi-line comment *)
// This is a single-line comment

let sign num =
   if num > 0 then "positive"
   elif num < 0 then "negative"
   else "zero"

let main() =
   Console.WriteLine("sign 5: {0}", (sign 5))

main()

Ketika Anda mengkompilasi dan menjalankan program, itu menghasilkan output berikut -

sign 5: positive

Harap dicatat bahwa -

File kode F # mungkin dimulai dengan nomor open pernyataan yang digunakan untuk mengimpor ruang nama.
Isi file mencakup fungsi lain yang mengimplementasikan logika bisnis aplikasi.
Loop utama berisi pernyataan eksekusi teratas.

Anda telah melihat struktur dasar dari program F #, sehingga akan mudah untuk memahami blok bangunan dasar lain dari bahasa pemrograman F #.

Token di F #

Program F # terdiri dari berbagai token. Token bisa berupa kata kunci, pengenal, konstanta, string literal, atau simbol. Kita dapat mengkategorikan token F # menjadi dua jenis -

Keywords
Simbol dan Operator

F # Kata kunci

Tabel berikut menunjukkan kata kunci dan deskripsi singkat dari kata kunci. Kami akan membahas penggunaan kata kunci ini di bab-bab selanjutnya.

Kata kunci	Deskripsi
abstract	Menunjukkan metode yang tidak memiliki implementasi dalam tipe yang dideklarasikannya atau yang virtual dan memiliki implementasi default.
and	Digunakan dalam binding yang saling rekursif, dalam deklarasi properti, dan dengan beberapa batasan pada parameter generik.
as	Digunakan untuk memberi objek kelas saat ini sebuah nama objek. Juga digunakan untuk memberi nama pada seluruh pola dalam kecocokan pola.
assert	Digunakan untuk memverifikasi kode selama debugging.
base	Digunakan sebagai nama objek kelas dasar.
begin	Dalam sintaks verbose, menunjukkan awal blok kode.
class	Dalam sintaks verbose, menunjukkan awal definisi kelas.
default	Menunjukkan implementasi metode abstrak; digunakan bersama dengan deklarasi metode abstrak untuk membuat metode virtual.
delegate	Digunakan untuk mendeklarasikan delegasi.
do	Digunakan dalam konstruksi perulangan atau untuk menjalankan kode imperatif.
done	Dalam sintaks verbose, menunjukkan akhir blok kode dalam ekspresi perulangan.
downcast	Digunakan untuk mengonversi ke tipe yang lebih rendah dalam rantai warisan.
downto	Di sebuah for ekspresi, digunakan saat menghitung terbalik.
elif	Digunakan dalam percabangan bersyarat. Bentuk singkat dari else if.
else	Digunakan dalam percabangan bersyarat.
end	Dalam definisi tipe dan ekstensi tipe, menunjukkan akhir dari bagian definisi anggota. Dalam sintaks verbose, digunakan untuk menentukan akhir dari blok kode yang dimulai dengan kata kunci begin.
exception	Digunakan untuk mendeklarasikan tipe pengecualian.
extern	Menunjukkan bahwa elemen program yang dideklarasikan didefinisikan dalam biner atau perakitan lain.
false	Digunakan sebagai literal Boolean.
finally	Digunakan bersama dengan mencoba untuk memperkenalkan blok kode yang dijalankan terlepas dari apakah pengecualian terjadi.
for	Digunakan dalam konstruksi perulangan.
fun	Digunakan dalam ekspresi lambda, juga dikenal sebagai fungsi anonim.
function	Digunakan sebagai alternatif yang lebih pendek untuk kata kunci menyenangkan dan ekspresi pencocokan dalam ekspresi lambda yang memiliki pola yang cocok pada satu argumen.
global	Digunakan untuk mereferensikan namespace .NET tingkat atas.
if	Digunakan dalam konstruksi percabangan bersyarat.
in	Digunakan untuk ekspresi urutan dan, dalam sintaks verbose, untuk memisahkan ekspresi dari binding.
inherit	Digunakan untuk menentukan kelas dasar atau antarmuka dasar.
inline	Digunakan untuk menunjukkan fungsi yang harus diintegrasikan langsung ke dalam kode pemanggil.
interface	Digunakan untuk mendeklarasikan dan mengimplementasikan antarmuka.
internal	Digunakan untuk menentukan bahwa anggota terlihat di dalam majelis tetapi tidak di luarnya.
lazy	Digunakan untuk menentukan komputasi yang akan dilakukan hanya jika hasil diperlukan.
let	Digunakan untuk mengasosiasikan, atau mengikat, nama ke nilai atau fungsi.
let!	Digunakan dalam alur kerja asinkron untuk mengikat nama ke hasil komputasi asinkron, atau, dalam ekspresi komputasi lainnya, digunakan untuk mengikat nama ke hasil, yang merupakan tipe komputasi.
match	Digunakan untuk bercabang dengan membandingkan nilai dengan pola.
member	Digunakan untuk mendeklarasikan properti atau metode dalam tipe objek.
module	Digunakan untuk mengaitkan nama dengan sekelompok jenis, nilai, dan fungsi terkait, untuk memisahkannya secara logis dari kode lain.
mutable	Digunakan untuk mendeklarasikan variabel, yaitu nilai yang dapat diubah.
namespace	Digunakan untuk mengasosiasikan nama dengan sekelompok tipe dan modul terkait, untuk memisahkannya secara logis dari kode lain.
new	Digunakan untuk mendeklarasikan, mendefinisikan, atau memanggil konstruktor yang membuat atau yang dapat membuat objek. Juga digunakan dalam batasan parameter umum untuk menunjukkan bahwa suatu tipe harus memiliki konstruktor tertentu.
not	Sebenarnya bukan kata kunci. Namun, kombinasi tidak struct digunakan sebagai batasan parameter umum.
null	Menunjukkan tidak adanya suatu objek. Juga digunakan dalam batasan parameter umum.
of	Digunakan dalam serikat terdiskriminasi untuk menunjukkan tipe kategori nilai, dan dalam deklarasi delegasi dan pengecualian.
open	Digunakan untuk membuat konten namespace atau modul tersedia tanpa kualifikasi.
or	Digunakan dengan ketentuan Boolean sebagai Boolean atau operator. Setara dengan \|\|. Juga digunakan dalam batasan anggota.
override	Digunakan untuk mengimplementasikan versi metode abstrak atau virtual yang berbeda dari versi dasar.
private	Membatasi akses ke anggota untuk kode dalam tipe atau modul yang sama.
public	Mengizinkan akses ke anggota dari luar tipe.
rec	Digunakan untuk menunjukkan bahwa suatu fungsi bersifat rekursif.
return	Digunakan untuk menunjukkan nilai yang akan diberikan sebagai hasil dari ekspresi komputasi.
return!	Digunakan untuk menunjukkan ekspresi komputasi yang, ketika dievaluasi, memberikan hasil dari ekspresi komputasi yang memuatnya.
select	Digunakan dalam ekspresi kueri untuk menentukan bidang atau kolom apa yang akan diekstrak. Perhatikan bahwa ini adalah kata kunci kontekstual, yang berarti bahwa ini sebenarnya bukan kata yang dipesan dan hanya bertindak seperti kata kunci dalam konteks yang sesuai.
static	Digunakan untuk menunjukkan metode atau properti yang bisa dipanggil tanpa instance dari suatu tipe, atau anggota nilai yang dibagikan di antara semua instance suatu tipe.
struct	Digunakan untuk mendeklarasikan tipe struktur. Juga digunakan dalam batasan parameter umum. Digunakan untuk kompatibilitas OCaml dalam definisi modul.
then	Digunakan dalam ekspresi bersyarat. Juga digunakan untuk melakukan efek samping setelah konstruksi objek.
to	Digunakan untuk loop untuk menunjukkan rentang.
true	Digunakan sebagai literal Boolean.
try	Digunakan untuk memperkenalkan blok kode yang mungkin menghasilkan pengecualian. Digunakan bersama dengan atau akhirnya.
type	Digunakan untuk mendeklarasikan kelas, catatan, struktur, gabungan yang terdiskriminasi, jenis pencacahan, satuan ukuran, atau singkatan jenis.
upcast	Digunakan untuk mengonversi ke tipe yang lebih tinggi dalam rantai warisan.
use	Digunakan sebagai ganti let untuk nilai yang mengharuskan Buang dipanggil ke sumber daya gratis.
use!	Digunakan sebagai pengganti biarkan! dalam alur kerja asinkron dan ekspresi komputasi lainnya untuk nilai yang mengharuskan Buang dipanggil ke sumber daya gratis.
val	Digunakan dalam tanda tangan untuk menunjukkan nilai, atau dalam tipe untuk menyatakan anggota, dalam situasi terbatas.
void	Menunjukkan tipe void .NET. Digunakan saat beroperasi dengan bahasa .NET lainnya.
when	Digunakan untuk kondisi Boolean (saat menjaga) pada kecocokan pola dan untuk memperkenalkan klausa pembatas untuk parameter tipe umum.
while	Memperkenalkan konstruksi perulangan.
with	Digunakan bersama dengan kata kunci pencocokan dalam ekspresi pencocokan pola. Juga digunakan dalam ekspresi objek, ekspresi penyalinan rekaman, dan ekstensi tipe untuk memperkenalkan definisi anggota, dan untuk memperkenalkan penangan pengecualian.
yield	Digunakan dalam ekspresi urutan untuk menghasilkan nilai urutan.
yield!	Digunakan dalam ekspresi komputasi untuk menambahkan hasil dari ekspresi komputasi yang diberikan ke kumpulan hasil untuk ekspresi komputasi yang memuatnya.

Beberapa kata kunci yang dipesan berasal dari bahasa OCaml -

asr	tanah	lor	lsl	lsr	lxor	mod	sig

Beberapa kata kunci cadangan lainnya disimpan untuk perluasan F # di masa mendatang.

atom	istirahat	diperiksa	komponen	const	paksaan	constructor
continue	eager	event	external	fixed	functor	include
method	mixin	object	parallel	process	protected	pure
sealed	tailcall	trait	virtual	volatile

Comments in F#

F# provides two types of comments −

One line comment starts with // symbol.
Multi line comment starts with (* and ends with *).

A Basic Program and Application Entry Point in F#

Generally, you don’t have any explicit entry point for F# programs. When you compile an F# application, the last file provided to the compiler becomes the entry point and all top level statements in that file are executed from top to bottom.

A well-written program should have a single top-level statement that would call the main loop of the program.

A very minimalistic F# program that would display ‘Hello World’ on the screen −

(* This is a comment *)
(* Sample Hello World program using F# *)
printfn "Hello World!"

When you compile and execute the program, it yields the following output −

Hello World!

The data types in F# can be classified as follows −

Integral types
Floating point types
Text types
Other types

Integral Data Type

The following table provides the integral data types of F#. These are basically integer data types.

F# Type	Size	Range	Example	Remarks
sbyte	1 byte	-128 to 127	42y -11y	8-bit signed integer
byte	1 byte	0 to 255	42uy 200uy	8-bit unsigned integer
int16	2 bytes	-32768 to 32767	42s -11s	16-bit signed integer
uint16	2 bytes	0 to 65,535	42us 200us	16-bit unsigned integer
int/int32	4 bytes	-2,147,483,648 to 2,147,483,647	42 -11	32-bit signed integer
uint32	4 bytes	0 to 4,294,967,295	42u 200u	32-bit unsigned integer
int64	8 bytes	-9,223,372,036,854,775,808 to 9,223,372,036,854,775,807	42L -11L	64-bit signed integer
uint64	8 bytes	0 to 18,446,744,073,709,551,615	42UL 200UL	64-bit unsigned integer
bigint	At least 4 bytes	any integer	42I 1499999 9999999 9999999 9999999 9999I	arbitrary precision integer

Example

(* single byte integer *)
let x = 268.97f
let y = 312.58f
let z = x + y

printfn "x: %f" x
printfn "y: %f" y
printfn "z: %f" z

(* unsigned 8-bit natural number *)

let p = 2uy
let q = 4uy
let r = p + q

printfn "p: %i" p
printfn "q: %i" q
printfn "r: %i" r

(* signed 16-bit integer *)

let a = 12s
let b = 24s
let c = a + b

printfn "a: %i" a
printfn "b: %i" b
printfn "c: %i" c

(* signed 32-bit integer *)

let d = 212l
let e = 504l
let f = d + e

printfn "d: %i" d
printfn "e: %i" e
printfn "f: %i" f

When you compile and execute the program, it yields the following output −

x: 1
y: 2
z: 3
p: 2
q: 4
r: 6
a: 12
b: 24
c: 36
d: 212
e: 504
f: 716

Floating Point Data Types

The following table provides the floating point data types of F#.

F# Type	Size	Range	Example	Remarks
float32	4 bytes	±1.5e-45 to ±3.4e38	42.0F -11.0F	32-bit signed floating point number (7 significant digits)
float	8 bytes	±5.0e-324 to ±1.7e308	42.0 -11.0	64-bit signed floating point number (15-16 significant digits)
decimal	16 bytes	±1.0e-28 to ±7.9e28	42.0M -11.0M	128-bit signed floating point number (28-29 significant digits)
BigRational	At least 4 bytes	Any rational number.	42N -11N	Arbitrary precision rational number. Using this type requires a reference to FSharp.PowerPack.dll.

Example

(* 32-bit signed floating point number *)
(* 7 significant digits *)

let d = 212.098f
let e = 504.768f
let f = d + e

printfn "d: %f" d
printfn "e: %f" e
printfn "f: %f" f

(* 64-bit signed floating point number *)
(* 15-16 significant digits *)
let x = 21290.098
let y = 50446.768
let z = x + y

printfn "x: %g" x
printfn "y: %g" y
printfn "z: %g" z

When you compile and execute the program, it yields the following output −

d: 212.098000
e: 504.768000
f: 716.866000
x: 21290.1
y: 50446.8
z: 71736.9

Text Data Types

The following table provides the text data types of F#.

F# Type	Size	Range	Example	Remarks
char	2 bytes	U+0000 to U+ffff	'x' '\t'	Single unicode characters
string	20 + (2 * string's length) bytes	0 to about 2 billion characters	"Hello" "World"	Unicode text

Example

let choice = 'y'
let name = "Zara Ali"
let org = "Tutorials Point"

printfn "Choice: %c" choice
printfn "Name: %s" name
printfn "Organisation: %s" org

When you compile and execute the program, it yields the following output −

Choice: y
Name: Zara Ali
Organisation: Tutorials Point

Other Data Types

The following table provides some other data types of F#.

F# Type	Size	Range	Example	Remarks
bool	1 byte	Only two possible values, true or false	true false	Stores boolean values

Example

let trueVal = true
let falseVal = false

printfn "True Value: %b" (trueVal)
printfn "False Value: %b" (falseVal)

When you compile and execute the program, it yields the following output −

True Value: true
False Value: false

A variable is a name given to a storage area that our programs can manipulate. Each variable has a specific type, which determines the size and layout of the variable's memory; the range of values that can be stored within that memory; and the set of operations that can be applied to the variable.

Variable Declaration in F#

The let keyword is used for variable declaration −

For example,

let x = 10

It declares a variable x and assigns the value 10 to it.

You can also assign an expression to a variable −

let x = 10
let y = 20
let z = x + y

The following example illustrates the concept −

Example

let x = 10
let y = 20
let z = x + y

printfn "x: %i" x
printfn "y: %i" y
printfn "z: %i" z

When you compile and execute the program, it yields the following output −

x: 10
y: 20
z: 30

Variables in F# are immutable, which means once a variable is bound to a value, it can’t be changed. They are actually compiled as static read-only properties.

The following example demonstrates this.

Example

let x = 10
let y = 20
let z = x + y

printfn "x: %i" x
printfn "y: %i" y
printfn "z: %i" z

let x = 15
let y = 20
let z = x + y

printfn "x: %i" x
printfn "y: %i" y
printfn "z: %i" z

When you compile and execute the program, it shows the following error message −

Duplicate definition of value 'x'
Duplicate definition of value 'Y'
Duplicate definition of value 'Z'

Variable Definition With Type Declaration

A variable definition tells the compiler where and how much storage for the variable should be created. A variable definition may specify a data type and contains a list of one or more variables of that type as shown in the following example.

Example

let x:int32 = 10
let y:int32 = 20
let z:int32 = x + y

printfn "x: %d" x
printfn "y: %d" y
printfn "z: %d" z

let p:float = 15.99
let q:float = 20.78
let r:float = p + q

printfn "p: %g" p
printfn "q: %g" q
printfn "r: %g" r

When you compile and execute the program, it shows the following error message −

x: 10
y: 20
z: 30
p: 15.99
q: 20.78
r: 36.77

Mutable Variables

At times you need to change the values stored in a variable. To specify that there could be a change in the value of a declared and assigned variable, in later part of a program, F# provides the mutable keyword. You can declare and assign mutable variables using this keyword, whose values you will change.

The mutable keyword allows you to declare and assign values in a mutable variable.

You can assign some initial value to a mutable variable using the let keyword. However, to assign new subsequent value to it, you need to use the ← operator.

For example,

let mutable x = 10
x ← 15

The following example will clear the concept −

Example

let mutable x = 10
let y = 20
let mutable z = x + y

printfn "Original Values:"
printfn "x: %i" x
printfn "y: %i" y
printfn "z: %i" z

printfn "Let us change the value of x"
printfn "Value of z will change too."

x <- 15
z <- x + y

printfn "New Values:"
printfn "x: %i" x
printfn "y: %i" y
printfn "z: %i" z

When you compile and execute the program, it yields the following output −

Original Values:
x: 10
y: 20
z: 30
Let us change the value of x
Value of z will change too.
New Values:
x: 15
y: 20
z: 35

An operator is a symbol that tells the compiler to perform specific mathematical or logical manipulations. F# is rich in built-in operators and provides the following types of operators −

Arithmetic Operators
Comparison Operators
Boolean Operators
Bitwise Operators

Arithmetic Operators

The following table shows all the arithmetic operators supported by F# language. Assume variable A holds 10 and variable B holds 20 then −

Show Example

Operator	Description	Example
+	Adds two operands	A + B will give 30
-	Subtracts second operand from the first	A - B will give -10
*	Multiplies both operands	A * B will give 200
/	Divides numerator by de-numerator	B / A will give 2
%	Modulus Operator and remainder of after an integer division	B % A will give 0
**	Exponentiation Operator, raises an operand to the power of another	B**A will give 20¹⁰

Comparison Operators

The following table shows all the comparison operators supported by F# language. These binary comparison operators are available for integral and floating-point types. These operators return values of type bool.

Assume variable A holds 10 and variable B holds 20, then −

Show Example

Operator	Description	Example
=	Checks if the values of two operands are equal or not, if yes then condition becomes true.	(A == B) is not true.
<>	Checks if the values of two operands are equal or not, if values are not equal then condition becomes true.	(A <> B) is true.
>	Checks if the value of left operand is greater than the value of right operand, if yes then condition becomes true.	(A > B) is not true.
<	Checks if the value of left operand is less than the value of right operand, if yes then condition becomes true.	(A < B) is true.
>=	Checks if the value of left operand is greater than or equal to the value of right operand, if yes then condition becomes true.	(A >= B) is not true.
<=	Checks if the value of left operand is less than or equal to the value of right operand, if yes then condition becomes true.	(A <= B) is true.

Boolean Operators

The following table shows all the Boolean operators supported by F# language. Assume variable A holds true and variable B holds false, then −

Show Example

Operator	Description	Example
&&	Called Boolean AND operator. If both the operands are non-zero, then condition becomes true.	(A && B) is false.
\|\|	Called Boolean OR Operator. If any of the two operands is non-zero, then condition becomes true.	(A \|\| B) is true.
not	Called Boolean NOT Operator. Use to reverses the logical state of its operand. If a condition is true then Logical NOT operator will make false.	not (A && B) is true.

Bitwise Operators

Bitwise operators work on bits and perform bit-by-bit operation. The truth tables for &&& (bitwise AND), ||| (bitwise OR), and ^^^ (bitwise exclusive OR) are as follows −

Show Example

p	q	p &&& q	p \|\|\| q	p ^^^ q
0	0	0	0	0
0	1	0	1	1
1	1	1	1	0
1	0	0	1	1

Assume if A = 60; and B = 13; now in binary format they will be as follows −

A = 0011 1100

B = 0000 1101

A&&&B = 0000 1100

A|||B = 0011 1101

A^^^B = 0011 0001

~~~A = 1100 0011

The Bitwise operators supported by F# language are listed in the following table. Assume variable A holds 60 and variable B holds 13, then −

Operator	Description	Example
&&&	Binary AND Operator copies a bit to the result if it exists in both operands.	(A &&& B) will give 12, which is 0000 1100
\|\|\|	Binary OR Operator copies a bit if it exists in either operand.	(A \|\|\| B) will give 61, which is 0011 1101
^^^	Binary XOR Operator copies the bit if it is set in one operand but not both.	(A ^^^ B) will give 49, which is 0011 0001
~~~	Binary Ones Complement Operator is unary and has the effect of 'flipping' bits.	(~~~A) will give -61, which is 1100 0011 in 2's complement form.
<<<	Binary Left Shift Operator. The left operands value is moved left by the number of bits specified by the right operand.	A <<< 2 will give 240 which is 1111 0000
>>>	Binary Right Shift Operator. The left operands value is moved right by the number of bits specified by the right operand.	A >>> 2 will give 15 which is 0000 1111

Operators Precedence

The following table shows the order of precedence of operators and other expression keywords in the F# language, from lowest precedence to the highest precedence.

Show Example

Operator	Associativity
as	Right
when	Right
\| (pipe)	Left
;	Right
let	Non associative
function, fun, match, try	Non associative
if	Non associative
→	Right
:=	Right
,	Non associative
or, \|\|	Left
&, &&	Left
< op, >op, =, \|op, &op	Left
&&& , \|\|\|, ^^^, ~~~, <<<, >>>	Left
^ op	Right
::	Right
:?>, :?	Non associative
- op, +op, (binary)	Left
* op, /op, %op	Left
** op	Right
f x (function application)	Left
\| (pattern match)	Right
prefix operators (+op, -op, %, %%, &, &&, !op, ~op)	Left
.	Left
f(x)	Left
f<types>	Left

Decision making structures require that the programmer specify one or more conditions to be evaluated or tested by the program. It should be along with a statement or statements to be executed if the condition is determined to be true, and optionally, other statements to be executed if the condition is determined to be false.

Following is the general form of a typical decision making structure found in most of the programming languages −

F# programming language provides the following types of decision making statements.

Statement	Description
if /then statement	An if/then statement consists of a Boolean expression followed by one or more statements.
if/then/ else statement	An if/then statement can be followed by an optional else statement, which executes when the Boolean expression is false.
if/then/elif/else statement	An if/then/elif/else statement allows you to have multiple else branches.
nested if statements	You can use one if or else if statement inside another if or else if statement(s).

Programming languages provide various control structures that allow for more complicated execution paths.

A loop statement allows us to execute a statement or group of statements multiple times and following is the general form of a loop statement in most of the programming languages −

F# provides the following types of loops to handle the looping requirements.

Loop Type	Description
for… to and for… downto expressions	The for...to expression is used to iterate in a loop over a range of values of a loop variable. The for… downto expression reduces the value of loop variable.
for … in expression	This form of for loop is used to iterate over collections of items i.e., loops over collections and sequences
While…do loop	Repeats a statement or group of statements while a given condition is true. It tests the condition before executing the loop body.
nested loops	You can use one or more loop inside any other for or while loop.

In F#, functions work like data types. You can declare and use a function in the same way like any other variable.

Since functions can be used like any other variables, you can −

Create a function, with a name and associate that name with a type.
Assign it a value.
Perform some calculation on that value.
Pass it as a parameter to another function or sub-routine.
Return a function as the result of another function.

Defining a Function

Functions are defined by using the let keyword. A function definition has the following syntax −

let [inline] function-name parameter-list [ : return-type ]
= function-body

Where,

function-name is an identifier that represents the function.
parameter-list gives the list of parameters separated by spaces. You can also specify an explicit type for each parameter and if not specified compiler tends to deduce it from the function body (like variables).
function-body consists of an expression, or a compound expression consisting of a number of expressions. The final expression in the function body is the return value.
return-type is a colon followed by a type and is optional. If the return type is not specified, then the compiler determines it from the final expression in the function body.

Parameters of a Function

You list the names of parameters right after the function name. You can specify the type of a parameter. The type of the parameter should follow the name of the parameter separated by a colon.

If no parameter type is specified, it is inferred by the compiler.

For example −

let doubleIt (x : int) = 2 * x

Calling a Function

A function is called by specifying the function name followed by a space and then any arguments separated by spaces.

For example −

let vol = cylinderVolume 3.0 5.0

The following programs illustrate the concepts.

Example 1

The following program calculates the volume of a cylinder when the radius and length are given as parameters

// the function calculates the volume of
// a cylinder with radius and length as parameters

let cylinderVolume radius length : float =

   // function body
   let pi = 3.14159
   length * pi * radius * radius

let vol = cylinderVolume 3.0 5.0
printfn " Volume: %g " vol

When you compile and execute the program, it yields the following output −

Volume: 141.372

Example 2

The following program returns the larger value of two given parameters −

// the function returns the larger value between two
// arguments

let max num1 num2 : int32 =
   // function body
   if(num1>num2)then
      num1
   else
      num2

let res = max 39 52
printfn " Max Value: %d " res

When you compile and execute the program, it yields the following output −

Max Value: 52

Example 3

let doubleIt (x : int) = 2 * x
printfn "Double 19: %d" ( doubleIt(19))

When you compile and execute the program, it yields the following output −

Double 19: 38

Recursive Functions

Recursive functions are functions that call themselves.

You define a recursive using the let rec keyword combination.

Syntax for defining a recursive function is −

//Recursive function definition
let rec function-name parameter-list = recursive-function-body

For example −

let rec fib n = if n < 2 then 1 else fib (n - 1) + fib (n - 2)

Example 1

The following program returns Fibonacci 1 to 10 −

let rec fib n = if n < 2 then 1 else fib (n - 1) + fib (n - 2)
for i = 1 to 10 do
   printfn "Fibonacci %d: %d" i (fib i)

When you compile and execute the program, it yields the following output −

Fibonacci 1: 1
Fibonacci 2: 2
Fibonacci 3: 3
Fibonacci 4: 5
Fibonacci 5: 8
Fibonacci 6: 13
Fibonacci 7: 21
Fibonacci 8: 34
Fibonacci 9: 55
Fibonacci 10: 89

Example 2

The following program returns factorial 8 −

open System
let rec fact x =
   if x < 1 then 1
   else x * fact (x - 1)
Console.WriteLine(fact 8)

When you compile and execute the program, it yields the following output −

Arrow Notations in F#

F# reports about data type in functions and values, using a chained arrow notation. Let us take an example of a function that takes one int input, and returns a string. In arrow notation, it is written as −

int -> string

Data types are read from left to right.

Let us take another hypothetical function that takes two int data inputs and returns a string.

let mydivfunction x y = (x / y).ToString();;

F# reports the data type using chained arrow notation as −

val mydivfunction : x:int -> y:int -> string

The return type is represented by the rightmost data type in chained arrow notation.

Some more examples −

Notation	Meaning
float → float → float	The function takes two float inputs, returns another float.
int → string → float	The function takes an int and a string input, returns a float.

Lambda Expressions

A lambda expression is an unnamed function.

Let us take an example of two functions −

let applyFunction ( f: int -> int -> int) x y = f x y
let mul x y = x * y
let res = applyFunction mul 5 7
printfn "%d" res

When you compile and execute the program, it yields the following output −

Now in the above example, if instead of defining the function mul, we could have used lambda expressions as −

let applyFunction ( f: int -> int -> int) x y = f x y
let res = applyFunction (fun x y -> x * y ) 5 7
printfn "%d" res

When you compile and execute the program, it yields the following output −

Function Composition and Pipelining

In F#, one function can be composed from other functions.

The following example shows the composition of a function named f, from two functions function1 and function2 −

let function1 x = x + 1
let function2 x = x * 5

let f = function1 >> function2
let res = f 10
printfn "%d" res

When you compile and execute the program, it yields the following output −

F# also provides a feature called pipelining of functions. Pipelining allows function calls to be chained together as successive operations.

The following example shows that −

let function1 x = x + 1
let function2 x = x * 5

let res = 10 |> function1 |> function2
printfn "%d" res

When you compile and execute the program, it yields the following output −

In F#, the string type represents immutable text as a sequence of Unicode characters.

String Literals

String literals are delimited by the quotation mark (") character.

Some special characters are there for special uses like newline, tab, etc. They are encoded using backslash (\) character. The backslash character and the related character make the escape sequence. The following table shows the escape sequence supported by F#.

Character	Escape sequence
Backspace	\b
Newline	\n
Carriage return	\r
Tab	\t
Backslash	\\
Quotation mark	\"
Apostrophe	\'
Unicode character	\uXXXX or \UXXXXXXXX (where X indicates a hexadecimal digit)

Ways of lgnoring the Escape Sequence

The following two ways makes the compiler ignore the escape sequence −

Using the @ symbol.
Enclosing the string in triple quotes.

When a string literal is preceded by the @ symbol, it is called a verbatim string. In that way, all escape sequences in the string are ignored, except that two quotation mark characters are interpreted as one quotation mark character.

When a string is enclosed by triple quotes, then also all escape sequences are ignored, including double quotation mark characters.

Example

The following example demonstrates this technique showing how to work with XML or other structures that include embedded quotation marks −

// Using a verbatim string
let xmldata = @"<book author=""Lewis, C.S"" title=""Narnia"">"
printfn "%s" xmldata

When you compile and execute the program, it yields the following output −

<book author="Lewis, C.S" title="Narnia">

Basic Operators on Strings

The following table shows the basic operations on strings −

Value	Description
collect : (char → string) → string → string	Creates a new string whose characters are the results of applying a specified function to each of the characters of the input string and concatenating the resulting strings.
concat : string → seq<string> → string	Returns a new string made by concatenating the given strings with a separator.
exists : (char → bool) → string → bool	Tests if any character of the string satisfies the given predicate.
forall : (char → bool) → string → bool	Tests if all characters in the string satisfy the given predicate.
init : int → (int → string) → string	Creates a new string whose characters are the results of applying a specified function to each index and concatenating the resulting strings.
iter : (char → unit) → string → unit	Applies a specified function to each character in the string.
iteri : (int → char → unit) → string → unit	Applies a specified function to the index of each character in the string and the character itself.
length : string → int	Returns the length of the string.
map : (char → char) → string → string	Creates a new string whose characters are the results of applying a specified function to each of the characters of the input string.
mapi : (int → char → char) → string → string	Creates a new string whose characters are the results of applying a specified function to each character and index of the input string.
replicate : int → string → string	Returns a string by concatenating a specified number of instances of a string.

The following examples demonstrate the uses of some of the above functionalities −

Example 1

The String.collect function builds a new string whose characters are the results of applying a specified function to each of the characters of the input string and concatenating the resulting strings.

let collectTesting inputS =
   String.collect (fun c -> sprintf "%c " c) inputS
printfn "%s" (collectTesting "Happy New Year!")

When you compile and execute the program, it yields the following output −

H a p p y N e w Y e a r !

Example 2

The String.concat function concatenates a given sequence of strings with a separator and returns a new string.

let strings = [ "Tutorials Point"; "Coding Ground"; "Absolute Classes" ]
let ourProducts = String.concat "\n" strings
printfn "%s" ourProducts

When you compile and execute the program, it yields the following output −

Tutorials Point
Coding Ground
Absolute Classes

Example 3

The String.replicate method returns a string by concatenating a specified number of instances of a string.

printfn "%s" <| String.replicate 10 "*! "

When you compile and execute the program, it yields the following output −

*! *! *! *! *! *! *! *! *! *!

The option type in F# is used in calculations when there may or may not exist a value for a variable or function. Option types are used for representing optional values in calculations. They can have two possible values − Some(x) or None.

For example, a function performing a division will return a value in normal situation, but will throw exceptions in case of a zero denominator. Using options here will help to indicate whether the function has succeeded or failed.

An option has an underlying type and can hold a value of that type, or it might not have a value.

Using Options

Let us take the example of division function. The following program explains this −

Let us write a function div, and send two arguments to it 20 and 5 −

let div x y = x / y
let res = div 20 5
printfn "Result: %d" res

When you compile and execute the program, it yields the following output −

Result: 4

If the second argument is zero, then the program throws an exception −

let div x y = x / y
let res = div 20 0
printfn "Result: %d" res

When you compile and execute the program, it yields the following output −

Unhandled Exception:
System.DivideByZeroException: Division by zero

In such cases, we can use option types to return Some (value) when the operation is successful or None if the operation fails.

The following example demonstrates the use of options −

Example

let div x y =
   match y with
   | 0 -> None
   | _ -> Some(x/y)

let res : int option = div 20 4
printfn "Result: %A " res

When you compile and execute the program, it yields the following output −

Result: Some 5

Option Properties and Methods

The option type supports the following properties and methods −

Property or method	Type	Description
None	'T option	A static property that enables you to create an option value that has the None value.
IsNone	bool	Returns true if the option has the None value.
IsSome	bool	Returns true if the option has a value that is not None.
Some	'T option	A static member that creates an option that has a value that is not None.
Value	'T	Returns the underlying value, or throws a NullReferenceException if the value is None.

Example 1

let checkPositive (a : int) =
   if a > 0 then
      Some(a)
   else
      None

let res : int option = checkPositive(-31)
printfn "Result: %A " res

When you compile and execute the program, it yields the following output −

Result: <null>

Example 2

let div x y =
   match y with
   | 0 -> None
   | _ -> Some(x/y)

let res : int option = div 20 4
printfn "Result: %A " res
printfn "Result: %A " res.Value

When you compile and execute the program, it yields the following output −

Result: Some 5
Result: 5

Example 3

let isHundred = function
   | Some(100) -> true
   | Some(_) | None -> false

printfn "%A" (isHundred (Some(45)))
printfn "%A" (isHundred (Some(100)))
printfn "%A" (isHundred None)

When you compile and execute the program, it yields the following output −

false
true
false

SEBUAH tupleadalah kumpulan nilai yang dipisahkan koma. Ini digunakan untuk membuat struktur data ad hoc, yang mengelompokkan nilai terkait.

Misalnya, ("Zara Ali", "Hyderabad", 10) adalah 3-tupel dengan dua nilai string dan nilai int, memiliki tipe (string * string * int).

Tupel bisa berpasangan, tiga kali lipat, dan seterusnya, dengan tipe yang sama atau berbeda.

Beberapa contoh disediakan di sini -

// Tuple of two integers.
( 4, 5 )

// Triple of strings.
( "one", "two", "three" )

// Tuple of unknown types.
( a, b )

// Tuple that has mixed types.
( "Absolute Classes", 1, 2.0 )

// Tuple of integer expressions.
( a * 4, b + 7)

Contoh

Program ini memiliki fungsi yang mengambil tupel dari empat nilai float dan mengembalikan rata-rata -

let averageFour (a, b, c, d) =
   let sum = a + b + c + d
   sum / 4.0

let avg:float = averageFour (4.0, 5.1, 8.0, 12.0)
printfn "Avg of four numbers: %f" avg

Ketika Anda mengkompilasi dan menjalankan program, itu menghasilkan output berikut -

Avg of four numbers: 7.275000

Mengakses Anggota Tuple Perorangan

Anggota individu tupel dapat dinilai dan dicetak menggunakan pencocokan pola.

Contoh berikut menggambarkan konsep -

Contoh

let display tuple1 =
   match tuple1 with
   | (a, b, c) -> printfn "Detail Info: %A %A %A" a b c

display ("Zara Ali", "Hyderabad", 10 )

Ketika Anda mengkompilasi dan menjalankan program, itu menghasilkan output berikut -

Detail Info: "Zara Ali" "Hyderabad" 10

F # memiliki dua fungsi bawaan, fst dan snd, yang mengembalikan item pertama dan kedua dalam 2-tupel.

Contoh berikut menggambarkan konsep -

Contoh

printfn "First member: %A" (fst(23, 30))
printfn "Second member: %A" (snd(23, 30))

printfn "First member: %A" (fst("Hello", "World!"))
printfn "Second member: %A" (snd("Hello", "World!"))

let nameTuple = ("Zara", "Ali")

printfn "First Name: %A" (fst nameTuple)
printfn "Second Name: %A" (snd nameTuple)

Ketika Anda mengkompilasi dan menjalankan program, itu menghasilkan output berikut -

First member: 23
Second member: 30
First member: "Hello"
Second member: "World!"
First Name: "Zara"
Second Name: "Ali"

SEBUAH recordmirip dengan tupel, namun berisi bidang bernama. Sebagai contoh,

type website =
   { title : string;
      url : string }

Mendefinisikan Record

Record didefinisikan sebagai tipe yang menggunakan type kata kunci, dan bidang rekaman ditentukan sebagai daftar yang dipisahkan titik koma.

Sintaks untuk mendefinisikan record adalah -

type recordName =
   { [ fieldName : dataType ] + }

Membuat Record

Anda dapat membuat rekaman dengan menentukan bidang rekaman. Misalnya, mari kita buat rekaman situs web bernama beranda -

let homepage = { Title = "TutorialsPoint"; Url = "www.tutorialspoint.com" }

Contoh berikut akan menjelaskan konsep -

Contoh 1

Program ini mendefinisikan tipe record bernama website. Kemudian membuat beberapa catatan dari jenis situs web dan mencetak catatan tersebut.

(* defining a record type named website *)
type website =
   { Title : string;
      Url : string }

(* creating some records *)
let homepage = { Title = "TutorialsPoint"; Url = "www.tutorialspoint.com" }
let cpage = { Title = "Learn C"; Url = "www.tutorialspoint.com/cprogramming/index.htm" }
let fsharppage = { Title = "Learn F#"; Url = "www.tutorialspoint.com/fsharp/index.htm" }
let csharppage = { Title = "Learn C#"; Url = "www.tutorialspoint.com/csharp/index.htm" }

(*printing records *)
(printfn "Home Page: Title: %A \n \t URL: %A") homepage.Title homepage.Url
(printfn "C Page: Title: %A \n \t URL: %A") cpage.Title cpage.Url
(printfn "F# Page: Title: %A \n \t URL: %A") fsharppage.Title fsharppage.Url
(printfn "C# Page: Title: %A \n \t URL: %A") csharppage.Title csharppage.Url

Ketika Anda mengkompilasi dan menjalankan program, itu menghasilkan output berikut -

Home Page: Title: "TutorialsPoint"
       URL: "www.tutorialspoint.com"
C Page: Title: "Learn C"
      URL: "www.tutorialspoint.com/cprogramming/index.htm"
F# Page: Title: "Learn F#"
      URL: "www.tutorialspoint.com/fsharp/index.htm"
C# Page: Title: "Learn C#"
      URL: "www.tutorialspoint.com/csharp/index.htm"

Contoh 2

type student =
   { Name : string;
      ID : int;
      RegistrationText : string;
      IsRegistered : bool }

let getStudent name id =
   { Name = name; ID = id; RegistrationText = null; IsRegistered = false }

let registerStudent st =
   { st with
      RegistrationText = "Registered";
      IsRegistered = true }

let printStudent msg st =
   printfn "%s: %A" msg st

let main() =
   let preRegisteredStudent = getStudent "Zara" 10
   let postRegisteredStudent = registerStudent preRegisteredStudent

   printStudent "Before Registration: " preRegisteredStudent
   printStudent "After Registration: " postRegisteredStudent

main()

Ketika Anda mengkompilasi dan menjalankan program, itu menghasilkan output berikut -

Before Registration: : {Name = "Zara";
   ID = 10;
   RegistrationText = null;
   IsRegistered = false;}
After Registration: : {Name = "Zara";
   ID = 10;
   RegistrationText = "Registered";
   IsRegistered = true;}

Dalam F #, list adalah rangkaian elemen yang teratur dan tidak dapat diubah dari tipe yang sama. Ini sampai batas tertentu setara dengan struktur data daftar tertaut.

Modul F #, Microsoft.FSharp.Collections.List,memiliki operasi umum pada daftar. Namun F # mengimpor modul ini secara otomatis dan membuatnya dapat diakses oleh setiap aplikasi F #.

Membuat dan Memulai Daftar

Berikut adalah berbagai cara membuat daftar -

Menggunakan daftar literals.
Menggunakan cons (: :) operator.
Menggunakan List.init metode modul Daftar.
Menggunakan beberapa syntactic constructs dipanggil List Comprehensions.

Daftar Literal

Dalam metode ini, Anda cukup menentukan urutan nilai yang dipisahkan titik koma dalam tanda kurung siku. Misalnya -

let list1 = [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]

Kontra (: :) Operator

Dengan metode ini, Anda dapat menambahkan beberapa nilai dengan prepending atau cons-ingke daftar yang ada menggunakan :: operator. Misalnya -

let list2 = 1::2::3::4::5::6::7::8::9::10::[];;

[] menunjukkan daftar kosong.

Daftar Metode init

Metode List.init dari modul List sering digunakan untuk membuat daftar. Metode ini memiliki tipe -

val init : int -> (int -> 'T) -> 'T list

Argumen pertama adalah panjang daftar baru yang diinginkan, dan argumen kedua adalah fungsi penginisialisasi, yang menghasilkan item dalam daftar.

Sebagai contoh,

let list5 = List.init 5 (fun index -> (index, index * index, index * index * index))

Di sini, fungsi indeks menghasilkan daftar.

Daftar Pemahaman

Pemahaman daftar adalah konstruksi sintaksis khusus yang digunakan untuk menghasilkan daftar.

Sintaks pemahaman daftar F # hadir dalam dua bentuk - rentang dan generator.

Rentang memiliki konstruksi - [start .. end] dan [start .. step .. end]

Sebagai contoh,

let list3 = [1 .. 10]

Generator memiliki konstruksi - [untuk x dalam koleksi do ... yield expr]

Sebagai contoh,

let list6 = [ for a in 1 .. 10 do yield (a * a) ]

Sebagai yield kata kunci mendorong satu nilai ke dalam daftar, kata kunci, yield!, mendorong kumpulan nilai ke dalam daftar.

Fungsi berikut menunjukkan metode di atas -

Contoh

(* using list literals *)
let list1 = [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]
printfn "The list: %A" list1

(*using cons operator *)
let list2 = 1 :: 2 :: 3 :: []
printfn "The list: %A" list2

(* using range constructs*)
let list3 = [1 .. 10]
printfn "The list: %A" list3

(* using range constructs *)
let list4 = ['a' .. 'm']
printfn "The list: %A" list4

(* using init method *)
let list5 = List.init 5 (fun index -> (index, index * index, index * index * index))
printfn "The list: %A" list5

(* using yield operator *)
let list6 = [ for a in 1 .. 10 do yield (a * a) ]
printfn "The list: %A" list6

(* using yield operator *)
let list7 = [ for a in 1 .. 100 do if a % 3 = 0 && a % 5 = 0 then yield a]
printfn "The list: %A" list7

(* using yield! operator *)
let list8 = [for a in 1 .. 3 do yield! [ a .. a + 3 ] ]
printfn "The list: %A" list8

Ketika Anda mengkompilasi dan menjalankan program, itu menghasilkan output berikut -

The list: [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]
The list: [1; 2; 3]
The list: [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]
The list: ['a'; 'b'; 'c'; 'd'; 'e'; 'f'; 'g'; 'h'; 'i'; 'j'; 'k'; 'l'; 'm']
The list: [(0, 0, 0); (1, 1, 1); (2, 4, 8); (3, 9, 27); (4, 16, 64)]
The list: [1; 4; 9; 16; 25; 36; 49; 64; 81; 100]
The list: [15; 30; 45; 60; 75; 90]
The list: [1; 2; 3; 4; 2; 3; 4; 5; 3; 4; 5; 6]

Properti Tipe Data Daftar

Tabel berikut menunjukkan berbagai properti tipe data daftar -

Properti	Tipe	Deskripsi
Kepala	'T	Elemen pertama.
Kosong	Daftar 'T	Properti statis yang mengembalikan daftar kosong dari tipe yang sesuai.
Kosong	bool	true jika daftar tidak memiliki elemen.
Barang	'T	Elemen pada indeks yang ditentukan (berbasis nol).
Panjangnya	int	Jumlah elemen.
Ekor	Daftar 'T	Daftar tanpa elemen pertama.

Contoh berikut menunjukkan penggunaan properti ini -

Contoh

let list1 = [ 2; 4; 6; 8; 10; 12; 14; 16 ]

// Use of Properties
printfn "list1.IsEmpty is %b" (list1.IsEmpty)
printfn "list1.Length is %d" (list1.Length)
printfn "list1.Head is %d" (list1.Head)
printfn "list1.Tail.Head is %d" (list1.Tail.Head)
printfn "list1.Tail.Tail.Head is %d" (list1.Tail.Tail.Head)
printfn "list1.Item(1) is %d" (list1.Item(1))

Ketika Anda mengkompilasi dan menjalankan program, itu menghasilkan output berikut -

list1.IsEmpty is false
list1.Length is 8
list1.Head is 2
list1.Tail.Head is 4
list1.Tail.Tail.Head is 6
list1.Item(1) is 4

Operator Dasar dalam Daftar

Tabel berikut menunjukkan operasi dasar pada tipe data daftar -

Nilai	Deskripsi
tambahkan: 'Daftar T →' Daftar T → 'Daftar T	Mengembalikan daftar baru yang berisi elemen dari daftar pertama diikuti dengan elemen dari daftar kedua.
rata-rata: 'Daftar T → ^ T	Mengembalikan rata-rata elemen dalam daftar.
averageBy: ('T → ^ U) →' T list → ^ U	Mengembalikan rata-rata elemen yang dihasilkan dengan menerapkan fungsi ke setiap elemen daftar.
pilih: ('T →' U option) → 'T list →' U list	Menerapkan fungsi yang diberikan ke setiap elemen daftar. Mengembalikan daftar yang terdiri dari hasil untuk setiap elemen tempat fungsi kembaliSome.
kumpulkan: ('T →' daftar U) → 'Daftar T →' Daftar U.	Untuk setiap elemen daftar, terapkan fungsi yang diberikan. Menggabungkan semua hasil dan mengembalikan daftar gabungan.
concat: seq <'T list> →' T daftar	Mengembalikan daftar baru yang berisi elemen dari setiap daftar secara berurutan.
kosong: 'Daftar T	Menampilkan daftar kosong dari tipe yang diberikan.
ada: ('T → bool) →' T list → bool	Menguji apakah ada elemen dalam daftar yang memenuhi predikat yang diberikan.
existing2: ('T1 →' T2 → bool) → 'T1 list →' T2 list → bool	Menguji apakah ada pasangan elemen yang sesuai dari daftar yang memenuhi predikat yang diberikan.
filter: ('T → bool) →' T list → 'T list	Mengembalikan koleksi baru yang hanya berisi elemen koleksi yang predikatnya dikembalikan true.
temukan: ('T → bool) →' T list → 'T	Mengembalikan elemen pertama yang dikembalikan fungsi yang diberikan true.
findIndex: ('T → bool) →' T list → int	Mengembalikan indeks elemen pertama dalam daftar yang memenuhi predikat yang diberikan.
fold: ('State →' T → 'State) →' State → 'T list →' State	Menerapkan fungsi ke setiap elemen koleksi, memasukkan argumen akumulator melalui komputasi. Fungsi ini mengambil argumen kedua, dan menerapkan fungsi ke argumen tersebut dan elemen pertama dari daftar. Kemudian, ia meneruskan hasil ini ke dalam fungsi bersama dengan elemen kedua, dan seterusnya. Akhirnya, ini mengembalikan hasil akhir. Jika fungsi masukan adalah f dan elemennya adalah i0 ... iN, maka fungsi ini menghitung f (... (fs i0) i1 ...) iN.
fold2: ('State →' T1 → 'T2 →' State) → 'State →' T1 list → 'T2 list →' State	Menerapkan fungsi ke elemen yang sesuai dari dua koleksi, memasukkan argumen akumulator melalui komputasi. Koleksi harus memiliki ukuran yang identik. Jika fungsi masukan adalah f dan elemennya adalah i0 ... iN dan j0 ... jN, maka fungsi ini menghitung f (... (fs i0 j0) ...) iN jN.
foldBack: ('T →' State → 'State) →' T list → 'State →' State	Menerapkan fungsi ke setiap elemen koleksi, memasukkan argumen akumulator melalui komputasi. Jika fungsi input isf dan elemennya adalah i0 ... iN maka hitung f i0 (... (f iN s)).
foldBack2: ('T1 →' T2 → 'State →' State) → 'T1 list →' T2 list → 'State →' State	Menerapkan fungsi ke elemen yang sesuai dari dua koleksi, memasukkan argumen akumulator melalui komputasi. Koleksi harus memiliki ukuran yang identik. Jika fungsi masukan adalah f dan elemennya adalah i0 ... iN dan j0 ... jN, maka fungsi ini menghitung f i0 j0 (... (f iN jN s)).
forall: ('T → bool) →' T list → bool	Menguji apakah semua elemen koleksi memenuhi predikat yang diberikan.
forall2: ('T1 →' T2 → bool) → 'T1 list →' T2 list → bool	Menguji apakah semua elemen yang sesuai dari koleksi memenuhi predikat berpasangan.
kepala: 'Daftar T →' T	Mengembalikan elemen pertama dari daftar.
init: int → (int → 'T) →' T daftar	Membuat daftar dengan memanggil generator yang diberikan pada setiap indeks.
isEmpty: 'T list → bool	Kembali true jika daftar tidak berisi elemen, false jika tidak.
iter: ('T → unit) →' T list → unit	Menerapkan fungsi yang diberikan ke setiap elemen koleksi.
iter2: ('T1 →' T2 → unit) → 'T1 list →' T2 list → unit	Menerapkan fungsi yang diberikan ke dua koleksi secara bersamaan. Koleksinya harus berukuran sama.
iteri: (int → 'T → unit) →' T list → unit	Menerapkan fungsi yang diberikan ke setiap elemen koleksi. Integer yang diteruskan ke fungsi tersebut menunjukkan indeks elemen.
iteri2: (int → 'T1 →' T2 → unit) → 'T1 list →' T2 list → unit	Menerapkan fungsi yang diberikan ke dua koleksi secara bersamaan. Koleksinya harus berukuran sama. Integer yang diteruskan ke fungsi tersebut menunjukkan indeks elemen.
panjang: 'T list → int	Menampilkan panjang daftar.
peta: ('T →' U) → 'T list →' U list	Membuat koleksi baru yang elemennya merupakan hasil penerapan fungsi yang diberikan ke setiap elemen koleksi.
map2: ('T1 →' T2 → 'U) →' T1 list → 'T2 list →' U list	Membuat koleksi baru yang elemennya merupakan hasil penerapan fungsi yang diberikan ke elemen yang sesuai dari dua koleksi secara berpasangan.
map3: ('T1 →' T2 → 'T3 →' U) → 'T1 list →' T2 list → 'T3 list →' U list	Membuat koleksi baru yang elemennya merupakan hasil penerapan fungsi yang diberikan ke elemen yang sesuai dari tiga koleksi secara bersamaan.
mapi: (int → 'T →' U) → 'T list →' U list	Membuat koleksi baru yang elemennya merupakan hasil penerapan fungsi yang diberikan ke setiap elemen koleksi. Indeks integer yang diteruskan ke fungsi menunjukkan indeks (dari 0) elemen yang sedang diubah.
mapi2: (int → 'T1 →' T2 → 'U) →' T1 list → 'T2 list →' U list	Seperti List.mapi, tetapi memetakan elemen yang sesuai dari dua daftar dengan panjang yang sama.
maks: 'Daftar T →' T	Mengembalikan yang terbesar dari semua elemen daftar, dibandingkan dengan menggunakan Operators.max.
maxBy: ('T →' U) → 'T list →' T	Mengembalikan yang terbesar dari semua elemen daftar, dibandingkan dengan menggunakan Operators.max pada hasil fungsi.
min: 'Daftar T →' T	Mengembalikan nilai terendah dari semua elemen daftar, dibandingkan dengan menggunakan Operators.min.
minBy: ('T →' U) → 'T list →' T	Mengembalikan nilai terendah dari semua elemen daftar, dibandingkan dengan menggunakan Operators.min pada hasil fungsi
nth: 'T list → int →' T	Mengindeks ke dalam daftar. Elemen pertama memiliki indeks 0.
ofArray: 'T [] →' T daftar	Membuat daftar dari larik yang diberikan.
ofSeq: seq <'T> →' T daftar	Membuat daftar baru dari objek yang dapat dihitung.
partisi: ('T → bool) →' T list * 'T list	Membagi koleksi menjadi dua koleksi, berisi elemen yang dikembalikan predikatnya true dan false masing-masing.
permute: (int → int) → 'T list →' T list	Mengembalikan daftar dengan semua elemen yang diizinkan sesuai dengan permutasi yang ditentukan.
pilih: ('T →' opsi U) → 'Daftar T →' U	Menerapkan fungsi yang diberikan ke elemen yang berurutan, mengembalikan hasil pertama di mana fungsi kembali Some untuk beberapa nilai.
mengurangi: ('T →' T → 'T) →' T list → 'T	Menerapkan fungsi ke setiap elemen koleksi, memasukkan argumen akumulator melalui komputasi. Fungsi ini menerapkan fungsi yang ditentukan ke dua elemen pertama dari daftar. Ia kemudian meneruskan hasil ini ke dalam fungsi bersama dengan elemen ketiga, dan seterusnya. Akhirnya, ini mengembalikan hasil akhir. Jika fungsi masukan adalah f dan elemennya adalah i0 ... iN, maka fungsi ini menghitung f (... (f i0 i1) i2 ...) iN.
reduceBack: ('T →' T → 'T) →' T list → 'T	Menerapkan fungsi ke setiap elemen koleksi, memasukkan argumen akumulator melalui komputasi. Jika fungsi masukan isf dan elemennya adalah i0 ... iN, maka fungsi ini menghitung f i0 (... (f iN-1 iN)).
replikasi: (int → 'T →' T list)	Membuat daftar dengan memanggil generator yang diberikan pada setiap indeks.
rev: 'Daftar T →' Daftar T.	Mengembalikan daftar baru dengan elemen dalam urutan terbalik.
scan: ('State →' T → 'State) →' State → 'T list →' State list	Menerapkan fungsi ke setiap elemen koleksi, memasukkan argumen akumulator melalui komputasi. Fungsi ini mengambil argumen kedua, dan menerapkan fungsi yang ditentukan padanya dan elemen pertama dari daftar. Kemudian, ia meneruskan hasil ini ke dalam fungsi bersama dengan elemen kedua dan seterusnya. Akhirnya, ini mengembalikan daftar hasil antara dan hasil akhir.
scanBack: ('T →' State → 'State) →' T list → 'State →' State list	Seperti foldBack, tetapi mengembalikan hasil antara dan akhir
urutkan: 'Daftar T →' Daftar T.	Mengurutkan daftar yang diberikan menggunakan Operators.compare.
sortBy: ('T →' Key) → 'T list →' T list	Mengurutkan daftar yang diberikan menggunakan kunci yang diberikan oleh proyeksi yang diberikan. Kunci dibandingkan menggunakan Operators.compare.
sortWith: ('T →' T → int) → 'T list →' T list	Mengurutkan daftar yang diberikan menggunakan fungsi perbandingan yang diberikan.
jumlah: ^ Daftar T → ^ T	Mengembalikan jumlah elemen dalam daftar.
sumBy: ('T → ^ U) →' T list → ^ U	Mengembalikan jumlah hasil yang dihasilkan dengan menerapkan fungsi ke setiap elemen daftar.
ekor: 'Daftar T →' Daftar T.	Mengembalikan daftar input tanpa elemen pertama.
toArray: 'T list →' T []	Membuat array dari daftar yang diberikan.
toSeq: 'T list → seq <' T>	Melihat daftar yang diberikan sebagai urutan.
tryFind: ('T → bool) →' T list → 'T pilihan	Mengembalikan elemen pertama yang dikembalikan fungsi yang diberikan true. KembaliNone jika tidak ada elemen seperti itu.
tryFindIndex: ('T → bool) →' T list → opsi int	Mengembalikan indeks elemen pertama dalam daftar yang memenuhi predikat yang diberikan. KembaliNone jika tidak ada elemen seperti itu.
tryPick: (opsi 'T →' U) → 'Daftar T →' Opsi U.	Menerapkan fungsi yang diberikan ke elemen yang berurutan, mengembalikan hasil pertama di mana fungsi kembali Someuntuk beberapa nilai. Jika tidak ada elemen seperti itu, kembalikanNone.
unzip: ('T1 ' T2) list → 'T1 list ' T2 list	Membagi daftar pasangan menjadi dua daftar.
unzip3: ('T1 ' T2 'T3) list →' T1 list * 'T2 list *' T3 list	Membagi daftar tiga kali lipat menjadi tiga daftar.
zip: 'T1 list →' T2 list → ('T1 *' T2) list	Menggabungkan dua daftar menjadi daftar pasangan. Kedua daftar harus memiliki panjang yang sama.
zip3: 'T1 list →' T2 list → 'T3 list → (' T1 * 'T2 *' T3) list	Menggabungkan tiga daftar menjadi daftar tiga kali lipat. Daftar harus memiliki panjang yang sama.

Contoh berikut menunjukkan penggunaan fungsi di atas -

Contoh 1

Program ini menunjukkan pembalikan daftar secara rekursif -

let list1 = [ 2; 4; 6; 8; 10; 12; 14; 16 ]
printfn "The original list: %A" list1

let reverse lt =
   let rec loop acc = function
      | [] -> acc
      | hd :: tl -> loop (hd :: acc) tl
   loop [] lt

printfn "The reversed list: %A" (reverse list1)

Ketika Anda mengkompilasi dan menjalankan program, itu menghasilkan output berikut -

The original list: [2; 4; 6; 8; 10; 12; 14; 16]
The reversed list: [16; 14; 12; 10; 8; 6; 4; 2]

Namun, Anda dapat menggunakan rev fungsi modul untuk tujuan yang sama -

let list1 = [ 2; 4; 6; 8; 10; 12; 14; 16 ]
printfn "The original list: %A" list1
printfn "The reversed list: %A" (List.rev list1)

Ketika Anda mengkompilasi dan menjalankan program, itu menghasilkan output berikut -

The original list: [2; 4; 6; 8; 10; 12; 14; 16]
The reversed list: [16; 14; 12; 10; 8; 6; 4; 2]

Contoh 2

Program ini menunjukkan pemfilteran daftar menggunakan List.filter metode -

let list1 = [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]
printfn "The list: %A" list1
let list2 = list1 |> List.filter (fun x -> x % 2 = 0);;
printfn "The Filtered list: %A" list2

Ketika Anda mengkompilasi dan menjalankan program, itu menghasilkan output berikut -

The list: [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]
The Filtered list: [2; 4; 6; 8; 10]

Contoh 3

Itu List.map metode memetakan daftar dari satu jenis ke jenis lainnya -

let list1 = [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]
printfn "The list: %A" list1
let list2 = list1 |> List.map (fun x -> (x * x).ToString());;
printfn "The Mapped list: %A" list2

Ketika Anda mengkompilasi dan menjalankan program, itu menghasilkan output berikut -

The list: [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]
The Mapped list: ["1"; "4"; "9"; "16"; "25"; "36"; "49"; "64"; "81"; "100"]

Contoh 4

Itu List.append metode dan operator @ menambahkan satu daftar ke daftar lainnya -

let list1 = [1; 2; 3; 4; 5 ]
let list2 = [6; 7; 8; 9; 10]
let list3 = List.append list1 list2

printfn "The first list: %A" list1
printfn "The second list: %A" list2
printfn "The appened list: %A" list3

let lt1 = ['a'; 'b';'c' ]
let lt2 = ['e'; 'f';'g' ]
let lt3 = lt1 @ lt2

printfn "The first list: %A" lt1
printfn "The second list: %A" lt2
printfn "The appened list: %A" lt3

Ketika Anda mengkompilasi dan menjalankan program, itu menghasilkan output berikut -

The first list: [1; 2; 3; 4; 5]
The second list: [6; 7; 8; 9; 10]
The appened list: [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]
The first list: ['a'; 'b'; 'c']
The second list: ['e'; 'f'; 'g']
The appened list: ['a'; 'b'; 'c'; 'e'; 'f'; 'g']

Contoh 5

Itu List.sortmetode mengurutkan daftar. ItuList.sum metode memberikan jumlah elemen dalam daftar dan List.average metode memberikan rata-rata elemen dalam daftar -

let list1 = [9.0; 0.0; 2.0; -4.5; 11.2; 8.0; -10.0]
printfn "The list: %A" list1

let list2 = List.sort list1
printfn "The sorted list: %A" list2

let s = List.sum list1
let avg = List.average list1
printfn "The sum: %f" s
printfn "The average: %f" avg

Ketika Anda mengkompilasi dan menjalankan program, itu menghasilkan output berikut -

The list: [9.0; 0.0; 2.0; -4.5; 11.2; 8.0; -10.0]
The sorted list: [-10.0; -4.5; 0.0; 2.0; 8.0; 9.0; 11.2]
The sum: 15.700000
The average: 2.242857

Operasi "lipat" menerapkan fungsi ke setiap elemen dalam daftar, menggabungkan hasil fungsi dalam variabel akumulator, dan mengembalikan akumulator sebagai hasil dari operasi lipatan.

Contoh 6

Itu List.fold metode menerapkan fungsi ke setiap elemen dari kiri ke kanan, sementara List.foldBack menerapkan fungsi ke setiap elemen dari kanan ke kiri.

let sumList list = List.fold (fun acc elem -> acc + elem) 0 list
printfn "Sum of the elements of list %A is %d." [ 1 .. 10 ] (sumList [ 1 .. 10 ])

Ketika Anda mengkompilasi dan menjalankan program, itu menghasilkan output berikut -

Sum of the elements of list [1; 2; 3; 4; 5; 6; 7; 8; 9; 10] is 55.

Urutan, seperti daftar juga mewakili kumpulan nilai yang terurut. Namun, elemen dalam urutan atau ekspresi urutan dihitung bila diperlukan. Mereka tidak dihitung sekaligus, dan karena alasan ini mereka digunakan untuk merepresentasikan struktur data tak hingga.

Mendefinisikan Urutan

Urutan ditentukan menggunakan sintaks berikut -

seq { expr }

Sebagai contoh,

let seq1 = seq { 1 .. 10 }

Membuat Urutan dan Ekspresi Urutan

Mirip dengan daftar, Anda dapat membuat urutan menggunakan rentang dan pemahaman.

Ekspresi urutan adalah ekspresi yang dapat Anda tulis untuk membuat urutan. Ini bisa dilakukan -

Dengan menentukan rentangnya.
Dengan menentukan rentang dengan kenaikan atau penurunan.
Dengan menggunakan yield kata kunci untuk menghasilkan nilai yang menjadi bagian dari urutan.
Dengan menggunakan operator →.

Contoh berikut menunjukkan konsep -

Contoh 1

(* Sequences *)
let seq1 = seq { 1 .. 10 }

(* ascending order and increment*)
printfn "The Sequence: %A" seq1
let seq2 = seq { 1 .. 5 .. 50 }

(* descending order and decrement*)
printfn "The Sequence: %A" seq2
let seq3 = seq {50 .. -5 .. 0}
printfn "The Sequence: %A" seq3

(* using yield *)
let seq4 = seq { for a in 1 .. 10 do yield a, a*a, a*a*a }
printfn "The Sequence: %A" seq4

Ketika Anda mengkompilasi dan menjalankan program, itu menghasilkan output berikut -

The Sequence: seq [1; 2; 3; 4; ...]
The Sequence: seq [1; 6; 11; 16; ...]
The Sequence: seq [50; 45; 40; 35; ...]
The Sequence: seq [(1, 1, 1); (2, 4, 8); (3, 9, 27); (4, 16, 64); ...]

Contoh 2

Program berikut mencetak bilangan prima dari 1 hingga 50 -

(* Recursive isprime function. *)
let isprime n =
   let rec check i =
      i > n/2 || (n % i <> 0 && check (i + 1))
   check 2

let primeIn50 = seq { for n in 1..50 do if isprime n then yield n }
for x in primeIn50 do
   printfn "%d" x

Ketika Anda mengkompilasi dan menjalankan program, itu menghasilkan output berikut -

Operasi Dasar Urutan

Tabel berikut menunjukkan operasi dasar pada tipe data sequence -

Nilai	Deskripsi
tambahkan: seq <'T> → seq <' T> → seq <'T>	Membungkus dua pencacahan yang diberikan sebagai pencacahan gabungan tunggal.
rata-rata: seq <^ T> → ^ T	Mengembalikan rata-rata elemen dalam urutan.
averageBy: ('T → ^ U) → seq <' T> → ^ U	Mengembalikan rata-rata hasil yang dihasilkan dengan menerapkan fungsi ke setiap elemen urutan.
cache: seq <'T> → seq <' T>	Mengembalikan urutan yang sesuai dengan versi cache dari urutan input.
cast: IEnumerable → seq <'T>	Membungkus Sistem yang diketik secara longgar. Urutan koleksi sebagai urutan yang diketik.
pilih: (opsi 'T →' U) → seq <'T> → seq <' U>	Menerapkan fungsi yang diberikan ke setiap elemen daftar. Kembalikan daftar yang terdiri dari hasil untuk setiap elemen tempat fungsi kembaliSome.
kumpulkan: ('T →' Collection) → seq <'T> → seq <' U>	Menerapkan fungsi yang diberikan ke setiap elemen urutan dan menggabungkan semua hasil.
bandingkanWith: ('T →' T → int) → seq <'T> → seq <' T> → int	Membandingkan dua urutan menggunakan fungsi perbandingan yang diberikan, elemen demi elemen.
concat: seq <'Collection> → seq <' T>	Menggabungkan pencacahan-pencacahan yang diberikan sebagai pencacahan gabungan tunggal.
countBy: ('T →' Key) → seq <'T> → seq <' Key * int>	Menerapkan fungsi penghasil kunci ke setiap elemen urutan dan mengembalikan urutan yang menghasilkan kunci unik dan jumlah kemunculannya dalam urutan asli.
penundaan: (unit → seq <'T>) → seq <' T>	Mengembalikan urutan yang dibangun dari spesifikasi tertunda yang diberikan dari suatu urutan.
berbeda: seq <'T> → seq <' T>	Mengembalikan urutan yang tidak berisi entri duplikat sesuai dengan perbandingan umum dan kesamaan hash pada entri. Jika sebuah elemen terjadi beberapa kali dalam urutan maka kemunculan selanjutnya akan dibuang.
differentBy: ('T →' Key) → seq <'T> → seq <' T>	Mengembalikan urutan yang tidak berisi entri duplikat sesuai dengan perbandingan umum hash dan kesetaraan pada kunci yang dikembalikan oleh fungsi penghasil kunci yang diberikan. Jika sebuah elemen terjadi beberapa kali dalam urutan maka kemunculan selanjutnya akan dibuang.
kosong: seq <'T>	Membuat urutan kosong.
persisOne: seq <'T> →' T	Mengembalikan satu-satunya elemen dari urutan.
ada: ('T → bool) → seq <' T> → bool	Menguji apakah ada elemen dalam urutan yang memenuhi predikat yang diberikan.
existing2: ('T1 →' T2 → bool) → seq <'T1> → seq <' T2> → bool	Menguji apakah pasangan elemen yang sesuai dari urutan masukan memenuhi predikat yang diberikan.
filter: ('T → bool) → seq <' T> → seq <'T>	Mengembalikan koleksi baru yang hanya berisi elemen koleksi yang predikatnya dikembalikan true.
temukan: ('T → bool) → seq <' T> → 'T	Mengembalikan elemen pertama yang dikembalikan fungsi yang diberikan true.
findIndex: ('T → bool) → seq <' T> → int	Mengembalikan indeks elemen pertama yang mengembalikan fungsi yang diberikan true.
fold: ('State →' T → 'State) →' State → seq <'T> →' State	Menerapkan fungsi ke setiap elemen koleksi, memasukkan argumen akumulator melalui komputasi. Jika fungsi masukan adalah f dan elemennya adalah i0 ... iN, maka fungsi ini menghitung f (... (fs i0) ...) iN.
forall: ('T → bool) → seq <' T> → bool	Menguji apakah semua elemen urutan memenuhi predikat yang diberikan.
forall2: ('T1 →' T2 → bool) → seq <'T1> → seq <' T2> → bool	Menguji bahwa semua pasangan elemen yang diambil dari dua urutan memenuhi predikat yang diberikan. Jika satu urutan lebih pendek dari yang lain maka elemen yang tersisa dari urutan yang lebih panjang diabaikan.
groupBy: ('T →' Key) → seq <'T> → seq <' Key * seq <'T >>	Menerapkan fungsi penghasil kunci ke setiap elemen urutan dan menghasilkan urutan kunci unik. Setiap kunci unik juga berisi urutan semua elemen yang cocok dengan kunci ini.
kepala: seq <'T> →' T	Mengembalikan elemen pertama dari urutan.
init: int → (int → 'T) → seq <' T>	Menghasilkan urutan baru yang, ketika diiterasi, mengembalikan elemen berurutan dengan memanggil fungsi yang diberikan, hingga jumlah yang ditentukan. Hasil pemanggilan fungsi tidak disimpan, yaitu, fungsi diterapkan kembali seperlunya untuk meregenerasi elemen. Fungsi ini melewati indeks dari item yang sedang dibuat.
initInfinite: (int → 'T) → seq <' T>	Menghasilkan urutan baru yang, ketika diiterasi, akan mengembalikan elemen berurutan dengan memanggil fungsi yang diberikan. Hasil pemanggilan fungsi tidak disimpan, artinya, fungsi akan diterapkan kembali seperlunya untuk meregenerasi elemen. Fungsi ini melewati indeks dari item yang sedang dibuat.
isEmpty: seq <'T> → bool	Menguji apakah suatu urutan memiliki elemen apa pun.
iter: ('T → unit) → seq <' T> → unit	Menerapkan fungsi yang diberikan ke setiap elemen koleksi.
iter2: ('T1 →' T2 → unit) → seq <'T1> → seq <' T2> → unit	Menerapkan fungsi yang diberikan ke dua koleksi secara bersamaan. Jika satu urutan lebih pendek dari yang lain maka elemen yang tersisa dari urutan yang lebih panjang diabaikan.
iteri: (int → 'T → unit) → seq <' T> → unit	Menerapkan fungsi yang diberikan ke setiap elemen koleksi. Integer yang diteruskan ke fungsi tersebut menunjukkan indeks elemen.
terakhir: seq <'T> →' T	Mengembalikan elemen terakhir dari urutan.
length: seq <'T> → int	Mengembalikan panjang urutan.
peta: ('T →' U) → seq <'T> → seq <' U>	Membuat koleksi baru yang elemennya merupakan hasil penerapan fungsi yang diberikan ke setiap elemen koleksi. Fungsi yang diberikan akan diterapkan saat elemen diminta menggunakan metode MoveNext pada pencacah yang diambil dari objek.
map2: ('T1 →' T2 → 'U) → seq <' T1> → seq <'T2> → seq <' U>	Membuat koleksi baru yang elemennya merupakan hasil penerapan fungsi yang diberikan ke pasangan elemen yang sesuai dari dua urutan. Jika satu urutan masukan lebih pendek dari yang lain maka elemen yang tersisa dari urutan yang lebih panjang diabaikan.
mapi: (int → 'T →' U) → seq <'T> → seq <' U>	Membuat koleksi baru yang elemennya merupakan hasil penerapan fungsi yang diberikan ke setiap elemen koleksi. Indeks integer yang diteruskan ke fungsi menunjukkan indeks (dari 0) elemen yang sedang diubah.
maks: seq <'T> →' T	Mengembalikan yang terbesar dari semua elemen urutan, dibandingkan dengan menggunakan Operators.max.
maxBy: ('T →' U) → seq <'T> →' T	Mengembalikan elemen terbesar dari semua urutan, dibandingkan dengan menggunakan Operators.max pada hasil fungsi.
min: seq <'T> →' T	Mengembalikan nilai terendah dari semua elemen urutan, dibandingkan dengan menggunakan Operators.min.
minBy: ('T →' U) → seq <'T> →' T	Mengembalikan nilai terendah dari semua elemen urutan, dibandingkan dengan menggunakan Operators.min pada hasil fungsi.
n: int → seq <'T> →' T	Menghitung elemen ke - n dalam koleksi.
ofArray: 'T array → seq <' T>	Menampilkan larik yang diberikan sebagai urutan.
ofList: 'T list → seq <' T>	Melihat daftar yang diberikan sebagai urutan.
berpasangan: seq <'T> → seq <' T * 'T>	Mengembalikan urutan setiap elemen dalam urutan input dan pendahulunya, dengan pengecualian elemen pertama yang hanya dikembalikan sebagai pendahulu dari elemen kedua.
pilih: (opsi 'T →' U) → seq <'T> →' U	Menerapkan fungsi yang diberikan ke elemen yang berurutan, mengembalikan nilai pertama di mana fungsi tersebut mengembalikan a Some nilai.
readonly: seq <'T> → seq <' T>	Membuat objek urutan baru yang didelegasikan ke objek urutan tertentu. Ini memastikan urutan asli tidak dapat ditemukan kembali dan dimutasikan oleh tipe pemeran. Misalnya, jika diberikan sebuah array, urutan yang dikembalikan akan mengembalikan elemen-elemen dari array tersebut, tetapi Anda tidak dapat mentransmisikan objek urutan yang dikembalikan ke sebuah array.
mengurangi: ('T →' T → 'T) → seq <' T> → 'T	Menerapkan fungsi ke setiap elemen urutan, memasukkan argumen akumulator melalui komputasi. Mulailah dengan menerapkan fungsi ke dua elemen pertama. Kemudian masukkan hasil ini ke dalam fungsi bersama dengan elemen ketiga dan seterusnya. Kembalikan hasil akhirnya.
scan: ('State →' T → 'State) →' State → seq <'T> → seq <' State>	Seperti Seq.fold, tetapi menghitung sesuai permintaan dan mengembalikan urutan hasil perantara dan akhir.
singleton: 'T → seq <' T>	Mengembalikan urutan yang hanya menghasilkan satu item.
lewati: int → seq <'T> → seq <' T>	Mengembalikan urutan yang melewati sejumlah elemen tertentu dari urutan yang mendasari dan kemudian menghasilkan elemen yang tersisa dari urutan.
skipWhile: ('T → bool) → seq <' T> → seq <'T>	Mengembalikan urutan yang, ketika diulang, melewatkan elemen dari urutan yang mendasari sementara predikat yang diberikan kembali true, dan kemudian menghasilkan elemen yang tersisa dari urutan tersebut.
urutkan: seq <'T> → seq <' T>	Menghasilkan urutan yang diurutkan berdasarkan kunci.
sortBy: ('T →' Key) → seq <'T> → seq <' T>	Menerapkan fungsi penghasil kunci ke setiap elemen urutan dan menghasilkan urutan yang diurutkan berdasarkan kunci. Kunci-kunci tersebut dibandingkan menggunakan perbandingan umum seperti yang diterapkan oleh Operators.compare.
jumlah: seq <^ T> → ^ T	Mengembalikan jumlah elemen dalam urutan.
sumBy	Mengembalikan jumlah hasil yang dihasilkan dengan menerapkan fungsi ke setiap elemen urutan.
ambil: int → seq <'T> → seq <' T>	Mengembalikan elemen pertama dari urutan hingga jumlah tertentu.
takeWhile: ('T → bool) → seq <' T> → seq <'T>	Mengembalikan urutan yang, ketika diulang, menghasilkan elemen dari urutan yang mendasarinya sementara predikat yang diberikan kembali true, dan kemudian tidak mengembalikan elemen lagi.
toArray: seq <'T> →' T []	Membuat larik dari koleksi yang diberikan.
toList: seq <'T> →' T list	Membuat daftar dari koleksi yang diberikan.
truncate: int → seq <'T> → seq <' T>	Mengembalikan urutan yang ketika enumerasi mengembalikan tidak lebih dari jumlah elemen yang ditentukan.
tryFind: ('T → bool) → seq <' T> → 'T pilihan	Mengembalikan elemen pertama yang dikembalikan fungsi yang diberikan true, atau None jika tidak ada elemen seperti itu.
tryFindIndex: ('T → bool) → seq <' T> → opsi int	Mengembalikan indeks elemen pertama dalam urutan yang memenuhi predikat yang diberikan, atau None jika tidak ada elemen seperti itu.
tryPick: (opsi 'T →' U) → seq <'T> →' U opsi	Menerapkan fungsi yang diberikan ke elemen yang berurutan, mengembalikan nilai pertama di mana fungsi tersebut mengembalikan a Some nilai.
terungkap: ('State →' T * 'State option) →' State → seq <'T>	Mengembalikan urutan yang berisi elemen yang dihasilkan oleh komputasi yang diberikan.
dimana: ('T → bool) → seq <' T> → seq <'T>	Mengembalikan koleksi baru yang hanya berisi elemen koleksi yang predikatnya dikembalikan true. Sinonim dari Seq.filter.
berjendela: int → seq <'T> → seq <' T []>	Mengembalikan urutan yang menghasilkan jendela geser berisi elemen yang diambil dari urutan masukan. Setiap jendela dikembalikan sebagai larik baru.
zip: seq <'T1> → seq <' T2> → seq <'T1 *' T2>	Menggabungkan dua urutan menjadi daftar pasangan. Kedua urutan tidak perlu memiliki panjang yang sama - jika satu urutan habis, elemen yang tersisa di urutan lainnya diabaikan.
zip3: seq <'T1> → seq <' T2> → seq <'T3> → seq <' T1 * 'T2 *' T3>	Menggabungkan tiga urutan menjadi daftar tripel. Urutan tidak perlu memiliki panjang yang sama - ketika satu urutan habis, elemen yang tersisa di urutan lainnya diabaikan.

Contoh berikut menunjukkan penggunaan beberapa fungsi di atas -

Contoh 1

Program ini membuat urutan kosong dan mengisinya nanti -

(* Creating sequences *)
let emptySeq = Seq.empty
let seq1 = Seq.singleton 20

printfn"The singleton sequence:"
printfn "%A " seq1
printfn"The init sequence:"

let seq2 = Seq.init 5 (fun n -> n * 3)
Seq.iter (fun i -> printf "%d " i) seq2
printfn""

(* converting an array to sequence by using cast *)
printfn"The array sequence 1:"
let seq3 = [| 1 .. 10 |] :> seq<int>
Seq.iter (fun i -> printf "%d " i) seq3
printfn""

(* converting an array to sequence by using Seq.ofArray *)
printfn"The array sequence 2:"
let seq4 = [| 2..2.. 20 |] |> Seq.ofArray
Seq.iter (fun i -> printf "%d " i) seq4
printfn""

Ketika Anda mengkompilasi dan menjalankan program, itu menghasilkan output berikut -

The singleton sequence:
seq [20]
The init sequence:
0 3 6 9 12
The array sequence 1:
1 2 3 4 5 6 7 8 9 10
The array sequence 2:
2 4 6 8 10 12 14 16 18 20

Harap dicatat bahwa -

Metode Seq.empty membuat urutan kosong.
Metode Seq.singleton membuat urutan hanya dari satu elemen yang ditentukan.
Metode Seq.init membuat urutan elemen yang dibuat dengan menggunakan fungsi yang diberikan.
Metode Seq.ofArray dan Seq.ofList <'T> membuat urutan dari array dan daftar.
Metode Seq.iter memungkinkan iterasi melalui urutan.

Contoh 2

Metode Seq.unfold menghasilkan urutan dari fungsi komputasi yang mengambil status dan mengubahnya untuk menghasilkan setiap elemen berikutnya dalam urutan tersebut.

Fungsi berikut menghasilkan 20 bilangan asli pertama -

let seq1 = Seq.unfold (fun state -> if (state > 20) then None else Some(state, state + 1)) 0
printfn "The sequence seq1 contains numbers from 0 to 20."
for x in seq1 do printf "%d " x
printfn" "

Ketika Anda mengkompilasi dan menjalankan program, itu menghasilkan output berikut -

The sequence seq1 contains numbers from 0 to 20.
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

Contoh 3

Metode Seq.truncate membuat urutan dari urutan lain, tetapi membatasi urutan ke sejumlah elemen tertentu.

Metode Seq.take membuat urutan baru yang berisi sejumlah elemen tertentu dari awal urutan.

let mySeq = seq { for i in 1 .. 10 -> 3*i }
let truncatedSeq = Seq.truncate 5 mySeq
let takeSeq = Seq.take 5 mySeq

printfn"The original sequence"
Seq.iter (fun i -> printf "%d " i) mySeq
printfn""

printfn"The truncated sequence"
Seq.iter (fun i -> printf "%d " i) truncatedSeq
printfn""

printfn"The take sequence"
Seq.iter (fun i -> printf "%d " i) takeSeq
printfn""

Ketika Anda mengkompilasi dan menjalankan program, itu menghasilkan output berikut -

The original sequence
3 6 9 12 15 18 21 24 27 30
The truncated sequence
3 6 9 12 15
The take sequence
3 6 9 12 15

Himpunan di F # adalah struktur data yang bertindak sebagai kumpulan item tanpa mempertahankan urutan penyisipan item. Set tidak mengizinkan entri duplikat untuk dimasukkan ke dalam koleksi.

Membuat Set

Set dapat dibuat dengan cara berikut -

Dengan membuat satu set kosong menggunakan Set.empty dan menambahkan item menggunakan fungsi add.
Mengonversi urutan dan daftar menjadi kumpulan.

Program berikut mendemonstrasikan teknik -

(* creating sets *)
let set1 = Set.empty.Add(3).Add(5).Add(7). Add(9)
printfn"The new set: %A" set1

let weekdays = Set.ofList ["mon"; "tues"; "wed"; "thurs"; "fri"]
printfn "The list set: %A" weekdays

let set2 = Set.ofSeq [ 1 .. 2.. 10 ]
printfn "The sequence set: %A" set2

Ketika Anda mengkompilasi dan menjalankan program, itu menghasilkan output berikut -

The new set: set [3; 5; 7; 9]
The list set: set ["fri"; "mon"; "thurs"; "tues"; "wed"]
The sequence set: set [1; 3; 5; 7; 9]

Operasi Dasar di Set

Tabel berikut menunjukkan operasi dasar pada set -

Nilai	Deskripsi
tambahkan: 'T → Set <' T> → Set <'T>	Mengembalikan set baru dengan elemen yang ditambahkan ke set. Tidak ada pengecualian dimunculkan jika set sudah berisi elemen yang diberikan.
berisi: 'T → Set <' T> → bool	Dievaluasi ke true jika elemen yang diberikan ada di set yang diberikan.
hitungan: Setel <'T> → int	Mengembalikan jumlah elemen dalam set.
perbedaan: Set <'T> → Set <' T> → Set <'T>	Mengembalikan set baru dengan elemen dari set kedua dihapus dari yang pertama.
kosong: Setel <'T>	Himpunan kosong untuk tipe yang ditentukan.
ada: ('T → bool) → Set <' T> → bool	Menguji apakah ada elemen koleksi yang memenuhi predikat yang diberikan. Jika fungsi input adalah predikat dan elemennya adalah i0 ... iN, maka fungsi ini menghitung predikat i0 atau ... atau predikat iN.
filter: ('T → bool) → Set <' T> → Set <'T>	Mengembalikan koleksi baru yang hanya berisi elemen koleksi yang predikatnya dikembalikan true.
fold: ('State →' T → 'State) →' State → Set <'T> →' State	Menerapkan fungsi akumulasi yang diberikan ke semua elemen himpunan.
foldBack: ('T →' State → 'State) → Set <' T> → 'State →' State	Menerapkan fungsi akumulasi yang diberikan ke semua elemen himpunan.
forall: ('T → bool) → Set <' T> → bool	Menguji apakah semua elemen koleksi memenuhi predikat yang diberikan. Jika fungsi inputnya adalah p dan elemennya adalah i0 ... iN, maka fungsi ini menghitung p i0 && ... && p iN.
intersect: Setel <'T> → Set <' T> → Set <'T>	Menghitung perpotongan dua set.
intersectMany: seq <Set <'T >> → Set <' T>	Menghitung perpotongan urutan set. Urutan tidak boleh kosong.
isEmpty: Setel <'T> → bool	Kembali true jika set kosong.
isProperSubset: Set <'T> → Set <' T> → bool	Dievaluasi ke true jika semua elemen dari set pertama ada di set kedua, dan setidaknya satu elemen dari set kedua tidak ada di set pertama.
isProperSuperset: Setel <'T> → Set <' T> → bool	Dievaluasi ke true jika semua elemen dari himpunan kedua ada di set pertama, dan setidaknya satu elemen dari set pertama tidak ada di set kedua.
isSubset: Setel <'T> → Set <' T> → bool	Dievaluasi ke true jika semua elemen dari set pertama ada di set kedua.
isSuperset: Setel <'T> → Set <' T> → bool	Dievaluasi ke true jika semua elemen dari set kedua ada di set pertama.
iter: ('T → unit) → Set <' T> → unit	Menerapkan fungsi yang diberikan ke setiap elemen himpunan, dalam urutan sesuai dengan fungsi perbandingan.
peta: ('T →' U) → Set <'T> → Set <' U>	Mengembalikan koleksi baru yang berisi hasil penerapan fungsi yang diberikan ke setiap elemen set input.
maxElement: Setel <'T> →' T	Mengembalikan elemen tertinggi dalam himpunan sesuai dengan urutan yang digunakan untuk himpunan.
minElement: Setel <'T> →' T	Mengembalikan elemen terendah dalam himpunan sesuai dengan urutan yang digunakan untuk himpunan.
ofArray: 'T array → Set <' T>	Membuat set yang berisi elemen yang sama seperti array yang diberikan.
ofList: 'T list → Set <' T>	Membuat set yang berisi elemen yang sama seperti daftar yang diberikan.
ofSeq: seq <'T> → Set <' T>	Membuat koleksi baru dari objek enumerabel yang diberikan.
partisi: ('T → bool) → Set <' T> → Set <'T> * Set <' T>	Membagi set menjadi dua set yang berisi elemen yang predikatnya masing-masing mengembalikan benar dan salah.
hapus: 'T → Set <' T> → Set <'T>	Mengembalikan set baru dengan elemen yang diberikan dihapus. Tidak ada pengecualian dimunculkan jika set tidak berisi elemen yang diberikan.
singleton: 'T → Set <' T>	Set yang berisi elemen yang diberikan.
toArray: Setel larik <'T> →' T.	Membuat larik yang berisi elemen himpunan secara berurutan.
toList: Setel <'T> →' T list	Membuat daftar yang berisi elemen himpunan secara berurutan.
toSeq: Setel <'T> → seq <' T>	Mengembalikan tampilan terurut dari koleksi sebagai objek yang dapat dihitung.
union: Setel <'T> → Set <' T> → Set <'T>	Menghitung gabungan dari dua set.
unionMany: seq <Set <'T >> → Set <' T>	Menghitung penyatuan urutan set.

Contoh berikut menunjukkan penggunaan beberapa fungsi di atas -

Contoh

let a = Set.ofSeq [ 1 ..2.. 20 ]
let b = Set.ofSeq [ 1 ..3 .. 20 ]
let c = Set.intersect a b
let d = Set.union a b
let e = Set.difference a b

printfn "Set a: "
Set.iter (fun x -> printf "%O " x) a
printfn""

printfn "Set b: "
Set.iter (fun x -> printf "%O " x) b
printfn""

printfn "Set c = set intersect of a and b : "
Set.iter (fun x -> printf "%O " x) c
printfn""

printfn "Set d = set union of a and b : "
Set.iter (fun x -> printf "%O " x) d
printfn""

printfn "Set e = set difference of a and b : "
Set.iter (fun x -> printf "%O " x) e
printfn""

Ketika Anda mengkompilasi dan menjalankan program, itu menghasilkan output berikut -

Set a:
1 3 5 7 9 11 13 15 17 19
Set b:
1 4 7 10 13 16 19
Set c = set intersect of a and b :
1 7 13 19
Set d = set union of a and b :
1 3 4 5 7 9 10 11 13 15 16 17 19
Set e = set difference of a and b :
3 5 9 11 15 17

Di F #, peta adalah jenis himpunan khusus yang mengaitkan nilai dengan kunci. Peta dibuat dengan cara yang sama seperti set dibuat.

Membuat Peta

Peta dibuat dengan membuat peta kosong menggunakan Map.empty dan menambahkan item menggunakan fungsi Tambah. Contoh berikut menunjukkan ini -

Contoh

(* Create an empty Map *)
let students =
   Map.empty. (* Creating an empty Map *)
      Add("Zara Ali", "1501").
      Add("Rishita Gupta", "1502").
      Add("Robin Sahoo", "1503").
      Add("Gillian Megan", "1504");;
printfn "Map - students: %A" students

(* Convert a list to Map *)
let capitals =
   [ "Argentina", "Buenos Aires";
      "France ", "Paris";
      "Chili", "Santiago";
      "Malaysia", " Kuala Lumpur";
      "Switzerland", "Bern" ]
   |> Map.ofList;;
printfn "Map capitals : %A" capitals

Ketika Anda mengkompilasi dan menjalankan program, itu menghasilkan output berikut -

Map - students: map
[("Gillian Megan", "1504"); ("Rishita Gupta", "1502"); ("Robin Sahoo", "1503
");
("Zara Ali", "1501")]
Map capitals : map
[("Argentina", "Buenos Aires"); ("Chili", "Santiago"); ("France ", "Paris");
("Malaysia", " Kuala Lumpur"); ("Switzerland", "Bern")]

Anda dapat mengakses elemen individu di peta menggunakan kunci.

Contoh

(* Create an empty Map *)
let students =
   Map.empty. (* Creating an empty Map *)
      Add("Zara Ali", "1501").
      Add("Rishita Gupta", "1502").
      Add("Robin Sahoo", "1503").
      Add("Gillian Megan", "1504");;
printfn "Map - students: %A" students

(*Accessing an element using key *)
printfn "%A" students.["Zara Ali"]

Ketika Anda mengkompilasi dan menjalankan program, itu menghasilkan output berikut -

Map - students: map
[("Gillian Megan", "1504"); ("Rishita Gupta", "1502"); ("Robin Sahoo", "1503
");
("Zara Ali", "1501")]
"1501"

Operasi Dasar di Maps

Tambahkan nama modul

Tabel berikut menunjukkan operasi dasar pada peta -

Anggota	Deskripsi
Menambahkan	Mengembalikan peta baru dengan pengikatan yang ditambahkan ke peta yang diberikan.
ContainsKey	Menguji apakah suatu elemen ada dalam domain peta.
Menghitung	Jumlah binding di peta.
Kosong	Mengembalikan nilai true jika tidak ada binding di peta.
Barang	Cari elemen di peta. Menambah KeyNotFoundException jika tidak ada pengikatan di peta.
Menghapus	Menghapus elemen dari domain peta. Tidak ada pengecualian dimunculkan jika elemen tidak ada.
TryFind	Cari elemen di peta, mengembalikan a Some nilai jika elemen berada dalam domain peta dan None jika tidak.

Contoh berikut menunjukkan penggunaan beberapa fungsi di atas -

Contoh

(* Create an empty Map *)
let students =
   Map.empty. (* Creating an empty Map *)
      Add("Zara Ali", "1501").
      Add("Rishita Gupta", "1502").
      Add("Robin Sahoo", "1503").
      Add("Gillian Megan", "1504").
      Add("Shraddha Dubey", "1505").
      Add("Novonil Sarker", "1506").
      Add("Joan Paul", "1507");;
printfn "Map - students: %A" students
printfn "Map - number of students: %d" students.Count

(* finding the registration number of a student*)
let found = students.TryFind "Rishita Gupta"
match found with
| Some x -> printfn "Found %s." x
| None -> printfn "Did not find the specified value."

Ketika Anda mengkompilasi dan menjalankan program, itu menghasilkan output berikut -

Map - students: map
[("Gillian Megan", "1504"); ("Joan Paul", "1507"); ("Novonil Sarker", "1506"
);
("Rishita Gupta", "1502"); ("Robin Sahoo", "1503");
("Shraddha Dubey", "1505"); ("Zara Ali", "1501")]
Map - number of students: 7
Found 1502.

Serikat, atau serikat yang terdiskriminasi memungkinkan Anda membangun struktur data kompleks yang mewakili sekumpulan pilihan yang ditentukan dengan baik. Misalnya, Anda perlu membuat implementasi variabel pilihan , yang memiliki dua nilai ya dan tidak. Dengan menggunakan alat Serikat Pekerja, Anda dapat mendesain ini.

Sintaksis

Serikat pekerja yang terdiskriminasi ditentukan menggunakan sintaks berikut -

type type-name =
   | case-identifier1 [of [ fieldname1 : ] type1 [ * [ fieldname2 : ] 
type2 ...]
   | case-identifier2 [of [fieldname3 : ]type3 [ * [ fieldname4 : ]type4 ...]
...

Penerapan sederhana kami dari, pilihan, akan terlihat seperti berikut -

type choice =
   | Yes
   | No

Contoh berikut menggunakan pilihan tipe -

type choice =
   | Yes
   | No

let x = Yes (* creates an instance of choice *)
let y = No (* creates another instance of choice *)
let main() =
   printfn "x: %A" x
   printfn "y: %A" y
main()

Ketika Anda mengkompilasi dan menjalankan program, itu menghasilkan output berikut -

x: Yes
y: No

Contoh 1

Contoh berikut menunjukkan implementasi status tegangan yang menetapkan sedikit tinggi atau rendah -

type VoltageState =
   | High
   | Low

let toggleSwitch = function (* pattern matching input *)
   | High -> Low
   | Low -> High

let main() =
   let on = High
   let off = Low
   let change = toggleSwitch off

   printfn "Switch on state: %A" on
   printfn "Switch off state: %A" off
   printfn "Toggle off: %A" change
   printfn "Toggle the Changed state: %A" (toggleSwitch change)

main()

Ketika Anda mengkompilasi dan menjalankan program, itu menghasilkan output berikut -

Switch on state: High
Switch off state: Low
Toggle off: High
Toggle the Changed state: Low

Contoh 2

type Shape =
   // here we store the radius of a circle
   | Circle of float

   // here we store the side length.
   | Square of float

   // here we store the height and width.
   | Rectangle of float * float

let pi = 3.141592654

let area myShape =
   match myShape with
   | Circle radius -> pi * radius * radius
   | Square s -> s * s
   | Rectangle (h, w) -> h * w

let radius = 12.0
let myCircle = Circle(radius)
printfn "Area of circle with radius %g: %g" radius (area myCircle)

let side = 15.0
let mySquare = Square(side)
printfn "Area of square that has side %g: %g" side (area mySquare)

let height, width = 5.0, 8.0
let myRectangle = Rectangle(height, width)
printfn "Area of rectangle with height %g and width %g is %g" height width (area myRectangle)

Ketika Anda mengkompilasi dan menjalankan program, itu menghasilkan output berikut -

Area of circle with radius 12: 452.389
Area of square that has side 15: 225
Area of rectangle with height 5 and width 8 is 40

Variabel di F # adalah immutable,yang berarti sekali variabel terikat ke suatu nilai, itu tidak dapat diubah. Mereka sebenarnya dikompilasi sebagai properti hanya baca statis.

Contoh berikut menunjukkan hal ini.

Contoh

let x = 10
let y = 20
let z = x + y

printfn "x: %i" x
printfn "y: %i" y
printfn "z: %i" z

let x = 15
let y = 20
let z = x + y

printfn "x: %i" x
printfn "y: %i" y
printfn "z: %i" z

Ketika Anda mengkompilasi dan menjalankan program, itu menunjukkan pesan kesalahan berikut -

Duplicate definition of value 'x'
Duplicate definition of value 'Y'
Duplicate definition of value 'Z'

Variabel yang Dapat Diubah

Terkadang Anda perlu mengubah nilai yang disimpan dalam variabel. Untuk menentukan bahwa mungkin ada perubahan nilai variabel yang dideklarasikan dan ditugaskan di bagian program selanjutnya, F # menyediakanmutablekata kunci. Anda dapat mendeklarasikan dan menetapkan variabel yang dapat berubah menggunakan kata kunci ini, yang nilainya akan Anda ubah.

Itu mutable kata kunci memungkinkan Anda untuk mendeklarasikan dan menetapkan nilai dalam variabel yang bisa berubah.

Anda dapat menetapkan beberapa nilai awal ke variabel yang bisa berubah menggunakan letkata kunci. Namun, untuk menetapkan nilai baru berikutnya, Anda perlu menggunakan<- operator.

Sebagai contoh,

let mutable x = 10
x <- 15

Contoh berikut akan menghapus konsep -

Contoh

let mutable x = 10
let y = 20
let mutable z = x + y

printfn "Original Values:"
printfn "x: %i" x
printfn "y: %i" y
printfn "z: %i" z

printfn "Let us change the value of x"
printfn "Value of z will change too."

x <- 15
z <- x + y

printfn "New Values:"
printfn "x: %i" x
printfn "y: %i" y
printfn "z: %i" z

Ketika Anda mengkompilasi dan menjalankan program, itu menghasilkan output berikut -

Original Values:
x: 10
y: 20
z: 30
Let us change the value of x
Value of z will change too.
New Values:
x: 15
y: 20
z: 35

Penggunaan Data yang Dapat Diubah

Data yang dapat berubah seringkali dibutuhkan dan digunakan dalam pemrosesan data, terutama dengan struktur data record. Contoh berikut menunjukkan ini -

open System

type studentData =
   { ID : int;
      mutable IsRegistered : bool;
      mutable RegisteredText : string; }

let getStudent id =
   { ID = id;
      IsRegistered = false;
      RegisteredText = null; }

let registerStudents (students : studentData list) =
   students |> List.iter(fun st ->
      st.IsRegistered <- true
      st.RegisteredText <- sprintf "Registered %s" (DateTime.Now.ToString("hh:mm:ss"))

      Threading.Thread.Sleep(1000) (* Putting thread to sleep for 1 second to simulate processing overhead. *))

let printData (students : studentData list) =
   students |> List.iter (fun x -> printfn "%A" x)

let main() =
   let students = List.init 3 getStudent

   printfn "Before Process:"
   printData students

   printfn "After process:"
   registerStudents students
   printData students

   Console.ReadKey(true) |> ignore

main()

Ketika Anda mengkompilasi dan menjalankan program, itu menghasilkan output berikut -

Before Process:
{ID = 0;
IsRegistered = false;
RegisteredText = null;}
{ID = 1;
IsRegistered = false;
RegisteredText = null;}
{ID = 2;
IsRegistered = false;
RegisteredText = null;}
After process:
{ID = 0;
IsRegistered = true;
RegisteredText = "Registered 05:39:15";}
{ID = 1;
IsRegistered = true;
RegisteredText = "Registered 05:39:16";}
{ID = 2;
IsRegistered = true;
RegisteredText = "Registered 05:39:17";}

Array adalah kumpulan elemen data berurutan dengan ukuran tetap, berbasis nol, dan dapat berubah yang semuanya berjenis sama.

Membuat Array

Anda dapat membuat array menggunakan berbagai sintaks dan cara atau dengan menggunakan fungsi dari modul Array. Pada bagian ini, kita akan membahas pembuatan array tanpa menggunakan fungsi modul.

Ada tiga cara sintaksis untuk membuat array tanpa fungsi -

Dengan mencantumkan nilai berurutan antara [| dan |] dan dipisahkan oleh titik koma.
Dengan meletakkan setiap elemen pada baris terpisah, dalam hal ini pemisah titik koma bersifat opsional.
Dengan menggunakan ekspresi urutan.

Anda dapat mengakses elemen array dengan menggunakan operator titik (.) Dan tanda kurung ([dan]).

Contoh berikut menunjukkan pembuatan array -

//using semicolon separator
let array1 = [| 1; 2; 3; 4; 5; 6 |]
for i in 0 .. array1.Length - 1 do
   printf "%d " array1.[i]
printfn" "

// without semicolon separator
let array2 =
   [|
      1
      2
      3
      4
      5
   |]
for i in 0 .. array2.Length - 1 do
   printf "%d " array2.[i]
printfn" "

//using sequence
let array3 = [| for i in 1 .. 10 -> i * i |]
for i in 0 .. array3.Length - 1 do
   printf "%d " array3.[i]
printfn" "

Ketika Anda mengkompilasi dan menjalankan program, itu menghasilkan output berikut -

1 2 3 4 5 6
1 2 3 4 5
1 4 9 16 25 36 49 64 81 100

Operasi Dasar pada Array

Modul perpustakaan Microsoft.FSharp.Collections.Array mendukung operasi pada array satu dimensi.

Tabel berikut menunjukkan operasi dasar pada Array -

Nilai	Deskripsi
tambahkan: 'T [] →' T [] → 'T []	Membuat larik yang berisi elemen satu larik diikuti dengan elemen larik lainnya.
rata-rata: ^ T [] → ^ T	Mengembalikan rata-rata elemen dalam larik.
averageBy: ('T → ^ U) →' T [] → ^ U	Mengembalikan rata-rata elemen yang dihasilkan dengan menerapkan fungsi ke setiap elemen larik.
blit: 'T [] → int →' T [] → int → int → unit	Membaca berbagai elemen dari satu larik dan menuliskannya ke larik lain.
pilih: (opsi 'T → U) →' T [] → 'U []	Menerapkan fungsi yang disediakan untuk setiap elemen array. Mengembalikan larik yang berisi hasil x untuk setiap elemen yang fungsinya mengembalikan Some (x).
kumpulkan: ('T →' U []) → T [] → 'U []	Menerapkan fungsi yang disediakan ke setiap elemen larik, menggabungkan hasil, dan mengembalikan larik gabungan.
concat: seq <'T []> →' T []	Membuat larik yang berisi elemen dari setiap urutan larik yang disediakan.
salin: 'T →' T []	Membuat larik yang berisi elemen larik yang disediakan.
buat: int → 'T →' T []	Membuat array yang semua elemen awalnya adalah nilai yang diberikan.
kosong: 'T []	Mengembalikan larik kosong dari tipe yang diberikan.
ada: ('T → bool) →' T [] → bool	Menguji apakah ada elemen array yang memenuhi predikat yang diberikan.
keberadaan2: ('T1 →' T2 → bool) → 'T1 [] →' T2 [] → bool	Menguji apakah pasangan elemen yang sesuai dari dua larik memenuhi kondisi yang disediakan.
isi: 'T [] → int → int →' T → unit	Mengisi berbagai elemen larik dengan nilai yang diberikan.
filter: ('T → bool) →' T [] → 'T []	Mengembalikan koleksi yang hanya berisi elemen dari larik yang disediakan yang dikembalikan kondisi yang disediakan true.
temukan: ('T → bool) →' T [] → 'T	Mengembalikan elemen pertama yang dikembalikan fungsi yang disediakan true. Menambah KeyNotFoundException jika tidak ada elemen seperti itu.
findIndex: ('T → bool) →' T [] → int	Mengembalikan indeks elemen pertama dalam larik yang memenuhi kondisi yang disediakan. Muncul KeyNotFoundException jika tidak ada elemen yang memenuhi ketentuan.
fold: ('State →' T → 'State) →' State → 'T [] →' State	Menerapkan fungsi ke setiap elemen array, memasukkan argumen akumulator melalui komputasi. Jika fungsi input adalah f dan elemen array adalah i0 ... iN, fungsi ini menghitung f (... (fs i0) ...) iN.
fold2: ('State →' T1 → 'T2 →' State) → 'State →' T1 [] → 'T2 [] →' State	Menerapkan fungsi ke pasangan elemen dari dua larik yang disediakan, kiri-ke-kanan, memasukkan argumen akumulator melalui komputasi. Kedua larik masukan harus memiliki panjang yang sama; jika tidak, ArgumentException akan dimunculkan.
foldBack: ('T →' State → 'State) →' T [] → 'State →' State	Menerapkan fungsi ke setiap elemen array, memasukkan argumen akumulator melalui komputasi. Jika fungsi input adalah f dan elemen array adalah i0 ... iN, fungsi ini menghitung f i0 (... (f iN s)).
foldBack2: ('T1 →' T2 → 'State →' State) → 'T1 [] →' T2 [] → 'State →' State	Menerapkan fungsi ke pasangan elemen dari dua larik yang disediakan, kanan ke kiri, memasukkan argumen akumulator melalui komputasi. Kedua larik masukan harus memiliki panjang yang sama; jika tidak, ArgumentException akan dimunculkan.
forall: ('T → bool) →' T [] → bool	Menguji apakah semua elemen larik memenuhi kondisi yang disediakan.
forall2: ('T1 →' T2 → bool) → 'T1 [] →' T2 [] → bool	Menguji apakah semua elemen yang sesuai dari dua larik yang disediakan memenuhi kondisi yang disuplai.
dapatkan: 'T [] → int →' T	Mendapat elemen dari array.
init: int → (int → 'T) →' T []	Menggunakan fungsi yang disediakan untuk membuat larik dari dimensi yang disediakan.
isEmpty: 'T [] → bool	Menguji apakah sebuah array memiliki elemen apa pun.
iter: ('T → unit) →' T [] → unit	Menerapkan fungsi yang disediakan untuk setiap elemen array.
iter2: ('T1 →' T2 → unit) → 'T1 [] →' T2 [] → unit)	Menerapkan fungsi yang disediakan untuk sepasang elemen dari indeks yang cocok dalam dua larik. Kedua larik harus memiliki panjang yang sama; jika tidak, ArgumentException akan dimunculkan.
iteri: (int → 'T → unit) →' T [] → unit	Menerapkan fungsi yang disediakan untuk setiap elemen array. Integer yang diteruskan ke fungsi menunjukkan indeks elemen.
iteri2: (int → 'T1 →' T2 → unit) → 'T1 [] →' T2 [] → unit	Menerapkan fungsi yang disediakan ke sepasang elemen dari indeks yang cocok dalam dua larik, juga meneruskan indeks elemen. Kedua larik harus memiliki panjang yang sama; jika tidak, ArgumentException akan dimunculkan.
panjang: 'T [] → int	Menampilkan panjang larik. Properti Panjang melakukan hal yang sama.
peta: ('T →' U) → 'T [] →' U []	Membuat larik yang elemennya merupakan hasil penerapan fungsi yang disediakan ke setiap elemen larik yang disediakan.
map2: ('T1 →' T2 → 'U) →' T1 [] → 'T2 [] →' U []	Membuat larik yang elemennya merupakan hasil penerapan fungsi yang disediakan ke elemen terkait dari dua larik yang disediakan. Kedua larik masukan harus memiliki panjang yang sama; jika tidak, ArgumentException akan dimunculkan.
mapi: (int → 'T →' U) → 'T [] →' U []	Membuat larik yang elemennya merupakan hasil penerapan fungsi yang disediakan ke setiap elemen larik yang disediakan. Indeks integer yang diteruskan ke fungsi menunjukkan indeks elemen yang sedang diubah.
mapi2: (int → 'T1 →' T2 → 'U) →' T1 [] → 'T2 [] →' U []	Membuat larik yang elemennya merupakan hasil penerapan fungsi yang disediakan ke elemen yang sesuai dari dua koleksi secara berpasangan, juga meneruskan indeks elemen. Kedua larik masukan harus memiliki panjang yang sama; jika tidak, ArgumentException akan dimunculkan.
maks: 'T [] →' T	Mengembalikan elemen terbesar dari semua larik. Operators.max digunakan untuk membandingkan elemen.
maxBy: ('T →' U) → 'T [] →' T	Mengembalikan yang terbesar dari semua elemen larik, dibandingkan melalui Operators.max pada hasil fungsi.
min: ('T [] →' T	Menampilkan elemen terkecil dari semua elemen larik. Operators.min digunakan untuk membandingkan elemen.
minBy: ('T →' U) → 'T [] →' T	Menampilkan elemen terkecil dari semua elemen larik. Operators.min digunakan untuk membandingkan elemen.
ofList: 'T list →' T []	Membuat larik dari daftar yang disediakan.
ofSeq: seq <'T> →' T []	Membuat array dari objek enumerable yang disediakan.
partisi: ('T → bool) →' T [] → 'T [] *' T []	Membagi larik menjadi dua larik, satu larik berisi elemen yang dikembalikan kondisi yang disediakan true, dan yang lainnya berisi yang dikembalikan false.
permutasi: (int → int) → 'T [] →' T []	Mengizinkan elemen array sesuai dengan permutasi yang ditentukan.
pilih: (Opsi 'T →' U) → 'T [] →' U	Menerapkan fungsi yang disediakan ke elemen berturut-turut dari larik yang disediakan, mengembalikan hasil pertama di mana fungsi mengembalikan Some (x) untuk beberapa x. Jika fungsi tidak pernah mengembalikan Some (x), KeyNotFoundException akan dimunculkan.
mengurangi: ('T →' T → 'T) →' T [] → 'T	Menerapkan fungsi ke setiap elemen array, memasukkan argumen akumulator melalui komputasi. Jika fungsi input adalah f dan elemen array adalah i0 ... iN, fungsi ini menghitung f (... (f i0 i1) ...) iN. Jika array berukuran nol, ArgumentException akan dimunculkan.
reduceBack: ('T →' T → 'T) →' T [] → 'T	Menerapkan fungsi ke setiap elemen array, memasukkan argumen akumulator melalui komputasi. Jika fungsi masukan adalah f dan elemennya adalah i0 ... iN, fungsi ini menghitung f i0 (... (f iN-1 iN)). Jika array berukuran nol, ArgumentException akan dimunculkan.
rev: 'T [] →' T []	Membalik urutan elemen dalam larik yang disediakan.
scan: ('State →' T → 'State) →' State → 'T [] →' State [])	Berperilaku seperti lipatan, tetapi mengembalikan hasil antara bersama dengan hasil akhir.
scanBack: ('T →' State → 'State) →' T [] → 'State →' State []	Berperilaku seperti foldBack, tetapi mengembalikan hasil perantara bersama dengan hasil akhir.
set: 'T [] → int →' T → unit	Menetapkan elemen array.
urutkan: 'T [] →' T []	Mengurutkan elemen dari sebuah array dan mengembalikan sebuah array baru. Operator.compare digunakan untuk membandingkan elemen.
sortBy: ('T →' Key) → 'T [] →' T []	Mengurutkan elemen array dengan menggunakan fungsi yang disediakan untuk mengubah elemen menjadi tipe yang menjadi dasar operasi pengurutan, dan mengembalikan array baru. Operator.compare digunakan untuk membandingkan elemen.
sortInPlace: 'T [] → unit	Mengurutkan elemen array dengan mengubah array pada tempatnya, menggunakan fungsi perbandingan yang disediakan. Operator.compare digunakan untuk membandingkan elemen.
sortInPlaceBy: ('T →' Key) → 'T [] → unit	Mengurutkan elemen array dengan mengubah array pada tempatnya, menggunakan proyeksi yang disediakan untuk kunci. Operator.compare digunakan untuk membandingkan elemen.
sortInPlaceWith: ('T →' T → int) → 'T [] → unit	Mengurutkan elemen dari sebuah larik dengan menggunakan fungsi perbandingan yang disediakan untuk mengubah larik pada tempatnya.
sortWith: ('T →' T → int) → 'T [] →' T []	Mengurutkan elemen array dengan menggunakan fungsi perbandingan yang disediakan, dan mengembalikan array baru.
sub: 'T [] → int → int →' T []	Membuat larik yang berisi subrentang yang disediakan, yang ditentukan dengan indeks awal dan panjang.
jumlah: 'T [] → ^ T	Mengembalikan jumlah elemen dalam larik.
sumBy: ('T → ^ U) →' T [] → ^ U	Mengembalikan jumlah hasil yang dihasilkan dengan menerapkan fungsi ke setiap elemen larik.
toList: 'T [] →' T daftar	Mengonversi larik yang disediakan menjadi daftar.
toSeq: 'T [] → seq <' T>	Melihat larik yang disediakan sebagai urutan.
tryFind: opsi ('T → bool) →' T [] → 'T	Mengembalikan elemen pertama dalam larik yang disediakan yang dikembalikan fungsi yang disediakan true. KembaliNone jika tidak ada elemen seperti itu.
tryFindIndex: ('T → bool) →' T [] → opsi int	Mengembalikan indeks elemen pertama dalam larik yang memenuhi kondisi yang disediakan.
tryPick: (opsi 'T →' U) → 'T [] →' U opsi	Menerapkan fungsi yang disediakan ke elemen berturut-turut dari larik yang disediakan, dan mengembalikan hasil pertama di mana fungsi tersebut mengembalikan Some (x) untuk beberapa x. Jika fungsi tidak pernah mengembalikan Beberapa (x),None dikembalikan.
buka zip: ('T1 ' T2) [] → 'T1 [] ' T2 []	Membagi larik pasangan tupel menjadi tupel yang terdiri dari dua larik.
unzip3: ('T1 ' T2 'T3) [] →' T1 [] * 'T2 [] *' T3 []	Membagi larik tupel tiga elemen menjadi tupel tiga larik.
zeroCreate: int → 'T []	Membuat larik yang elemen awalnya disetel ke nilai default Unchecked.defaultof <'T>.
zip: 'T1 [] →' T2 [] → ('T1 *' T2) []	Menggabungkan dua larik menjadi larik tupel yang memiliki dua elemen. Kedua larik harus memiliki panjang yang sama; jika tidak, ArgumentException akan dimunculkan.
zip3: 'T1 [] →' T2 [] → 'T3 [] → (' T1 * 'T2 * 113' T3) []	Menggabungkan tiga larik menjadi larik tupel yang memiliki tiga elemen. Ketiga larik harus memiliki panjang yang sama; jika tidak, ArgumentException akan dimunculkan.

Pada bagian berikut, kita akan melihat penggunaan dari beberapa fungsi ini.

Membuat Array Menggunakan Fungsi

Modul Array menyediakan beberapa fungsi yang membuat array dari awal.

Itu Array.empty fungsi membuat array kosong baru.
Itu Array.create fungsi membuat larik dengan ukuran tertentu dan menyetel semua elemen ke nilai yang diberikan.
Itu Array.init function membuat sebuah array, diberi dimensi dan fungsi untuk menghasilkan elemen.
Itu Array.zeroCreate fungsi membuat larik di mana semua elemen diinisialisasi ke nilai nol.
Itu Array.copy fungsi membuat array baru yang berisi elemen yang disalin dari array yang sudah ada.
Itu Array.sub function menghasilkan array baru dari subrange array.
Itu Array.append fungsi membuat array baru dengan menggabungkan dua array yang sudah ada.
Itu Array.choose fungsi memilih elemen dari sebuah larik untuk dimasukkan ke dalam larik baru.
Itu Array.collect function menjalankan fungsi tertentu pada setiap elemen array dari array yang ada dan kemudian mengumpulkan elemen yang dihasilkan oleh fungsi dan menggabungkannya menjadi array baru.
Itu Array.concat function mengambil urutan array dan menggabungkannya menjadi satu array.
Itu Array.filter function mengambil fungsi kondisi Boolean dan menghasilkan larik baru yang hanya berisi elemen-elemen dari larik masukan yang kondisinya benar.
Itu Array.rev function menghasilkan array baru dengan membalik urutan array yang sudah ada.

Contoh berikut menunjukkan fungsi-fungsi ini -

Contoh 1

(* using create and set *)
let array1 = Array.create 10 ""
for i in 0 .. array1.Length - 1 do
   Array.set array1 i (i.ToString())
for i in 0 .. array1.Length - 1 do
   printf "%s " (Array.get array1 i)
printfn " "

(* empty array *)
let array2 = Array.empty
printfn "Length of empty array: %d" array2.Length

let array3 = Array.create 10 7.0
printfn "Float Array: %A" array3

(* using the init and zeroCreate *)
let array4 = Array.init 10 (fun index -> index * index)
printfn "Array of squares: %A" array4

let array5 : float array = Array.zeroCreate 10
let (myZeroArray : float array) = Array.zeroCreate 10
printfn "Float Array: %A" array5

Ketika Anda mengkompilasi dan menjalankan program, itu menghasilkan output berikut -

0 1 2 3 4 5 6 7 8 9
Length of empty array: 0
Float Array: [|7.0; 7.0; 7.0; 7.0; 7.0; 7.0; 7.0; 7.0; 7.0; 7.0|]
Array of squares: [|0; 1; 4; 9; 16; 25; 36; 49; 64; 81|]
Float Array: [|0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0|]

Contoh 2

(* creating subarray from element 5 *)
(* containing 15 elements thereon *)

let array1 = [| 0 .. 50 |]
let array2 = Array.sub array1 5 15
printfn "Sub Array:"
printfn "%A" array2

(* appending two arrays *)
let array3 = [| 1; 2; 3; 4|]
let array4 = [| 5 .. 9 |]
printfn "Appended Array:"
let array5 = Array.append array3 array4
printfn "%A" array5

(* using the Choose function *)
let array6 = [| 1 .. 20 |]
let array7 = Array.choose (fun elem -> if elem % 3 = 0 then
                                             Some(float (elem))
                                          else
                                             None) array6
printfn "Array with Chosen elements:"
printfn "%A" array7

(*using the Collect function *)
let array8 = [| 2 .. 5 |]
let array9 = Array.collect (fun elem -> [| 0 .. elem - 1 |]) array8
printfn "Array with collected elements:"
printfn "%A" array9

Ketika Anda mengkompilasi dan menjalankan program, itu menghasilkan output berikut -

Sub Array:
[|5; 6; 7; 8; 9; 10; 11; 12; 13; 14; 15; 16; 17; 18; 19|]
Appended Array:
[|1; 2; 3; 4; 5; 6; 7; 8; 9|]
Array with Chosen elements:
[|3.0; 6.0; 9.0; 12.0; 15.0; 18.0|]
Array with collected elements:
[|0; 1; 0; 1; 2; 0; 1; 2; 3; 0; 1; 2; 3; 4|]

Mencari Array

Itu Array.find function mengambil fungsi Boolean dan mengembalikan elemen pertama yang fungsinya mengembalikan true, jika tidak memunculkan KeyNotFoundException.

Itu Array.findIndex function bekerja dengan cara yang sama kecuali ia mengembalikan indeks elemen, bukan elemen itu sendiri.

Contoh berikut menunjukkan hal ini.

Microsoft memberikan contoh program yang menarik ini, yang menemukan elemen pertama dalam kisaran angka tertentu yang merupakan kuadrat sempurna dan juga kubus sempurna -

let array1 = [| 2 .. 100 |]
let delta = 1.0e-10
let isPerfectSquare (x:int) =
   let y = sqrt (float x)
   abs(y - round y) < delta

let isPerfectCube (x:int) =
   let y = System.Math.Pow(float x, 1.0/3.0)
   abs(y - round y) < delta

let element = Array.find (fun elem -> isPerfectSquare elem && isPerfectCube elem) array1

let index = Array.findIndex (fun elem -> isPerfectSquare elem && isPerfectCube elem) array1

printfn "The first element that is both a square and a cube is %d and its index is %d." element index

Ketika Anda mengkompilasi dan menjalankan program, itu menghasilkan output berikut -

The first element that is both a square and a cube is 64 and its index is 62.

Itu List<'T> class mewakili daftar objek yang diketik dengan kuat yang dapat diakses oleh indeks.

Ini adalah pasangan kelas List yang bisa berubah. Ini mirip dengan array, karena dapat diakses oleh indeks, namun, tidak seperti array, daftar dapat diubah ukurannya. Oleh karena itu, Anda tidak perlu menentukan ukuran selama deklarasi.

Membuat Daftar yang Dapat Diubah

Daftar dibuat menggunakan newkata kunci dan memanggil konstruktor daftar. Contoh berikut menunjukkan ini -

(* Creating a List *)
open System.Collections.Generic

let booksList = new List<string>()
booksList.Add("Gone with the Wind")
booksList.Add("Atlas Shrugged")
booksList.Add("Fountainhead")
booksList.Add("Thornbirds")
booksList.Add("Rebecca")
booksList.Add("Narnia")

booksList |> Seq.iteri (fun index item -> printfn "%i: %s" index booksList.[index])

Ketika Anda mengkompilasi dan menjalankan program, itu menghasilkan output berikut -

0: Gone with the Wind
1: Atlas Shrugged
2: Fountainhead
3: Thornbirds
4: Rebecca
5: Narnia

Kelas Daftar (T)

Kelas List (T) mewakili daftar objek yang diketik dengan kuat yang dapat diakses oleh indeks. Ini menyediakan metode untuk mencari, mengurutkan, dan memanipulasi daftar.

Tabel berikut menyediakan properti, konstruktor, dan metode kelas List (T) -

Properti

Properti	Deskripsi
Kapasitas	Mendapat atau menyetel jumlah total elemen yang dapat disimpan oleh struktur data internal tanpa mengubah ukurannya.
Menghitung	Mendapat jumlah elemen yang terdapat dalam List (T).
Barang	Mendapat atau menyetel elemen pada indeks yang ditentukan.

Konstruktor

Pembuat	Deskripsi
Daftar (T) ()	Menginisialisasi instance baru kelas List (T) yang kosong dan memiliki kapasitas awal default.
Daftar (T) (IEnumerable (T))	Menginisialisasi instance baru kelas List (T) yang berisi elemen yang disalin dari koleksi yang ditentukan dan memiliki kapasitas yang cukup untuk mengakomodasi jumlah elemen yang disalin.
Daftar (T) (Int32)	Menginisialisasi instance baru kelas List (T) yang kosong dan memiliki kapasitas awal yang ditentukan.

metode

Metode	Deskripsi
Menambahkan	Menambahkan objek ke akhir List (T).
AddRange	Menambahkan elemen dari koleksi yang ditentukan ke akhir Daftar (T).
AsReadOnly	Mengembalikan pembungkus IList (T) hanya baca untuk koleksi saat ini.
BinarySearch (T)	Mencari seluruh Daftar yang diurutkan (T) untuk sebuah elemen menggunakan pembanding default dan mengembalikan indeks berbasis nol dari elemen tersebut.
BinarySearch (T, IComparer (T))	Mencari seluruh Daftar yang diurutkan (T) untuk sebuah elemen menggunakan pembanding yang ditentukan dan mengembalikan indeks berbasis nol dari elemen tersebut.
BinarySearch (Int32, Int32, T, IComparer (T))	Menelusuri rentang elemen dalam Daftar yang diurutkan (T) untuk elemen menggunakan pembanding yang ditentukan dan mengembalikan indeks elemen berbasis nol.
Bersih	Menghapus semua elemen dari Daftar (T).
Mengandung	Menentukan apakah suatu elemen ada dalam List (T).
ConvertAll (TOutput)	Mengonversi elemen dalam Daftar (T) saat ini ke tipe lain, dan mengembalikan daftar yang berisi elemen yang dikonversi.
CopyTo (T [])	Menyalin seluruh Daftar (T) ke larik satu dimensi yang kompatibel, dimulai dari awal larik target.
CopyTo (T [], Int32)	Menyalin seluruh Daftar (T) ke larik satu dimensi yang kompatibel, dimulai dari indeks larik target yang ditentukan.
CopyTo (Int32, T [], Int32, Int32)	Menyalin berbagai elemen dari List (T) ke array satu dimensi yang kompatibel, dimulai dari indeks yang ditentukan dari array target.
Sama dengan (Objek)	Menentukan apakah objek yang ditentukan sama dengan objek saat ini. (Diwariskan dari Objek.)
Ada	Menentukan apakah Daftar (T) berisi elemen yang sesuai dengan kondisi yang ditentukan oleh predikat yang ditentukan.
Menyelesaikan	Mengizinkan objek mencoba membebaskan sumber daya dan melakukan operasi pembersihan lainnya sebelum diklaim kembali oleh pengumpulan sampah (Diwarisi dari Objek).
Temukan	Mencari elemen yang cocok dengan kondisi yang ditentukan oleh predikat yang ditentukan, dan mengembalikan kemunculan pertama dalam seluruh Daftar (T).
Temukan semua	Mengambil semua elemen yang cocok dengan kondisi yang ditentukan oleh predikat yang ditentukan.
FindIndex (Predikat (T))	Mencari elemen yang cocok dengan kondisi yang ditentukan oleh predikat yang ditentukan, dan mengembalikan indeks berbasis nol dari kejadian pertama dalam seluruh Daftar (T).
FindIndex (Int32, Predicate (T))	Mencari elemen yang cocok dengan kondisi yang ditentukan oleh predikat yang ditentukan, dan mengembalikan indeks berbasis nol dari kemunculan pertama dalam rentang elemen dalam Daftar (T) yang meluas dari indeks yang ditentukan ke elemen terakhir.
FindIndex (Int32, Int32, Predicate (T))	Mencari elemen yang cocok dengan kondisi yang ditentukan oleh predikat yang ditentukan, dan mengembalikan indeks berbasis nol dari kejadian pertama dalam rentang elemen dalam Daftar (T) yang dimulai pada indeks yang ditentukan dan berisi jumlah elemen yang ditentukan.
FindLast	Mencari elemen yang cocok dengan kondisi yang ditentukan oleh predikat yang ditentukan, dan mengembalikan kemunculan terakhir dalam seluruh Daftar (T).
FindLastIndex (Predicate (T))	Mencari elemen yang cocok dengan kondisi yang ditentukan oleh predikat yang ditentukan, dan mengembalikan indeks berbasis nol dari kejadian terakhir dalam seluruh Daftar (T).
FindLastIndex (Int32, Predicate (T))	Mencari elemen yang cocok dengan kondisi yang ditentukan oleh predikat yang ditentukan, dan mengembalikan indeks berbasis nol dari kejadian terakhir dalam rentang elemen dalam Daftar (T) yang meluas dari elemen pertama ke indeks yang ditentukan.
FindLastIndex (Int32, Int32, Predicate (T))	Mencari elemen yang cocok dengan kondisi yang ditentukan oleh predikat yang ditentukan, dan mengembalikan indeks berbasis nol dari kejadian terakhir dalam rentang elemen dalam Daftar (T) yang berisi jumlah elemen yang ditentukan dan berakhir pada indeks yang ditentukan.
Untuk setiap	Melakukan tindakan yang ditentukan pada setiap elemen List (T).
GetEnumerator	Mengembalikan enumerator yang mengulang melalui List (T).
GetHashCode	Berfungsi sebagai fungsi hash default. (Diwariskan dari Objek.)
GetRange	Membuat salinan dangkal dari berbagai elemen dalam Daftar sumber (T).
GetType	Mendapat Jenis instance saat ini. (Diwariskan dari Objek.)
IndexOf (T)	Mencari objek yang ditentukan dan mengembalikan indeks berbasis nol dari kemunculan pertama dalam seluruh Daftar (T).
IndexOf (T, Int32)	Mencari objek yang ditentukan dan mengembalikan indeks berbasis nol dari kemunculan pertama dalam rentang elemen dalam Daftar (T) yang meluas dari indeks yang ditentukan ke elemen terakhir.
IndexOf (T, Int32, Int32)	Mencari objek yang ditentukan dan mengembalikan indeks berbasis nol dari kejadian pertama dalam rentang elemen dalam Daftar (T) yang dimulai pada indeks yang ditentukan dan berisi jumlah elemen yang ditentukan.
Memasukkan	Menyisipkan elemen ke dalam Daftar (T) pada indeks yang ditentukan.
InsertRange	Menyisipkan elemen koleksi ke dalam Daftar (T) pada indeks yang ditentukan.
LastIndexOf (T)	Mencari objek yang ditentukan dan mengembalikan indeks berbasis nol dari kejadian terakhir dalam seluruh Daftar (T).
LastIndexOf (T, Int32)	Mencari objek yang ditentukan dan mengembalikan indeks berbasis nol dari kejadian terakhir dalam rentang elemen dalam Daftar (T) yang meluas dari elemen pertama ke indeks yang ditentukan.
LastIndexOf (T, Int32, Int32)	Mencari objek yang ditentukan dan mengembalikan indeks berbasis nol dari kejadian terakhir dalam rentang elemen dalam Daftar (T) yang berisi jumlah elemen yang ditentukan dan berakhir pada indeks yang ditentukan.
MemberwiseClone	Membuat salinan dangkal dari Objek saat ini. (Diwariskan dari Objek.)
Menghapus	Menghapus kemunculan pertama objek tertentu dari Daftar (T).
Menghapus semua	Menghapus semua elemen yang cocok dengan kondisi yang ditentukan oleh predikat yang ditentukan.
RemoveAt	Menghapus elemen pada indeks tertentu dari List (T).
RemoveRange	Menghapus berbagai elemen dari Daftar (T).
Balik()	Membalik urutan elemen di seluruh Daftar (T).
Terbalik (Int32, Int32)	Membalik urutan elemen dalam rentang yang ditentukan.
Menyortir()	Mengurutkan elemen di seluruh Daftar (T) menggunakan pembanding default.
Urutkan (Perbandingan (T))	Mengurutkan elemen di seluruh Daftar (T) menggunakan Sistem yang ditentukan. Perbandingan (T).
Urutkan (Pembanding (T))	Mengurutkan elemen di seluruh Daftar (T) menggunakan pembanding yang ditentukan.
Urutkan (Int32, Int32, IComparer (T))	Mengurutkan elemen dalam rentang elemen dalam Daftar (T) menggunakan pembanding yang ditentukan.
ToArray	Menyalin elemen List (T) ke array baru.
ToString	Mengembalikan string yang mewakili objek saat ini. (Diwariskan dari Objek.)
TrimExcess	Menyetel kapasitas ke jumlah elemen sebenarnya dalam Daftar (T), jika angka itu kurang dari nilai ambang batas.
TrueForAll	Menentukan apakah setiap elemen dalam Daftar (T) cocok dengan kondisi yang ditentukan oleh predikat yang ditentukan.

Contoh

(* Creating a List *)
open System.Collections.Generic

let booksList = new List<string>()
booksList.Add("Gone with the Wind")
booksList.Add("Atlas Shrugged")
booksList.Add("Fountainhead")
booksList.Add("Thornbirds")
booksList.Add("Rebecca")
booksList.Add("Narnia")

printfn"Total %d books" booksList.Count
booksList |> Seq.iteri (fun index item -> printfn "%i: %s" index booksList.[index])
booksList.Insert(2, "Roots")

printfn("after inserting at index 2")
printfn"Total %d books" booksList.Count

booksList |> Seq.iteri (fun index item -> printfn "%i: %s" index booksList.[index])
booksList.RemoveAt(3)

printfn("after removing from index 3")
printfn"Total %d books" booksList.Count

booksList |> Seq.iteri (fun index item -> printfn "%i: %s" index booksList.[index])

Ketika Anda mengkompilasi dan menjalankan program, itu menghasilkan output berikut -

Total 6 books
0: Gone with the Wind
1: Atlas Shrugged
2: Fountainhead
3: Thornbirds
4: Rebecca
5: Narnia
after inserting at index 2
Total 7 books
0: Gone with the Wind
1: Atlas Shrugged
2: Roots
3: Fountainhead
4: Thornbirds
5: Rebecca
6: Narnia
after removing from index 3
Total 6 books
0: Gone with the Wind
1: Atlas Shrugged
2: Roots
3: Thornbirds
4: Rebecca
5: Narnia

Itu Dictionary<'TKey, 'TValue> class adalah analog yang bisa berubah dari struktur data peta F # dan berisi banyak fungsi yang sama.

Meringkas dari bab Peta di F #, peta adalah jenis himpunan khusus yang menghubungkan nilai dengan kunci.

Membuat Kamus yang Dapat Diubah

Kamus yang dapat berubah dibuat menggunakan newkata kunci dan memanggil konstruktor daftar. Contoh berikut menunjukkan ini -

open System.Collections.Generic
let dict = new Dictionary<string, string>()
dict.Add("1501", "Zara Ali")
dict.Add("1502","Rishita Gupta")
dict.Add("1503","Robin Sahoo")
dict.Add("1504","Gillian Megan")
printfn "Dictionary - students: %A" dict

Ketika Anda mengkompilasi dan menjalankan program, itu menghasilkan output berikut -

Dictionary - students: seq
[[1501, Zara Ali]; [1502, Rishita Gupta]; [1503, Robin Sahoo];
[1504, Gillian Megan]]

Kelas Kamus (TKey, TValue)

Kelas Dictionary (TKey, TValue) mewakili kumpulan kunci dan nilai.

Tabel berikut menyediakan properti, konstruktor, dan metode kelas List (T) -

Properti

Properti	Deskripsi
Pembanding	Mendapatkan IEqualityComparer (T) yang digunakan untuk menentukan persamaan kunci untuk kamus.
Menghitung	Mendapat jumlah pasangan kunci / nilai yang terdapat dalam Kamus (TKey, TValue).
Barang	Mendapat atau menetapkan nilai yang terkait dengan kunci yang ditentukan.
Kunci	Mendapat koleksi yang berisi kunci dalam Kamus (TKey, TValue).
Nilai	Mendapat koleksi yang berisi nilai-nilai dalam Kamus (TKey, TValue).

Konstruktor

Konstruktor	Deskripsi
Kamus (TKey, TValue) ()	Menginisialisasi instance baru dari Dictionary(TKey, TValue) kelas yang kosong, memiliki kapasitas awal default, dan menggunakan pembanding kesetaraan default untuk jenis kunci.
Kamus (TKey, TValue) (IDictionary (TKey, TValue))	Menginisialisasi instance baru dari Dictionary(TKey, TValue) kelas yang berisi elemen yang disalin dari yang ditentukan IDictionary(TKey, TValue) dan menggunakan pembanding kesetaraan default untuk jenis kunci.
Kamus (TKey, TValue) (IEqualityComparer (TKey))	Menginisialisasi instance baru dari Dictionary(TKey, TValue) kelas yang kosong, memiliki kapasitas awal default, dan menggunakan yang ditentukan IEqualityComparer(T).
Kamus (TKey, TValue) (Int32)	Menginisialisasi instance baru dari Dictionary(TKey, TValue) kelas yang kosong, memiliki kapasitas awal yang ditentukan, dan menggunakan pembanding kesetaraan default untuk jenis kunci.
Kamus (TKey, TValue) (IDictionary (TKey, TValue), IEqualityComparer (TKey))	Menginisialisasi instance baru dari Dictionary(TKey, TValue) kelas yang berisi elemen yang disalin dari yang ditentukan IDictionary(TKey, TValue) dan menggunakan yang ditentukan IEqualityComparer(T).
Kamus (TKey, TValue) (Int32, IEqualityComparer (TKey))	Menginisialisasi instance baru dari Dictionary(TKey, TValue) kelas yang kosong, memiliki kapasitas awal yang ditentukan, dan menggunakan yang ditentukan IEqualityComparer(T).
Kamus (TKey, TValue) (SerializationInfo, StreamingContext)	Menginisialisasi instance baru dari ictionary(TKey, TValue) kelas dengan data serial.

Metode

metode	Deskripsi
Menambahkan	Menambahkan kunci dan nilai yang ditentukan ke kamus.
Bersih	Menghapus semua kunci dan nilai dari Kamus (TKey, TValue).
ContainsKey	Menentukan apakah Kamus (TKey, TValue) berisi kunci yang ditentukan.
ContainsValue	Menentukan apakah Kamus (TKey, TValue) berisi nilai tertentu.
Sama dengan (Objek)	Menentukan apakah objek yang ditentukan sama dengan objek saat ini. (Diwariskan dari Objek.)
Menyelesaikan	Mengizinkan objek mencoba membebaskan sumber daya dan melakukan operasi pembersihan lain sebelum diklaim kembali oleh pengumpulan sampah. (Diwariskan dari Objek.)
GetEnumerator	Mengembalikan enumerator yang mengulang melalui Kamus (TKey, TValue).
GetHashCode	Berfungsi sebagai fungsi hash default. (Diwariskan dari Objek.)
GetObjectData	Mengimplementasikan antarmuka System.Runtime.Serialization.ISerializable dan mengembalikan data yang diperlukan untuk membuat serial instance Dictionary (TKey, TValue).
GetType	Mendapat Jenis instance saat ini. (Diwariskan dari Objek.)
MemberwiseClone	Membuat salinan dangkal dari Objek saat ini. (Diwariskan dari Objek.)
OnDeserialization	Mengimplementasikan antarmuka System.Runtime.Serialization.ISerializable dan memunculkan peristiwa deserialization ketika deserialization selesai.
Menghapus	Menghapus nilai dengan kunci yang ditentukan dari Kamus (TKey, TValue).
ToString	Mengembalikan string yang mewakili objek saat ini. (Diwariskan dari Objek.)
TryGetValue	Mendapat nilai yang terkait dengan kunci yang ditentukan.

Contoh

open System.Collections.Generic
let dict = new Dictionary<string, string>()

dict.Add("1501", "Zara Ali")
dict.Add("1502","Rishita Gupta")
dict.Add("1503","Robin Sahoo")
dict.Add("1504","Gillian Megan")

printfn "Dictionary - students: %A" dict
printfn "Total Number of Students: %d" dict.Count
printfn "The keys: %A" dict.Keys
printf"The Values: %A" dict.Values

Ketika Anda mengkompilasi dan menjalankan program, itu menghasilkan output berikut -

Dictionary - students: seq
[[1501, Zara Ali]; [1502, Rishita Gupta]; [1503, Robin Sahoo];
[1504, Gillian Megan]]
Total Number of Students: 4
The keys: seq ["1501"; "1502"; "1503"; "1504"]
The Values: seq ["Zara Ali"; "Rishita Gupta"; "Robin Sahoo"; "Gillian Megan"]

Output Input Dasar meliputi -

Membaca dari dan menulis ke konsol.
Membaca dari dan menulis ke dalam file.

Modul Core.Printf

Kami telah menggunakan fungsi printf dan printfn untuk menulis ke konsol. Di bagian ini, kita akan melihat detail filePrintf modul F #.

Terlepas dari fungsi di atas, modul Core.Printf dari F # memiliki berbagai metode lain untuk mencetak dan memformat menggunakan% penanda sebagai placeholder. Tabel berikut menunjukkan metode dengan deskripsi singkat -

Nilai	Deskripsi
bprintf: StringBuilder → BuilderFormat <'T> →' T	Mencetak ke StringBuilder.
eprintf: TextWriterFormat <'T> →' T	Mencetak keluaran yang diformat ke stderr.
eprintfn: TextWriterFormat <'T> →' T	Mencetak keluaran yang diformat ke stderr, menambahkan baris baru.
failwithf: StringFormat <'T,' Result> → 'T	Mencetak ke buffer string dan memunculkan pengecualian dengan hasil yang diberikan.
fprintf: TextWriter → TextWriterFormat <'T> →' T	Mencetak ke penulis teks.
fprintfn: TextWriter → TextWriterFormat <'T> →' T	Mencetak ke penulis teks, menambahkan baris baru.
kbprintf: (unit → 'Result) → StringBuilder → BuilderFormat <' T, 'Result> →' T	Seperti bprintf, tetapi memanggil fungsi yang ditentukan untuk menghasilkan hasilnya.
kfprintf: (unit → 'Result) → TextWriter → TextWriterFormat <' T, 'Result> →' T	Seperti fprintf, tetapi memanggil fungsi yang ditentukan untuk menghasilkan hasilnya.
kprintf: (string → 'Result) → StringFormat <' T, 'Result> →' T	Seperti printf, tetapi memanggil fungsi yang ditentukan untuk menghasilkan hasilnya. Misalnya, ini membiarkan pencetakan memaksa flush setelah semua output dimasukkan ke saluran, tetapi tidak sebelumnya.
ksprintf: (string → 'Result) → StringFormat <' T, 'Result> →' T	Seperti sprintf, tetapi memanggil fungsi yang ditentukan untuk menghasilkan hasilnya.
printf: TextWriterFormat <'T> →' T	Mencetak keluaran yang diformat ke stdout.
printfn: TextWriterFormat <'T> →' T	Mencetak keluaran yang diformat ke stdout, menambahkan baris baru.
sprintf: StringFormat <'T> →' T	Mencetak ke string dengan menggunakan buffer string internal dan mengembalikan hasilnya sebagai string.

Spesifikasi Format

Spesifikasi format digunakan untuk memformat input atau output, sesuai dengan kebutuhan programmer.

Ini adalah string dengan% penanda yang menunjukkan tempat penampung format.

Sintaks tempat penampung Format adalah -

%[flags][width][.precision][type]

Itu type diartikan sebagai -

Tipe	Deskripsi
% b	Format a bool, diformat sebagai true atau false.
% c	Memformat karakter.
% s	Format a string, diformat sebagai isinya, tanpa menafsirkan karakter escape apa pun.
% d,% i	Memformat jenis bilangan bulat dasar apa pun yang diformat sebagai bilangan bulat desimal, ditandatangani jika jenis bilangan bulat dasar ditandatangani.
% u	Memformat semua jenis bilangan bulat dasar yang diformat sebagai bilangan bulat desimal tak bertanda.
% x	Memformat semua jenis bilangan bulat dasar yang diformat sebagai bilangan bulat heksadesimal tak bertanda, menggunakan huruf kecil a sampai f.
% X	Memformat semua jenis bilangan bulat dasar yang diformat sebagai bilangan bulat heksadesimal tanpa tanda, menggunakan huruf besar A sampai F.
%Hai	Memformat semua jenis bilangan bulat dasar yang diformat sebagai bilangan bulat oktal tak bertanda.
% e,% E,% f,% F,% g,% G	Memformat jenis titik mengambang dasar apa pun (float, float32) diformat menggunakan spesifikasi format titik mengambang gaya-C.
% e,% E	Memformat nilai bertanda yang berbentuk [-] d.dddde [tanda] ddd di mana d adalah digit desimal tunggal, dddd adalah satu atau lebih digit desimal, ddd persis tiga digit desimal, dan tanda + atau -.
% f	Memformat nilai bertanda yang memiliki bentuk [-] dddd.dddd, dengan dddd adalah satu atau lebih digit desimal. Jumlah digit sebelum titik desimal bergantung pada besarnya angka, dan jumlah digit setelah koma desimal bergantung pada ketepatan yang diminta.
% g,% G	Memformat nilai yang ditandatangani yang dicetak dalam format f atau e, mana saja yang lebih ringkas untuk nilai dan presisi yang diberikan.
% M	Memformat nilai Desimal.
%HAI	Memformat nilai apa pun, dicetak dengan mengemas objek dan menggunakannya ToString metode.
% A,% + A	Memformat nilai apa pun, dicetak dengan pengaturan tata letak default. Gunakan% + A untuk mencetak struktur serikat yang terdiskriminasi dengan representasi internal dan pribadi.
%Sebuah	Penentu format umum, membutuhkan dua argumen. Argumen pertama adalah fungsi yang menerima dua argumen: pertama, parameter konteks dari tipe yang sesuai untuk fungsi pemformatan yang diberikan (misalnya, Penulis Teks), dan kedua, nilai untuk dicetak dan yang mengeluarkan atau mengembalikan teks yang sesuai. Argumen kedua adalah nilai khusus untuk dicetak.
% t	Penentu format umum, memerlukan satu argumen: fungsi yang menerima parameter konteks dari tipe yang sesuai untuk fungsi pemformatan yang diberikan (aTextWriter) dan yang mengeluarkan atau mengembalikan teks yang sesuai. Jenis integer dasar adalahbyte, sbyte, int16, uint16, int32, uint32, int64, uint64, nativeint, dan unativeint. Jenis dasar floating point adalah float dan float32.

Itu widthadalah parameter opsional. Ini adalah bilangan bulat yang menunjukkan lebar minimal dari hasil. Misalnya,% 5d mencetak bilangan bulat dengan setidaknya spasi 5 karakter.

Sah flags dijelaskan dalam tabel berikut -

Nilai	Deskripsi
0	Menentukan untuk menambahkan nol sebagai ganti spasi untuk membuat lebar yang diperlukan.
-	Menentukan untuk meratakan kiri hasil dalam lebar yang ditentukan.
+	Menentukan untuk menambahkan karakter + jika angka tersebut positif (untuk mencocokkan tanda - untuk angka negatif).
'' (spasi)	Menentukan untuk menambahkan spasi ekstra jika angkanya positif (untuk mencocokkan tanda - untuk bilangan negatif).
#	Tidak valid.

Contoh

printf "Hello "
printf "World"
printfn ""
printfn "Hello "
printfn "World"
printf "Hi, I'm %s and I'm a %s" "Rohit" "Medical Student"

printfn "d: %f" 212.098f
printfn "e: %f" 504.768f

printfn "x: %g" 212.098f
printfn "y: %g" 504.768f

printfn "x: %e" 212.098f
printfn "y: %e" 504.768f
printfn "True: %b" true

Ketika Anda mengkompilasi dan menjalankan program, itu menghasilkan output berikut -

Hello World
Hello
World
Hi, I'm Rohit and I'm a Medical Studentd: 212.098000
e: 504.768000
x: 212.098
y: 504.768
x: 2.120980e+002
y: 5.047680e+002
True: true

Kelas Konsol

Kelas ini adalah bagian dari kerangka .NET. Ini mewakili aliran input, output, dan kesalahan standar untuk aplikasi konsol.

Ini menyediakan berbagai metode untuk membaca dan menulis ke dalam konsol. Tabel berikut menunjukkan metode -

metode	Deskripsi
Berbunyi()	Memutar suara bip melalui speaker konsol.
Bip (Int32, Int32)	Memutar suara bip pada frekuensi dan durasi tertentu melalui speaker konsol.
Bersih	Menghapus buffer konsol dan jendela konsol yang sesuai dari informasi tampilan.
MoveBufferArea (Int32, Int32, Int32, Int32, Int32, Int32)	Menyalin area sumber tertentu dari buffer layar ke area tujuan yang ditentukan.
MoveBufferArea (Int32, Int32, Int32, Int32, Int32, Int32, Char, ConsoleColor, ConsoleColor)	Menyalin area sumber tertentu dari buffer layar ke area tujuan yang ditentukan.
OpenStandardError ()	Memperoleh aliran kesalahan standar.
OpenStandardError (Int32)	Memperoleh aliran kesalahan standar, yang disetel ke ukuran buffer yang ditentukan.
OpenStandardInput ()	Memperoleh aliran input standar.
OpenStandardInput (Int32)	Memperoleh aliran input standar, yang disetel ke ukuran buffer yang ditentukan.
OpenStandardOutput ()	Memperoleh aliran keluaran standar.
OpenStandardOutput (Int32)	Memperoleh aliran keluaran standar, yang disetel ke ukuran buffer yang ditentukan.
Baca	Membaca karakter berikutnya dari aliran input standar.
Kunci Baca()	Memperoleh karakter atau tombol fungsi berikutnya yang ditekan oleh pengguna. Tombol yang ditekan ditampilkan di jendela konsol.
ReadKey (Boolean)	Memperoleh karakter atau tombol fungsi berikutnya yang ditekan oleh pengguna. Tombol yang ditekan secara opsional ditampilkan di jendela konsol.
ReadLine	Membaca baris karakter berikutnya dari aliran input standar.
ResetColor	Setel warna konsol latar depan dan latar belakang ke defaultnya.
SetBufferSize	Menyetel tinggi dan lebar area penyangga layar ke nilai yang ditentukan.
SetCursorPosition	Mengatur posisi kursor.
SetError	Setel properti Error ke objek TextWriter tertentu .
SetIn	Setel properti In ke objek TextReader yang ditentukan .
SetOut	Setel properti Out ke objek TextWriter tertentu .
SetWindowPosition	Menetapkan posisi jendela konsol relatif terhadap buffer layar.
SetWindowSize	Menetapkan tinggi dan lebar jendela konsol ke nilai yang ditentukan.
Menulis (Boolean)	Menulis representasi teks dari nilai Boolean yang ditentukan ke aliran keluaran standar.
Tulis (Char)	Menulis nilai karakter Unicode yang ditentukan ke aliran keluaran standar.
Tulis (Char [])	Menulis larik karakter Unicode yang ditentukan ke aliran keluaran standar.
Tulis (Desimal)	Menulis representasi teks dari nilai Desimal yang ditentukan ke aliran keluaran standar.
Menulis (Ganda)	Menulis representasi teks dari nilai titik-mengambang presisi ganda yang ditentukan ke aliran keluaran standar.
Tulis (Int32)	Menulis representasi teks dari nilai integer bertanda tangan 32-bit yang ditentukan ke aliran keluaran standar.
Tulis (Int64)	Menulis representasi teks dari nilai integer bertanda tangan 64-bit yang ditentukan ke aliran keluaran standar.
Tulis (Objek)	Menulis representasi teks dari objek yang ditentukan ke aliran keluaran standar.
Tulis (Tunggal)	Menulis representasi teks dari nilai titik-mengambang presisi-tunggal yang ditentukan ke aliran keluaran standar.
Tulis (String)	Menulis nilai string yang ditentukan ke aliran keluaran standar.
Tulis (UInt32)	Menulis representasi teks dari nilai integer 32-bit unsigned yang ditentukan ke aliran keluaran standar.
Tulis (UInt64)	Menulis representasi teks dari nilai integer 64-bit unsigned yang ditentukan ke aliran keluaran standar.
Tulis (String, Objek)	Menulis representasi teks dari objek yang ditentukan ke aliran keluaran standar menggunakan informasi format yang ditentukan.
Tulis (String, Objek [])	Menulis representasi teks dari larik objek yang ditentukan ke aliran keluaran standar menggunakan informasi format yang ditentukan.
Tulis (Char [], Int32, Int32)	Menulis subarray tertentu dari karakter Unicode ke aliran keluaran standar.
Tulis (String, Objek, Objek)	Menulis representasi teks dari objek yang ditentukan ke aliran keluaran standar menggunakan informasi format yang ditentukan.
Tulis (String, Objek, Objek, Objek)	Menulis representasi teks dari objek yang ditentukan ke aliran keluaran standar menggunakan informasi format yang ditentukan.
Tulis (String, Objek, Objek, Objek, Objek)	Menulis representasi teks dari objek yang ditentukan dan daftar parameter panjang variabel ke aliran keluaran standar menggunakan informasi format yang ditentukan.
WriteLine ()	Menulis terminator baris saat ini ke aliran keluaran standar.
WriteLine (Boolean)	Menulis representasi teks dari nilai Boolean yang ditentukan, diikuti oleh terminator baris saat ini, ke aliran keluaran standar.
WriteLine (Char)	Menulis karakter Unicode yang ditentukan, diikuti oleh terminator baris saat ini, nilai ke aliran keluaran standar.
WriteLine (Char [])	Menulis larik karakter Unicode yang ditentukan, diikuti oleh terminator baris saat ini, ke aliran keluaran standar.
WriteLine (Desimal)	Menulis representasi teks dari nilai Desimal yang ditentukan, diikuti oleh terminator baris saat ini, ke aliran keluaran standar.
WriteLine (Ganda)	Menulis representasi teks dari nilai titik-mengambang presisi ganda yang ditentukan, diikuti oleh terminator baris saat ini, ke aliran keluaran standar.
WriteLine (Int32)	Menulis representasi teks dari nilai integer bertanda tangan 32-bit yang ditentukan, diikuti oleh terminator baris saat ini, ke aliran keluaran standar.
WriteLine (Int64)	Menulis representasi teks dari nilai integer bertanda tangan 64-bit yang ditentukan, diikuti oleh terminator baris saat ini, ke aliran keluaran standar.
WriteLine (Objek)	Menulis representasi teks dari objek yang ditentukan, diikuti oleh terminator baris saat ini, ke aliran keluaran standar.
WriteLine (Tunggal)	Menulis representasi teks dari nilai titik-mengambang presisi tunggal yang ditentukan, diikuti oleh terminator baris saat ini, ke aliran keluaran standar.
WriteLine (String)	Menulis nilai string yang ditentukan, diikuti oleh terminator baris saat ini, ke aliran keluaran standar.
WriteLine (UInt32)	Menulis representasi teks dari nilai integer 32-bit unsigned yang ditentukan, diikuti oleh terminator baris saat ini, ke aliran keluaran standar.
WriteLine (UInt64)	Menulis representasi teks dari nilai integer 64-bit unsigned yang ditentukan, diikuti oleh terminator baris saat ini, ke aliran keluaran standar.
WriteLine (String, Objek)	Menulis representasi teks dari objek yang ditentukan, diikuti oleh terminator baris saat ini, ke aliran keluaran standar menggunakan informasi format yang ditentukan.
WriteLine (String, Objek [])	Menulis representasi teks dari larik objek yang ditentukan, diikuti oleh terminator baris saat ini, ke aliran keluaran standar menggunakan informasi format yang ditentukan.
WriteLine (Char [], Int32, Int32)	Menulis subarray yang ditentukan dari karakter Unicode, diikuti oleh terminator baris saat ini, ke aliran keluaran standar.
WriteLine (String, Objek, Objek)	Menulis representasi teks dari objek yang ditentukan, diikuti oleh terminator baris saat ini, ke aliran keluaran standar menggunakan informasi format yang ditentukan.
WriteLine (String, Objek, Objek, Objek)	Menulis representasi teks dari objek yang ditentukan, diikuti oleh terminator baris saat ini, ke aliran keluaran standar menggunakan informasi format yang ditentukan.
WriteLine (String, Objek, Objek, Objek, Objek)	Menulis representasi teks dari objek yang ditentukan dan daftar parameter panjang variabel, diikuti oleh terminator baris saat ini, ke aliran keluaran standar menggunakan informasi format yang ditentukan.

Contoh berikut menunjukkan membaca dari konsol dan menulis ke dalamnya -

Contoh

open System
let main() =
   Console.Write("What's your name? ")
   let name = Console.ReadLine()
   Console.Write("Hello, {0}\n", name)
   Console.WriteLine(System.String.Format("Big Greetings from {0} and {1}", "TutorialsPoint", "Absoulte Classes"))
   Console.WriteLine(System.String.Format("|{0:yyyy-MMM-dd}|", System.DateTime.Now))
main()

Ketika Anda mengkompilasi dan menjalankan program, itu menghasilkan output berikut -

What's your name? Kabir
Hello, Kabir
Big Greetings from TutorialsPoint and Absoulte Classes
|2015-Jan-05|

Ruang nama System.IO

Namespace System.IO berisi berbagai kelas yang berguna untuk melakukan I / O dasar.

Ini berisi tipe atau kelas yang memungkinkan membaca dan menulis ke file dan aliran data dan tipe yang menyediakan file dasar dan dukungan direktori.

Kelas berguna untuk bekerja dengan sistem file -

Kelas System.IO.File digunakan untuk membuat, menambahkan, dan menghapus file.
Kelas System.IO.Directory digunakan untuk membuat, memindahkan, dan menghapus direktori.
Kelas System.IO.Path melakukan operasi pada string, yang mewakili jalur file.
Kelas System.IO.FileSystemWatcher memungkinkan pengguna untuk mendengarkan direktori untuk perubahan.

Kelas berguna untuk bekerja dengan aliran (urutan byte) -

Kelas System.IO.StreamReader digunakan untuk membaca karakter dari aliran.
Kelas System.IO.StreamWriter digunakan untuk menulis karakter ke aliran.
Kelas System.IO.MemoryStream membuat aliran byte dalam memori.

Tabel berikut menunjukkan semua kelas yang disediakan di namespace bersama dengan deskripsi singkat -

Kelas	Deskripsi
BinaryReader	Membaca tipe data primitif sebagai nilai biner dalam encoding tertentu.
BinaryWriter	Menulis tipe primitif dalam biner ke aliran dan mendukung penulisan string dalam pengkodean tertentu.
BufferedStream	Menambahkan lapisan buffering untuk membaca dan menulis operasi di aliran lain.
Direktori	Memperlihatkan metode statis untuk membuat, memindahkan, dan menghitung melalui direktori dan subdirektori.
DirectoryInfo	Memperlihatkan metode instance untuk membuat, memindahkan, dan menghitung melalui direktori dan subdirektori.
DirectoryNotFoundException	Pengecualian yang muncul ketika bagian dari file atau direktori tidak dapat ditemukan.
DriveInfo	Memberikan akses ke informasi di drive.
DriveNotFoundException	Pengecualian yang dilontarkan saat mencoba mengakses drive atau share yang tidak tersedia.
EndOfStreamException	Pengecualian yang muncul saat membaca diupayakan melewati akhir aliran.
ErrorEventArgs	Menyediakan data untuk peristiwa FileSystemWatcher.Error.
Mengajukan	Menyediakan metode statis untuk membuat, menyalin, menghapus, memindahkan, dan membuka satu file, dan membantu pembuatan objek FileStream.
FileFormatException	Pengecualian yang muncul ketika file input atau aliran data yang seharusnya sesuai dengan spesifikasi format file tertentu salah format.
FileInfo	Menyediakan properti dan metode instance untuk pembuatan, penyalinan, penghapusan, pemindahan, dan pembukaan file, dan bantu dalam pembuatan objek FileStream.
FileLoadException	Pengecualian yang muncul saat rakitan terkelola ditemukan tetapi tidak dapat dimuat.
FileNotFoundException	Pengecualian yang muncul saat upaya untuk mengakses file yang tidak ada di disk gagal.
FileStream	Memaparkan Stream di sekitar file, mendukung operasi baca dan tulis sinkron dan asinkron.
FileSystemEventArgs	Menyediakan data untuk acara direktori - Diubah, Dibuat, Dihapus.
FileSystemInfo	Menyediakan kelas dasar untuk objek FileInfo dan DirectoryInfo.
FileSystemWatcher	Mendengarkan pemberitahuan perubahan sistem file dan memunculkan peristiwa ketika direktori, atau file dalam direktori, berubah.
InternalBufferOverflowException	Pengecualian muncul saat buffer internal meluap.
InvalidDataException	Pengecualian yang muncul ketika aliran data dalam format yang tidak valid.
IODescriptionAttribute	Menetapkan deskripsi yang dapat ditampilkan desainer visual saat mereferensikan acara, perluasan, atau properti.
IOException	Pengecualian yang muncul saat terjadi kesalahan I / O.
MemoryStream	Membuat aliran yang penyimpanan pendukungnya adalah memori.
Jalan	Melakukan operasi pada instance String yang berisi informasi jalur file atau direktori. Operasi ini dilakukan dengan cara lintas platform.
PathTooLongException	Pengecualian yang muncul saat jalur atau nama file lebih panjang dari panjang maksimum yang ditentukan sistem.
PipeException	Dilempar saat terjadi kesalahan dalam pipa bernama.
RenamedEventArgs	Memberikan data untuk acara Berganti Nama.
Aliran	Menyediakan tampilan umum dari urutan byte. Ini adalah kelas abstrak.
StreamReader	Menerapkan TextReader yang membaca karakter dari aliran byte dalam pengkodean tertentu.
StreamWriter	Menerapkan Penulis Teks untuk menulis karakter ke aliran dalam pengkodean tertentu. Untuk menelusuri kode sumber .NET Framework untuk jenis ini, lihat Sumber Referensi.
StringReader	Menerapkan TextReader yang membaca dari string.
Penulis String	Menerapkan Penulis Teks untuk menulis informasi ke string. Informasi disimpan dalam StringBuilder yang mendasari.
TextReader	Mewakili pembaca yang dapat membaca rangkaian karakter yang berurutan.
Penulis Teks	Mewakili seorang penulis yang dapat menulis serangkaian karakter berurutan. Kelas ini abstrak.
UnmanagedMemoryAccessor	Memberikan akses acak ke blok memori yang tidak dikelola dari kode yang dikelola.
UnmanagedMemoryStream	Menyediakan akses ke blok memori yang tidak dikelola dari kode yang dikelola.
WindowsRuntimeStorageExtensions	Berisi metode ekstensi untuk antarmuka IStorageFile dan IStorageFolder di Windows Runtime saat mengembangkan aplikasi Windows Store.
WindowsRuntimeStreamExtensions	Berisi metode ekstensi untuk mengonversi antara aliran di Windows Runtime dan aliran terkelola di .NET untuk aplikasi Windows Store.

Contoh

Contoh berikut membuat file bernama test.txt, menulis pesan di sana, membaca teks dari file dan mencetaknya di konsol.

Note - Jumlah kode yang diperlukan untuk melakukan ini ternyata lebih sedikit!

open System.IO // Name spaces can be opened just as modules
File.WriteAllText("test.txt", "Hello There\n Welcome to:\n Tutorials Point")
let msg = File.ReadAllText("test.txt")
printfn "%s" msg

Ketika Anda mengkompilasi dan menjalankan program, itu menghasilkan output berikut -

Hello There
Welcome to:
Tutorials Point

Generik memungkinkan Anda untuk menunda spesifikasi tipe data elemen pemrograman di kelas atau metode, hingga benar-benar digunakan dalam program. Dengan kata lain, obat generik memungkinkan Anda untuk menulis kelas atau metode yang dapat bekerja dengan tipe data apa pun.

Anda menulis spesifikasi untuk kelas atau metode, dengan parameter pengganti untuk tipe data. Ketika kompilator menemukan konstruktor untuk kelas atau panggilan fungsi untuk metode tersebut, ia menghasilkan kode untuk menangani tipe data tertentu.

Di F #, nilai fungsi, metode, properti, dan tipe agregat seperti kelas, catatan, dan serikat yang terdiskriminasi dapat bersifat umum.

Konstruksi umum berisi setidaknya satu jenis parameter. Fungsi dan tipe generik memungkinkan Anda untuk menulis kode yang bekerja dengan berbagai tipe tanpa mengulang kode untuk setiap tipe.

Sintaksis

Sintaks untuk menulis konstruksi generik adalah sebagai berikut -

// Explicitly generic function.
let function-name<type-parameters> parameter-list =
   function-body

// Explicitly generic method.
[ static ] member object-identifer.method-name<type-parameters> parameter-list [ return-type ] =
   method-body

// Explicitly generic class, record, interface, structure,
// or discriminated union.
type type-name<type-parameters> type-definition

Contoh

(* Generic Function *)
let printFunc<'T> x y =
   printfn "%A, %A" x y

printFunc<float> 10.0 20.0

Ketika Anda mengkompilasi dan menjalankan program, itu menghasilkan output berikut -

10.0, 20.0

Anda juga dapat membuat fungsi generik dengan menggunakan sintaks tanda kutip tunggal -

(* Generic Function *)
let printFunction (x: 'a) (y: 'a) =
   printfn "%A %A" x y

printFunction 10.0 20.0

Ketika Anda mengkompilasi dan menjalankan program, itu menghasilkan output berikut -

10.0 20.0

Harap dicatat bahwa ketika Anda menggunakan fungsi atau metode umum, Anda mungkin tidak perlu menentukan argumen tipe. Namun, jika terjadi ambiguitas, Anda dapat memberikan argumen tipe dalam tanda kurung siku seperti yang kita lakukan pada contoh pertama.

Jika Anda memiliki lebih dari satu jenis, maka Anda memisahkan beberapa jenis argumen dengan koma.

Kelas Generik

Seperti fungsi generik, Anda juga bisa menulis kelas generik. Contoh berikut menunjukkan ini -

type genericClass<'a> (x: 'a) =
   do printfn "%A" x

let gr = new genericClass<string>("zara")
let gs = genericClass( seq { for i in 1 .. 10 -> (i, i*i) } )

Ketika Anda mengkompilasi dan menjalankan program, itu menghasilkan output berikut -

"zara"
seq [(1, 1); (2, 4); (3, 9); (4, 16); ...]

Delegasi adalah variabel jenis referensi yang menyimpan referensi ke suatu metode. Referensi dapat diubah saat runtime. Delegasi F # mirip dengan pointer ke fungsi, di C atau C ++.

Mendeklarasikan Delegasi

Deklarasi delegasi menentukan metode yang bisa direferensikan oleh delegasi. Seorang delegasi dapat merujuk ke sebuah metode, yang memiliki tanda tangan yang sama dengan yang dimiliki oleh delegasi tersebut.

Sintaks untuk deklarasi delegasi adalah -

type delegate-typename = delegate of type1 -> type2

Misalnya, pertimbangkan para delegasi -

// Delegate1 works with tuple arguments.
type Delegate1 = delegate of (int * int) -> int
// Delegate2 works with curried arguments.
type Delegate2 = delegate of int * int -> int

Kedua delegasi dapat digunakan untuk mereferensikan metode apa pun yang memiliki dua parameter int dan mengembalikan variabel tipe int .

Dalam sintaks -

type1 mewakili tipe argumen.
type2 mewakili tipe pengembalian.

Harap diperhatikan -

Tipe argumen secara otomatis diambil.
Delegasi dapat dilampirkan ke nilai fungsi, dan metode statis atau contoh.
Nilai fungsi F # bisa diteruskan secara langsung sebagai argumen untuk mendelegasikan konstruktor.
Untuk metode statis, delegasi dipanggil dengan menggunakan nama kelas dan metode. Untuk metode instance, nama instance objek dan metode digunakan.
Metode Panggil pada tipe delegasi memanggil fungsi yang dienkapsulasi.
Selain itu, delegasi dapat dikirimkan sebagai nilai fungsi dengan mereferensikan nama metode Panggil tanpa tanda kurung.

Contoh berikut menunjukkan konsep -

Contoh

type Myclass() =
   static member add(a : int, b : int) =
      a + b
   static member sub (a : int) (b : int) =
      a - b
   member x.Add(a : int, b : int) =
      a + b
   member x.Sub(a : int) (b : int) =
      a - b

// Delegate1 works with tuple arguments.
type Delegate1 = delegate of (int * int) -> int
// Delegate2 works with curried arguments.
type Delegate2 = delegate of int * int -> int

let InvokeDelegate1 (dlg : Delegate1) (a : int) (b: int) =
   dlg.Invoke(a, b)
let InvokeDelegate2 (dlg : Delegate2) (a : int) (b: int) =
   dlg.Invoke(a, b)

// For static methods, use the class name, the dot operator, and the
// name of the static method.
let del1 : Delegate1 = new Delegate1( Myclass.add )
let del2 : Delegate2 = new Delegate2( Myclass.sub )

let mc = Myclass()
// For instance methods, use the instance value name, the dot operator, and the instance method name.

let del3 : Delegate1 = new Delegate1( mc.Add )
let del4 : Delegate2 = new Delegate2( mc.Sub )

for (a, b) in [ (400, 200); (100, 45) ] do
   printfn "%d + %d = %d" a b (InvokeDelegate1 del1 a b)
   printfn "%d - %d = %d" a b (InvokeDelegate2 del2 a b)
   printfn "%d + %d = %d" a b (InvokeDelegate1 del3 a b)
   printfn "%d - %d = %d" a b (InvokeDelegate2 del4 a b)

Ketika Anda mengkompilasi dan menjalankan program, itu menghasilkan output berikut -

400 + 200 = 600
400 - 200 = 200
400 + 200 = 600
400 - 200 = 200
100 + 45 = 145
100 - 45 = 55
100 + 45 = 145
100 - 45 = 55

Enumerasi adalah sekumpulan konstanta integer bernama.

Di F #, enumerations, juga dikenal sebagai enums,adalah tipe integral di mana label ditetapkan ke subset nilai. Anda dapat menggunakannya sebagai pengganti literal agar kode lebih mudah dibaca dan dipelihara.

Menyatakan Pencacahan

Sintaks umum untuk mendeklarasikan enumerasi adalah -

type enum-name =
   | value1 = integer-literal1
   | value2 = integer-literal2
...

Contoh berikut menunjukkan penggunaan enumerasi -

Contoh

// Declaration of an enumeration.
type Days =
   | Sun = 0
   | Mon = 1
   | Tues = 2
   | Wed = 3
   | Thurs = 4
   | Fri = 5
   | Sat = 6

// Use of an enumeration.
let weekend1 : Days = Days.Sat
let weekend2 : Days = Days.Sun
let weekDay1 : Days = Days.Mon

printfn "Monday: %A" weekDay1
printfn "Saturday: %A" weekend1
printfn "Sunday: %A" weekend2

Ketika Anda mengkompilasi dan menjalankan program, itu menghasilkan output berikut -

Monday: Mon
Saturday: Sat
Sunday: Sun

Pencocokan pola memungkinkan Anda untuk "membandingkan data dengan struktur atau struktur logis, menguraikan data menjadi bagian-bagian penyusun, atau mengekstrak informasi dari data dengan berbagai cara".

Dengan kata lain, ini memberikan cara yang lebih fleksibel dan kuat untuk menguji data terhadap serangkaian kondisi dan melakukan beberapa komputasi berdasarkan kondisi yang dipenuhi.

Secara konseptual, ini seperti serangkaian pernyataan jika… maka.

Sintaksis

Dalam istilah tingkat tinggi, pencocokan pola mengikuti sintaks ini di F # -

match expr with
| pat1 - result1
| pat2 -> result2
| pat3 when expr2 -> result3
| _ -> defaultResult

Where,

Each | symbol defines a condition.
The -> symbol means "if the condition is true, return this value...".
The _ symbol provides the default pattern, meaning that it matches all other things like a wildcard.

Example 1

The following example, calculates the Fibonacci numbers using pattern matching syntax −

let rec fib n =
   match n with
   | 0 -> 0
   | 1 -> 1
   | _ -> fib (n - 1) + fib (n - 2)
for i = 1 to 10 do
   printfn "Fibonacci %d: %d" i (fib i)

When you compile and execute the program, it yields the following output −

Fibonacci 1: 1
Fibonacci 2: 1
Fibonacci 3: 2
Fibonacci 4: 3
Fibonacci 5: 5
Fibonacci 6: 8
Fibonacci 7: 13
Fibonacci 8: 21
Fibonacci 9: 34
Fibonacci 10: 55

You can also chain together multiple conditions, which return the same value. For example −

Example 2

let printSeason month =
   match month with
   | "December" | "January" | "February" -> printfn "Winter"
   | "March" | "April" -> printfn "Spring"
   | "May" | "June" -> printfn "Summer"
   | "July" | "August" -> printfn "Rainy"
   | "September" | "October" | "November" -> printfn "Autumn"
   | _ -> printfn "Season depends on month!"

printSeason "February"
printSeason "April"
printSeason "November"
printSeason "July"

When you compile and execute the program, it yields the following output −

Winter
Spring
Autumn
Rainy

Pattern Matching Functions

F# allows you to write pattern matching functions using the function keyword −

let getRate = function
   | "potato" -> 10.00
   | "brinjal" -> 20.50
   | "cauliflower" -> 21.00
   | "cabbage" -> 8.75
   | "carrot" -> 15.00
   | _ -> nan (* nan is a special value meaning "not a number" *)

printfn "%g"(getRate "potato")
printfn "%g"(getRate "brinjal")
printfn "%g"(getRate "cauliflower")
printfn "%g"(getRate "cabbage")
printfn "%g"(getRate "carrot")

When you compile and execute the program, it yields the following output −

Adding Filters or Guards to Patterns

You can add filters, or guards, to patterns using the when keyword.

Example 1

let sign = function
   | 0 -> 0
   | x when x < 0 -> -1
   | x when x > 0 -> 1

printfn "%d" (sign -20)
printfn "%d" (sign 20)
printfn "%d" (sign 0)

When you compile and execute the program, it yields the following output −

-1
1
0

Example 2

let compareInt x =
   match x with
   | (var1, var2) when var1 > var2 -> printfn "%d is greater than %d" var1 var2
   | (var1, var2) when var1 < var2 -> printfn "%d is less than %d" var1 var2
   | (var1, var2) -> printfn "%d equals %d" var1 var2

compareInt (11,25)
compareInt (72, 10)
compareInt (0, 0)

When you compile and execute the program, it yields the following output −

11 is less than 25
72 is greater than 10
0 equals 0

Pattern Matching with Tuples

The following example demonstrates the pattern matching with tuples −

let greeting (name, subject) =
   match (name, subject) with
   | ("Zara", _) -> "Hello, Zara"
   | (name, "English") -> "Hello, " + name + " from the department of English"
   | (name, _) when subject.StartsWith("Comp") -> "Hello, " + name + " from the department of Computer Sc."
   | (_, "Accounts and Finance") -> "Welcome to the department of Accounts and Finance!"
   | _ -> "You are not registered into the system"

printfn "%s" (greeting ("Zara", "English"))
printfn "%s" (greeting ("Raman", "Computer Science"))
printfn "%s" (greeting ("Ravi", "Mathematics"))

When you compile and execute the program, it yields the following output −

Hello, Zara
Hello, Raman from the department of Computer Sc.
You are not registered into the system

Pattern Matching with Records

The following example demonstrates pattern matching with records −

type Point = { x: float; y: float }
let evaluatePoint (point: Point) =
   match point with
   | { x = 0.0; y = 0.0 } -> printfn "Point is at the origin."
   | { x = xVal; y = 0.0 } -> printfn "Point is on the x-axis. Value is %f." xVal
   | { x = 0.0; y = yVal } -> printfn "Point is on the y-axis. Value is %f." yVal
   | { x = xVal; y = yVal } -> printfn "Point is at (%f, %f)." xVal yVal

evaluatePoint { x = 0.0; y = 0.0 }
evaluatePoint { x = 10.0; y = 0.0 }
evaluatePoint { x = 0.0; y = 10.0 }
evaluatePoint { x = 10.0; y = 10.0 }

When you compile and execute the program, it yields the following output −

Point is at the origin.
Point is on the x-axis. Value is 10.000000.
Point is on the y-axis. Value is 10.000000.
Point is at (10.000000, 10.000000).

An exception is a problem that arises during the execution of a program. An F# exception is a response to an exceptional circumstance that arises while a program is running, such as an attempt to divide by zero.

Exceptions provide a way to transfer control from one part of a program to another. F# exception handling provides the following constructs −

Construct	Description
raise expr	Raises the given exception.
failwith expr	Raises the System.Exception exception.
try expr with rules	Catches expressions matching the pattern rules.
try expr finally expr	Execution the finally expression both when the computation is successful and when an exception is raised.
\| :? ArgumentException	A rule matching the given .NET exception type.
\| :? ArgumentException as e	A rule matching the given .NET exception type, binding the name e to the exception object value.
\| Failure(msg) → expr	A rule matching the given data-carrying F# exception.
\| exn → expr	A rule matching any exception, binding the name exn to the exception object value.
\| exn when expr → expr	A rule matching the exception under the given condition, binding the name exn to the exception object value.

Let us start with the basic syntax of Exception Handling.

Syntax

Basic syntax for F# exception handling block is −

exception exception-type of argument-type

Where,

exception-type is the name of a new F# exception type.
argument-type represents the type of an argument that can be supplied when you raise an exception of this type.
Multiple arguments can be specified by using a tuple type for argument-type.

Itu try...with ekspresi digunakan untuk penanganan pengecualian dalam bahasa F #.

Sintaks untuk percobaan… dengan ekspresi adalah -

try
   expression1
with
   | pattern1 -> expression2
   | pattern2 -> expression3
...

Itu try...finally ekspresi memungkinkan Anda untuk mengeksekusi kode pembersihan meskipun blok kode memunculkan pengecualian.

Sintaks untuk percobaan ... akhirnya ekspresi adalah -

try
   expression1
finally
   expression2

Itu raisefungsi digunakan untuk menunjukkan bahwa telah terjadi kesalahan atau kondisi luar biasa. Ini juga menangkap informasi tentang kesalahan dalam objek pengecualian.

Sintaks untuk fungsi kenaikan adalah -

raise (expression)

Itu failwith fungsi menghasilkan pengecualian F #.

Sintaks untuk fungsi failwith adalah -

failwith error-message-string

Itu invalidArg fungsi menghasilkan pengecualian argumen.

invalidArg parameter-name error-message-string

Contoh Penanganan Pengecualian

Contoh 1

Program berikut menunjukkan penanganan pengecualian dasar dengan percobaan sederhana… dengan blok -

let divisionprog x y =
   try
      Some (x / y)
   with
      | :? System.DivideByZeroException -> printfn "Division by zero!"; None

let result1 = divisionprog 100 0

Ketika Anda mengkompilasi dan menjalankan program, itu menghasilkan output berikut -

Division by zero!

Contoh 2

F # menyediakan exceptionjenis untuk mendeklarasikan pengecualian. Anda dapat menggunakan jenis pengecualian secara langsung di filter di atry...with ekspresi.

Contoh berikut menunjukkan ini -

exception Error1 of string
// Using a tuple type as the argument type.
exception Error2 of string * int

let myfunction x y =
   try
      if x = y then raise (Error1("Equal Number Error"))
      else raise (Error2("Error Not detected", 100))
   with
      | Error1(str) -> printfn "Error1 %s" str
      | Error2(str, i) -> printfn "Error2 %s %d" str i
myfunction 20 10
myfunction 5 5

Ketika Anda mengkompilasi dan menjalankan program, itu menghasilkan output berikut -

Error2 Error Not detected 100
Error1 Equal Number Error

Contoh 3

Contoh berikut menunjukkan penanganan pengecualian bersarang -

exception InnerError of string
exception OuterError of string

let func1 x y =
   try
      try
         if x = y then raise (InnerError("inner error"))
         else raise (OuterError("outer error"))
      with
         | InnerError(str) -> printfn "Error:%s" str
   finally
      printfn "From the finally block."

let func2 x y =
   try
      func1 x y
   with
      | OuterError(str) -> printfn "Error: %s" str

func2 100 150
func2 100 100
func2 100 120

Ketika Anda mengkompilasi dan menjalankan program, itu menghasilkan output berikut -

From the finally block.
Error: outer error
Error:inner error
From the finally block.
From the finally block.
Error: outer error

Contoh 4

Fungsi berikut mendemonstrasikan failwith fungsi -

let divisionFunc x y =
   if (y = 0) then failwith "Divisor cannot be zero."
   else
      x / y

let trydivisionFunc x y =
   try
      divisionFunc x y
   with
      | Failure(msg) -> printfn "%s" msg; 0

let result1 = trydivisionFunc 100 0
let result2 = trydivisionFunc 100 4
printfn "%A" result1
printfn "%A" result2

Ketika Anda mengkompilasi dan menjalankan program, itu menghasilkan output berikut -

Divisor cannot be zero.
0
25

Contoh 5

Itu invalidArgfungsi menghasilkan pengecualian argumen. Program berikut menunjukkan ini -

let days = [| "Sunday"; "Monday"; "Tuesday"; "Wednesday"; "Thursday"; "Friday"; "Saturday" |]
let findDay day =
   if (day > 7 || day < 1)
      then invalidArg "day" (sprintf "You have entered %d." day)
   days.[day - 1]

printfn "%s" (findDay 1)
printfn "%s" (findDay 5)
printfn "%s" (findDay 9)

Ketika Anda mengkompilasi dan menjalankan program, itu menghasilkan output berikut -

Sunday
Thursday
Unhandled Exception:
System.ArgumentException: You have entered 9.
…

Beberapa informasi lain tentang file dan variabel yang menyebabkan kesalahan dalam sistem juga akan ditampilkan, tergantung pada sistemnya.

Kelas adalah tipe yang mewakili objek yang dapat memiliki properti, metode, dan kejadian. 'Mereka digunakan untuk memodelkan tindakan, proses, dan entitas konseptual apa pun dalam aplikasi'.

Sintaksis

Sintaks untuk mendefinisikan tipe kelas adalah sebagai berikut -

// Class definition:
type [access-modifier] type-name [type-params] [access-modifier] ( parameter-list ) [ as identifier ] =
   [ class ]
      [ inherit base-type-name(base-constructor-args) ]
      [ let-bindings ]
      [ do-bindings ]
      member-list
      ...
   [ end ]

// Mutually recursive class definitions:
type [access-modifier] type-name1 ...
and [access-modifier] type-name2 ...
...

Dimana,

Itu type-nameadalah pengenal yang valid. Pengubah akses default untuk ini adalahpublic.
Itu type-params menjelaskan parameter tipe generik opsional.
Itu parameter-listmenjelaskan parameter konstruktor. Pengubah akses default untuk konstruktor utama adalahpublic.
Itu identifier digunakan dengan opsional as kata kunci memberi nama pada variabel contoh, atau self-identifier, yang dapat digunakan dalam definisi tipe untuk merujuk ke instance tipe.
Itu inherit kata kunci memungkinkan Anda untuk menentukan kelas dasar untuk sebuah kelas.
Itu let binding memungkinkan Anda untuk mendeklarasikan bidang atau nilai fungsi lokal ke kelas.
Itu do-bindings bagian termasuk kode untuk dieksekusi pada konstruksi objek.
Itu member-list terdiri dari konstruktor tambahan, deklarasi metode instance dan statis, deklarasi antarmuka, binding abstrak, serta deklarasi properti dan peristiwa.
Kata kuncinya class dan end yang menandai awal dan akhir definisi bersifat opsional.

Pembina Kelas

Konstruktor adalah kode yang membuat instance dari tipe kelas.

Di F #, konstruktor bekerja sedikit berbeda dari bahasa .Net lainnya. Dalam definisi kelas, argumen dari konstruktor utama dideskripsikan sebagai daftar parameter.

Badan konstruktor terdiri dari let dan do binding.

Anda dapat menambahkan konstruktor tambahan dengan menggunakan kata kunci baru untuk menambahkan anggota -

new (argument-list) = constructor-body

Contoh berikut menggambarkan konsep -

Contoh

Program berikut membuat kelas garis bersama dengan konstruktor yang menghitung panjang garis saat objek kelas dibuat -

type Line = class
   val X1 : float
   val Y1 : float
   val X2 : float
   val Y2 : float

   new (x1, y1, x2, y2) as this =
      { X1 = x1; Y1 = y1; X2 = x2; Y2 = y2;}
      then
         printfn " Creating Line: {(%g, %g), (%g, %g)}\nLength: %g"
            this.X1 this.Y1 this.X2 this.Y2 this.Length

   member x.Length =
      let sqr x = x * x
      sqrt(sqr(x.X1 - x.X2) + sqr(x.Y1 - x.Y2) )
end
let aLine = new Line(1.0, 1.0, 4.0, 5.0)

Ketika Anda mengkompilasi dan menjalankan program, itu menghasilkan output berikut -

Creating Line: {(1, 1), (4, 5)}
Length: 5

Biarkan Bindings

Binding let dalam definisi kelas memungkinkan Anda untuk menentukan bidang privat dan fungsi privat untuk kelas F #.

type Greetings(name) as gr =
   let data = name
   do
      gr.PrintMessage()
   member this.PrintMessage() =
      printf "Hello %s\n" data
let gtr = new Greetings("Zara")

Ketika Anda mengkompilasi dan menjalankan program, itu menghasilkan output berikut -

Hello Zara

Harap perhatikan penggunaan gr pengidentifikasi diri untuk kelas Salam .

Struktur di F # adalah tipe data tipe nilai. Ini membantu Anda membuat variabel tunggal, menyimpan data terkait dari berbagai tipe data. Itustruct kata kunci digunakan untuk membuat struktur.

Sintaksis

Sintaks untuk mendefinisikan struktur adalah sebagai berikut -

[ attributes ]
type [accessibility-modifier] type-name =
   struct
      type-definition-elements
   end
// or
[ attributes ]
[<StructAttribute>]
type [accessibility-modifier] type-name =
   type-definition-elements

Ada dua sintaks. Sintaks pertama paling banyak digunakan, karena, jika Anda menggunakanstruct dan end kata kunci, Anda dapat menghilangkan StructAttribute atribut.

Elemen definisi struktur menyediakan -

Deklarasi dan definisi anggota.
Konstruktor dan bidang yang dapat berubah dan tidak berubah.
Anggota dan implementasi antarmuka.

Tidak seperti kelas, struktur tidak dapat diwariskan dan tidak dapat berisi biarkan atau lakukan binding. Karena, struktur tidak membiarkan ikatan; Anda harus mendeklarasikan bidang dalam struktur dengan menggunakanval kata kunci.

Saat Anda menentukan bidang dan jenisnya menggunakan valkata kunci, Anda tidak dapat menginisialisasi nilai bidang, sebagai gantinya mereka diinisialisasi ke nol atau nol. Jadi untuk struktur yang memiliki konstruktor implisit, makaval deklarasi dianotasi dengan DefaultValue atribut.

Contoh

Program berikut membuat struktur garis bersama dengan konstruktor. Program menghitung panjang garis menggunakan struktur -

type Line = struct
   val X1 : float
   val Y1 : float
   val X2 : float
   val Y2 : float

   new (x1, y1, x2, y2) =
      {X1 = x1; Y1 = y1; X2 = x2; Y2 = y2;}
end
let calcLength(a : Line)=
   let sqr a = a * a
   sqrt(sqr(a.X1 - a.X2) + sqr(a.Y1 - a.Y2) )

let aLine = new Line(1.0, 1.0, 4.0, 5.0)
let length = calcLength aLine
printfn "Length of the Line: %g " length

Ketika Anda mengkompilasi dan menjalankan program, itu menghasilkan output berikut -

Length of the Line: 5

Anda dapat mendefinisikan ulang atau membebani sebagian besar operator bawaan yang tersedia di F #. Dengan demikian seorang programmer dapat menggunakan operator dengan tipe yang ditentukan pengguna juga.

Operator adalah fungsi dengan nama khusus, diapit tanda kurung. Mereka harus didefinisikan sebagai anggota kelas statis. Seperti fungsi lainnya, operator yang kelebihan beban memiliki tipe kembalian dan daftar parameter.

Contoh berikut, menunjukkan operator + pada bilangan kompleks -

//overloading + operator
static member (+) (a : Complex, b: Complex) =
Complex(a.x + b.x, a.y + b.y)

Fungsi di atas mengimplementasikan operator penambahan (+) untuk kompleks kelas yang ditentukan pengguna. Ia menambahkan atribut dari dua objek dan mengembalikan objek Kompleks yang dihasilkan.

Penerapan Operator Overloading

Program berikut menunjukkan implementasi lengkap -

//implementing a complex class with +, and - operators
//overloaded
type Complex(x: float, y : float) =
   member this.x = x
   member this.y = y
   //overloading + operator
   static member (+) (a : Complex, b: Complex) =
      Complex(a.x + b.x, a.y + b.y)

   //overloading - operator
   static member (-) (a : Complex, b: Complex) =
      Complex(a.x - b.x, a.y - b.y)

   // overriding the ToString method
   override this.ToString() =
      this.x.ToString() + " " + this.y.ToString()

//Creating two complex numbers
let c1 = Complex(7.0, 5.0)
let c2 = Complex(4.2, 3.1)

// addition and subtraction using the
//overloaded operators
let c3 = c1 + c2
let c4 = c1 - c2

//printing the complex numbers
printfn "%s" (c1.ToString())
printfn "%s" (c2.ToString())
printfn "%s" (c3.ToString())
printfn "%s" (c4.ToString())

Ketika Anda mengkompilasi dan menjalankan program, itu menghasilkan output berikut -

7 5
4.2 3.1
11.2 8.1
2.8 1.9

Salah satu konsep terpenting dalam pemrograman berorientasi objek adalah tentang pewarisan. Inheritance memungkinkan kita untuk mendefinisikan kelas dalam istilah kelas lain, yang membuatnya lebih mudah untuk membuat dan memelihara aplikasi. Ini juga memberikan kesempatan untuk menggunakan kembali fungsionalitas kode dan waktu implementasi yang cepat.

Saat membuat kelas, daripada menulis anggota data dan fungsi anggota yang benar-benar baru, pemrogram dapat menetapkan bahwa kelas baru harus mewarisi anggota kelas yang sudah ada. Kelas yang sudah ada ini disebut kelas dasar, dan kelas baru disebut sebagai kelas turunan.

Ide pewarisan mengimplementasikan hubungan IS-A. Misal, mamalia IS A binatang, anjing IS-A mamalia maka anjing IS-A binatang begitu juga dan seterusnya.

Kelas Dasar dan Sub Kelas

Subclass diturunkan dari kelas dasar, yang sudah ditentukan. Subkelas mewarisi anggota kelas dasar, serta memiliki anggota sendiri.

Sebuah subclass didefinisikan menggunakan inherit kata kunci seperti yang ditunjukkan di bawah ini -

type MyDerived(...) =
   inherit MyBase(...)

Dalam F #, sebuah kelas dapat memiliki paling banyak satu kelas dasar langsung. Jika Anda tidak menentukan kelas dasar dengan menggunakaninherit kata kunci, kelas secara implisit mewarisi dari Object.

Harap diperhatikan -

Metode dan anggota kelas dasar tersedia untuk pengguna kelas turunan seperti anggota langsung dari kelas turunan.
Biarkan binding dan parameter konstruktor bersifat privat ke kelas dan, oleh karena itu, tidak dapat diakses dari kelas turunan.
Kata kunci basemengacu pada instance kelas dasar. Ini digunakan seperti pengenal diri.

Contoh

type Person(name) =
   member x.Name = name
   member x.Greet() = printfn "Hi, I'm %s" x.Name

type Student(name, studentID : int) =
   inherit Person(name)
   let mutable _GPA = 0.0
   member x.StudentID = studentID
   member x.GPA
      with get() = _GPA
      and set value = _GPA <- value

type Teacher(name, expertise : string) =
   inherit Person(name)

   let mutable _salary = 0.0
   member x.Salary
      with get() = _salary
      and set value = _salary <- value
   member x.Expertise = expertise

//using the subclasses
let p = new Person("Mohan")
let st = new Student("Zara", 1234)
let tr = new Teacher("Mariam", "Java")

p.Greet()
st.Greet()
tr.Greet()

Ketika Anda mengkompilasi dan menjalankan program, itu menghasilkan output berikut -

Hi, I'm Mohan
Hi, I'm Zara
Hi, I'm Mariam

Metode Utama

Anda dapat mengganti perilaku default metode kelas dasar dan menerapkannya secara berbeda di subkelas atau kelas turunan.

Metode di F # tidak dapat diganti secara default.

Untuk mengganti metode dalam kelas turunan, Anda harus mendeklarasikan metode Anda sebagai dapat diganti menggunakan abstract dan default kata kunci sebagai berikut -

type Person(name) =
   member x.Name = name
   abstract Greet : unit -> unit
   default x.Greet() = printfn "Hi, I'm %s" x.Name

Sekarang, Greet metode kelas Person dapat diganti dalam kelas turunan. Contoh berikut menunjukkan ini -

Contoh

type Person(name) =
   member x.Name = name
   abstract Greet : unit -> unit
   default x.Greet() = printfn "Hi, I'm %s" x.Name

type Student(name, studentID : int) =
   inherit Person(name)

   let mutable _GPA = 0.0

   member x.StudentID = studentID
   member x.GPA
      with get() = _GPA
      and set value = _GPA <- value
   override x.Greet() = printfn "Student %s" x.Name

type Teacher(name, expertise : string) =
   inherit Person(name)
   let mutable _salary = 0.0
   member x.Salary
      with get() = _salary
      and set value = _salary <- value

   member x.Expertise = expertise
   override x.Greet() = printfn "Teacher %s." x.Name

//using the subclasses
let p = new Person("Mohan")
let st = new Student("Zara", 1234)
let tr = new Teacher("Mariam", "Java")

//default Greet
p.Greet()

//Overriden Greet
st.Greet()
tr.Greet()

Ketika Anda mengkompilasi dan menjalankan program, itu menghasilkan output berikut -

Hi, I'm Mohan
Student Zara
Teacher Mariam.

Kelas Abstrak

Terkadang Anda perlu memberikan implementasi objek yang tidak lengkap, yang seharusnya tidak diimplementasikan dalam kenyataan. Kemudian, beberapa programmer lain harus membuat subclass dari kelas abstrak untuk implementasi lengkap.

Misalnya, kelas Person tidak diperlukan dalam Sistem Manajemen Sekolah. Namun, kelas Murid atau Guru akan dibutuhkan. Dalam kasus seperti itu, Anda dapat mendeklarasikan kelas Person sebagai kelas abstrak.

Itu AbstractClass atribut memberi tahu kompiler bahwa kelas tersebut memiliki beberapa anggota abstrak.

Anda tidak dapat membuat instance dari kelas abstrak karena kelas tersebut belum diterapkan sepenuhnya.

Contoh berikut menunjukkan ini -

Contoh

[<AbstractClass>]
type Person(name) =
   member x.Name = name
   abstract Greet : unit -> unit

type Student(name, studentID : int) =
   inherit Person(name)
   let mutable _GPA = 0.0
   member x.StudentID = studentID
   member x.GPA
      with get() = _GPA
      and set value = _GPA <- value
   override x.Greet() = printfn "Student %s" x.Name

type Teacher(name, expertise : string) =
   inherit Person(name)
   let mutable _salary = 0.0
   member x.Salary
      with get() = _salary
      and set value = _salary <- value
   member x.Expertise = expertise
   override x.Greet() = printfn "Teacher %s." x.Name

let st = new Student("Zara", 1234)
let tr = new Teacher("Mariam", "Java")

//Overriden Greet
st.Greet()
tr.Greet()

Ketika Anda mengkompilasi dan menjalankan program, itu menghasilkan output berikut -

Student Zara
Teacher Mariam.

Antarmuka menyediakan cara abstrak untuk menulis detail implementasi kelas. Ini adalah template yang mendeklarasikan metode yang harus diterapkan dan diekspos oleh kelas secara publik.

Sintaksis

Antarmuka menentukan kumpulan anggota terkait yang diimplementasikan oleh kelas lain. Ini memiliki sintaks berikut -

// Interface declaration:
[ attributes ]
type interface-name =
   [ interface ]
      [ inherit base-interface-name ...]
      abstract member1 : [ argument-types1 -> ] return-type1
      abstract member2 : [ argument-types2 -> ] return-type2
      ...
   [ end ]
	
// Implementing, inside a class type definition:
interface interface-name with
   member self-identifier.member1 argument-list = method-body1
   member self-identifier.member2 argument-list = method-body2
// Implementing, by using an object expression:
[ attributes ]
let class-name (argument-list) =
   { new interface-name with
      member self-identifier.member1 argument-list = method-body1
      member self-identifier.member2 argument-list = method-body2
      [ base-interface-definitions ]
   }
member-list

Harap diperhatikan -

Dalam deklarasi antarmuka, anggota tidak diimplementasikan.
Anggotanya abstrak, dinyatakan oleh abstractkata kunci. Namun, Anda dapat menyediakan implementasi default menggunakandefault kata kunci.
Anda dapat mengimplementasikan antarmuka baik dengan menggunakan ekspresi objek atau dengan menggunakan tipe kelas.
Dalam implementasi kelas atau objek, Anda perlu menyediakan badan metode untuk metode abstrak antarmuka.
Kata kuncinya interface dan end, yang menandai awal dan akhir definisi, bersifat opsional.

Sebagai contoh,

type IPerson =
   abstract Name : string
   abstract Enter : unit -> unit
   abstract Leave : unit -> unit

Memanggil Metode Antarmuka

Metode antarmuka dipanggil melalui antarmuka, bukan melalui instance kelas atau antarmuka pelaksana tipe. Untuk memanggil metode antarmuka, Anda dapat mentransmisikan ke jenis antarmuka dengan menggunakan:> operator (operator upcast).

Sebagai contoh,

(s :> IPerson).Enter()
(s :> IPerson).Leave()

Contoh berikut menggambarkan konsep -

Contoh

type IPerson =
   abstract Name : string
   abstract Enter : unit -> unit
   abstract Leave : unit -> unit

type Student(name : string, id : int) =
   member this.ID = id
   interface IPerson with
      member this.Name = name
      member this.Enter() = printfn "Student entering premises!"
      member this.Leave() = printfn "Student leaving premises!"

type StuffMember(name : string, id : int, salary : float) =
   let mutable _salary = salary

   member this.Salary
      with get() = _salary
      and set(value) = _salary <- value

   interface IPerson with
      member this.Name = name
      member this.Enter() = printfn "Stuff member entering premises!"
      member this.Leave() = printfn "Stuff member leaving premises!"

let s = new Student("Zara", 1234)
let st = new StuffMember("Rohit", 34, 50000.0)

(s :> IPerson).Enter()
(s :> IPerson).Leave()
(st :> IPerson).Enter()
(st :> IPerson).Leave()

Ketika Anda mengkompilasi dan menjalankan program, itu menghasilkan output berikut -

Student entering premises!
Student leaving premises!
Stuff member entering premises!
Stuff member leaving premises!

Pewarisan Antarmuka

Antarmuka dapat mewarisi dari satu atau lebih antarmuka dasar.

Contoh berikut menunjukkan konsep -

type Interface1 =
   abstract member doubleIt: int -> int

type Interface2 =
   abstract member tripleIt: int -> int

type Interface3 =
   inherit Interface1
   inherit Interface2
   abstract member printIt: int -> string

type multiplierClass() =
   interface Interface3 with
      member this.doubleIt(a) = 2 * a
      member this.tripleIt(a) = 3 * a
      member this.printIt(a) = a.ToString()

let ml = multiplierClass()
printfn "%d" ((ml:>Interface3).doubleIt(5))
printfn "%d" ((ml:>Interface3).tripleIt(5))
printfn "%s" ((ml:>Interface3).printIt(5))

Ketika Anda mengkompilasi dan menjalankan program, itu menghasilkan output berikut -

10
15
5

Acara memungkinkan kelas untuk mengirim dan menerima pesan antara satu sama lain.

Di GUI, peristiwa adalah tindakan pengguna seperti penekanan tombol, klik, gerakan mouse, dll., Atau beberapa kejadian seperti pemberitahuan yang dihasilkan sistem. Aplikasi perlu merespons peristiwa saat terjadi. Misalnya, menyela. Acara digunakan untuk komunikasi antar proses.

Objek berkomunikasi satu sama lain melalui penyampaian pesan yang sinkron.

Acara dilampirkan ke fungsi lain; objek mendaftarcallback berfungsi ke suatu peristiwa, dan callback ini dijalankan ketika (dan jika) peristiwa tersebut dipicu oleh beberapa objek.

Kelas Acara dan Modul Acara

Kelas Control.Event <'T> membantu dalam membuat objek atau acara yang dapat diamati.

Ini memiliki anggota contoh berikut untuk bekerja dengan acara -

Anggota	Deskripsi
Menerbitkan	Menerbitkan observasi sebagai nilai kelas satu.
Pelatuk	Memicu pengamatan menggunakan parameter yang diberikan.

Modul Control.Event menyediakan fungsi untuk mengelola aliran acara -

Nilai	Deskripsi
tambahkan: ('T → unit) → Peristiwa <' Del, 'T> → unit	Menjalankan fungsi yang diberikan setiap kali peristiwa tertentu dipicu.
pilih: ('T →' U option) → IEvent <'Del,' T> → IEvent <'U>	Mengembalikan acara baru yang mengaktifkan pilihan pesan dari acara asli. Fungsi pemilihan membawa pesan asli ke pesan baru opsional.
filter: ('T → bool) → IEvent <' Del, 'T> → IEvent <' T>	Mengembalikan kejadian baru yang mendengarkan kejadian asli dan memicu kejadian yang dihasilkan hanya ketika argumen ke kejadian tersebut melewati fungsi yang diberikan.
peta: ('T →' U) → IEvent <'Del,' T> → IEvent <'U>	Mengembalikan peristiwa baru yang meneruskan nilai yang diubah oleh fungsi yang diberikan.
gabungkan: IEvent <'Del1,' T> → IEvent <'Del2,' T> → IEvent <'T>	Mengaktifkan peristiwa keluaran ketika salah satu peristiwa masukan diaktifkan.
berpasangan: IEvent <'Del,' T> → IEvent <'T *' T>	Menampilkan peristiwa baru yang dipicu pada pemicu kedua dan selanjutnya dari peristiwa masukan. ItuNth memicu peristiwa input meneruskan argumen dari N-1th dan Nthmemicu sebagai pasangan. Argumen diteruskan keN-1th memicu diadakan dalam keadaan internal tersembunyi sampai Nth memicu terjadi.
partisi: ('T → bool) → IEvent <' Del, 'T> → IEvent <' T> * IEvent <'T>	Mengembalikan peristiwa baru yang mendengarkan peristiwa asli dan memicu peristiwa hasil pertama jika penerapan predikat ke argumen peristiwa mengembalikan nilai benar, dan peristiwa kedua jika mengembalikan salah.
scan: ('U →' T → 'U) →' U → IEvent <'Del,' T> → IEvent <'U>	Mengembalikan peristiwa baru yang terdiri dari hasil penerapan fungsi akumulasi yang diberikan ke nilai berurutan yang dipicu pada peristiwa masukan. Item status internal mencatat nilai parameter status saat ini. Keadaan internal tidak terkunci selama pelaksanaan fungsi akumulasi, jadi berhati-hatilah agar input IEvent tidak dipicu oleh beberapa utas secara bersamaan.
split: ('T → Choice <' U1, 'U2>) → IEvent <' Del, 'T> → IEvent <' U1> * IEvent <'U2>	Mengembalikan kejadian baru yang mendengarkan kejadian asli dan memicu kejadian hasil pertama jika penerapan fungsi ke argumen kejadian mengembalikan Choice1Of2, dan kejadian kedua jika mengembalikan Choice2Of2.

Membuat Acara

Acara dibuat dan digunakan melalui Eventkelas. Konstruktor Acara digunakan untuk membuat acara.

Contoh

type Worker(name : string, shift : string) =
   let mutable _name = name;
   let mutable _shift = shift;
   let nameChanged = new Event<unit>() (* creates event *)
   let shiftChanged = new Event<unit>() (* creates event *)

   member this.Name
      with get() = _name
      and set(value) = _name <- value

   member this.Shift
      with get() = _shift
      and set(value) = _shift <- value

Setelah ini, Anda perlu mengekspos bidang nameChanged sebagai anggota publik, sehingga pendengar dapat terhubung ke acara yang, Anda menggunakan Publish properti acara -

type Worker(name : string, shift : string) =
   let mutable _name = name;
   let mutable _shift = shift;

   let nameChanged = new Event<unit>() (* creates event *)
   let shiftChanged = new Event<unit>() (* creates event *)

   member this.NameChanged = nameChanged.Publish (* exposed event handler *)
   member this.ShiftChanged = shiftChanged.Publish (* exposed event handler *)

   member this.Name
      with get() = _name
      and set(value) = _name <- value
      nameChanged.Trigger() (* invokes event handler *)

   member this.Shift
      with get() = _shift
      and set(value) = _shift <- value
   shiftChanged.Trigger() (* invokes event handler *)

Selanjutnya, Anda menambahkan callback ke event handler. Setiap pengendali kejadian memiliki tipe IEvent <'T>, yang menyediakan beberapa metode -

metode	Deskripsi
val Tambahkan: event :( 'T → unit) → unit	Menghubungkan fungsi pendengar ke acara tersebut. Pendengar akan dipanggil saat acara dipicu.
val AddHandler: 'del → unit	Menghubungkan objek delegasi penangan ke acara tersebut. Sebuah penangan nantinya dapat dihapus menggunakan RemoveHandler. Pendengar akan dipanggil saat acara dipicu.
val RemoveHandler: 'del → unit	Menghapus delegasi pendengar dari penyimpanan pendengar acara.

Bagian berikut memberikan contoh lengkapnya.

Contoh

Contoh berikut menunjukkan konsep dan teknik yang dibahas di atas -

type Worker(name : string, shift : string) =
   let mutable _name = name;
   let mutable _shift = shift;

   let nameChanged = new Event<unit>() (* creates event *)
   let shiftChanged = new Event<unit>() (* creates event *)

   member this.NameChanged = nameChanged.Publish (* exposed event handler *)
   member this.ShiftChanged = shiftChanged.Publish (* exposed event handler *)

   member this.Name
      with get() = _name
      and set(value) = 
         _name <- value
         nameChanged.Trigger() (* invokes event handler *)

   member this.Shift
      with get() = _shift
      and set(value) = 
         _shift <- value
         shiftChanged.Trigger() (* invokes event handler *)

let wk = new Worker("Wilson", "Evening")
wk.NameChanged.Add(fun () -> printfn "Worker changed name! New name: %s" wk.Name)
wk.Name <- "William"
wk.NameChanged.Add(fun () -> printfn "-- Another handler attached to NameChanged!")
wk.Name <- "Bill"

wk.ShiftChanged.Add(fun () -> printfn "Worker changed shift! New shift: %s" wk.Shift)
wk.Shift <- "Morning"
wk.ShiftChanged.Add(fun () -> printfn "-- Another handler attached to ShiftChanged!")
wk.Shift <- "Night"

Ketika Anda mengkompilasi dan menjalankan program, itu menghasilkan output berikut -

Worker changed name! New name: William
Worker changed name! New name: Bill
-- Another handler attached to NameChanged!
Worker changed shift! New shift: Morning
Worker changed shift! New shift: Night
-- Another handler attached to ShiftChanged!

Sesuai pustaka MSDN, modul F # adalah pengelompokan konstruksi kode F #, seperti tipe, nilai, nilai fungsi, dan kode dalam pengikatan. Ini diimplementasikan sebagai kelas runtime bahasa umum (CLR) yang hanya memiliki anggota statis.

Bergantung pada situasinya apakah seluruh file termasuk dalam modul, ada dua jenis deklarasi modul -

Deklarasi modul tingkat atas
Deklarasi modul lokal

Dalam deklarasi modul tingkat atas, seluruh file disertakan dalam modul. Dalam hal ini, deklarasi pertama dalam file tersebut adalah deklarasi modul. Anda tidak harus membuat deklarasi indentasi di modul tingkat atas.

Dalam deklarasi modul lokal, hanya deklarasi yang diindentasi di bawah deklarasi modul itu yang merupakan bagian dari modul.

Sintaksis

Sintaks untuk deklarasi modul adalah sebagai berikut -

// Top-level module declaration.
module [accessibility-modifier] [qualified-namespace.]module-name
   declarations
// Local module declaration.
module [accessibility-modifier] module-name =
   declarations

Harap dicatat bahwa pengubah aksesibilitas dapat menjadi salah satu dari yang berikut - publik, pribadi, internal. Standarnya adalahpublic.

Contoh berikut akan menunjukkan konsep -

Contoh 1

File modul Arithmetic.fs -

module Arithmetic
let add x y =
   x + y

let sub x y =
   x - y
	
let mult x y =
   x * y
	
let div x y =
   x / y

File program main.fs -

// Fully qualify the function name.
open Arithmetic
let addRes = Arithmetic.add 25 9
let subRes = Arithmetic.sub 25 9
let multRes = Arithmetic.mult 25 9
let divRes = Arithmetic.div 25 9

printfn "%d" addRes
printfn "%d" subRes
printfn "%d" multRes
printfn "%d" divRes

Ketika Anda mengkompilasi dan menjalankan program, itu menghasilkan output berikut -

Contoh 2

// Module1
module module1 =
   // Indent all program elements within modules that are declared with an equal sign.
   let value1 = 100
   let module1Function x =
      x + value1

// Module2
module module2 =
   let value2 = 200

   // Use a qualified name to access the function.
   // from module1.
   let module2Function x =
      x + (module1.module1Function value2)

let result = module1.module1Function 25
printfn "%d" result

let result2 = module2.module2Function 25
printfn "%d" result2

Ketika Anda mengkompilasi dan menjalankan program, itu menghasilkan output berikut -

125
325

SEBUAH namespacedirancang untuk menyediakan cara untuk memisahkan satu set nama dari yang lain. Nama kelas yang dideklarasikan dalam satu namespace tidak akan bertentangan dengan nama kelas yang sama yang dideklarasikan di namespace lain.

Sesuai perpustakaan MSDN, a namespace memungkinkan Anda mengatur kode ke dalam area fungsionalitas terkait dengan memungkinkan Anda melampirkan nama ke pengelompokan elemen program.

Mendeklarasikan Namespace

Untuk mengatur kode Anda dalam namespace, Anda harus mendeklarasikan namespace sebagai deklarasi pertama dalam file. Isi seluruh file kemudian menjadi bagian dari namespace.

namespace [parent-namespaces.]identifier

Contoh berikut menggambarkan konsep -

Contoh

namespace testing

module testmodule1 =
   let testFunction x y =
      printfn "Values from Module1: %A %A" x y
module testmodule2 =
   let testFunction x y =
      printfn "Values from Module2: %A %A" x y

module usermodule =
   do
      testmodule1.testFunction ( "one", "two", "three" ) 150
      testmodule2.testFunction (seq { for i in 1 .. 10 do yield i * i }) 200

Ketika Anda mengkompilasi dan menjalankan program, itu menghasilkan output berikut -

Values from Module1: ("one", "two", "three") 150
Values from Module2: seq [1; 4; 9; 16; ...] 200