a short introduction to ocaml
play

A Short Introduction to OCaml Jean-Christophe Filli atre September - PowerPoint PPT Presentation

Nov 29, 2022 •205 likes •2.01k views

Ecole Polytechnique INF549 A Short Introduction to OCaml Jean-Christophe Filli atre September 11, 2018 Jean-Christophe Filli atre A Short Introduction to OCaml INF549 1 / 102 overview lecture Jean-Christophe Filli atre labs

  1. procedure a procedure = a function whose result type is unit example # let x = ref 1;; # let set v = x := v;; val set : int -> unit = <fun> # set 3;; - : unit = () # !x;; - : int = 3 Jean-Christophe Filliˆ atre A Short Introduction to OCaml INF549 19 / 102

  2. procedure a procedure = a function whose result type is unit example # let x = ref 1;; # let set v = x := v;; val set : int -> unit = <fun> # set 3;; - : unit = () # !x;; - : int = 3 Jean-Christophe Filliˆ atre A Short Introduction to OCaml INF549 19 / 102

  3. procedure a procedure = a function whose result type is unit example # let x = ref 1;; # let set v = x := v;; val set : int -> unit = <fun> # set 3;; - : unit = () # !x;; - : int = 3 Jean-Christophe Filliˆ atre A Short Introduction to OCaml INF549 19 / 102

  4. procedure a procedure = a function whose result type is unit example # let x = ref 1;; # let set v = x := v;; val set : int -> unit = <fun> # set 3;; - : unit = () # !x;; - : int = 3 Jean-Christophe Filliˆ atre A Short Introduction to OCaml INF549 19 / 102

  5. function without arguments takes an argument of type unit example # let reset () = x := 0;; val reset : unit -> unit = <fun> # reset ();; Jean-Christophe Filliˆ atre A Short Introduction to OCaml INF549 20 / 102

  6. function without arguments takes an argument of type unit example # let reset () = x := 0;; val reset : unit -> unit = <fun> # reset ();; Jean-Christophe Filliˆ atre A Short Introduction to OCaml INF549 20 / 102

  7. function with several arguments # let f x y z = if x > 0 then y + x else z - x;; val f : int -> int -> int -> int = <fun> # f 1 2 3;; - : int = 3 Jean-Christophe Filliˆ atre A Short Introduction to OCaml INF549 21 / 102

  8. function with several arguments # let f x y z = if x > 0 then y + x else z - x;; val f : int -> int -> int -> int = <fun> # f 1 2 3;; - : int = 3 Jean-Christophe Filliˆ atre A Short Introduction to OCaml INF549 21 / 102

  9. local function function local to an expression # let sqr x = x * x in sqr 3 + sqr 4 = sqr 5;; - : bool = true function local to another function # let pythagorean x y z = let sqr n = n * n in sqr x + sqr y = sqr z;; val pythagorean : int -> int -> int -> bool = <fun> Jean-Christophe Filliˆ atre A Short Introduction to OCaml INF549 22 / 102

  10. local function function local to an expression # let sqr x = x * x in sqr 3 + sqr 4 = sqr 5;; - : bool = true function local to another function # let pythagorean x y z = let sqr n = n * n in sqr x + sqr y = sqr z;; val pythagorean : int -> int -> int -> bool = <fun> Jean-Christophe Filliˆ atre A Short Introduction to OCaml INF549 22 / 102

  11. function as first-class citizen function = yet another expression, introduced with fun # fun x -> x+1 - : int -> int = <fun> # (fun x -> x+1) 3;; - : int = 4 internally let f x = x+1;; is identical to let f = fun x -> x+1;; Jean-Christophe Filliˆ atre A Short Introduction to OCaml INF549 23 / 102

  12. function as first-class citizen function = yet another expression, introduced with fun # fun x -> x+1 - : int -> int = <fun> # (fun x -> x+1) 3;; - : int = 4 internally let f x = x+1;; is identical to let f = fun x -> x+1;; Jean-Christophe Filliˆ atre A Short Introduction to OCaml INF549 23 / 102

  13. partial application fun x y -> x*x + y*y is the same as fun x -> fun y -> x*x + y*y one can apply a function partially example # let f x y = x*x + y*y;; val f : int -> int -> int = <fun> # let g = f 3;; val g : int -> int = <fun> # g 4;; - : int = 25 Jean-Christophe Filliˆ atre A Short Introduction to OCaml INF549 24 / 102

  14. partial application fun x y -> x*x + y*y is the same as fun x -> fun y -> x*x + y*y one can apply a function partially example # let f x y = x*x + y*y;; val f : int -> int -> int = <fun> # let g = f 3;; val g : int -> int = <fun> # g 4;; - : int = 25 Jean-Christophe Filliˆ atre A Short Introduction to OCaml INF549 24 / 102

  15. partial application a partial application is a way to return a function but one can also return a function as the result of a computation # let f x = let x2 = x * x in fun y -> x2 + y * y;; val f : int -> int -> int = <fun> a partial application of f computes x*x only once Jean-Christophe Filliˆ atre A Short Introduction to OCaml INF549 25 / 102

  16. partial application: example # let count_from n = let r = ref (n-1) in fun () -> incr r; !r;; val count_from : int -> unit -> int = <fun> # let c = count_from 0;; val c : unit -> int = <fun> # c ();; - : int = 0 # c ();; - : int = 1 Jean-Christophe Filliˆ atre A Short Introduction to OCaml INF549 26 / 102

  17. higher-order functions a function may take functions as arguments # let integral f = let n = 100 in let s = ref 0.0 in for i = 0 to n-1 do let x = float i /. float n in s := !s +. f x done; !s /. float n # integral sin;; - : float = 0.455486508387318301 # integral (fun x -> x*.x);; - : float = 0.32835 Jean-Christophe Filliˆ atre A Short Introduction to OCaml INF549 27 / 102

  18. iteration in Java, one iterates over a collection with a cursor for (Elt x: s) { ... do something with x ... } in OCaml, we typically write iter (fun x -> ... do something with x ...) s where iter is a function provided with the data structure, with type val iter: (elt -> unit) -> set -> unit example iter (fun x -> Printf.printf "%s\n" x) s Jean-Christophe Filliˆ atre A Short Introduction to OCaml INF549 28 / 102

  19. iteration in Java, one iterates over a collection with a cursor for (Elt x: s) { ... do something with x ... } in OCaml, we typically write iter (fun x -> ... do something with x ...) s where iter is a function provided with the data structure, with type val iter: (elt -> unit) -> set -> unit example iter (fun x -> Printf.printf "%s\n" x) s Jean-Christophe Filliˆ atre A Short Introduction to OCaml INF549 28 / 102

  20. difference wrt to function pointers “in C one can pass and return function pointers” but OCaml functions are more than function pointers let f x = let x2 = x * x in fun y -> x2 + y * y;; the value of x2 is captured in a closure note: there are closures in Java ( ≥ 8) too s.forEach(x -> { System.out.println(x); }); Jean-Christophe Filliˆ atre A Short Introduction to OCaml INF549 29 / 102

  21. difference wrt to function pointers “in C one can pass and return function pointers” but OCaml functions are more than function pointers let f x = let x2 = x * x in fun y -> x2 + y * y;; the value of x2 is captured in a closure note: there are closures in Java ( ≥ 8) too s.forEach(x -> { System.out.println(x); }); Jean-Christophe Filliˆ atre A Short Introduction to OCaml INF549 29 / 102

  22. recursive functions in OCaml, it is idiomatic to use recursive functions, for a function call is cheap tail calls are optimized example: let zero f = let rec lookup i = if f i = 0 then i else lookup (i+1) in lookup 0 recursive code ⇒ clearer, simpler to justify Jean-Christophe Filliˆ atre A Short Introduction to OCaml INF549 30 / 102

  23. recursive functions in OCaml, it is idiomatic to use recursive functions, for a function call is cheap tail calls are optimized example: let zero f = let rec lookup i = if f i = 0 then i else lookup (i+1) in lookup 0 recursive code ⇒ clearer, simpler to justify Jean-Christophe Filliˆ atre A Short Introduction to OCaml INF549 30 / 102

  24. polymorphism # let f x = x;; val f : ’a -> ’a = <fun> # f 3;; - : int = 3 # f true;; - : bool = true # f print_int;; - : int -> unit = <fun> # f print_int 1;; 1- : unit = () Jean-Christophe Filliˆ atre A Short Introduction to OCaml INF549 31 / 102

  25. polymorphism # let f x = x;; val f : ’a -> ’a = <fun> # f 3;; - : int = 3 # f true;; - : bool = true # f print_int;; - : int -> unit = <fun> # f print_int 1;; 1- : unit = () Jean-Christophe Filliˆ atre A Short Introduction to OCaml INF549 31 / 102

  26. polymorphism OCaml always infers the most general type example: # let compose f g = fun x -> f (g x);; val compose : (’a -> ’b) -> (’c -> ’a) -> ’c -> ’b = <fun> Jean-Christophe Filliˆ atre A Short Introduction to OCaml INF549 32 / 102

  27. polymorphism OCaml always infers the most general type example: # let compose f g = fun x -> f (g x);; val compose : (’a -> ’b) -> (’c -> ’a) -> ’c -> ’b = <fun> Jean-Christophe Filliˆ atre A Short Introduction to OCaml INF549 32 / 102

  28. recap functions = first-class values: local, anonymous, arguments of other functions, etc. partially applied polymorphic function call is cheap Jean-Christophe Filliˆ atre A Short Introduction to OCaml INF549 33 / 102

  29. memory allocation Jean-Christophe Filliˆ atre A Short Introduction to OCaml INF549 34 / 102

  30. GC memory allocation handled by a garbage collector (GC) benefits: unused memory is reclaimed automatically efficient allocation ⇒ forget about “dynamic allocation is expensive” ... but keep worrying about complexity! Jean-Christophe Filliˆ atre A Short Introduction to OCaml INF549 35 / 102

  31. GC memory allocation handled by a garbage collector (GC) benefits: unused memory is reclaimed automatically efficient allocation ⇒ forget about “dynamic allocation is expensive” ... but keep worrying about complexity! Jean-Christophe Filliˆ atre A Short Introduction to OCaml INF549 35 / 102

  32. arrays # let a = Array.make 10 0;; val a : int array = [|0; 0; 0; 0; 0; 0; 0; 0; 0; 0|] necessarily initialized # let a = [| 1; 2; 3; 4 |];; # a.(1);; - : int = 2 # a.(1) <- 5;; - : unit = () # a;; - : int array = [|1; 5; 3; 4|] Jean-Christophe Filliˆ atre A Short Introduction to OCaml INF549 36 / 102

  33. arrays # let a = Array.make 10 0;; val a : int array = [|0; 0; 0; 0; 0; 0; 0; 0; 0; 0|] necessarily initialized # let a = [| 1; 2; 3; 4 |];; # a.(1);; - : int = 2 # a.(1) <- 5;; - : unit = () # a;; - : int array = [|1; 5; 3; 4|] Jean-Christophe Filliˆ atre A Short Introduction to OCaml INF549 36 / 102

  34. parallel Java OCaml int[] a = new int[42]; let a = Array.make 42 0 a[17] a.(17) a[7] = 3; a.(7) <- 3 a.length Array.length a Jean-Christophe Filliˆ atre A Short Introduction to OCaml INF549 37 / 102

  35. example: insertion sort let insertion_sort a = let swap i j = let t = a.(i) in a.(i) <- a.(j); a.(j) <- t in for i = 1 to Array.length a - 1 do (* insert element a[i] in a[0..i-1] *) let j = ref (i - 1) in while !j >= 0 && a.(!j) > a.(!j + 1) do swap !j (!j + 1); decr j done done Jean-Christophe Filliˆ atre A Short Introduction to OCaml INF549 38 / 102

  36. insertion sort let insertion_sort a = let swap i j = let t = a.(i) in a.(i) <- a.(j); a.(j) <- t in for i = 1 to Array.length a - 1 do (* insert element a[i] in a[0..i-1] *) let rec insert j = if j >= 0 && a.(j) > a.(j+1) then begin swap j (j+1); insert (j-1) end in insert (i-1) done Jean-Christophe Filliˆ atre A Short Introduction to OCaml INF549 39 / 102

  37. records like in most programming languages a record type is first declared type complex = { re : float; im : float } allocation and initialization are simultaneous: # let x = { re = 1.0; im = -1.0 };; val x : complex = {re = 1.; im = -1.} # x.im;; - : float = -1. Jean-Christophe Filliˆ atre A Short Introduction to OCaml INF549 40 / 102

  38. records like in most programming languages a record type is first declared type complex = { re : float; im : float } allocation and initialization are simultaneous: # let x = { re = 1.0; im = -1.0 };; val x : complex = {re = 1.; im = -1.} # x.im;; - : float = -1. Jean-Christophe Filliˆ atre A Short Introduction to OCaml INF549 40 / 102

  39. records like in most programming languages a record type is first declared type complex = { re : float; im : float } allocation and initialization are simultaneous: # let x = { re = 1.0; im = -1.0 };; val x : complex = {re = 1.; im = -1.} # x.im;; - : float = -1. Jean-Christophe Filliˆ atre A Short Introduction to OCaml INF549 40 / 102

  40. mutable fields type person = { name : string; mutable age : int } # let p = { name = "Martin"; age = 23 };; val p : person = {name = "Martin"; age = 23} # p.age <- p.age + 1;; - : unit = () # p.age;; - : int = 24 Jean-Christophe Filliˆ atre A Short Introduction to OCaml INF549 41 / 102

  41. mutable fields type person = { name : string; mutable age : int } # let p = { name = "Martin"; age = 23 };; val p : person = {name = "Martin"; age = 23} # p.age <- p.age + 1;; - : unit = () # p.age;; - : int = 24 Jean-Christophe Filliˆ atre A Short Introduction to OCaml INF549 41 / 102

  42. parallel Java OCaml class T { type t = { final int v; boolean b; v: int; T(int v, boolean b) { mutable b: bool; } this.v = v; this.b = b; } } T r = new T(42, true); let r = { v = 42; b = true } r.b = false; r.b <- false r.v r.v Jean-Christophe Filliˆ atre A Short Introduction to OCaml INF549 42 / 102

  43. references a reference = a record of that predefined type type ’a ref = { mutable contents : ’a } ref , ! and := are syntactic sugar only arrays and mutable fields can be mutated Jean-Christophe Filliˆ atre A Short Introduction to OCaml INF549 43 / 102

  44. references a reference = a record of that predefined type type ’a ref = { mutable contents : ’a } ref , ! and := are syntactic sugar only arrays and mutable fields can be mutated Jean-Christophe Filliˆ atre A Short Introduction to OCaml INF549 43 / 102

  45. references a reference = a record of that predefined type type ’a ref = { mutable contents : ’a } ref , ! and := are syntactic sugar only arrays and mutable fields can be mutated Jean-Christophe Filliˆ atre A Short Introduction to OCaml INF549 43 / 102

  46. tuples usual notation # (1,2,3);; - : int * int * int = (1, 2, 3) # let v = (1, true, "hello", ’a’);; val v : int * bool * string * char = (1, true, "hello", ’a’) access to components # let (a,b,c,d) = v;; val a : int = 1 val b : bool = true val c : string = "hello" val d : char = ’a’ Jean-Christophe Filliˆ atre A Short Introduction to OCaml INF549 44 / 102

  47. tuples usual notation # (1,2,3);; - : int * int * int = (1, 2, 3) # let v = (1, true, "hello", ’a’);; val v : int * bool * string * char = (1, true, "hello", ’a’) access to components # let (a,b,c,d) = v;; val a : int = 1 val b : bool = true val c : string = "hello" val d : char = ’a’ Jean-Christophe Filliˆ atre A Short Introduction to OCaml INF549 44 / 102

  48. tuples useful to return several values # let rec division n m = if n < m then (0, n) else let (q,r) = division (n - m) m in (q + 1, r);; val division : int -> int -> int * int = <fun> function taking a tuple as argument # let f (x,y) = x + y;; val f : int * int -> int = <fun> # f (1,2);; - : int = 3 Jean-Christophe Filliˆ atre A Short Introduction to OCaml INF549 45 / 102

  49. tuples useful to return several values # let rec division n m = if n < m then (0, n) else let (q,r) = division (n - m) m in (q + 1, r);; val division : int -> int -> int * int = <fun> function taking a tuple as argument # let f (x,y) = x + y;; val f : int * int -> int = <fun> # f (1,2);; - : int = 3 Jean-Christophe Filliˆ atre A Short Introduction to OCaml INF549 45 / 102

  50. lists predefined type of lists, α list , immutable and homogeneous built from the empty list [] and addition in front of a list :: # let l = 1 :: 2 :: 3 :: [];; val l : int list = [1; 2; 3] shorter syntax # let l = [1; 2; 3];; Jean-Christophe Filliˆ atre A Short Introduction to OCaml INF549 46 / 102

  51. pattern matching pattern matching = case analysis on a list # let rec sum l = match l with | [] -> 0 | x :: r -> x + sum r;; val sum : int list -> int = <fun> # sum [1;2;3];; - : int = 6 shorter notation for a function performing pattern matching on its argument let rec sum = function | [] -> 0 | x :: r -> x + sum r;; Jean-Christophe Filliˆ atre A Short Introduction to OCaml INF549 47 / 102

  52. pattern matching pattern matching = case analysis on a list # let rec sum l = match l with | [] -> 0 | x :: r -> x + sum r;; val sum : int list -> int = <fun> # sum [1;2;3];; - : int = 6 shorter notation for a function performing pattern matching on its argument let rec sum = function | [] -> 0 | x :: r -> x + sum r;; Jean-Christophe Filliˆ atre A Short Introduction to OCaml INF549 47 / 102

  53. pattern matching pattern matching = case analysis on a list # let rec sum l = match l with | [] -> 0 | x :: r -> x + sum r;; val sum : int list -> int = <fun> # sum [1;2;3];; - : int = 6 shorter notation for a function performing pattern matching on its argument let rec sum = function | [] -> 0 | x :: r -> x + sum r;; Jean-Christophe Filliˆ atre A Short Introduction to OCaml INF549 47 / 102

  54. representation in memory OCaml lists = identical to lists in C or Java the list [1; 2; 3] is represented as 1 2 3 [] Jean-Christophe Filliˆ atre A Short Introduction to OCaml INF549 48 / 102

  55. algebraic data types lists = particular case of algebraic data type algebraic data type = union of several constructors type fmla = True | False | And of fmla * fmla # True;; - : fmla = True # And (True, False);; - : fmla = And (True, False) lists predefined as type ’a list = [] | :: of ’a * ’a list Jean-Christophe Filliˆ atre A Short Introduction to OCaml INF549 49 / 102

  56. algebraic data types lists = particular case of algebraic data type algebraic data type = union of several constructors type fmla = True | False | And of fmla * fmla # True;; - : fmla = True # And (True, False);; - : fmla = And (True, False) lists predefined as type ’a list = [] | :: of ’a * ’a list Jean-Christophe Filliˆ atre A Short Introduction to OCaml INF549 49 / 102

  57. algebraic data types lists = particular case of algebraic data type algebraic data type = union of several constructors type fmla = True | False | And of fmla * fmla # True;; - : fmla = True # And (True, False);; - : fmla = And (True, False) lists predefined as type ’a list = [] | :: of ’a * ’a list Jean-Christophe Filliˆ atre A Short Introduction to OCaml INF549 49 / 102

  58. algebraic data types lists = particular case of algebraic data type algebraic data type = union of several constructors type fmla = True | False | And of fmla * fmla # True;; - : fmla = True # And (True, False);; - : fmla = And (True, False) lists predefined as type ’a list = [] | :: of ’a * ’a list Jean-Christophe Filliˆ atre A Short Introduction to OCaml INF549 49 / 102

  59. pattern matching pattern matching generalizes to algebraic data types # let rec eval = function | True -> true | False -> false | And (f1, f2) -> eval f1 && eval f2;; val eval : fmla -> bool = <fun> Jean-Christophe Filliˆ atre A Short Introduction to OCaml INF549 50 / 102

  60. pattern matching patterns can be nested: let rec eval = function | True -> true | False -> false | And (False, f2) -> false | And (f1, False) -> false | And (f1, f2) -> eval f1 && eval f2;; Jean-Christophe Filliˆ atre A Short Introduction to OCaml INF549 51 / 102

  61. pattern matching patterns can be omitted or grouped let rec eval = function | True -> true | False -> false | And (False, _) | And (_, False) -> false | And (f1, f2) -> eval f1 && eval f2;; Jean-Christophe Filliˆ atre A Short Introduction to OCaml INF549 52 / 102

  62. parallel OCaml Java abstract class Fmla { } type fmla = class True extends Fmla { } | True class False extends Fmla { } | False class And extends Fmla { | And of fmla * fmla Fmla f1, f2; } abstract class Fmla { let rec eval = function abstract boolean eval(); } | True -> true class True { boolean eval() { return true; } } | False -> false class False { boolean eval() { return false; } } | And (f1, f2) -> class And { boolean eval() { eval f1 && eval f2 return f1.eval()&&f2.eval(); } } Jean-Christophe Filliˆ atre A Short Introduction to OCaml INF549 53 / 102

  63. pattern matching pattern matching is not limited to algebraic data types let rec mult = function | [] -> 1 | 0 :: _ -> 0 | x :: l -> x * mult l one may write let pattern = expression when there is a single pattern (as in let (a,b,c,d) = v for instance) Jean-Christophe Filliˆ atre A Short Introduction to OCaml INF549 54 / 102

  64. pattern matching pattern matching is not limited to algebraic data types let rec mult = function | [] -> 1 | 0 :: _ -> 0 | x :: l -> x * mult l one may write let pattern = expression when there is a single pattern (as in let (a,b,c,d) = v for instance) Jean-Christophe Filliˆ atre A Short Introduction to OCaml INF549 54 / 102

  65. recap allocation is cheap memory is reclaimed automatically allocated values are necessarily initialized most values cannot be mutated (only arrays and mutable record fields can be) efficient representation of values pattern matching = case analysis over values Jean-Christophe Filliˆ atre A Short Introduction to OCaml INF549 55 / 102

  66. execution model Jean-Christophe Filliˆ atre A Short Introduction to OCaml INF549 56 / 102

