1.1 Exercise🔗

Open interp1.rhm and try the exercises listed at the top of the file.

1.2 Exercise🔗

Open interp2.rhm and try the exercises listed at the top of the file.

If you’re new to Rhombus, and because you followed the instructions to skip the docs, you’ll need to know about ellipses:

• When ... is used in to match a pattern in a binding position, each variable before the ... stands for a repetition. It binds matching any number of times.

  For example, it can be used for multi-argument functions:

  fun ignore_all_args(x, ...):   "ok"

  > ignore_all_args(0)

  "ok"

  > ignore_all_args()

  "ok"

  > ignore_all_args(0, 1, 2)

  "ok"

  It can also be used inside lists in a single argument:

  fun ignore_ints_in_list([x :: Int, ...]):   "ok"

  > def fav_ints = [1, 2, 3]

  > ignore_ints_in_list(fav_ints)

  "ok"

  > ignore_ints_in_list([1])

  "ok"

  > ignore_ints_in_list([1, "apple"])

  ignore_ints_in_list: argument does not satisfy annotation

  argument: [1, "apple"]

  annotation: matching(List((_ :: Int), ...))

• Expression forms such as function calls, list constructions, and map (dictionary) constructions also recognize .... They duplicate the form before the ..., which must include a reference to a repetition. The referenced repetition determines the number times the expression is repeated.

  fun add_to_all(x :: Int, [y :: Int, ...]):   [x + y, ...]

  > add_to_all(10, [1, 2, 3])

  [11, 12, 13]

  > def [x, ...] = ["1", "42", "79"]

  > String.append(x, ...)

  "14279"

  > def m = { x.to_int(): x, ... }

  > m

  {1: "1", 42: "42", 79: "79"}

  > m[42]

  "42"

1.3 Exercise🔗

Open interp3.rhm and try the exercises listed at the top of the file.

This exercise uses syntax objects. Terms surrounded by single quotes '…' are not strings, but are data structures. They are typically used to represent program expressions and avoid all the problems of using strings to represent expressions. They must conform to shrubbery notation (don’t read those docs!) in the same way that quoted Lisp and Scheme terms must conform to S-expression notation. Like S-expressions, some notational choices (such as the presence of leading zeros in numbers) do not affect the meaning of the syntax object, so '1  + 0002' (with extra spaces zeros) is the same as '1 + 2'. Unlike S-expressions, syntax objects are a sophisticated data structure that can even help track binding information.

Using '…' in a pattern-matching position accepts a matching syntax object, where $ escapes back to binding mode. Similarly, using $ escapes in a '…' expression escapes back to expression mode and substitutes the expression’s result into the syntax object.