Rhombus

https://docs.racket-lang.org/rhombus/
Admin
Rhombus is a programming language built on Racket that provides a modern syntax and expressive...
Tokens:433,708
Snippets:5,429
Trust Score:9.4
Update:2 months ago
Show doc for...
Tokens:
Raw
### examples(option, ..., chunk, ..., repl, ...)

Source: https://docs.racket-lang.org/rhombus-scribble/examples.html

The examples form evaluates code forms and renders them, supporting various modes like definitions, REPL-style interaction, and hidden evaluation.

```APIDOC
## examples

### Description
Evaluates forms and renders the input and results. Forms are grouped into chunks, and specific keywords control the rendering style (~defn, ~repl, ~result, ~hidden, ~version_and_later).

### Parameters
- **option** (keyword) - Optional - Configuration options including ~label, ~eval, ~indent, ~spacer_info_box, and ~escape.
- **chunk** (block) - Optional - Groupings of forms to be evaluated and rendered.
- **repl** (form) - Optional - Individual evaluation forms, supporting ~error, ~check, ~fake, and ~blank modifiers.
```

--------------------------------

### Range Emptiness Examples

Source: https://docs.racket-lang.org/rhombus-reference/Ranges.html

Examples demonstrating the is_empty method on various range configurations.

```rhombus
(3..4).is_empty()
```

```rhombus
(3..=3).is_empty()
```

```rhombus
(3..3).is_empty()
```

```rhombus
(3 <..= 3).is_empty()
```

```rhombus
(3 <.. 4).is_empty()
```

--------------------------------

### Hello World Presentation

Source: https://docs.racket-lang.org/rhombus-slideshow/overview.html

A minimal example to initialize and display a slide presentation.

```rhombus
#lang rhombus
---
import:
  slideshow open
slide(@t{Hello, world})
```

--------------------------------

### String conversion examples

Source: https://docs.racket-lang.org/rhombus-reference/Strings.html

Examples of converting various values to strings using to_string and repr.

```Rhombus
> to_string(10)
"10"
> to_string('hello')
"hello"
> to_string([1, 2, 3])
"[1, 2, 3]"
> to_string('hello', ~mode: #'expr)
"'hello'"
```

--------------------------------

### Conditional Expansion Example

Source: https://docs.racket-lang.org/rhombus-reference/version-number.html

Example usage of version_meta.when_at_least to conditionally include code based on the version.

```rhombus
version_meta.when_at_least "0.1":
  use_static // not available before version 0.1
  fun greet(who :~ String):
    "Hello, " ++ who ++ "!"
```

--------------------------------

### Render Printable Examples

Source: https://docs.racket-lang.org/rhombus-reference/Printables.html

Examples of rendering list and block printable descriptions.

```rhombus
Printable.render(
PrintDesc.list(
"Posn(",
["x", "y"],
")"
))
```

```rhombus
Printable.render(
PrintDesc.block(
"begin",
PrintDesc.concat(
"one", PrintDesc.newline(),
"two",
)))
```

--------------------------------

### Macro Simplification Example

Source: https://docs.racket-lang.org/rhombus-meta/stxobj-macro.html

Demonstrates using bound_as to match specific operators in a macro.

```rhombus
import:
rhombus/meta open
rhombus:
rename + as plus
expose plus
expr.macro 'simplify($stx)':
let new_stx:
match stx
| '$(a :: Int) $(bound_as expr_meta.space: '+') $(b :: Int)':
'$(a.unwrap() + b.unwrap())'
| ~else:
stx
'Syntax.literal($new_stx)'
> simplify(1 + 2)
'3'
> simplify(1 plus 2)
'3'
> simplify(1 * 2)
'1 * 2'
```

--------------------------------

### Thread Message Passing Example

Source: https://docs.racket-lang.org/rhombus-reference/thread.html

Demonstrates creating a thread, sending messages, and handling failures.

```rhombus
def orig = Thread.current()
```

```rhombus
def t:
thread:
match Thread.receive()
| #'ping: orig.send(#'pong)
```

```rhombus
Thread.maybe_receive()
```

```rhombus
#false
```

```rhombus
t.send(#'ping)
```

```rhombus
Thread.receive()
```

```rhombus
#'pong
```

```rhombus
t.wait()
```

```rhombus
t.send(#'oops, ~fail: fun (): "thread isn't there")
```

```rhombus
"thread isn't there"
```

--------------------------------

### Defining and Using Aliases

Source: https://docs.racket-lang.org/rhombus-reference/Aliases.html

Examples showing how to alias a type constructor and an operator.

```Rhombus
alias 'Roster': 'List'
Roster[1, 2, 3]
[1, 2, 3] is_a Roster
alias '%': 'mod'
5 % 2
```

--------------------------------

### Documenting a function

Source: https://docs.racket-lang.org/rhombus-reference/doc_notation.html

Example of a function documentation entry using the fun form.

```Rhombus
fun fib(n :: Nat) :: Nat
```

--------------------------------

### Dynamic Lookup Example

Source: https://docs.racket-lang.org/rhombus-reference/Static_and_Dynamic_Lookup.html

Demonstrates how use_dynamic relaxes static requirements for lookup operations.

```rhombus
class Posn(x, y)
fun (ps):
  use_dynamic
  ps[0].x
#<function:fun>
```

--------------------------------

### Bitwise Operation Examples

Source: https://docs.racket-lang.org/rhombus-reference/Numbers.html

Demonstrates usage of bitwise operators and functions on integer values.

```rhombus
> 5 bits.and 3
1
```

```rhombus
> 5 bits.or 3
7
```

```rhombus
> 5 bits.xor 3
6
```

```rhombus
> bits.not 3
-4
```

```rhombus
> 5 bits.(<<) 2
20
```

```rhombus
> 5 bits.(>>) 2
1
```

```rhombus
> bits.length(2)
2
```

```rhombus
> bits.length(-2)
1
```

```rhombus
> bits.field(255, 1, 4)
7
```

