Introducción a OCaml. October 19, 2015

Transcripción

1 Introducción a OCaml October 19, 2015

2 OCaml: introducción Es un dialecto de ML. Lenguaje de programación funcional. Fuertemente tipado. Con inferencia de tipos. Polimórfico. [Página oficial: Listado de funciones por orden alfabético: values.html

3 Expresiones simples A partir del promt (#) comienza una expresión, que ha de finalizar con (;;). # ;; - : int = 9 Los comentarios van entre (* y *) # 4 + (* esto es un comentario *) 5 ;; - : int = 9

4 Tipos básicos unit: es el tipo más simple de OCaml, que contiene un elemento: (). int: enteros de precisión fija, entre y float: reales de precisión arbitraria. Ejemplos: 0.2, 2e7, , E 1, 2 Los operadores aritméticos incluyen un (.) Funciones para transformar entero en real y viceversa: float of int, int of float # e7;; - : float = # 4.0 /. 2e7;; - : float = 2e-07 int_of_float 2.4;; - : int = 2 # float_of_int 2;; - : float = 2.

5 Tipos básicos char: caracteres # a ;; - : char = a # \120 ;; - : char = x # x ;; - : char = x # Char.code x ;; - : int = 120 # Char.chr 120;; - : char = x # \n ;; - : char = \n # \r ;; - : char = \r

6 Tipos básicos: string: cadenas de caracteres # "Hola y adios";; - : string = "Hola y adios" # String.length "Hola y adios";; - : int = 12 # String.sub "Hola y adios" 2 5;; - : string = "la y " # "Hola y adios".[2];; - : char = l

7 Tipos básicos bool: true, false Relaciones para comparar valores: devuelven true o false x = y, x == y, x! = y, x <> y x < y, x <= y, x >= y, x > y # 2 < 4;; - : bool = true # "Hola" > "Hasta luego";; - : bool = true # = 8;; - : bool = true # == 8;; - : bool = true # 1.0 = 1.0;; - : bool = true # 1.0 == 1.0;; - : bool = false

8 Tipos básicos Operadores lógicos: not, &&, # not true;; - : bool = false # 1 < 2 (1 / 0) > 0 ;; - : bool = true # 1 < 2 && (1 / 0) > 0 ;; Exception: Division_by_zero. # 1 > 2 && (1 / 0) > 0 ;; - : bool = false Condicional: if a then b else c # if 1 < 2 then 3+7 else 4;; - : int = 10

9 Variables y funciones Asignación: let nombre = expresión # let x = 1;; val x : int = 1 # let y = 4;; val y : int = 4 # let z = x + y;; val z : int = 5 Asignaciones anidadas: let nombre = expr1 in expr2 # let x = 8 in let y = 2 in x+y;; - : int = 10 # x;; - : int = 1

10 Variables y funciones Funciones # let siguiente = fun i -> i+1;; val siguiente : int -> int = <fun> # let siguiente i = i+1;; val siguiente : int -> int = <fun> # siguiente 6;; - : int = 7 Precedencia de las funciones # siguiente 2 * 3;; - : int = 9 # siguiente (2 * 3);; - : int = 7

11 Variables y funciones Funciones con varios argumentos: currificación # let suma x y = x + y;; val suma : int -> int -> int = <fun> # let suma = fun x -> (fun y -> x + y);; val suma : int -> int -> int = <fun> # let suma x = fun y -> x + y;; val suma : int -> int -> int = <fun> Parcialización # let siguiente = suma 1;; val siguiente : int -> int = <fun> # siguiente 4;; - : int = 5

12 Variables y funciones Funciones recursivas: let rec nombre= expresión # let rec factorial n = if n = 0 then 1 else n*(factorial (n-1));; val factorial : int -> int = <fun> # let rec potencia n x= if n = 0 then 1.0 else x*. (potencia (n-1) x);; val potencia : int -> float -> float = <fun> # factorial 10;; - : int = # potencia 4 5.0;; - : float = 625.

13 Variables y funciones Funciones de orden superior: función derivada # let dx = 1e-10;; val dx : float = 1e-10 # let derivada f = fun x -> (f (x +. dx) -. f x) /. dx;; val derivada : (float -> float) -> float -> float = <fun> # let f1 = potencia 3;; val f1 : float -> float = <fun> # f1 10.0;; - : float = # let f1 = derivada f1;; val f1 : float -> float = <fun> # f1 10.0;; - : float =

14 Funciones: definiciones mediante patrones Sintaxis: match expr with patron_1 -> expr1 patron_2 -> expr2... patron_n -> exprn Ejemplo: sucesión de Fibonacci # let rec fib n = match n with 0 -> 0 1 -> 1 n -> fib (n-1) + fib (n-2);; val fib : int -> int = <fun> # fib 10;;

15 Funciones: definiciones mediante patrones Expresiones alternativas # let rec fib n = match n with (0 1) -> n _ -> fib (n-1) + fib (n-2);; # let rec fib = function (0 1) as n -> n n -> fib (n-1) + fib (n-2);; val fib : int -> int = <fun> # let rec fib = function n when n < 2 -> n n -> fib (n-1) + fib (n-2);;

16 Tuplas Se corresponden con el producto cartesiano. # let p = 1, "Hola";; val p : int * string = (1, "Hola") # fst p;; - : int = 1 # snd p;; - : string = "Hola" # let x, y = p;; val x : int = 1 val y : string = "Hola" # let segundo (_,y,_) = y;; val segundo : a * b * c -> b = <fun> # segundo (1, 4.5, "hola");; - : float = 4.5

17 Listas Sucesión de elementos del mismo tipo. # [1;2;3;5];; - : int list = [1; 2; 3; 5] Constructores: [], (::) let xs = [1;2;3;5] in 7::xs;; - : int list = [7; 1; 2; 3; 5] Operaciones: length hd tl nth rev append concat

18 Definiciones de tipos de datos Sintaxis type nombre = Identificador_1 of tipo_1... Identificador_n of tipo_n Ejemplo: árbol binario con nodos enteros # type arbol = Hoja Nodo of int * arbol * arbol;; type arbol = Hoja Nodo of int * arbol * arbol # let ej1 = Hoja;; val ej1 : arbol = Hoja # let ej2 = Nodo (1, Hoja, Hoja);; val ej2 : arbol = Nodo (1, Hoja, Hoja) # let ej3 = Nodo (4, ej2, ej1);; val ej3 : arbol = Nodo (4, Nodo (1, Hoja, Hoja), Hoja)

19 Definiciones de tipos de datos Árboles binarios # type a arbol = Hoja Nodo of a * a arbol * a arbol;; type a arbol = Hoja Nodo of a * a arbol * a arbol Expresiones aritméticas: type expression = Var of string Const of int Add of expression * expression Mul of expression * expression;; let expr1 = Add(Mul(Const 2,Var "x"),var "y");;

20 Tipos de datos: fórmulas type ( a)formula = False True Atom of a Not of ( a)formula And of ( a)formula * ( a)formula Or of ( a)formula * ( a)formula Imp of ( a)formula * ( a)formula Iff of ( a)formula * ( a)formula Forall of string * ( a)formula Exists of string * ( a)formula;;