İşlevler (F#)

Temel birimi olan herhangi bir programlama dilinde program yürütme işlevlerdir.Diğer dillerde olduğu gibi bir F# işlevi bir adı vardır, gerçekleştirilmesi gereken bağımsız değişkenleri ve parametreleri olabilir ve bir gövdeye sahip.F# da fonksiyonlar değerler olarak değerlendirmesini gibi fonksiyonel programlama yapıları ifadelerde, yeni işlevler, curried işlevler ve işlevler işlev bağımsız değişkenlerinin kısmi uygulaması yoluyla örtülü tanımı oluşturmak için işlevler oluşumunu adsız işlevler kullanarak destekler.

İşlevleri kullanarak tanımladığınız let anahtar sözcüğü veya özyinelemeli işlevi ise, let rec anahtar sözcük bileşimini.

// Non-recursive function definition.
let [inline] function-name parameter-list [ : return-type ] = function-body
// Recursive function definition.
let rec function-name parameter-list = recursive-function-body

Notlar

function-name İşlevi gösteren bir tanımlayıcıdır.parameter-list Boşluklarla ayrılmış birbirini izleyen parametreleri içerir.Parametreler bölümünde açıklandığı gibi her parametre için açıkça bir türü belirtebilirsiniz.Belirli bir bağımsız değişken türü belirtmezseniz, derleyici işlev gövdesi türünden gerçekleştirip çalışır.function-body Bir ifade oluşur.İşlev gövdesi yaptığı genellikle dönüş değeri son bir ifade culminate ifadelerin oluşan bileşik bir deyim ifadesidir.return-type İki nokta ve ardından bir türünü ve isteğe bağlıdır.Dönüş değeri türü açıkça belirtmezseniz, derleyici son ifadesinden dönüş türü belirler.

Basit işlev tanımı aşağıdakine benzer:

let f x = x + 1

Önceki örnekte, işlev adı olan f, bağımsız değişken x, türü olan int, işlev gövdesi x + 1, ve dönüş değeri türü int.

Satır içi belirleyici bir ipucu derleyiciye işlevin küçük ve kod işlevi çağıran gövdesine entegre hale getirilebilir değil.

Kapsam

Herhangi bir modül kapsam dışında bir kapsam düzeyinde, değere veya işlev adı yeniden kullanmak için bir hata değil.Bir adı yeniden, daha sonra bildirilen adı daha önce bildirilen ad gölgeliyor.Ancak, üst düzey kapsamında Modül içindeki adları benzersiz olmalıdır.Örneğin, aşağıdaki kod modülü kapsamında göründüğünde, ancak bir işlev içinde görüntülendiğinde değil, bir hata üretir:

let list1 = [ 1; 2; 3]
// Error: duplicate definition. 
let list1 = []  
let function1 =
   let list1 = [1; 2; 3]
   let list1 = []
   list1

Ancak aşağıdaki kod kapsamı herhangi bir düzeyde kabul edilebilir:

let list1 = [ 1; 2; 3]
let sumPlus x =
// OK: inner list1 hides the outer list1. 
   let list1 = [1; 5; 10]  
   x + List.sum list1

Parametreler

İşlev adından sonra parametre adları listelenir.Aşağıdaki örnekte gösterildiği gibi bir türü için bir parametre belirtebilirsiniz:

let f (x : int) = x + 1

Bir türü belirtirseniz, parametrenin adı izler ve adı iki nokta ile ayrılır.Parametre türü parametresi için tür yazmazsanız, derleyici tarafından algılanır.Örneğin, aşağıdaki işlev tanımında, bağımsız değişken x türü olayla int 1 türü olduğundan int.

let f x = x + 1

Ancak, derleyici işlevi olabildiğince genel kurmayı dener.Örneğin, aşağıdaki kodu not alın:

let f x = (x, x)

İşlev herhangi türde bir bağımsız değişken bir dizi oluşturur.İşlev türü belirtilmemiş olduğundan, herhangi bir bağımsız değişken türü ile birlikte kullanılabilir.Daha fazla bilgi için bkz. Otomatik Genelleştirme (F#).

İşlev gövdesi

İşlev gövdesi yerel değişkenleri ve işlevleri tanımları içerebilir.Kapsam değil dışında ancak geçerli işlevinin gövdesinde bu tür değişkenleri ve işlevleri arasındadır.Basit sözdizimi seçeneği etkin olduğunda, aşağıdaki örnekte gösterildiği gibi bir tanımı bir işlev gövdesinde olduğunu belirtmek için girinti kullanmanız gerekir:

let cylinderVolume radius length =
    // Define a local value pi. 
    let pi = 3.14159
    length * pi * radius * radius

Daha fazla bilgi için, bkz. Kod Biçimlendirme Yönergeleri (F#) ve Ayrıntılı Sözdizimi (F#).

Dönüş Değerleri

Derleyici dönüş değerini ve türünü belirlemek için işlev gövdesinde son ifade kullanır.Derleyici, önceki deyimlere son ifadeden türü gerçekleştirip.İşlevinde cylinderVolumetürü önceki bölümünde gösterilen pi sabit değer türünden belirlenir 3.14159 olarak float.Derleyici türünü kullanan pi ifade türünü belirlemek için h * pi * r * r olarak float.Bu nedenle, işlev genel dönüş türü olan float.

Dönüş değeri açıkça belirtmek için kodu aşağıdaki gibi yazın:

let cylinderVolume radius length : float =
   // Define a local value pi. 
   let pi = 3.14159
   length * pi * radius * radius

Yukarıdaki kod yazıldığı gibi derleyici geçerli float tüm işlev; parametre türleri de uygulamak anlamına gelir, şu kodu kullanın:

let cylinderVolume (radius : float) (length : float) : float

Bir işlev çağırarak

İşlevler, işlev adı ve bir boşluk ve ardından boşluklarla ayrılmış bağımsız değişkenleri belirterek çağırın.Örneğin işlevini çağırmak üzere, cylinderVolume ve sonuç değeri atayın vol, aşağıdaki kodu yazın:

let vol = cylinderVolume 2.0 3.0

Bağımsız değişkenlerin kısmi uygulaması

Bağımsız değişkenler belirtilen sayıdan daha az sağlarsanız, kalan bağımsız değişken almayan yeni bir işlev oluşturun.Bu yöntem bağımsız değişkenleri işleme için olarak adlandırılır currying ve F# işlevsel programlama dilleri bir özelliğidir.Örneğin, iki kanal boyutlarıyla çalıştığınız varsayalım: yarıçapı, varsa 2.0 ve diğer yarıçapı, 3.0.Boru birim belirlemek gibi işlevler oluşturabilirsiniz:

let smallPipeRadius = 2.0
let bigPipeRadius = 3.0

// These define functions that take the length as a remaining 
// argument: 

let smallPipeVolume = cylinderVolume smallPipeRadius
let bigPipeVolume = cylinderVolume bigPipeRadius

Sonra kanalın iki farklı boyutlarda çeşitli uzunlukları için gerektiği gibi ek bağımsız değişken vermeniz:

let length1 = 30.0
let length2 = 40.0
let smallPipeVol1 = smallPipeVolume length1
let smallPipeVol2 = smallPipeVolume length2
let bigPipeVol1 = bigPipeVolume length1
let bigPipeVol2 = bigPipeVolume length2

Özyinelemeli işlevleri

Özyinelemeli işlevleri , kendilerini çağrı işlevlerdir.Bunlar, belirttiğiniz gerektirir rec anahtar sözcüğünü aşağıdaki let anahtar sözcük.Yalnızca herhangi bir işlev çağrısı çağırmak gibi işlev gövdesi içinde özyinelemeli işlevini çağırır.Aşağıdaki özyinelemeli işlevi hesaplar nth Fibonacci sayısı.Fibonacci sayı dizisi antiquity beri bilinen ve her ardışık sayı önceki iki sayı dizisini toplamı olan bir dizidir.

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

Bazı işlevler program yığın taşmasına veya bunları dikkatle ve bilincini accumulators ve devamlılığını kullanımı gibi özel teknikleri ile yazdığınız değil, inefficiently gerçekleştirin.

İşlev değerlerini

F#'da tüm işlevler değerler olarak kabul edilir; olarak aslında bilinen İşlev değerlerini.Fonksiyonlar değerler olduğundan, diğer bağlamlarda veya diğer işlevler için bağımsız değişkenler olarak değerleri kullanıldığı kullanılabilirler.İşlevi değerini bir bağımsız değişken olarak alan bir işlev örneği aşağıda verilmiştir:

let apply1 (transform : int -> int ) y = transform y

İşlevi değer türünü kullanarak, belirttiğiniz -> belirteci.Bu belirteç sol tarafındaki bağımsız değişkenin türü ve sağ tarafta dönüş değeri.Önceki örnekte, apply1 bir işlev götüren bir işlevdir transform , bağımsız değişken olarak burada transform tamsayı alan ve başka bir tamsayı döndüren bir işlevdir.Aşağıdaki kod nasıl kullanacağınızı gösterir apply1:

let increment x = x + 1

let result1 = apply1 increment 100

Değeri result önceki kod çalıştıktan sonra 101 olacaktır.

Birden fazla değişken art arda tarafından ayrılmış -> , aşağıdaki örnekte gösterildiği gibi belirteçler:

let apply2 ( f: int -> int -> int) x y = f x y

let mul x y = x * y

let result2 = apply2 mul 10 20

Sonucu 200'dür.

Lambda İfadeleri

A lambda ifadesi adlandırılmamış bir işlevdir.Önceki örneklerde, işlevler adlı tanımlamak yerine increment ve mul, lambda ifadeleri aşağıdaki gibi kullanabilirsiniz:

let result3 = apply1 (fun x -> x + 1) 100

let result4 = apply2 (fun x y -> x * y ) 10 20

Lambda ifadeleri kullanarak tanımladığınız fun anahtar sözcük.Lambda ifadesi yerine, dışında bir işlev tanımı benzer = token, -> belirteci işlevi gövdesinden bağımsız değişken listesine ayırmak için kullanılır.Normal işlev tanımı, olduğu gibi bağımsız değişken türleri olayla veya açıkça belirtilen ve lambda ifadesi dönüş türü gövdesi içindeki son ifade türünden algılanır.Daha fazla bilgi için bkz. Lambda İfadeleri: fun Anahtar Sözcüğü (F#).

İşlev bileşimi ve ardışık düzen oluşturma

F# işlevleri diğer işlevlerden oluşan.İki işlev oluşumunu function1 ve function2 , uygulamanın gösteren başka bir işlevi olan function1 uygulamasının ardından function2:

let function1 x = x + 1
let function2 x = x * 2
let h = function1 >> function2
let result5 = h 100

202 Sonucudur.

Ardışık ardışık işlemler olarak birlikte zincirleme için işlev çağrıları etkinleştirir.Works gibi ardışık düzen oluşturma:

let result = 100 |> function1 |> function2

Yeniden 202 sonucudur.

Kompozisyon operatörleri iki işlev alır ve bir işlev döndürür; Bunun tersine, boru hattı operatörleri bir işlevi ve bir bağımsız değişken alır ve bir değer döndürür.Aşağıdaki kod örneği tarafından imza işlevi ve kullanımı arasındaki farklılıklar gösteren ardışık düzen ve kompozisyon operatörler arasındaki farkı gösterir.

// Function composition and pipeline operators compared.

let addOne x = x + 1
let timesTwo x = 2 * x

// Composition operator
// ( >> ) : ('T1 -> 'T2) -> ('T2 -> 'T3) -> 'T1 -> 'T3
let Compose2 = addOne >> timesTwo

// Backward composition operator
// ( << ) : ('T2 -> 'T3) -> ('T1 -> 'T2) -> 'T1 -> 'T3
let Compose1 = addOne << timesTwo

// Result is 5
let result1 = Compose1 2

// Result is 6
let result2 = Compose2 2

// Pipelining
// Pipeline operator
// ( <| ) : ('T -> 'U) -> 'T -> 'U
let Pipeline1 x = addOne <| timesTwo x

// Backward pipeline operator
// ( |> ) : 'T1 -> ('T1 -> 'U) -> 'U
let Pipeline2 x = addOne x |> timesTwo

// Result is 5
let result3 = Pipeline1 2

// Result is 6
let result4 = Pipeline2 2

Aşırı yükleme işlevleri

Bir tür, ancak değil fonksiyonlarını yöntemleri aşırı yüklenmeye neden olabilir.Daha fazla bilgi için bkz. Yöntemler (F#).

Ayrıca bkz.

Diğer Kaynaklar

Değerler (F#)

F# Dili Başvurusu