Leituras de valores numéricos

Transcrição

1 DIM Conceitos e Técnicas de Programação Leituras de valores numéricos 1

2 Leitura de valores numéricos em uma linha só... São dois comandos: read_int() read_float() Erro de execução quando não é digitado um número 2

3 Leitura de valores numéricos em uma linha só... São dois comandos: read_int() read_float() Erro de execução quando não é digitado um número (* lê um inteiro, dá o nome i1 ao valor lido *) let i1 : int = read_int ();; (* lê um inteiro, dá o nome i2 ao valor lido *) let i2 : int = read_int ();; (* lê um float, dá o nome f ao valor lido *) let f : float = read_float ();; (* imprime a soma de i1 e i2 em uma linha *) print_int (i1 + i2); print_newline (); (* imprime o dobro de f em uma linha *) print_float (f *. 2.); print_newline ();; 2

4 Leitura de valores numéricos em uma linha só... São dois comandos: read_int() read_float() Erro de execução quando não é digitado um número (* lê um inteiro, dá o nome i1 ao valor lido *) let i1 : int = read_int ();; (* lê um inteiro, dá o nome i2 ao valor lido *) let i2 : int = read_int ();; (* lê um float, dá o nome f ao valor lido *) localhost:david$ ocamlc.opt leitura.ml -o leitura let f : float = read_float ();; localhost:david$./leitura (* imprime a soma de i1 e i2 em uma linha 3 *) print_int (i1 + i2); print_newline (); (* imprime o dobro de f em uma linha *) print_float (f *. 2.); print_newline ();; localhost:david$ 2

5 DIM Conceitos e Técnicas de Programação Funções 3

6 Funções Wikipedia: Function (mathematics), an abstract entity that associates an input to a corresponding output according to some rule. Exemplo: Em programação funcional, funções são trechos de códigos responsáveis para calcular o valor da aplicação de uma função (matemática) para uma determinada entrada. Exemplo: Caml Lua C fun (x : int) -> x * x function (x) return x*x end int f (int x) { return x * x; } 4

7 Definição de funções em OCaml Funções são definidas com: a palavra chave fun, seguida de os parâmetros: os argumentos da função, o separador ->, o corpo: uma expressão que depende dos parâmetros e que define o resultado. Exemplos: fun (x : int) -> x * x fun (x : float) -> x *. x 5

8 Funções nomeadas Frequentemente, precisamos atribuir um nome a uma função: A função pode ser utilizada em diversos lugares e não queremos digitar toda a definição a cada vez. Dar um bom nome à definição permite esclarecer o seu papel e tornar o código mais legível. Em OCaml, o mecanismo para dar um nome a um valor é o let (aula 3). Exemplo: # let int_square : int -> int = fun (i : int) -> i * i;; val int_square : int -> int = <fun> O nome int_square passa a representar uma função Caml que calcula o quadrado de um inteiro. # int_square (~- 5);; - : int = 25 # int_square (1 + (int_square 3));; 6 - : int = 100

9 Funções nomeadas Podemos utilizar a sintaxe alternativa para explicitar o tipo da função: Exemplo: let int_square : int -> int = fun i -> i * i Pode-se também explicitar ambos tipos: da função e dos parâmetros. let int_square : int -> int = fun (i : int) -> i * i Evidentemente, deve-se ter tipos compatíveis... O sistema de tipos de OCaml permite inferir o tipo também: let int_square = fun i -> i * i 7

10 Funções: unidades coesas de código Em programação, funções podem ser usadas para agrupar unidades coesas de código: módulos responsáveis por um determinado papel o papel só depende dos parâmetros o papel pode ser usado para definir outros papeis. # let potencia2 = fun (n : int) -> n * n;; val potencia2 : int -> int = <fun> # let potencia4 = fun (n : int) -> (potencia2 (potencia2 n));; val potencia4 : int -> int = <fun> # potencia4 2;; - : int = 16 8

