Urbit Developers
  • Hoon

    • Overview
    • Cheat Sheet
    • Irregular forms
    • Hoon Errors
    • Hoon Style Guide
    • Basic Types
    • Advanced Types
    • Auras
    • Arvo
    • Standard Library

      • 1a: Basic Arithmetic
      • 1b: Tree Addressing
      • 1c: Molds and Mold-Builders
      • 2a: Unit Logic
      • 2b: List Logic
      • 2c: Bit Arithmetic
      • 2d: Bit Logic
      • 2e: Insecure Hashing
      • 2f: Noun Ordering
      • 2g: Unsigned Powers
      • 2h: Set Logic
      • 2i: Map Logic
      • 2j: Jar and Jug Logic
      • 2k: Queue Logic
      • 2l: Container from Container
      • 2m: Container from Noun
      • 2n: Functional Hacks
      • 2o: Normalizing Containers
      • 2p: Serialization
      • 2q: Molds and Mold-Builders
      • 3a: Modular and Signed Ints
      • 3b: Floating Point
      • 3c: Urbit Time
      • 3d: SHA Hash Family
      • 3e: AES encryption (Removed)
      • 3f: Scrambling
      • 3g: Molds and Mold-Builders
      • 4a: Exotic Bases
      • 4b: Text Processing
      • 4c: Tank Printer
      • 4d: Parsing (Tracing)
      • 4e: Parsing (Combinators)
      • 4f: Parsing (Rule-Builders)
      • 4g: Parsing (Outside Caller)
      • 4h: Parsing (ASCII Glyphs)
      • 4i: Parsing (Useful Idioms)
      • 4j: Parsing (Bases and Base Digits)
      • 4k: Atom Printing
      • 4l: Atom Parsing
      • 4m: Formatting Functions
      • 4n: Virtualization
      • 4o: Molds
      • 5a: Compiler Utilities
      • 5b: Macro Expansion
      • 5c: Compiler Backend & Prettyprinter
      • 5d: Parser
      • 5e: Molds and mold builders
      • 5f: Profiling support
      • Runes

        • Constants (Atoms and Strings)
        • + lus · Arms
        • | bar · Cores
        • $ buc · Structures
        • % cen · Calls
        • : col · Cells
        • . dot · Nock
        • / fas · Imports
        • ^ ket · Casts
        • ; mic · Make
        • ~ sig · Hints
        • = tis · Subject
        • ? wut · Conditionals
        • ! zap · Wild
        • --, == Terminators
        • Limbs and wings

          • Limbs
          • Wings
          • Zuse

            • 2d(1-5): To JSON, Wains
            • 2d(6): From JSON
            • 2d(7): From JSON (unit)
            • 2e(2-3): Print & Parse JSON
            • 2m: Ordered Maps
          • Arvo

            • Overview
            • Ames

              • Overview
              • Cryptography
              • API Reference
              • Scry Reference
              • Data Types
              • Behn

                • Overview
                • API Reference
                • Scry Reference
                • Examples
                • Clay

                  • Overview
                  • Architecture
                  • Using Clay
                  • Data Types
                  • Scry Reference
                  • API Reference
                  • Examples
                  • Marks

                    • Overview
                    • Writing Marks
                    • Using Marks
                    • Examples
                  • Dill

                    • Overview
                    • API Reference
                    • Scry Reference
                    • Data Types
                    • Eyre

                      • Overview
                      • External API Reference
                      • Internal API Reference
                      • Scry Reference
                      • Data Types
                      • Guide
                      • Gall

                        • Overview
                        • API Reference
                        • Data Types
                        • Threads Reference
                        • Iris

                          • Overview
                          • API Reference
                          • Data Types
                          • Example
                          • Jael

                            • Overview
                            • API Reference
                            • Scry Reference
                            • Data Types
                            • Examples
                            • Khan

                              • Overview
                              • API Reference
                              • Data Types
                              • Example
                              • Threads

                                • Overview
                                • HTTP API
                                • Reference
                                • Gall

                                  • Start Thread
                                  • Take Result
                                  • Take Facts
                                  • Stop Thread
                                  • Poke Thread
                                  • Examples

                                    • Fetch JSON
                                    • Child Thread
                                    • Main-loop
                                    • Poke Agent
                                    • Scry
                                    • Take Fact
                                  • Concepts

                                    • Scries
                                    • Subscriptions
                                    • Tutorials

                                      • Move Trace
                                      • Reference

                                        • Cryptography
                                        • Filesystem Hierarchy
                                      • Nock

                                        • Nock Definition
                                        • Explanation
                                        • Example
                                        • Implementations
                                        • Vere

                                          • C Runtime System
                                          • Land of Nouns
                                          • API overview by prefix
                                          • C in Urbit
                                          • Writing Jets
                                          • Cryptography
                                          • Azimuth

                                            • Overview
                                            • Urbit HD Wallet
                                            • Azimuth Data Flow
                                            • Azimuth.eth
                                            • Ecliptic.eth
                                            • Advanced Azimuth Tools
                                            • Life and Rift
                                            • Layer 2

                                              • Layer 2 Overview
                                              • Layer 2 Actions
                                              • Transaction Format
                                              • Rollers
                                              • Roller HTTP RPC-API
                                              • Custom Roller Tutorial
                                            • Glossary

                                              • Agent
                                              • Ames
                                              • API
                                              • Aqua
                                              • Arm
                                              • Arvo
                                              • Atom
                                              • Aura
                                              • Aural ASCII
                                              • Azimuth
                                              • Battery
                                              • Behn
                                              • Bowl
                                              • Bridge
                                              • Bunt
                                              • Card
                                              • Case
                                              • Cask
                                              • Cell
                                              • Censures
                                              • Claims
                                              • Clay
                                              • Cold atom
                                              • Comet
                                              • Commit
                                              • Cons
                                              • Context
                                              • Cord
                                              • Core
                                              • Delegated Sending
                                              • Desk
                                              • Dill
                                              • Document Proposal
                                              • Dojo
                                              • Door
                                              • Double-boot
                                              • Dry Gate
                                              • Duct
                                              • Ecliptic
                                              • Entropy
                                              • Event Log
                                              • Eyre
                                              • Face
                                              • Fact
                                              • Foo Bar Baz
                                              • Galaxy
                                              • Gall
                                              • Garden
                                              • Gate
                                              • Generator
                                              • Gift
                                              • Glob
                                              • HD Wallet
                                              • Helm
                                              • Hood
                                              • Hoon
                                              • Invite Tree
                                              • Iris
                                              • Jael
                                              • Jet
                                              • Kelvin versioning
                                              • Kelvin versioning
                                              • Keyfile
                                              • Keywords
                                              • Khan
                                              • Kiln
                                              • Landscape
                                              • Leg
                                              • List
                                              • Loobean
                                              • Lull
                                              • Mark
                                              • Metals
                                              • Mold
                                              • Monad
                                              • Moon
                                              • Move
                                              • Nock
                                              • Noun
                                              • ~
                                              • OTA Updates
                                              • Path Prefix
                                              • Path
                                              • @p
                                              • Payload
                                              • Peek
                                              • pH
                                              • Pier
                                              • Pill
                                              • Planet
                                              • Poke
                                              • Proxies
                                              • Replay
                                              • Factory Reset
                                              • Roller
                                              • Naive rollups
                                              • Rune
                                              • Runtime
                                              • Sail
                                              • Sample
                                              • Scry
                                              • Senate
                                              • Ship
                                              • Slam
                                              • Spider
                                              • Sponsor
                                              • Star
                                              • String
                                              • Subject Oriented Programming
                                              • Subject
                                              • Subscription
                                              • Tape
                                              • Thread
                                              • Trap
                                              • Udon
                                              • Upgrade Proposal
                                              • Userspace
                                              • Vane
                                              • Vase
                                              • Vere
                                              • Voting
                                              • Warm atom
                                              • Wet Gate
                                              • Wing
                                              • Wire
                                              • Wrapper
                                              • ~zod
                                              • Zuse
                                              • Additional

                                                • Cryptography
                                                • Mips (Maps of Maps)
                                                • Software Distribution

                                                  • Overview
                                                  • Docket File
                                                  • Glob
                                                Urbit Developers
                                                • Hoon

                                                  • Overview
                                                  • Cheat Sheet
                                                  • Irregular forms
                                                  • Hoon Errors
                                                  • Hoon Style Guide
                                                  • Basic Types
                                                  • Advanced Types
                                                  • Auras
                                                  • Arvo
                                                  • Standard Library

                                                    • 1a: Basic Arithmetic
                                                    • 1b: Tree Addressing
                                                    • 1c: Molds and Mold-Builders
                                                    • 2a: Unit Logic
                                                    • 2b: List Logic
                                                    • 2c: Bit Arithmetic
                                                    • 2d: Bit Logic
                                                    • 2e: Insecure Hashing
                                                    • 2f: Noun Ordering
                                                    • 2g: Unsigned Powers
                                                    • 2h: Set Logic
                                                    • 2i: Map Logic
                                                    • 2j: Jar and Jug Logic
                                                    • 2k: Queue Logic
                                                    • 2l: Container from Container
                                                    • 2m: Container from Noun
                                                    • 2n: Functional Hacks
                                                    • 2o: Normalizing Containers
                                                    • 2p: Serialization
                                                    • 2q: Molds and Mold-Builders
                                                    • 3a: Modular and Signed Ints
                                                    • 3b: Floating Point
                                                    • 3c: Urbit Time
                                                    • 3d: SHA Hash Family
                                                    • 3e: AES encryption (Removed)
                                                    • 3f: Scrambling
                                                    • 3g: Molds and Mold-Builders
                                                    • 4a: Exotic Bases
                                                    • 4b: Text Processing
                                                    • 4c: Tank Printer
                                                    • 4d: Parsing (Tracing)
                                                    • 4e: Parsing (Combinators)
                                                    • 4f: Parsing (Rule-Builders)
                                                    • 4g: Parsing (Outside Caller)
                                                    • 4h: Parsing (ASCII Glyphs)
                                                    • 4i: Parsing (Useful Idioms)
                                                    • 4j: Parsing (Bases and Base Digits)
                                                    • 4k: Atom Printing
                                                    • 4l: Atom Parsing
                                                    • 4m: Formatting Functions
                                                    • 4n: Virtualization
                                                    • 4o: Molds
                                                    • 5a: Compiler Utilities
                                                    • 5b: Macro Expansion
                                                    • 5c: Compiler Backend & Prettyprinter
                                                    • 5d: Parser
                                                    • 5e: Molds and mold builders
                                                    • 5f: Profiling support
                                                    • Runes

                                                      • Constants (Atoms and Strings)
                                                      • + lus · Arms
                                                      • | bar · Cores
                                                      • $ buc · Structures
                                                      • % cen · Calls
                                                      • : col · Cells
                                                      • . dot · Nock
                                                      • / fas · Imports
                                                      • ^ ket · Casts
                                                      • ; mic · Make
                                                      • ~ sig · Hints
                                                      • = tis · Subject
                                                      • ? wut · Conditionals
                                                      • ! zap · Wild
                                                      • --, == Terminators
                                                      • Limbs and wings

                                                        • Limbs
                                                        • Wings
                                                        • Zuse

                                                          • 2d(1-5): To JSON, Wains
                                                          • 2d(6): From JSON
                                                          • 2d(7): From JSON (unit)
                                                          • 2e(2-3): Print & Parse JSON
                                                          • 2m: Ordered Maps
                                                        • Arvo

                                                          • Overview
                                                          • Ames

                                                            • Overview
                                                            • Cryptography
                                                            • API Reference
                                                            • Scry Reference
                                                            • Data Types
                                                            • Behn

                                                              • Overview
                                                              • API Reference
                                                              • Scry Reference
                                                              • Examples
                                                              • Clay

                                                                • Overview
                                                                • Architecture
                                                                • Using Clay
                                                                • Data Types
                                                                • Scry Reference
                                                                • API Reference
                                                                • Examples
                                                                • Marks

                                                                  • Overview
                                                                  • Writing Marks
                                                                  • Using Marks
                                                                  • Examples
                                                                • Dill

                                                                  • Overview
                                                                  • API Reference
                                                                  • Scry Reference
                                                                  • Data Types
                                                                  • Eyre

                                                                    • Overview
                                                                    • External API Reference
                                                                    • Internal API Reference
                                                                    • Scry Reference
                                                                    • Data Types
                                                                    • Guide
                                                                    • Gall

                                                                      • Overview
                                                                      • API Reference
                                                                      • Data Types
                                                                      • Threads Reference
                                                                      • Iris

                                                                        • Overview
                                                                        • API Reference
                                                                        • Data Types
                                                                        • Example
                                                                        • Jael

                                                                          • Overview
                                                                          • API Reference
                                                                          • Scry Reference
                                                                          • Data Types
                                                                          • Examples
                                                                          • Khan

                                                                            • Overview
                                                                            • API Reference
                                                                            • Data Types
                                                                            • Example
                                                                            • Threads

                                                                              • Overview
                                                                              • HTTP API
                                                                              • Reference
                                                                              • Gall

                                                                                • Start Thread
                                                                                • Take Result
                                                                                • Take Facts
                                                                                • Stop Thread
                                                                                • Poke Thread
                                                                                • Examples

                                                                                  • Fetch JSON
                                                                                  • Child Thread
                                                                                  • Main-loop
                                                                                  • Poke Agent
                                                                                  • Scry
                                                                                  • Take Fact
                                                                                • Concepts

                                                                                  • Scries
                                                                                  • Subscriptions
                                                                                  • Tutorials

                                                                                    • Move Trace
                                                                                    • Reference

                                                                                      • Cryptography
                                                                                      • Filesystem Hierarchy
                                                                                    • Nock

                                                                                      • Nock Definition
                                                                                      • Explanation
                                                                                      • Example
                                                                                      • Implementations
                                                                                      • Vere

                                                                                        • C Runtime System
                                                                                        • Land of Nouns
                                                                                        • API overview by prefix
                                                                                        • C in Urbit
                                                                                        • Writing Jets
                                                                                        • Cryptography
                                                                                        • Azimuth

                                                                                          • Overview
                                                                                          • Urbit HD Wallet
                                                                                          • Azimuth Data Flow
                                                                                          • Azimuth.eth
                                                                                          • Ecliptic.eth
                                                                                          • Advanced Azimuth Tools
                                                                                          • Life and Rift
                                                                                          • Layer 2

                                                                                            • Layer 2 Overview
                                                                                            • Layer 2 Actions
                                                                                            • Transaction Format
                                                                                            • Rollers
                                                                                            • Roller HTTP RPC-API
                                                                                            • Custom Roller Tutorial
                                                                                          • Glossary

                                                                                            • Agent
                                                                                            • Ames
                                                                                            • API
                                                                                            • Aqua
                                                                                            • Arm
                                                                                            • Arvo
                                                                                            • Atom
                                                                                            • Aura
                                                                                            • Aural ASCII
                                                                                            • Azimuth
                                                                                            • Battery
                                                                                            • Behn
                                                                                            • Bowl
                                                                                            • Bridge
                                                                                            • Bunt
                                                                                            • Card
                                                                                            • Case
                                                                                            • Cask
                                                                                            • Cell
                                                                                            • Censures
                                                                                            • Claims
                                                                                            • Clay
                                                                                            • Cold atom
                                                                                            • Comet
                                                                                            • Commit
                                                                                            • Cons
                                                                                            • Context
                                                                                            • Cord
                                                                                            • Core
                                                                                            • Delegated Sending
                                                                                            • Desk
                                                                                            • Dill
                                                                                            • Document Proposal
                                                                                            • Dojo
                                                                                            • Door
                                                                                            • Double-boot
                                                                                            • Dry Gate
                                                                                            • Duct
                                                                                            • Ecliptic
                                                                                            • Entropy
                                                                                            • Event Log
                                                                                            • Eyre
                                                                                            • Face
                                                                                            • Fact
                                                                                            • Foo Bar Baz
                                                                                            • Galaxy
                                                                                            • Gall
                                                                                            • Garden
                                                                                            • Gate
                                                                                            • Generator
                                                                                            • Gift
                                                                                            • Glob
                                                                                            • HD Wallet
                                                                                            • Helm
                                                                                            • Hood
                                                                                            • Hoon
                                                                                            • Invite Tree
                                                                                            • Iris
                                                                                            • Jael
                                                                                            • Jet
                                                                                            • Kelvin versioning
                                                                                            • Kelvin versioning
                                                                                            • Keyfile
                                                                                            • Keywords
                                                                                            • Khan
                                                                                            • Kiln
                                                                                            • Landscape
                                                                                            • Leg
                                                                                            • List
                                                                                            • Loobean
                                                                                            • Lull
                                                                                            • Mark
                                                                                            • Metals
                                                                                            • Mold
                                                                                            • Monad
                                                                                            • Moon
                                                                                            • Move
                                                                                            • Nock
                                                                                            • Noun
                                                                                            • ~
                                                                                            • OTA Updates
                                                                                            • Path Prefix
                                                                                            • Path
                                                                                            • @p
                                                                                            • Payload
                                                                                            • Peek
                                                                                            • pH
                                                                                            • Pier
                                                                                            • Pill
                                                                                            • Planet
                                                                                            • Poke
                                                                                            • Proxies
                                                                                            • Replay
                                                                                            • Factory Reset
                                                                                            • Roller
                                                                                            • Naive rollups
                                                                                            • Rune
                                                                                            • Runtime
                                                                                            • Sail
                                                                                            • Sample
                                                                                            • Scry
                                                                                            • Senate
                                                                                            • Ship
                                                                                            • Slam
                                                                                            • Spider
                                                                                            • Sponsor
                                                                                            • Star
                                                                                            • String
                                                                                            • Subject Oriented Programming
                                                                                            • Subject
                                                                                            • Subscription
                                                                                            • Tape
                                                                                            • Thread
                                                                                            • Trap
                                                                                            • Udon
                                                                                            • Upgrade Proposal
                                                                                            • Userspace
                                                                                            • Vane
                                                                                            • Vase
                                                                                            • Vere
                                                                                            • Voting
                                                                                            • Warm atom
                                                                                            • Wet Gate
                                                                                            • Wing
                                                                                            • Wire
                                                                                            • Wrapper
                                                                                            • ~zod
                                                                                            • Zuse
                                                                                            • Additional

                                                                                              • Cryptography
                                                                                              • Mips (Maps of Maps)
                                                                                              • Software Distribution

                                                                                                • Overview
                                                                                                • Docket File
                                                                                                • Glob
                                                                                              Reference/Hoon/Runes

                                                                                              ; mic · Make

                                                                                              Miscellaneous useful macros.

                                                                                              ;: "miccol"

                                                                                              Call a binary function as an n-ary function.

                                                                                              Syntax

                                                                                              One fixed argument, then a variable number of arguments.

                                                                                              FormSyntax
                                                                                              Tall
                                                                                              ;: p
                                                                                              q1
                                                                                              q2
                                                                                              qn
                                                                                              ==
                                                                                              Wide
                                                                                              ;:(p q1 q2 qn)
                                                                                              Irregular
                                                                                              :(p q1 q2 qn)

                                                                                              AST

                                                                                              [%mccl p=hoon q=(list hoon)]

                                                                                              Expands to

                                                                                              Pseudocode: a, b, c, ... as elements of q:

                                                                                              Regular form:

                                                                                              %-(p a %-(p b %-(p c ...)))

                                                                                              Irregular form:

                                                                                              (p a (p b (p c ...)))

                                                                                              Desugaring

                                                                                              |-
                                                                                              ?~ q !!
                                                                                              ?~ t.q !!
                                                                                              ?~ t.t.q
                                                                                              (p i.q i.t.q)
                                                                                              (p i.q $(q t.q))

                                                                                              Examples

                                                                                              > (add 3 (add 4 5))
                                                                                              12
                                                                                              > ;:(add 3 4 5)
                                                                                              12
                                                                                              > :(add 3 4 5)
                                                                                              12
                                                                                              > `@t`:((cury cat 3) 'a' 'b' 'c' 'd')
                                                                                              'abcd'

                                                                                              ;< "micgal"

                                                                                              Monadic do notation.

                                                                                              Syntax

                                                                                              Four arguments, fixed.

                                                                                              FormSyntax
                                                                                              Tall
                                                                                              ;< mold bind expr1 expr2
                                                                                              Wide
                                                                                              ;<(mold bind expr1 expr2)
                                                                                              IrregularNone.

                                                                                              AST

                                                                                              [%mcgl p=spec q=hoon r=hoon s=hoon]

                                                                                              Semantics

                                                                                              A ;< is for sequencing two computations, expr1 and expr2, using a provided implementation of monadic bind. This rune takes a gate bind which takes a mold mold and produces an implementation of monadic bind.

                                                                                              Desugaring

                                                                                              %+ (bind mold)
                                                                                              expr1
                                                                                              |= mold
                                                                                              expr2

                                                                                              Discussion

                                                                                              ;< is much like Haskell do notation. You have a sequence of events you'd like to run such that each past the first depends on the output of the previous one. The output of the previous one may not be of the correct type to use as an input to the next one, and so an adapter such as +biff is needed.

                                                                                              ;< differs from ;~ in that it takes a gate which takes a mold that produces an implementation of monadic bind, rather than taking an implementation of monadic bind directly.

                                                                                              ;< can be used to glue a pipeline together to run an asynchronous function or event. This can be helpful when deferring parts of a computation based on external data.

                                                                                              We remark that you can switch binds in the middle of a sequence of ;<.

                                                                                              Examples

                                                                                              +biff is the unit monad's implementation of monadic bind. That is to say, it takes a unit a and a gate b that accepts a noun that produces a unit, and extracts the value from a to pass as a sample to b.

                                                                                              We illustrate the usage of ;< with +biff with a map of atoms:

                                                                                              > =m (my ~[[1 3] [2 2] [3 1]])
                                                                                              > (~(get by m) 1)
                                                                                              [~ 3]

                                                                                              A single usage of ;< only serves to apply the binding function to the output of expr1:

                                                                                              > ;< [email protected] _biff (~(get by m) 1)
                                                                                              a
                                                                                              3

                                                                                              Here we see the result of chaining them together:

                                                                                              > ;< [email protected] _biff (~(get by m) 1)
                                                                                              ;< [email protected] _biff (~(get by m) a)
                                                                                              b
                                                                                              1

                                                                                              ;+ "miclus"

                                                                                              make a single XML node (Sail)

                                                                                              Syntax

                                                                                              One argument, fixed.

                                                                                              FormSyntax
                                                                                              Tall
                                                                                              ;+ p
                                                                                              Wide
                                                                                              ;+(p)
                                                                                              IrregularNone.

                                                                                              p is a Hoon expression that produces a manx.

                                                                                              Produces

                                                                                              A marl, i.e., a list of manx. A manx is a noun that represents a single XML node.

                                                                                              Discussion

                                                                                              tl;dr -- ;+ converts a manx to a marl.

                                                                                              ;+ is a Sail rune. Sail is a part of Hoon used for creating and operating on nouns that represent XML nodes. With the appropriate rendering pipeline, a Sail document can be used to generate a static website.

                                                                                              In Sail a single XML node is represented by a manx. A single <p> node manx can be produced in the following way:

                                                                                              > ;p: This will be rendered as an XML node.
                                                                                              [[%p ~] [[%$ [%$ "This will be rendered as an XML node."] ~] ~] ~]

                                                                                              Sometimes what is needed is a marl, i.e., a list of manx. To convert a single manx to a marl, use the ;+ rune.

                                                                                              One interesting thing about Sail is that it allows you to use complex Hoon expressions to choose from among several nodes to render. The ;+ rune can take such a complex expression.

                                                                                              Examples

                                                                                              > ^- marl
                                                                                              ;+ ?: (gth 3 2)
                                                                                              ;p: This is the node for 'yes'.
                                                                                              ;p: This is the node for 'no'.
                                                                                              ~[
                                                                                              [ g=[n=%p a=~]
                                                                                              c=[i=[g=[n=%$ a=~[[n=%$ v="This is the node for 'yes'."]]] c=~] t=~]
                                                                                              ]
                                                                                              ]
                                                                                              > ^- marl
                                                                                              ;+ ?: (gth 2 3)
                                                                                              ;p: This is the node for 'yes'.
                                                                                              ;p: This is the node for 'no'.
                                                                                              ~[
                                                                                              [ g=[n=%p a=~]
                                                                                              c=[i=[g=[n=%$ a=~[[n=%$ v="This is the node for 'no'."]]] c=~] t=~]
                                                                                              ]
                                                                                              ]

                                                                                              ;; "micmic"

                                                                                              Normalize with a mold, asserting fixpoint.

                                                                                              Syntax

                                                                                              Two arguments, fixed.

                                                                                              FormSyntax
                                                                                              Tall
                                                                                              ;; p
                                                                                              q
                                                                                              Wide
                                                                                              ;;(p q)
                                                                                              IrregularNone.

                                                                                              AST

                                                                                              [%mcmc p=spec q=hoon]

                                                                                              Expands to

                                                                                              =+ a=(p q)
                                                                                              ?> =(`*`a `*`q)
                                                                                              a

                                                                                              Note: the expansion implementation is hygienic -- it doesn't actually add the a face to the subject.

                                                                                              Examples

                                                                                              Fails because of auras:

                                                                                              > ^-(tape ~[97 98 99])
                                                                                              mint-nice
                                                                                              -need.?(%~ [[email protected] t=""])
                                                                                              -have.[@ud @ud @ud %~]
                                                                                              nest-fail
                                                                                              dojo: hoon expression failed

                                                                                              Succeeds because molds don't care about auras:

                                                                                              > ;;(tape ~[97 98 99])
                                                                                              "abc"

                                                                                              Fails because not a fixpoint:

                                                                                              > ;;(tape [50 51 52])
                                                                                              dojo: hoon expression failed

                                                                                              ;/ "micfas"

                                                                                              Tape as XML element.

                                                                                              Syntax

                                                                                              One argument, fixed.

                                                                                              FormSyntax
                                                                                              Tall
                                                                                              ;/ p
                                                                                              Wide
                                                                                              ;/(p)
                                                                                              IrregularNone.

                                                                                              AST

                                                                                              [%mcnt p=hoon]

                                                                                              Expands to

                                                                                              ~[%$ ~[%$ 'p']]

                                                                                              Examples

                                                                                              > ;/ "foo"
                                                                                              [[%~. [%~. "foo"] ~] ~]

                                                                                              ;~ "micsig"

                                                                                              Glue a pipeline together with a product-sample adapter.

                                                                                              Syntax

                                                                                              One fixed argument, then a variable number of arguments.

                                                                                              FormSyntax
                                                                                              Tall
                                                                                              ;~ p
                                                                                              q1
                                                                                              q2
                                                                                              qn
                                                                                              ==
                                                                                              Wide
                                                                                              ;~(p q1 q2 qn)
                                                                                              IrregularNone.

                                                                                              AST

                                                                                              [%mcsg p=hoon q=(list hoon)]

                                                                                              Produces

                                                                                              The gates in q are composed together using the gate p as an intermediate function, which transforms a q product and a q gate into a q sample.

                                                                                              Expands to

                                                                                              Note: these are structurally correct, but elide some type-system complexity.

                                                                                              ;~(a b) reduces to b.

                                                                                              ;~(a b c) expands to

                                                                                              |= arg=*
                                                                                              (a (b arg) c(+6 arg))

                                                                                              ;~(a b c d) expands to

                                                                                              |= arg=*
                                                                                              %+ a (b arg)
                                                                                              =+ arg=arg
                                                                                              |. (a (c arg) d(+6 arg))

                                                                                              Desugaring

                                                                                              ?~ q !!
                                                                                              |-
                                                                                              ?~ t.q i.q
                                                                                              =/ a $(q t.q)
                                                                                              =/ b i.q
                                                                                              =/ c ,.+6.b
                                                                                              |. (p (b c) a(,.+6 c))

                                                                                              Discussion

                                                                                              Apparently ;~ is a "Kleisli arrow." It's also a close cousin of the infamous "monad." Don't let that bother you. Hoon doesn't know anything about category theory, so you don't need to either.

                                                                                              ;~ is often used in parsers, but is not only for parsers.

                                                                                              This can be thought of as user-defined function composition; instead of simply nesting the gates in q, each is passed individually to p with the product of the previous gate, allowing arbitrary filtering, transformation, or conditional application.

                                                                                              Examples

                                                                                              A simple "parser." trip converts a cord (atomic string) to a tape (linked string).

                                                                                              > =cmp |=([a=tape b=$-(char tape)] `tape`?~(a ~ (weld (b i.a) t.a)))
                                                                                              > ;~(cmp trip)
                                                                                              <1.zje {a/@ <409.yxa 110.lxv 1.ztu $151>}>

                                                                                              With just one gate in the pipeline q, the glue p is unused:

                                                                                              > (;~(cmp trip) 'a')
                                                                                              "a"

                                                                                              But for multiple gates, we need it to connect the pipeline:

                                                                                              > (;~(cmp trip |=([email protected] ~[a a])) 'a')
                                                                                              "aa"
                                                                                              > (;~(cmp trip |=([email protected] ~[a a])) '')
                                                                                              ""

                                                                                              A more complicated example:

                                                                                              > (;~(cmp trip ;~(cmp |=([email protected] ~[a a]) |=([email protected] <(dec a)>))) 'b')
                                                                                              "97b"
                                                                                              > (;~(cmp trip |=([email protected] ~[a a]) |=([email protected] <(dec a)>)) 'b')
                                                                                              "97b"
                                                                                              > (;~(cmp trip |=([email protected] ~[a a]) |=([email protected] <(dec a)>)) '')
                                                                                              ""
                                                                                              > (;~(cmp trip |=([email protected] ~[a a]) |=([email protected] <(dec a)>)) 'a')
                                                                                              "96a"
                                                                                              > (;~(cmp trip |=([email protected] ~[a a]) |=([email protected] <(dec a)>)) 'acd')
                                                                                              "96acd"

                                                                                              ;* "mictar"

                                                                                              make a list of XML nodes from complex Hoon expression (Sail)

                                                                                              Syntax

                                                                                              One argument, fixed.

                                                                                              FormSyntax
                                                                                              Tall
                                                                                              ;* p
                                                                                              Wide
                                                                                              ;*(p)
                                                                                              IrregularNone.

                                                                                              p is a Hoon expression that produces a marl.

                                                                                              Produces

                                                                                              A marl, i.e., a list of manx. A manx is a noun that represents a single XML node.

                                                                                              Discussion

                                                                                              ;* is a Sail rune. Sail is a part of Hoon used for creating and operating on nouns that represent XML nodes. With the appropriate rendering pipeline, a Sail document can be used to generate a static website.

                                                                                              If you need a complex Hoon expression to produce a marl, use the ;* rune. Often this rune is used with an expression, p, that includes one or more ;= subexpressions.

                                                                                              (See also ;=.)

                                                                                              Examples

                                                                                              > ;* ?: (gth 3 2)
                                                                                              ;= ;p: This is node 1 of 'yes'.
                                                                                              ;p: This is node 2 of 'yes'.
                                                                                              ==
                                                                                              ;= ;p: This is node 1 of 'no'.
                                                                                              ;p: This is node 2 of 'no'.
                                                                                              ==
                                                                                              [ [[%p ~] [[%$ [%$ "This is node 1 of 'yes'."] ~] ~] ~]
                                                                                              [[[%p ~] [[%$ [%$ "This is node 2 of 'yes'."] ~] ~] ~] ~]
                                                                                              ]
                                                                                              > ;* ?: (gth 2 3)
                                                                                              ;= ;p: This is node 1 of 'yes'.
                                                                                              ;p: This is node 2 of 'yes'.
                                                                                              ==
                                                                                              ;= ;p: This is node 1 of 'no'.
                                                                                              ;p: This is node 2 of 'no'.
                                                                                              ==
                                                                                              [ [[%p ~] [[%$ [%$ "This is node 1 of 'no'."] ~] ~] ~]
                                                                                              [[[%p ~] [[%$ [%$ "This is node 2 of 'no'."] ~] ~] ~] ~]
                                                                                              ]

                                                                                              ;= "mictis"

                                                                                              make a list of XML nodes (Sail)

                                                                                              Syntax

                                                                                              A variable number of arguments.

                                                                                              FormSyntax
                                                                                              Tall
                                                                                              ;= p1
                                                                                              p2
                                                                                              p3
                                                                                              pn
                                                                                              ==
                                                                                              Wide
                                                                                              ;=(p1 p2 p3 pn)
                                                                                              IrregularNone.

                                                                                              p1-pn are Hoon expressions, each of which poduces a manx.

                                                                                              Produces

                                                                                              A marl, i.e., a list of manx. A manx is a noun that represents a single XML node.

                                                                                              Discussion

                                                                                              ;= is a Sail rune. Sail is a part of Hoon used for creating and operating on nouns that represent XML nodes. With the appropriate rendering pipeline, a Sail document can be used to generate a static website.

                                                                                              In Sail a single XML node is represented by a manx. A single <p> node manx can be produced in the following way:

                                                                                              > ;p: This will be rendered as an XML node.
                                                                                              [[%p ~] [[%$ [%$ "This will be rendered as an XML node."] ~] ~] ~]

                                                                                              Sometimes what is needed is a marl, i.e., a list of manx. To convert a series of manx nodes to a marl, use the ;= rune.

                                                                                              (See also ;*.)

                                                                                              Examples

                                                                                              > ;= ;p: This is the first node.
                                                                                              ;p: This is the second.
                                                                                              ;p: Here is the last one.
                                                                                              ==
                                                                                              [ [[%p ~] [[%$ [%$ "This is the first node."] ~] ~] ~]
                                                                                              [[%p ~] [[%$ [%$ "This is the second."] ~] ~] ~]
                                                                                              [[%p ~] [[%$ [%$ "Here is the last one."] ~] ~] ~]
                                                                                              ~
                                                                                              ]

                                                                                              <-

                                                                                              ^ ket · Casts

                                                                                              ~ sig · Hints

                                                                                              ->

                                                                                              Edit this page on GitHub

                                                                                              Last modified March 29, 2023