F# language-wskazówki dla początkujących [zamknięty]

Nie chcę się strasznie pieprzyć, ale napisałem kilka postów O F# na moim blogu tutaj i tutaj . Chris Smith (gość z zespołu F# w MS) ma artykuł "F # in 20 minutes" - part 1 i part 2 .

Uwaga musisz być ostrożny, ponieważ najnowszy CTP F# (wersja 1.9.6.0) ma kilka poważnie łamiących zmian w porównaniu do poprzednich wersji, więc niektóre przykłady / tutoriale mogą nie działać bez modyfikacji.

Oto szybkie podsumowanie kilku fajnych rzeczy, może sam dam ci kilka wskazówek, które są wyraźnie bardzo krótkie i prawdopodobnie nie świetne, ale mam nadzieję, że da ci coś do zabawy!:-

Pierwsza uwaga-większość przykładów w Internecie zakłada ,że "lekka składnia" jest włączona. Aby to osiągnąć, użyj następującego wiersza kodu: -

#light

Zapobiega to konieczności wstawiania pewnych słów kluczowych, które są obecne dla zgodności OCaml, a także konieczności zakończenia każdego z nich linia ze średnikami. Zauważ, że użycie tej składni oznacza, że wcięcie definiuje zakres. Stanie się to jasne w późniejszych przykładach, z których wszystkie opierają się na włączonej lekkiej składni.

Jeśli używasz trybu interaktywnego, musisz zakończyć wszystkie polecenia podwójnymi średnikami, na przykład:-

  > #light;;
  > let f x y = x + y;;

  val f : int -> int -> int

  > f 1 2;;
  val it : int = 3

Zauważ, że tryb interaktywny zwraca wynik 'val' po każdej linii. Daje to ważne informacje o definicjach, które tworzymy, na przykład 'val f: int - > int - >int ' wskazuje, że funkcja przyjmująca dwa inty zwraca int.

Zauważ, że tylko w interaktywnych musimy kończyć linie średnikami, kiedy faktycznie definiujemy Kod F# jesteśmy od tego wolni: -)

Definiujesz funkcje za pomocą słowa kluczowego 'let'. Jest to prawdopodobnie najważniejsze słowo kluczowe w całym F# i będziesz go często używać. Na przykład: -

let sumStuff x y = x + y
let sumStuffTuple (x, y) = x + y

Możemy wywołać te funkcje tak:-

sumStuff 1 2
3
sumStuffTuple (1, 2)
3

Uwaga Istnieją dwa różne sposoby definiowania funkcje tutaj - możesz albo oddzielić parametry według białych znaków, albo określić parametry w 'krotkach' (tzn. wartości w nawiasach oddzielone przecinkami). Różnica polega na tym, że możemy użyć "częściowej aplikacji funkcji", aby uzyskać funkcje, które przyjmują mniej niż wymagane parametry, używając pierwszego podejścia, a nie drugiego. Np.: -

let sumStuff1 = sumStuff 1
sumStuff 2
3

Uwaga otrzymujemy funkcję z wyrażenia "sumStuff 1". Kiedy możemy przekazać funkcje równie łatwo, jak dane, które są jako język posiadający "funkcje pierwszej klasy", jest to podstawowa część każdego języka funkcyjnego, takiego jak F#.