11 Exercícios Escreva, em O Caml, uma função que, dada um numero inteiro, retorna o cubo deste número. 9

12 Exercícios Escreva, em O Caml, uma função que, dada um numero inteiro, retorna o cubo deste número. fun (x : int) -> x * x * x 9

13 Tipos de funções Funções são valores de tipos funcionais. Um tipo funcional é composto de dois tipos: O tipo dos valores de entrada da função (A) O tipo dos valores de resultado da função (B) A notação empregrada é A -> B Exemplos: # fun (i : int) -> i * i;; - : int -> int = <fun> # fun (i : int) -> i *. i;; - : float -> float = <fun> 10

14 Tipo do parâmetro # fun x -> x * x;; -: int -> int = <fun> # fun x -> x *. x;; -: float -> float = <fun> Caml determina corretamente o tipo dessas duas funções. O tipo dos operandos do operador * é int. O tipo dos operandos do operador *. é float. Podemos definir explicitamente esse tipo: # fun (x : int) -> x * x;; - : int -> int = <fun> # fun (x : float) -> x *. x;; - : float -> float = <fun> É uma forma de explicitar a intenção. Torna mais fácil a leitura e o entendimento do programa Permite verificar se a nossa intenção é corretamente implementada. 11

15 Tipo do parâmetro # fun x -> x * x;; -: int -> int = <fun> # fun x -> x *. x;; -: float -> float = <fun> Caml determina corretamente o tipo dessas duas funções. O tipo dos operandos do operador * é int. O tipo dos operandos do operador *. é float. Podemos definir explicitamente esse tipo: # fun (x : int) -> x * x;; - : int -> int = <fun> # fun (x : float) -> x *. x;; - : float -> float = <fun> É uma forma de explicitar a intenção. Torna mais fácil a leitura e o entendimento do programa Permite verificar se a nossa intenção é corretamente implementada. # fun (x : float) -> x * x;; This expression has type float but is here used with type int 11

16 Para cada função, identifique: o tipo do parâmetro o tipo do resultado o tipo da função fun (x : int) -> x * (x + x) Tipo do parâmetro: exercício fun x -> x /

17 Para cada função, identifique: o tipo do parâmetro o tipo do resultado o tipo da função Tipo do parâmetro: exercício fun (x : int) -> x * (x + x) int int int -> int fun x -> x /

18 Para cada função, identifique: o tipo do parâmetro o tipo do resultado o tipo da função Tipo do parâmetro: exercício fun (x : int) -> x * (x + x) int int int -> int fun x -> x /. 2. float float float -> float 12

19 Aplicação de funções Aplicar uma função Caml a um, ou vários valores, permite calcular a imagem desses valores pela função matemática representada. Sintaxe: função valores ou (função valores) Exemplos: (fun i -> i * i) 2 ou ((fun i -> i * i) 2) Semântica: O parâmetro formal é substituído pelo valor do parâmetro efetivo o parâmetro formal i é substituído pelo parâmetro efetivo 2 O corpo da função é avaliado a expressão 2 * 2 é avaliada; O resultado da avaliação é o resultado da aplicação da função: - : int = 4 13

20 Aplicação de funções 14

21 Exemplos: Aplicação de funções 14

22 Exemplos: ((fun i -> i * i) 2) Aplicação de funções 14

23 Exemplos: ((fun i -> i * i) 2) ((fun i -> i * i) 2) Aplicação de funções 14

24 Exemplos: ((fun i -> i * i) 2) ((fun i -> i * i) 2) 2 * 2 Aplicação de funções 14

25 Exemplos: ((fun i -> i * i) 2) ((fun i -> i * i) 2) 2 * 2 4 Aplicação de funções 14

26 Aplicação de funções 15

27 Exemplos: Aplicação de funções 15

28 Aplicação de funções Exemplos: ((fun i -> i * i) (5-4)) 15

