mirror of
https://github.com/adambard/learnxinyminutes-docs.git
synced 2024-12-23 17:41:41 +00:00
[whip/*] delete (#4949)
This commit is contained in:
Boris Verkhovskiy
GitHub
parent
797b965edd
commit
036500080b
@ -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)
|
||||
@ -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)
|
||||
@ -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)
|
||||
Loading…
Reference in New Issue
Block a user