Kom igång med F# i Visual Studio för Mac

  • Artikel

Viktigt!

Microsoft har meddelat att Visual Studio för Mac upphör. Visual Studio för Mac stöds inte längre från och med den 31 augusti 2024. Alternativen är:

Mer information finns i Visual Studio för Mac-meddelande om pensionering.

F# stöds i Visual Studio för Mac IDE. Kontrollera att Visual Studio för Mac är installerat.

Skapa ett konsolprogram

Ett av de mest grundläggande projekten i Visual Studio för Mac är konsolprogrammet. Så här gör du. När Visual Studio för Mac är öppet:

  1. På menyn Arkiv pekar du på Ny lösning.

  2. I dialogrutan Nytt projekt finns det två olika mallar för konsolprogram. Det finns en under Andra –> .NET som riktar sig till .NET Framework. Den andra mallen finns under .NET Core –> App som riktar sig till .NET Core. Båda mallarna bör fungera i den här artikeln.

  3. Under konsolappen ändrar du C# till F# om det behövs. Välj knappen Nästa för att gå vidare!

  4. Ge projektet ett namn och välj de alternativ som du vill använda för appen. Observera att förhandsgranskningsfönstret på sidan av skärmen som visar den katalogstruktur som ska skapas baserat på de alternativ som valts.

  5. Klicka på Skapa. Nu bör du se ett F#-projekt i Solution Explorer.

Skriva koden

Vi börjar med att skriva kod först. Kontrollera att Program.fs filen är öppen och ersätt dess innehåll med följande:

module HelloSquare

let square x = x * x

[<EntryPoint>]
let main argv =
    printfn "%d squared is: %d!" 12 (square 12)
    0 // Return an integer exit code

I föregående kodexempel har en funktion square definierats som tar en indata med namnet x och multiplicerar den med sig själv. Eftersom F# använder typinferens behöver inte typen av x anges. F#-kompilatorn förstår vilka typer av multiplikation som är giltig och tilldelar en typ till x baserat på hur square anropas. Om du hovra över squarebör du se följande:

val square: x:int -> int

Det här kallas funktionens typsignatur. Det kan läsas så här: "Kvadrat är en funktion som tar ett heltal med namnet x och producerar ett heltal". Observera att kompilatorn gav squareint typen för tillfället – det beror på att multiplikation inte är generisk för alla typer, utan snarare är generisk över en sluten uppsättning typer. F#-kompilatorn har valts int just nu, men den justerar typsignaturen om du anropar square med en annan indatatyp, till exempel en float.

En annan funktion, main, definieras, som är dekorerad med EntryPoint attributet för att berätta för F#-kompilatorn att programkörningen ska starta där. Den följer samma konvention som andra programmeringsspråk i C-stil, där kommandoradsargument kan skickas till den här funktionen och en heltalskod returneras (vanligtvis 0).

Det är i den här funktionen som vi anropar square funktionen med argumentet 12. F#-kompilatorn tilldelar sedan den typ av square som ska vara int -> int (det vill: en funktion som tar en int och genererar en int). Anropet till printfn är en formaterad utskriftsfunktion som använder en formatsträng som liknar programmeringsspråk i C-format, parametrar som motsvarar de som anges i formatsträngen och sedan skriver ut resultatet och en ny rad.

Köra koden

Du kan köra koden och se resultat genom att klicka på Kör från menyn på den översta nivån och sedan Starta utan felsökning. Detta kör programmet utan felsökning och gör att du kan se resultatet.

Du bör nu se följande skrivs ut till konsolfönstret som Visual Studio för Mac dök upp:

12 squared is 144!

Grattis! Du har skapat ditt första F#-projekt i Visual Studio för Mac, skrivit en F#-funktion som skrivit ut resultatet av att anropa funktionen och kört projektet för att se några resultat.

Använda interaktivT F#

En av de bästa funktionerna i F#-verktyg i Visual Studio för Mac är det interaktiva F#-fönstret. Det gör att du kan skicka kod till en process där du kan anropa koden och se resultatet interaktivt.

Om du vill börja använda den markerar du funktionen square som definierats i koden. Klicka sedan på Redigera på menyn på den översta nivån. Välj sedan Skicka markeringen till F# Interactive. Detta kör koden i det interaktiva F#-fönstret. Du kan också högerklicka på markeringen och välja Skicka markeringen till F# Interactive. Du bör se det interaktiva F#-fönstret med följande i det:

>

val square: x: int -> int

>

Detta visar samma funktionssignatur för square funktionen, som du såg tidigare när du hovrade över funktionen. Eftersom square nu har definierats i den interaktiva F#-processen kan du anropa den med olika värden:

> square 12;;
val it: int = 144
> square 13;;
val it: int = 169

Detta kör funktionen, binder resultatet till ett nytt namn itoch visar typen och värdet för it. Observera att du måste avsluta varje rad med ;;. Så här vet F# Interactive när funktionsanropet är klart. Du kan också definiera nya funktioner i F# Interactive:

> let isOdd x = x % 2 <> 0;;

val isOdd: x: int -> bool

> isOdd 12;;
val it: bool = false

Ovanstående definierar en ny funktion, isOdd, som tar en int och kontrollerar om det är konstigt! Du kan anropa den här funktionen för att se vad den returnerar med olika indata. Du kan anropa funktioner i funktionsanrop:

> isOdd (square 15);;
val it: bool = true

Du kan också använda pipe-forward-operatorn för att pipelines värdet till de två funktionerna:

> 15 |> square |> isOdd;;
val it: bool = true

Pipe-forward-operatorn med mera beskrivs i senare självstudier.

Det här är bara en inblick i vad du kan göra med F# Interactive. Mer information finns i Interaktiv programmering med F#.

Nästa steg

Om du inte redan har gjort det kan du titta på Tour of F#, som omfattar några av kärnfunktionerna i F#. Det ger dig en översikt över några av funktionerna i F#, och innehåller gott om kodexempel som du kan kopiera till Visual Studio för Mac och köra. Det finns också några bra externa resurser som du kan använda, som visas i F#-guiden.

Se även