29 Aplicação de funções Exemplos: ((fun i -> i * i) (5-4)) ((fun i -> i * i) (5-4)) 15

30 Aplicação de funções Exemplos: ((fun i -> i * i) (5-4)) ((fun i -> i * i) (5-4)) ((fun i -> i * i) 1) 15

31 Aplicação de funções Exemplos: ((fun i -> i * i) (5-4)) ((fun i -> i * i) (5-4)) ((fun i -> i * i) 1) 1 * 1 15

32 Aplicação de funções Exemplos: ((fun i -> i * i) (5-4)) ((fun i -> i * i) (5-4)) ((fun i -> i * i) 1) 1 *

33 Aplicação de funções 16

34 Exemplos: Aplicação de funções 16

35 Aplicação de funções Exemplos: ((fun i -> i + i) ((fun i -> i * i) 2)) 16

36 Aplicação de funções Exemplos: ((fun i -> i + i) ((fun i -> i * i) 2)) ((fun i -> i + i) ((fun i -> i * i) 2)) 16

37 Aplicação de funções Exemplos: ((fun i -> i + i) ((fun i -> i * i) 2)) ((fun i -> i + i) ((fun i -> i * i) 2)) ((fun i -> i + i) 4) 16

38 Aplicação de funções Exemplos: ((fun i -> i + i) ((fun i -> i * i) 2)) ((fun i -> i + i) ((fun i -> i * i) 2)) ((fun i -> i + i) 4)

39 Aplicação de funções Exemplos: ((fun i -> i + i) ((fun i -> i * i) 2)) ((fun i -> i + i) ((fun i -> i * i) 2)) ((fun i -> i + i) 4)

40 Aplicação de funções 17

41 Exemplos: Aplicação de funções 17

42 Aplicação de funções Exemplos: ((fun i -> i *. i) 2.0) 17

43 Aplicação de funções Exemplos: ((fun i -> i *. i) 2.0) ((fun i -> i *. i) 2.0) 17

44 Aplicação de funções Exemplos: ((fun i -> i *. i) 2.0) ((fun i -> i *. i) 2.0) 2.0 *

45 Aplicação de funções Exemplos: ((fun i -> i *. i) 2.0) ((fun i -> i *. i) 2.0) 2.0 *

46 Aplicação de funções 18

47 Exemplos: Aplicação de funções 18

48 Exemplos: Aplicação de funções (fun x -> fun y -> x + (int_of_float y))

49 Exemplos: Aplicação de funções (fun x -> fun y -> x + (int_of_float y)) (fun x -> fun y -> x + (int_of_float y))

50 Exemplos: Aplicação de funções (fun x -> fun y -> x + (int_of_float y)) (fun x -> fun y -> x + (int_of_float y)) (fun y -> 2 + (int_of_float y))

51 Exemplos: Aplicação de funções (fun x -> fun y -> x + (int_of_float y)) (fun x -> fun y -> x + (int_of_float y)) (fun y -> 2 + (int_of_float y)) 5.3 (fun y -> 2 + (int_of_float y))

52 Exemplos: Aplicação de funções (fun x -> fun y -> x + (int_of_float y)) (fun x -> fun y -> x + (int_of_float y)) (fun y -> 2 + (int_of_float y)) 5.3 (fun y -> 2 + (int_of_float y)) (int_of_float 5.3) 18

53 Exemplos: Aplicação de funções (fun x -> fun y -> x + (int_of_float y)) (fun x -> fun y -> x + (int_of_float y)) (fun y -> 2 + (int_of_float y)) 5.3 (fun y -> 2 + (int_of_float y)) (int_of_float 5.3)

54 Exemplos: Aplicação de funções (fun x -> fun y -> x + (int_of_float y)) (fun x -> fun y -> x + (int_of_float y)) (fun y -> 2 + (int_of_float y)) 5.3 (fun y -> 2 + (int_of_float y)) (int_of_float 5.3)

