Operators and Expressions

Statements and Expressions

One of the first details that you may notice when perusing a Jock programming is how the statements are sometimes terminated with semicolon ; “mic”. Jock uses ; “mic” to separate statements that are “composed” together in Nock. Thus their usage is not random, but similar to Rust describes statements that do not result in values.

For instance, this program imports a library, defines some variables, and results in a final atom:

import hoon;      // import Hoon standard library (superfluous)

let a = 5;        // define variable
let b = 36;       // define variable

b = +(b);         // modify a variable

a + b             // return a value from an expression

The earlier statements modify the execution context, or subject, of the final value, and as such as marked with ; “mic”.

In contrast, statement which sit “together” (as the methods in a class) are not delimited by ; “mic”.

/*  A class is broadly equivalent to a Hoon door. It has a top-level
    sample which represents its state, along with methods that have
    each their own samples.

    A class must be composed into the subject to be accessible.
*/
compose
  class Foo(x:@) {
    bar(p:@) -> Foo {
      p
    }
    qux(p:@) -> (@ @) {
      (p p)
    }
  }
; // end compose

//  let name:Type = value;
let a:Foo = Foo(41);
//  let name = Type(value);
let b = Foo(42);
//  let name:type = value;
let c:@ = 43;

(Foo(40) a b c)

Jock commonly relies on the compose pattern (as above) to explicitly include a data structure in the appropriate execution context (subject).

Arithmetical Expressions

Parentheses () "pal”/“par” are furthermore used to collect terms for operators in arithmetic. Right now, Jock binds to the right (like APL), although we expect to implement a more intuitive operator precedence later.

(
  1 + 2            // 3
  3 * 4 - 1        // 9 (3*(4-1))
  (3 * 4) - 1      // 11
  5 * 6 / 7        // 0 (5*(6/7)), C-style floor division
)

Built-in arithmetic is supported for unsigned integer operations only.

• + → Hoon add

• - → Hoon sub

• * → Hoon mul

• / → Hoon div

• ** → Hoon pow

• % → Hoon mod

These will be expanded and support for floating-point operations added at a later release.

Logical Expressions

Built-in comparisons

• < → Hoon lth

• > → Hoon gth

• <= → Hoon lte

• >= → Hoon gte

• == → equality, Nock 5

• != → inequality

These apply to atoms only, except for == and != which can be used for any two nouns.

Code Blocks

While {} “kel”/“ker” generally denote sets, braces are also used to mark collected code blocks for certain keywords such as if and match. In cases where these need to result in a set, the braces are doubled.

let a: @ = 3;

if a == 3 {
  72
} else {
  17
}

Contrast that result, which is a bare atom, with the result of the following:

let a: @ = 3;

if a == 3 {
  { 72 }
} else {
  { 17 }
}

This results in a Set(@) or set of atoms with a single member, 72.

(Note further that ifand else are always paired—there is no standalone if.)