Series "changers"

---

Tyto příkazy mění původní řady !

action! clear

Smaže všechny elementy řady.

Pouhé přiřazení prázdného řetězce (" ")  nebo nuly nemusí mít očekávaný účinek. Pamatování "věcí" realizuje Red mnohdy neočekávanými způsoby. Skutečné smazání řady zajistí příkaz  clear.

>> a: [11 22 33 "cat"]
== [11 22 33 "cat"]

>> clear a
== []

>> a
== []

action! poke

Změní hodnotu elementu řady v pozici dané druhým argumentem na hodnotu třetího argumentu.

>> 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

Vloží elementy druhého argumentu na konec řady.

>> 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

Omezuje počet připojovaných elementů.

>>  append/part ["a" "b" "c"] ["A" "B" "C" "D" "E"]  2
== ["a" "b" "c" "A" "B"]

/only

Připojí připojovanou řadu jako vnořený blok.

>> append/only ["a" "b" "c"] ["A" "B"]
== ["a" "b" "c" ["A" "B"]]

/dup

Připojí vícekrát (dup) druhý argument k prvnímu.

>> append/dup ["a" "b" "c"] ["A" "B"] 3
== ["a" "b" "c" "A" "B" "A" "B" "A" "B"]

action! insert

Vloží elementy druhého argumentu v místě aktuálního entry-indexu (obvykle to je počátek řady). Zatímco append vrací řadu od čela, insert ji vrací až za místem vložení. To umožňuje řetězit vícero operací  insert, nebo  počítat délku vložené části.

>> a: "abcdefgh"
== "abcdefgh"

>> insert a "OOO"
== "abcdefgh"

>> a
== "OOOabcdefgh"

>> a: "abcdefgh"
== "abcdefgh"

>> insert at a 3 "OOO"
== "cdefgh"

>> a
== "abOOOcdefgh"

/part

Vloží pouze zadaný počet vkládaných elementů.

/only

Umožňuje vložení elementů jako blok.

/dup

Umožňuje opakované vložení druhého argumentu v počtu, daném třetím argumentem.

>> a: "abcdefg"
== "abcdefg"

>> insert/dup a "XYZ" 3
== "abcdefg"

>> a
== "XYZXYZXYZabcdefg"

function! replace

Nahradit uvedený element danou hodnotou. Provede se jen pro první výskyt.

>> replace ["cat" "dog" "mouse" "fly" "Sky" "Bull"] "mouse" "HORSE"
== ["cat" "dog" "HORSE" "fly" "Sky" "Bull"]

/all

Nahradí se všechny výskyty

>> 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

Třídí řadu podle velikosti hodnot.

>> 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       

Provede case-sensitive třídění.

/skip

Zachází s řadou jako s pořadím skupin zadané délky.

/compare  

Pro definovaný komparátor (offset, blok, funkce) zadáme porovnávané elementy.

>> names: ["Larry" "Curly" "Mo" ]
== ["Larry" "Curly" "Mo" ]

>> sort/compare names function [a b] [a > b]         ; zajímavá diskrepance!

== ["Mo" "Larry" "Curly"]

/part

Třídí pouze části řad

/all

Porovná všechna vybraná pole. Používá se s upřesněním 'skip'  pro určení velikosti skupin.

/reverse

Obrátit pořadí

/stable

Místo někdy  nestabilního třídění Quicksort se použije stabilnější ale pomalejší algoritmus Merge.

action! remove

Odebere první hodnotu řady.

>> s: ["cat" "dog" "fox" "cow" "fly" "ant" "bee"]
== ["cat" "dog" "fox" "cow" "fly" "ant" "bee"]

>> remove s
== ["dog" "fox" "cow" "fly" "ant" "bee"]

>> s
== ["dog" "fox" "cow" "fly" "ant" "bee"]

/part

Odebere zadaný počet elementů.

>> s: "abcdefghij"
== "abcdefghij"

>> remove/part s 4
== "efghij"

Totéž lze provést příkazem  remove at [0 1 2 3 4 5] 2 

native! remove-each

Podobně jako foreach,  postupně vyhodnotí blok pro každý element řady. Vrací-li blok hodnotu  true, je element odebrán z řady:

Red []

a: ["dog" 23 3.5 "house" 45]

remove-each i a [string? i]                    ; odebere všechny řetězce

print a

23 3.5 45

Red []

a: "   my house in the middle of our street"

remove-each i a [i = #" "]                      ; odebere všechny mezery

print a

myhouseinthemiddleofourstreet

action! take

Odebere první element z řady a vrátí jej jako vratnou hodnotu (return).

>> 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

Odebere poslední element z řady a vrátí jej jako vratnou hodnotu (return).

>> 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 and append can be used to perform stack (queue) operations.

/part

Odebere daný počet elementů z počátku řady a vrátí je jako  return.

>> 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

Kopíruje vnořené hodnoty. 

action! move

Přemístí jeden (implicitně) nebo více elementů řady na jinou pozici téže nebo jiné řady. Mění oba vstupní argumenty.

/part

Přemístí zadaný počet elementů

>> 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]

Příkaz move může být kombinován s jinými příkazy pro přemístění uvnitř jediné řady. Na příklad:

>> 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

Změní počáteční elementy řady a vrací řadu po změně. Mění pouze první řadu.

>> 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

Upraví měněnou délku řady vložením hodnot z jiné řady.

>> a: [1 2 3 4 5]
== [1 2 3 4 5]

>> change/part a ["a" "b"] 3
== [4 5]

>> a
== ["a" "b" 4 5]

/only

Nahradí první element blokem.

>> change/only s: [1 2 3 4 5] [1 2]
== [2 3 4 5]

>> s
== [[1 2] 2 3 4 5]

/dup
Provede zadaný počet duplikátů změny.

function! alter

Připojí element k řadě nebo jej z řady odebere. Pokud   alter  zadaný element v řadě nenalezne připojí jej a vrátí true. Pokud jej nalezne, odebere jej a vrátí 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

Prohodí první elementy dvou řad. Vrací první řadu ale mění obě:

>> a: [1 2 3 4] b: [a b c d]
== [a b c d]

>> swap a b
== [a 2 3 4]

>> a
== [a 2 3 4]

>> b
== [1 b c d]

S použitím slova find lze prohodit libovolný element dvou řad nebo elementy téže řady:

>> 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

Převrátí pořadí elementů v řadě:

>> reverse [1 2 3]
== [3 2 1]

>> reverse "abcde"
== "edcba"

/part  omezí akci reverse na zadaný počet elementů:

>> reverse/part "abcdefghi" 4
== "dcbaefghi"