--------------------------------

### Cairo C Example

Source: https://docs.racket-lang.org/rhombus-ffi/tutorial2.html

Original C code for setting dash patterns in Cairo.

```c
double dashes[] = {50.0, 10.0, 10.0, 10.0};  
int ndash = sizeof(dashes)/sizeof(dashes[0]);  
double offset = -50.0;  
cairo_set_dash (cr, dashes, ndash, offset);  
cairo_set_line_width (cr, 10.0);  
cairo_move_to (cr, 128.0, 25.6);  
cairo_line_to (cr, 230.4, 230.4);  
cairo_rel_line_to (cr, -102.4, 0.0);  
cairo_curve_to (cr, 51.2, 230.4, 51.2, 128.0, 128.0, 128.0);  
cairo_stroke (cr);
```

--------------------------------

### Each repetition examples

Source: https://docs.racket-lang.org/rhombus-reference/Repetitions.html

Shows how each creates a repetition from a sequence, serving as a shorthand for list bindings.

```rhombus
def lst = [1, 2, 3]
block:
  let List[x, ...] = lst
  [x+1, ...]
```

```rhombus
[(each lst) + 1, ...]
```

--------------------------------

### Function composition usage examples

Source: https://docs.racket-lang.org/rhombus-reference/ref-function.html

Practical examples of composing functions to transform data.

```rhombus
def nstr = to_string compose math.abs
nstr(-100)
```

```rhombus
def partition_to_list = List compose_values List.partition
partition_to_list([1, -2, -3, 4], (_ > 0))
```

--------------------------------

### Documenting multiple bindings with doc

Source: https://docs.racket-lang.org/rhombus-scribble/doc.html

Example showing how to document Widget, ok_button, and make_panel together using the doc form.

```rhombus
@doc(  
---
annot.macro 'Widget'  
def ok_button :: Widget  
fun make_panel(label :: String,  
[child :: Widget, ...]) :: Widget  
){
  A @rhombus(Widget, ~annot) is an interactive thing, and the  
  constant @rhombus(ok_button) is a stock widget. Use @rhombus(make_panel)  
  to combine several widgets into a titled panel, where @rhombus(label)  
  provide the panel's title.  
}
```

--------------------------------

### Reducer Usage Examples

Source: https://docs.racket-lang.org/rhombus-meta/Reducer_Macros.html

Demonstrations of using reducers like counted(List) and counted(Map) with iteration.

```Rhombus
for counted(List) (i in 0..3): i
```

```Rhombus
def (map, count):
for counted(Map) (i in 0..10):
keep_when i mod 2 == 0
values(i, "val" +& i)
```

```Rhombus
values(map, count)
```

```Rhombus
block:
use_static
map.remove(2)
```

```Rhombus
for counted(values(i = 0, j = 10)) (k in 0..5):
values(i+k, j-k)
```

--------------------------------

### Using Keyword Arguments

Source: https://docs.racket-lang.org/rhombus-quick/index.html

Demonstrates calling functions with keyword arguments for customization.

```rhombus
> circle(~size: 20, ~fill: "red")
> rectangle(~width: 10, ~height: 20, ~line: "blue")
```

--------------------------------

### Defining and Calling Functions

Source: https://docs.racket-lang.org/rhombus-reference/ref-function.html

Basic examples of defining functions using the fun keyword and invoking them.

```Rhombus
fun f(x):
  x+1
> f(0)
1
```

```Rhombus
fun List.number_of_items(l):
  List.length(l)
> List.number_of_items(["a", "b", "c"])
3
```

--------------------------------

### Using Port.Output.using and Port.Input.using

Source: https://docs.racket-lang.org/rhombus-guide/port.html

Simplifies file port management using the using utility.

```rhombus
def tmp = filesystem.make_temporary()
Port.Output.using ~file tmp.path:
  ~exists: #'truncate
  println("data")
Port.Input.using ~file tmp.path:
  stdin.read_line()
tmp.close()
```

--------------------------------

### Exporting Names from Namespaces

Source: https://docs.racket-lang.org/rhombus-reference/Export.html

Examples demonstrating basic export, renaming, and exporting definitions directly.

```rhombus
> namespace ns1:
  def x = 1
  export x
> ns1.x
1
```

```rhombus
> namespace ns2:
  def x = 2
  export:
    rename x as y
> ns2.y
2
```

```rhombus
> namespace ns3:
  export def x = 3
> ns3.x
3
```

```rhombus
> namespace ns4:
  export all_defined
  def x = 4
  def y = "four"
> ns4.x
4
> ns4.y
"four"
```

```rhombus
> defn.macro 'namespace_auto $ns_id $(a_defn :: Sequence)':
  'namespace $ns_id:
    export ~scope_like $ns_id $a_defn'
> namespace_auto ns5 def x = 5
> ns5.x
5
```

--------------------------------

### Implement a fruit pattern using the low-level binding protocol

Source: https://docs.racket-lang.org/rhombus-model/bind-macro-protocol.html

Example demonstrating the use of bind.macro, bind.infoer, and bind.oncer to create a custom 'fruit' binding pattern.

```rhombus
import:
  rhombus/meta open

bind.macro 'fruit($id)':
  bind_meta.pack('(fruit_infoer,
  // remember the id:
  $id)')

bind.infoer 'fruit_infoer($static_info, $id)':
  '("matching(fruit(_))",
  $id,
  // no overall static info:
  (),
  // `id` is bound,
  // `~repet ()` means usable as repetition, and
  // `()` means no static info:
  (($id, [~repet ()], ())),
  fruit_oncer,
  fruit_matcher,
  (), // no evidence needed
  fruit_committer,
  fruit_binder,
  // binder needs id:
  $id)'

bind.oncer 'fruit_oncer($id)':
  ''
```

--------------------------------

### Constructing and Accessing Lists

Source: https://docs.racket-lang.org/rhombus-reference/Lists.html

Examples of creating lists, accessing elements by index, and concatenating lists.

