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

fix pod formatting (fixes #24)

calc.go

@@ -121,20 +121,28 @@ func (c *Calc) GetCompleteCustomFuncalls() func(string) []string {
 		}
 
 		for command := range c.SettingsCommands {
+			if len(command) > 1 {
 				completions = append(completions, command)
 			}
+		}
 
 		for command := range c.ShowCommands {
+			if len(command) > 1 {
 				completions = append(completions, command)
 			}
+		}
 
 		for command := range c.StackCommands {
+			if len(command) > 1 {
 				completions = append(completions, command)
 			}
+		}
 
 		for command := range c.Commands {
+			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,8 +270,12 @@ func (c *Calc) Eval(line string) {
 				continue
 			}
 
-			if c.batch {
+			if exists(c.BatchFuncalls, item) {
-				if _, ok := c.BatchFuncalls[item]; ok {
+				if !c.batch {
+					fmt.Println("only supported in batch mode")
+					continue
+				}
+
 				if err := c.DoFuncall(item); err != nil {
 					fmt.Println(err)
 				} else {
@@ -271,12 +283,6 @@ func (c *Calc) Eval(line string) {
 				}
 				continue
 			}
-			} else {
-				if _, ok := c.BatchFuncalls[item]; ok {
-					fmt.Println("only supported in batch mode")
-					continue
-				}
-			}
 
 			if contains(c.LuaFunctions, item) {
 				// user provided custom lua functions
@@ -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

@@ -305,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"]
 }

rpn.go

@@ -208,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

@@ -216,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
+// find an item in a list, generic variant
-func contains(s []string, e string) bool {
+func contains[E comparable](s []E, v E) bool {
-	for _, a := range s {
+	for _, vs := range s {
-		if a == e {
+		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":