F# programowanie funkcyjne w.net ((bo każdy lubi programowanie funkcyjne))

Transkrypt

1 F# programowanie funkcyjne w.net ((bo każdy lubi programowanie funkcyjne)) Marek Sawerwain Instytut Sterowania i Systemów Informatycznych Uniwersytet Zielonogórski M.Sawerwain@issi.uz.zgora.pl tel. (praca): pok. 328a A-2, ul. prof. Z.Szafrana 2, Zielona Góra IT Academy Day 14 listopada 2013 WEIT, UZ, Zielona Góra V1.0 1/ 45

2 Spis treści 1 Wprowadzenie Historia języka F# Książki, książki,... 2 Pierwsze kroki z F# Wyrażenia let jak szwajcarski scyzoryk do wszystkiego if, for, while czasem się przydają Typowe konstrukcje F# Rekurencja Listy Szybko i zwięźle o sortowaniu Tablice 3 F# krok dalej Klasy i obiekty Definicja nowych operatorów Zapytania LINQ Analiza wyrażeń arytmetycznych Aplikacje GUI 4 Podsumowanie Dodatkowe informacje V1.0 2/ 45

3 Historia języka F# Programowanie funkcyjne i F# Krótki rys historyczny Język F# zyskał sporą popularność od momentu pojawienia się pierwszej wersji razem ze środowiskiem Visual Studio Prace na F# rozpoczęły się już w roku Rozpoczęto wtedy prace nad adaptacją rozwiązań funkcyjnych opartych o języki z rodziny ML dla platformy.net, również w kontekście typów uogólnionych. Grupa, która zajmowała się tymi zagadnieniami, wzorowała się też na języku Ocaml. Głównym architektem jezyka F# jest Don Syme. V1.0 3/ 45

4 Historia języka F# Główne fakty o F# Główne fakty dotyczące języka F#: pierwsze produkcyjne wydanie F# pojawiło się w Visual Studio 2010, najnowsza wersja to F# 3.1 dostępny w Visual Studio 2013, istnieje kompilator Open Source, na razie wspiera wersję 3.0, programy F# a także kompilator, współpracuje z platformą Mono, co zapewnia multiplaformowość, wspiera różne paradygmaty (style) programowania, a ostatnio, w dobrym tonie jest pisanie w programów F#. V1.0 4/ 45

5 Historia języka F# Paradygmaty w języku F# Język F# jest językiem programowania wspierającego kilka paradygmatów programowania w ramach platformy.net: Uwaga F# wspiera programowanie funkcyjne, w tym stylu metody programowania podkreślają co program na zrobić, bez ścisłego określenia jak program powinien pracować, wspierane jest także programowanie obiektowe, dostępne są min. klasy abstrakcyjne, a powstałe klasy naturalnie zgodne są z modelem obiektowym dostępnym w.net, wspierana są również techniki programowania imperatywnego, co pozwala na łatwą obsługę plików, czy obsługę sieci, język F# jest językiem statycznie silnie typowalnym, co oznacza iż typ jest znany na etapie kompilacji, F# jest językiem należącym do platformy.net, działa w ramach CLI, co pozwala na wykorzystywanie możliwości platformy jak min. garbage collection, możliwy jest dostęp do zbioru klas, oraz do takich pojęć jak delegaci, zdarzenia i etc. Podsumowując, F# obejmuje głównie paradygmat obiektowy oraz funkcyjny, gdzie funkcje są funkcjami tzw. pierwszej klasy. V1.0 5/ 45

6 Książki, książki,... Literatura o języku F# Pozycja (elektroniczna) w języku polskim: Marian Mysior, Język F# w praktyce, 2012 W języku angielskim: Don Syme, Adam Granicz, Antonio Cisternino, Expert F# 3.0, Apress, 2012 Chris Smith, Programming F# 3.0, 2nd Edition, O Reilly Media, 2012 Informacje o innych książkach: V1.0 6/ 45

7 Książki, książki,... F# środowisko pracy Główne środowisko pracy to naturalnie Visual Studio wersje 2010, 2012, 2013, dostępne jest też SharpDevelop oraz MonoDevelop: V1.0 7/ 45

8 Książki, książki,... F# środowisko pracy Główne środowisko pracy to naturalnie Visual Studio wersje 2010, 2012, 2013, dostępne jest też SharpDevelop oraz MonoDevelop: V1.0 8/ 45