```rhombus
def lst = List(1, 2, 3)
lst
lst[0]
lst ++ [4, 5]
#%brackets [1, 2, 3]
```

--------------------------------

### Interactive @ Notation Examples

Source: https://docs.racket-lang.org/rhombus-guide/string-interpolation.html

Various examples showing how @ notation handles expressions, lists, and nested calls.

```Rhombus
@str{1 + 1 is @(1 + 1).}
```

```Rhombus
@(1 + 1)
```

```Rhombus
@List{apple}
```

```Rhombus
@List(1, 2, 3)
```

```Rhombus
@str{1 + 1 is @str{2}.}
```

```Rhombus
@str{1 + 1 is @math.sum(1, 1).}
```

```Rhombus
@str{Text within {} is
not constrained to
a single line.}
```

--------------------------------

### Style.HTML.InstallResource

Source: https://docs.racket-lang.org/rhombus-scribble/style-property-annot.html

Creates an InstallResource style property.

```APIDOC
## fun Style.HTML.InstallResource(script :: PathString) :: Style.HTML.InstallResource

### Description
Like Style.HTML.LinkResource, but without hyperlinking to the copied file.

### Parameters
- **script** (PathString) - The path to the resource.
```

--------------------------------

### Using Reducers

Source: https://docs.racket-lang.org/rhombus-reference/Iteration.html

Examples of using List, values, and Map reducers to collect iteration results.

```rhombus
fun grid(m, n):
  for List:
    each i in 0..m
    each j in 0..n
    [i, j]
```

```rhombus
fun sum(l :: List):
  for values(sum = 0):
    each i in l
    sum+i
```

```rhombus
for:
  each i in [1, 2, 3]
  each j in 10..10+3
  [i, j]
  ~into List
```

```rhombus
for values(x = 0, y = 2):
  each j in 0..3
  values(x + y, j)
```

```rhombus
fun grid2(m, n):
  for List:
    each i in 0..m
    let k = i + 1
    each j in 0..n
    [k, j]
```

```rhombus
for Map (i in 0..3):
  values(i, i +& "!")
```

```rhombus
for Map:
  each i in 0..3
  values(i, i +& "!")
```

--------------------------------

### Repetition Operators

Source: https://docs.racket-lang.org/rhombus-guide/rx-lang.html

Examples of using + and ? operators for repetition.

```rhombus
rx'"a"+ "b"+'.match("aaabb")
```

```rhombus
rx'"a"+ "b"+'.match_in("xxaaabbxx")
```

--------------------------------

### Complete Cairo library integration

Source: https://docs.racket-lang.org/rhombus-ffi/tutorial1.html

A full example demonstrating loading a library, defining types and functions, and performing drawing operations.

```rhombus
#lang rhombus/static
import:
ffi open
draw
pict
rhombus/rkt_obj
def cairo_lib = Lib.load("libcairo", ["2", #false])
foreign.linker cairo:
~lib: cairo_lib
foreign.type cairo_t
foreign.type cairo_surface_t
foreign.enum cairo_line_cap_t int_t
butt
round
square
cairo.fun cairo_create(cairo_surface_t*) :: cairo_t*
cairo.fun cairo_move_to(cairo_t*, double_t, double_t) :: void_t
cairo.fun cairo_line_to(cairo_t*, double_t, double_t) :: void_t
cairo.fun cairo_set_line_width(cairo_t*, double_t) :: void_t
cairo.fun cairo_stroke(cairo_t*) :: void_t
cairo.fun cairo_set_line_cap(cairo_t*, cairo_line_cap_t) :: void_t
fun make():
def bt = draw.Bitmap([256, 256])
def bt_surface = cpointer_to_ptr(rkt_obj.send bt.handle.#{get-handle}())
values(bt, cairo_create(cast (cairo_surface_t*) bt_surface))
fun show(bt):
pict.rectangle(~around: pict.bitmap(bt), ~line_width: 2)
def (bt, cr) = make()
cairo_move_to(cr, 50.0, 75.0)
cairo_line_to(cr, 200.0, 75.0)
cairo_move_to(cr, 50.0, 125.0)
cairo_line_to(cr, 200.0, 125.0)
cairo_move_to(cr, 50.0, 175.0)
cairo_line_to(cr, 200.0, 175.0)
cairo_set_line_width(cr, 30.0)
cairo_set_line_cap(cr, #'round)
cairo_stroke(cr)
show(bt)
```

--------------------------------

### Path.move_to()

Source: https://docs.racket-lang.org/rhombus-draw/Path.html

Sets the starting point for an open subpath.

```APIDOC
## (path :: draw.Path).move_to(pt :: PointLike)

### Description
Sets a starting point for an open subpath.
```

--------------------------------

### Creating and Using a Logger and Receiver

Source: https://docs.racket-lang.org/rhombus-reference/Logging.html

Demonstrates initializing a logger and a receiver, logging an error, and synchronizing to receive the event.

```rhombus
def l = Logger(~topic: #'example, ~parent: #false)
```

```rhombus
def r = LogReceiver(~logger: l, ~receive: #'warning)
```

```rhombus
l.error("something is wrong")
```

```rhombus
r.sync()
```

```rhombus
Array(#'error, "example: something is wrong", #false, #'example).snapshot()
```

```rhombus
l.debug("detailed information") // no receiver interested in debug
```

```rhombus
r.sync(~timeout: 0)
```

```rhombus
#false
```

--------------------------------

### Pict.metadata

Source: https://docs.racket-lang.org/rhombus-pict/pict.html

Gets or sets metadata associated with a pict.

```APIDOC
## method (pict :: Pict).metadata() :: Map
## method (pict :: Pict).set_metadata(metadata :: Map) :: Pict

### Description
Gets metadata registered for an immediate pict, or returns a pict that is like pict but with the given metadata.
```

--------------------------------

### Create an open path

Source: https://docs.racket-lang.org/rhombus-draw/overview.html

