Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://www.mistql.com/docs/reference/functions below:

Functions | MistQL

The following are all builtin functions in MistQL

Takes the second argument and provides it as the context for the first argument

This is almost exclusively used as a utility as part of piping, e.g. 1 | apply @ + 1 | apply @ * 2

({a: "foo" } | apply a + "bar") == "foobar"

Returns the length of an array.

The following counts the number of occurrences of the number 3 in the array

[1, 2, 3, 2, 2, 3] | filter @ == 3 | count

Gets the entries of an object.

Query:

{foo: "bar", baz: {boof: "woof"}} | entries

Result:

[["foo", "bar"] ["baz", {boof: "woof"}]]

Filters an array based on a condition.

Query:

[  {animal: "cat", name: "Millie"},  {animal: "dog", name: "Alfred"},  {animal: "cat", name: "Mulberry"},] | filter animal == "cat"

Result:

[  {animal: "cat", name: "Millie"},  {animal: "cat", name: "Mulberry"},]

Filters a object's keys based on a condition

Query:

{apple: "good", banana: "very good", carrot: "excellent"}| filterkeys @ > "apricot"

Result:

{ banana: "very good", carrot: "excellent" }

Filters a object's values based on a condition

Query:

{  apple: {score: 5},  banana: {score: 4},  carrot: {score: 7},  donut: {score: 10}} | filterkeys score >= 7

Result:

{  carrot: {score: 7},  donut: {score: 10}}

Finds the first item that matches the condition

Query:

[  { fruit: "apple", score: 5},  { fruit: "banana", score: 4},  { fruit: "carrot", score: 7},  { fruit: "donut", score: 10} ] | find (score % 2) == 0

Result:

{ fruit: "banana", score: 4},

Flattens a doubly nested array into a singly nested array.

Query:

[  [1, 2, 3],  [4, 5],  [6, 7]] | flatten

Result:

Casts the target value to a float

Create an object from a list of entries. The inverse of entries.

Query:

[["foo", "bar"] ["baz", {boof: "woof"}]] | fromentries

Result:

{foo: "bar", baz: {boof: "woof"}}

Groups the items in the array based on some condition

Query:

[  { gender: "female", name: "hayley" },  { gender: "female", name: "emily" },  { gender: "male", name: "abhik" },  { gender: "female", name: "carmen" },  { gender: "male", name: "ori" },  { gender: "male", name: "adrian" },  { gender: "nonbinary", name: "ash" },  { gender: "nonbinary", name: "remy" }, ] | groupby gender

Result:

{  "female": [    { "gender": "female", "name": "hayley"},    {"gender": "female", "name": "emily"},    {"gender": "female", "name": "carmen"}  ],  "male": [    {"gender": "male", "name": "abhik"},    {"gender": "male", "name": "ori"},    {"gender": "male", "name": "adrian"}  ],  "nonbinary": [    {"gender": "nonbinary", "name": "ash"},    { gender: "nonbinary", name: "remy" }  ]}

If the condition is true, returns the second argument. Otherwise returns the third argument.

Result:

Performs the indexing operation, returning null if no such item exists. Bracket notation is syntactic sugar for calling the above function calls. Below are a number of indexing expressions and their equivalent index function calls.

More information can be found in the indexing reference document.

Example:

Result:

Returns an array of all keys of a given object.

{bleep: "bloop", zap: [4, 5, 6]} | keys

Result:

Logs the value to the console, and passes it without modification. This is used for debugging.

Query:

log ["haha", "blah", "cat"]

Result:

Additionally, MistQL Log: ["haha", "blah", "cat"] is written to the console.

Whether the given string matches the pattern.

If the pattern is a string instead of a regex, it is implicitly converted to a regex with no flags.

match returns true if the pattern matches anywhere within the target. For example, match (regex "be") "abe" returns true. To match the whole string, use default regex start and end characters, e.g. match (regex "^be$") value.

Query:

match (regex "(ha)*") "hahahaha"

Result:

Runs an expression on every element of an array.

Query:

[  {animal: "cat", name: "Millie"},  {animal: "dog", name: "Alfred"},  {animal: "cat", name: "Mulberry"},] | map name + " the " + animal

Result:

[  "Millie the cat",  "Alfred the dog",  "Mulberry the cat"]

Maps every key in an expression.

Query:

{  abhik: true,  evin: false, } | mapkeys  @ + "@example.com"

Result:

{  "abhik@example.com": true,  "evin@example.com": false,}

Runs an expression on every value of a object.

Query:

{  bestInShow: {animal: "cat", name: "Millie"},  bestBehaved: {animal: "dog", name: "Alfred"},  coolest: {animal: "cat", name: "Mulberry"}, } | mapvalues name + " the " + animal

Result:

{  bestInShow: "Millie the cat",  bestBehaved: "Alfred the dog",  coolest: "Mulberry the cat"}

Runs a reduce operation on every value of an array

Query:

[1, 2, 3] | reduce @[0] + @[1] 0

Result:

Takes arguments start, stop, and step. Returns a list of integers starting at start, ending at stop (non-inclusive), using steps of size step. If the sign of step does not match the sign of stop - start, then an empty list is returned.

Behavior of range closely matches python's range function.

Below is a table describing how the variables start, stop, and step are constructed at different arities. This corresponds to Python's range() method.

Numbers provided to range must all be integers. Step must be greater than zero.

range 5 yields [0, 1, 2, 3, 4]

range 3 8 yields [3, 4, 5, 6, 7]

range 3 8 2 yields [3, 5, 7]

Constructs a regular expression based on the pattern. The second, optional, argument specifies the flags.

regex "(h.)*" "g" constructs the regular expression /(h.)*/g

Replaces the first matching instance of parameter 1 with parameter 2 in parameter 3. If a global regex is used, all instances are replaced.

Query:

"haha" | replace (regex "h." "g") "z"

Result:

Reverses an array

Query:

Result:

Computes the set of all possible subsequences of the target array that satisfy the specified conditions.

Query:

[1, 2, 3, 4] | sequence (@ % 2) ((@ + 1)% 2)

Result:

Sorts an array into ascending order. Strings are sorted alphabetically. Numbers are sorted numerically.

Query:

Result:

Sorts an array into ascending order by some expression

Query:

[3, 1, 2, 8] | sortby @ % 4

Result:

Splits a string based on a delimiter. Unicode codepoints are not split.

Query:

"foo,bar,baz" | split ","

Result:

Casts the target value to a string

Joins an array of strings together with a given delimiter.

["foo", "bar", "baz"] | stringjoin ","

Result:

Adds all numbers in an array together

Query:

Result:

Gives a object containing a statistical summary of an array of numbers

Query:

[1, 2, 3, 4, 5, 6] | summarize

Result:

{  "max": 6,  "min": 1,  "mean": 3.5,  "median": 3.5,  "variance": 2.9166666666666665,  "stddev": 1.707825127659933}

Returns an array of all values of a given object.

Query:

{bleep: "bloop", zap: [4, 5, 6]} | values

Result:

Maps an array to a list of tuple-like arrays with the index as the first member of said tuple, and the original value as the second member.

Query:

["a", "b", "c", "d"] | values

Result:

[  [0, "a"],  [1, "b"],  [2, "c"],   [3, "d"]]

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4