Förord

Vad är unit för datatyp, hur används ignore function och tuples.

Innehåll

Unit()
------
Unit ett värde som representerar ingenting och unit typen kan jämföras med void i C#.
F# är en funktionellt språk och i funktionella språk måste alla funktioner returnera nånting och värdet null ogilas av funktionella språk.
Men om en funktion som exempel bara skriver ut ett värde till konsolen så måste den ändå returnera nånting.
Funktioner som inte returnerar något värde måste i F# returnera unit.

xemple:

let x = ()

FSharp interactive svarar:
val x : unit


let print s =
printfn "%A" s

print "PelleSoft"

"PelleSoft"
val it : unit = ()

ignore funktion:
---------------
Om du inte vill ta om hand om returvärdet unit() så kan du ignorera värdet från en funktion som returnerar unit.
Då använder du ignore funktionen.

Square funktionen returnerar en int.

let square x = x * x

val square : int -> int


square 10

val it : int = 100

Genom att ignorera svaret från square funktionen så returneras värdet unit istället.

ignore (square 10)

// Eller lite coolare syntax
square 10 |> ignore

val it : unit = ()


Tuples:
-------
Med tuples kan man gruppera relaterade värden utan att behöva skapa en datatyp som håller ihop alla värden.
Om en funktion returnerar flera värden så grupperar du dom i en tuple och returnerar den istället.
Eller om en funktion tar ett antal parametrar så kan man skicka in en tuple som parameter istället.
En tuple kan innehålla vilka datatyper som helst och även en eller flera nya tuplar.
I bakgrunden så är det System.Tuple som används, samma som i C#.
Tuples är inget nytt i funktionella språk utan har där funnits länge. Men i C# 4.0 så är System.Tuple en ny klass.
Tuples är den enklaste men kanske mest användbara av alla F# datastrukturer.

Man använder sällan direkt System.Tuple utan man deklarerar en tuple oftast såhär:

En tuple med 3 integer värden

let myTuple = (10, 20, 30)

val myTuple : int * int * int = (10, 20, 30)


En tuple med olika värden

let myTuple = (1, "2", 3.0)

val myTuple : int * string * float = (1, "2", 3.0)

En tuple som innehåller en tuple och som skapas utifrån en befintlig tuple

let aNewTuple = (myTuple, 10, "20", 30.0)

val aNewTuple : (int * string * float) * int * string * float =
((1, "2", 3.0), 10, "20", 30.0)

Tuples kan brytas ned i sina olika delar på två sätt.
För par, det vill säga tuples med två element, du kan explicit anropa funktioner fst och snd, som, när deras förkortat namn antyder, extrahera den första och andra delen av paret.

En tuple med två värden.

let tuple = ("first", "second")

val tuple : string * string = ("first", "second")

Hämta ut första och andra värdet med fst och snd.

let first = fst tuple
let second = snd tuple

val first : string = "first"
val second : string = "second"

Innehåller en tuple mer än två värden så kan du hämta värdena såhär.

let tuple = (1, 2, 3, 4, 5)

val tuple : int * int * int * int * int = (1, 2, 3, 4, 5)


let i1, i2, i3, i4, i5 = tuple

val i5 : int = 5
val i4 : int = 4
val i3 : int = 3
val i2 : int = 2
val i1 : int = 1

En funktion som tar en tuple som parameter

let tupleAddFunction (x, y) = x + y

val tupleAddFunction : int * int -> int


let sum = tupleAddFunction (10, 20)

val sum : int = 30

En funktion som returnerar en tuple

let tupleFunktion (x, y) =
(x + y, x * y)

val tupleFunktion : int * int -> int * int


let tuple = tupleFunktion (10, 20)

val tuple : int * int = (30, 200)

Att bryta ner en Tupel och få ut typerna av alla element så kan du använda FSharpType.GetTupleElements metod, som returnerar tillbaka typer av alla elementa som en matris.

let aTuple = ("a string", 10, 20.0)

val aTuple : string * int * float = ("a string", 10, 20.0)


open Microsoft.FSharp.Reflection
let tupleElementTypes = FSharpType.GetTupleElements (aTuple.GetType())

val tupleElementTypes : System.Type [] =
[|System.String; System.Int32; System.Double|]

Om du vill ha ut ett element och inte de andra i en tuple så gör du såhär.
Underscore ignorerar första och tredje elementet i tuplen och x får värdet av den andra elementet.

let _, x, _ = aTuple

val x : int = 10


Du kan följa mig på twitter som @TigerHasse.

0 Kommentarer

Skriv en kommentar på artikeln

Ditt betyg på artikeln

UtmärktLäsvärdIntressantMindre braDålig

Kommentar: