6.23 Booleans

8.12

6.23 Booleans🔗ℹ

annotation

Boolean

Matches #true or #false.

annotation

False

annotation

True

Matches only #false and values other than #false, respectively.

> #false is_a False
#true
> #false is_a True
#false
> 42 is_a True
#true

expression

expr || expr

Produces the value of the first expr if it is non-#false, otherwise produces the value(s) of the second expr.

The second expr is evaluated in tail position with respect to the || form.

binding operator

left_bind || right_bind

Matches if either left_bind or right_bind matches. No identifiers are bound after a successful match, however. In other words, left_bind and right_bind are used only in matching mode, and implied conversions might be skipped.

> fun check_shape(v):
    match v
    | [x] || [x, y, z]: #true
    | ~else: #false
> check_shape([1])
#true
> check_shape([1, 2, 3])
#true
> check_shape([1, 2])
#false

annotation

left_annot || right_annot

Creates an annotation that accepts a value satisfying either left_annot or right_annot. The static information implied by the annotation is the intersection of information for left_annot and right_annot.

The annotations are checked in other. Either or both of left_annot and right_annot can be a converter annotation, in which case the conversion result of the first satisified annotation is used.

> 1 is_a (String || Int)
#true
> 1 is_a (Boolean || Int)
#true

reducer

any

A reducer that stops an iteration as soon as a non-#false value is produced for an element and returns that value, otherwise returns #false.

> for any (i: 0..10):
i == 5 && to_string(i)
"5"
> for any (i: 0..10):
i == 10
#false

expression

expr && expr

Produces #false if the the value of the first expr is #false, otherwise produces the value(s) of the second expr.

The second expr is evaluated in tail position with respect to the && form.

binding operator

left_bind && right_bind

Matches when both left_bind and right_bind match. All identifiers from bindings are available after the match, and static information from left_bind is propagated to right_bind (but not the other way around).

See where for a different kind of “and” binding that allows the right-hand side to refer to bindings from the left-hand side.

> class Posn(x, y)
> fun three_xs(v):
    match v
    | [_, _, _] && [Posn(x, _), ...]: [x, ...]
    | ~else: #false
> three_xs([Posn(1, 2), Posn(3, 4), Posn(5, 6)])
[1, 3, 5]
> three_xs([Posn(1, 2), Posn(3, 4)])
#false
> three_xs([Posn(1, 2), Posn(3, 4), "no"])
#false

annotation

left_annot && right_annot

Creates an annotation that accepts a value satisfying both left_annot and right_annot.

When left_annot and right_annot are predicate annotations, the static information implied by the annotation is the union of information for left_annot and right_annot, where information from right_annot takes precedence in cases where both supply values for the same static-information key.

If left_annot or right_annot is a converter annotation, the left_annot conversion is applied first, and its result is the input to right_annot, and the result of right_annot is the result for the for the overall annotation created by &&. When the overall annotation is used only for matching, the conversion part of right_annot is skipped, but the conversion part of left_annot must be performed.

> 1 is_a (String && Int)
#false
> Pair(1, "hello") is_a (Pair.of(Int, Any) && Pair.of(Any, String))
#true
> 1 :: (converting(fun (n): n+1) && converting(fun (n): -n))
-2

reducer

all

A reducer that stops an iteration as soon as a #false value is produced for an element and otherwise returns the result of the last iteration.

> for all (i: 0..10):
i == 5
#false
> for all (i: 0..10):
i < 10 && to_string(i)
"9"

operator

operator (! (v :: Any)) :: Boolean

Returns #true if v is #false, #false otherwise.

> !#false
#true
> !#true
#false
> !"false"
#false

binding operator

! bind

Matches if bind does not match. Because bind does not match, no identifiers are bound.

> fun
| is_two_list(![x, y]): #false
| is_two_list(_): #true
> is_two_list([1])
#false
> is_two_list([1, 2])
#true
> is_two_list([1, 2, 3])
#false

annotation

! annot

Creates an annotation that accepts a value not satisfying annot. Because annot is not satisfied, no conversion is performed.

> [1, 2, 3] is_a !List
#false
> PairList[1, 2, 3] is_a !List
#true

1	Rhombus Essentials
2	Collections and Iteration
3	Syntax Objects and Macros
4	Classes and Interfaces
5	Static Information and Binding
6	Core Reference
7	Meta and Macros Reference
8	Rhombus Static by Default
9	Libraries
10	Naming Conventions

6.1	General Forms
6.2	Definitions
6.3	Namespaces
6.4	Import
6.5	Export
6.6	Functions
6.7	Operators
6.8	Classes and Interfaces
6.9	Veneers
6.10	Mutable Variables and Assignment
6.11	Repetitions
6.12	Block
6.13	Conditionals
6.14	Matching
6.15	Iteration
6.16	Recursion
6.17	Context Parameters
6.18	Exceptions
6.19	Continuations
6.20	Implicit Forms
6.21	Static and Dynamic Lookup
6.22	Modules and Submodules
6.23	Booleans
6.24	Numbers
6.25	Characters
6.26	Strings
6.27	Keywords
6.28	Symbols
6.29	Byte Strings
6.30	Lists
6.31	Pairs and Pair Lists
6.32	Mutable Lists
6.33	Arrays
6.34	Maps
6.35	Sets
6.36	Boxes
6.37	Indexables
6.38	Listables
6.39	Sequences
6.40	Appendables
6.41	Comparables
6.42	Paths
6.43	Source Locations
6.44	Void
6.45	Equality
6.46	Dot
6.47	Multiple Values
6.48	Annotations
6.49	Enumerations
6.50	Input and Output
6.51	Eval
6.52	Syntax Objects
6.53	Syntax Classes
6.54	Simple Expression Macros
6.55	Unit Testing