Permalink
Browse files

Do not eval code that hangs the process.

The most common reason is the presence of `read_line()` and infinite
loops.  Several code blocks that were not OCaml were also tagged with
`tryocaml` (there may be some left, I did not track them systematically).
  • Loading branch information...
1 parent 625430c commit d918b2f99dbdc45d50c09410c3dd719a571b9e45 @Chris00 Chris00 committed Nov 18, 2013
@@ -4,7 +4,7 @@
## Commentaires
Les commentaires OCaml sont délimités par `(*` et `*)`, comme ceci:
-```tryocaml
+```ocaml
(* Ceci est une ligne de commentaire. *)
(* Ceci est
@@ -23,7 +23,7 @@ l'équipe d'OCaml d'ajouter ça dans les versions à venir.
OCaml prend en compte les commentaires imbriqués, ce qui permet
facilement de mettre des portions de code en commentaire:
-```tryocaml
+```ocaml
(* Ce code n'est pas au point...
(* Test de primalité. *)
@@ -32,6 +32,7 @@ let is_prime n =
*)
```
+
## Appels de fonctions
Supposons que vous ayez écrit une fonction nommée `repeated`, qui prend
en argument une chaîne de caractères `s` et un nombre `n` et renvoie une
@@ -40,9 +41,10 @@ nouvelle chaîne de caractères qui contient l'originale répétée `n` fois.
Dans la plupart des languages dérivés du C, un appel de fonction
ressemble à ça :
-```tryocaml
+```ocaml
repeated ("hello", 3) /* c'est du code C */
```
+
Ca veut dire « appelle la fonction `repeated` avec deux arguments, le
premier étant la chaîne de caractères hello et le second étant le nombre
3 ».
@@ -51,7 +53,7 @@ OCaml, tout comme d'autres langages fonctionnels, écrit et parenthèse
différemment les appels de fonctions, ce qui entraîne bien des erreurs
au début. Voici le même appel de fonction en OCaml :
-```tryocaml
+```ocaml
repeated "hello" 3 (* c'est du code OCaml *)
```
Notez-bien : **pas** de parenthèses, et **pas** de virgule entre les
@@ -74,10 +76,11 @@ qui demande à l'utilisateur de taper quelque chose et renvoie la chaîne
de caractère ainsi entrée. Nous voulons passer cette chaîne de
caractères à la fonction `repeated`. Voici les versions C et OCaml :
-```tryocaml
+```C
/* code C: */
repeated (get_string_from_user ("Veuillez entrer une chaîne de caractères."), 3)
-
+```
+```ocaml
(* code OCaml: *)
repeated (get_string_from_user "Veuillez entrer une chaîne de caractères.") 3
```
@@ -86,7 +89,7 @@ règle est la suivante : « mettez des parenthèses autour de tout l'appel
de fonction - ne mettez pas de parenthèses autour des arguments passés à
une fonction ». Voici quelques exemples supplémentaires :
-```tryocaml
+```ocaml
f 5 (g "hello") 3 (* f a 3 arguments, g a un argument *)
f (g 3 4) (* f a un argument, g a 2 arguments *)
@@ -4,14 +4,15 @@
## Commenti
In OCaml i commenti sono delimitati da `(*` e `*)`, come segue:
-```tryocaml
+```ocaml
(* Questo è un commento su un'unica riga. *)
(* Questo è un
* commento su
* più righe.
*)
```
+
In altre parole, la convenzione per i commenti è molto simile a quella
originale di C (`/* ... */`).
@@ -23,7 +24,7 @@ OCaml di aggiungerlo in futuro.
OCaml conta i blocchi `(* ... *)` annodati, e questo vi consente di
commentare assai facilmente regioni di codice:
-```tryocaml
+```ocaml
(* Questo codice non è valido ...
(* Test di primalità. *)
@@ -32,6 +33,7 @@ let is_prime n =
*)
```
+
## Chiamare funzioni
Poniamo che abbiate scritto una funzione - la chiameremo `repeated` -
che prende una stringa `s` ed un numero `n`, e restituisce una nuova
@@ -40,7 +42,7 @@ stringa che contiene la stringa originale `s` ripetuta `n` volte.
Nella maggior parte dei linguaggi derivati da C una chiamata a questa
funzione apparirà come segue:
-```tryocaml
+```C
repeated ("hello", 3) /* questo è codice C */
```
Questo significa "chiama la funzione `repeated` con due argomenti, di
@@ -50,7 +52,7 @@ OCaml, in comune con altri linguaggi funzionali, scrive e mette tra
parentesi le chiamate di funzioni in modo differente, e questo è causa
di molti errori. Ecco la modesima chiamata di funzione in OCaml:
-```tryocaml
+```ocaml
repeated "hello" 3 (* questo è codice OCaml *)
```
Notate - **non** vi sono parentesi e **non** vi sono virgole fra gli
@@ -71,10 +73,11 @@ una stringa da terminale e restituisce la stringa digitata dall'utente.
Vogliamo passare questa stringa in `repeated`. Seguono le versioni C e
OCaml:
-```tryocaml
+```C
/* codice C: */
repeated (get_string_from_user ("Si inserisca una stringa."), 3)
-
+```
+```ocaml
(* codice OCaml: *)
repeated (get_string_from_user "Si inserisca una stringa.") 3
```
@@ -83,13 +86,14 @@ virgole. In generale la regola è: "parentesi intorno all'intera chiamata
di funzione - non mettere parentesi intorno agli argomenti ad una
chiamata di funzione". Seguono ulteriori esempi:
-```tryocaml
+```ocaml
f 5 (g "hello") 3 (* f ha tre argomenti, g ha un argomento *)
f (g 3 4) (* f ha un argomento, g ha due argomenti *)
# repeated ("hello", 3);; (* OCaml segnalerà l'errore *)
This expression has type string * int but is here used with type string
```
+
## Definire una funzione
Tutti voi sapete come definire una funzione (o un metodo statico, per
chi pensa in Java) nei nostri linguaggi. Come lo facciamo in OCaml?
@@ -105,9 +109,8 @@ Scrivete questo nel "toplevel" di OCaml (su Unix, scrivete il comando
`ocaml` dalla shell) e vedrete così:
```tryocaml
-# let average a b =
- (a +. b) /. 2.0;;
-val average : float -> float -> float = <fun>
+let average a b =
+ (a +. b) /. 2.0
```
Se osservate bene la definizione di funzione, ed anche che cosa OCaml vi
restituisce in stampa, avrete diverse domande:
@@ -121,7 +124,7 @@ Java sarebbe piuttosto simile a quella in C), e plausibilmente questo
dovrebbe sollevare ancora più questioni. Ecco la nostra versione in C di
`average`:
-```tryocaml
+```C
double
average (double a, double b)
{
@@ -161,7 +164,7 @@ I dettagli effettivi seguono nelle sezioni e nei capitoli successivi.
## Tipi di base
I tipi di base in OCaml sono:
-```tryocaml
+```
tipo OCaml Range
int Intero a 31 bit con segno, circa +/- 1 billion
@@ -171,6 +174,7 @@ char Un carattere a 8 bit
string Una stringa
unit Scritto come ()
```
+
OCaml utilizza uno dei bit in un `int` internamente per differenziare
tra interi e puntatori. È perciò che l'`int` di base è a 31 bit, non a
32 bit (63 bit se state utilizzando una piattaforma a 64 bit). Nella
@@ -213,8 +217,7 @@ int, e qui gli stiamo dando un int e un float, dunque esso riposta
questo errore:
```tryocaml
-# 1 + 2.5;;
-This expression has type float but is here used with type int
+1 + 2.5;;
```
(Nel linguaggio "tradotto dal francese" dei messaggi di errore di OCaml
questo significa "hai messo qui un float, ma aspettavo un int").
@@ -226,8 +229,7 @@ OCaml non promuove gli int a float automaticamente, quindi è un errore
anche il seguente:
```tryocaml
-# 1 +. 2.5;;
-This expression has type int but is here used with type float
+1 +. 2.5;;
```
Qui OCaml si sta ora lamentando per il primo argomento.
@@ -5,7 +5,7 @@
## Comments
OCaml comments are delimited by `(*` and `*)`, like this:
-```tryocaml
+```ocaml
(* This is a single-line comment. *)
(* This is a
@@ -20,7 +20,7 @@ In other words, the commenting convention is very similar to original C
OCaml counts nested `(* ... *)` blocks, and this allows you to comment
out regions of code very easily:
-```tryocaml
+```ocaml
(* This code is broken ...
(* Primality test. *)
@@ -29,6 +29,7 @@ let is_prime n =
*)
```
+
## Calling functions
Let's say you've written a function - we'll call it `repeated` - which
takes a string `s` and a number `n`, and returns a new string which
@@ -24,7 +24,7 @@ L'autre méthode, plus correcte, est de stocker les âges dans un champ de
type "entier ou NULL". Par exemple, en SQL, la table pour stocker les
âges ressemblerait à :
-```tryocaml
+```SQL
create table users
(
userid serial,
@@ -124,7 +124,7 @@ aversion pour les débogueurs autres que gdb, vous voudrez sûrement faire
afficher des avertissements par vos fonctions. Voici un exemple (notez
le code surligné) :
-```tryocaml
+```ocaml
open Graphics;;
open_graph " 640x480";;
@@ -136,12 +136,13 @@ for i = 12 downto 1 do
done;;
read_line ();;
```
+
Si vous préférez le style `printf` du langage C, essayez plutôt le
module `Printf` d'OCaml :
-```tryocaml
+```ocaml
open Graphics;;
-<em>open Printf;;</em>
+open Printf;;
open_graph " 640x480";;
for i = 12 downto 1 do
@@ -152,5 +153,4 @@ for i = 12 downto 1 do
fill_circle 320 240 radius
done;;
read_line ();;
-
```
@@ -23,14 +23,15 @@ the long words and use primary colours everywhere.
The other, correct method is to store the age in a field which has type
"int or null". Here's a SQL table for storing ages:
-```tryocaml
+```SQL
create table users
(
userid serial,
name text not null,
age int -- may be null
);
```
+
If the age data isn't collected, then it goes into the database as a
special SQL `NULL` value. SQL ignores this automatically when you ask it
to compute averages and so on.
@@ -111,7 +112,7 @@ If you want to debug your program, but, like me, you have an aversion to
debuggers which aren't gdb, then you'll probably want to print out a
warning some way through your function. Here's an example:
-```tryocaml
+```ocaml
open Graphics
let () =
@@ -127,7 +128,7 @@ let () =
If you prefer C-style `printf`'s then try using OCaml's `Printf` module
instead:
-```tryocaml
+```ocaml
open Graphics
open Printf
@@ -140,5 +141,4 @@ let () =
fill_circle 320 240 radius
done;
read_line ()
-
```
Oops, something went wrong.

0 comments on commit d918b2f

Please sign in to comment.