Funkce

Článek
01/27/2024

Funkce jsou základní jednotkou provádění programů v libovolném programovacím jazyce. Stejně jako v jiných jazycích má funkce F# název, může mít parametry a přijímat argumenty a má tělo. Jazyk F# také podporuje funkční programovací konstrukce, jako je zacházení s funkcemi jako s hodnotami, používání nenáznamných funkcí ve výrazech, složení funkcí pro vytváření nových funkcí, složených funkcí a implicitní definice funkcí prostřednictvím částečného použití argumentů funkce.

Funkce definujete pomocí klíčového let slova, nebo pokud je funkce rekurzivní, let rec kombinace klíčových slov.

Syntax

// 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

Poznámky

Název funkce je identifikátor, který představuje funkci. Seznam parametrů se skládá z následných parametrů oddělených mezerami. Pro každý parametr můžete zadat explicitní typ, jak je popsáno v části Parametry. Pokud nezadáte konkrétní typ argumentu, kompilátor se pokusí odvodit typ z těla funkce. Tělo funkce se skládá z výrazu. Výraz, který tvoří tělo funkce, je obvykle složený výraz sestávající z řady výrazů, které vyvrcholí konečným výrazem, který je vrácenou hodnotou. Návratový typ je dvojtečka následovaná typem a je volitelná. Pokud explicitně nezadáte typ návratové hodnoty, kompilátor určí návratový typ z konečného výrazu.

Jednoduchá definice funkce se podobá následující:

let f x = x + 1

V předchozím příkladu je fnázev funkce , argument je , který má xtyp int, tělo funkce je x + 1a návratová hodnota je typu int.

Funkce lze označit inline. Informace o inlinenástroji Inline Functions naleznete v tématu Vložené funkce.

Obor

Na jakékoli úrovni oboru jiného než oboru modulu se nejedná o chybu opakovaného použití hodnoty nebo názvu funkce. Pokud znovu použijete název, název deklarovaný později stínuje název deklarovaný dříve. V oboru nejvyšší úrovně modulu ale názvy musí být jedinečné. Například následující kód vytvoří chybu, když se zobrazí v oboru modulu, ale ne, když se zobrazí uvnitř funkce:

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

Následující kód je ale přijatelný na libovolné úrovni rozsahu:

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

Parametry

Názvy parametrů jsou uvedeny za názvem funkce. Můžete zadat typ parametru, jak je znázorněno v následujícím příkladu:

let f (x : int) = x + 1

Pokud zadáte typ, řídí se názvem parametru a je oddělen od názvu dvojtekou. Pokud vynecháte typ parametru, typ parametru je odvozen kompilátorem. Například v následující definici funkce je argument x odvozen jako typ int , protože 1 je typu int.

let f x = x + 1

Kompilátor se ale pokusí funkci co nejogenerovat. Poznamenejte si například následující kód:

let f x = (x, x)

Funkce vytvoří řazenou kolekci členů z jednoho argumentu libovolného typu. Vzhledem k tomu, že typ není zadán, lze funkci použít s libovolným typem argumentu. Další informace najdete v tématu Automatická generalizace.

Těla funkcí

Tělo funkce může obsahovat definice místních proměnných a funkcí. Tyto proměnné a funkce jsou v oboru v těle aktuální funkce, ale ne mimo ni. Pomocí odsazení je nutné určit, že definice je v těle funkce, jak je znázorněno v následujícím příkladu:

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

Další informace najdete v tématu Pokyny pro formátování kódu a podrobnou syntaxi.

Návratové hodnoty

Kompilátor používá konečný výraz v textu funkce k určení návratové hodnoty a typu. Kompilátor může odvodit typ konečného výrazu z předchozích výrazů. V funkci cylinderVolume, zobrazený v předchozí části, typ pi je určen z typu literálu 3.14159 , který má být float. Kompilátor používá typ pi k určení typu výrazu length * pi * radius * radius , který má být float. Proto je celkový návratový typ funkce float.

Pokud chcete explicitně zadat návratový typ, napište kód následujícím způsobem:

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

Jak je kód napsaný výše, kompilátor použije float na celou funkci; pokud chcete použít i u typů parametrů, použijte následující kód:

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

Volání funkce

Funkce voláte tak, že zadáte název funkce následovaný mezerou a potom všechny argumenty oddělené mezerami. Pokud například chcete volat funkci cylinderVolume a přiřadit výsledek k hodnotě vol, napíšete následující kód:

let vol = cylinderVolume 2.0 3.0

Částečné použití argumentů

Pokud zadáte méně než zadaný počet argumentů, vytvoříte novou funkci, která očekává zbývající argumenty. Tato metoda zpracování argumentů se označuje jako currying a je charakteristická pro funkční programovací jazyky, jako je F#. Předpokládejme například, že pracujete se dvěma velikostmi potrubí: jeden má poloměr 2,0 a druhý má poloměr 3,0. Můžete vytvořit funkce, které určují objem kanálu následujícím způsobem:

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