Demonstrates initializing a Path object and defining line segments using move_to and line_to methods.

```rhombus
def zee = draw.Path()
zee.move_to([0, 0])
zee.line_to([30, 0])
zee.line_to([0, 30])
zee.line_to([30, 30])
```

--------------------------------

### Construct a Path

Source: https://docs.racket-lang.org/rhombus-reference/path.html

Example of creating a path object from a string.

```rhombus
def p = Path("/home/rhombus/shape.txt")
p
```

--------------------------------

### String.trim

Source: https://docs.racket-lang.org/rhombus-reference/Strings.html

Removes matches to a separator from the start and end of a string.

```APIDOC
## String.trim(str, sep, ~start, ~end, ~repeat)

### Description
Removes matches to `sep` from the start (when `start` is true) and end (when `end` is true) of `str`.

### Parameters
- **str** (ReadableString) - The string to trim.
- **sep** (ReadableString or RX) - The pattern to remove.
- **~start** (Boolean) - Whether to trim the start.
- **~end** (Boolean) - Whether to trim the end.
- **~repeat** (Boolean) - Whether to remove repeated matches.
```

--------------------------------

### Constructing and Inspecting Cross-Platform Paths

Source: https://docs.racket-lang.org/rhombus-reference/cross-path.html

Demonstrates creating a CrossPath with a specific convention and retrieving its string representation and convention.

```rhombus
> def p = CrossPath(#"/home/rhombus/shape.txt", #'unix)
> p.string()
"/home/rhombus/shape.txt"
> p.convention()
#'unix
```

--------------------------------

### Get String Length

Source: https://docs.racket-lang.org/rhombus-reference/Strings.html

Returns the number of characters in a string.

```Rhombus
String.length("hello")
```

```Rhombus
"hello".length()
```

--------------------------------

### Create a basic GUI window

Source: https://docs.racket-lang.org/rhombus-gui/overview.html

Constructs and runs a simple window containing a label.

```rhombus
#lang rhombus
---
import:
  gui
gui.Window(gui.Label("Hello, World!")).run()
```

--------------------------------

### Get list length

Source: https://docs.racket-lang.org/rhombus-reference/Lists.html

Returns the number of items in the list.

```rhombus
[1, 4, 8].length()
```

```rhombus
[].length()
```

--------------------------------

### Create and Query a Map

Source: https://docs.racket-lang.org/rhombus-guide/map.html

Demonstrates creating a map using the Map constructor and performing lookups and membership tests.

```rhombus
def neighborhood = Map(  
["alice", Posn(4, 5)],  
["bob", Posn(7, 9)],  
)  
> neighborhood["alice"]  
Posn(4, 5)  
> neighborhood["clara"]  
Map.get: no value found for key  
key: "clara"  
> "clara" in neighborhood  
#false  
> "alice" in neighborhood  
#true
```

--------------------------------

### Pict.epoch_metadata

Source: https://docs.racket-lang.org/rhombus-pict/animate.html

Gets or sets metadata for an epoch within a pict.

```APIDOC
## method (pict :: Pict).epoch_metadata(i :: Int) :: Map
## method (pict :: Pict).epoch_set_metadata(i :: Int, metadata :: Map) :: Pict

### Description
Gets metadata registered for an epoch within a pict, or returns a pict that is like pict but with the given metadata for the given epoch.
```

--------------------------------

### Importing Modules with Relative Paths

Source: https://docs.racket-lang.org/rhombus-guide/module-basics.html

Examples of using relative paths to import modules in a project structure.

```rhombus
#lang rhombus  
---
import:
"db/lookup.rhm"
"machine/control.rhm"
....
```

```rhombus
#lang rhombus  
---
import:
"barcodes.rhm"
"makers.rhm"
....
```

```rhombus
#lang rhombus  
---
import:
"sensors.rhm"
"actuators.rhm"
....
```

--------------------------------

### Write HTML syntax objects

Source: https://docs.racket-lang.org/rhombus-html/htmlstx.html

Examples of using html.write_syntax to output HTML syntax objects.

```rhombus
html.write_syntax(
  html.syntax:
  a: "hello <name>"
)
```

```rhombus
html.write_syntax(
  html.syntax:
  a: ("b", "c", [["d"], "e"])
)
```

```rhombus
html.write_syntax(
  html.syntax:
  a: @{say this: "hello <name>"}
)
```

```rhombus
html.write_syntax(
  html.syntax:
  a: $(Syntax.inject(html.Comment(~data: "123")))
)
```

--------------------------------

### http.get

Source: https://docs.racket-lang.org/rhombus-http/get.html

Sends an HTTP GET request to the specified URI.

```APIDOC
## http.get(uri, ...)

### Description
Sends an HTTP request using the session argument's Session.request method. This function supports various configurations including sessions, headers, parameters, and authentication.

### Parameters
- **uri** (Bytes | String | url.URL | LiteralURL) - Required - The target URI for the request.
- **~session** (Session) - Optional - The session to use, defaults to Session.current().
- **~method** (Method) - Optional - The HTTP method, defaults to #'get.
- **~close** (Any.to_boolean) - Optional - Whether to close the connection.
- **~stream** (Any.to_boolean) - Optional - Whether to stream the response.
- **~headers** (Headers) - Optional - A map of HTTP headers.
- **~params** (List.of(url.KeyValue)) - Optional - Query parameters to include.
- **~auth** (maybe(auth.Function)) - Optional - Authentication function.
- **~data** (maybe(Bytes | String | Port.Input | payload.Function)) - Optional - Request payload data.
- **~timeouts** (Timeouts) - Optional - Timeout configuration.
- **~max_attempts** (PosInt) - Optional - Maximum number of retry attempts, defaults to 3.
- **~max_redirects** (PosInt) - Optional - Maximum number of redirects, defaults to 16.
- **~user_agent** (Bytes | String) - Optional - User-Agent string to send.

### Response
- **Response** - Returns a Response object.
```

--------------------------------

### Creating and Mutating Context Parameters

Source: https://docs.racket-lang.org/rhombus-reference/context-parameters.html

Demonstrates creating a context parameter with Parameter.make, retrieving its value, and updating it via function calls.

```rhombus
def size = Parameter.make(10)
> size()
10
> size(11)
> size()
11
```

--------------------------------

### gui.Obs.value

Source: https://docs.racket-lang.org/rhombus-gui/Observables.html

Property to get or set the current value of the observable.

```APIDOC
## (obs :: gui.Obs).value

### Description
Accesses or updates the current value held by the observable. Reading returns the value, while assigning updates it.
```

--------------------------------

### Define and Implement Interfaces

Source: https://docs.racket-lang.org/rhombus-guide/interfaces.html

Demonstrates defining interfaces and implementing them in a class, then checking instance satisfaction with is_a.

```rhombus
interface Shape
interface Dance
class Square(side):
  implements:
    Shape
    Dance
def s = Square(10)
s is_a Shape
#true
s is_a Dance
#true
```

--------------------------------

### Instantiate a gui.Window

Source: https://docs.racket-lang.org/rhombus-gui/window.html

Defines the constructor parameters for creating a top-level window, including configuration for title, style, size, position, and callbacks.

```Rhombus
class gui.Window():
  implements WindowView
  constructor (
    ~title: title :: ObsOrValue.of(String) = "Untitled",
    ~style: style :: ObsOrValue.of(List.of(Window.Style)) = [],
    ~size: size :: ObsOrValue.of(View.Size) = [#false, #false],
    ~position: position :: ObsOrValue.of(View.Position) = #'center,
    ~align: align :: ObsOrValue.of(View.Alignment) = [#'center, #'center],
    ~min_size: min_size :: ObsOrValue.of(View.Size) = [#false, #false],
    ~stretch: stretch :: ObsOrValue.of(View.Stretch) = [#true, #true],
    ~enable: enable :: ObsOrValue.of(Boolean) = #true,
    ~menu_bar: menu_bar :: maybe(MenuBar) = #false,
    ~window_callbacks: window_callbacks :: maybe(WindowCallbacks) = #false,
    child :: ObsOrValue.of(WindowChildView && !WindowView), ...
  )
```

--------------------------------

### Documenting a constant value

Source: https://docs.racket-lang.org/rhombus-reference/doc_notation.html

Example of a value binding documentation entry.

```Rhombus
def my_constant :: Int
```

--------------------------------

### Match failure exceptions

Source: https://docs.racket-lang.org/rhombus-reference/Matching.html

Examples of run-time exceptions when no pattern matches.

```Rhombus
> match 1+2
| 4: "four"
match: no matching case
```

```Rhombus
> match '1+2'
| '4': "four"
match: expected the literal 4
```

```Rhombus
> match '4'
| (pattern:
| '$x + $y'
| '$x - $y'):
"arithmetic"
match: expected more terms starting with the operator ‘+‘ or the
operator ‘-‘
```

--------------------------------

### show(v :: Any, ..., ~out: Port.Output, ~pretty: Any)

Source: https://docs.racket-lang.org/rhombus-reference/Printing.html

Prints values using the #'expr print mode.

```APIDOC
## show(v :: Any, ..., ~out: Port.Output = stdout, ~pretty: Any = Printable.current_pretty()) -> Void

### Description
Equivalent to calling `print` with the `~mode: #'expr` argument.
```

--------------------------------

### Start the Rhombus REPL

Source: https://docs.racket-lang.org/rhombus-guide/repl.html

Commands to launch the Rhombus REPL from the terminal.

```bash
rhombus
```

```bash
racket -I rhombus
```

--------------------------------

### Getting Mutable List Length

Source: https://docs.racket-lang.org/rhombus-reference/Mutable_Lists.html

Retrieving the number of elements in a list.

```rhombus
MutableList[1, 4, 8].length()
MutableList[].length()
```

--------------------------------

### Define Style.HTML.InstallResource

Source: https://docs.racket-lang.org/rhombus-scribble/style-property-annot.html

Creates an InstallResource style property to copy a file without hyperlinking.

```rhombus
fun Style.HTML.InstallResource(
  script :: PathString
):: Style.HTML.InstallResource
```

--------------------------------

### Importing and using a library function

Source: https://docs.racket-lang.org/rhombus-quick/index.html

Demonstrates importing a library and accessing its functions using a dotted name.

```rhombus
import:
  pict/radial
radial.flower(~fill: "pink")
```

--------------------------------

### Array Access and Modification

Source: https://docs.racket-lang.org/rhombus-reference/Arrays.html

Methods for getting and setting array elements.

```rhombus
Array("a", "b", "c")[1]
```

```rhombus
Array("a", "b", "c").get(1)
```

```rhombus
def a = Array("a", "b", "c")
a.set(1, "d")
a
a[1] := "e"
a
```

--------------------------------

### Syntax.group_source_properties

Source: https://docs.racket-lang.org/rhombus-reference/stxobj.html

Queries or installs source text information on a syntax group.

```APIDOC
## Syntax.group_source_properties(syntax :: Group)

### Description
Queries the source properties of a syntax group.

### Returns
- **values** (Any, Any, Any, Any) - The prefix, content, tail, and suffix components.

## Syntax.group_source_properties(syntax :: Group, prefix, content, tail, suffix)

### Description
Installs source text information onto a syntax group.

### Parameters
- **syntax** (Group) - The group to modify.
- **prefix** (Any) - The prefix component.
- **content** (Any) - The content component.
- **tail** (Any) - The tail component.
- **suffix** (Any) - The suffix component.

### Returns
- **Group** - The updated group.
```

--------------------------------

### Defining and Using Syntax Parameters

Source: https://docs.racket-lang.org/rhombus-meta/ref-syntax-parameter.html

Demonstrates defining a syntax parameter with syntax_parameter.bridge, accessing it via syntax_parameter_meta.lookup, and overriding its value with syntax_parameter.relet.

```Rhombus
syntax_parameter.bridge today_name:
  "Thursday"
