14 gode grunde til at bruge F #

F # er et stærkt skrevet, funktionelt første programmeringssprog, der giver dig mulighed for at løse komplekse problemer ved at skrive enkel kode. Baseret på ML og bygget på .NET Framework tilbyder F # god interoperabilitet, bærbarhed og kørehastighed såvel som "Five Cs" - bevidsthed, bekvemmelighed, korrekthed, samtidighed og fuldstændighed.

F # var oprindeligt kun tilgængelig på Windows som et Microsoft Research-projekt, men det er nu et førsteklasses sprog på en række platforme. Du kan bruge F # på Mac og Linux med værktøjssupport i Xamarin Studio, MonoDevelop, Emacs og andre; på Windows med Visual Studio, Xamarin Studio og Emacs; og på Android- og iOS-enheder og på internettet ved hjælp af HTML5. Ud over programmering til generelle formål gælder F # for GPU-kode, big data, spil og meget mere.

Hvorfor bruge F #? Lad mig give dig 14 grunde.

F # er interaktiv

En af fordelene ved F # er, at den har en interaktiv REPL (læse, evaluere, udskrive, loop), hvor du kan prøve kode, som vist på skærmbilledet nedenfor. Med uret, øverst til venstre, ser vi F # Interaktive vinduer fra Visual Studio i Windows, fra TryFSharp kører i Chrome og fra Xamarin Studio kører på Mac OS X. ;; fortæller F # Interactive at evaluere, hvad du har skrevet; på TryFSharp sender “run” -knappen det samme signal. Brug af en REPL til at kompilere og teste kode, før den går ind i et komplet program, fremskynder både udvikling og reducerer fejl.

F # er til scripting

F # kan bruges som et script-sprog såvel som et programmeringssprog. Nedenfor ser vi en Visual Studio-prøve, hvor et F #-script indlæser fire F # -programfiler og åbner to .NET-biblioteker, før den udfører sin egen kode. Notationen [|…|] brugt her erklærer en matrix. Notationen |> er et fremadrør, der fører resultatet af venstre side til funktionen på højre side. De nye linjer her er ikke syntaktisk signifikante. De gør bare koden lettere at læse end at have hele rørudtryk på en enkelt linje.

F # er funktionel

F # understøtter funktionelle programmeringskonstruktioner såsom behandling af funktioner som værdier ved hjælp af ikke-navngivne funktioner i udtryk, sammensætning af funktioner til dannelse af nye funktioner, curried-funktioner og den implicitte definition af funktioner ved hjælp af delvis anvendelse af funktionsargumenter. I det øverste skærmbillede nedenfor definerer vi og bruger en tilføje fungere. Funktionens krop er indrykket (som Python), og argumenttyperne udledes som heltal på grund af + operatør. I det nederste skærmbillede giver vi en typebetegnelse efter argumentnavnet ved hjælp af et kolon og et typenavn, så F # ved, at udtryk er en snor type.

F # er kortfattet

Koden nedenfor er en Quicksort-lignende algoritme implementeret i F # (af Scott Wlaschin). Det rec nøgleord angiver, at funktionen er rekursiv. Det match..med syntaks er en kontakt erklæring om steroider, med | angiver tilfælde. Det [] angiver en tom liste. Det firstElem og andre elementer oprettes automatisk.

Bemærk, at der ikke er nogen typedeklarationer nævnt nogen steder i koden, hvilket betyder, at funktionen kan sortere lister, der indeholder enhver type, der understøtter sammenligningsoperatorer. Det sjovt nøgleord er til at definere en anonym lambda-funktion.

lad rec quicksort liste =
  kampliste med
  | [] -> // Hvis listen er tom
  [] // returner en tom liste
   | firstElem :: otherElements -> // Hvis listen ikke er tom
  lad smallerElements = // udtrække de mindre
  andre elementer
  |> List.filter (fun e -> e <firstElem)
  |> quicksort // og sorter dem
  lad largerElements = // udtrække de store
  andre elementer
  |> List.filter (sjovt e -> e> = firstElem)
  |> quicksort // og sorter dem
  // Kombiner de 3 dele til en ny liste, og returner den
  List.concat [smallerElements; [firstElem]; størreElementer]
//prøve
printfn "% A" (kviksort [1; 5; 23; 18; 9; 1; 3])

Til sammenligning kan du se på den traditionelle C # implementering nedenfor.

