@@ -10,18 +10,18 @@ The Arvo operating system is divided up into modules called vanes. Gall is the v
1010
1111```hoon
1212|%
13−+$ effect (pair bone syscall)
14−+$ syscall [%wait path @da]
13++$ move (pair bone card)
14++$ card [%wait path @da]
1515--
1616|_ [bowl:gall ~]
1717++ poke-noun
1818 |= t=@dr
19− ^+ [*(list effect) +>.$]
19+ ^+ [*(list move) +>.$]
2020 :_ +>.$ :_ ~
2121 [ost %wait /egg-timer (add now t)]
2222++ wake
2323 |= [=wire error=(unit tang)]
24− ^+ [*(list effect) +>.$]
24+ ^+ [*(list card) +>.$]
2525 ~& "Timer went off!"
2626 [~ +>.$]
2727--
@@ -31,14 +31,14 @@ The first thing to notice is that we are creating a `core` (`|%`) and a `door` (
3131
3232```hoon
3333|%
34−+$ effect (pair bone syscall)
35−+$ syscall [%wait path @da]
34++$ card (pair bone move)
35++$ move [%wait path @da]
3636--
3737```
3838
39−The `core` here defines two types: `effect` and `syscall`. An `effect` is a `pair` of `bone` and `syscall`. A `bone` is a Gall-only type that identifies app event chains by mapping atoms to them. We define `syscall` to be a request to Arvo to do something for us. In this case, the only valid `syscall` will be `%wait` which we'll discuss in a bit.
39+The `core` here defines two types: `card` and `move`. An `card` is a `pair` of `bone` and `move`. A `bone` is a Gall-only type that identifies app event chains by mapping atoms to them. We define `move` to be a request to Arvo to do something for us. In this case, the only valid `move` will be `%wait` which we'll discuss in a bit.
4040
41−It's important to note that the names `effect` and `syscall` are arbitrary; you can call them whatever you'd like. Commonly you will see them called `move` and `card`, respectively, but we've changed the names here to try to introduce some clarity that that older convention lacks.
41+It's important to note that the names `card` and `move` are arbitrary; you can call them whatever you'd like. Commonly you will see them called `move` and `card`.
4242
4343The sample of the `door` is:
4444
@@ -59,7 +59,7 @@ The `door` we've made has two arms `poke-noun` and `wake`. Gall is capable of di
5959```hoon
6060++ poke-noun
6161 |= t=@dr
62− ^+ [*(list effect) +>.$]
62+ ^+ [*(list card) +>.$]
6363 :_ +>.$ :_ ~
6464 [ost %wait /egg-timer (add now t)]
6565```
@@ -70,7 +70,7 @@ In the above code, we create a gate that takes a single `@dr` argument. `@dr` is
7070- `~m20` 20 minutes
7171- `~d42` 42 days
7272
73−As a matter of good type hygiene, we explicitly cast the output of this gate with `^+` to ensure we are producing the correct thing for Gall to handle. `^+` is the rune for casting by example. Our example is a cell: `list` of `effect`, which we `bunt` with `*`, is the head; `+>.$`, the enclosing core which is our `door`, is the tail.
73+As a matter of good type hygiene, we explicitly cast the output of this gate with `^+` to ensure we are producing the correct thing for Gall to handle. `^+` is the rune for casting by example. Our example is a cell: `list` of `card`, which we `bunt` with `*`, is the head; `+>.$`, the enclosing core which is our `door`, is the tail.
7474
7575Next we're going to use the `:_` rune which is just the inverted form a `:-` the cell construction rune. We use it twice so the actual data will end up looking something like:
7676
@@ -78,9 +78,9 @@ Next we're going to use the `:_` rune which is just the inverted form a `:-` the
7878[[[ost %wait /egg-timer (add now t)] ~] +>.$]
7979```
8080
81−`ost` is the `bone`, the opaque reference to a chain of events, that comes from `bowl`, so we're going to continue to use it here. `%wait` is the name of the `syscall`, in this case a request to the Behn vain to start a timer for us.
81+`ost` is the `bone`, the opaque reference to a chain of events, that comes from `bowl`, so we're going to continue to use it here. `%wait` is the name of the `move`, in this case a request to the Behn vain to start a timer for us.
8282
83−After `%wait`, we have the `path`, a `list` of `cords` that serves as the unique identifier for this `syscall`:
83+After `%wait`, we have the `path`, a `list` of `cords` that serves as the unique identifier for this `move`:
8484
8585```
8686/egg-timer
@@ -88,7 +88,7 @@ After `%wait`, we have the `path`, a `list` of `cords` that serves as the unique
8888
8989The `/` here is an irregular syntax to make a `path`.
9090
91−The final part of this `syscall` is:
91+The final part of this `move` is:
9292
9393```
9494(add now t)
@@ -96,17 +96,17 @@ The final part of this `syscall` is:
9696
9797`now` is the current time of type `@da`, and `t` was declared as `@dr`. Because they are both atoms, we can add `now` and `t` these two to get an atom that is `t` units of time into the future from `now`. That produced atom can be interpreted as a `@da`.
9898
99−That's all for our `poke-noun` arm. But what about when the timer goes off? Behn will create a `gift`, a similar construct to how we created an `effect`, only this time it will end up being dispatched back to us via Gall in the `++wake` arm. Any app that wants to use a timer trigger needs to have an arm called `++wake`.
99+That's all for our `poke-noun` arm. But what about when the timer goes off? Behn will create a `gift`, a similar construct to how we created an `card`, only this time it will end up being dispatched back to us via Gall in the `++wake` arm. Any app that wants to use a timer trigger needs to have an arm called `++wake`.
100100
101101```hoon
102102++ wake
103103 |= [=wire error=(unit tang)]
104− ^+ [*(list effect) +>.$]
104+ ^+ [*(list card) +>.$]
105105 ~& "Timer went off!"
106106 [~ +>.$]
107107```
108108
109−`wake` is a `gate` that has two arguments: a `wire`, and a `(unit tang)` with the face `error`. The syntax of `=wire` is a shortcut for `wire=wire`; it's a common pattern to shadow the name of a type when you only have one instance of the type and are not going to refer to the type itself. A `wire` is just an alias for `path`. Our `wire` will be the `path` that we gave original `syscall`. If we needed to do something based on which request caused this gate to be called, we could use the wire to do so. In this case, we don't do perform such a dispatch.
109+`wake` is a `gate` that has two arguments: a `wire`, and a `(unit tang)` with the face `error`. The syntax of `=wire` is a shortcut for `wire=wire`; it's a common pattern to shadow the name of a type when you only have one instance of the type and are not going to refer to the type itself. A `wire` is just an alias for `path`. Our `wire` will be the `path` that we gave original `move`. If we needed to do something based on which request caused this gate to be called, we could use the wire to do so. In this case, we don't do perform such a dispatch.
110110
111111Next we have the same cast we used in `++poke-noun` to make sure we are producing the correct thing for Gall. These casts are not strictly necessary, as the type system can infer what the type will be, but they can be very useful both for debugging our own code and for someone else trying to determine what our code should be producing.
112112
@@ -116,4 +116,4 @@ Next we have the same cast we used in `++poke-noun` to make sure we are producin
116116
117117`~&` is the debugging printf rune. Here we're using it to output a message. We could, however, modify this line of code to do any other computation we would want to happen when `++wait` gets called.
118118
119−Finally, we need to produce our `effect`. Here the effect is simply `[~ +>.$]`, since we have no `syscall` to make and we are not changing the state of our app. We just use the `door` without changing its sample.
119+Finally, we need to produce our `card`. Here the effect is simply `[~ +>.$]`, since we have no `move` to make and we are not changing the state of our app. We just use the `door` without changing its sample.