expr.macro 'today':
  '$(syntax_parameter_meta.lookup('today_name'))'
fun say_today():
  today
expr.macro 'say_today_here':
  'today'
today
"Thursday"
block:
  syntax_parameter.relet today_name:
    "Friday"
  [today,
   say_today(),
   say_today_here]
["Friday", "Thursday", "Friday"]
today
"Thursday"
```

--------------------------------

### Create a directory

Source: https://docs.racket-lang.org/rhombus-reference/filesystem.html

Creates a new directory. Set parents to true to create any missing parent directories.

```Rhombus
fun filesystem.make_directory(
  path :: PathString,
  ~parents: parents = #false,
  ~permissions: permissions :: Int.in(0 ..= 65535) = 0o777
) :: Void
```

--------------------------------

### Create and Convert Paths

Source: https://docs.racket-lang.org/rhombus-reference/path.html

Demonstrates initializing a Path object and converting it to a string representation.

```rhombus
> Path("/home/rhombus/shape.txt")
| > Path(p)
---
Path("/home/rhombus/shape.txt")
| > p.string()
---
"/home/rhombus/shape.txt"
```

--------------------------------

### Pipeline Operator Usage

Source: https://docs.racket-lang.org/rhombus-reference/ref-function-call.html

Examples of the pipe-forward operator |> for chaining function calls.

```rhombus
[1, 2, 3] |> List.length
```

```rhombus
[3, 1, 2]
|> List.sort(_)
|> ([0] ++ _ ++ [100])
|> to_string.map(_)
```

--------------------------------

### Convert byte strings using Converter

Source: https://docs.racket-lang.org/rhombus-reference/converter.html

Demonstrates initializing a converter and performing conversions between character encodings.

```rhombus
def cvt = bytes.Converter(~from: "UTF-8", ~to: "UTF-16")
```

```rhombus
cvt.convert(#"ABCD")
```

```rhombus
cvt.convert(#"\303\247\303\260\303\266\302\243")
```

```rhombus
cvt.close()
```

--------------------------------

### Documenting a class with fields

Source: https://docs.racket-lang.org/rhombus-reference/doc_notation.html

Example of how a class with specific fields is represented in documentation.

```rhombus
class Lure(weight :: Number,
color :: String)
```

--------------------------------

### Importing from namespaces

Source: https://docs.racket-lang.org/rhombus-guide/namespaces-overview.html

Demonstrates importing namespaces within blocks and using the open keyword to bring bindings into scope.

```Rhombus
block:
  import:
    .geometry open
  Complex(0, tau)
  geometry.Complex(0, 6.28)

def also_pi:
  import:
    .geometry open
  tau/2

also_pi
```

--------------------------------

### Wrapping Events

Source: https://docs.racket-lang.org/rhombus-reference/evt.html

Examples of using Evt.wrap to transform the result of a synchronization event.

```Rhombus
Evt.always.wrap(fun (_): "done").sync()
```

```Rhombus
Evt.always.wrap(fun (_): values("also", "done")).sync()
```

```Rhombus
Evt.always.wrap(fun (_): 1).wrap(fun (v): v+1).sync()
```

```Rhombus
Evt.always.wrap(fun (_): values(1, 2)).wrap(fun (u, v): u+v).sync()
```

--------------------------------

### Paragraph Layout Examples

Source: https://docs.racket-lang.org/rhombus-pict/text.html

Demonstrates various paragraph formatting options including width constraints, horizontal alignment, and dynamic scaling.

```Rhombus
@para{Say ``hello'' for me!}
```

```Rhombus
@para(~width: 50){Say ``hello'' for me!}
```

```Rhombus
@para(~width: 50, ~horiz: #'right){Say ``hello'' for me!}
```

```Rhombus
para(& for List (i in 0..50): @t{Echo}.scale((50 - i)/50))
```

```Rhombus
parameterize { current_font:
current_font() with (size = 18, kind = #'roman) }:
para(@{There's a fine line between fishing},
@{and just standing on the shore like an idiot.},
@{--- Stephen Wright})
```

--------------------------------

### Checking Exactness

Source: https://docs.racket-lang.org/rhombus-reference/Numbers.html

Example of using the Exact annotation to verify if a number is exact.

```Rhombus
> 5 is_a Exact
#true
```

--------------------------------

### Creating and Using date.DateTime

Source: https://docs.racket-lang.org/rhombus-reference/date-datetime.html

Demonstrates initializing a date.DateTime instance, converting it to a string, and performing a comparison.

```rhombus
def dt = date.DateTime(~year: 2025, ~month: 11, ~day: 14, ~hour: 18, ~minute: 14)
```

```rhombus
dt
```

```rhombus
dt.to_string()
```

```rhombus
dt > date.DateTime.from_seconds(0)
```

--------------------------------

### Built-in Annotations Usage

Source: https://docs.racket-lang.org/rhombus-reference/Annotations.html

Examples of using Any, Any.of, Any.to_boolean, and Never annotations.

```rhombus
> "hello" is_a Any
#true
```

```rhombus
> "hello" is_a Any.of("hello", "goodbye")
#true
```

```rhombus
> "hola" is_a Any.of("hello", "goodbye")
#false
```

```rhombus
> "hello" :: Any.to_boolean
#true
```

```rhombus
> #false :: Any.to_boolean
#false
```

```rhombus
> "will not match" is_a Never
#false
```

```rhombus
> "will not match" is_a Any.of()
#false
```

--------------------------------

### Create a gui.Button

Source: https://docs.racket-lang.org/rhombus-gui/button.html

Constructor for creating a button with configurable label, action, style, and layout properties.

```Rhombus
class gui.Button():
  implements WindowChildView
  constructor (
    label :: ObsOrValue.of(View.LabelString
      || draw.Bitmap
      || [draw.Bitmap,
          View.LabelString,
          Button.LabelPosition]),
    ~action: action :: () -> ~any = fun (): #void,
    ~style: style :: List.of(Button.Style) = [],
    ~font : font :: draw.Font = View.normal_control_font,
    ~margin: margin :: ObsOrValue.of(View.Margin) = [2, 2],
    ~min_size: min_size :: ObsOrValue.of(View.Size) = [#false, #false],
    ~stretch: stretch :: ObsOrValue.of(View.Stretch) = [#false, #false],
    ~enable: enable :: ObsOrValue.of(Boolean) = #true,
    ~window_callbacks: window_callbacks :: maybe(WindowCallbacks) = #false
  )
```

--------------------------------

### Optional Newlines in Sequences

Source: https://docs.racket-lang.org/rhombus-meta-tutorial/shrubbery.html

Examples of where extra newlines are permitted between groups in a sequence.

```rhombus
(group 1, group 2,
group 3)
(group 1,
group 2)
'group 1
group 2'
```

--------------------------------

### ssl.Context.Server

Source: https://docs.racket-lang.org/rhombus-ssl/context.html

Creates a new SSL server context, optionally loading a private key and certificate chain.

```APIDOC
## fun ssl.Context.Server(~private_key: private_key = #false, ~certificate_chain: certificate_chain = #false)

### Description
Creates a server-side SSL context for a listener.

### Parameters
- **~private_key** (maybe(ssl.Context.PrivateKey)) - Optional - The private key to load into the context.
- **~certificate_chain** (maybe(Path)) - Optional - The certificate chain to load into the context.
```

--------------------------------

### Declare a module in Rhombus

Source: https://docs.racket-lang.org/rhombus-model/module-eval-model.html

Example of a basic module declaration in a Rhombus file.

```rhombus
#lang rhombus
def x = 10
```

--------------------------------

### class gui.VPanel

Source: https://docs.racket-lang.org/rhombus-gui/vpanel.html

Constructor for creating a vertical panel container.

```APIDOC
## class gui.VPanel()

### Description
Creates a panel that arranges child views vertically. When a panel is disabled via ~enable, all content within the panel is also disabled.

### Constructor Parameters
- **~align** (ObsOrValue.of(View.Alignment)) - Optional - Alignment of the panel content, defaults to [#'center, #'center].
- **~style** (ObsOrValue.of(List.of(VPanel.Style))) - Optional - List of style options for the panel.
- **~spacing** (ObsOrValue.of(View.SpacingInt)) - Optional - Spacing between children, defaults to 0.
- **~margin** (ObsOrValue.of(View.Margin)) - Optional - Margin around the panel, defaults to [0, 0].
- **~min_size** (ObsOrValue.of(View.Size)) - Optional - Minimum size of the panel, defaults to [#false, #false].
- **~stretch** (ObsOrValue.of(View.Stretch)) - Optional - Stretch behavior, defaults to [#true, #true].
- **~enable** (ObsOrValue.of(Boolean)) - Optional - Whether the panel is enabled, defaults to #true.
- **~window_callbacks** (maybe(WindowCallbacks)) - Optional - Callbacks common to all WindowChildViews.
- **child** (ObsOrValue.of(WindowChildView && !WindowView)) - Required - The child views to be arranged vertically.
```

--------------------------------

### Trimming Strings

Source: https://docs.racket-lang.org/rhombus-reference/Strings.html

Removes specified characters or whitespace from the start and end of a string.

```Rhombus
" Hello World ".trim()
```

```Rhombus
" Hello World ".trim(~start: #false)
```

```Rhombus
" Hello World ".trim(~end: #false)
```

```Rhombus
"_Hello World__".trim("_")
```

```Rhombus
"_Hello World__".trim("_", ~repeat: #true)
```

```Rhombus
"aBaBa".trim("aBa")
```

--------------------------------

### Initialize gui.Progress

Source: https://docs.racket-lang.org/rhombus-gui/progress.html

Constructor for creating a progress gauge with configurable value, range, and style.

```Rhombus
class gui.Progress():
  implements WindowChildView
  constructor (
    value :: ObsOrValue.of(View.SizeInt) = 0,
    ~label: label :: ObsOrValue.of(maybe(View.LabelString)) = #false,
    ~max_value: max_value :: ObsOrValue.of(View.PosSizeInt) = 100,
    ~enable: enable :: ObsOrValue.of(Boolean) = #true,
    ~margin: margin :: ObsOrValue.of(View.Margin) = [2, 2],
    ~min_size: min_size :: ObsOrValue.of(View.Size) = [#false, #false],
    ~stretch: stretch :: ObsOrValue.of(View.Stretch) = [#true, #true],
    ~style: style :: List.of(Progress.Style) = [#'horizontal],
    ~window_callbacks: window_callbacks :: maybe(WindowCallbacks) = #false
  )
```

--------------------------------

### RXMatch Method Definitions

Source: https://docs.racket-lang.org/rhombus-reference/Regexp_Match_Results.html

Definitions for the to_list and get methods on the RXMatch class.

```Rhombus
method (rx :: RXMatch).to_list() :: List
```

```Rhombus
method (rx :: RXMatch).get(index)
```

--------------------------------

### gui.Button constructor

Source: https://docs.racket-lang.org/rhombus-gui/button.html

Creates a new button instance with a specified label, action callback, and optional styling or layout configurations.

```APIDOC
## class gui.Button()

### Description
Creates a button component. Buttons can display text, bitmaps, or a combination of both. The action function is triggered when the user clicks the button.

### Constructor Signature
```
constructor (
  label :: ObsOrValue.of(View.LabelString || draw.Bitmap || [draw.Bitmap, View.LabelString, Button.LabelPosition]),
  ~action: action :: () -> ~any = fun (): #void,
  ~style: style :: List.of(Button.Style) = [],
  ~font : font :: draw.Font = View.normal_control_font,
  ~margin: margin :: ObsOrValue.of(View.Margin) = [2, 2],
  ~min_size: min_size :: ObsOrValue.of(View.Size) = [#false, #false],
  ~stretch: stretch :: ObsOrValue.of(View.Stretch) = [#false, #false],
  ~enable: enable :: ObsOrValue.of(Boolean) = #true,
  ~window_callbacks: window_callbacks :: maybe(WindowCallbacks) = #false
)
```
```

--------------------------------

### Get Byte String Length

Source: https://docs.racket-lang.org/rhombus-reference/Byte_Strings.html

Retrieve the number of bytes in a byte string.

```Rhombus
#"hello".length()
```

```Rhombus
Bytes.length(#"hello")
```

--------------------------------

### Creating and Testing Sets

Source: https://docs.racket-lang.org/rhombus-guide/set.html

Demonstrates set creation, membership testing using the 'in' operator, and set union using '++'.

```rhombus
def friends = {"alice", "bob", "carol"}
if "alice" in friends && "carol" in friends
"I know both"
"Who are they?"
def new_friends = friends ++ {"david"}
"david" in new_friends
"david" in friends
```

--------------------------------

### make_rhombus_eval

Source: https://docs.racket-lang.org/rhombus-scribble/examples.html

Creates a new Rhombus evaluator instance for use within documentation examples.

```APIDOC
## make_rhombus_eval

### Description
Creates a new evaluator instance specifically configured for Rhombus code, allowing for the execution and display of code examples within documentation.

### Usage
`make_rhombus_eval()`
```

--------------------------------

### Matching with Start Offset

Source: https://docs.racket-lang.org/rhombus-reference/Regexp_Objects.html

Shows how to apply a match to a specific portion of the input using the ~start argument.

```Rhombus
rx'"a"*'.match_in("a aa aaa", ~start: 2)
```

--------------------------------

### Instantiating and Comparing date.Time

Source: https://docs.racket-lang.org/rhombus-reference/date-time.html

Demonstrates creating a date.Time instance, converting it to a string, and performing comparisons.

```rhombus
> def tm = date.Time(~hour: 5, ~minute: 45)
> tm
Time(~hour: 5, ~minute: 45, ~second: 0, ~nanosecond: 0)
> tm.to_string()
"05:45:00"
> tm < date.Time(~hour: 6, ~minute: 10)
#true
```

--------------------------------

### Repetition Operators

Source: https://docs.racket-lang.org/rhombus-reference/rx-pattern.html

Examples of the * repetition operator with different greedy, nongreedy, and possessive modes.

```Rhombus
rx'any*'.match("abc")
```

```Rhombus
rx'any*'.match("")
```

```Rhombus
rx'($head: any*) ($tail: any*)'.match("abc")
```

```Rhombus
rx'($head: any* ~nongreedy) ($tail: any*)'.match("abc")
```

```Rhombus
rx'any* ~greedy "z"'.match("abcz")
```

```Rhombus
rx'any* ~possessive "z"'.match("abcz")
```

--------------------------------

### Using the Current Logger

Source: https://docs.racket-lang.org/rhombus-reference/Logging.html

Shows how to use the current logger via the log shorthand.

```rhombus
block:
  log.error("something is wrong") // probably goes to stderr
  #'done
```

--------------------------------

### Initialize HPanel

Source: https://docs.racket-lang.org/rhombus-gui/hpanel.html

Constructor for creating an HPanel with configurable style, alignment, spacing, and other layout properties.

```Rhombus
class gui.HPanel():
  implements WindowChildView
  constructor (
    ~style: style :: ObsOrValue.of(List.of(HPanel.Style)) = [],
    ~align: align :: ObsOrValue.of(View.Alignment) = [#'center, #'center],
    ~spacing: spacing :: ObsOrValue.of(View.SpacingInt) = 0,
    ~margin: margin :: ObsOrValue.of(View.Margin) = [0, 0],
    ~min_size: min_size :: ObsOrValue.of(View.Size) = [#false, #false],
    ~stretch: stretch :: ObsOrValue.of(View.Stretch) = [#true, #true],
    ~enable: enable :: ObsOrValue.of(Boolean) = #true,
    ~window_callbacks: window_callbacks :: maybe(WindowCallbacks) = #false,
    child :: ObsOrValue.of(WindowChildView && !WindowView),
    ...
  )
```

--------------------------------

### Searching Lists

Source: https://docs.racket-lang.org/rhombus-reference/Lists.html

Examples of checking for element existence and finding indices within a list.

```Rhombus
[1, 2, 3].contains(2)
```

```Rhombus
[1, 2, 3].contains(200)
```

```Rhombus
[10, 20, 30].contains(20.0, (_ .= _))
```

```Rhombus
2 in [1, 2, 3]
```

```Rhombus
["a", "b", "c"].index("b")
```

```Rhombus
["a", "b", "c"].index("d")
```

```Rhombus
[10, 20, 30].index(20.0, (_ .= _))
```

--------------------------------

### Initialize gui.Spacer

Source: https://docs.racket-lang.org/rhombus-gui/spacer.html

Constructor for creating a spacer instance with optional size, stretch, and callback configurations.

```rhombus
class gui.Spacer():
  implements WindowChildView
  constructor (
    ~min_size: min_size :: ObsOrValue.of(View.Size) = [#false, #false],
    ~stretch: stretch :: ObsOrValue.of(View.Stretch) = [#true, #true],
    ~window_callbacks: window_callbacks :: maybe(WindowCallbacks) = #false
  )
```

--------------------------------

### Annotating Mutable Lists

Source: https://docs.racket-lang.org/rhombus-reference/Mutable_Lists.html

Examples of using MutableList annotations for static type checking.

```rhombus
MutableList(1, 2, 3) :: MutableList
```

```rhombus
MutableList(1, 2, 3) :: MutableList.now_of(Number)
```

```rhombus
MutableList(1, "b", 3) :: MutableList.now_of(Number)
```

```rhombus
def l :: MutableList.later_of(Number) = MutableList(1, "b", 3)
l[0]
l[1]
l[2] := "c"
```
Tokens:
Raw