offentlig klasse QuickSortHelper
{
  offentlig statisk liste QuickSort (listeværdier)
  hvor T: IC sammenlignes
   {
  hvis (værdier.Tæller == 0)
      {
  returner ny liste ();
      }
  // få det første element
   T firstElement = værdier [0];
  // få de mindre og større elementer
 var smallerElements = ny liste ();
  var largerElements = ny liste ();
  for (int i = 1; i <values.Count; i ++) // i starter ved 1
 {// ikke 0!
 var elem = værdier [i];
  hvis (elem.CompareTo (firstElement) <0)
         {
  smallerElements.Add (elem);
         }
  andet
         {
  largerElements.Add (elem);
         }
      }
  // returnere resultatet
 var resultat = ny liste ();
  result.AddRange (QuickSort (smallerElements.ToList ()));
  result.Add (firstElement);
  result.AddRange (QuickSort (largeElements.ToList ()));
  returresultat
   }
}

Du vil bemærke, hvor meget ekstra cruft C # -koden har sammenlignet med F # -koden.

F # er virkelig kortfattet

Ifølge Scott Wlaschin har den nedenfor viste version af quicksort - alle fire linjer - det typiske koncise udseende af F # skrevet af en erfaren funktionel koder. Selvfølgelig ville han være den første til at påpege, at det ikke sorterer på plads. Det tog mig flere aflæsninger for at få mening om koden, men det var tiden værd.

lad rec quicksort2 = funktion
   | [] -> []                        
  | først :: hvile ->
  lad mindre, større = List.partition ((> =) først) hvile
  List.concat [quicksort2 mindre; [først]; quicksort2 større]
// testkode
printfn "% A" (quicksort2 [1; 5; 23; 18; 9; 1; 3])

Kort fortalt returnerer den første sag en tom liste, hvis den er bestået, og giver et exitkriterium; det andet tilfælde opdeler listen i det første element og resten og tildeler underlisten startende med den mindre værdi til mindre og den anden underliste til større. Inden for sammenkædningen af underlisterne sorterer funktionen rekursivt mindre og større lister.

F # reducerer fejl gennem stærk skrivning

I modsætning til JavaScript, Ruby og Python er F # stærkt skrevet, ikke dynamisk skrevet. I modsætning til C og C ++, som også er stærkt skrevet, men kræver, at alle typer erklæres, udfører F #, når det er muligt. Når typeafledning ikke er mulig, men typen skal være kendt, kaster F # -kompilatoren en fejl og foreslår, at du angiver en typebetegnelse, som vi var nødt til at gøre i et tidligere eksempel til (sætning: streng) argument til toHackerTalk fungere. Fangst af en typefejltilpasning på kompileringstidspunktet eliminerer en hel klasse af kørselsfejl, som dynamisk typede sprog er tilbøjelige til.

Forresten, F # lade bindinger er uforanderlige, medmindre du specifikt erklærer dem kan ændres.

F # har et stort, velvalgt sæt objekter, herunder List, String og Array

Som du kan se fra IntelliSense nedenfor, har F # rige List-, String- og Array-moduler baseret på .NET Framework. I denne henseende er det også et objektorienteret sprog, selvom det først og fremmest er et funktionelt sprog. Bemærk, at det ikke betyder noget, om du bruger modulnavnet eller et indtastet variabelnavn - når du tilføjer prikken, vises medlemsfunktionerne. Nogle mennesker hævder, at eksplicit at bruge modulnavnet er en bedre stil for et funktionelt sprog end prikkede variabler, men jeg køber ikke det argument helt.

F # er nyttig til MapReduce

MapReduce er en effektiv totrinsproces, der ofte bruges på big data og understøttes eksplicit i Hadoop. I dette F # -eksempel kortlægger og reducerer vi en liste over heltal. Først filtrerer vi listen til lige tal, derefter fordobler vi hvert tal, og til sidst tager vi summen af alle elementerne på listen for at samle eller reducere resultatet. Liste. Kort er en stærk højere ordensfunktion; en højere ordensfunktion er en, der tager en anden funktion som et argument. Ud over lister og arrays understøtter F # poster, sekvenser, datatypeleverandører og LINQ (sprogintegreret forespørgsel).

F # har optegnelser

F # poster repræsenterer enkle aggregater af navngivne værdier, eventuelt med medlemmer. I eksemplet nedenfor definerer vi først a Bestil posttype med fire navngivne værdier, og derefter opretter vi en post ved hjælp af de samme fire navne. F # -compileren udleder korrekt Bestil skriv ved at matche navnene.

F # poster kan have valgfri værdier

