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

                                                                                                                      1a: Basic Arithmetic

                                                                                                                      ++add

                                                                                                                      Add

                                                                                                                      Produces the sum of a and b.

                                                                                                                      Accepts

                                                                                                                      a is an atom.

                                                                                                                      b is an atom.

                                                                                                                      Produces

                                                                                                                      An atom.

                                                                                                                      Source

                                                                                                                      ++  add
                                                                                                                            ~/  %add
                                                                                                                            |=  [a=@ b=@]
                                                                                                                            ^-  @
                                                                                                                            ?:  =(0 a)  b
                                                                                                                            $(a (dec a), b +(b))
                                                                                                                      

                                                                                                                      Examples

                                                                                                                          > (add 2 2)
                                                                                                                          4
                                                                                                                      
                                                                                                                          > (add 1 1.000.000)
                                                                                                                          1.000.001
                                                                                                                      
                                                                                                                          > (add 1.333 (mul 2 2))
                                                                                                                          1.337
                                                                                                                      
                                                                                                                          > (add 'a' 4)
                                                                                                                          101
                                                                                                                      
                                                                                                                          > (add 'a' 'b')
                                                                                                                          195
                                                                                                                      
                                                                                                                          > (add 0xc 0xf)
                                                                                                                          27
                                                                                                                      
                                                                                                                          > `@ux`(add 0xc 0xf)
                                                                                                                          0x1b

                                                                                                                      ++dec

                                                                                                                      Decrement

                                                                                                                      Decrements a by 1.

                                                                                                                      Accepts

                                                                                                                      a is an atom.

                                                                                                                      Produces

                                                                                                                      An atom.

                                                                                                                      Source

                                                                                                                      ++  dec
                                                                                                                            ~/  %dec
                                                                                                                            |=  a=@
                                                                                                                            ~|  %decrement-underflow
                                                                                                                            ?<  =(0 a)
                                                                                                                            =+  b=0
                                                                                                                            |-  ^-  @
                                                                                                                            ?:  =(a +(b))  b
                                                                                                                            $(b +(b))
                                                                                                                      

                                                                                                                      Examples

                                                                                                                          > (dec 7)
                                                                                                                          6
                                                                                                                      
                                                                                                                          > (dec 0)
                                                                                                                          ! decrement-underflow
                                                                                                                          ! exit
                                                                                                                      
                                                                                                                          > (dec 'b')
                                                                                                                          97
                                                                                                                          > `@t`(dec 'b')
                                                                                                                          'a'
                                                                                                                      
                                                                                                                          > (dec 0xc)
                                                                                                                          11
                                                                                                                          > `@ux`(dec 0xc)
                                                                                                                          0xb

                                                                                                                      ++div

                                                                                                                      Divide

                                                                                                                      Computes a divided by b without remainder.

                                                                                                                      Accepts

                                                                                                                      a is an atom.

                                                                                                                      b is an atom.

                                                                                                                      Produces

                                                                                                                      An atom.

                                                                                                                      Source

                                                                                                                      ++  div
                                                                                                                            ~/  %div
                                                                                                                            |:  [a=`@`1 b=`@`1]
                                                                                                                            ^-  @
                                                                                                                            ~_  leaf+"divide-by-zero"
                                                                                                                            ?<  =(0 b)
                                                                                                                            =+  c=0
                                                                                                                            |-
                                                                                                                            ?:  (lth a b)  c
                                                                                                                            $(a (sub a b), c +(c))
                                                                                                                      

                                                                                                                      Examples

                                                                                                                          > (div 4 2)
                                                                                                                          2
                                                                                                                      
                                                                                                                          > (div 17 8)
                                                                                                                          2
                                                                                                                      
                                                                                                                          > (div 20 30)
                                                                                                                          0
                                                                                                                      
                                                                                                                          > (div 'ab' 'a')
                                                                                                                          259
                                                                                                                          > `@`'ab'
                                                                                                                          25.185
                                                                                                                          > `@`a
                                                                                                                          97
                                                                                                                      
                                                                                                                          > (div 0x9f 0x29)
                                                                                                                          6

                                                                                                                      ++dvr

                                                                                                                      Divide with remainder

                                                                                                                      Computes a divided by b, producing the quotient and the remainder.

                                                                                                                      Accepts

                                                                                                                      a is an atom.

                                                                                                                      b is an atom.

                                                                                                                      Produces

                                                                                                                      A cell of atoms.

                                                                                                                      Source

                                                                                                                      ++  dvr
                                                                                                                            ~/  %dvr
                                                                                                                            |=  [a=@ b=@]
                                                                                                                            ^-  [p=@ q=@]
                                                                                                                            [(div a b) (mod a b)]
                                                                                                                      

                                                                                                                      Examples

                                                                                                                          > (dvr 17 8)
                                                                                                                          [p=2 q=1]
                                                                                                                      
                                                                                                                          > (dvr 17 6)
                                                                                                                          [p=2 q=5]
                                                                                                                      
                                                                                                                          > (dvr 18 6)
                                                                                                                          [p=3 q=0]
                                                                                                                      
                                                                                                                          > (dvr 4 2)
                                                                                                                          [p=2 q=0]
                                                                                                                      
                                                                                                                          > (dvr 'ab 'a')
                                                                                                                          [p=259 q=62]
                                                                                                                          > `@`'a'
                                                                                                                          97
                                                                                                                          > `@`'ab'
                                                                                                                          25.185

                                                                                                                      ++gte

                                                                                                                      Greater-than/equal

                                                                                                                      Tests whether a is greater than or equal to b.

                                                                                                                      Accepts

                                                                                                                      a is an atom.

                                                                                                                      b is an atom.

                                                                                                                      Produces

                                                                                                                      A flag.

                                                                                                                      Source

                                                                                                                      ++  gte
                                                                                                                            ~/  %gte
                                                                                                                            |=  [a=@ b=@]
                                                                                                                            ^-  ?
                                                                                                                            !(lth a b)
                                                                                                                      

                                                                                                                      Examples

                                                                                                                          > (gte 100 10)
                                                                                                                          %.y
                                                                                                                      
                                                                                                                          > (gte 4 4)
                                                                                                                          %.y
                                                                                                                      
                                                                                                                          > (gte 3 4)
                                                                                                                          %.n

                                                                                                                      ++gth

                                                                                                                      Greater-than

                                                                                                                      Tests whether a is greater than b.

                                                                                                                      Accepts

                                                                                                                      a is an atom.

                                                                                                                      b is an atom.

                                                                                                                      Produces

                                                                                                                      A flag.

                                                                                                                      Source

                                                                                                                      ++  gth
                                                                                                                            ~/  %gth
                                                                                                                            |=  [a=@ b=@]
                                                                                                                            ^-  ?
                                                                                                                            !(lte a b)
                                                                                                                      

                                                                                                                      Examples

                                                                                                                          > (gth 'd' 'c')
                                                                                                                          %.y
                                                                                                                      
                                                                                                                          > (gth ~h1 ~m61)
                                                                                                                          %.n
                                                                                                                      
                                                                                                                          > (gth 'steak' 'brisket')
                                                                                                                          %.n

                                                                                                                      ++lte

                                                                                                                      Less-than/equal

                                                                                                                      Tests whether a is less than or equal to b.

                                                                                                                      Accepts

                                                                                                                      a is an atom.

                                                                                                                      b is an atom.

                                                                                                                      Produces

                                                                                                                      A flag.

                                                                                                                      Source

                                                                                                                      ++  lte
                                                                                                                            ~/  %lte
                                                                                                                            |=  [a=@ b=@]
                                                                                                                            |(=(a b) (lth a b))
                                                                                                                      

                                                                                                                      Examples

                                                                                                                          > (lte 4 5)
                                                                                                                          %.y
                                                                                                                      
                                                                                                                          > (lte 5 4)
                                                                                                                          %.n
                                                                                                                      
                                                                                                                          > (lte 5 5)
                                                                                                                          %.y
                                                                                                                      
                                                                                                                          > (lte 0 0)
                                                                                                                          %.y
                                                                                                                      
                                                                                                                      
                                                                                                                          > (lte 'a' 'b')
                                                                                                                          %.y
                                                                                                                          > `@`'a'
                                                                                                                          97
                                                                                                                          > `@`'b'
                                                                                                                          98
                                                                                                                      
                                                                                                                          > (lte 'abraham' 'bob')
                                                                                                                          %.n
                                                                                                                      
                                                                                                                          > (lte ~m61 ~h1)
                                                                                                                          %.n

                                                                                                                      ++lth

                                                                                                                      Less-than

                                                                                                                      Tests whether a is less than b.

                                                                                                                      Accepts

                                                                                                                      a is an atom.

                                                                                                                      b is an atom.

                                                                                                                      Produces

                                                                                                                      A flag.

                                                                                                                      Source

                                                                                                                      ++  lth
                                                                                                                            ~/  %lth
                                                                                                                            |=  [a=@ b=@]
                                                                                                                            ^-  ?
                                                                                                                            ?&  !=(a b)
                                                                                                                                |-
                                                                                                                                ?|  =(0 a)
                                                                                                                                    ?&  !=(0 b)
                                                                                                                                        $(a (dec a), b (dec b))
                                                                                                                            ==  ==  ==
                                                                                                                      

                                                                                                                      Examples

                                                                                                                          > (lth 4 5)
                                                                                                                          %.y
                                                                                                                      
                                                                                                                          > (lth 5 4)
                                                                                                                          %.n
                                                                                                                      
                                                                                                                          > (lth 5 5)
                                                                                                                          %.n
                                                                                                                      
                                                                                                                          > (lth 5 0)
                                                                                                                          %.n
                                                                                                                      
                                                                                                                          > (lth 'a' 'b')
                                                                                                                          %.y
                                                                                                                          > `@`'a'
                                                                                                                          97
                                                                                                                          > `@`'b'
                                                                                                                          98
                                                                                                                      
                                                                                                                          > (lth 'abraham' 'bob')
                                                                                                                          %.n

                                                                                                                      ++max

                                                                                                                      Maximum

                                                                                                                      Computes the greater of a and b.

                                                                                                                      Accepts

                                                                                                                      a is an atom.

                                                                                                                      b is an atom.

                                                                                                                      Produces

                                                                                                                      An atom.

                                                                                                                      Source

                                                                                                                      ++  max
                                                                                                                            ~/  %max
                                                                                                                            |=  [a=@ b=@]
                                                                                                                            ^-  @
                                                                                                                            ?:  (gth a b)  a
                                                                                                                            b
                                                                                                                      

                                                                                                                      Examples

                                                                                                                          > (max 10 100)
                                                                                                                          100
                                                                                                                      
                                                                                                                          > (max 10.443 9)
                                                                                                                          10.443
                                                                                                                      
                                                                                                                          > (max 1 1)
                                                                                                                          1
                                                                                                                      
                                                                                                                          > (max 'abraham' 'bob')
                                                                                                                          30.787.873.400.840.801
                                                                                                                      
                                                                                                                          > `@t`(max 'abraham' 'bob')
                                                                                                                          'abraham'
                                                                                                                      
                                                                                                                          > `@t`(max 'abraham' 'benjamin')
                                                                                                                          'benjamin'
                                                                                                                      
                                                                                                                          > `@dr`(max ~m6 ~h1)
                                                                                                                          ~h1
                                                                                                                      
                                                                                                                          >`@ux`(max 0xe1 0x1e)
                                                                                                                          0xe1

                                                                                                                      ++min

                                                                                                                      Minimum

                                                                                                                      Computes the lesser of a and b.

                                                                                                                      Accepts

                                                                                                                      a is an atom.

                                                                                                                      b is an atom.

                                                                                                                      Produces

                                                                                                                      An atom.

                                                                                                                      Source

                                                                                                                      ++  min
                                                                                                                            ~/  %min
                                                                                                                            |=  [a=@ b=@]
                                                                                                                            ^-  @
                                                                                                                            ?:  (lth a b)  a
                                                                                                                            b
                                                                                                                      

                                                                                                                      Examples

                                                                                                                          > (min 10 100)
                                                                                                                          10
                                                                                                                      
                                                                                                                          > (min 10.443 9)
                                                                                                                          9
                                                                                                                      
                                                                                                                          > (min 1 1)
                                                                                                                          1
                                                                                                                      
                                                                                                                          > (min 'abraham' 'bob')
                                                                                                                          6.451.042
                                                                                                                      
                                                                                                                          > `@t`(min 'abraham' 'bob')
                                                                                                                          'bob'
                                                                                                                      
                                                                                                                          > `@t`(min 'abraham' 'benjamin')
                                                                                                                          'abraham'
                                                                                                                      
                                                                                                                          > `@dr`(min ~m6 ~h1)
                                                                                                                          ~m6

                                                                                                                      ++mod

                                                                                                                      Modulus

                                                                                                                      Computes the remainder of dividing a by b.

                                                                                                                      Accepts

                                                                                                                      a is an atom.

                                                                                                                      b is an atom.

                                                                                                                      Produces

                                                                                                                      An atom.

                                                                                                                      Source

                                                                                                                      ++  mod
                                                                                                                            ~/  %mod
                                                                                                                            |:  [a=`@`1 b=`@`1]
                                                                                                                            ^-  @
                                                                                                                            ?<  =(0 b)
                                                                                                                            (sub a (mul b (div a b)))
                                                                                                                      

                                                                                                                      Examples

                                                                                                                          > (mod 5 2)
                                                                                                                          1
                                                                                                                      
                                                                                                                          > (mod 5 5)
                                                                                                                          0
                                                                                                                      
                                                                                                                          > (mod 2 5)
                                                                                                                          2
                                                                                                                      
                                                                                                                          > (mod 40 20)
                                                                                                                          0
                                                                                                                      
                                                                                                                          > `@`'c'
                                                                                                                          99
                                                                                                                          >`@`'a'
                                                                                                                          97
                                                                                                                          > (mod 'c' 'a')
                                                                                                                          2

                                                                                                                      ++mul

                                                                                                                      Multiply

                                                                                                                      Multiplies a by b.

                                                                                                                      Accepts

                                                                                                                      a is an atom.

                                                                                                                      b is an atom.

                                                                                                                      Produces

                                                                                                                      An atom.

                                                                                                                      Source

                                                                                                                      ++  mul
                                                                                                                            ~/  %mul
                                                                                                                            |:  [a=`@`1 b=`@`1]
                                                                                                                            ^-  @
                                                                                                                            =+  c=0
                                                                                                                            |-
                                                                                                                            ?:  =(0 a)  c
                                                                                                                            $(a (dec a), c (add b c))
                                                                                                                      

                                                                                                                      Examples

                                                                                                                          > (mul 3 4)
                                                                                                                          12
                                                                                                                      
                                                                                                                          > (mul 0 1)
                                                                                                                          0
                                                                                                                      
                                                                                                                          > `@`'a'
                                                                                                                          97
                                                                                                                          > `@`'b'
                                                                                                                          98
                                                                                                                          > (mul 'a' 'b')
                                                                                                                          9.506
                                                                                                                      
                                                                                                                          >`@ux`(mul 0x1f 0xe)
                                                                                                                          0x1b2

                                                                                                                      ++sub

                                                                                                                      Subtract

                                                                                                                      Subtracts b from a.

                                                                                                                      Accepts

                                                                                                                      a is an atom.

                                                                                                                      b is an atom.

                                                                                                                      Produces

                                                                                                                      An atom.

                                                                                                                      Source

                                                                                                                      ++  sub
                                                                                                                                ~/  %sub
                                                                                                                                |=  [a=@ b=@]
                                                                                                                                ~_  leaf+"subtract-underflow"
                                                                                                                                ^-  @
                                                                                                                                ?:  =(0 b)  a
                                                                                                                                $(a (dec a), b (dec b))
                                                                                                                      

                                                                                                                      Examples

                                                                                                                          > (sub 10 5)
                                                                                                                          5
                                                                                                                      
                                                                                                                          > (sub 243 44)
                                                                                                                          199
                                                                                                                      
                                                                                                                          > (sub 5 0)
                                                                                                                          5
                                                                                                                      
                                                                                                                          > (sub 0 5)
                                                                                                                          ! subtract-underflow
                                                                                                                          ! exit
                                                                                                                      
                                                                                                                          > (sub 'c' 'a')
                                                                                                                          2
                                                                                                                          > `@`'c'
                                                                                                                          99
                                                                                                                          > `@`'a'
                                                                                                                          97
                                                                                                                      
                                                                                                                          > (sub 0x1f 0xe)
                                                                                                                          17
                                                                                                                          > `@ux`(sub 0x1f 0xe)
                                                                                                                          0x11

                                                                                                                      <-

                                                                                                                      Table of Contents

                                                                                                                      1b: Tree Addressing

                                                                                                                      ->