Table of Contents
- Hoon Syntax - This module will discuss the fundamental data concepts of Hoon and how programs effect control flow.
- Azimuth (Urbit ID) - This module introduces how Urbit ID is structured and provides practice in converting and working with
@pidentity points. (Optional)
- Gates (Functions) - This module will teach you how to produce deferred computations for later use, like functions in other languages.
- Molds (Types) - This module will introduce the Hoon type system and illustrate how type checking and type inference work.
- Cores - This module will introduce the key Hoon data structure known as the core, as well as ramifications.
- Trees and Addressing - This module will elaborate how we can use the structure of nouns to locate data and evaluate code in a given expression. It will also discuss the important
listmold builder and a number of standard library operations.
- Libraries - This module will discuss how libraries can be produced, imported, and used.
- Testing Code - This module will discuss how we can have confidence that a program does what it claims to do, using unit testing and debugging strategies. (Optional)
- Text Processing I - This module will discuss how text is represented in Hoon, discuss tools for producing and manipulating text, and introduce the
%saygenerator, a new generator type.
- Cores & Doors - This module will start by introducing the concept of gate-building gates; then it will expand our notion of cores to include doors; finally it will introduce a common door, the
++map, to illustrate how doors work.
- Data Structures - This module will introduce you to several useful data structures built on the door, then discuss how the compiler handles types and the sample.
- Type Checking - This module will cover how the Hoon compiler infers type, as well as various cases in which a type check is performed.
- Conditional Logic - This module will cover the nature of loobean logic and the rest of the
- Subject-Oriented Programming - This module discusses how Urbit's subject-oriented programming paradigm structures how cores and values are used and maintain state, as well as how deferred computations and remote value lookups (“scrying”) are handled.
- Text Processing II - This module will elaborate on text representation in Hoon, including formatted text, and
- Functional Programming - This module will discuss some gates-that-work-on-gates and other assorted operators that are commonly recognized as functional programming tools.
- Text Processing III - This module will cover text parsing. (Optional)
- Generic and Variant Cores - This module introduces how cores can be extended for different behavioral patterns. (Optional)
- Mathematics - This module introduces how non-
@udmathematics are instrumented in Hoon. (Optional)