816be15 · urbit.org · git.iko.soy

git.iko.soy/urbit.org

Merge pull request #672 from urbit/next-up

removed next up links

commit816be15ad60eba715e815528dc9362f3f8986bc6 authorrmariani <robert@tlon.io> dateTue 22 Oct 2019, 17:31 (7 years ago) parentff18ced d02bac7

24 files changed+1−47

compare with master

unifiedsplit

tutorials/hoon/ackermann.md−3

@@ -27,6 +27,3 @@ Second, if `n` is zero, decrement `m`, set `n` to 1 and recurse.

2727Else, decrement `m` and set `n` to be the value of the Ackermann function with `n` and the decrement of `n` as arguments.

2828

2929This is not a terribly useful function to compute but it has an interesting history in mathematics. When running this function the value grows rapidly even for very small input. The value of computing this where `m` is `4` and `n` is `2` is an integer with 19,729 digits.

30−

31−

32−### [Next Up: Reading -- Arms and Cores](../arms-and-cores)

tutorials/hoon/arms-and-cores.md+1−3

@@ -485,6 +485,4 @@ You can now unbind `c` in the dojo -- this will help to keep your dojo subject t

485485

486486> c

487487-find.c

488−```

489−

490−### [Next Up: Walkthrough -- Caesar Cipher](../caesar)

488+```

tutorials/hoon/atoms-auras-and-simple-cell-types.md−2

@@ -775,5 +775,3 @@ Hoon pretty-prints them the same way, but can we be sure that they are the same

775775

776776They are indeed the same.

777777

778−

779−### [Next Up: Reading -- Type Checking and Type Inference](../type-checking-and-type-inference)

tutorials/hoon/bank-account.md−2

@@ -78,5 +78,3 @@ Each of these arms produces a gate which takes an `@ud` argument. Each of these

7878`+>` is [wing syntax](/docs/reference/hoon-expressions/limb/limb/). This particularly wing construction looks for the the tail of the tail (the third element) in `$`, the subject of the gate we are in, which is the entire `new-account` door. We change `balance` to be the result of adding `balance` and `amount` and produce the door as the result. `withdraw` functions the same way only doing subtraction instead of addition.

7979

8080It's important to notice that the sample, `balance`, is stored as part of the door rather than existing outside of it.

81−

82−### [Next Up: Reading -- Generators](../generators)

tutorials/hoon/caesar.md−2

@@ -343,5 +343,3 @@ look for the legible result.

343343possible unshifted `tapes`.

344344

3453454. Modify the example generator into a `%say` generator.

346−

347−### [Next Up: Reading -- Doors](../doors)

tutorials/hoon/conditionals.md−2

@@ -71,5 +71,3 @@ We only went into three "wut" runes in our walkthrough, but there are many other

7171- `?|` takes an indefinite number of children. It's the logical "or" operator. It checks if at least one of its children is true.

7272

7373To see an exhaustive list of "wut" runes, check out the [reference documentation on conditionals](/docs/reference/hoon-expressions/rune/wut/).

74−

75−### [Next Up: Reading -- Lists](../lists)

tutorials/hoon/doors.md−2

@@ -502,5 +502,3 @@ It's better simply to use the `~(arm rs arg)` syntax to replace the value of the

502502## Conclusion

503503

504504You've now reached the end of Chapter 1 of the Hoon tutorial. Ideally you should have a fair understanding of the fundamental concepts of subject-oriented programming: limbs, legs, faces, wings, arms, cores, gates, and doors. If you can master these concepts you should have little or no trouble learning to write substantial Hoon programs. Continue to [Chapter 2](atoms-auras-and-simple-cell-types) to get started.

505−

506−### [Next Up: Walkthrough -- Bank Account](../bank-account)

tutorials/hoon/egg-timer.md−2

@@ -117,5 +117,3 @@ Next we have the same cast we used in `++poke-noun` to make sure we are producin

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

119119Finally, 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.

120−

121−### [Next Up: Reading -- Ford](../ford)

tutorials/hoon/fibonacci.md−2

