Racket

@racket-lang.org

Racket is... * a general purpose language * compiler, runtime and tools, * a diverse community https://racket-lang.org/ Rhombus is a general-purpose programming language that is easy to use and uniquely customizable. https://rhombus-lang.org

```python
// efficient functional data structures

class Tree(val, children :: List.of(Tree)):
method flatten(): // O(N log N) for N `val`s
for fold(lst = [val]) (child in children):
// because append with `++` is O(log N)
lst ++ child.flatten()

Tree(1, [Tree(2, [Tree(4, [])]),
Tree(3, [Tree(5, [])])])
.flatten() // ⇒ [1, 2, 4, 3, 5]
```
(the 'python’ syntax highlighting in most markdown-like environments is sufficient for Rhombus)

Rhombus Programming Language
https://rhombus-lang.org
#rhombus

```
// pattern matching in all binding positions

class Posn(x, y)

fun flip_all([Posn(x, y), ...]):
[Posn(y, x), ...]

flip_all([Posn(1, 2), Posn(3, 4)])
// ⇒ [Posn(2, 1), Posn(4, 3)]
flip_all([Posn(5, 6)])
// ⇒ [Posn(6, 5)]
```

https://rhombus-lang.org

Code sample from https://rhombus-lang.org
```rhombus
// ellipses to create and use repetitions

fun all_same([str0, str, ...]):
all(str0 == str, ...)

all_same(["hello", "hello", "hello"])
// ⇒ #true
all_same(["hello", "goodbye", "hello"])
// ⇒ #false
```

// `for` as a general-purpose iteration and
// comprehension form

fun i_repeat(str :: String, n :: Nat) :: List:
for List (i in 0..n):
i+1 +& ". " +& str

i_repeat("hello", 3)
// ⇒ ["1. hello", "2. hello", "3. hello"]

https://rhombus-lang.org

// `:` for nesting, `|` for alternatives,
// `::` for type-like checked annotations

fun repeat(str :: String, n :: Nat) :: List:
if n == 0
| []
| [str] ++ repeat(str, n-1)

repeat("hello", 3)
// ⇒ ["hello", "hello", "hello"]
repeat(3, "hello")
// ⇒ error: 3 is not a String

https://rhombus-lang.org

$// pattern matching on objects, lists, and maps class Rect(left, top, right, bottom) fun rect_like_to_rect(v): match v | Rect(_, _, _, _): v | {"LT": [l, t], "RB": [r, b]}: Rect(l, t, r, b) | {"TL": [t, l], "BR": [b, r]}: Rect(l, t, r, b) rect_like_to_rect({"LT": [0, 2], "RB": [10, 5]}) // ⇒ Rect(0, 2, 10, 5) rect_like_to_rect({"TL": [0, 2], "BR": [10, 5]}) // ⇒ Rect(2, 0, 5, 10)$