summaryrefslogtreecommitdiffhomepage
diff options
context:
space:
mode:
authorlkdjiin <xavier.nayrac@gmail.com>2013-12-07 13:55:06 +0100
committerlkdjiin <xavier.nayrac@gmail.com>2013-12-07 13:55:06 +0100
commit9221714ccc15ec315d1df671ecd08697028ee358 (patch)
treeef1eff73ef09b568adb8ab3b4af121f8fd1be9af
parente4b82f94155af6c18236b0811be8defd214d68a8 (diff)
Second draft for french translation of Racket
-rw-r--r--fr-fr/racket-fr.html.markdown52
1 files changed, 25 insertions, 27 deletions
diff --git a/fr-fr/racket-fr.html.markdown b/fr-fr/racket-fr.html.markdown
index ab103647..8b2420f8 100644
--- a/fr-fr/racket-fr.html.markdown
+++ b/fr-fr/racket-fr.html.markdown
@@ -47,9 +47,9 @@ service]. Vous pouvez joindre le traducteur de ce document ici :
1/2 ; rationnel
1+2i ; complexe
-;; Une fonction s'écrit (f x y z ...)
+;; Un appel de fonction s'écrit (f x y z ...)
;; où f est une fonction et x, y, z, ... sont des arguments.
-;; Si vous voulez créer une liste de données litérales, utilisez ' pour
+;; Si vous voulez créer une liste littérales, utilisez ' pour
;; empécher l'évaluation de la liste.
'(+ 1 2) ; => (+ 1 2)
;; Et maintenant, un peu d'arithmétique
@@ -65,8 +65,8 @@ service]. Vous pouvez joindre le traducteur de ce document ici :
(+ 1+2i 2-3i) ; => 3-1i
;;; Booléens
-#t ; for true
-#f ; for false -- any value other than #f is true
+#t ; pour vrai
+#f ; pour faux -- Toute autre valeur que #f est vraie
(not #t) ; => #f
(and 0 #f (error "doesn't get here")) ; => #f
(or #f 0 (error "doesn't get here")) ; => 0
@@ -79,8 +79,8 @@ service]. Vous pouvez joindre le traducteur de ce document ici :
;;; Une chaîne de caractères est un tableau de caractères de longueur
;;; fixe.
"Hello, world!"
-"Benjamin \"Bugsy\" Siegel" ; le backslash est le caractère d'échappement
-"Foo\tbar\41\x21\u0021\a\r\n" ; sont inclus les échappements de type C
+"Benjamin \"Bugsy\" Siegel" ; Le backslash est le caractère d'échappement
+"Foo\tbar\41\x21\u0021\a\r\n" ; Sont inclus les échappements de type C
; et unicode
"λx:(μα.α→α).xx" ; une chaîne peut inclure de l'unicode
@@ -100,7 +100,6 @@ service]. Vous pouvez joindre le traducteur de ce document ici :
;; 2. Variables
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Vous pouvez créer une variable à l'aide de define
-;; a variable name can use any character except: ()[]{}",'`;#|\
;; Une variable peut contenir n'importe quel caractères, à l'exception
;; de : ()[]{}",'`;#|\
(define some-var 5)
@@ -113,7 +112,7 @@ some-var ; => 5
;; Accéder à une variable non-initialisée provoque une exception
; x ; => x: indéfini ...
-;; Attachement local : `me` est attaché à "Bob" seulement à l'intérieur
+;; Déclaration locale : `me` est attaché à "Bob" seulement à l'intérieur
;; de (let ...)
(let ([me "Bob"])
"Alice"
@@ -131,9 +130,9 @@ my-pet ; => #<dog>
(dog? my-pet) ; => #t
(dog-name my-pet) ; => "lassie"
-;;; Paires (non-mutable)
-;; `cons` construit une paire, `car` et `cdr` extraient respectivement les
-;; premiers et seconds éléments.
+;;; Paires (non mutable)
+;; `cons` construit une paire, `car` et `cdr` extraient respectivement le
+;; premier et le second élément.
(cons 1 2) ; => '(1 . 2)
(car (cons 1 2)) ; => 1
(cdr (cons 1 2)) ; => 2
@@ -141,22 +140,22 @@ my-pet ; => #<dog>
;;; Listes
;; Les listes en Racket sont des structures de données de type *linked-list*,
-;; produites avec des paires assemblées avec `cons` et terminée avec `null`
+;; produites avec des paires assemblées avec `cons` et terminée par `null`
;; (ou '()).
(cons 1 (cons 2 (cons 3 null))) ; => '(1 2 3)
;; `list` est un constructeur variadique plus commode à utiliser
(list 1 2 3) ; => '(1 2 3)
-;; et un guillemet simple peut aussi être utilisé pour une liste litérale
+;; et un guillemet simple peut aussi être utilisé pour une liste littérale
'(1 2 3) ; => '(1 2 3)
;; On peut toujours utiliser `cons` pour ajouter un élément au début
;; d'une liste
(cons 4 '(1 2 3)) ; => '(4 1 2 3)
-;; Utilisez `append` pour additionner des listes entre elles
+;; Utilisez `append` pour ajouter une liste à une autre
(append '(1 2) '(3 4)) ; => '(1 2 3 4)
-;; Les listes sont un type très basique, il y a donc *beaucoup* de
+;; Une liste est un type très basique, il y a donc *beaucoup* de
;; fonctionnalités qui leur sont dédiées, quelques exemples :
(map add1 '(1 2 3)) ; => '(2 3 4)
(map + '(1 2 3) '(10 20 30)) ; => '(11 22 33)
@@ -175,17 +174,17 @@ my-pet ; => #<dog>
;;; Sets
-;; Créew un set à partir d'une liste
+;; Créez un set à partir d'une liste
(list->set '(1 2 3 1 2 3 3 2 1 3 2 1)) ; => (set 1 2 3)
;; Ajoutez un membre avec `set-add`
;; (Fonctionnel: renvoit le set étendu, plutôt que de muter le set en entrée)
(set-add (set 1 2 3) 4) ; => (set 1 2 3 4)
-;; Retirer un membre avec `set-remove`
+;; Retirez un membre avec `set-remove`
(set-remove (set 1 2 3) 1) ; => (set 2 3)
-;; Tester l'existence d'un membre avec `set-member?`
+;; Testez l'existence d'un membre avec `set-member?`
(set-member? (set 1 2 3) 1) ; => #t
(set-member? (set 1 2 3) 4) ; => #f
@@ -219,9 +218,8 @@ m ; => '#hash((b . 2) (a . 1) (c . 3)) <-- no `d'
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Utilisez `lambda` pour créer des fonctions.
-;; Une fonction renvoit toujours la valeur de sa dernière expression.
+;; Une fonction renvoie toujours la valeur de sa dernière expression.
(lambda () "Hello World") ; => #<procedure>
-;; Can also use a unicode `λ'
;; On peut aussi utiliser le caractère unicode `λ'
(λ () "Hello World") ; => même fonction
@@ -235,10 +233,11 @@ m ; => '#hash((b . 2) (a . 1) (c . 3)) <-- no `d'
(hello-world) ; => "Hello World"
;; Vous pouvez raccourcir ceci en utilisant le sucre syntaxique pour la
-;; définition des fonctions :
+;; définition de fonction :
(define (hello-world2) "Hello World")
-;; Entre les () après lambda, vous avez la liste des arguments de la fonction
+;; Entre les () après lambda, vous déclarez la liste des arguments de la
+;; fonction
(define hello
(lambda (name)
(string-append "Hello " name)))
@@ -306,7 +305,7 @@ m ; => '#hash((b . 2) (a . 1) (c . 3)) <-- no `d'
(equal? (list 'a 'b) (list 'b 'a)) ; => #f
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; 5. Contrôle du flot
+;; 5. Structures de contrôle
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Conditions
@@ -448,7 +447,7 @@ m ; => '#hash((b . 2) (a . 1) (c . 3)) <-- no `d'
;; 6. Mutabilité
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; Util `set!` pour réassigner une valeur à une variable existante
+;; Utilisez `set!` pour réassigner une valeur à une variable existante
(define n 5)
(set! n (add1 n))
n ; => 6
@@ -503,7 +502,7 @@ vec ; => #(1 2 3 4)
(printf fmt (make-string n ch))
(newline)))
-;; Utilisez `require` pour importer les fonctions fournies par le
+;; Utilisez `require` pour importer les fonctions fournies par un
;; module (provide)
(require 'cake) ; le ' est pour un sous-module local
(print-cake 3)
@@ -537,9 +536,8 @@ vec ; => #(1 2 3 4)
(send charlie grow 6)
(send charlie get-size) ; => 16
-;; `fish%' is a plain "first class" value, which can get us mixins
;; `fish%` est une simple valeur de «première classe», ce qui va permettre
-;; les mélanges (*mixins*)
+;; la composition (*mixins*)
(define (add-color c%)
(class c%
(init color)