diff options
| -rw-r--r-- | es-es/whip-es.html.markdown | 255 | ||||
| -rw-r--r-- | pt-br/whip-pt.html.markdown | 247 | ||||
| -rw-r--r-- | whip.html.markdown | 241 |
3 files changed, 0 insertions, 743 deletions
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) |