Pak byste podle potřeby dodali konečný argument pro různé délky potrubí dvou různých velikostí:

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

Rekurzivní funkce

Rekurzivní funkce jsou funkce , které se nazývají samy. Vyžadují, abyste zadali klíčové slovo rec za klíčovým slovem let . Vyvolá rekurzivní funkci z těla funkce stejně jako vyvolání jakéhokoli volání funkce. Následující rekurzivní funkce vypočítá n^fibonacci číslo. Fibonacciho číselná posloupnost byla známa od starosti a je posloupnost, ve které každé po sobě jdoucí číslo je součet předchozích dvou čísel v posloupnosti.

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

Některé rekurzivní funkce mohou přetékat zásobník programu nebo provádět neefektivní výkon, pokud je nezapisujete opatrně a s povědomím o speciálních technikách, jako je použití rekurze ocasu, akumulátorů a pokračování.

Hodnoty funkcí

V jazyce F# jsou všechny funkce považovány za hodnoty; ve skutečnosti se označují jako hodnoty funkcí. Vzhledem k tomu, že jsou funkce hodnotami, lze je použít jako argumenty pro jiné funkce nebo v jiných kontextech, kde se hodnoty používají. Následuje příklad funkce, která jako argument přebírá hodnotu funkce:

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

Typ hodnoty funkce zadáte pomocí tokenu -> . Na levé straně tohoto tokenu je typ argumentu a na pravé straně je vrácená hodnota. V předchozím příkladu je funkce, apply1 která přebírá funkci transform jako argument, kde transform je funkce, která přebírá celé číslo a vrací další celé číslo. Následující kód ukazuje, jak používat apply1:

let increment x = x + 1

let result1 = apply1 increment 100

Hodnota result bude 101 po spuštění předchozího kódu.

Několik argumentů je odděleno následnými -> tokeny, jak je znázorněno v následujícím příkladu:

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

let mul x y = x * y

let result2 = apply2 mul 10 20

Výsledek je 200.

Lambda – výrazy

Výraz lambda je nepojmenovaná funkce. V předchozích příkladech můžete místo definování pojmenovaných funkcí zvýšit a mulovat výrazy lambda následujícím způsobem:

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

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

Výrazy lambda definujete pomocí klíčového fun slova. Výraz lambda se podobá definici funkce s tím rozdílem, že místo tokenu =-> se token používá k oddělení seznamu argumentů od textu funkce. Stejně jako v definici regulární funkce lze typy argumentů explicitně odvodit nebo zadat a návratový typ výrazu lambda je odvozen z typu posledního výrazu v těle. Další informace najdete v tématu Výrazy lambda: fun Klíčové slovo.

Pipelines

Operátor |> kanálu se při zpracování dat v jazyce F# používá značně. Tento operátor umožňuje flexibilním způsobem vytvořit "kanály" funkcí. Pipelining umožňuje zřetězování volání funkcí jako následných operací:

let result = 100 |> function1 |> function2

Následující ukázka vás provede použitím těchto operátorů k vytvoření jednoduchého funkčního kanálu:


/// Square the odd values of the input and add one, using F# pipe operators.
let squareAndAddOdd values =
    values
    |> List.filter (fun x -> x % 2 <> 0)
    |> List.map (fun x -> x * x + 1)

let numbers = [ 1; 2; 3; 4; 5 ]

let result = squareAndAddOdd numbers

Výsledek je [2; 10; 26]. Předchozí ukázka používá funkce pro zpracování seznamů, které demonstrují, jak se dají funkce použít ke zpracování dat při vytváření kanálů. Samotný operátor kanálu je definován v základní knihovně jazyka F#následujícím způsobem:

let (|>) x f = f x

Složení funkce

Funkce v jazyce F# se dají skládat z jiných funkcí. Složení dvou funkcí function1 a function2 je další funkce, která představuje aplikaci funkce1 následovanou aplikací funkce2:

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

Výsledek je 202.

Operátor >> složení přebírá dvě funkce a vrací funkci. Naproti tomu operátor |> kanálu přebírá hodnotu a funkci a vrátí hodnotu. Následující příklad kódu ukazuje rozdíl mezi operátory kanálu a složení zobrazením rozdílů v podpisech a využití funkce.

// 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
// ( |> ) : 'T1 -> ('T1 -> 'U) -> 'U
let Pipeline2 x = addOne x |> timesTwo

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

// Result is 5
let result3 = Pipeline1 2

// Result is 6
let result4 = Pipeline2 2

Přetížení funkcí

Metody typu můžete přetížit, ale ne funkce. Další informace naleznete v tématu Metody.