Co to jest F#

F# to uniwersalny język programowania do pisania zwięzłego, niezawodnego i wydajnego kodu.

Język F# umożliwia pisanie kodu bez wyrejeszczonego, samodzielnego dokumentowania, w którym koncentrujesz się na domenie problemu, a nie na szczegółach programowania.

Robi to bez naruszania szybkości i zgodności — jest to rozwiązanie typu open source, międzyplatformowe i współdziałające.

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

Język F# ma wiele funkcji, w tym:

• Uproszczona składnia
• Niezmienne domyślnie
• Wnioskowanie typów i automatyczna uogólnienie
• Funkcje pierwszoklasowe
• Zaawansowane typy danych
• Dopasowanie do wzorca
• Programowanie asynchroniczne

Pełny zestaw funkcji opisano w przewodniku języka F#.

Zaawansowane typy danych

Typy, takie jak Rekordy i Związki Dyskryminujące, umożliwiają reprezentowanie danych.

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

Rekordy języka F# i związki dyskryminacyjne są domyślnie niezmienialne, niezmienne i porównywalne, co sprawia, że są bardzo łatwe w użyciu.

Poprawność z funkcjami i dopasowaniem wzorca

Funkcje języka F# są łatwe do zdefiniowania. W połączeniu z dopasowaniem wzorca umożliwiają definiowanie zachowania, którego poprawność jest wymuszana przez kompilator.

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

Funkcje języka F# są również najwyższej klasy, co oznacza, że mogą być przekazywane jako parametry i zwracane z innych funkcji.

Funkcje do definiowania operacji na obiektach

Język F# ma pełną obsługę obiektów, które są przydatne, gdy trzeba mieszać dane i funkcje. Elementy członkowskie i funkcje języka F# można zdefiniować w celu manipulowania obiektami.

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)

W języku F# często będziesz pisać kod, który traktuje obiekty jako typ do manipulowania funkcjami. Funkcje, takie jak interfejsy ogólne, wyrażenia obiektów i rozsądne użycie elementów członkowskich , są powszechne w większych programach języka F#.

Następne kroki

Aby dowiedzieć się więcej na temat większego zestawu funkcji języka F#, zapoznaj się z przewodnikiem języka F#.