use generics for contains() and add generic exists()

fix pod formatting (fixes #24)

calc.go

@@ -121,19 +121,27 @@ func (c *Calc) GetCompleteCustomFuncalls() func(string) []string {
 		}
 
 		for command := range c.SettingsCommands {
-			completions = append(completions, command)
+			if len(command) > 1 {
+				completions = append(completions, command)
+			}
 		}
 
 		for command := range c.ShowCommands {
-			completions = append(completions, command)
+			if len(command) > 1 {
+				completions = append(completions, command)
+			}
 		}
 
 		for command := range c.StackCommands {
-			completions = append(completions, command)
+			if len(command) > 1 {
+				completions = append(completions, command)
+			}
 		}
 
 		for command := range c.Commands {
-			completions = append(completions, command)
+			if len(command) > 1 {
+				completions = append(completions, command)
+			}
 		}
 
 		return completions
@@ -253,7 +261,7 @@ func (c *Calc) Eval(line string) {
 				continue
 			}
 
-			if _, ok := c.Funcalls[item]; ok {
+			if exists(c.Funcalls, item) {
 				if err := c.DoFuncall(item); err != nil {
 					fmt.Println(err)
 				} else {
@@ -262,20 +270,18 @@ func (c *Calc) Eval(line string) {
 				continue
 			}
 
-			if c.batch {
-				if _, ok := c.BatchFuncalls[item]; ok {
-					if err := c.DoFuncall(item); err != nil {
-						fmt.Println(err)
-					} else {
-						c.Result()
-					}
-					continue
-				}
-			} else {
-				if _, ok := c.BatchFuncalls[item]; ok {
+			if exists(c.BatchFuncalls, item) {
+				if !c.batch {
 					fmt.Println("only supported in batch mode")
 					continue
 				}
+
+				if err := c.DoFuncall(item); err != nil {
+					fmt.Println(err)
+				} else {
+					c.Result()
+				}
+				continue
 			}
 
 			if contains(c.LuaFunctions, item) {
@@ -296,22 +302,22 @@ func (c *Calc) Eval(line string) {
 			}
 
 			// internal commands
-			if _, ok := c.Commands[item]; ok {
+			if exists(c.Commands, item) {
 				c.Commands[item].Func(c)
 				continue
 			}
 
-			if _, ok := c.ShowCommands[item]; ok {
+			if exists(c.ShowCommands, item) {
 				c.ShowCommands[item].Func(c)
 				continue
 			}
 
-			if _, ok := c.StackCommands[item]; ok {
+			if exists(c.StackCommands, item) {
 				c.StackCommands[item].Func(c)
 				continue
 			}
 
-			if _, ok := c.SettingsCommands[item]; ok {
+			if exists(c.SettingsCommands, item) {
 				c.SettingsCommands[item].Func(c)
 				continue
 			}
@@ -499,7 +505,7 @@ func (c *Calc) PutVar(name string) {
 }
 
 func (c *Calc) GetVar(name string) {
-	if _, ok := c.Vars[name]; ok {
+	if exists(c.Vars, name) {
 		c.Debug(fmt.Sprintf("retrieve %.2f from %s", c.Vars[name], name))
 		c.stack.Backup()
 		c.stack.Push(c.Vars[name])

command.go

@@ -18,8 +18,12 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
 package main
 
 import (
+	"bufio"
 	"fmt"
 	"os"
+	"os/exec"
+	"strconv"
+	"strings"
 )
 
 type CommandFunction func(*Calc)
@@ -184,6 +188,102 @@ func (c *Calc) SetCommands() {
 				}
 			},
 		),
+
+		"edit": NewCommand(
+			"edit the stack interactively",
+			func(c *Calc) {
+				if c.stack.Len() == 0 {
+					fmt.Println("empty stack")
+					return
+				}
+
+				c.stack.Backup()
+
+				// put the stack contents into a tmp file
+				tmp, err := os.CreateTemp("", "stack")
+				if err != nil {
+					fmt.Println(err)
+					return
+				}
+				defer os.Remove(tmp.Name())
+
+				comment := `# add or remove numbers as you wish.
+# each number must be on its own line.
+# numbers must be floating point formatted.
+`
+				_, err = tmp.WriteString(comment)
+				if err != nil {
+					fmt.Println(err)
+					return
+				}
+
+				for _, item := range c.stack.All() {
+					_, err = fmt.Fprintf(tmp, "%f\n", item)
+					if err != nil {
+						fmt.Println(err)
+						return
+					}
+				}
+
+				tmp.Close()
+
+				// determine which editor to use
+				editor := "vi"
+				enveditor, present := os.LookupEnv("EDITOR")
+				if present {
+					if editor != "" {
+						if _, err := os.Stat(editor); err == nil {
+							editor = enveditor
+						}
+					}
+				}
+
+				// execute editor with our tmp file containing current stack
+				cmd := exec.Command(editor, tmp.Name())
+
+				cmd.Stdin = os.Stdin
+				cmd.Stdout = os.Stdout
+				cmd.Stderr = os.Stderr
+
+				err = cmd.Run()
+				if err != nil {
+					fmt.Println("could not run editor command: ", err)
+					return
+				}
+
+				// read the file back in
+				modified, err := os.Open(tmp.Name())
+				if err != nil {
+					fmt.Println("Error opening file:", err)
+					return
+				}
+				defer modified.Close()
+
+				// reset the stack
+				c.stack.Clear()
+
+				// and put the new contents (if legit) back onto the stack
+				scanner := bufio.NewScanner(modified)
+				for scanner.Scan() {
+					line := strings.TrimSpace(c.Comment.ReplaceAllString(scanner.Text(), ""))
+					if line == "" {
+						continue
+					}
+
+					num, err := strconv.ParseFloat(line, 64)
+					if err != nil {
+						fmt.Printf("%s is not a floating point number!\n", line)
+						continue
+					}
+
+					c.stack.Push(num)
+				}
+
+				if err := scanner.Err(); err != nil {
+					fmt.Println("Error reading from file:", err)
+				}
+			},
+		),
 	}
 
 	// general commands
@@ -205,6 +305,15 @@ func (c *Calc) SetCommands() {
 
 	// aliases
 	c.Commands["quit"] = c.Commands["exit"]
-	c.SettingsCommands["undebug"] = c.SettingsCommands["nodebug"]
-	c.SettingsCommands["show"] = c.SettingsCommands["showstack"]
+
+	c.SettingsCommands["d"] = c.SettingsCommands["debug"]
+	c.SettingsCommands["b"] = c.SettingsCommands["batch"]
+	c.SettingsCommands["s"] = c.SettingsCommands["showstack"]
+
+	c.ShowCommands["h"] = c.ShowCommands["history"]
+	c.ShowCommands["p"] = c.ShowCommands["dump"]
+	c.ShowCommands["v"] = c.ShowCommands["vars"]
+
+	c.StackCommands["c"] = c.StackCommands["clear"]
+	c.StackCommands["u"] = c.StackCommands["undo"]
 }

main.go

@@ -30,7 +30,7 @@ import (
 	lua "github.com/yuin/gopher-lua"
 )
 
-const VERSION string = "2.0.10"
+const VERSION string = "2.0.11"
 
 const Usage string = `This is rpn, a reverse polish notation calculator cli.
 

rpn.go

@@ -178,17 +178,28 @@ DESCRIPTION
         [no]debug            toggle debug output (nodebug turns it off)
         [no]showstack        show the last 5 items of the stack (noshowtack turns it off)
 
-    Show commands: dump display the stack contents hex show last stack item
-    in hex form (converted to int) history display calculation history vars
-    show list of variables
+    Show commands:
 
-    Stack manipulation commands: clear clear the whole stack shift remove
-    the last element of the stack reverse reverse the stack elements swap
-    exchange the last two stack elements dup duplicate last stack item undo
-    undo last operation
+        dump                 display the stack contents
+        hex                  show last stack item in hex form (converted to int)
+        history              display calculation history
+        vars                 show list of variables
 
-    Other commands: help|? show this message manual show manual
-    quit|exit|c-d|c-c exit program
+    Stack manipulation commands:
+
+        clear                clear the whole stack
+        shift                remove the last element of the stack
+        reverse              reverse the stack elements
+        swap                 exchange the last two stack elements
+        dup                  duplicate last stack item
+        undo                 undo last operation
+        edit                 edit the stack interactively using vi or $EDITOR
+
+    Other commands:
+
+        help|?               show this message
+        manual               show manual
+        quit|exit|c-d|c-c    exit program
 
     Register variables:
 
@@ -197,6 +208,17 @@ DESCRIPTION
 
     Refer to https://pkg.go.dev/math for details about those functions.
 
+    There are also a number of shortcuts for some commands available:
+
+        d    debug
+        b    batch
+        s    showstack
+        h    history
+        p    dump (aka print)
+        v    vars
+        c    clear
+        u    undo
+
 INTERACTIVE REPL
     While you can use rpn in the command-line, the best experience you'll
     have is the interactive repl (read eval print loop). Just execute "rpn"

rpn.pod

@@ -186,20 +186,24 @@ Configuration Commands:
     [no]showstack        show the last 5 items of the stack (noshowtack turns it off)
 
 Show commands:
+
     dump                 display the stack contents
     hex                  show last stack item in hex form (converted to int)
     history              display calculation history
     vars                 show list of variables
 
 Stack manipulation commands:
+
     clear                clear the whole stack
     shift                remove the last element of the stack
     reverse              reverse the stack elements
     swap                 exchange the last two stack elements
     dup                  duplicate last stack item
     undo                 undo last operation
+    edit                 edit the stack interactively using vi or $EDITOR
 
 Other commands:
+
     help|?               show this message
     manual               show manual
     quit|exit|c-d|c-c    exit program
@@ -212,6 +216,17 @@ Register variables:
 
 Refer to https://pkg.go.dev/math for details about those functions.
 
+There are also a number of shortcuts for some commands available:
+
+    d    debug
+    b    batch
+    s    showstack
+    h    history
+    p    dump (aka print)
+    v    vars
+    c    clear
+    u    undo
+
 =head1 INTERACTIVE REPL
 
 While you can use rpn in the command-line, the best experience you'll

util.go

@@ -23,16 +23,24 @@ import (
 	"strings"
 )
 
-// find an item in a list
-func contains(s []string, e string) bool {
-	for _, a := range s {
-		if a == e {
+// find an item in a list, generic variant
+func contains[E comparable](s []E, v E) bool {
+	for _, vs := range s {
+		if v == vs {
 			return true
 		}
 	}
 	return false
 }
 
+// look if a key in a map exists, generic variant
+func exists[K comparable, V any](m map[K]V, v K) bool {
+	if _, ok := m[v]; ok {
+		return true
+	}
+	return false
+}
+
 func const2num(name string) float64 {
 	switch name {
 	case "Pi":