diff --git a/es-es/whip-es.html.markdown b/es-es/whip-es.html.markdown
deleted file mode 100644
index 7c2f4bd2..00000000
--- a/es-es/whip-es.html.markdown
+++ /dev/null
@@ -1,255 +0,0 @@
----
-language: whip
-contributors:
-  - ["Tenor Biel", "http://github.com/L8D"]
-translators:
-    - ["Daniel Zendejas", "https://github.com/DanielZendejas"]
-author: Tenor Biel
-author_url: http://github.com/L8D
-filename: whip-es.lisp
-lang: es-es
----
-Tutorial de Whip en español.
-
-Whip es un dialecto de LISP hecho para escribir código y conceptos
-simples. Ha tomado prestado bastante de la sintaxis de Haskell
-(un lenguaje no relacionado).
-
-Esta documentación fue escrita por el creador del lenguaje
-
-```scheme
-; Los comentarios son como en LISP, con punto y coma...
-
-; La mayoría de las sentencias de primer nivel están dentro de
-; "formas". Una forma no es más que cosas dentro de paréntesis
-no_en_la_forma
-(en_la_form)
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-; 1. Números, Strings y Operadores
-
-;Whip tiene un tipo para números (es el estándar 64-bit IEEE 754 double, de JS)
-3 ; => 3
-1.5 ; => 1.5
-
-; Las funciones son llamadas si son el primer elemento de una forma
-(funcion_llamada argumentos)
-
-; La mayoría de los operadores se hacen con funciones
-; Toda la aritmética básica es bastante estándar
-(+ 1 1) ; => 2
-(- 2 1) ; => 1
-(* 1 2) ; => 2
-(/ 2 1) ; => 2
-; incluso el módulo
-(% 9 4) ; => 1
-; división impar al estilo de JavaScript.
-(/ 5 2) ; => 2.5
-
-; Las formas anidadas funcionan como se espera.
-(* 2 (+ 1 3)) ; => 8
-
-; Hay un tipo booleano.
-true
-false
-
-; Los Strings son creados con comillas dobles ".
-"Hola mundo"
-
-; Los caracteres solos se declaran con comillas simples '.
-'a'
-
-; La negación usa la función 'not'.
-(not true) ; => false
-(not false) ; => true
-
-; La mayoría de las funcions que no vienen de Haskell tienen
-; atajos. La función 'not' también se puede declarar con '!'.
-(! (! true)) ; => true
-
-; La igualdad es `equal` o `=`.
-(= 1 1) ; => true
-(equal 2 1) ; => false
-
-; Por ejemplo, la desigualdad sería combinar la función 'not' con
-; la función de igualdad
-(! (= 2 1)) ; => true
-
-; Más comparaciones
-(< 1 10) ; => true
-(> 1 10) ; => false
-; y su contraparte textual.
-(lesser 1 10) ; => true
-(greater 1 10) ; => false
-
-; Los Strings pueden concatenarse con la función +.
-(+ "Hola " "mundo!") ; => "Hello world!"
-
-; También puedes usar las comparativas de JavaScript
-(< 'a' 'b') ; => true
-; ...y la coerción de tipos
-(= '5' 5)
-
-; La función 'at' o @ accesa a los caracteres dentro de los strings,
-; empezando en 0.
-(at 0 'a') ; => 'a'
-(@ 3 "foobar") ; => 'b'
-
-; También están las variables  `null` and `undefined`.
-null; usado para indicar una falta de valor deliberada.
-undefined; usado para indicar un valor que aún no está definido.
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-; 2. Variables, Listas y Diccionarios
-
-; Las variables son declaradas con las funciones `def` o `let`.
-; Las variables que aún no son asignadas tendrán el valor `undefined`.
-(def mi_variable 5)
-; `def` asignará la variable al contexto global.
-; `let` asignará la variable al contexto local,  
-; y tiene una sintaxis distinta.
-(let ((mi_variable 5)) (+ mi_variable 5)) ; => 10
-(+ mi_variable 5) ; = undefined + 5 => undefined
-
-; Las listas son arreglos de valores de cualquier tipo.
-; Básicamente, son formas sin funciones al inicio.
-(1 2 3) ; => [1, 2, 3] (sintaxis JavaScript)
-
-; Los diccionarios son el equivalente en Whip de los 'objetos' de JavaScript,
-; los 'dicts' de Python o los 'hashes' de Ruby: una colección desordenada
-; de pares llave-valor
-{"llave1" "valor1" "llave2" 2 3 3}
-
-; Las llaves son sólo valores, identificadores, números o strings.
-(def mi_diccionario {mi_llave "mi_valor" "mi otra llave" 4})
-; Pero con Whip, los diccionarios son leidos así:
-; "llave" "espacio en blanco" "valor" "espacio en blanco"
-{"llave" "valor"
-"otra llave"
-1234
-}
-
-; Las definiciones de los diccionarios pueden accesarse con la función @
-; (como los strings y las listas)
-(@ "mi otra llave" mi_diccionario) ; => 4
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-; 3. Logica y secuencias de control
-
-; La funcion `if` es bastante simple, aunque distinta que en otros lenguajes.
-(if true "regresa esto si es true" "regresa esto si es false")
-; => "regresa esto si es true"
-
-; Y para el operador ternario `?`
-(? false true false) ; => false
-
-? `both` es un 'y' lógico, mientras que la función `either` es un 'o'.
-(both true true) ; => true
-(both true false) ; => false
-(either true false) ; => true
-(either false false) ; => false
-; Y sus atajos son '&' y '^' respectivamente
-; & => both
-; ^ => either
-(& true true) ; => true
-(^ false true) ; => true
-
-;;;;;;;;;
-; Lambdas
-
-; Las Lambdas en Whip son declaradas con las funciones `lambda` o `->`.
-; Las funciones regulares en realidad sólo son lambdas con nombre.
-(def mi_funcion (-> (x y) (+ (+ x y) 10)))
-;         |       |   |         |
-;         |       |   |    valor regresado(estas son las variables argumentos)
-;         |       | argumentos
-;         | declaración de lambda
-;         |
-;   nombre de la lambda
-
-(mi_funcion 10 10) ; = (+ (+ 10 10) 10) => 30
-
-; Obviamente, todas las lambdas por definición son anónimas y
-; técnicamente siempre usadas anónimamente. Redundancia.
-((lambda (x) x) 10) ; => 10
-
-;;;;;;;;;;;;;;;;
-; Comprensiones
-
-; `range` o `..` genera una lista de números que comprende
-; cada entero dentro de los argumentos.
-(range 1 5) ; => (1 2 3 4 5)
-(.. 0 2)    ; => (0 1 2)
-
-; `map` aplica su primer argumento (que debe ser una función)
-; al siguiente argumento (que es una lista).
-(map (-> (x) (+ x 1)) (1 2 3)) ; => (2 3 4)
-
-; Reducir
-(reduce + (.. 1 5))
-; equivale a
-((+ (+ (+ 1 2) 3) 4) 5)
-
-; Nota: map y reduce no tienen atajos.
-
-; `slice` o `\` es idéntico a la función .slice() de JavaScript
-; Pero toma la lista del primer argumento, no del último.
-(slice (.. 1 5) 2) ; => (3 4 5)
-(\ (.. 0 100) -5) ; => (96 97 98 99 100)
-
-; `append` o `<<` se explica solo.
-(append 4 (1 2 3)) ; => (1 2 3 4)
-(<< "bar" ("foo")) ; => ("foo" "bar")
-
-; Length se explica solo.
-(length (1 2 3)) ; => 3
-(_ "foobar") ; => 6
-
-;;;;;;;;;;;;;;;
-; Elementos de Haskell
-
-; Primer elemento en una lista
-(head (1 2 3)) ; => 1
-
-; Lista del segundo elemento al último en una lista
-(tail (1 2 3)) ; => (2 3)
-
-; Último elemento en una lista
-(last (1 2 3)) ; => 3
-
-; Contrario a `tail`
-(init (1 2 3)) ; => (1 2)
-
-; Lista del primer elemento al argumento
-(take 1 (1 2 3 4)) ; (1 2)
-
-; Contrario a `take`
-(drop 1 (1 2 3 4)) ; (3 4)
-
-; Valor más pequeño de una lista
-(min (1 2 3 4)) ; 1
-
-; Valor más grande de una lista
-(max (1 2 3 4)) ; 4
-
-; Comprobar que el elemento está en la lista
-(elem 1 (1 2 3)) ; true
-(elem "foo" {"foo" "bar"}) ; true
-(elem "bar" {"foo" "bar"}) ; false
-
-; Invertir el orden de la lista
-(reverse (1 2 3 4)) ; => (4 3 2 1)
-
-; Comprobar si un elemento es par o impar
-(even 1) ; => false
-(odd 1) ; => true
-
-; Separar string en una lista de strings, separados por espacios
-(words "foobar nachos cheese") ; => ("foobar" "nachos" "cheese")
-; Juntar lista de strings.
-(unwords ("foo" "bar")) ; => "foobar"
-(pred 21) ; => 20
-(succ 20) ; => 21
-```
-
-Para más información, revisa el [repositorio](http://github.com/L8D/whip)
diff --git a/pt-br/whip-pt.html.markdown b/pt-br/whip-pt.html.markdown
deleted file mode 100644
index b11faf28..00000000
--- a/pt-br/whip-pt.html.markdown
+++ /dev/null
@@ -1,247 +0,0 @@
----
-language: whip
-contributors:
-  - ["Tenor Biel", "http://github.com/L8D"]
-  - ["Saurabh Sandav", "http://github.com/SaurabhSandav"]
-author: Tenor Biel
-author_url: http://github.com/L8D
-translators:
-  - ["Paulo Henrique Rodrigues Pinheiro", "https://github.com/paulohrpinheiro"]
-lang: pt-br
-filename: whip-pt.lisp
----
-
-Whip é um dialeto de Lisp feito para construir scripts e trabalhar com
-conceitos mais simples.
-Ele também copia muitas funções e sintaxe de Haskell (uma linguagem não correlata)
-
-Esse documento foi escrito pelo próprio autor da linguagem. Então é isso.
-
-```scheme
-; Comentário são como em Lisp. Pontos-e-vírgulas...
-
-; A maioria das declarações de primeiro nível estão dentro de "listas"
-; que nada mais são que coisas entre parênteses separadas por espaços em branco
-nao_é_uma_lista
-(uma lista)
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-; 1. Números, texto e operadores
-
-; Whip tem um tipo numérico (que é um double de 64 bits IEE 754, do JavaScript)
-3 ; => 3
-1.5 ; => 1.5
-
-; Funções são chamadas se elas são o primeiro elemento em uma lista
-(funcao_chamada argumentos)
-
-; A maioria das operações são feitas com funções
-; Todas as funções aritméticas básicas são bem diretas
-(+ 1 1) ; => 2
-(- 2 1) ; => 1
-(* 1 2) ; => 2
-(/ 2 1) ; => 2
-; até mesmo o módulo
-(% 9 4) ; => 1
-; Divisão não inteira ao estilo JavaScript.
-(/ 5 2) ; => 2.5
-
-; Aninhamento de listas funciona como esperado.
-(* 2 (+ 1 3)) ; => 8
-
-; Há um tipo boleano.
-true
-false
-
-; Textos são criados com ".
-"Hello, world"
-
-; Caracteres são criados com '.
-'a'
-
-; Para negação usa-se a função 'not'.
-(not true) ; => false
-(not false) ; => true
-
-; Mas a maioria das funções não-haskell tem atalhos
-; o atalho para "não" é um '!'.
-(! (! true)) ; => true
-
-; Igualdade é `equal` ou `=`.
-(= 1 1) ; => true
-(equal 2 1) ; => false
-
-; Por exemplo, desigualdade pode ser verificada combinando as funções
-;`not` e `equal`.
-(! (= 2 1)) ; => true
-
-; Mais comparações
-(< 1 10) ; => true
-(> 1 10) ; => false
-; e suas contra partes para texto.
-(lesser 1 10) ; => true
-(greater 1 10) ; => false
-
-; Texto pode ser concatenado com +.
-(+ "Hello " "world!") ; => "Hello world!"
-
-; Você pode usar as características comparativas do JavaScript.
-(< 'a' 'b') ; => true
-; ... e coerção de tipos
-(= '5' 5)
-
-; As funções `at` ou `@` acessarão caracteres de um texto, começando em 0.
-(at 0 'a') ; => 'a'
-(@ 3 "foobar") ; => 'b'
-
-; Também existem as variáveis `null` e `undefined`.
-null ; usada para indicar a ausência de algum valor
-undefined ; usada para indicar que um valor não foi informado
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-; 2. Variáveis, matrizes e dicionários
-
-; Variáveis são declaradas com as funções `def` ou `let`.
-; Variáveis que não tiveram valor atribuído serão `undefined`.
-(def some_var 5)
-; `def` deixará a variável no contexto global.
-; `let` deixará a variável no contexto local, e tem uma sintaxe estranha.
-(let ((a_var 5)) (+ a_var 5)) ; => 10
-(+ a_var 5) ; = undefined + 5 => undefined
-
-; Matrizes são listas de valores de qualquer tipo.
-; Elas basicamente são listas sem funções no início
-(1 2 3) ; => [1, 2, 3] (sintaxe JavaScript)
-
-; Dicionários em Whip são o equivalente a 'object' em JavaScript ou
-; 'dict' em python ou 'hash' em Ruby: eles são uma coleção desordenada
-de pares chave-valor.
-{"key1" "value1" "key2" 2 3 3}
-
-; Chaves podem ser apenas identificadores, números ou texto.
-(def my_dict {my_key "my_value" "my other key" 4})
-; Mas em Whip, dicionários são parceados como: valor, espaço, valor;
-; com mais espaço entre cada. Então isso significa que
-{"key" "value"
-"another key"
-1234
-}
-é avaliado da mesma forma que
-{"key" "value" "another key" 1234}
-
-; Dicionários podem ser acessados usando a função `at`
-; (como em texto e listas)
-(@ "my other key" my_dict) ; => 4
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-; 3. Lógica e controle de fluxo
-
-; A função `if` é muito simples, ainda que muito diferente do que em muitas
-linguagens imperativas.
-(if true "returned if first arg is true" "returned if first arg is false")
-; => "returned if first arg is true"
-
-; E por conta do legado operador ternário
-; `?` é o atalho não utilizado para `if`.
-(? false true false) ; => false
-
-; `both` é uma declaração lógica `and`, e `either` é o `or` lógico.
-(both true true) ; => true
-(both true false) ; => false
-(either true false) ; => true
-(either false false) ; => false
-; E seus atalhos são
-; & => both
-; ^ => either
-(& true true) ; => true
-(^ false true) ; => true
-
-;;;;;;;;;
-; Lambdas
-
-; Lambdas em Whip são declaradas com as funções `lambda` ou `->`.
-; E funções são na verdade lambdas com nomes.
-(def my_function (-> (x y) (+ (+ x y) 10)))
-;         |       |    |          |
-;         |       |    |    valor retornado (com escopo contento argumentos)
-;         |       | argumentos
-;         | declaração de funções lambda
-;         |
-;   nome do lambda a ser declarado
-
-(my_function 10 10) ; = (+ (+ 10 10) 10) => 30
-
-; Obviamente, todos os lambdas por definição são anônimos e
-; tecnicamente sempre usados anonimamente. Redundância.
-((lambda (x) x) 10) ; => 10
-
-;;;;;;;;;;;;;;;;
-; Comprehensions
-
-; `range` or `..` geram uma lista dos números para
-; cada número entre seus dois argumentos.
-(range 1 5) ; => (1 2 3 4 5)
-(.. 0 2)    ; => (0 1 2)
-
-; `map` aplica seu primeiro argumento (que deve ser um lambda/função)
-; a cada item dos argumentos seguintes (que precisa ser uma lista)
-(map (-> (x) (+ x 1)) (1 2 3)) ; => (2 3 4)
-
-; Reduce
-(reduce + (.. 1 5))
-; equivalente a
-((+ (+ (+ 1 2) 3) 4) 5)
-
-; Nota: map e reduce não possuem atalhos
-
-; `slice` ou `\` é similar ao .slice() do JavaScript
-; mas veja que ele pega uma lista como primeiro argumento, não o último.
-(slice (.. 1 5) 2) ; => (3 4 5)
-(\ (.. 0 100) -5) ; => (96 97 98 99 100)
-
-; `append` ou `<<` são auto explicativos
-(append 4 (1 2 3)) ; => (1 2 3 4)
-(<< "bar" ("foo")) ; => ("foo" "bar")
-
-; Length é auto explicativo.
-(length (1 2 3)) ; => 3
-(_ "foobar") ; => 6
-
-;;;;;;;;;;;;;;;
-; Delicadezas Haskell
-
-; Primeiro item de uma lista
-(head (1 2 3)) ; => 1
-; Pega do segundo ao último elemento de uma lista
-(tail (1 2 3)) ; => (2 3)
-; Último item de uma lista
-(last (1 2 3)) ; => 3
-; Contrário de `tail`
-(init (1 2 3)) ; => (1 2)
-; Pega do primeiro até o elemento especificado da lista
-(take 1 (1 2 3 4)) ; (1 2)
-; Contrário de `take`
-(drop 1 (1 2 3 4)) ; (3 4)
-; Menor valor em uma lista
-(min (1 2 3 4)) ; 1
-; Maior valor em uma lista
-(max (1 2 3 4)) ; 4
-; Verifica se o valor está em uma lista ou objeto
-(elem 1 (1 2 3)) ; true
-(elem "foo" {"foo" "bar"}) ; true
-(elem "bar" {"foo" "bar"}) ; false
-; Inverte a ordem de uma lista
-(reverse (1 2 3 4)) ; => (4 3 2 1)
-; Verifica se o valor é par ou ímpar
-(even 1) ; => false
-(odd 1) ; => true
-; Separa um texto cortando por espaço em branco
-(words "foobar nachos cheese") ; => ("foobar" "nachos" "cheese")
-; Junta lista de textos
-(unwords ("foo" "bar")) ; => "foobar"
-; Sucessor e predecessor
-(pred 21) ; => 20
-(succ 20) ; => 21
-```
-
-Para mais informação, verifique o [repositório](http://github.com/L8D/whip)
diff --git a/whip.html.markdown b/whip.html.markdown
deleted file mode 100644
index c692714a..00000000
--- a/whip.html.markdown
+++ /dev/null
@@ -1,241 +0,0 @@
----
-language: whip
-contributors:
-  - ["Tenor Biel", "http://github.com/L8D"]
-  - ["Saurabh Sandav", "http://github.com/SaurabhSandav"]
-  - ["Paulo Henrique Rodrigues Pinheiro", "https://github.com/paulohrpinheiro"]
-author: Tenor Biel
-author_url: http://github.com/L8D
-filename: whip.lisp
----
-
-Whip is a LISP-dialect made for scripting and simplified concepts.
-It has also borrowed a lot of functions and syntax from Haskell (a non-related language).
-
-These docs were written by the creator of the language himself. So is this line.
-
-```scheme
-; Comments are like LISP. Semi-colons...
-
-; Majority of first-level statements are inside "forms"
-; which are just things inside parens separated by whitespace
-not_in_form
-(in_form)
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-; 1. Numbers, Strings, and Operators
-
-; Whip has one number type (which is a 64-bit IEEE 754 double, from JavaScript).
-3 ; => 3
-1.5 ; => 1.5
-
-; Functions are called if they are the first element in a form
-(called_function args)
-
-; Majority of operations are done with functions
-; All the basic arithmetic is pretty straight forward
-(+ 1 1) ; => 2
-(- 2 1) ; => 1
-(* 1 2) ; => 2
-(/ 2 1) ; => 2
-; even modulo
-(% 9 4) ; => 1
-; JavaScript-style uneven division.
-(/ 5 2) ; => 2.5
-
-; Nesting forms works as you expect.
-(* 2 (+ 1 3)) ; => 8
-
-; There's a boolean type.
-true
-false
-
-; Strings are created with ".
-"Hello, world"
-
-; Single chars are created with '.
-'a'
-
-; Negation uses the 'not' function.
-(not true) ; => false
-(not false) ; => true
-
-; But the majority of non-haskell functions have shortcuts
-; not's shortcut is a '!'.
-(! (! true)) ; => true
-
-; Equality is `equal` or `=`.
-(= 1 1) ; => true
-(equal 2 1) ; => false
-
-; For example, inequality would be combining the not and equal functions.
-(! (= 2 1)) ; => true
-
-; More comparisons
-(< 1 10) ; => true
-(> 1 10) ; => false
-; and their word counterpart.
-(lesser 1 10) ; => true
-(greater 1 10) ; => false
-
-; Strings can be concatenated with +.
-(+ "Hello " "world!") ; => "Hello world!"
-
-; You can use JavaScript's comparative abilities.
-(< 'a' 'b') ; => true
-; ...and type coercion
-(= '5' 5)
-
-; The `at` or @ function will access characters in strings, starting at 0.
-(at 0 'a') ; => 'a'
-(@ 3 "foobar") ; => 'b'
-
-; There is also the `null` and `undefined` variables.
-null ; used to indicate a deliberate non-value
-undefined ; user to indicate a value that hasn't been set
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-; 2. Variables, Lists, and Dicts
-
-; Variables are declared with the `def` or `let` functions.
-; Variables that haven't been set will be `undefined`.
-(def some_var 5)
-; `def` will keep the variable in the global context.
-; `let` will only have the variable inside its context, and has a weirder syntax.
-(let ((a_var 5)) (+ a_var 5)) ; => 10
-(+ a_var 5) ; = undefined + 5 => undefined
-
-; Lists are arrays of values of any type.
-; They basically are just forms without functions at the beginning.
-(1 2 3) ; => [1, 2, 3] (JavaScript syntax)
-
-; Dictionaries are Whip's equivalent to JavaScript 'objects' or Python 'dicts'
-; or Ruby 'hashes': an unordered collection of key-value pairs.
-{"key1" "value1" "key2" 2 3 3}
-
-; Keys are just values, either identifier, number, or string.
-(def my_dict {my_key "my_value" "my other key" 4})
-; But in Whip, dictionaries get parsed like: value, whitespace, value;
-; with more whitespace between each. So that means
-{"key" "value"
-"another key"
-1234
-}
-; is evaluated to the same as
-{"key" "value" "another key" 1234}
-
-; Dictionary definitions can be accessed used the `at` function
-; (like strings and lists.)
-(@ "my other key" my_dict) ; => 4
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-; 3. Logic and Control sequences
-
-; The `if` function is pretty simple, though different than most imperative langs.
-(if true "returned if first arg is true" "returned if first arg is false")
-; => "returned if first arg is true"
-
-; And for the sake of ternary operator legacy
-; `?` is if's unused shortcut.
-(? false true false) ; => false
-
-; `both` is a logical 'and' statement, and `either` is a logical 'or'.
-(both true true) ; => true
-(both true false) ; => false
-(either true false) ; => true
-(either false false) ; => false
-; And their shortcuts are
-; & => both
-; ^ => either
-(& true true) ; => true
-(^ false true) ; => true
-
-;;;;;;;;;
-; Lambdas
-
-; Lambdas in Whip are declared with the `lambda` or `->` function.
-; And functions are really just lambdas with names.
-(def my_function (-> (x y) (+ (+ x y) 10)))
-;         |       |    |          |
-;         |       |    |    returned value(with scope containing argument vars)
-;         |       | arguments
-;         | lambda declaration function
-;         |
-;   name of the to-be-declared lambda
-
-(my_function 10 10) ; = (+ (+ 10 10) 10) => 30
-
-; Obviously, all lambdas by definition are anonymous and
-; technically always used anonymously. Redundancy.
-((lambda (x) x) 10) ; => 10
-
-;;;;;;;;;;;;;;;;
-; Comprehensions
-
-; `range` or `..` generates a list of numbers for
-; each number between its two args.
-(range 1 5) ; => (1 2 3 4 5)
-(.. 0 2)    ; => (0 1 2)
-
-; `map` applies its first arg (which should be a lambda/function)
-; to each item in the following arg (which should be a list)
-(map (-> (x) (+ x 1)) (1 2 3)) ; => (2 3 4)
-
-; Reduce
-(reduce + (.. 1 5))
-; equivalent to
-((+ (+ (+ 1 2) 3) 4) 5)
-
-; Note: map and reduce don't have shortcuts
-
-; `slice` or `\` is just like JavaScript's .slice()
-; But do note, it takes the list as the first argument, not the last.
-(slice (.. 1 5) 2) ; => (3 4 5)
-(\ (.. 0 100) -5) ; => (96 97 98 99 100)
-
-; `append` or `<<` is self explanatory
-(append 4 (1 2 3)) ; => (1 2 3 4)
-(<< "bar" ("foo")) ; => ("foo" "bar")
-
-; Length is self explanatory.
-(length (1 2 3)) ; => 3
-(_ "foobar") ; => 6
-
-;;;;;;;;;;;;;;;
-; Haskell fluff
-
-; First item in list
-(head (1 2 3)) ; => 1
-; List from second to last elements in list
-(tail (1 2 3)) ; => (2 3)
-; Last item in list
-(last (1 2 3)) ; => 3
-; Reverse of `tail`
-(init (1 2 3)) ; => (1 2)
-; List from first to specified elements in list
-(take 1 (1 2 3 4)) ; (1 2)
-; Reverse of `take`
-(drop 1 (1 2 3 4)) ; (3 4)
-; Lowest value in list
-(min (1 2 3 4)) ; 1
-; Highest value in list
-(max (1 2 3 4)) ; 4
-; If value is in list or object
-(elem 1 (1 2 3)) ; true
-(elem "foo" {"foo" "bar"}) ; true
-(elem "bar" {"foo" "bar"}) ; false
-; Reverse list order
-(reverse (1 2 3 4)) ; => (4 3 2 1)
-; If value is even or odd
-(even 1) ; => false
-(odd 1) ; => true
-; Split string into list of strings by whitespace
-(words "foobar nachos cheese") ; => ("foobar" "nachos" "cheese")
-; Join list of strings together.
-(unwords ("foo" "bar")) ; => "foobar"
-; Successor and Predecessor
-(pred 21) ; => 20
-(succ 20) ; => 21
-```
-
-For more info, check out the [repo](http://github.com/L8D/whip)