Apprendre X en Y minutes

;; Ceci est une introduction simple à Hy, pour un tutoriel rapide aller à
;; http://try-hy.appspot.com
;;
; Les commentaires se font avec des points-virgules, comme les autres LISPS

;; les s-expression de bases
; Les programmes Lisp sont fait d'expressions symboliques ou sexps qui
; ressemblent à
(some-function args)
; maintenant le quintessentiel hello world
(print "hello world")

;; les types de données simples
; Tous les types de données simples sont exactement similaires à leurs
; homologues de Python
42 ; => 42
3.14 ; => 3.14
True ; => True
4+10j ; => (4+10j) un nombre complexe

; Commençons par un peu d'arithmétique très simple
(+ 4 1) ;=> 5
; l'opérateur est appliqué à tous les arguments, comme les autres lisps
(+ 4 1 2 3) ;=> 10
(- 2 1) ;=> 1
(* 4 2) ;=> 8
(/ 4 1) ;=> 4
(% 4 2) ;=> 0 l'opérateur modulo
; l'opérateur d'élévation à la puissance est représenté par ** comme en Python
(** 3 2) ;=> 9
; les expressions imbriquées vont se comporter comme on s'y attend
(+ 2 (* 4 2)) ;=> 10
; aussi, les opérateurs logiques and or not et equal to etc. vont se comporter
; comme on s'y attend
(= 5 4) ;=> False
(not (= 5 4)) ;=> True

;; variables
; les variables sont déclarées en utilisant setv, les noms de variables
; peuvent utiliser l'UTF-8 à l'exception de ()[]{}",'`;#|
(setv a 42)
(setv π 3.14159)
(def *foo* 42)
;; d'autres types de conteneurs
; les chaînes, les listes, les tuples et dicts
; ce sont exactement les mêmes que les types de conteneurs de Python
"hello world" ;=> "hello world"
; les opérations sur les chaînes fonctionnent comme en Python
(+ "hello " "world") ;=> "hello world"
; les listes sont créés en utilisant [], l'indexation commence à 0
(setv mylist [1 2 3 4])
; les tuples sont des structures de données immuables
(setv mytuple (, 1 2))
; les dictionnaires sont des paires clé-valeur
(setv dict1 {"key1" 42 "key2" 21})
; :nom peut être utilisé pour définir des mots clés dans Hy qui peuvent être
;  utilisées comme clés
(setv dict2 {:key1 41 :key2 20})
; utilisez `get' pour obtenir l'élément à l'index / clé
(get mylist 1) ;=> 2
(get dict1 "key1") ;=> 42
; Alternativement, si des mots clés ont été utilisés, l'élément peut être
; obtenu directement
(:key1 dict2) ;=> 41

;; fonctions et autres constructions de programme
; les fonctions sont définies en utilisant defn, la dernière sexp est renvoyé par défaut
(defn greet [name]
  "A simple greeting" ; une docstring optionnelle
  (print "hello " name))

(greet "bilbo") ;=> "hello bilbo"

; les fonctions peuvent prendre des arguments optionnels ainsi que des
; arguments sous forme de mots clés
(defn foolists [arg1 &optional [arg2 2]]
  [arg1 arg2])

(foolists 3) ;=> [3 2]
(foolists 10 3) ;=> [10 3]

; les fonctions anonymes sont créés en utilisant `fn' ou `lambda'
; qui sont semblable à `defn '
(map (fn [x] (* x x)) [1 2 3 4]) ;=> [1 4 9 16]

;; Opérations sur les séquences
; Hy a des utilitaires natifs pour les opérations sur les séquences etc.
; récupérez le premier élément en utilisant  `first' ou `car'
(setv mylist [1 2 3 4])
(setv mydict {"a" 1 "b" 2})
(first mylist) ;=> 1

; découpez les listes en utilisant cut
(cut mylist 1 3) ;=> [2 3]

; obtenez les éléments d'une liste ou dict en utilisant `get'
(get mylist 1) ;=> 2
(get mydict "b") ;=> 2
; l'indexation des listes commence à 0 comme en Python
; assoc peut définir les éléments à clés/index
(assoc mylist 2 10) ; makes mylist [1 2 10 4]
(assoc mydict "c" 3) ; makes mydict {"a" 1 "b" 2 "c" 3}
; il ya tout un tas d'autres fonctions de base qui rend le travail avec
; les séquences amusant

;; les importations fonctionnent comme en Python
(import datetime)
(import functools [partial reduce]) ; importe fun1 et fun2 de module1
(import matplotlib.pyplot :as plt) ; faire une importation foo comme bar
; toutes les méthodes natives de Python sont accessibles à partir de Hy
; a.foo(arg) est appelé (.foo a arg)
(.split (.strip "hello world  ")) ;=> ["hello" "world"]

;; Conditionelles
; (if condition (body-if-true) (body-if-false)
(if (= passcode "moria")
  (print "welcome")
  (print "Speak friend, and Enter!"))

; imbriquez plusieurs if else if avec le mot clé cond
(cond
 (= someval 42) (print "Life, universe and everything else!")
 (> someval 42) (print "val too large")
 (< someval 42) (print "val too small"))

; groupez les expressions avec do, ceux-ci seront executé séquentiellemnt
; les expressions comme defn ont un do implicite
(do
 (setv someval 10)
 (print "someval is set to " someval)) ;=> 10

; créer une liaison lexicale avec `let', toutes les variables déclarées
; comme cela ont une portée locale
(let [[nemesis {"superman" "lex luther"
                "sherlock" "moriarty"
                "seinfeld" "newman"}]]
  (for [(, h v) (.items nemesis)]
    (print (.format "{0}'s nemesis was {1}" h v))))

;; classes
; les classes sont définies comme ceci
(defclass Wizard [object]
  (defn __init__ [self spell]
    (setv self.spell spell))

  (defn get-spell [self]
    self.spell))