Mi az F?#

Az F# egy univerzális programozási nyelv, amely tömör, robusztus és hatékony kódot ír.

Az F# lehetővé teszi, hogy átnézetlen, önaláírt kódot írjon, ahol a fókusz a problémás tartományra marad a programozás részletei helyett.

Mindezt anélkül teszi, hogy veszélyeztetné a sebességet és a kompatibilitást – nyílt forráskódú, platformfüggetlen és interoperábilis.

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#")

Az F# számos funkcióval rendelkezik, például:

• Egyszerűsített szintaxis
• Alapértelmezés szerint nem módosítható
• Típusmegállapítás és automatikus általánosítás
• Első osztályú függvények
• Hatékony adattípusok
• Mintaegyezés
• Aszinkron programozás

A funkciók teljes készletét az F# nyelvi útmutatója dokumentálja.

Gazdag adattípusok

Az olyan típusok, mint a rekordok és a diszkriminált szakszervezetek , lehetővé teszik az adatok megjelenítését.

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

Az F#-rekordok és a diszkriminált szakszervezetek alapértelmezés szerint nem null értékűek, nem módosíthatók és összehasonlíthatók, így nagyon könnyen használhatók.

Helyesség függvényekkel és mintaegyeztetéssel

Az F#-függvények könnyen definiálhatók. A mintaegyeztetéssel kombinálva meghatározhatja azokat a viselkedést, amelyek helyességét a fordító érvényesíti.

// 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 :("

Az F#-függvények szintén első osztályúak, ami azt jelenti, hogy paraméterekként továbbíthatók, és más függvényekből is visszaadhatók.

Objektumok műveleteinek definiálásához szükséges függvények

Az F# teljes mértékben támogatja az objektumokat, amelyek akkor hasznosak, ha adatokat és funkciókat kell kombinálnia. Az F#-tagok és -függvények definiálhatók az objektumok kezeléséhez.

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)

Az F#-ban gyakran olyan kódot fog írni, amely az objektumokat a függvények manipulálására szolgáló típusként kezeli. A nagyobb F#-programokban gyakoriak az olyan funkciók, mint az általános felületek, az objektumkifejezések és a tagok megfontolt használata.

Következő lépések

Ha többet szeretne megtudni az F# funkcióinak nagyobb halmazáról, tekintse meg az F#-bemutatót.