Co je F#

F# je univerzální programovací jazyk pro psaní stručného, robustního a výkonného kódu.

F# umožňuje psát nezaplněný kód pro samodokumentování, kde váš fokus zůstává na vaší problémové doméně, a ne na podrobnosti programování.

Dělá to bez ohrožení rychlosti a kompatibility – je to opensourcový, multiplatformní a interoperabilní.

open System // Gets access to functionality in System namespace.

// Defines a list of names
let names = [ "Peter"; "Julia"; "Xi" ]

// Defines a function that takes a name and produces a greeting.
let getGreeting name = $"Hello, {name}"

// Prints a greeting for each name!
names
|> List.map getGreeting
|> List.iter (fun greeting -> printfn $"{greeting}! Enjoy your F#")

Jazyk F# má řadu funkcí, mezi které patří:

• Jednoduchá syntaxe
• Neměnné ve výchozím nastavení
• Odvození typů a automatická generalizace
• Funkce první třídy
• Výkonné datové typy
• Porovnávání vzorů
• Asynchronní programování

Úplná sada funkcí je zdokumentovaná v průvodci jazykem F#.

Bohaté datové typy

Typy, jako jsou záznamy a diskriminované sjednocení , umožňují znázorňovat vaše data.

// Group data with Records
type SuccessfulWithdrawal =
    { Amount: decimal
      Balance: decimal }

type FailedWithdrawal =
    { Amount: decimal
      Balance: decimal
      IsOverdraft: bool }

// Use discriminated unions to represent data of 1 or more forms
type WithdrawalResult =
    | Success of SuccessfulWithdrawal
    | InsufficientFunds of FailedWithdrawal
    | CardExpired of System.DateTime
    | UndisclosedFailure

Záznamy F# a diskriminované sjednocení jsou non-null, neměnné a srovnatelné ve výchozím nastavení, což je velmi snadné.

Správnost funkcí a porovnávání vzorů

Funkce jazyka F# se snadno definují. V kombinaci s porovnáváním vzorů umožňují definovat chování, jehož správnost vynucuje kompilátor.

// Returns a WithdrawalResult
let withdrawMoney amount = // Implementation elided

let handleWithdrawal amount =
    let w = withdrawMoney amount

    // The F# compiler enforces accounting for each case!
    match w with
    | Success s -> printfn $"Successfully withdrew %f{s.Amount}"
    | InsufficientFunds f -> printfn $"Failed: balance is %f{f.Balance}"
    | CardExpired d -> printfn $"Failed: card expired on {d}"
    | UndisclosedFailure -> printfn "Failed: unknown :("

Funkce F# jsou také prvotřídní, což znamená, že je možné je předat jako parametry a vracet je z jiných funkcí.

Funkce definující operace s objekty

Jazyk F# má plnou podporu pro objekty, které jsou užitečné, když potřebujete kombinovat data a funkce. Členy a funkce jazyka F# je možné definovat pro manipulaci s objekty.

type Set<'T when 'T: comparison>(elements: seq<'T>) =
    member s.IsEmpty = // Implementation elided
    member s.Contains (value) =// Implementation elided
    member s.Add (value) = // Implementation elided
    // ...
    // Further Implementation elided
    // ...
    interface IEnumerable<'T>
    interface IReadOnlyCollection<'T>

module Set =
    let isEmpty (set: Set<'T>) = set.IsEmpty

    let contains element (set: Set<'T>) = set.Contains(element)

    let add value (set: Set<'T>) = set.Add(value)

V jazyce F# často napíšete kód, který zpracovává objekty jako typ pro funkce, které se mají manipulovat. Funkce, jako jsou obecná rozhraní, výrazy objektů a uvážlivé použití členů, jsou běžné ve větších programech jazyka F#.

Další kroky

Další informace o větší sadě funkcí jazyka F# najdete v prohlídce jazyka F#.