Séries- comandos de alteração
Estes comandos alteram a série original:
action! clear
Apaga os elementos da série.
Simplesmente atribuir " " (string vazia) ou zero para uma série não vai produzir os resultados esperados. A lógica do Red parece fazer com que ele "lembre" de coisas de forma inesperada. Para realmente limpar uma série, você precisa usar o clear.
>> a: [11 22 33 "cat"]
== [11 22 33 "cat"]
>> clear a
== []
>> a
== []
action! poke
Altera o valor de um elemento da série na posição dada pelo segundo argumento. O novo valor da posição é dado pelo terceiro argumento.
>> x: ["cat" "dog" "mouse" "fly"]
== ["cat" "dog" "mouse" "fly"]
>> poke x 3 "BULL"
== "BULL"
>> x
== ["cat" "dog" "BULL" "fly"]
>> s: "abcdefghijklmn"
== "abcdefghijklmn"
>> poke s 4 #"W"
== #"W"
>> s
== "abcWefghijklmn"
action! append
Insere os valores do segundo argumento no final da série. Altera apenas a primeira série original.
>> x: ["cat" "dog" "mouse" "fly"]
== ["cat" "dog" "mouse" "fly"]
>> append x "HOUSE"
== ["cat" "dog" "mouse" "fly" "HOUSE"]
>> x
== ["cat" "dog" "mouse" "fly" "HOUSE"]
>> x: ["cat" "dog" "mouse" "fly"]
== ["cat" "dog" "mouse" "fly"]
>> y: ["Sky" "Bull"]
== ["Sky" "Bull"]
>> append x y
== ["cat" "dog" "mouse" "fly" "Sky" "Bull"]
>> x
== ["cat" "dog" "mouse" "fly" "Sky" "Bull"]
>> append "abcd" "EFGH"
== "abcdEFGH"
/part
Limita o numero de elementos do append.
>> append/part ["a" "b" "c"] ["A" "B" "C" "D" "E"] 2
== ["a" "b" "c" "A" "B"]
/only
Faz o append da série B na série A, mas B vai como um bloco:
>> append/only ["a" "b" "c"] ["A" "B"]
== ["a" "b" "c" ["A" "B"]]
/dup
Faz o append da série B na série A um determinado número de vezes. Acho que não devia se chamar dup de "duplicado", pois pode triplicar, quadruplicar...
>> append/dup ["a" "b" "c"] ["A" "B"] 3
== ["a" "b" "c" "A" "B" "A" "B" "A" "B"]
action! insert
É como o append, mas as adição é feita no entry index corrente (normalmente o começo). Enquanto o append retorna a série a partir do head, o insert returna a partir da inserção. Isto permite que sejam feitos muitas operações de insert em cadeia e ajuda a calcular o tamanho da parte inserida, mas note que a: insert a xxx não altera "a"!
>> a: "abcdefgh"
== "abcdefgh"
>> insert a "OOO"
== "abcdefgh"
>> a
== "OOOabcdefgh"
>> a: "abcdefgh"
== "abcdefgh"
>> insert at a 3 "OOO"
== "cdefgh"
>> a
== "abOOOcdefgh"
/part
Insere apenas um dado número de elementos do segundo argumento.
/only
Permite a inserção como bloco.
/dup
Permite a inserção um dado número de vezes:
>> a: "abcdefg"
== "abcdefg"
>> insert/dup a "XYZ" 3
== "abcdefg"
>> a
== "XYZXYZXYZabcdefg"
function! replace
Substitui os elementos de uma série.
>> replace ["cat" "dog" "mouse" "fly" "Sky" "Bull"] "mouse" "HORSE"
== ["cat" "dog" "HORSE" "fly" "Sky" "Bull"]
/all
Susbstitui todas as ocorrências:
>> a: "my nono house nono is nono nice"
== "my nono house nono is nono nice"
>> replace/all a "nono " ""
== "my house is nice"
action! sort
Ordena a série.
>> sort [8 4 3 9 0 1 5 2 7 6]
== [0 1 2 3 4 5 6 7 8 9]
>> sort "sorting strings is useless"
== " eeggiiilnnorrsssssssttu"
/case
Leva em consideração letras maiúsculas e minúsculas.
/skip
Trata a série como grupos de elementos de tamanho definido.
/compare
Para comparar offset, block ou function. (?)
/part
Ordena só parte da série.
/all
Compara todos os campos. (?)
/reverse
Reverte a ordem da ordenação.
/stable
Ordenação estável. (?)
action! remove
Remove o primeiro elemento da série.
>> s: ["cat" "dog" "fox" "cow" "fly" "ant" "bee"]
== ["cat" "dog" "fox" "cow" "fly" "ant" "bee"]
>> remove s
== ["dog" "fox" "cow" "fly" "ant" "bee"]
/part
Remove um determinado número de elementos.
>> s: "abcdefghij"
== "abcdefghij"
>> remove/part s 4
== "efghij"
Note que você pode fazer a mesma coisa com remove at [0 1 2 3 4 5] 2 .
native! remove-each
Assim como foreach, este comando executa um bloco para cada elemento da série. Se o bloco retornar true, o comando remove o elemento correspondente da série:
Red []
a: ["dog" 23 3.5 "house" 45]
remove-each i a [string? i] ;removes all strings
print a
23 3.5 45
Red []
a: " my house in the middle of our street"
remove-each i a [i = #" "] ;removes all spaces
print a
myhouseinthemiddleofourstreet
action! take
Remove o PRIMEIRO elemento da série e retorna este primeiro elemento.
>> s: ["cat" "dog" "fox" "cow" "fly" "ant" "bee"]
== ["cat" "dog" "fox" "cow" "fly" "ant" "bee"]
>> take s
== "cat"
>> s
== ["dog" "fox" "cow" "fly" "ant" "bee"]
/last
Remove o último elemento da série e retorna este elemento.
>> s: ["cat" "dog" "fox" "cow" "fly" "ant" "bee"]
== ["cat" "dog" "fox" "cow" "fly" "ant" "bee"]
>> take/last s
== "bee"
>> s
== ["cat" "dog" "fox" "cow" "fly" "ant"]
take/last e append podem ser usados para fazer operações tipo "pilha" (stack).
/part
Remove um determinado número de elementos do começo de uma série e os dá como retorno.
>> s: ["cat" "dog" "fox" "cow" "fly" "ant" "bee"]
== ["cat" "dog" "fox" "cow" "fly" "ant" "bee"]
>> take/part s 3
== ["cat" "dog" "fox"]
>> s
== ["cow" "fly" "ant" "bee"]
/deep
A documentação diz que "Copy nested values". Não entendi.
action! move
Move um ou mais elementos do segundo argumento para o primeiro. Altera as duas séries.
/part
Para mover mais de um elemento.
>> a: [a b c d]
== [a b c d]
>> b: [1 2 3 4]
== [1 2 3 4]
>> move a b
== [b c d]
>> a
== [b c d]
>> b
== [a 1 2 3 4]
>> move/part a b 2
== [d]
>> a
== [d]
>> b
== [b c a 1 2 3 4]
move pode ser usado em combinação com outros comandos para mover elementos dentro de uma mesma série:
>> a: [1 2 3 4 5]
== [1 2 3 4 5]
>> move a tail a
== [2 3 4 5 1]
>> move/part a tail a 3
== [5 1 2 3 4]
action! change
Altera os primeiros elementos de uma série e retorna a série após a mudança. Modifica a primeira série original, não a segunda.
>> a: [1 2 3 4 5]
== [1 2 3 4 5]
>> change a [a b]
== [3 4 5]
>> a
== [a b 3 4 5]
/part
Limita a quantidade de mudanças a um dado número de elementos.
/only
Muda uma série como série.
/dup
Faz a mudança um determinado número de vezes.
function! alter
Pode remover ou fazzer um append na série. Se alter NÃO encontrar o elemento na série, ele faz o append desse elemento e retorna true. Se ele encontra o elemento, remove-o , e retorna false.
>> a: ["cat" "dog" "fly" "bat" "owl"]
== ["cat" "dog" "fly" "bat" "owl"]
>> alter a "dog"
== false
>> a
== ["cat" "fly" "bat" "owl"]
>> alter a "HOUSE"
== true
>> a
== ["cat" "fly" "bat" "owl" "HOUSE"]
action! swap
Troca os primeiros elementos de duas séries. Retorna a primeira série, mas modifica as duas:
>> a: [1 2 3 4] b: [a b c d]
>> swap a b
== [a 2 3 4]
>> a
== [a 2 3 4]
>> b
== [1 b c d]
Com find , por exemplo, pode ser usado para trocar quaisquer elementos de duas séries ou mesmo elementos dentro de uma mesma série:
>> a: [1 2 3 4 5] b: ["dog" "bat" "owl" "rat"]
== ["dog" "bat" "owl" "rat"]
>> swap find a 3 find b "owl"
== ["owl" 4 5]
>> a
== [1 2 "owl" 4 5]
>> b
== ["dog" "bat" 3 "rat"]
action! reverse
Reverte a ordem dos elementos de uma série:
>> reverse [1 2 3]
== [3 2 1]
>> reverse "abcde"
== "edcba"
/part limita o número de elementos a serem revertidos:
>> reverse/part "abcdefghi" 4
== "dcbaefghi"