9 Programy w języku F#, mogą być bardzo krótkie, a nawet składać się tylko z jednej linii: let x = 2 in printfn "%d+%d=%d" x x (x+x) Naturalnie można podać wyrażenie pełniące rolę funkcji głównej: [<EntryPoint>] let main argv = printfn "Hello World!" 0 Jednakże o tym iż określony symbol pełni rolę funkcji głównej decyduje atrybut [<EntryPoint>]: [<EntryPoint>] let ZielonaGóraStacjaGłówna argv = printfn "Witaj Świecie!" 0 Uwaga Pod spinaczem, znajdują się kody źródłowe prezentowanych przykładów. V1.0 9/ 45

10 Poprawny i pełny program w F#, podobny do C#: open System [<EntryPoint>] let main (args : string[]) = if args.length <> 2 then failwith "Błąd: nie podano dwóch parametrów" let greeting, thing = args.[0], args.[1] let timeofday = DateTime.Now.ToString("hh:mm tt") printfn "%s, %s o godzinie %s" greeting thing timeofday 0 V1.0 10/ 45

11 Programy w F# wykonują się od góry do dołu: open System let rec fib = function 0 -> 0 1 -> 1 n -> fib (n - 1) + fib (n - 2) let mainfun() = Console.WriteLine("fib 5: {0}", (fib 5)) mainfun() Uwaga Jednak warto pisać programy porządnie, tzn. jawnie wskazywać funkcję główną. V1.0 11/ 45

12 Wyrażenia let jak szwajcarski scyzoryk do wszystkiego Konstrukcja let Podstawowym wyrażeniem w F# jest wiązanie symbolu z wartością za pomocą słowa kluczowego let. Wyrażenie let let symbol = wyrażenie Wiązania, symbole, zmienne Wiązania nie należy utożsamiać z przypisaniem wartości do zmiennej, jak to zwykle bywa w językach takich jak C++ czy Java, bowiem symbol powiązany z wartością nie może zostać zmieniony w lokalnej przestrzeni nazw. Operacja przypisania jest reprezentowana przez operator <-. Jeśli chcemy zmienić wartość symbolu, czyli traktować go jako tradycyjną zmienną, musimy dodać słowo mutable: Wyrażenie let z mutable let mutable x = 10 V1.0 12/ 45

13 Wyrażenia let jak szwajcarski scyzoryk do wszystkiego Konstrukcja let Przykładem let: let n = 42 let str = "Hello world!" Wyrażenie let kreuje także funkcje: let sqr v = v * v ;; albo let add20 n = n + 20 ;; Wyrażenia let mogą się zagnieżdżać jak w poniższym przykładzie obliczającym pojemność kuli: let pojemnośćkuli promień = let pi = (4.0 / 3.0) * pi * promień * promień * promień printfn "%f" (pojemnośćkuli 5.0) V1.0 13/ 45

14 if, for, while czasem się przydają Instrukcja silnego sterowania F# oferuje instrukcję sterującą ze silną kontrolą sterowania, a jest to konstrukcja if... then... else... let result = if System.DateTime.Now.Second % 2 = 0 then "tik" else "tak" printfn "%A" result Jest to bezpośredni odpowiednik następującego przykładu z match: let result = match System.DateTime.Now.Second % 2 = 0 with true -> "tik" false -> "tak" Operatory logiczne to &&,, not. V1.0 14/ 45

15 if, for, while czasem się przydają Pętla for... do Ogólny zapis instrukcji for for identifier = start [ to downto ] finish do body-expression Przykład typowej pętli for: let funexam1() = for i = 1 to 100 do printf "%d " i printfn "" Określenie wartości początkowej i końcowej: let ex1 x y = x - 2*y let ex2 x y = x + 2*y let funexam2 x y = for i = (ex1 x y) to (ex2 x y) do printf "%d " i printfn "" funexam V1.0 15/ 45

16 if, for, while czasem się przydają Pętla for... in Ogólne zapis instrukcji for... in dla przeliczalnego wyrażenia for pattern in enumerable-expression do body-expression Przeglądnięcie listy: let list1 = [ 1; 2; 4; 8; 16 ] for i in list1 do printfn "%d" i Utworzenie i przeglądnięcie sekwencji uporządkowanych par: let seq1 = seq { for i in > (i, i*i) } for (i, isqr) in seq1 do printfn "%d podniesione do kwadratu to %d" is isqr V1.0 16/ 45