@@ -59,5 +59,3 @@ In the code above, `?:` checks whether the first child, `=(i n)`, our terminatin

5959```

6060

6161The final expression in our program calls the `$` arm of the trap we are but makes some changes: we increment `i`, set `p` to be `q` and `q` becomes the sum of `p` and `q`. `r` becomes a cell of `q` and whatever `r` was previously. The list built from this is the one that will get `flop`ped to produce the result at the end of the computation.

62−

63−### [Next Up: Reading -- Gates](../gates)

tutorials/hoon/ford.md−2

@@ -193,5 +193,3 @@ produces: `0v0`

193193Ford is the vane utilized for unit testing, which are the the simplest sort of test one may perform on software that is one step removed from manual testing. Ford itself does not have testing capabilities built in, rather Ford has a more general capability known as _rendering_ which is utilized by the `+test` generator to perform the tests. The walkthrough which follows this lesson goes into more detail.

194194

195195One typically tests software by feeding it inputs and seeing if the outputs matches what is expected (something that is determined manually by the engineer). Unit tests work with only a single "module" at a time. What exactly is meant by this is shown by example in the following walkthrough, but for now it suffices to say that unit tests are in contrast with larger scale tests variously known as end-to-end tests, system tests, and integration tests.

196−

197−### [Next up: Unit Testing with Ford](../test-sets.md)

tutorials/hoon/gates.md−2

@@ -269,5 +269,3 @@ Write a gate that takes an atom, `a=@`, and which returns double the value of `a

269269> (double 25)

27027050

271271```

272−

273−### [Next Up: Walkthrough -- Recursion](../recursion)

tutorials/hoon/hoon-syntax.md−2

@@ -325,5 +325,3 @@ There are a couple useful runes associated with debugging:

325325`~&` (sigpam) is used to print its argument every time that argument executes. So, if you wanted to see how many times your program executed `foo`, you would write `foo bar`. Then, when your program runs, it will print `foo` on a new line of output every time the program comes across it by recursion.

326326

327327But there are more. Check out the aforementioned [troubleshooting](/docs/reference/troubleshooting/) page to see other handy debugging runes and how to use them.

328−

329−### [Next Up: Walkthrough -- Conditionals](../conditionals)

tutorials/hoon/iron-polymorphism.md−3

@@ -86,6 +86,3 @@ But `fold` does not have to produce a `list`. Let's look at another example:

8686Here `fold` will produce a gate that takes an `atom` and applies a gate to a `list` of `atoms`. The difference here is that this call will produce a sum of the elements of the list, rather than the list itself.

8787

8888The key takeaway from both of these examples is that the gates provided are _iron polymorphic_ with respect to the definition of the type in `fold`. They are iron polymorphic because samples `s` and `e` nest under the types `state` and `elem`. In second case case, that's because when we provided those to `fold`, it was was stated they were `@` and `@`. In the first case, we stated that `state` was `(list @)` and `elem` was `@`. In both cases, the sample of each gate nest inside the types defined when we called the wet gate `fold`.

89−

90−

91−[Next Up: Walkthrough -- Lead Polymorphism](../lead-polymorphism)

tutorials/hoon/lead-polymorphism.md−2

@@ -153,5 +153,3 @@ Finally, the first line of our program will take the first 10 elements of `fib`

153153```

154154

155155This example is a bit overkill for simply calculating the Fibonacci series, but it nicely illustrates how you might use iron cores. Instead of `fib`, you could have any `stream` that produces some stream of values and you'd still be able to use the `take`, `to-list`, and `stream-type` arms.

156−

157−[Next Up: Reading -- Gall](../gall)

tutorials/hoon/libraries.md−2

@@ -181,5 +181,3 @@ So now that we have this library, how do we actually use it? Let's look at a ver

181181If you save our the library as `playing-cards.hoon` in the `lib` directory, you can import the library with the `/+` rune. Our above `say` -- let's call it `cards.hoon` -- imports our library in this way. It should be noted that `/+` is not a Hoon rune, but instead a rune used by Ford, the Urbit build-system. When `cards.hoon` gets built, Ford will pull in the requested library and also build that. It will also create a dependency so that if `playing-cards.hoon` changes, this file will also get rebuilt.