55 Aplicação de funções 19

56 Exemplos: Aplicação de funções 19

57 Exemplos: Aplicação de funções (fun x -> fun y -> x + (int_of_float y)) 0 19

58 Exemplos: Aplicação de funções (fun x -> fun y -> x + (int_of_float y)) 0 (fun x -> fun y -> x + (int_of_float y)) 0 19

59 Exemplos: Aplicação de funções (fun x -> fun y -> x + (int_of_float y)) 0 (fun x -> fun y -> x + (int_of_float y)) 0 (fun y -> 0 + (int_of_float y)) 19

60 Exemplos: Aplicação de funções (fun x -> fun y -> x + (int_of_float y)) 0 (fun x -> fun y -> x + (int_of_float y)) 0 (fun y -> 0 + (int_of_float y)) fun y -> (int_of_float y) 19

61 Aplicação de funções e tipagem O tipo do parâmetro efetivo deve ser o mesmo do parâmetro formal: # (fun i -> i *. i) 2;; This expression has type int but is here used with type float 20

62 Aplicação de funções e associatividade # (fun i -> i * i) (fun i -> i * i) 2;; This function is applied to too many arguments, maybe you forgot a `;' OCaml aplica a primeira função. É seguida de dois argumentos (uma função e um inteiro). Não corresponde à definição da função. Colocar os parênteses elimina eventuais ambigüidades. # (fun i -> i * i) ((fun i -> i * i) 2);; - : int = 16 21

63 Aplicação de funções e precedência # (fun i -> i * i) 2 * 3;; - : int = 12 # ((fun i -> i * i) 2) * 3;; - : int = 12 # (fun i -> i * i) (2 * 3);; - : int = 36 A aplicação de função tem maior precedência que os demais operadores. 22

64 Multiplos parâmetros Pode-se definir funções que tenham mais de um parâmetro. Exemplo # let linear = fun (a : float) (b : float) (x : float) -> a *. x +. b;; val linear : float -> float -> float -> float = <fun> # linear ;; - : float = 5.8 linear » (fun (a : float) (b : float) (x : float) -> a *. x +. b) » 2.0 * »

65 Como funciona? Funções de n parâmetros são representadas como funções de 1 parâmetro retornando uma função de n-1 parâmetros. Exemplo 24

66 Como funciona? Funções de n parâmetros são representadas como funções de 1 parâmetro retornando uma função de n-1 parâmetros. Exemplo fun (a : float) (b : float) (x : float) -> a *. x +. b» fun (a: float) -> fun (b : float) (x : float) -> a *. x +. b 24

67 Como funciona? Funções de n parâmetros são representadas como funções de 1 parâmetro retornando uma função de n-1 parâmetros. Exemplo fun (a : float) (b : float) (x : float) -> a *. x +. b» fun (a: float) -> fun (b : float) (x : float) -> a *. x +. b fun (b : float) (x : float) -> a *. x +. b» fun (b: float) -> fun (x : float) -> a *. x +. b 24

68 Como funciona? Funções de n parâmetros são representadas como funções de 1 parâmetro retornando uma função de n-1 parâmetros. Exemplo fun (a : float) (b : float) (x : float) -> a *. x +. b» fun (a: float) -> fun (b : float) (x : float) -> a *. x +. b fun (b : float) (x : float) -> a *. x +. b» fun (b: float) -> fun (x : float) -> a *. x +. b fun (a : float) (b : float) (x : float) -> a *. x +. b»»» fun (a : float) -> fun (b : float) -> fun (x : float) -> a *. x +. b 24

69 Como funciona? 25

70 linear Como funciona? 25

71 linear Como funciona?» (fun (a : float) (b : float) (x : float) -> a *. x +. b )

72 Como funciona? linear » (fun (a : float) (b : float) (x : float) -> a *. x +. b ) » (fun (a : float) -> fun (b : float) -> fun (x : float) -> a *. x +. b) » (fun (a : float) -> fun (b : float) -> fun (x : float) -> a *. x +. b)

