Urbit
  • Introduction
  • Development

    • Getting Started
    • Environment Setup
    • Grants Program
    • Project Repositories
    • Precepts
    • System Overview

      • Arvo
      • Hoon
      • Nock
      • Vere
      • Azimuth
      • Cryptography
      • Arvo

        • Overview
        • Reference

          • Cryptography
          • Filesystem Hierarchy
          • Ames

            • Overview
            • Cryptography
            • API Reference
            • Behn

              • Overview
              • API Reference
              • Clay

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

                  • Overview
                  • API Reference
                  • Eyre

                    • Overview
                    • External API Reference
                    • Internal API Reference
                    • Scry Reference
                    • Data Types
                    • Examples
                    • Ford

                      • Overview
                      • Gall

                        • Overview
                        • Iris

                          • API Reference
                          • Jael

                            • API Reference
                            • Concepts

                              • Subscriptions
                              • Tutorials

                                • Move Trace
                              • Userspace

                                • Overview
                                • Gall

                                  • Overview
                                  • Tutorial
                                  • API Reference
                                  • Graph Store

                                    • Graph Store Overview
                                    • Data Structure Overview
                                    • Validator Walkthrough
                                    • Advanced Info
                                    • Threads

                                      • Overview
                                      • HTTP API
                                      • Reference
                                      • Basics

                                        • Fundamentals
                                        • Bind
                                        • Input
                                        • Output
                                        • Summary
                                        • Gall

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

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

                                            • Overview
                                            • API Reference

                                              • Graph Store
                                          • Hoon

                                            • Overview
                                            • Hoon School

                                              • 1.1 Setup
                                              • 1.1.1 Walkthrough: List of Numbers
                                              • 1.2 Nouns
                                              • 1.3 Hoon Syntax
                                              • 1.3.1 Walkthrough: Conditionals
                                              • 1.4 Gates (Hoon Functions)
                                              • 1.4.1 Walkthrough: Recursion
                                              • 1.5 Lists
                                              • 1.5.1 Walkthrough: Fibonacci Sequence
                                              • 1.6 The Subject and Its Legs
                                              • 1.6.1 Walkthrough: Ackermann Function
                                              • 1.7 Arms and Cores
                                              • 1.7.1 Walkthrough: Caesar Cipher
                                              • 1.8 Doors
                                              • 1.8.1 Bank Account
                                              • 1.9 Generators
                                              • 2.1 Atoms, Auras, and Simple Cell Types
                                              • 2.2 Type Checking and Type Inference
                                              • 2.3 Structures and Complex Types
                                              • 2.3.1 Walkthrough: Libraries
                                              • 2.3.2 Molds
                                              • 2.4 Standard Library: Trees, Sets, and Maps
                                              • 2.5 Type Polymorphism
                                              • 2.5.1 Walkthrough: Iron Polymorphism and Wet Polymorphism
                                              • 2.5.2 Walkthrough: Lead Polymorphism
                                              • 2.6 Behn
                                              • 2.7 Gall
                                              • 2.7.1 Gall Walkthrough: Egg Timer
                                              • Guides

                                                • CLI apps
                                                • Parsing
                                                • Writing Aqua Tests
                                                • Reference

                                                  • Cheat Sheet
                                                  • Irregular forms
                                                  • Hoon Errors
                                                  • Hoon Style Guide
                                                  • Basic Types
                                                  • Advanced Types
                                                  • Auras
                                                  • Runes

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

                                                      • Limbs
                                                      • Wings
                                                      • Standard library

                                                        • Table of Contents
                                                        • 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: Caching Compiler
                                                        • 5f: Molds and Mold-Builders
                                                        • 5g: profiling support
                                                    • 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
                                                          • Life and Rift
                                                          • Advanced Azimuth Tools
                                                          • Glossary

                                                            • Ames
                                                            • Aqua
                                                            • Arm
                                                            • Arvo
                                                            • Atom
                                                            • Azimuth
                                                            • Battery
                                                            • Behn
                                                            • Breach
                                                            • Bridge
                                                            • Censures
                                                            • Ceremony
                                                            • chat
                                                            • Claims
                                                            • Clay
                                                            • Comet
                                                            • Core
                                                            • Delegated Sending
                                                            • Desk
                                                            • Dill
                                                            • Document Proposal
                                                            • Dojo
                                                            • Door
                                                            • Ecliptic
                                                            • Event Log
                                                            • Eyre
                                                            • Ford
                                                            • Galaxy
                                                            • Gall
                                                            • Gate
                                                            • HD Wallet
                                                            • Hoon
                                                            • Invite Tree
                                                            • Iris
                                                            • Jael
                                                            • Jaque
                                                            • Keyfile
                                                            • Landscape
                                                            • Mark
                                                            • Moon
                                                            • Nock
                                                            • Noun
                                                            • OTA Updates
                                                            • Payload
                                                            • pH
                                                            • Pier
                                                            • Pill
                                                            • Planet
                                                            • Proxies
                                                            • Replay
                                                            • Sail/Udon
                                                            • Senate
                                                            • Ship
                                                            • ship.arvo.network
                                                            • Star
                                                            • |sync
                                                            • Trap
                                                            • Upgrade Proposal
                                                            • Vane
                                                            • Vere
                                                            • Voting
                                                            • Wallet-Generator
                                                            Urbit
                                                            • Introduction
                                                            • Development

                                                              • Getting Started
                                                              • Environment Setup
                                                              • Grants Program
                                                              • Project Repositories
                                                              • Precepts
                                                              • System Overview

                                                                • Arvo
                                                                • Hoon
                                                                • Nock
                                                                • Vere
                                                                • Azimuth
                                                                • Cryptography
                                                                • Arvo

                                                                  • Overview
                                                                  • Reference

                                                                    • Cryptography
                                                                    • Filesystem Hierarchy
                                                                    • Ames

                                                                      • Overview
                                                                      • Cryptography
                                                                      • API Reference
                                                                      • Behn

                                                                        • Overview
                                                                        • API Reference
                                                                        • Clay

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

                                                                            • Overview
                                                                            • API Reference
                                                                            • Eyre

                                                                              • Overview
                                                                              • External API Reference
                                                                              • Internal API Reference
                                                                              • Scry Reference
                                                                              • Data Types
                                                                              • Examples
                                                                              • Ford

                                                                                • Overview
                                                                                • Gall

                                                                                  • Overview
                                                                                  • Iris

                                                                                    • API Reference
                                                                                    • Jael

                                                                                      • API Reference
                                                                                      • Concepts

                                                                                        • Subscriptions
                                                                                        • Tutorials

                                                                                          • Move Trace
                                                                                        • Userspace

                                                                                          • Overview
                                                                                          • Gall

                                                                                            • Overview
                                                                                            • Tutorial
                                                                                            • API Reference
                                                                                            • Graph Store

                                                                                              • Graph Store Overview
                                                                                              • Data Structure Overview
                                                                                              • Validator Walkthrough
                                                                                              • Advanced Info
                                                                                              • Threads

                                                                                                • Overview
                                                                                                • HTTP API
                                                                                                • Reference
                                                                                                • Basics

                                                                                                  • Fundamentals
                                                                                                  • Bind
                                                                                                  • Input
                                                                                                  • Output
                                                                                                  • Summary
                                                                                                  • Gall

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

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

                                                                                                      • Overview
                                                                                                      • API Reference

                                                                                                        • Graph Store
                                                                                                    • Hoon

                                                                                                      • Overview
                                                                                                      • Hoon School

                                                                                                        • 1.1 Setup
                                                                                                        • 1.1.1 Walkthrough: List of Numbers
                                                                                                        • 1.2 Nouns
                                                                                                        • 1.3 Hoon Syntax
                                                                                                        • 1.3.1 Walkthrough: Conditionals
                                                                                                        • 1.4 Gates (Hoon Functions)
                                                                                                        • 1.4.1 Walkthrough: Recursion
                                                                                                        • 1.5 Lists
                                                                                                        • 1.5.1 Walkthrough: Fibonacci Sequence
                                                                                                        • 1.6 The Subject and Its Legs
                                                                                                        • 1.6.1 Walkthrough: Ackermann Function
                                                                                                        • 1.7 Arms and Cores
                                                                                                        • 1.7.1 Walkthrough: Caesar Cipher
                                                                                                        • 1.8 Doors
                                                                                                        • 1.8.1 Bank Account
                                                                                                        • 1.9 Generators
                                                                                                        • 2.1 Atoms, Auras, and Simple Cell Types
                                                                                                        • 2.2 Type Checking and Type Inference
                                                                                                        • 2.3 Structures and Complex Types
                                                                                                        • 2.3.1 Walkthrough: Libraries
                                                                                                        • 2.3.2 Molds
                                                                                                        • 2.4 Standard Library: Trees, Sets, and Maps
                                                                                                        • 2.5 Type Polymorphism
                                                                                                        • 2.5.1 Walkthrough: Iron Polymorphism and Wet Polymorphism
                                                                                                        • 2.5.2 Walkthrough: Lead Polymorphism
                                                                                                        • 2.6 Behn
                                                                                                        • 2.7 Gall
                                                                                                        • 2.7.1 Gall Walkthrough: Egg Timer
                                                                                                        • Guides

                                                                                                          • CLI apps
                                                                                                          • Parsing
                                                                                                          • Writing Aqua Tests
                                                                                                          • Reference

                                                                                                            • Cheat Sheet
                                                                                                            • Irregular forms
                                                                                                            • Hoon Errors
                                                                                                            • Hoon Style Guide
                                                                                                            • Basic Types
                                                                                                            • Advanced Types
                                                                                                            • Auras
                                                                                                            • Runes

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

                                                                                                                • Limbs
                                                                                                                • Wings
                                                                                                                • Standard library

                                                                                                                  • Table of Contents
                                                                                                                  • 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: Caching Compiler
                                                                                                                  • 5f: Molds and Mold-Builders
                                                                                                                  • 5g: profiling support
                                                                                                              • 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
                                                                                                                    • Life and Rift
                                                                                                                    • Advanced Azimuth Tools
                                                                                                                    • Glossary

                                                                                                                      • Ames
                                                                                                                      • Aqua
                                                                                                                      • Arm
                                                                                                                      • Arvo
                                                                                                                      • Atom
                                                                                                                      • Azimuth
                                                                                                                      • Battery
                                                                                                                      • Behn
                                                                                                                      • Breach
                                                                                                                      • Bridge
                                                                                                                      • Censures
                                                                                                                      • Ceremony
                                                                                                                      • chat
                                                                                                                      • Claims
                                                                                                                      • Clay
                                                                                                                      • Comet
                                                                                                                      • Core
                                                                                                                      • Delegated Sending
                                                                                                                      • Desk
                                                                                                                      • Dill
                                                                                                                      • Document Proposal
                                                                                                                      • Dojo
                                                                                                                      • Door
                                                                                                                      • Ecliptic
                                                                                                                      • Event Log
                                                                                                                      • Eyre
                                                                                                                      • Ford
                                                                                                                      • Galaxy
                                                                                                                      • Gall
                                                                                                                      • Gate
                                                                                                                      • HD Wallet
                                                                                                                      • Hoon
                                                                                                                      • Invite Tree
                                                                                                                      • Iris
                                                                                                                      • Jael
                                                                                                                      • Jaque
                                                                                                                      • Keyfile
                                                                                                                      • Landscape
                                                                                                                      • Mark
                                                                                                                      • Moon
                                                                                                                      • Nock
                                                                                                                      • Noun
                                                                                                                      • OTA Updates
                                                                                                                      • Payload
                                                                                                                      • pH
                                                                                                                      • Pier
                                                                                                                      • Pill
                                                                                                                      • Planet
                                                                                                                      • Proxies
                                                                                                                      • Replay
                                                                                                                      • Sail/Udon
                                                                                                                      • Senate
                                                                                                                      • Ship
                                                                                                                      • ship.arvo.network
                                                                                                                      • Star
                                                                                                                      • |sync
                                                                                                                      • Trap
                                                                                                                      • Upgrade Proposal
                                                                                                                      • Vane
                                                                                                                      • Vere
                                                                                                                      • Voting
                                                                                                                      • Wallet-Generator
                                                                                                                      Urbit/Documentation/Hoon/Reference/Standard library

                                                                                                                      4h: Parsing (ASCII Glyphs)

                                                                                                                      ++ace

                                                                                                                      Parse space

                                                                                                                      Parses ASCII character 32, space.

                                                                                                                      Source

                                                                                                                      ++  ace  (just ' ')
                                                                                                                      

                                                                                                                      Examples

                                                                                                                          > (scan " " ace)
                                                                                                                          ~~.
                                                                                                                      
                                                                                                                          > `cord`
                                                                                                                          (scan " " ace)
                                                                                                                          ' '
                                                                                                                      
                                                                                                                          > (ace [[1 1] " "])
                                                                                                                          [p=[p=1 q=2] q=[~ [p=~~. q=[p=[p=1 q=2] q=""]]]]
                                                                                                                      
                                                                                                                          > (ace [[1 1] " abc "])
                                                                                                                          [p=[p=1 q=2] q=[~ [p=~~. q=[p=[p=1 q=2] q="abc "]]]]

                                                                                                                      ++bar

                                                                                                                      Parse vertical bar

                                                                                                                      Parses ASCII character 124, the vertical bar.

                                                                                                                      Source

                                                                                                                      ++  bar  (just '|')
                                                                                                                      

                                                                                                                      Examples

                                                                                                                          > (scan "|" bar)
                                                                                                                          ~~~7c.
                                                                                                                      
                                                                                                                          > `cord`(scan "|" bar)
                                                                                                                          '|'
                                                                                                                      
                                                                                                                          > (bar [[1 1] "|"])
                                                                                                                          [p=[p=1 q=2] q=[~ [p=~~~7c. q=[p=[p=1 q=2] q=""]]]]
                                                                                                                      
                                                                                                                          > (bar [[1 1] "|="])
                                                                                                                          [p=[p=1 q=2] q=[~ [p=~~~7c. q=[p=[p=1 q=2] q="="]]]]

                                                                                                                      ++bas

                                                                                                                      Parse backslash

                                                                                                                      Parses ASCII character 92, the backslash. Note the extra \ in the calling of bas with ++just is to escape the escape character, \.

                                                                                                                      Source

                                                                                                                      ++  bas  (just '\\')
                                                                                                                      

                                                                                                                      Examples

                                                                                                                          > (scan "\\" bas)
                                                                                                                          ~~~5c.
                                                                                                                      
                                                                                                                          > `cord`(scan "\\" bas)
                                                                                                                          '\'
                                                                                                                      
                                                                                                                          > (bas [[1 1] "\"])
                                                                                                                          ~ <syntax error at [1 18]>
                                                                                                                      
                                                                                                                          > (bas [[1 1] "\\"])
                                                                                                                          [p=[p=1 q=2] q=[~ [p=~~~5c. q=[p=[p=1 q=2] q=""]]]]
                                                                                                                      
                                                                                                                          > (bas [[1 1] "\""])
                                                                                                                          [p=[p=1 q=1] q=~]

                                                                                                                      ++buc

                                                                                                                      Parse dollar sign

                                                                                                                      Parses ASCII character 36, the dollar sign.

                                                                                                                      Source

                                                                                                                      ++  buc  (just '$')
                                                                                                                      

                                                                                                                      Examples

                                                                                                                          > (scan "$" buc)
                                                                                                                          ~~~24.
                                                                                                                      
                                                                                                                          > `cord`(scan "$" buc)
                                                                                                                          '$'
                                                                                                                      
                                                                                                                          > (buc [[1 1] "$"])
                                                                                                                          [p=[p=1 q=2] q=[~ [p=~~~24. q=[p=[p=1 q=2] q=""]]]]
                                                                                                                      
                                                                                                                          > (buc [[1 1] "$%"])
                                                                                                                          [p=[p=1 q=2] q=[~ [p=~~~24. q=[p=[p=1 q=2] q="%"]]]]

                                                                                                                      ++cab

                                                                                                                      Parse underscore

                                                                                                                      Parses ASCII character 95, the underscore.

                                                                                                                      Source

                                                                                                                      ++  cab  (just '_')
                                                                                                                      

                                                                                                                      Examples

                                                                                                                          > (scan "_" cab)
                                                                                                                          ~~~5f.
                                                                                                                      
                                                                                                                          > `cord`(scan "_" cab)
                                                                                                                          '_'
                                                                                                                      
                                                                                                                          > (cab [[1 1] "_"])
                                                                                                                          [p=[p=1 q=2] q=[~ [p=~~~5f. q=[p=[p=1 q=2] q=""]]]]
                                                                                                                      
                                                                                                                          > (cab [[1 1] "|_"])
                                                                                                                          [p=[p=1 q=1] q=~]

                                                                                                                      ++cen

                                                                                                                      Parses percent sign

                                                                                                                      Parses ASCII character 37, the percent sign.

                                                                                                                      Source

                                                                                                                      ++  cen  (just '%')
                                                                                                                      

                                                                                                                      Examples

                                                                                                                          > (scan "%" cen)
                                                                                                                          ~~~25.
                                                                                                                      
                                                                                                                          > `cord`(scan "%" cen)
                                                                                                                          '%'
                                                                                                                      
                                                                                                                          > (cen [[1 1] "%"])
                                                                                                                          [p=[p=1 q=2] q=[~ [p=~~~25. q=[p=[p=1 q=2] q=""]]]]
                                                                                                                      
                                                                                                                          > (cen [[1 1] "%^"])
                                                                                                                          [p=[p=1 q=2] q=[~ [p=~~~25. q=[p=[p=1 q=2] q="^"]]]]

                                                                                                                      ++col

                                                                                                                      Parse colon

                                                                                                                      Parses ASCII character 58, the colon

                                                                                                                      Source

                                                                                                                      ++  col  (just ':')
                                                                                                                      

                                                                                                                      Examples

                                                                                                                          > (scan ":" col)
                                                                                                                          ~~~3a.
                                                                                                                      
                                                                                                                          > `cord`(scan ":" col)
                                                                                                                          ':'
                                                                                                                      
                                                                                                                          > (col [[1 1] ":"])
                                                                                                                          [p=[p=1 q=2] q=[~ [p=~~~3a. q=[p=[p=1 q=2] q=""]]]]
                                                                                                                      
                                                                                                                          > (col [[1 1] ":-"])
                                                                                                                          [p=[p=1 q=2] q=[~ [p=~~~3a. q=[p=[p=1 q=2] q="-"]]]]

                                                                                                                      ++com

                                                                                                                      Parse comma

                                                                                                                      Parses ASCII character 44, the comma.

                                                                                                                      Source

                                                                                                                      ++  com  (just ',')
                                                                                                                      

                                                                                                                      Examples

                                                                                                                          > (scan "," com)
                                                                                                                          ~~~2c.
                                                                                                                      
                                                                                                                          > `cord`(scan "," com)
                                                                                                                          ','
                                                                                                                      
                                                                                                                          > (com [[1 1] ","])
                                                                                                                          [p=[p=1 q=2] q=[~ [p=~~~2c. q=[p=[p=1 q=2] q=""]]]]
                                                                                                                      
                                                                                                                          > (com [[1 1] "not com"])
                                                                                                                          [p=[p=1 q=1] q=~]

                                                                                                                      ++doq

                                                                                                                      Parse double quote

                                                                                                                      Parses ASCII character 34, the double quote.

                                                                                                                      Source

                                                                                                                      ++  doq  (just '"')
                                                                                                                      

                                                                                                                      Examples

                                                                                                                          > (scan "\"" doq)
                                                                                                                          ~~~22.
                                                                                                                      
                                                                                                                          > `cord`(scan "\"" doq)
                                                                                                                          '"'
                                                                                                                      
                                                                                                                          > (doq [[1 1] "\""])
                                                                                                                          [p=[p=1 q=2] q=[~ [p=~~~22. q=[p=[p=1 q=2] q=""]]]]
                                                                                                                      
                                                                                                                          > (doq [[1 1] "not successfully parsed"])
                                                                                                                          [p=[p=1 q=1] q=~]
                                                                                                                      
                                                                                                                          > (scan "see?" doq)
                                                                                                                          ! {1 1}
                                                                                                                          ! 'syntax-error'
                                                                                                                          ! exit

                                                                                                                      ++dot

                                                                                                                      Parse period

                                                                                                                      Parses ASCII character 46, the period.

                                                                                                                      Source

                                                                                                                      ++  dot  (just '.')
                                                                                                                      

                                                                                                                      Examples

                                                                                                                          > (scan "." dot)
                                                                                                                          ~~~.
                                                                                                                      
                                                                                                                          > `cord`(scan "." dot)
                                                                                                                          '.'
                                                                                                                      
                                                                                                                          > (dot [[1 1] "."])
                                                                                                                          [p=[p=1 q=2] q=[~ [p=~~~. q=[p=[p=1 q=2] q=""]]]]
                                                                                                                      
                                                                                                                          > (dot [[1 1] ".^"])
                                                                                                                          [p=[p=1 q=2] q=[~ [p=~~~. q=[p=[p=1 q=2] q="^"]]]]

                                                                                                                      ++fas

                                                                                                                      Parse forward slash

                                                                                                                      Parses ASCII character 47, the forward slash.

                                                                                                                      Source

                                                                                                                      ++  fas  (just '/')
                                                                                                                      

                                                                                                                      Examples

                                                                                                                          > (scan "/" fas)
                                                                                                                          '/'
                                                                                                                      
                                                                                                                          > (fas [[1 1] "/"])
                                                                                                                          [p=[p=1 q=2] q=[~ [p=~~~2f. q=[p=[p=1 q=2] q=""]]]]
                                                                                                                      
                                                                                                                          > (fas [[1 1] "|/"])
                                                                                                                          [p=[p=1 q=1] q=~]

                                                                                                                      ++gal

                                                                                                                      Parse less-than sign

                                                                                                                      Parses ASCII character 60, the less-than sign.

                                                                                                                      Source

                                                                                                                      ++  gal  (just '<')
                                                                                                                      

                                                                                                                      Examples

                                                                                                                          > (scan "<" gal)
                                                                                                                          '<'
                                                                                                                      
                                                                                                                          > (gal [[1 1] "<"])
                                                                                                                          [p=[p=1 q=2] q=[~ [p=~~~3c. q=[p=[p=1 q=2] q=""]]]]
                                                                                                                      
                                                                                                                          > (gal [[1 1] "<+"])
                                                                                                                          [p=[p=1 q=2] q=[~ [p=~~~3c. q=[p=[p=1 q=2] q="+"]]]]
                                                                                                                      
                                                                                                                          > (gal [[1 1] "+<"])
                                                                                                                          [p=[p=1 q=1] q=~]

                                                                                                                      ++gar

                                                                                                                      Parse greater-than sign

                                                                                                                      Parses ASCII character 62, the greater-than sign.

                                                                                                                      Source

                                                                                                                      ++  gar  (just '>')
                                                                                                                      

                                                                                                                      Examples

                                                                                                                          > (scan ">" gar)
                                                                                                                          ~~~3e.
                                                                                                                      
                                                                                                                          > `cord`(scan ">" gar)
                                                                                                                          '>'
                                                                                                                      
                                                                                                                          > (gar [[1 1] ">"])
                                                                                                                          [p=[p=1 q=2] q=[~ [p=~~~3e. q=[p=[p=1 q=2] q=""]]]]
                                                                                                                      
                                                                                                                          > (gar [[1 1] "=>"])
                                                                                                                          [p=[p=1 q=1] q=~]

                                                                                                                      ++hax

                                                                                                                      Parse number sign

                                                                                                                      Parses ASCII character 35, the number sign.

                                                                                                                      Source

                                                                                                                      ++  hax  (just '#')
                                                                                                                      

                                                                                                                      Examples

                                                                                                                          > (scan "#" hax)
                                                                                                                          '#'
                                                                                                                      
                                                                                                                          > (hax [[1 1] "#"])
                                                                                                                          [p=[p=1 q=2] q=[~ [p=~~~23. q=[p=[p=1 q=2] q=""]]]]
                                                                                                                      
                                                                                                                          > (hax [[1 1] "#!"])
                                                                                                                          [p=[p=1 q=2] q=[~ [p=~~~23. q=[p=[p=1 q=2] q="!"]]]]

                                                                                                                      ++hep

                                                                                                                      Parse hyphen

                                                                                                                      Parses ASCII character 45, the hyphen.

                                                                                                                      Source

                                                                                                                      ++  hep  (just '-')
                                                                                                                      

                                                                                                                      Examples

                                                                                                                          > (scan "-" hep)
                                                                                                                          '-'
                                                                                                                      
                                                                                                                          > (hep [[1 1] "-"])
                                                                                                                          [p=[p=1 q=2] q=[~ [p=~~- q=[p=[p=1 q=2] q=""]]]]
                                                                                                                      
                                                                                                                          > (hep [[1 1] ":-"])
                                                                                                                          [p=[p=1 q=1] q=~]

                                                                                                                      ++kel

                                                                                                                      Parse left curley bracket

                                                                                                                      Parses ASCII character 123, the left curly bracket. Note that { (kel) and } (ker) open and close a Hoon expression for Hoon string interpolation. To parse either of them, they must be escaped.

                                                                                                                      Source

                                                                                                                      ++  kel  (just '{')
                                                                                                                      

                                                                                                                      Examples

                                                                                                                          > (scan "\{" kel)
                                                                                                                          '{'
                                                                                                                      
                                                                                                                          > (kel [[1 1] "\{"])
                                                                                                                          [p=[p=1 q=2] q=[~ [p=~~~7b. q=[p=[p=1 q=2] q=""]]]]
                                                                                                                      
                                                                                                                          > (kel [[1 1] " \{"])
                                                                                                                          [p=[p=1 q=1] q=~]

                                                                                                                      ++ker

                                                                                                                      Parse right curley bracket

                                                                                                                      Parses ASCII character 125, the right curly bracket. Note that { (kel) and } (ker) open and close a Hoon expression for Hoon string interpolation. To parse either of them, they must be escaped.

                                                                                                                      Source

                                                                                                                      ++  ker  (just '}')
                                                                                                                      

                                                                                                                      Examples

                                                                                                                          > (scan "}" ker)
                                                                                                                          '}'
                                                                                                                      
                                                                                                                          > (ker [[1 1] "}"])
                                                                                                                          [p=[p=1 q=2] q=[~ [p=~~~7d. q=[p=[p=1 q=2] q=""]]]]
                                                                                                                      
                                                                                                                          > (ker [[1 1] "\{}"])
                                                                                                                          [p=[p=1 q=1] q=~]

                                                                                                                      ++ket

                                                                                                                      Parse caret

                                                                                                                      Parses ASCII character 94, the caret.

                                                                                                                      Source

                                                                                                                      ++  ket  (just '^')
                                                                                                                      

                                                                                                                      Examples

                                                                                                                          > (scan "^" ket)
                                                                                                                          '^'
                                                                                                                      
                                                                                                                          > (ket [[1 1] "^"])
                                                                                                                          [p=[p=1 q=2] q=[~ [p=~~~5e. q=[p=[p=1 q=2] q=""]]]]
                                                                                                                      
                                                                                                                          > (ket [[1 1] ".^"])
                                                                                                                          [p=[p=1 q=1] q=~]

                                                                                                                      ++lus

                                                                                                                      Parse plus sign

                                                                                                                      Parses ASCII character 43, the plus sign.

                                                                                                                      Source

                                                                                                                      ++  lus  (just '+')
                                                                                                                      

                                                                                                                      Examples

                                                                                                                              > (scan "+" lus)
                                                                                                                              ~~~2b.
                                                                                                                      
                                                                                                                              > `cord`(scan "+" lus)
                                                                                                                              '+'
                                                                                                                      
                                                                                                                              > (lus [[1 1] "+"])
                                                                                                                              [p=[p=1 q=2] q=[~ [p=~~~2b. q=[p=[p=1 q=2] q=""]]]]
                                                                                                                      
                                                                                                                              > (lus [[1 1] ".+"])
                                                                                                                              [p=[p=1 q=1] q=~]

                                                                                                                      ++pam

                                                                                                                      Parse ampersand

                                                                                                                      Parses ASCII character 38, the ampersand.

                                                                                                                      Source

                                                                                                                      ++  pam  (just '&')
                                                                                                                      

                                                                                                                      Examples

                                                                                                                          > (scan "&" pam)
                                                                                                                          ~~~26.
                                                                                                                      
                                                                                                                          > `cord`(scan "&" pam)
                                                                                                                          '&'
                                                                                                                      
                                                                                                                          > (pam [[1 1] "&"])
                                                                                                                          [p=[p=1 q=2] q=[~ [p=~~~26. q=[p=[p=1 q=2] q=""]]]]
                                                                                                                      
                                                                                                                          > (pam [[1 1] "?&"])
                                                                                                                          [p=[p=1 q=1] q=~]

                                                                                                                      ++pat

                                                                                                                      Parse "at" sign

                                                                                                                      Parses ASCII character 64, the "at" sign.

                                                                                                                      Source

                                                                                                                      ++  pat  (just '@')
                                                                                                                      

                                                                                                                      Examples

                                                                                                                          > (scan "@" pat)
                                                                                                                          ~~~4.
                                                                                                                      
                                                                                                                          > `cord`(scan "@" pat)
                                                                                                                          '@'
                                                                                                                      
                                                                                                                          > (pat [[1 1] "@"])
                                                                                                                          [p=[p=1 q=2] q=[~ [p=~~~4. q=[p=[p=1 q=2] q=""]]]]
                                                                                                                      
                                                                                                                          > (pat [[1 1] "?@"])
                                                                                                                          [p=[p=1 q=1] q=~]

                                                                                                                      ++pel

                                                                                                                      Parse left parenthesis

                                                                                                                      Parses ASCII character 40, the left parenthesis.

                                                                                                                      Source

                                                                                                                      ++  pel  (just '(')
                                                                                                                      

                                                                                                                      Examples

                                                                                                                          > (scan "(" pel)
                                                                                                                          '('
                                                                                                                      
                                                                                                                          > (pel [[1 1] "("])
                                                                                                                          [p=[p=1 q=2] q=[~ [p=~~~28. q=[p=[p=1 q=2] q=""]]]]
                                                                                                                      
                                                                                                                          > (pel [[1 1] ";("])
                                                                                                                          [p=[p=1 q=1] q=~]

                                                                                                                      ++per

                                                                                                                      Parse right parenthesis

                                                                                                                      Parses ASCII character 41, the right parenthesis.

                                                                                                                      Source

                                                                                                                      ++  per  (just ')')
                                                                                                                      

                                                                                                                      Examples

                                                                                                                          > (scan ")" per)
                                                                                                                          ')'
                                                                                                                      
                                                                                                                          > (per [[1 1] ")"])
                                                                                                                          [p=[p=1 q=2] q=[~ [p=~~~29. q=[p=[p=1 q=2] q=""]]]]
                                                                                                                      
                                                                                                                          > (per [[1 1] " )"])
                                                                                                                          [p=[p=1 q=1] q=~]

                                                                                                                      ++sel

                                                                                                                      Parse left square bracket

                                                                                                                      Parses ASCII character 91, the left square bracket.

                                                                                                                      Source

                                                                                                                      ++  sel  (just '[')
                                                                                                                      

                                                                                                                      Examples

                                                                                                                              > (scan "[" sel)
                                                                                                                              '['
                                                                                                                      
                                                                                                                              > (sel [[1 1] "["])
                                                                                                                              [p=[p=1 q=2] q=[~ [p=~~~5b. q=[p=[p=1 q=2] q=""]]]]
                                                                                                                      
                                                                                                                              > (sel [[1 1] "-["])
                                                                                                                              [p=[p=1 q=1] q=~]

                                                                                                                      ++sem

                                                                                                                      Parse semicolon

                                                                                                                      Parses ASCII character 59, the semicolon.

                                                                                                                      Source

                                                                                                                      ++  sem  (just ';')
                                                                                                                      

                                                                                                                      Examples

                                                                                                                          > (scan ";" sem)
                                                                                                                          ';'
                                                                                                                      
                                                                                                                          > (sem [[1 1] ";"])
                                                                                                                          [p=[p=1 q=2] q=[~ [p=~~~3b. q=[p=[p=1 q=2] q=""]]]]
                                                                                                                      
                                                                                                                          > (sem [[1 1] " ;"])
                                                                                                                          [p=[p=1 q=1] q=~]

                                                                                                                      ++ser

                                                                                                                      Parse right square bracket

                                                                                                                      Parses ASCII character 93, the right square bracket.

                                                                                                                      Source

                                                                                                                      ++  ser  (just ']')
                                                                                                                      

                                                                                                                      Examples

                                                                                                                          > (scan "]" ser)
                                                                                                                          ']'
                                                                                                                      
                                                                                                                          > (ser [[1 1] "]"])
                                                                                                                          [p=[p=1 q=2] q=[~ [p=~~~5d. q=[p=[p=1 q=2] q=""]]]]
                                                                                                                      
                                                                                                                          > (ser [[1 1] "[ ]"])
                                                                                                                          [p=[p=1 q=1] q=~]

                                                                                                                      ++sig

                                                                                                                      Parse tilde

                                                                                                                      Parses ASCII character 126, the tilde.

                                                                                                                      Source

                                                                                                                      ++  sig  (just '~')
                                                                                                                      

                                                                                                                      Examples

                                                                                                                          > (scan "~" sig)
                                                                                                                          '~'
                                                                                                                      
                                                                                                                          > (sig [[1 1] "~"])
                                                                                                                          [p=[p=1 q=2] q=[~ [p=~~~~ q=[p=[p=1 q=2] q=""]]]]
                                                                                                                      
                                                                                                                          > (sig [[1 1] "?~"])
                                                                                                                          [p=[p=1 q=1] q=~]

                                                                                                                      ++soq

                                                                                                                      Parse single quote

                                                                                                                      Parses ASCII character 39, soq. Note the extra '' is to escape the first soq because soq delimits a ++cord.

                                                                                                                      Source

                                                                                                                      ++  soq  (just '\'')
                                                                                                                      

                                                                                                                      Examples

                                                                                                                          > (scan "'" soq)
                                                                                                                          '\''
                                                                                                                      
                                                                                                                          > (soq [[1 1] "'"])
                                                                                                                          [p=[p=1 q=2] q=[~ [p=~~~27. q=[p=[p=1 q=2] q=""]]]]
                                                                                                                      
                                                                                                                          > (soq [[1 1] ">'"])
                                                                                                                          [p=[p=1 q=1] q=~]

                                                                                                                      ++tar

                                                                                                                      Parse asterisk

                                                                                                                      Parses ASCII character 42, the asterisk.

                                                                                                                      Source

                                                                                                                      ++  tar  (just '*')
                                                                                                                      

                                                                                                                      Examples

                                                                                                                          > (scan "*" tar)
                                                                                                                          ~~~2a.
                                                                                                                      
                                                                                                                          > `cord`(scan "*" tar)
                                                                                                                          '*'
                                                                                                                      
                                                                                                                          > (tar [[1 1] "*"])
                                                                                                                          [p=[p=1 q=2] q=[~ [p=~~~2a. q=[p=[p=1 q=2] q=""]]]]
                                                                                                                      
                                                                                                                          > (tar [[1 1] ".*"])
                                                                                                                          [p=[p=1 q=1] q=~]

                                                                                                                      ++tec

                                                                                                                      Parse backtick

                                                                                                                      Parses ASCII character 96, the backtick (also known as the "grave accent").

                                                                                                                      Source

                                                                                                                      ++  tec  (just '`')                                     ::  backTiCk
                                                                                                                      

                                                                                                                      Examples

                                                                                                                          > (scan "`" tec)
                                                                                                                          ~~~6.
                                                                                                                      
                                                                                                                          > `cord`(scan "`" tec)
                                                                                                                          '`'
                                                                                                                      
                                                                                                                          > (tec [[1 1] "`"])
                                                                                                                          [p=[p=1 q=2] q=[~ [p=~~~6. q=[p=[p=1 q=2] q=""]]]]
                                                                                                                      
                                                                                                                          > (tec [[1 1] " `"])
                                                                                                                          [p=[p=1 q=1] q=~]

                                                                                                                      ++tis

                                                                                                                      Parse equals sign

                                                                                                                      Parses ASCII character 61, the equals sign.

                                                                                                                      Source

                                                                                                                      ++  tis  (just '=')
                                                                                                                      

                                                                                                                      Examples

                                                                                                                          > (scan "=" tis)
                                                                                                                          '='
                                                                                                                      
                                                                                                                          > (tis [[1 1] "="])
                                                                                                                          [p=[p=1 q=2] q=[~ [p=~~~3d. q=[p=[p=1 q=2] q=""]]]]
                                                                                                                      
                                                                                                                          > (tis [[1 1] "|="])
                                                                                                                          [p=[p=1 q=1] q=~]

                                                                                                                      ++wut

                                                                                                                      Parses question mark

                                                                                                                      Parses ASCII character 63, the question mark.

                                                                                                                      Source

                                                                                                                      ++  wut  (just '?')
                                                                                                                      

                                                                                                                      Examples

                                                                                                                          > (scan "?" wut)
                                                                                                                          '?'
                                                                                                                      
                                                                                                                          > (wut [[1 1] "?"])
                                                                                                                          [p=[p=1 q=2] q=[~ [p=~~~3f. q=[p=[p=1 q=2] q=""]]]]
                                                                                                                      
                                                                                                                          > (wut [[1 1] ".?"])
                                                                                                                          [p=[p=1 q=1] q=~]

                                                                                                                      ++zap

                                                                                                                      Exclamation point

                                                                                                                      Parses ASCII character 33, the exclamation point zap.

                                                                                                                      Source

                                                                                                                      ++  zap  (just '!')
                                                                                                                      

                                                                                                                      Examples

                                                                                                                              > (scan "!" zap)
                                                                                                                              '!'
                                                                                                                      
                                                                                                                              > (zap [[1 1] "!"])
                                                                                                                              [p=[p=1 q=2] q=[~ [p=~~~21. q=[p=[p=1 q=2] q=""]]]]
                                                                                                                      
                                                                                                                              > (zap [[1 1] "?!"])
                                                                                                                              [p=[p=1 q=1] q=~]

                                                                                                                      <-

                                                                                                                      4g: Parsing (Outside Caller)

                                                                                                                      4i: Parsing (Useful Idioms)

                                                                                                                      ->