Recommend

State of Multicore OCaml KC Sivaramakrishnan University of OCaml Labs Cambridge Outline

State of Multicore OCaml KC Sivaramakrishnan University of OCaml Labs Cambridge Outline

State of Multicore OCaml KC Sivaramakrishnan University of OCaml Labs Cambridge Outline Overview of the multicore OCaml project Multicore OCaml runtime design Future directions Multicore OCaml Multicore OCaml Add native

932 views • 62 slides
Accessing and using weather data in OCaml Hez Carty - OCaml 2013 MDA Information Systems LLC

Accessing and using weather data in OCaml Hez Carty - OCaml 2013 MDA Information Systems LLC

Accessing and using weather data in OCaml Hez Carty - OCaml 2013 MDA Information Systems LLC Weather and OCaml OCaml - why and where? Library bindings Highs and lows Why OCaml The usual reasons Functional (when you want

503 views • 13 slides
CMSC 430 Introduction to Compilers Spring 2017 Everything (else) you always wanted to know

CMSC 430 Introduction to Compilers Spring 2017 Everything (else) you always wanted to know

CMSC 430 Introduction to Compilers Spring 2017 Everything (else) you always wanted to know about OCaml (but were afraid to ask) OCaml You know it well from CMSC 330 All programming projects will be in OCaml OCaml is well-designed

181 views • 16 slides
OCaml Scope: a New OCaml API Search Jun Furuse - Standard Chartered Bank Who am I? OCaml

OCaml Scope: a New OCaml API Search Jun Furuse - Standard Chartered Bank Who am I? OCaml

OCaml Scope: a New OCaml API Search Jun Furuse - Standard Chartered Bank Who am I? OCaml hacker using Haskell at work What did helped me most in Haskell industry? Type class? Purity? Laziness? It's Hoogle. API Search Engine for Haskell

509 views • 21 slides
Introduction to Functional Programming Using OCaml Romain Bardou July 6, 2011 Introduction to

Introduction to Functional Programming Using OCaml Romain Bardou July 6, 2011 Introduction to

Introduction to Functional Programming Using OCaml Romain Bardou July 6, 2011 Introduction to Functional Programming Using OCaml 1 / 50 Introduction There are two ways to write error-free programs; only the third one works. Alan J.

901 views • 50 slides
Retrofitting a Concurrent GC onto OCaml KC Sivaramakrishnan University of OCaml Labs Cambridge

Retrofitting a Concurrent GC onto OCaml KC Sivaramakrishnan University of OCaml Labs Cambridge

Retrofitting a Concurrent GC onto OCaml KC Sivaramakrishnan University of OCaml Labs Cambridge OCaml industrial-strength, pragmatic, functional programming language Functional core with imperative and Hindley-Milner Type Inference

721 views • 28 slides
High level OCaml optimisations Pierre Chambart, OCamlPro OCaml 2013, 23 September 2013 OCaml is

High level OCaml optimisations Pierre Chambart, OCamlPro OCaml 2013, 23 September 2013 OCaml is

High level OCaml optimisations Pierre Chambart, OCamlPro OCaml 2013, 23 September 2013 OCaml is fast Not an optimising compiler, but: Predictable performances Good generated code What can we do to get faster ? Small modification on high

285 views • 25 slides
Practical Algebraic Effect Handlers in Multicore OCaml KC Sivaramakrishnan University of

Practical Algebraic Effect Handlers in Multicore OCaml KC Sivaramakrishnan University of

Practical Algebraic Effect Handlers in Multicore OCaml KC Sivaramakrishnan University of OCaml Cambridge Labs Multicore OCaml Native support for concurrency and parallelism https://github.com/ocamllabs/ocaml-multicore Led from

526 views • 36 slides
The state of OCaml, 2013 Xavier Leroy INRIA Paris-Rocquencourt OCaml Workshop, 2013-09-24 X.

The state of OCaml, 2013 Xavier Leroy INRIA Paris-Rocquencourt OCaml Workshop, 2013-09-24 X.

The state of OCaml, 2013 Xavier Leroy INRIA Paris-Rocquencourt OCaml Workshop, 2013-09-24 X. Leroy (INRIA) The state of OCaml, 2013 OCaml 2013 1 / 19 Outline OCaml development news 1 OCaml community news 2 Work in progress 3 X. Leroy

413 views • 20 slides
Melt: L A T EX with OCaml Romain Bardou GT ProVal June 11, 2010 L A T EX versus OCaml L A T

Melt: L A T EX with OCaml Romain Bardou GT ProVal June 11, 2010 L A T EX versus OCaml L A T

Melt: L A T EX with OCaml Romain Bardou GT ProVal June 11, 2010 L A T EX versus OCaml L A T EX: OCaml: Beautiful documents Great programming language Lots of macros Lots of packages Motivations for Document Programming

621 views • 34 slides
Multicore OCaml GC KC Sivaramakrishnan, Stephen Dolan University of OCaml Labs Cambridge

Multicore OCaml GC KC Sivaramakrishnan, Stephen Dolan University of OCaml Labs Cambridge

Multicore OCaml GC KC Sivaramakrishnan, Stephen Dolan University of OCaml Labs Cambridge Multicore OCaml Multicore OCaml Adds native support for concurrency and parallelism in OCaml Multicore OCaml Adds native support for concurrency

1.28k views • 115 slides
Profiling the Memory Usage of OCaml Applications without Changing their Behavior OCaml 2013

Profiling the Memory Usage of OCaml Applications without Changing their Behavior OCaml 2013

Profiling the Memory Usage of OCaml Applications without Changing their Behavior OCaml 2013 agdas Bozman 1 , 2 , 3 C Thomas Gazagnaire 1 Fabrice Le Fessant 2 Michel Mauny 3 OCamlPro 1 | INRIA 2 | ENSTA-ParisTech 3 Sept. 24 2013 - Boston (MA)

713 views • 18 slides
Concurrent System Programming with Effect Handlers KC Sivaramakrishnan University of OCaml

Concurrent System Programming with Effect Handlers KC Sivaramakrishnan University of OCaml

Concurrent System Programming with Effect Handlers KC Sivaramakrishnan University of OCaml Cambridge Labs Multicore OCaml Native support for concurrency and parallelism in OCaml Lead from OCaml Labs, University of Cambridge

773 views • 23 slides
Advances in Programming Languages APL3: Row variables in OCaml Ian Stark School of Informatics

Advances in Programming Languages APL3: Row variables in OCaml Ian Stark School of Informatics

Advances in Programming Languages APL3: Row variables in OCaml Ian Stark School of Informatics The University of Edinburgh Thursday 17 January 2008 Semester 2 Week 2 Outline OCaml overview: types, expressions 1 OCaml example: region

676 views • 31 slides
Composable lock-free programming for Multicore OCaml KC Sivaramakrishnan University of OCaml

Composable lock-free programming for Multicore OCaml KC Sivaramakrishnan University of OCaml

Composable lock-free programming for Multicore OCaml KC Sivaramakrishnan University of OCaml Cambridge Labs JVM: java.util.concurrent .Net: System.Concurrent.Collections Synchronization Data structures Reentrant locks Queues Not

263 views • 23 slides
Better typing errors for OCaml Arthur Charguraud Inria 2 Overview State of the art

Better typing errors for OCaml Arthur Charguraud Inria 2 Overview State of the art

Better typing errors for OCaml Arthur Charguraud Inria 2 Overview State of the art Dozens of research papers on reporting type errors in ML... ... none of these ideas ever reached the OCaml compiler! Motivation Get OCaml to

578 views • 16 slides
The state of OCaml, 2012 Xavier Leroy INRIA Paris-Rocquencourt OCaml Users and Developers

The state of OCaml, 2012 Xavier Leroy INRIA Paris-Rocquencourt OCaml Users and Developers

The state of OCaml, 2012 Xavier Leroy INRIA Paris-Rocquencourt OCaml Users and Developers Workshop, 2012-09-14 X. Leroy (INRIA) The state of OCaml, 2012 OUD 2012 1 / 17 Outline OCaml development news 1 OCaml community news 2 X. Leroy

488 views • 19 slides
OCamlot: OCaml Online Testing State for the Open Source OCaml Community David Sheets, Anil

OCamlot: OCaml Online Testing State for the Open Source OCaml Community David Sheets, Anil

OCamlot: OCaml Online Testing State for the Open Source OCaml Community David Sheets, Anil Madhavapeddy, Amir Chaudhry and Thomas Gazagnaire University of Cambridge and OCamlPro OCamlot : OCaml Online Testing The Quality Quality A Typical

583 views • 30 slides
Towards a separation logic for Multicore OCaml Glen Mvel , Jacques-Henri Jourdan, Franois

Towards a separation logic for Multicore OCaml Glen Mvel , Jacques-Henri Jourdan, Franois

Towards a separation logic for Multicore OCaml Glen Mvel , Jacques-Henri Jourdan, Franois Pottier May 25, 2020 PPS seminar, Paris CNRS &amp; Inria, Paris, France The weak memory model Multicore OCaml Extension of the OCaml language with

837 views • 52 slides
CIS 500 Software Foundations Fall 2005 Programming with OCaml CIS 500, Programming

CIS 500 Software Foundations Fall 2005 Programming with OCaml CIS 500, Programming

CIS 500 Software Foundations Fall 2005 Programming with OCaml CIS 500, Programming with OCaml 1 Functional programming with OCaml CIS 500, Programming with OCaml 2 OCaml and this course The

1.38k views • 99 slides
OCaml Tutorial Abram Hindle Kitchener Waterloo Perl Monger http://kw.pm.org abez@abez.ca

OCaml Tutorial Abram Hindle Kitchener Waterloo Perl Monger http://kw.pm.org abez@abez.ca

OCaml Tutorial OCaml Tutorial Abram Hindle Kitchener Waterloo Perl Monger http://kw.pm.org abez@abez.ca October 19, 2006 Abram Hindle 1 OCaml Tutorial OCaml Functional Language Multiple paradigms: Imperative, Functional, Object

196 views • 18 slides
Reagents: lock-free programming for the masses KC Sivaramakrishnan University of OCaml

Reagents: lock-free programming for the masses KC Sivaramakrishnan University of OCaml

Reagents: lock-free programming for the masses KC Sivaramakrishnan University of OCaml Cambridge Labs Multicore OCaml Concurrency Parallelism Libraries Language + Stdlib Compiler 2 Multicore OCaml Concurrency Parallelism

868 views • 75 slides
Bounding Data Races in Space and Time KC Sivaramakrishnan University of Darwin College, 1851

Bounding Data Races in Space and Time KC Sivaramakrishnan University of Darwin College, 1851

Bounding Data Races in Space and Time KC Sivaramakrishnan University of Darwin College, 1851 Royal OCaml Labs Cambridge Cambridge Commission 1 Multicore OCaml 2 Multicore OCaml OCaml is an industrial-strength, functional

1.2k views • 99 slides
Effect Handlers in Multicore OCaml Daniel Hillerstrm, Daan Leijen, Sam Lindley, Matija Pretnar,

Effect Handlers in Multicore OCaml Daniel Hillerstrm, Daan Leijen, Sam Lindley, Matija Pretnar,

Effect Handlers in Multicore OCaml Daniel Hillerstrm, Daan Leijen, Sam Lindley, Matija Pretnar, Andreas Rossberg, KC Sivaramakrishnan Effect Handlers Multicore OCaml is an OCaml extension with native support for concurrency and

1.43k views • 42 slides

More recommend