73 Como funciona? linear » (fun (a : float) (b : float) (x : float) -> a *. x +. b ) » (fun (a : float) -> fun (b : float) -> fun (x : float) -> a *. x +. b) » (fun (a : float) -> fun (b : float) -> fun (x : float) -> a *. x +. b) » (fun (b : float) -> fun (x : float) -> 2.0 *. x +. b) » (fun (b : float) -> fun (x : float) -> 2.0 *. x +. b)

74 Como funciona? linear » (fun (a : float) (b : float) (x : float) -> a *. x +. b ) » (fun (a : float) -> fun (b : float) -> fun (x : float) -> a *. x +. b) » (fun (a : float) -> fun (b : float) -> fun (x : float) -> a *. x +. b) » (fun (b : float) -> fun (x : float) -> 2.0 *. x +. b) » (fun (b : float) -> fun (x : float) -> 2.0 *. x +. b) » (fun (x : float) -> 2.0 *. x ) 1.4» (fun (x : float) -> 2.0 *. x )

75 Como funciona? linear » (fun (a : float) (b : float) (x : float) -> a *. x +. b ) » (fun (a : float) -> fun (b : float) -> fun (x : float) -> a *. x +. b) » (fun (a : float) -> fun (b : float) -> fun (x : float) -> a *. x +. b) » (fun (b : float) -> fun (x : float) -> 2.0 *. x +. b) » (fun (b : float) -> fun (x : float) -> 2.0 *. x +. b) » (fun (x : float) -> 2.0 *. x ) 1.4» (fun (x : float) -> 2.0 *. x ) 1.4» 2.0 *

76 Como funciona? linear » (fun (a : float) (b : float) (x : float) -> a *. x +. b ) » (fun (a : float) -> fun (b : float) -> fun (x : float) -> a *. x +. b) » (fun (a : float) -> fun (b : float) -> fun (x : float) -> a *. x +. b) » (fun (b : float) -> fun (x : float) -> 2.0 *. x +. b) » (fun (b : float) -> fun (x : float) -> 2.0 *. x +. b) » (fun (x : float) -> 2.0 *. x ) 1.4» (fun (x : float) -> 2.0 *. x ) 1.4» 2.0 * »

77 Visualizando a avaliação da aplicação de função. # let f1 = fun x y -> x + y;; val f1 : int -> int -> int = <fun> # #trace f1;; f1 is now traced. # f1 3 4;; f1 <-- 3 f1 --> <fun> f1* <-- 4 f1* --> 7 - : int = 7 # 26

78 Funções como valores Funções são valores de tipos funcionais. Uma função pode então ser o resultado de uma função. exemplos função de múltiplos argumentos (técnica de curryficação). Uma função pode ser o parâmetro de uma função. exemplos função de ordem superior 27

79 Exercícios Considere a função Caml seguinte: fun a b c -> (a * b * c *. 6.0) / Aplicamos os valores 7,0 e 9,0. Qual função representa o resultado da aplicação desses dois valores? 28

80 Exercícios Considere a função Caml seguinte: fun a b c -> (a * b * c *. 6.0) / Aplicamos os valores 7,0 e 9,0. Qual função representa o resultado da aplicação desses dois valores? substituindo a por 7.0 e b por 9.0: fun c -> ( c*.6.0) /

81 Funções tendo função como resultado A aplicação de uma função pode ser uma função O tipo resultado é um tipo funcional Exemplo: 29

82 Funções tendo função como resultado A aplicação de uma função pode ser uma função O tipo resultado é um tipo funcional Exemplo: # let f1 = fun expo -> (fun x -> x ** (float_of_int expo));; val f1 : int -> float -> float = <fun> # let float_cubo = f1 3;; val float_cubo : float -> float = <fun> # float_cubo 2.0;; - : float = 8. 29

