git.iko.soy/urbit.org
on 6d45ede help sign in
urbit.org/docs/arvo/subject.md
106 lines 4.0 kB history raw
1---
2navhome: /docs
3sort: 2
4next: true
5title: The subject
6---
8The subject
9===========
11Now we're going to cover the boiler plate that we skimmed over earlier.
13 :- %say |= *
14 :- %noun
15 =< (sum [1.000 2.000])
17The first rune, `:-` (colhep, aka
18[:cons](../../hoon/twig/col-cell/hep-cons/)), constructs the 2-element cell
19that will be our program. The first element, `%say`, tells the
20interpreter what to produce--in this case a value.
22The second element is `|=`, which we know produces a function. `|=`'s
23first child is its argument(s), which in this case is any noun (`*`).
24Its second child is the remainder of the program.
26Similarly, the rest of the program (which we construct with another
27`:-`) is a cell of the literal `%noun`, which tells the shell that we're
28producing a value of type `noun`, and the code that we run to actually
29produce our value of the type `noun`.
31`=<` ([tisgal](../../hoon/twig/tis-flow/gal-rap/)) is a rune that takes two
32children. The second child is the context against which we run the first
33child. So in this case, we are running the expression
34`(sum [1.000 2.000])` against everything contained within the `|%`. In
35Hoon, we call the code executed the "formula" and its context the
36"subject".
38 ::::::::::::::::::::::::::::::
39 =< (sum [1.000 2.000]) :: formula
40 ::::::::::::::::::::::::::::::
41 |% ::
42 ++ three ::
43 |= a/@ ::
44 =| b/@ ::
45 |- ^- @u ::
46 ?: (lth a b) ::
47 0 ::
48 (add b $(b (add 3 b))) ::
49 ::
50 ++ five ::
51 |= a/@ :: subject
52 =| b/@ ::
53 |- ^- @ ::
54 ?: (lte a b) ::
55 0 ::
56 ?: =((mod b 3) 0) ::
57 $(b (add b 5)) ::
58 (add b $(b (add b 5))) ::
59 ::
60 ++ sum ::
61 |= {a/@u b/@u} ::
62 (add (five a) (three b)) ::
63 -- ::
64 ::::::::::::::::::::::::::::::
66In nearly every language there is a similar concept of a "context" in
67which expressions are executed. For example, in C this includes things
68like the call stack, stack variables, and so on.
70Hoon is unique in that this context is a first-class value. Scheme
71allows a sort of reification of the context through continuations, and
72some may see a parallel to Forth's stack, but Hoon takes the
73concept one step further.
75Our starting subject is the [standard library](../../hoon/library), which is
76defined in `/arvo/hoon.hoon` and `/arvo/zuse.hoon`. This is where
77functions like `add` are defined. When we define a core with `|%`, we
78don't throw away the subject (i.e. the standard library); rather, we
79stack the new core on top of the old subject so that both are
80accessible.
82**Exercises**:
84- Pass `++sum` its arguments (`2.000` and `3.000`) from the
85 commandline.
87- Comment out all of the arms of the `|%`. Now add another arm and
88 call it `++add`, have it accept two arguments and procduce 42
89 (regardless of input). Change the `=<` line to
90 `[(add 5 7) (^add 5 7)]`. Can you recognize what's happening?
92Cheatsheet:
94- To pass arguments from the command line to a program, you replace
95 the `*` in the first line of the boiler plate to
96 `{^ {{arg/TYPE $~} $~}}` where `TYPE` is replaced with the type of
97 argument you're expecting. Then `+euler1 a` from the dojo sets `arg`
98 to `a`.
99- The empty list is `~`
100- Lisp-style cons (construct a cell/prepend an element) is
101 `[new-element list]`
102- For example, the first three positive integers are `[1 2 3 ~]`
103- `(gte a b)` tests whether `a` is greater than or equal to `b`.
104- `(mod a b)` runs the modulo operation on two atoms.
105- See the basic math section in `/arvo/hoon.hoon` for more info.