Operators#

An expression combines operators to calculate its result. Each operator defines its accepted arguments and result. The Arguments column gives argument names in their accepted order. Stardust rejects the wrong number of arguments. It also rejects an argument of the wrong type.

#_ada {name Ada
       role engineer
       age  36}
#_bob {name   Bob
       role   engineer
       age    41
       mentor {#link #_ada}}
#_cy  {name Cy
       role designer
       age  29}

More than two arguments#

Operators that accept more than two arguments use a fold, a chain, or all arguments together.

A fold applies the operator again to its own result. +, -, * and / have this shape, and [+ 1 2 3] is [+ [+ 1 2] 3]. A fold goes from left to right, which changes the result of - and /.

[- 20 5 3]

12

xor has this shape. [xor a b c] is [xor [xor a b] c], and xor is therefore true when the number of true arguments cannot be divided by 2. Three true arguments give true.

[xor true true true]

true

A chain applies the operator to each pair of adjacent arguments. <, <=, > >= and = have this shape. [< 1 5 10] requires 1 to be less than 5 and 5 to be less than 10. It does not compare a true or false value against 10.

[< 1 5 10]

true

The other operators that accept more than two arguments use all of them together. min, max, concat and format have this shape.

Arithmetic#

An integer result of more than 64 bits is an error. Division by zero is also an error. rem and % reject a divisor of zero in the same way.

[/ 1 0]

rem and % give the same result when both arguments are more than zero. The results are different when one argument is less than zero. rem keeps the sign of the first argument, and % keeps the sign of the second argument.

[list [rem -17 5] [% -17 5]]

[-2 3]

Comparison and equality#

not and xor use the rule for true and false values: only null and false are false. xor counts the arguments that are true.

[xor 0 false]

true

Three arguments give a range test. < and > keep the value away from both limits. <= and >= accept the value at each limit.

[<= 1 10 10]

true

One operator gives the same type of limit on each side. If the two limits are not the same type, use and with two comparisons. This example accepts a value at the low limit but not at the high limit.

[and [<= 1 1] [< 1 10]]

true

Math#

pow gives an integer when both numbers are integers and the power is zero or more. Such a result must fit in 64 bits, as for *. Other powers give a float. sqrt requires a number that is not negative, and log and log2 require a number greater than zero. A result that is not finite is an error, as for /.

[list [pow 2 10] [pow 2 -1] [sqrt 2] [log2 1024] [log [exp 1]]]

[1024 0.5 1.4142135623730951 10.0 1.0]

seededRand gives the same number for the same arguments on every machine and every run. A value that must be irregular but must not change between runs therefore needs no stored database field.

[list [seededRand ada] [seededRand ada] [seededRand grace]]

[0.85209372965481489 0.85209372965481489 0.81815489141183417]

Text#

Stardust counts and cuts text in characters. [textLength héllo] gives 5.

format uses {} in sequence and {0} by position. {{}} gives one brace.

A specification after : must suit the type of its value. An integer accepts b, c, d, o, x, X and U. A float accepts e, E, f, F, g and G, and a text accepts s. A float specification over an integer is an error, as [format '{:.2f}' 42] is.

[
  format
  '{1:.1f} {0}'
  a
  2.5]

2.5 a

Collections#

get gives null for a missing key or position. Its third argument sets a different default. nth rejects a position outside the list.

Stardust sorts values of different types in this sequence: null, booleans, numbers, text, then collections.

[sort [list 1 a true null 2.5 2]]

[null true 1 2 2.5 a]

Operators that use a function#

Each operator in this group has a function first. The input list is last, including forms with an initial value or direction. A built-in operator can be a function, as in [reduce + 0 [list 1 2 3]].

[all [fn [?value] [> ?value 1]] [list 2 3]]

true

Type tests#

isNull, isBool, isText, isInt, isFloat, isNumber, isEntity, isTagged, isList and isMap each have one argument. Each one gives true or false. isInt and isFloat separate the two kinds of number. isNumber accepts both kinds.

Type changes#

A value that an operator cannot change gives an error. There is no fallback value. Expressions gives the full rules.

[toInt '4.0']

Digests#

Stardust calculates the digest from the JSON form of the value. The result is a {#sha256 …} map with hexadecimal digest text.

[hash a]

{#sha256 ac8d8342bbb2362d13f0a559a3621bb407011368895164b628a54f7fc33fc43c}

Regular expressions#

The pattern is first. reReplace has the replacement second and input text last. An empty match gives empty text. An absent match gives null.

[reMatch '^catalog-[0-9]+$' catalog-171]

true

reReplace changes every match. In the replacement, $1 to $9 are the groups that the pattern captured. $0 is the whole match. $ is one dollar sign.

[
  reReplace
  '([0-9]{4})-([0-9]{2})-([0-9]{2})'
  $3/$2/$1
  shipped 2026-09-18]

shipped 18/09/2026

A pattern can start and end with / to add flags. The i flag ignores case. The m flag lets ^ and $ match at each line. The x flag ignores spaces in the pattern. The u flag reads the text as Unicode.

[reMatch /^ADA$/i ada]

true

The pattern language#

A pattern accepts alternation a|b and classes [0-9] and [^0-9]. It also accepts the ASCII shorthands \d \s \w and their negations. The wildcard is .. Repeats use *, +, ?, or {1,2}, with ? for non-greedy matching. Groups use (a) or (?:a). Anchors are ^ and $, and word boundaries are \b and \B.

A pattern can have 9 groups. Stardust rejects a pattern with more groups. It also rejects group references such as \1, look-ahead (?=a), look-behind (?<=a), and group names such as (?<year>a).

[reMatch (?=foo) foo]

Matching examines each text position one time. It does not try each choice again, so the following expression gives false immediately: [reMatch (a+)+$ aaaaaaaaaaaaaaaaaaaaaaaa!].

[list [+] [*] [/ 2] [/ 2.0] [= 3 3 3] [reduce + 0 [list 1 2 3]] [reFind z abc] [reFind ^ abc]]

[0 1 0 0.5 true 6 null ""]

Run it#

build · program evaluate.