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

Download Presentation
Download Policy: The content available on the website is offered to you 'AS IS' for your personal information and use only. It cannot be commercialized, licensed, or distributed on other websites without prior consent from the author. To download a presentation, simply click this link. If you encounter any difficulties during the download process, it's possible that the publisher has removed the file from their server.

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
Introduction to Recursion Turn in your Design Problem 3 solution Review Object Oriented

Introduction to Recursion Turn in your Design Problem 3 solution Review Object Oriented

Review and Introduction to Recursion Turn in your Design Problem 3 solution Review Object Oriented Design Principles Encapsulation Cohesion Coupling Review Solar System Problem Scope and Static Variables Principles of

724 views • 26 slides
Functions How to make the person run? (See: runForest.cpp) Functions You can also use functions

Functions How to make the person run? (See: runForest.cpp) Functions You can also use functions

Functions How to make the person run? (See: runForest.cpp) Functions You can also use functions that return bool types in an if statement or loop This is commonly used if you have complex logic as it is normally easier to write a function

260 views • 10 slides
Compsc psci 101 101 List st C Compr prehe hens nsions, ns, T Transf nsform, Global al

Compsc psci 101 101 List st C Compr prehe hens nsions, ns, T Transf nsform, Global al

Compsc psci 101 101 List st C Compr prehe hens nsions, ns, T Transf nsform, Global al - Live L e Lec ecture Susan Rodger September 29, 2020 9/29/20 Compsci 101, Fall 2020 1 Announcements Assign ign 2 2 Turtl tles d

519 views • 14 slides
Processes Variables What makes up a process? program code Stack machine registers

Processes Variables What makes up a process? program code Stack machine registers

Unix processes and threads Processes fork() CSCE 515: wait() &amp; waitpid() Computer Network Programming ------ Processes vs. Threads Threads threads vs. processes Wenyuan Xu synchronization Department of Computer

354 views • 11 slides
CMPSC 311- Introduction to Systems Programming Module: Variables Arrays and Pointers Professor

CMPSC 311- Introduction to Systems Programming Module: Variables Arrays and Pointers Professor

CMPSC 311- Introduction to Systems Programming Module: Variables Arrays and Pointers Professor Patrick McDaniel Fall 2016 CMPSC 311 - Introduction to Systems Programming Variable Storage Classes C (and other languages) have several

885 views • 46 slides
Semantic Analysis with Attribute Grammars Part 5 Y.N. Srikant Department of Computer Science and

Semantic Analysis with Attribute Grammars Part 5 Y.N. Srikant Department of Computer Science and

Semantic Analysis with Attribute Grammars Part 5 Y.N. Srikant Department of Computer Science and Automation Indian Institute of Science Bangalore 560 012 NPTEL Course on Principles of Compiler Design Y.N. Srikant Semantic Analysis Outline

850 views • 31 slides
Set Variables Marco Chiarandini Department of Mathematics &amp; Computer Science University of

Set Variables Marco Chiarandini Department of Mathematics &amp; Computer Science University of

DM841 D ISCRETE O PTIMIZATION Part I Set Variables Marco Chiarandini Department of Mathematics &amp; Computer Science University of Southern Denmark Set Variables Graph Variables Resume and Outlook Float Variables Modeling in CP

462 views • 45 slides
Basic Ruby Syntax sum = 0 Newline is statement separator i = 1 while i &lt;= 10 do sum += i*i

Basic Ruby Syntax sum = 0 Newline is statement separator i = 1 while i &lt;= 10 do sum += i*i

Basic Ruby Syntax sum = 0 Newline is statement separator i = 1 while i &lt;= 10 do sum += i*i i = i + 1 do ... end instead of { ... } end puts &quot;Sum of squares is #{sum}\n&quot; Optional parentheses Substitution in in method

243 views • 13 slides

More recommend