182182

183183Below `/+ playing-cards`, you have the standard `say` generator boilerplate that allows us to get a bit of entropy from `arvo` when the generator is run. Then we feed the entropy and a `deck` created by `make-deck` into `shuffle-deck` to get back a shuffled `deck`.

184−

185−### [Next Up: Reading -- Trees, Sets, and Maps](../trees-sets-and-maps)

tutorials/hoon/list-of-numbers.md−2

@@ -130,5 +130,3 @@ Our program works by having each iteration of the list creating a cell. In each

130130```

131131

132132If you still don't intuit how this is working, don't worry. We'll take a deeper look into recursion later with our [Recursion walkthrough](../recursion).

133−

134−### [Next Up: Reading -- Nouns](../nouns)

tutorials/hoon/lists.md−2

@@ -332,5 +332,3 @@ Run in dojo:

332332> +snag [2 ~[11 22 33 44]]

33333333

334334```

335−

336−### [Next Up: Walkthrough -- Fibonacci Sequence](../fibonacci)

tutorials/hoon/nouns.md−2

@@ -479,5 +479,3 @@ That's it for our basic introduction to nouns. Hit `ctrl-d` to exit your ship,

479479+ +14

480480+ +15

481481+ +31

482−

483−### [Next Up: Reading -- Hoon Syntax](../hoon-syntax)

tutorials/hoon/recursion.md−1

@@ -193,4 +193,3 @@ Disks are stacked on a pole by decreasing order of size. Move all of the

193193disks from one pole to another with a third pole as a spare, moving one

194194disc at a time, without putting a larger disk on top of a smaller disk.

195195

196−### [Next Up: Reading -- The Subject and its Legs](../the-subject-and-its-legs/)

tutorials/hoon/setup.md−2

@@ -105,5 +105,3 @@ Emacs is free and open-source and runs on all major operating systems. It is ava

105105

106106Vim is free and open-source and runs on all major operating systems. It is available [here](https://www.vim.org/). Hoon support is available with [hoon.vim](https://github.com/urbit/hoon.vim) and is maintained by Tlon.

107107

108−

109−### [Next Up: Walkthrough -- List of Numbers](../list-of-numbers)

tutorials/hoon/structures-and-complex-types.md−1

@@ -354,4 +354,3 @@ Now the `~` value is included as a possible value for `user`.

354354

355355That's all we have to say about types in this chapter. More on types in [Chapter 2](@/docs/tutorials/hoon/type-polymorphism.md).

356356

357−### [Next Up: Walkthrough -- Libraries](../libraries)

tutorials/hoon/the-subject-and-its-legs.md−1

@@ -654,4 +654,3 @@ You can also use more complex wings and modify their values as well:

654654

655655At this point you should have at least a rough idea of what the subject is, and a fair understanding of how to get legs of the subject using wings. But legs are only one kind of limb -- we'll talk about arms in the next lesson.

656656

657−### [Next Up: Walkthrough -- Ackermann Function](../ackermann)

tutorials/hoon/trees-sets-and-maps.md−2

@@ -319,5 +319,3 @@ You can use `run` of `by` to apply a gate to each value in a map, producing a ma

319319```

320320

321321There are other map functions in the Hoon standard library that didn't cover here.

322−

323−### [Next Up: <placeholder>]

tutorials/hoon/type-checking-and-type-inference.md−1

@@ -641,4 +641,3 @@ More subtly, the `=+`, `=/`, and `=|` runes modify the subject by pinning values

641641

642642In general, anything that modifies the subject modifies the type of the subject. Type inference can work in subtle ways for various expressions. However, we have covered enough that it should be relatively clear how to anticipate how type inference works for the vast majority of ordinary use cases.

643643

644−### [Next Up: Reading -- Structures and Complex Types](../structures-and-complex-types)