Tomas Petricek. F# Language Overview

Transcription

1 Tomas Petricek F# Language Overview

2 Master student of computer science at Charles University Prague Bachelor thesis on AJAX development with meta programming under Don Syme Microsoft C# MVP Numerous articles and several open source projects Article published on his personal website Tomas Petricek 2/33

3 Research project at Microsoft (2005).NET language Visual Studio integration Multi paradigm Strongly functional Core ML and Ocaml inspired F# 3/33

4 Functional programming Imperative and object-oriented programming Language oriented programming (Briefly) Related C# constructs in green Article Overview 4/33

5 Functional Style Language Features 5/33

6 fsi.exe (F# Interactive Console) VFSI (Visual Studio) Alt-Enter Visual Studio #Light;; Running Code 6/33

7 Strongly typed with type inference Basic data types Tuple Discriminated union Record Array List Function Object Types 7/33

8 > let tuple = (42, "Hello world!");; val tuple : int * string > let (num, str) = tuple;; val num : int val str : string Good for returning multiple values Tuples (C# Anonymous Types) 8/33

9 > // Declaration of the 'Expr' type type Expr = Binary of string * Expr * Expr Variable of string Constant of int;; (...) > // Create a value 'v' representing 'x + 10' let v = Binary("+", Variable "x", Constant 10);; val v : Expr Discriminatied Union 9/33

10 > let rec eval x = match x with Binary(op, l, r) -> Constant(n) -> n;; val eval : Expr -> int let (lv, rv) = (eval l, eval r) if (op = "+") then lv + rv elif (op = "-") then lv - rv else failwith "Unknown operator!" Variable(var) -> getvariablevalue var Discriminated Union Pattern Matching 10/33

11 > // Declaration of a record type type Product = { Name:string; Price:int };; > // Constructing a value of the 'Product' type > // Creating a copy with different 'Name' let p2 = { p with Name="Test2" };; //Note that slightly different copies are easy to make val p2 : Product let p = { Name="Test"; Price=42; };; val p : Product > p.name;; val it : string = "Test" Records (C# Structs) 11/33

12 > let nums = [1; 2; 3; 4; 5];; val nums : list<int> // Not.NET List! > let rec sum list = match list with h::tail -> (sum tail) + h [] -> 0 val sum : list<int> -> int Lists 12/33

13 > // 'acc' is usually called an 'accumulator' variable let rec sumaux acc list = match list with h::tail -> sumaux (acc + h) tail [] -> acc val sum : int -> list<int> -> int > let sum list = sumaux 0 list val sum : list<int> -> int Lists - Tail-Calls 13/33

14 > let createadder n = (fun arg -> n + arg);; val createadder : int -> int -> int > let add10 = createadder 10;; val add10 : int -> int > add10 32;; val it : int = 42 Functions 14/33

15 > let add a b = a + b;; val add : int -> int -> int > let add10 = add 10;; val add10 : int -> int Read left-to-right, each parameter actually results in a function being returned Functions - Currying 15/33

16 > let odds = List.filter (fun n -> n%2 <> 0) [1; 2; 3; 4; 5];; val odds : list<int> = [1; 3; 5] > let squares = List.map (fun n -> n * n) odds;; val squares : list<int> = [1; 9; 25] C# Lambda Expressions Functions Generics and Higher Order Functions 16/33

17 > let nums = [1; 2; 3; 4; 5];; val nums : list<int> > let odds_plus_ten = nums > List.filter (fun n-> n%2 <> 0) > List.map (add 10) // Note: Is a function val odds_plus_ten : list<int> = [11; 13; 15];; Implemented to solve ugly code Functions Pipelining 17/33

18 C# alternatives Extension methods and lambda expressions var evenunderten = ints.where(i => i % 2 == 0).Where(i => i < 10); LINQ var evenundertenlinq = from i in ints where i % 2 == 0 where i < 10 select i; Functions Pipelining 18/33

19 Classic notation: g o f or f(g(x)) > (fst >> String.uppercase) ("Hello world", 123);; val it : string = "HELLO WORLD" // fst is a function which takes the first element in a tuple > let data = [ ("Jim", 1); ("John", 2); ("Jane", 3) ];; val data : (string * int) list > data > List.map (fst >> String.uppercase);; val it : string list = ["JIM"; "JOHN"; "JANE"] Function Composition 19/33

20 Imperative and OOP Style Language Features 20/33

21 Necessary features for imperative style Eager evaluation Mutable types > // Imperative factorial calculation let n = 10 let mutable res = 1 for n = 2 to n do res <- res * n // Return the result res;; val it : int = Imperative Support 21/33

22 Classic mutable array > let arr = [ ] val arr : array<int> > for i = 0 to 9 do arr.[i] < arr.[i] > arr;; val it : array<int> = [ 10; 9; 8; 7; 6; 5; 4; 3; 2; 1 ] Array 22/33

23 Must work with the OOP style Base Class Library Demands: Mutability, side effects and eager evaluation > let list = new ResizeArray<_>() // Alias for System.Collections.Generic.List list.add("hello") list.add("world") Seq.to_list list;; // To F# list val it : string list = ["hello"; "world"].net Interoperability 23/33

24 Compiles into CLR classes Fully compatible with other.net languages Supports Single inheritance Multiple interfacing Subtyping Dynamic type testing All object types inherit from 'obj' which is an alias for System.Object Object Types 24/33

25 // Constructor type MyCell(n:int) = // Field let mutable data = n + 1 do printf "Creating MyCell(%d)" n // Property member x.data with get() = data and set(v) = data <- v // Methods member x.print() = printf "Data: %d" data override x.tostring() = sprintf "(Data: %d)" data static member FromInt(n) = MyCell(n) Object Type 25/33

26 // Interface definition type AnyCell = abstract Value : int with get, set abstract Print : unit -> unit // Interface implementation type ImplementCell(n:int) = let mutable data = n + 1 interface AnyCell with member x.print() = printf "Data: %d" data member x.value with get() = data and set(v) = data <- v Object Types - Interfaces 26/33

27 Implement interface on the fly > let newcell n = // Function which returns new cell with n as data let data = ref n // Reference { new AnyCell with member x.print() = printf "Data: %d" (!data) member x.value with get() =!data // Dereferencing and set(v) = data:=v };; // { } is the object expression val newcell : int -> AnyCell Object Expressions 27/33

28 Language Oriented Programming 28/33

29 Is a key feature of F# The concept of LOP is to create Domain Specific Languages It can be done in several ways but the article focuses on those which use a subset of F# rather than creating new/other languages Language Oriented Programming 29/33

30 Discriminating union as declarative language Active patterns Creates different views of the same data Less code to transform data Computation expressions for transforming code structures More... (Quotation) Purpose is to allow developers to think only in the abstraction of the domain (remove scaffolding code) Language Oriented Programming - Features 30/33

31 Article Clean and concentrated information Well written Some code was unexplained (or only explained later) Part 4 is less coherent and seems undirected Personal Observations 31/33

32 OOP can does also support Language Oriented Programming to some extent F# looks to be an interesting and promising language, mainly because of.net interoperability. Language oriented programming syntax needs more work Personal Observations 32/33

33 ? Questions 33/33