83 Funções tendo função como resultado A aplicação de uma função pode ser uma função O tipo resultado é um tipo funcional Exemplo: # let f1 = fun expo -> (fun x -> x ** (float_of_int expo));; val f1 : int -> float -> float = <fun> # let float_cubo = f1 3;; val float_cubo : float -> float = <fun> # float_cubo 2.0;; - : float = 8. f1: dado um inteiro n, retorna uma função que, dada um real x, retorna x elevado à potência n. 29

84 Funções tendo função como resultado A aplicação de uma função pode ser uma função O tipo resultado é um tipo funcional Exemplo: # let f1 f2 = fun expo x -> (fun -> (fun e -> x (int_of_float -> x ** (float_of_int ((float_of_int expo));; x) ** (float_of_int e))));; val f1 f2 : int -> float int -> -> int float = <fun> = <fun> # let float_cubo pot2 = f2 2;; = f1 3;; val float_cubo pot2 : int ->: float int = -> <fun> float = <fun> # float_cubo pot2 4;; 2.0;; - : float int = = 168. f1: dado um inteiro n, retorna uma função que, dada um real x, retorna x elevado à potência n. 29

85 Funções tendo função como resultado A aplicação de uma função pode ser uma função O tipo resultado é um tipo funcional Exemplo: # let f1 f2 = fun expo x -> (fun -> (fun e -> x (int_of_float -> x ** (float_of_int ((float_of_int expo));; x) ** (float_of_int e))));; val f1 f2 : int -> float int -> -> int float = <fun> = <fun> # let float_cubo pot2 = f2 2;; = f1 3;; val float_cubo pot2 : int ->: float int = -> <fun> float = <fun> # float_cubo pot2 4;; 2.0;; - : float int = = 168. f1: dado um inteiro n, retorna uma função que, dada um real x, retorna x elevado à potência n. f2: dado um inteiro x, retorna uma função que, dada um inteiro e, retorna x elevado à potência e. 29

86 Funções poliádicas como combinação de funções monádicas Uma função de n > 1 parâmetros pode ser vista como uma função de um único parâmetro que tem como resultado uma função de n - 1 parâmetros (técnica conhecida como curryficação 1 ). Exemplo: Notação simplificada (mas equivalente): 1 30 vem do nome do lógico Haskell Curry.

87 Funções poliádicas como combinação de funções monádicas Uma função de n > 1 parâmetros pode ser vista como uma função de um único parâmetro que tem como resultado uma função de n - 1 parâmetros (técnica conhecida como curryficação 1 ). Exemplo: # let media_float = fun (x1 : float) -> fun (x2 : float) -> (x1 +. x2) /. 2;; val media_float : float -> float -> float -> float = <fun> Notação simplificada (mas equivalente): # let media_float = fun (x1 : float) (x2 : float) -> (x1 +. x2) /. 2;; val media_float : float -> float -> float -> float = <fun> 1 30 vem do nome do lógico Haskell Curry.

88 Sintaxe alternativa A função: fun a b c -> (a * b * c *. 6.0) / é equivalente à função: fun a -> (fun b c -> (a * b * c *. 6.0) /. 15.0) que é equivalente à função: fun a -> (fun b -> (fun c -> (a * b * c *. 6.0) /. 15.0)) 1 vem do nome do lógico Haskell Curry. 31

89 Funções de ordem superior Funções são valores. Funções que tem como parâmetro outras funções são chamadas funções de ordem superior. Exemplo: 32

90 Funções de ordem superior Funções são valores. Funções que tem como parâmetro outras funções são chamadas funções de ordem superior. Exemplo: # let misterio = fun f x -> (f (f x)) + (f x) + x;; val misterio : (int -> int) -> int -> int = <fun> # misterio (fun n -> n * 3) 4;; - : int = 52 # misterio (fun x -> x / 3) 2;; - : int = 2 32

