Make filter built in work on dicts (#188)

Author: mitchpaulus

CHANGELOG.md

@@ -12,6 +12,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - `match ... end` pattern matching syntax with value matching, type matching, `_` wildcard, maybe destructuring (`just v`/`none`), list destructuring (`[a b ...rest]`), and dict destructuring (`{ 'key': v }`)
 - `map` on dictionaries (maps over values, preserving keys)
 - Functions
+  - `filter` builtin now supports dictionaries, filtering by value while preserving keys
   - `cdh`
   - `cdp`
   - `fromUnixTimeMicro`

doc/control-flow.inc.html

@@ -342,6 +342,12 @@ <h1 id="control-flow-prefix-quote">Prefix Quote Syntax <a class="section-link" h
 <span class="mshellLEFT_SQUARE_BRACKET">[</span><span class="mshellLEFT_SQUARE_BRACKET">[</span><span class="mshellINTEGER">1</span> <span class="mshellINTEGER">2</span> <span class="mshellINTEGER">3</span><span class="mshellRIGHT_SQUARE_BRACKET">]</span> <span class="mshellLEFT_SQUARE_BRACKET">[</span><span class="mshellINTEGER">4</span> <span class="mshellINTEGER">5</span> <span class="mshellINTEGER">6</span><span class="mshellRIGHT_SQUARE_BRACKET">]</span> <span class="mshellLEFT_SQUARE_BRACKET">[</span><span class="mshellINTEGER">7</span> <span class="mshellINTEGER">8</span> <span class="mshellINTEGER">9</span><span class="mshellRIGHT_SQUARE_BRACKET">]</span><span class="mshellRIGHT_SQUARE_BRACKET">]</span> <span class="mshellPREFIXQUOTE">map.</span> <span class="mshellPREFIXQUOTE">filter.</span> <span class="mshellINTEGER">5</span> <span class="mshellGREATERTHAN">&gt;</span> <span class="mshellEND">end</span> <span class="mshellEND">end</span>   <span class="mshellLINECOMMENT"># Result: [[] [6] [7 8 9]]</span></code>
 </pre>
 
+<p><code>filter</code> also works on dictionaries; the quotation receives each value and matching entries keep their original keys:</p>
+
+<pre>
+<code><span class="mshellLEFT_CURLY">{</span> <span class="mshellSTRING">"a"</span><span class="mshellCOLON">:</span> <span class="mshellINTEGER">1</span><span class="mshellCOMMA">,</span> <span class="mshellSTRING">"b"</span><span class="mshellCOLON">:</span> <span class="mshellINTEGER">2</span><span class="mshellCOMMA">,</span> <span class="mshellSTRING">"c"</span><span class="mshellCOLON">:</span> <span class="mshellINTEGER">3</span> <span class="mshellRIGHT_CURLY">}</span> <span class="mshellPREFIXQUOTE">filter.</span> <span class="mshellINTEGER">1</span> <span class="mshellGREATERTHAN">&gt;</span> <span class="mshellEND">end</span> <span class="mshellLITERAL">str</span> <span class="mshellLITERAL">wl</span>   <span class="mshellLINECOMMENT"># {"b": 2, "c": 3}</span></code>
+</pre>
+
 <p>
 This is also useful to turn boolean operators <code>and</code> and <code>or</code> into
 a more traditional lookup infix format:

doc/functions.inc.html

@@ -237,7 +237,7 @@ <h1 id="functions-lists">Lists <a class="section-link" href="#functions-lists" a
         <tr> <td><code>nth</code></td> <td>Return the nth element (0-based).</td> <td><code>([a] <span class="sig-type sig-type-int">int</span> -- a)</code></td> </tr>
         <tr> <td><code>reverse</code></td> <td>Reverse a list.</td> <td><code>(<span class="sig-type sig-type-list">list</span> -- <span class="sig-type sig-type-list">list</span>)</code></td> </tr>
         <tr> <td><code>sum</code></td> <td>Sum numeric values in a list.</td> <td><code>([<span class="sig-type sig-type-numeric">numeric</span>] -- <span class="sig-type sig-type-numeric">numeric</span>)</code></td> </tr>
-        <tr> <td><code>filter</code></td> <td>Filter a list by a predicate quotation.</td> <td><code>([a] (a -- <span class="sig-type sig-type-bool">bool</span>) -- [a])</code></td> </tr>
+        <tr> <td><code>filter</code></td> <td>Filter a list or dictionary by a predicate quotation, returning a new list or dictionary. The input collection is not modified in place. For dictionaries, the quotation is applied to each value and matching entries are preserved.</td> <td><code>([a] (a -- <span class="sig-type sig-type-bool">bool</span>) -- [a])</code>, <code>(<span class="sig-type sig-type-dict">dict</span> (a -- <span class="sig-type sig-type-bool">bool</span>) -- <span class="sig-type sig-type-dict">dict</span>)</code></td> </tr>
         <tr> <td><code>linearSearch</code></td> <td>Return the first element that satisfies a predicate quotation, or <code>none</code> when missing.</td> <td><code>([a] (a -- <span class="sig-type sig-type-bool">bool</span>) -- <span class="sig-type sig-type-maybe">Maybe</span>[a])</code></td> </tr>
         <tr> <td><code>any</code></td> <td>Return true if any element satisfies the predicate.</td> <td><code>([a] (a -- <span class="sig-type sig-type-bool">bool</span>) -- <span class="sig-type sig-type-bool">bool</span>)</code></td> </tr>
         <tr> <td><code>all</code></td> <td>Return true if all elements satisfy the predicate.</td> <td><code>([a] (a -- <span class="sig-type sig-type-bool">bool</span>) -- <span class="sig-type sig-type-bool">bool</span>)</code></td> </tr>

doc/mshell.md

@@ -741,7 +741,7 @@ end
 - `nth`: Nth element of list (0-based) `([a] int -- a)`
 - `reverse`: Reverse list, `(list -- list)`
 - `sum`: Sum of list, `([numeric] -- numeric)`
-- `filter`: Filter list, `([a] (a -- bool) -- [a])`
+- `filter`: Filter a list or dictionary, returning a new collection. The input list or dictionary is not modified in place. For dictionaries, the quotation is applied to each value and matching entries are preserved. `([a] (a -- bool) -- [a])`, `(dict (a -- bool) -- dict)`
 - `any`: Check if any element in list satisfies a condition, `([a] (a -- bool) -- bool)`
 - `all`: Check if all elements in list satisfy a condition, `([a] (a -- bool) -- bool)`
 - `skip`: Skip first n elements of list, `(list int -- list)`
@@ -779,6 +779,7 @@ end
 - `values`: Get values from dictionary. Sorted. `(dict -- [str])`
 - `keyValues`: Get key/value pairs from dictionary as a list of lists. Each inner list is a two-element list with the key and value. Sorted by key. `(dict -- [[str a]])`
 - `map`: Map a quotation over dictionary values. Keys are preserved. `(dict (a -- b) -- dict)`
+- `filter`: Filter dictionary values with a predicate quotation, returning a new dictionary. Keys are preserved for matching entries, and the original dictionary is not modified in place. `(dict (a -- bool) -- dict)`
 - `in`: Check if key exists in dictionary. `(dict str -- bool)`
 
 ## Date Functions

lib/std.msh

@@ -109,24 +109,6 @@ def dropWhile ([T] (T -- bool) -- [T])
     @list @dropWhile-idx skip
 end
 
-# filter (list quote -- list)
-def filter ([T] (T -- bool) -- [T])
-    list!, quote!
-    @list len filter-len! # Get total length
-    0 filter-idx! # Index
-    [] filter-accum! # Accumulator
-    (
-        @filter-idx @filter-len >= (break) iff
-        @list @filter-idx nth item!
-        # $"Item: {@item str}" wl
-        @item @quote x  result!
-        # $"Result: {@result str}" wl
-        @result ( @filter-accum @item append drop ) iff
-        @filter-idx 1 + filter-idx! # inc index
-    ) loop
-    @filter-accum
-end
-
 def linearSearch ([T] (T -- bool) -- Maybe[T])
     list!, quote!
     none linearSearch-result!

mshell/BuiltInList.go

@@ -45,6 +45,7 @@ var BuiltInList = map[string]struct{}{
 	"fileExists": {},
 	"fileSize": {},
 	"files": {},
+	"filter": {},
 	"findReplace": {},
 	"floatCmp": {},
 	"floor": {},

mshell/Evaluator.go

@@ -4651,6 +4651,83 @@ MainLoop:
 						return state.FailWithMessage(fmt.Sprintf("%d:%d: Cannot do 'just' operation on an empty stack.\n", t.Line, t.Column))
 					}
 					stack.Push(&Maybe{obj: o})
+				} else if t.Lexeme == "filter" {
+					obj1, obj2, err := stack.Pop2(t)
+					if err != nil {
+						return state.FailWithMessage(err.Error())
+					}
+
+					fn, ok := obj1.(*MShellQuotation)
+					if !ok {
+						return state.FailWithMessage(fmt.Sprintf("%d:%d: The first parameter in 'filter' is expected to be a function, found a %s (%s)\n", t.Line, t.Column, obj1.TypeName(), obj1.DebugString()))
+					}
+
+					switch obj2Typed := obj2.(type) {
+					case *MShellList:
+						listObj := obj2Typed
+						newList := NewList(0)
+
+						var filterStack MShellStack
+						filterStack = []MShellObject{}
+
+						for _, item := range listObj.Items {
+							filterStack.Push(item)
+							result, err := state.EvaluateQuote(*fn, &filterStack, context, definitions)
+							if err != nil {
+								return state.FailWithMessage(err.Error())
+							}
+							if result.ShouldPassResultUpStack() {
+								return result
+							}
+							if len(filterStack) != 1 {
+								return state.FailWithMessage(fmt.Sprintf("%d:%d: The function in 'filter' did not return a single value, found %d values.\n", t.Line, t.Column, len(filterStack)))
+							}
+
+							filterResult, _ := filterStack.Pop()
+							filterBool, ok := filterResult.(MShellBool)
+							if !ok {
+								return state.FailWithMessage(fmt.Sprintf("%d:%d: The function in 'filter' did not return a bool, found a %s (%s).\n", t.Line, t.Column, filterResult.TypeName(), filterResult.DebugString()))
+							}
+
+							if filterBool.Value {
+								newList.Items = append(newList.Items, item)
+							}
+						}
+						stack.Push(newList)
+					case *MShellDict:
+						dictObj := obj2Typed
+						newDict := &MShellDict{Items: make(map[string]MShellObject, len(dictObj.Items))}
+
+						var filterStack MShellStack
+						filterStack = []MShellObject{}
+
+						for key, value := range dictObj.Items {
+							filterStack.Push(value)
+							result, err := state.EvaluateQuote(*fn, &filterStack, context, definitions)
+							if err != nil {
+								return state.FailWithMessage(err.Error())
+							}
+							if result.ShouldPassResultUpStack() {
+								return result
+							}
+							if len(filterStack) != 1 {
+								return state.FailWithMessage(fmt.Sprintf("%d:%d: The function in 'filter' did not return a single value, found %d values.\n", t.Line, t.Column, len(filterStack)))
+							}
+
+							filterResult, _ := filterStack.Pop()
+							filterBool, ok := filterResult.(MShellBool)
+							if !ok {
+								return state.FailWithMessage(fmt.Sprintf("%d:%d: The function in 'filter' did not return a bool, found a %s (%s).\n", t.Line, t.Column, filterResult.TypeName(), filterResult.DebugString()))
+							}
+
+							if filterBool.Value {
+								newDict.Items[key] = value
+							}
+						}
+						stack.Push(newDict)
+					default:
+						return state.FailWithMessage(fmt.Sprintf("%d:%d: The second parameter in 'filter' is expected to be a list or dictionary, found a %s (%s)\n", t.Line, t.Column, obj2.TypeName(), obj2.DebugString()))
+					}
 				} else if t.Lexeme == "map" {
 					// Map a function over a list, or a Maybe
 					obj1, obj2, err := stack.Pop2(t)

tests/filter.msh

@@ -2,3 +2,13 @@
 
 # Test filtering list of lists, this caught a bug with the order of the internal append in filter
 [[1 2] [] [3 4 5]] (len 1 >) filter ((str) map ", " join) map uw
+
+{ "a": 1, "b": 2, "c": 3 } (1 >) filter str wl
+
+[1 2 3 4] originalList!
+@originalList (2 >) filter str wl
+@originalList str wl
+
+{ "a": 1, "b": 2, "c": 3 } originalDict!
+@originalDict (1 >) filter str wl
+@originalDict str wl

tests/filter.msh.stdout

@@ -1,3 +1,8 @@
 4, 5
 1, 2
 3, 4, 5
+{"b": 2, "c": 3}
+[3 4]
+[1 2 3 4]
+{"b": 2, "c": 3}
+{"a": 1, "b": 2, "c": 3}

tests/prefix_quote.msh

@@ -16,6 +16,8 @@ true or. false end and. true end str wl
 5 threshold!
 [1 2 3 4 5 6 7] filter. @threshold > end (str) map ", " join wl
 
+{ "a": 1, "b": 2, "c": 3 } filter. 1 > end str wl
+
 # Prefix quote calling user-defined function
 def double (int -- int) 2 * end
 [1 2 3] map. double end (str) map ", " join wl