Pattern matching jest całkiem fajne, to w zasadzie jak polecenie switch na sterydach(tak, zwinąłem to zdanie z innego F# - ist: -). Możesz robić takie rzeczy jak: -

let someThing x =
  match x with
    | 0 -> "zero"
    | 1 -> "one"
    | 2 -> "two"
    | x when x < 0 -> "negative = " + x.ToString()
    | _ when x%2 = 0 -> "greater than two but even"
    | _ -> "greater than two but odd"

Uwaga używamy symbolu'_', gdy chcemy dopasować do czegoś, ale zwracane wyrażenie nie zależy od danych wejściowych.

Możemy skrócić dopasowanie wzorca używając if, elif i else wymagane wyrażenia: -

let negEvenOdd x = if x < 0 then "neg" elif x % 2 = 0 then "even" else "odd"

Listy F# (które są zaimplementowane jako listy połączone pod spodem) mogą być manipulowane w ten sposób:-

let l1 = [1;2;3]
l1.[0]
1

let l2 = [1 .. 10]
List.length l2
10

let squares = [for i in 1..10 -> i * i]
squares
[1; 4; 9; 16; 25; 36; 49; 64; 81; 100]

let square x = x * x;;
let squares2 = List.map square [1..10]
squares2
[1; 4; 9; 16; 25; 36; 49; 64; 81; 100]

let evenSquares = List.filter (fun x -> x % 2 = 0) squares
evenSqares
[4; 16; 36; 64; 100]

Zwróć uwagę na Listę.funkcja map "mapuje" funkcję kwadratową na liście od 1 do 10, tzn. stosuje funkcję do każdego elementu. Lista.filtruj' filtruje ' listę, zwracając tylko wartości z listy, które pasują do dostarczonej funkcji predykatu. Zwróć również uwagę na składnię 'fun x - > f' - to jest F# lambda.

Zauważ, że w całym nie zdefiniowaliśmy żadnych typów-f # kompilator/interpreter 'wywiera' typy, tzn. wypracowuje to, czego chcesz od użycia. Na przykład: -

let f x = "hi " + x

Tutaj kompilator / interpreter określi, że X jest ciągiem znaków, ponieważ wykonujesz operację, która wymaga, aby x był ciągiem znaków. Określa również, że zwracany typ będzie również string.

W przypadku niejednoznaczności kompilator przyjmuje założenia, na przykład:-

let f x y = x + y

Tutaj x i y mogą być różnymi typami, ale domyślnie kompilator to int. Jeśli chcesz zdefiniować typy, możesz użyć adnotacji typu: -

let f (x:string) y = x + y

Zauważ również, że musieliśmy zamknąć x:string w nawiasach, często musimy to zrobić, aby oddzielić części definicji funkcji.

Dwa bardzo przydatne i mocno używane operatory W F# to odpowiednio operatory pipe forward I function composition |> i>>.

Definiujemy | > tak:-

let (|>) x f = f x

Zauważ, że możesz definiować operatory W F#, jest to całkiem fajne :-).

To pozwala pisać rzeczy w jaśniejszy sposób, np.:-

[1..10] |> List.map (fun x -> x * x) |> List.filter (fun x -> x % 2 = 0)

Pozwoli ci uzyskać pierwsze 10 parzystych kwadratów. To jest jaśniejsze niż: -

List.filter (fun x -> x % 2 = 0) (List.map (fun x -> x * x) [1..10])

Cóż, przynajmniej tak myślę: -)

Skład funkcji zdefiniowany operatorem > > definiuje się następująco:-

let (>>) f g x = g(f(x))

Tzn. można wykonać operację tylko parametr pierwszej funkcji pozostaje nieokreślony. Jest to przydatne, ponieważ możesz wykonać następujące czynności:-

let mapFilter = List.map (fun x -> x * x) >> List.filter (fun x -> x % 2 = 0)

Tutaj mapFilter zaakceptuje listę i zwróci listę przefiltrowaną jak poprzednio. Jest to skrócona wersja: -

let mapFilter = l |> List.map (fun x -> x * x) |> List.filter (fun x -> x % 2 = 0)

Jeśli chcemy zapisać funkcje rekurencyjne, musimy zdefiniować funkcję jako rekurencyjną, umieszczając ' rec ' po let. Przykłady poniżej.

fajne rzeczy:-

Factorial

let rec fact x = if x <= 1 then 1 else x * fact (x-1)

N-Ta Liczba Fibonacciego

let rec fib n = if n <= 1 then n else fib (n-1) + fib (n-2)

FizzBuzz

let (/%) x y = x % y = 0
let fb = function
  | x when x /% 15 -> "FizzBuzz"
  | x when x /% 3  -> "Fizz"
  | x when x /% 5  -> "Buzz"
  | x              -> x.ToString()

[1..100] |> List.map (fb >> printfn "%s")

W każdym razie to jest bardzo krótki przegląd, mam nadzieję, że trochę pomoże!!