91 Funções de ordem superior: exemplo 1 # let misterio = fun f -> (fun x -> (f (f x))) val misterio :... = <fun> # let pot2 = fun (i : int) -> i * i;; val pot2 : int -> int = <fun> # let adivinhacao = misterio pot2;; val bizarro : int -> int = <fun> # adivinhacao 4;; - : int =

92 Funções de ordem superior: exemplo 1 # let misterio = fun f -> (fun x -> (f (f x))) val misterio :... = <fun> # let pot2 = fun (i : int) -> i * i;; val pot2 : int -> int = <fun> # let adivinhacao = misterio pot2;; val bizarro : int -> int = <fun> # adivinhacao 4;; - : int = 256 O que faz a função misterio? O que faz a função adivinhacao? 33

93 Funções de ordem superior Derivar: uma operação que transforma uma função em outra função (sua derivada) entrada: uma função de uma variável (número real) saída: uma função de uma variável (também número real) # let epsilon : float = 1e-10;; val epsilon : float # let deriv = fun f -> fun x -> (f (x +. epsilon) -. f x) /. epsilon;; val deriv : (float -> float) -> float -> float = <fun> 34

94 Funções de ordem superior Derivar: uma operação que transforma uma função em outra função (sua derivada) entrada: uma função de uma variável (número real) saída: uma função de uma variável (também número real) # let epsilon : float = 1e-10;; val epsilon : float # let deriv = fun f -> fun x -> (f (x +. epsilon) -. f x) /. epsilon;; val deriv : (float -> float) -> float -> float = <fun> # let sin = deriv sin;; val sin' : float -> float = <fun> 34

95 Funções de ordem superior Derivar: uma operação que transforma uma função em outra função (sua derivada) entrada: uma função de uma variável (número real) saída: uma função de uma variável (também número real) # let epsilon : float = 1e-10;; val epsilon : float # let deriv = fun f -> fun x -> (f (x +. epsilon) -. f x) /. epsilon;; val deriv : (float -> float) -> float -> float = <fun> # let sin = deriv sin;; val sin' : float -> float = <fun> # sin' 0.0;; - : float = 1. # let pi = acos (~-. 1.0);; val pi : float = # sin' pi;; - : float =

96 Procedimentos Procedimentos são rotinas que não retornam resultados. em OCaml, o tipo do resultado dos procedimentos é unit, o valor é () (leia: nada). exemplos: print_int, print_float Procedimentos podem alterar o conteúdo de uma memória escrever valores ler valores Exemplo: let i : int ref = ref 0 let leia : unit -> unit = fun () -> i := read_int() 35

97 Funções e programas (* funcoes auxiliares *) let aux1 :... = fun... (* funcao principal) let main : unit -> unit = fun () -> let (* declaração dos dados lidos e escritos *) <nome1> : <tipo1> = <valor inicial1> and <nome2> : <tipo2> = <valor inicial2> in (* leitura dos dados *) (* calculo dos valores a imprimir *) (* impressao dos valores calculados *) let _ = main() Modelo de programa 2: 36

98 Funções e programas (* declaração dos dados lidos e escritos *) let <nome1> : <tipo1> = <valor inicial1> and <nome2> : <tipo2> = <valor inicial2>... (* funcoes auxiliares *) let aux1 :... = fun... (* funcao principal) let main : unit -> unit = fun () -> (* leitura dos dados *) (* calculo dos valores a imprimir *) (* impressao dos valores calculados *) let _ = main() Modelo de programa 3: 37

99 Conclusões Função: conceito de programação, relação com funções matemáticas. Como definir funções em Caml: sintaxe e semântica Tipos funcionais, funções e o sistema de tipos da linguagem; Curryficação permite construir funções de n parâmetros como funções de um parâmetro; Funções podem ser nomeadas (variável) ou anônimas; Funções de ordem superior; Procedimentos. 38