add delete-file example, remove temporary test file

FossilOrigin-Name: 817b050cd42020eed1d5604da2998d04c13c698f69070b43f801d1606f6e3aef

RELEASE-NOTES

@@ -23,6 +23,7 @@
 ## Examples
 
 - add archive, archive-info, archive-extract
+- add delete-file
 
 ## Documentation
 

example/delete-file.retro

@@ -0,0 +1,13 @@
+#!/usr/bin/env retro
+
+This will delete the file specified on the command
+line.
+
+Example:
+
+    ./delete-file.retro /tmp/foo
+
+~~~
+#0 script:get-argument file:delete
+~~~
+

temp.retro

@@ -1,152 +0,0 @@
-# 1D Cellular Automota
-
-Assume an array of cells with an initial distribution of live
-and dead cells, and imaginary cells off the end of the array
-having fixed values.
-
-Cells in the next generation of the array are calculated based
-on the value of the cell and its left and right nearest neighbours
-in the current generation.
-
-If, in the following table, a live cell is represented by 1 and
-a dead cell by 0 then to generate the value of the cell at a
-particular index in the array of cellular values you use the
-following table:
-
-    000 -> 0  #
-    001 -> 0  #
-    010 -> 0  # Dies without enough neighbours
-    011 -> 1  # Needs one neighbour to survive
-    100 -> 0  #
-    101 -> 1  # Two neighbours giving birth
-    110 -> 1  # Needs one neighbour to survive
-    111 -> 0  # Starved to death.
-
-I had originally written an implementation of this in RETRO 11. For
-RETRO 12 I took advantage of new language features and some further
-considerations into the rules for this task.
-
-The first word, `string,` inlines a string to `here`. I'll use this to
-setup the initial input.
-
-~~~
-:string, (s-) [ , ] s:for-each #0 , ;
-~~~
-
-The next two lines setup an initial generation and a buffer for the
-evolved generation. In this case, `This` is the current generation and
-`Next` reflects the next step in the evolution.
-
-~~~
-'This d:create
-  '.###.##.#.#.#.#..#.. string,
-
-'Next d:create
-  '.................... string,
-~~~
-
-I use `display` to show the current generation.
-
-~~~
-:display (-)
-  &This s:put nl ;
-~~~
-
-As might be expected, `update` copies the `Next` generation to the
-`This` generation, setting things up for the next cycle.
-
-~~~
-:update (-)
-  &Next &This dup s:length copy ;
-~~~
-
-The word `group` extracts a group of three cells. This data will be
-passed to `evolve` for processing.
-
-~~~
-:group (a-nnn)
-  [ fetch ]
-  [ n:inc fetch ]
-  [ n:inc n:inc fetch ] tri ;
-~~~
-
-I use `evolve` to decide how a cell should change, based on its initial
-state with relation to its neighbors.
-
-In the prior implementation this part was much more complex as I tallied
-things up and had separate conditions for each combination. This time I
-take advantage of the fact that only cells with two neighbors will be
-alive in the next generation. So the process is:
-
-- take the data from `group`
-- compare to `$#` (for living cells)
-- add the flags
-- if the result is `#-2`, the cell should live
-- otherwise it'll be dead
-
-~~~
-:evolve (nnn-c)
-  [ $# eq? ] tri@ + +
-  #-2 eq? [ $# ] [ $. ] choose ;
-~~~
-
-For readability I separated out the next few things. `at` takes an index
-and returns the address in `This` starting with the index.
-
-~~~
-:at (n-na)
-  &This over + ;
-~~~
-
-The `record` word adds the evolved value to a buffer. In this case my
-`generation` code will set the buffer to `Next`.
-
-~~~
-:record (c-)
-  buffer:add n:inc ;
-~~~
-
-And now to tie it all together. Meet `generation`, the longest bit of
-code in this sample. It has several bits:
-
-- setup a new buffer pointing to `Next`
-  - this also preserves the old buffer
-- setup a loop for each cell in `This`
-  - initial loop index at -1, to ensure proper dummy state for first cell
-  - get length of `This` generation
-- perform a loop for each item in the generation, updating `Next` as it goes
-- copy `Next` to `This` using `update`.
-
-~~~
-:generation (-)
-  [ &Next buffer:set
-    #-1 &This s:length
-    [ at group evolve record ] times drop
-    update
-  ] buffer:preserve ;
-~~~
-
-The last bit is a helper. It takes a number of generations and displays
-the state, then runs a `generation`.
-
-~~~
-:generations (n-)
-  [ display generation ] times ;
-~~~
-
-And a text. The output should be:
-
-    .###.##.#.#.#.#..#..
-    .#.#####.#.#.#......
-    ..##...##.#.#.......
-    ..##...###.#........
-    ..##...#.##.........
-    ..##....###.........
-    ..##....#.#.........
-    ..##.....#..........
-    ..##................
-    ..##................
-
-~~~
-:run  #10 generations ;
-~~~