17 if, for, while czasem się przydają Pętla for... in Wyświetlenie, co drugiego elementu: let funexam3() = for i in do printf "%d " i printfn "" funexam3() Konwersja liczby całkowitej na postać binarną: let BitsNum = 32 ;; let binary_of_int n = [ for i in BitsNum > if (n >>> i) % 2 = 0 then "0" else "1" ] > String.concat "" ;; let x1 = binary_of_int 1431 ;; let x2 = binary_of_int ( ) ;; Operator > to tzw. pipe-forward operator stosujący lewy argument to prawego np.: 0.5 > Math.Sin. Operator _ pozwala na zignorowanie zmiennej/wzorca w konstrukcji for: let mutable count = 0 for _ in list1 do count <- count + 1 printfn "Długość listy: %d" count V1.0 17/ 45

18 if, for, while czasem się przydają Konstrukcja pętli while Konstrukcja pętli while ma następującą postać: while test-expression do body-expression Typowy iteracyjny przykład zastosowania pętli while: open System let szukajwartości val maxval = let mutable nextiter = true let randomnumbergenerator = new Random() while nextiter do let rand = randomnumbergenerator.next( maxval ) printfn "%d " rand if rand = val then printfn "\nodgadnięto wartość %d!" value nextiter <- false szukajwartości V1.0 18/ 45

19 Typowe konstrukcje F# printfn Wyrażenie let i różne typy danych: let message = "Hello World\r\n\t!" let main() = let dir printfn "%A" message let bytes = "bytesbytesbytes"b printfn "%A" dir let xa = 0xFFy printfn "%A" bytes let xb = 0o7777un printfn "%A" xa let xc = 0b10010UL printfn "%A" xa printfn "%A" xb printfn "%A" xc main() Po wykonaniu tego programu otrzymuje się następujące rezultaty: "Hello World!" "c:\projects" [ 98uy; 121uy; 116uy; 101uy; 115uy; 98uy; 121uy; 116uy; 101uy; 115uy; 98uy; 121uy; 116uy; 101uy; 115uy ] -1y 4095un 18UL V1.0 19/ 45

20 Typowe konstrukcje F# Wcięcia są ważne Ponieważ syntaktyka F# nie stosuje np. nawiasów klamrowych do tworzenie bloków instrukcji, to wcięcia wyznaczają nowe zasięgi zmiennych. let sign v = if v > 0 then 1 else if v = 0 then 0 else -1 Poniższe wyrażenie oblicza liczbę słów w podanym zdaniu: let wordcount (text : string) = let words = text.split > Array.toList in let wordset = Set.ofList words in let numwords = words.length in numwords printfn "Liczba słów: %A" (wordcount "Ile słów jest w tym zdaniu!") V1.0 20/ 45

21 Typowe konstrukcje F# Polecenie match dopasowanie wzorca Wyrażenie match pozwala na porównywanie wartości wyrażenia ze zbiorem wzorców i wybór rezultatu jeśli wyrażenie testowe jest zgodne z jednym ze wzorców: // schemat dla match match test-expression with pattern1 [ when condition ] -> result-expression1 pattern2 [ when condition ] -> result-expression2... // schemat dla funkcji function pattern1 [ when condition ] -> result-expression1 pattern2 [ when condition ] -> result-expression2... W przypadku połączenie match z tworzeniem lambda wyrażeń (słowo fun), schemat jest następujący: fun arg -> match arg with pattern1 [ when condition ] -> result-expression1 pattern2 [ when condition ] -> result-expression2... V1.0 21/ 45

22 Typowe konstrukcje F# Przykłady z match Raz jeszcze funkcja sign, let sign2 v = match v with _ when v > 0 -> 1 _ when v = 0 -> 0 _ when v < 0 -> -1 Typowy przykład dla match: let filter123 x = match x with > printfn "Znaleziono 1, 2 lub 3" a -> printfn "%d" a filter123 3 V1.0 22/ 45

23 Typowe konstrukcje F# Aktywne wzorce Siła polecenia match to tzw. aktywne wzorce, poniżej wzorzec, który w zależności od argumentu zwraca wartość oznaczającą parzystość lub nieparzystość liczby: let ( LParzysta LNieParzysta ) wartość = if wartość % 2 = 0 then LParzysta else LNieParzysta Funkcja testująca parzystość posiada bardo czytelną postać: let TestLiczbyCałkowitej wartość = match wartość with LParzysta -> printfn "liczba %d jest p." wartość LNieParzysta -> printfn "liczba %d jest niep." wartość V1.0 23/ 45

