add ok() / is_ok() and replace error("missing") with none handling

book/src/SUMMARY.md

@@ -105,14 +105,14 @@
             - [error](super-sql/functions/errors/error.md)
             - [has_error](super-sql/functions/errors/has_error.md)
             - [is_error](super-sql/functions/errors/is_error.md)
-            - [missing](super-sql/functions/errors/missing.md)
         - [Generics](super-sql/functions/generics/intro.md)
             - [coalesce](super-sql/functions/generics/coalesce.md)
             - [compare](super-sql/functions/generics/compare.md)
-            - [has](super-sql/functions/generics/has.md)
+            - [is_ok](super-sql/functions/generics/is_ok.md)
             - [len](super-sql/functions/generics/len.md)
             - [map](super-sql/functions/generics/map.md)
             - [nullif](super-sql/functions/generics/nullif.md)
+            - [ok](super-sql/functions/generics/ok.md)
             - [under](super-sql/functions/generics/under.md)
         - [Math](super-sql/functions/math/intro.md)
             - [abs](super-sql/functions/math/abs.md)

book/src/command/super.md

@@ -101,12 +101,12 @@ This can be especially handy when you are learning the language and its
 
 For example, this query
 ```mdtest-command
-super -C -c 'has(foo)'
+super -C -c 'is_ok(foo)'
 ```
 is an implied [where](../super-sql/operators/where.md) operator, which matches values
 that have a field `foo`, i.e.,
 ```mdtest-output
-where has(foo)
+where is_ok(foo)
 ```
 while this query
 ```mdtest-command

book/src/super-sql/expressions/comparisons.md

@@ -82,15 +82,14 @@ _Various scalar comparisons_
 
 ```mdtest-spq
 # spq
-values 1 > 2, 1 < 2, "b" > "a", 1 > "a", 1 > error("missing")
+values 1 > 2, 1 < 2, "b" > "a", 1 > "a"
 # input
 
 # expected output
 false
 true
 true
 false
-error("missing")
 ```
 
 ---
@@ -104,12 +103,12 @@ values {isNull:this is null,isNotNull:this is not null}
 1
 null
 2
-error("missing")
+none
 # expected output
 {isNull:false,isNotNull:true}
 {isNull:true,isNotNull:false}
 {isNull:false,isNotNull:true}
-{isNull:error("missing"),isNotNull:error("missing")}
+{isNull:false,isNotNull:true}
 ```
 
 ---

book/src/super-sql/functions/errors/error.md

@@ -60,18 +60,3 @@ error("exception")
 {that:error("exception"),err:true,kind:"error"}
 {that:"exception",err:false,kind:"primitive"}
 ```
-
----
-
-_Comparison of a missing error results in a missing error even if they
-are the same missing errors so as to not allow field comparisons of two
-missing fields to succeed_
-
-```mdtest-spq
-# spq
-badfield:=x | values badfield==error("missing")
-# input
-{}
-# expected output
-error("missing")
-```

book/src/super-sql/functions/generics/is_ok.md

@@ -0,0 +1,85 @@
+# is_ok
+
+test the validity of values
+
+## Synopsis
+
+```
+is_ok(val: any) -> bool
+```
+
+## Description
+
+The `is_ok` function is inspired by the Rust language pattern of the same name
+and returns true when `val` is not `none` or an error.
+It is a shortcut for `ok(val)!=none`.
+
+This function is often used to determine the existence of fields in a
+record, e.g., `is_ok(x)` is true when `this` is a record and has
+the field `x`, provided its value is not an error or none.
+
+It's also useful in shaping messy data when applying conditional logic based on the
+presence of certain fields:
+```
+switch
+  case a.is_ok() ( ... )
+  case b.is_ok() ( ... )
+  default ( ... )
+```
+
+## Examples
+
+---
+
+```mdtest-spq
+# spq
+values {yes:is_ok(foo),no:is_ok(bar)}
+# input
+{foo:10}
+# expected output
+{yes:true,no:false}
+```
+
+---
+
+```mdtest-spq
+# spq
+values {yes: foo[1].is_ok(),no:foo[4].is_ok()}
+# input
+{foo:[1,2,3]}
+# expected output
+{yes:true,no:false}
+```
+
+---
+
+```mdtest-spq
+# spq
+values {yes:foo.bar.is_ok(),no:foo.baz.is_ok()}
+# input
+{foo:{bar:"value"}}
+# expected output
+{yes:true,no:false}
+```
+
+---
+
+```mdtest-spq
+# spq
+values {yes:is_ok(foo+1),no:is_ok(bar+1)}
+# input
+{foo:10}
+# expected output
+{yes:true,no:false}
+```
+
+---
+
+```mdtest-spq
+# spq
+values bar.is_ok()
+# input
+1
+# expected output
+false
+```