Optegnelser behøver ikke altid at medtage alle deres navngivne værdier. Hvis du giver en navngivet værdi, skal mulighed attribut, når du definerer typen, så kan den udelades af en post. Når du indstiller en valgfri værdi, kan den enten være Ingen, der ender som en nul, eller det kan være Nogle efterfulgt af den værdi, du vil indstille. Registreringsfelter adskiller sig fra klasser, fordi de automatisk eksponeres som egenskaber. Klasser og strukturer i F # er .NET klasser og strukturer, der er kompatible med C # og Visual Basic. NET, så jeg vil give afkald på eksempler.

F # har sekvenser

En sekvens i F # er en logisk række af elementer, der alle er af samme type. Sekvenser er især nyttige, når du har en stor, ordnet dataindsamling, men ikke nødvendigvis forventer at bruge alle elementerne. Individuelle sekvenselementer beregnes kun efter behov, så en sekvens kan give bedre ydeevne end en liste i situationer, hvor ikke alle elementerne bruges. Det Sekv modul understøtter manipulationer, der involverer sekvenser. På billedet nedenfor demonstrerer vi enkle sekvenser, sekvenser med udtryk og sekvenser med filtre.

F # understøtter dataudbydere og LINQ

Nedenfor bruger vi TryFSharp-editoren til at åbne et online freebase meteorologi datasæt og forespørge dataudbyderen for cykloner, der har registreret de højeste vindværdier. Det forespørgsel {} syntaks implementerer LINQ til F #. Brug af denne DLL er specifik for TryFSharp. I Visual Studio ville du åbn Microsoft.FSharp.Data.TypeProviders og brug derefter den relevante dataudbydertjeneste.

Resultatet:

[Orkanen Andrew; Orkanen Hugo; 1900-orkanen i Galveston;

Tropisk storm Allison; Cyclone Tracy; Orkanen Iniki; Orkanen Ivan;

1999 Odisha-cyklon; Orkanen Katrina; Typhoon Talim; Orkanen Rita;

Typhoon Herb; Orkanen Wilma; Typhoon Vera; 1962 Pacific tyfonsæsonen;

Typhoon Ike; Typhoon Mireille; Typhoon Babe; Tropisk storm Arlene;

Orkanen Irene; Typhoon Zeb; Typhoon Maemi; Typhoon Bess; Typhoon Chanchu;

Typhoon Patsy; Typhoon Ewiniar; Orkanen Ioke; Typhoon Xangsane;…

F # kan analysere Hadoop-data

I dette eksempel bruger vi TryFsharp-editoren til at åbne en Hadoop Hive-forekomst, der blandt andet indeholder datasæt, målinger af irisblomstfunktioner sammen med måleenheder. Derfor har vi aktiveret brugen af enhedsbemærkninger i egenskaberne af HiveTypeProvider.

Denne beregning returnerer:

val avgPetalLength: float = 0,0374966443

F # laver mønstermatchning

F # match udtryk giver forgreningskontrol, der er baseret på sammenligningen af et udtryk med et sæt mønstre. Linje 1-7 i eksemplet nedenfor definerer en rekursiv er Palindrome fungere. Linjer 8-10 definerer en indpakningsfunktion til er Palindrome der kalder det første gang ved hjælp af hele strengen. Fordi "aba" er et palindrom, er derefter klausul om linje 9 affyrer og returnerer Nogle s, og match udsagn i linje 11 genererer “Strengen aba er palindrom”. Det _ mønster i linje 14 er standardtilstanden.

Det match .. | erklæring i F # har mange fordele i forhold til skifte..hylster erklæring i C #, C ++ og Java, hvoraf det vigtigste er, at det forårsager færre fejl.

F # understøtter asynkrone arbejdsgange

F # har adgang til alle .NET Framework, men det har også sin egen syntaks for asynkrone arbejdsgange. Det asynkronisering {udtryk} syntaks definerer en ikke-blokerende beregning. Det gør! nøgleord udfører en asynkron handling og venter på resultatet. Det lade! nøgleordet venter på en asynkron operation og tildeler resultatet. Og brug! venter på en asynkron operation, tildeler resultatet og frigiver ressourcen. Async.RunSynchronously udfører en asynkron operation og venter på resultatet. For at tilføje parallelitet skal du bruge Async. parallel funktion, som tager en liste over Async objekter, indstiller koden for hver Async opgaveobjekt til at køre parallelt og returnerer et Async objekt, der repræsenterer den parallelle beregning. Rør derefter resultatet til Async.RunSynchronously. (Eksemplet nedenfor er fra F # for sjov og fortjeneste.)