24 Rekurencja Funkcje rekurencyjne Liczby Fibonacciego: let rec fib n = match n with 0 1 -> n _ -> fib (n - 1) + fib (n - 2) Funkcja silnia (ang. factorial): let rec factorial n = match n with 0 -> 1 1 -> 1 n -> n * factorial ( n - 1 ) printfn "(fac 5) = %i" (factorial 5) V1.0 24/ 45

25 Rekurencja Silnia imperatywnie oraz funkcyjnie Definicja funkcji silnia w podejściu funkcyjnym: let rec ffactorial n = if (n = 0) then 1 else n * ffactorial(n - 1) albo let rec ffactorial n = if (n = 0) then 1 else n * ffactorial(n - 1) Wersja imperatywna z pętlą for: let ifactorial n = let mutable ret = 1 for i = 1 to n do ret <- ret * i ret V1.0 25/ 45

26 Listy Listy ważny typ danych Trzy główne pojęcia, lista pusta: let pustalista = [] Operator :: łączy wskazane elementy w listę let lista2 = "jeden" :: "dwa" :: "trzy" :: [] albo let lista3 = ["jeden" ; "dwa" ; "trzy" ] Operator :: ma też drugie zastosowanie, bowiem pozwala na wydzielenie z listy tzw. głowy, tj. pierwszego elementu oraz tzw. ogona lista. Połączenie dwóch list to zadanie dla let lista4 = ["e1"; ["e2"; "d3"; "e5"] V1.0 26/ 45

27 Listy Przykłady z listami Rekurencja do obliczania sumy elementów na liście: let rec sumaelementówlisty L = match L with h::t -> h + sumaelementówlisty t [] -> 0 F# oferuje wiele wbudowanych funkcji np.: operację reduce: let sumaelementówlistyprzezredukcję L = List.reduce (fun x y -> x + y) L Odczytanie ostatniego elementu z listy również można zrealizować poprzez wyznaczanie ogona z listy, aż otrzymamy jeden element: let rec ostatnielementlisty L = match L with [] -> failwith "lista pusta" [v] -> v _::L -> ostatnielementlisty L V1.0 27/ 45

28 Listy Przykłady z listami Ostatni element listy w jednej linii: let ostatnielementlisty2 L = L > List.rev > List.head Poniższa konstrukcja z podanej listy wybierze tylko elementy parzyste, a następnie z wybranych elementów zostanie zbudowana nowa lista: let tylkoparzyste L = List.filter (fun x -> x % 2 = 0) L Lista może też przechowywać tzw. krotki, np. pary elementów typu ciąg znaków i liczba całkowita. let data = [("Xyaz",3); ("Aghdrgs",4); ("Abcd",2); ("Pepsntlsc",1)] let res = data > List.filter (fun (słowo, id) -> słowo.length <= 4) printfn "Krótkie wyrazy : %A" res V1.0 28/ 45

29 Listy Przykłady z listami Odwrócenie kolejności elementów na liście: let revlista = List.rev lista Łącznie list w jedną listę: let listalist = [[2; 3; 5]; [7; 11; 13]; [17; 19; 23; 29]] let rec łączenielist l = match l with głowa :: ogon -> (łączenielist ogon) [] -> [] let liczbypierwsze = łączenielist listalist printfn "%A" liczbypierwsze Zastosowanie operacji do każdego elementu na liście: let rec listmap func list = match list with head :: rest -> func head :: listmap func rest [] -> [] let x = listmap ((+) 1) [1; 2; 3] printfn "%A" x V1.0 29/ 45

30 Szybko i zwięźle o sortowaniu Sortowanie szybkie Sortowanie szybkie, to modelowy przykład stosowany do prezentacji zwięzłości programowania funkcyjnego: let rec qsort1 L = match L with [] -> [] x::xs -> let smaller = [for i in xs do if i <= x then yield i] in let larger = [for i in xs do if i > x then yield i] in qsort1 qsort1 larger;; Można to zapisać krócej bez jawnego powoływania list smaller oraz larger: let rec qsort2 = function [] -> [] x::xs -> qsort2 [for a in xs do if a < x then yield x :: qsort2 [for a in xs do if a >= x then yield a] V1.0 30/ 45

31 Szybko i zwięźle o sortowaniu Sortowanie szybkie Wersja sortowania szybkiego z operacją filtrowania listy konstrukcją List.filter: let rec quicksort l = match l with [] -> [] h::t -> quicksort (List.filter (fun x -> x < h) h :: quicksort (List.filter (fun x -> x >= h) t) V1.0 31/ 45

32 Tablice Tablice Tablice powinny być stosowane w zadaniach gdzie niezbędna jest wysoka wydajność. Definicja tablicy: let arr = [ 1.0; 1.0; 1.0 ];; Tablice mogą być ogromne : let bigarray = Array.zeroCreate<int> ;; Tablice, współpracują operator >, który znakomicie sprawdza się w sekwencyjnym przetwarzaniu tablic: [ ] > Array.filter (fun elem -> elem % 2 <> 0) > Array.choose (fun elem -> if (elem <> 7 && elem <> 13) then Some(elem*elem) else None) > Array.rev > printfn "%A" V1.0 32/ 45

33 Klasy i obiekty Bez klas się nie da F# to język programowania funkcyjnego, ale dziś wiele aplikacji jest pisanych z użyciem klas oraz obiektów. Dlatego, F# oferuje także wsparcie dla klas dostępnych w ramach platformy.net. Zapewnia to możliwość łatwej współpracy z resztą platformy.net. type Base() = member x.getfirststate() = 10 type Sub() = inherit Base() member x.getsecondstate() = 20 let myobject = new Sub() printfn "myobject.state = %i,\nmyobject.otherstate = %i" (myobject.getfirststate()) (myobject.getsecondstate()) V1.0 33/ 45

34 Klasy i obiekty Bez klas się nie da F# to język programowania funkcyjnego, ale dziś wiele aplikacji jest pisanych z użyciem klas oraz obiektów. Dlatego, F# oferuje także wsparcie dla klas dostępnych w ramach platformy.net. Zapewnia to możliwość łatwej współpracy z resztą platformy.net. open System type Vector(x: float, y : float) = member this.x = x member this.y = y static member (~-) (v : Vector) = Vector(-1.0 * v.x, -1.0 * v.y) static member (*) (v : Vector, a) = Vector(a * v.x, a * v.y) static member (*) (a, v: Vector) = Vector(a * v.x, a * v.y) override this.tostring() = this.x.tostring() + " " + this.y.tostring() V1.0 34/ 45

35 Klasy i obiekty Bez klas się nie da Użycie klasy wektor oraz zdefiniowanych operatorów: let v1 = Vector(1.0, 2.0) let v2 = v1 * 2.0 let v3 = 2.0 * v1 let v4 = - v2 printfn "%s" (v1.tostring()) printfn "%s" (v2.tostring()) printfn "%s" (v3.tostring()) printfn "%s" (v4.tostring()) Console.ReadLine() > ignore V1.0 35/ 45

36 Definicja nowych operatorów Nowy operator globalny Można też przeciążać operatory globalne, a nawet tworzyć specjalne własne operatory: let inline (+?) (x: int) (y: int) = x + 2*y printfn "%d" (10 +? 1) Inny przykład bez specjalizacji typów: let inline (+@) x y = x + x * y printfn "%d" (1 +@ 1) printfn "%f" (1.0 +@ 0.5) V1.0 36/ 45

37 Zapytania LINQ Zapytania LINQ od wersji F# 3.0 Prosty przykład zapytania LINQ dla listy o trzech słowach: let słowa = ["słowo"; "marzec"; "abecadło"] Zadaniem tego zapytania jest posortowanie alfabetycznie słów w liście: let r = query { for s in słowa do sortby s select s } Rezultat możemy odczytać w następujący sposób: r > Seq.iter( fun n -> printf "%s " n ) V1.0 37/ 45

38 Zapytania LINQ Zapytania LINQ od wersji F# 3.0 Przykład, dla listy z liczbami: let liczby = [ 5; 4; 1; 3; 9; 8; 6; 7; 2; 0 ] Wyświetlamy tylko te liczby, które są większe od np. pięciu: let Liczba = 5 in query { for l in liczby do where (l < Liczba) select l; } > Seq.iter(fun n -> printf "%d " n) V1.0 38/ 45

39 Analiza wyrażeń arytmetycznych Analiza rożnego rodzaju wyrażeń, a jest to zagadnienie bardzo ważne np. w budowie interpreterów czy kompilatorów, to także domena języka F#, czy ogólnie języków funkcyjnych. open System open FParsec let chars s = pstring s >>. spaces let number = pfloat.>> spaces let numorpunctation = nextcharsatisfiesnot isletter >>. spaces let operators = new OperatorPrecedenceParser<float, unit,unit>() let expr = operators.expressionparser operators.termparser <- number < > between (chars "(") (chars ")") expr V1.0 39/ 45

40 Analiza wyrażeń arytmetycznych Głowna cześć analizatora: operators.addoperator(infixoperator("+", spaces, 1, Associativity.Left, (+))) // usunięte operatory operators.addoperator(infixoperator("^", spaces, 3, Associativity.Right, fun x y -> System.Math.Pow(x, y))) operators.addoperator(prefixoperator("-", spaces, 4, true, fun x -> -x)) operators.addoperator(prefixoperator("sin", numorpunctation, 4, true, System.Math.Sin)) // usunięte funkcje let arithexpr = spaces >>. expr.>> eof let aritheval s = run arithexpr s V1.0 40/ 45

41 Analiza wyrażeń arytmetycznych Część sterująca analizatora: let rec calctest() = printf "> " let strexpr = Console.ReadLine() match strexpr with "quit" -> () _ -> match aritheval strexpr with Success(value, _, _) -> printfn "%A" value ; calctest() Failure(msg, _, _) -> printfn "error: %A" msg do calctest() V1.0 41/ 45

42 Aplikacje GUI Aplikacje GUI Język F# pozwala także na budowanie aplikacje GUI. Niestety, jak dotąd nie ma środowiska graficznego do budowy aplikacji GUI bezpośrednio w F#, przy użyciu graficznych narzędzi jak w np.: C#. Dlatego, trzeba samodzielnie tworzyć obiekty odpowiedzialne za okno i poszczególne kontrolki. let windowsform = new Form() windowsform.text <- "Okno aplikacji okienkowej" albo let windowsform = new Form(Width= 640, Height = 480, Visible = true, Text = "tytuł") Przykład budowy menu: let mainmenu = windowsform.menu <- new MainMenu() let filemenu = windowsform.menu.menuitems.add("&plik") let quititem = new MenuItem("&Wyjście") filemenu.menuitems.add( quititem ) > ignore albo let _ = mfile.menuitems.add(menuitemquit) V1.0 42/ 45

43 Aplikacje GUI Aplikacje GUI obsługa zdarzeń Zamknięcie okna: quititem.click.add(fun _ -> windowsform.close()) Utworzenie okna dialogowego: let SaveFile file text = let dlg = new SaveFileDialog() dlg.filter <- "Pliki tekstowe *.txt *.txt Wszyst...*" dlg.filterindex <- 2 Zapis danych do pliku: if dlg.showdialog() = DialogResult.OK then let sw = new StreamWriter( dlg.filename ) sw.write( richtextbox.text:string ) sw.close( ) else None V1.0 43/ 45

44 Aplikacje GUI Aplikacje GUI obsługa zdarzeń Obsługa zapisu danych, podłączanie zdarzeń i uruchamianie programu: let clbsaveastext _ = match SaveFile filename textrichbox.text with Some file -> SetFilename file None -> () menuitemopen.click.add( clbloadtext ) > ignore menuitemsaveas.click.add( clbsaveastext ) > ignore menuitemquit.click.add( fun _ -> winform.close () ) > ignore menuitemabout.click.add( fun _ -> MessageBox.Show("Super-hyper notatnik w F#!", "O Notatniku") > ignore) > ignore [<STAThread()>] do Application.Run( winform ) V1.0 44/ 45

45 Dodatkowe informacje Zamiast uwag na koniec, spis dodatkowych materiałów w Internecie: 1 Podstawowa strona dotycząca języka F#: 2 Kod źródłowy kompilatora F# oraz najważniejszych pakietów: 3 Obszerny zbiór przykładów dla F#, które można wypróbować on-line: 4 F# PowerPack: 5 Obszerny zbiór przykładów dla F# w tym również przykładów zapytań LINQ: 6 Zbiór 99 problemów wraz z rozwiązaniami w F#: 7 Czasopismo o języku F#: 8 Web-blog głównego architekta F#, Don Symea: Dziękuje za uwagę!!! V1.0 45/ 45