| F# | |
|---|---|
| Språkklass |
multiparadigm : funktionell , objektorienterad , generaliserad , imperativ programmering |
| Framträdde i | 2005 |
| Författare | Microsoft Research |
| Utvecklaren | Microsoft och F Sharp Software Foundation [d] |
| Filtillägg _ | .fs, .fsi, .fsxeller.fsscript |
| Släpp | 6.0 ( 19 oktober 2021 ) |
| Typ system | sträng |
| Blivit påverkad | Mål Caml , C# , Haskell |
| Licens | Apache-programvarulicens |
| Hemsida | fsharp.org |
| OS | Programvara över plattformar ( .NET Framework , Mono ) |
| Mediafiler på Wikimedia Commons | |
F# (uttalas ef-sharp ) är ett multiparadigm programmeringsspråk i .NET - familjen av språk som stöder funktionell programmering förutom imperativ ( procedurell ) och objektorienterad programmering . Strukturen för F# liknar den för OCaml på många sätt, med den enda skillnaden är att F# är implementerat ovanpå .NET- biblioteken och runtime . Språket utvecklades av Don Syme vid Microsoft Research i Cambridge och utvecklas för närvarande av Microsoft Developer Division. F# integreras ganska nära med Visual Studios utvecklingsmiljö och ingår i distributionen av Visual Studio 2010/2012/2013/2015/2017/2019/2022; kompilatorer har också utvecklats för Mac och Linux [1] .
Microsoft har integrerat utvecklingsmiljön F# i Visual Studio 2010 och nyare versioner.
Den 4 november 2010 publicerades koden för F#-kompilatorn och dess kärnbibliotek under Apache License 2.0 [2] .
F# -kod är typsäker , ofta mer kompakt än liknande C# -kod , på grund av typinferens . F# har stark typning, implicita typkonverteringar saknas helt, vilket helt eliminerar fel associerade med typcasting.
Funktioner som generisk programmering och funktioner av högre ordning gör det möjligt att skriva abstrakta generiska algoritmer som manipulerar parameteriserade datastrukturer (t.ex. arrayer , listor , grafer , träd ).
På många språk är de flesta värden variabler. Till exempel kommer följande C++-kod xatt lagra värdet 3 i en variabel:
int x = 2 ; x ++ ;I F#, däremot, är alla värden konstanter som standard. F# tillåter variabler, vilket kräver att du specifikt markerar värden som föränderliga med ordet mutable:
låt x = 2 // oföränderlig låt föränderlig y = 2 // variabel x <- 3 // fel y <- 3 // Ok. y=3F# har också referenstyper och objekt som också kan innehålla föränderliga värden. Det mesta av koden är dock rena funktioner , vilket undviker många buggar och gör felsökningen enklare. Dessutom förenklas parallelliseringen av program. Med allt detta blir koden sällan mer komplicerad än liknande kod på ett imperativt språk.
En av huvudidéerna bakom F# är att se till att befintlig kod och typer i ett funktionellt programmeringsspråk lätt kan nås från andra .NET-språk. F#-program kompileras till CLR-sammansättningar (filer med .exe- och .dll-tillägg), men för att köra dem måste du installera ett runtime-paket utöver .NET Framework.
En intressant funktion (och skillnad från OCaml ) är kontrollen av den logiska kapslingen av kodkonstruktioner genom att dra in ett godtyckligt antal mellanslag (och endast mellanslag). Tab-tecken stöds inte för detta ändamål. Detta leder till ständiga diskussioner på forumen för erfarna utvecklare som är vana vid att använda flikar i andra programmeringsspråk.
F# är ett kompilerat programmeringsspråk som använder Common Intermediate Language (CIL) som ett mellanspråk, precis som program skrivna i C# eller VB.NET .
Tillsammans med F# -kompilatorn (fsc) finns det också en F# -tolk (fsi) som exekverar F#-kod interaktivt.
Det utmärkande för F# -kompilatorn och F# -tolken är förmågan att behandla kod på två olika sätt - omedelbart (som standard) och uppskjutet (programmeraren måste explicit specificera detta i källkoden). Vid omedelbar tolkning utvärderas uttryck i förväg i det ögonblick programmet startas för exekvering, oavsett om de anropas under programexekveringen eller inte. I det här fallet minskar ofta prestandan för programexekveringen och systemresurserna (till exempel minne) går till spillo. Vid lat kodtolkning utvärderas uttryck endast i det ögonblick då de är direkt åtkomliga under programexekveringen. Detta besparar programmet från ovanstående nackdelar, men minskar förutsägbarheten vad gäller mängden och sekvensen av resursanvändning (processortid, minne, I/O-enheter, etc.) vid olika stadier av programexekveringen.
Syntaxen för F# är baserad på matematisk notation, och programmering liknar i viss mån algebra , vilket gör att F# liknar Haskell . Till exempel, när du definierar en ny typ kan du ange att variablerna av den typen är " heltal eller strängar ". Så här ser det ut:
typ myType = IntVal av int | StringVal av strängEtt viktigt exempel på sådana typer är Option, som innehåller antingen ett värde av någon typ eller ingenting.
typ Alternativ <a> = Ingen | _ _ Några av enDet är en standard F#-typ och används ofta i situationer där resultatet av viss kod (som en uppslagning i en datastruktur) är ett värde som kanske inte returneras.
Koden är också en matematisk notation. Följande konstruktion är ekvivalent med f(x) = x + 1 i algebra:
låt f x = x + 1F# fungerar så här: typen " f" är " int -> int", det vill säga funktionen tar ett heltal som indata och producerar ett heltal som utdata.
F# låter dig komma åt absolut allt som finns i FCL . Syntaxen för att arbeta med .NET-bibliotek i denna mening är så nära C# -syntaxen som möjligt . Språkfunktioner märks när du använder hela utbudet av F#-funktioner. Till exempel tillämpar följande kod en funktion på elementen i en lista :
let rec map func lst = matcha lst med | [] -> [] | huvud :: svans -> func huvud :: map func svans låt min Lista = [ 1 ; 3 ; 5 ] låt newList = map ( kul x -> x + 1 ) myList" newList" är nu " [2;4;6]".
Analysen av listan i den här funktionen görs med en annan kraftfull funktion för mönstermatchning . Det låter dig specificera mönster, när matchning, motsvarande förekomster av matchningsoperatorn beräknas. Det första mönstret "[]" betyder en tom lista. Den andra är en lista som består av det första elementet och svansen (som kan vara en godtycklig lista, inklusive en tom). I det andra provet är huvudvärdet associerat med huvudvariabeln och svansvärdet med svans (namnen kan vara godtyckliga). Således, förutom huvuduppgiften, låter provet dig också bryta ner komplexa datastrukturer. Till exempel, i fallet med Option-typen, ser mönstermatchningen ut så här:
matcha x med | Vissa v -> printfn "Hittat värde %d." v | Ingen -> printfn "Inget hittades." | Ingen -> printfn "Hej"Språket stöder generatoruttryck definierade för uppsättningar { … }, listor [ … ]och arrayer. [| … |] Till exempel:
låt testa n = [ för i i 0 .. n gör om i % 2 = 0 så ger i ]Kartfunktionen är en av standardlistfunktionerna som finns i Listmodulen. Det finns även funktioner för andra datastrukturer som deklareras i modulerna Array, Set, Option.
Ett användbart verktyg är pipe-forward-operatorn (|>), som låter dig skriva funktionsanropskedjor i omvänd ordning. Som ett resultat sker följande kod (mellanliggande värden anges i kommentarerna):
[ 1 ; 2 ; 5 ] |> Lista . karta ((+) 1 ) // [2; 3; 6] |> Lista . filter ( fun x -> x % 2 = 0 ) // [2; 6] |> Lista . summa // 8Att använda operatören |>eliminerar behovet av ett stort antal konsoler och ändrar också den visuella uppfattningen av koden. Och nu lyder den här koden så här: ta en sådan och en sådan lista, lägg till 1 till varje element, lämna sedan bara jämna element, returnera deras summa. Det vill säga, den beskriver sekvensen av åtgärder som utförs på det ursprungliga objektet, i den ordning som det sker på datorn.
Följande är en liten demonstration av hur .NET-funktioner utökar F#. Ett exempel är fönsterapplikationer och händelsehantering. Händelsebearbetning innebär att vissa åtgärder i programmet endast sker som en reaktion på vissa händelser - användaråtgärder, enhetsanslutning, etc. Projektet kan skapas både i Visual Studio och i vilket textdokument som helst, som sedan matas till F#-kompilatorn ( fsc).
// open - kopplar ihop moduler och namnområden för att använda //-värdena, klasser och andra moduler som finns i dem. öppna System.Windows.Forms // - klasser Form (fönster), Knapp (knapp), etc. // Pip - en ljudsignal // Några fler parametrar skickas som pip-argument som vi inte använder låt pip _ = System . Konsol . Beep () // skapa ett fönster med ett programnamn ! behöver anropa en visningsordsfunktion - t.ex. Application.Run(window)! // Visible - booleskt värde, om fönstret är synligt // TopMost - om fönstret visas i förgrunden (ordningen på fönster med samma värde i omvänd ordning av samtalet) // Text - texten i fönstret title let window = nytt fönster ( Synligt = sant , TopMost = sant , Text = " " , Topp = 0 , Vänster = 0 , Höjd = 512 , Bredd = 768 ) . WindowState <- FormWindowState . Normal // Normal (, Minimerad, Maximerad) fönster. Bara inte med i fönsterkonstruktorn för exemplet . ClientSizeChanged . Lägg till pipfönster . _ tangentnedtryckning . Lägg till pipfönster . _ knapptryckning . Lägg till pipfönster . _ knappsats . Lägg till pip- applikation . Kör fönster // visningsfönsterRekursiv faktoriell funktion på naturligt sätt:
låt rec fac n = om n < 2 så 1 annat n * fac ( n - 1 )Rekursiv faktoriell funktion optimerad för svansrekursion.
låt factorial num = låt rec fac num acc = matcha num med | x när x < 2 -> acc |_ -> fac ( num - 1 ) ( acc * num ) fac num 1En faktoriell funktion, i en imperativ stil, med föränderligt tillstånd.
låt factorial num = om num < 2 så 1 annars låt föränderlig fac = 1 för i i [ 2 .. num ] do fac <- fac * i facFaktoriell funktion med listvikning och currymultiplikation:
låt fac n = Lista . vik (*) 1 [ 1 .. n ]Rekursiv funktion för att beräkna Fibonacci-tal med hjälp av mönstermatchningsmetod:
låt rec fib n a b = matcha n med | 0 -> a | 1 -> b | _ -> fib ( n - 1 ) b ( a + b )
| Programmeringsspråk | |
|---|---|
| |
| .NETTO | |
|---|---|
| Genomföranden | |
| Arkitektur | |
| Infrastruktur | |
| Microsofts språk | |
| Andra språk | |
| Windows Foundations | |
| Komponenter | |
| Jämförelser |
|
| Framtida teknologier | |
| Informationsresurser | |
| Microsoft Research (MSR) | |||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| Huvudprojekt _ |
| ||||||||||||||
| MSR Labs |
| ||||||||||||||
| Kategori | |||||||||||||||
| Gratis och öppen källkod från Microsoft | |||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| allmän information |
| ||||||||||||
| Programvara _ |
| ||||||||||||
| Licenser | |||||||||||||
| Relaterade ämnen |
| ||||||||||||
| Kategori | |||||||||||||