d02bac7 · urbit.org · git.iko.soy

tutorials/hoon/ackermann.md−3

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

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

28

29This 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

485

486> c

487-find.c

488−```

488+```

489−

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

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

775

776They are indeed the same.

777

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

78`+>` 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.

79

80It'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.

343possible unshifted `tapes`.

344

3454. 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

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

72

73To 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

502## Conclusion

503

504You'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

117`~&` 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.

118

119Finally, 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

59```

60

61The 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`

193Ford 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.

194

195One 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

269> (double 25)

27050

271```

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:

325`~&` (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.

326

327But 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:

86Here `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.

87

88The 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`

153```

154

155This 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

181If 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.

182

183Below `/+ 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

130```

131

132If 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:

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

33333

334```

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,

479+ +14

480+ +15

481+ +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

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

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

195

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

105

106Vim 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.

107

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`.

354

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

356

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:

654

655At 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.

656

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

319```

320

321There 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

641

642In 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.

643

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