Urbit
  • Introduction
  • Development

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

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

        • Overview
        • Ames

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

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

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

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

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

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

                    • Overview
                    • Gall

                      • Overview
                      • API Reference
                      • Data Types
                      • Iris

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

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

                            • Scries
                            • Subscriptions
                            • Tutorials

                              • Move Trace
                              • Reference

                                • Cryptography
                                • Filesystem Hierarchy
                              • Userspace

                                • Overview
                                • HTTP API Guide
                                • Gall Guide

                                  • Introduction
                                  • 1. Arvo
                                  • 2. The Agent Core
                                  • 3. Imports and Aliases
                                  • 4. Lifecycle
                                  • 5. Cards
                                  • 6. Pokes
                                  • 7. Structures and Marks
                                  • 8. Subscriptions
                                  • 9. Vanes
                                  • 10. Scries
                                  • 11. Failure
                                  • 12. Next Steps
                                  • Appendix: Types
                                  • Full-Stack Walkthrough

                                    • 1. Introduction
                                    • 2. Types
                                    • 3. Agent
                                    • 4. JSON
                                    • 5. Marks
                                    • 6. Eyre
                                    • 7. React app setup
                                    • 8. React app logic
                                    • 9. Desk and glob
                                    • 10. Summary
                                    • Graph Store

                                      • Graph Store Overview
                                      • Data Structure Overview
                                      • Validator Walkthrough
                                      • Sample Application: Library
                                      • Graph Store - Reference
                                      • 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
                                            • Distribution

                                              • Overview
                                              • Guide
                                              • Docket File
                                              • Glob
                                              • Dojo Tools
                                            • Hoon

                                              • Overview
                                              • Hoon School

                                                • 1.1 Introduction
                                                • 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
                                                  • JSON
                                                  • Strings
                                                  • Sail (HTML)
                                                  • 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')
                                                      • Imports / ('fas')
                                                      • 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: Molds and mold builders
                                                          • 5f: Profiling support
                                                          • Zuse

                                                            • Table of Contents
                                                            • 2d(1-5): To JSON, Wains
                                                            • 2d(6): From JSON
                                                            • 2d(7): From JSON (unit)
                                                            • 2e(2-3): Print & Parse JSON
                                                        • Nock

                                                          • Nock Definition
                                                          • Explanation
                                                          • Example
                                                          • Implementations
                                                          • Vere

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

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

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

                                                                • Ames
                                                                • Aqua
                                                                • Arm
                                                                • Arvo
                                                                • Atom
                                                                • Azimuth
                                                                • Battery
                                                                • Behn
                                                                • 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
                                                                • Factory Reset
                                                                • Naive rollups
                                                                • 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
                                                                      • Ames

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

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

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

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

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

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

                                                                                  • Overview
                                                                                  • Gall

                                                                                    • Overview
                                                                                    • API Reference
                                                                                    • Data Types
                                                                                    • Iris

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

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

                                                                                          • Scries
                                                                                          • Subscriptions
                                                                                          • Tutorials

                                                                                            • Move Trace
                                                                                            • Reference

                                                                                              • Cryptography
                                                                                              • Filesystem Hierarchy
                                                                                            • Userspace

                                                                                              • Overview
                                                                                              • HTTP API Guide
                                                                                              • Gall Guide

                                                                                                • Introduction
                                                                                                • 1. Arvo
                                                                                                • 2. The Agent Core
                                                                                                • 3. Imports and Aliases
                                                                                                • 4. Lifecycle
                                                                                                • 5. Cards
                                                                                                • 6. Pokes
                                                                                                • 7. Structures and Marks
                                                                                                • 8. Subscriptions
                                                                                                • 9. Vanes
                                                                                                • 10. Scries
                                                                                                • 11. Failure
                                                                                                • 12. Next Steps
                                                                                                • Appendix: Types
                                                                                                • Full-Stack Walkthrough

                                                                                                  • 1. Introduction
                                                                                                  • 2. Types
                                                                                                  • 3. Agent
                                                                                                  • 4. JSON
                                                                                                  • 5. Marks
                                                                                                  • 6. Eyre
                                                                                                  • 7. React app setup
                                                                                                  • 8. React app logic
                                                                                                  • 9. Desk and glob
                                                                                                  • 10. Summary
                                                                                                  • Graph Store

                                                                                                    • Graph Store Overview
                                                                                                    • Data Structure Overview
                                                                                                    • Validator Walkthrough
                                                                                                    • Sample Application: Library
                                                                                                    • Graph Store - Reference
                                                                                                    • 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
                                                                                                          • Distribution

                                                                                                            • Overview
                                                                                                            • Guide
                                                                                                            • Docket File
                                                                                                            • Glob
                                                                                                            • Dojo Tools
                                                                                                          • Hoon

                                                                                                            • Overview
                                                                                                            • Hoon School

                                                                                                              • 1.1 Introduction
                                                                                                              • 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
                                                                                                                • JSON
                                                                                                                • Strings
                                                                                                                • Sail (HTML)
                                                                                                                • 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')
                                                                                                                    • Imports / ('fas')
                                                                                                                    • 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: Molds and mold builders
                                                                                                                        • 5f: Profiling support
                                                                                                                        • Zuse

                                                                                                                          • Table of Contents
                                                                                                                          • 2d(1-5): To JSON, Wains
                                                                                                                          • 2d(6): From JSON
                                                                                                                          • 2d(7): From JSON (unit)
                                                                                                                          • 2e(2-3): Print & Parse JSON
                                                                                                                      • Nock

                                                                                                                        • Nock Definition
                                                                                                                        • Explanation
                                                                                                                        • Example
                                                                                                                        • Implementations
                                                                                                                        • Vere

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

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

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

                                                                                                                              • Ames
                                                                                                                              • Aqua
                                                                                                                              • Arm
                                                                                                                              • Arvo
                                                                                                                              • Atom
                                                                                                                              • Azimuth
                                                                                                                              • Battery
                                                                                                                              • Behn
                                                                                                                              • 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
                                                                                                                              • Factory Reset
                                                                                                                              • Naive rollups
                                                                                                                              • Sail/Udon
                                                                                                                              • Senate
                                                                                                                              • Ship
                                                                                                                              • ship.arvo.network
                                                                                                                              • Star
                                                                                                                              • |sync
                                                                                                                              • Trap
                                                                                                                              • Upgrade Proposal
                                                                                                                              • Vane
                                                                                                                              • Vere
                                                                                                                              • Voting
                                                                                                                              • Wallet-Generator
                                                                                                                              Urbit/Documentation/Hoon/Reference/Standard library

                                                                                                                              2i: Map Logic

                                                                                                                              ++by

                                                                                                                              Map operations

                                                                                                                              Container arm for map operation arms. A map is a set of key-value pairs. The contained arms inherit its sample map, a.

                                                                                                                              Accepts

                                                                                                                              a is a map.

                                                                                                                              Source

                                                                                                                              ++  by
                                                                                                                                ~/  %by
                                                                                                                                =|  a=(tree (pair))  ::  (map)
                                                                                                                                =*  node  ?>(?=(^ a) n.a)
                                                                                                                                |@
                                                                                                                              

                                                                                                                              Examples

                                                                                                                              > ~(. by (malt (limo ~[a+1 b+2 c+3])))
                                                                                                                              < 27.jus
                                                                                                                                [   a
                                                                                                                                  ?(
                                                                                                                                    %~
                                                                                                                                    [ n=[?(p=%a p=%b p=%c) q=@ud]
                                                                                                                                      l=nlr([p=?(%a %b %c) q=@ud])
                                                                                                                                      r=nlr([p=?(%a %b %c) q=@ud])
                                                                                                                                    ]
                                                                                                                                  )
                                                                                                                                  <123.zao 46.hgz 1.pnw %140>
                                                                                                                                ]
                                                                                                                              >

                                                                                                                              ++all:by

                                                                                                                              Logical AND

                                                                                                                              Computes the logical AND on the results of slamming every element in map a with gate b.

                                                                                                                              Accepts

                                                                                                                              a is a map, and is the sample of +by.

                                                                                                                              b is a gate.

                                                                                                                              Produces

                                                                                                                              A flag.

                                                                                                                              Source

                                                                                                                              ++  all
                                                                                                                                ~/  %all
                                                                                                                                |*  b=$-(* ?)
                                                                                                                                |-  ^-  ?
                                                                                                                                ?~  a
                                                                                                                                  &
                                                                                                                                ?&((b q.n.a) $(a l.a) $(a r.a))
                                                                                                                              

                                                                                                                              Examples

                                                                                                                              > =a (malt (limo ~[a+1 b+[2 3]]))
                                                                                                                              
                                                                                                                              > (~(all by a) |=(a=* ?@(a & |)))
                                                                                                                              %.n
                                                                                                                              > =a (malt (limo ~[a+1 b+2 c+3 d+4 e+5]))
                                                                                                                              
                                                                                                                              > (~(all by a) |=(a=@ (lte a 6)))
                                                                                                                              %.y
                                                                                                                              
                                                                                                                              > (~(all by a) |=(a=@ (lte a 4)))
                                                                                                                              %.n

                                                                                                                              ++any:by

                                                                                                                              Logical OR

                                                                                                                              Computes the logical OR on the results of slamming every element with gate b.

                                                                                                                              Accepts

                                                                                                                              a is a map, and is the sample of +by.

                                                                                                                              b is a wet gate.

                                                                                                                              Produces

                                                                                                                              A flag.

                                                                                                                              Source

                                                                                                                              ++  any
                                                                                                                                ~/  %any
                                                                                                                                |*  b=$-(* ?)
                                                                                                                                |-  ^-  ?
                                                                                                                                ?~  a
                                                                                                                                  |
                                                                                                                                ?|((b q.n.a) $(a l.a) $(a r.a))
                                                                                                                              

                                                                                                                              Examples

                                                                                                                              > =a (malt (limo ~[a+1 b+[2 3]]))
                                                                                                                              
                                                                                                                              > (~(any by a) |=(a=* ?@(a & |)))
                                                                                                                              %.y
                                                                                                                              > =a (malt (limo ~[a+1 b+2 c+3 d+4 e+5]))
                                                                                                                              
                                                                                                                              > (~(any by a) |=(a=@ (lte a 4)))
                                                                                                                              %.y

                                                                                                                              ++apt:by

                                                                                                                              Check correctness

                                                                                                                              Computes whether a has a correct horizontal order and a correct vertical order, producing a flag.

                                                                                                                              Accepts

                                                                                                                              a is a map.

                                                                                                                              Produces

                                                                                                                              A flag.

                                                                                                                              Source

                                                                                                                              ++  apt
                                                                                                                                =<  $
                                                                                                                                ~/  %apt
                                                                                                                                =|  [l=(unit) r=(unit)]
                                                                                                                                |.  ^-  ?
                                                                                                                                ?~  a   &
                                                                                                                                ?&  ?~(l & &((gor p.n.a u.l) !=(p.n.a u.l)))
                                                                                                                                    ?~(r & &((gor u.r p.n.a) !=(u.r p.n.a)))
                                                                                                                                    ?~  l.a   &
                                                                                                                                    &((mor p.n.a p.n.l.a) !=(p.n.a p.n.l.a) $(a l.a, l `p.n.a))
                                                                                                                                    ?~  r.a   &
                                                                                                                                    &((mor p.n.a p.n.r.a) !=(p.n.a p.n.r.a) $(a r.a, r `p.n.a))
                                                                                                                                ==
                                                                                                                              

                                                                                                                              Examples

                                                                                                                              > =a (malt `(list [@tas @])`~[a+1 b+2 c+3 d+4 e+5])
                                                                                                                              
                                                                                                                              > ~(apt by a)
                                                                                                                              %.y
                                                                                                                              
                                                                                                                              > =z ?~(a ~ a(p.n `@tas`%z))
                                                                                                                              
                                                                                                                              > z
                                                                                                                              [n=[p=%z q=2] l={[p=%e q=5]} r={[p=%d q=4] [p=%a q=1] [p=%c q=3]}]
                                                                                                                              
                                                                                                                              > ~(apt by z)
                                                                                                                              %.n

                                                                                                                              Discussion

                                                                                                                              See section 2f for more information on noun ordering.

                                                                                                                              ++bif:by

                                                                                                                              Bifurcate

                                                                                                                              Splits map a into two maps l and r, which contain the items either side of key b with value c but not including b-c.

                                                                                                                              Accepts

                                                                                                                              a is a map, and is the sample of +by.

                                                                                                                              b is a noun.

                                                                                                                              c is a noun.

                                                                                                                              Produces

                                                                                                                              A cell of two maps.

                                                                                                                              Source

                                                                                                                              ++  bif
                                                                                                                                ~/  %bif
                                                                                                                                |*  [b=* c=*]
                                                                                                                                ^+  [l=a r=a]
                                                                                                                                =<  +
                                                                                                                                |-  ^+  a
                                                                                                                                ?~  a
                                                                                                                                  [[b c] ~ ~]
                                                                                                                                ?:  =(b p.n.a)
                                                                                                                                  ?:  =(c q.n.a)
                                                                                                                                    a
                                                                                                                                  a(n [b c])
                                                                                                                                ?:  (gor b p.n.a)
                                                                                                                                  =+  d=$(a l.a)
                                                                                                                                  ?>  ?=(^ d)
                                                                                                                                  d(r a(l r.d))
                                                                                                                                =+  d=$(a r.a)
                                                                                                                                ?>  ?=(^ d)
                                                                                                                                d(l a(r l.d))
                                                                                                                              

                                                                                                                              Examples

                                                                                                                              > =a (malt `(list [@tas @])`~[a+1 b+2 c+3 d+4 e+5])
                                                                                                                              
                                                                                                                              > (~(bif by a) b+2)
                                                                                                                              [l=[n=[p=%e q=5] l=~ r=~] r=[n=[p=%d q=4] l=~ r=[n=[p=%c q=3] l={[p=%a q=1]} r={}]]]
                                                                                                                              
                                                                                                                              > `[(map @tas @) (map @tas @)]`(~(bif by a) b+2)
                                                                                                                              [{[p=%e q=5]} {[p=%d q=4] [p=%a q=1] [p=%c q=3]}]

                                                                                                                              Discussion

                                                                                                                              Note that maps are horizontally ordered by the mug hash of their keys and vertically ordered by the double-mug hash of their keys. This means bifurcating the map (malt ~[10^10 20^20 30^30 40^40 50^50]) at 30^30 will not produce [{10^10 20^20} {40^40 50^50}], but rather [{20^20} {10^10 40^40 50^50}] due to the tree structure resulting from their mug hashes.


                                                                                                                              ++del:by

                                                                                                                              Delete

                                                                                                                              Produces map a with the element located at key b removed.

                                                                                                                              Accepts

                                                                                                                              a is a map, and is the sample of +by.

                                                                                                                              b is a key as a noun.

                                                                                                                              Produces

                                                                                                                              A map.

                                                                                                                              Source

                                                                                                                              ++  del
                                                                                                                                ~/  %del
                                                                                                                                |*  b=*
                                                                                                                                |-  ^+  a
                                                                                                                                ?~  a
                                                                                                                                  ~
                                                                                                                                ?.  =(b p.n.a)
                                                                                                                                  ?:  (gor b p.n.a)
                                                                                                                                    a(l $(a l.a))
                                                                                                                                  a(r $(a r.a))
                                                                                                                                |-  ^-  [$?(~ _a)]
                                                                                                                                ?~  l.a  r.a
                                                                                                                                ?~  r.a  l.a
                                                                                                                                ?:  (mor p.n.l.a p.n.r.a)
                                                                                                                                  l.a(r $(l.a r.l.a))
                                                                                                                                r.a(l $(r.a l.r.a))
                                                                                                                              

                                                                                                                              Examples

                                                                                                                              > =a `(map @tas @)`(malt (limo ~[a+1 b+2 c+3 d+4]))
                                                                                                                              > a
                                                                                                                              {[p=%b q=2] [p=%d q=4] [p=%a q=1] [p=%c q=3]}
                                                                                                                              
                                                                                                                              > `(map @tas @)`(~(del by a) %z)
                                                                                                                              {[p=%b q=2] [p=%d q=4] [p=%a q=1] [p=%c q=3]}
                                                                                                                              
                                                                                                                              > `(map @tas @)`(~(del by a) %b)
                                                                                                                              {[p=%d q=4] [p=%a q=1] [p=%c q=3]}

                                                                                                                              ++dif:by

                                                                                                                              Difference

                                                                                                                              Computes the difference between a and b, producing the map of key-value pairs in a whose keys are not in b.

                                                                                                                              Accepts

                                                                                                                              a is a map, and is the sample of +by.

                                                                                                                              b is a map.

                                                                                                                              Produces

                                                                                                                              A map.

                                                                                                                              Source

                                                                                                                              ++  dif
                                                                                                                                ~/  %dif
                                                                                                                                =+  b=a
                                                                                                                                |@
                                                                                                                                ++  $
                                                                                                                                  |-  ^+  a
                                                                                                                                  ?~  b
                                                                                                                                    a
                                                                                                                                  =+  c=(bif p.n.b q.n.b)
                                                                                                                                  ?>  ?=(^ c)
                                                                                                                                  =+  d=$(a l.c, b l.b)
                                                                                                                                  =+  e=$(a r.c, b r.b)
                                                                                                                                  |-  ^-  [$?(~ _a)]
                                                                                                                                  ?~  d  e
                                                                                                                                  ?~  e  d
                                                                                                                                  ?:  (mor p.n.d p.n.e)
                                                                                                                                    d(r $(d r.d))
                                                                                                                                  e(l $(e l.e))
                                                                                                                                --
                                                                                                                              

                                                                                                                              Examples

                                                                                                                              > =a `(map @tas @)`(malt (limo ~[a+1 b+2 c+3 d+4]))
                                                                                                                              > =b `(map @tas @)`(malt (limo ~[c+3 d+4 e+5 f+6]))
                                                                                                                              > a
                                                                                                                              {[p=%b q=2] [p=%d q=4] [p=%a q=1] [p=%c q=3]}
                                                                                                                              > b
                                                                                                                              {[p=%e q=5] [p=%d q=4] [p=%f q=6] [p=%c q=3]}
                                                                                                                              
                                                                                                                              > `(map @tas @)`(~(dif by a) b)
                                                                                                                              {[p=%b q=2] [p=%a q=1]}
                                                                                                                              > =a `(map @tas @)`(malt (limo ~[a+1 b+2 c+3 d+4]))
                                                                                                                              > =b `(map @tas @)`(malt (limo ~[a+2 e+4 f+5]))
                                                                                                                              > a
                                                                                                                              {[p=%b q=2] [p=%d q=4] [p=%a q=1] [p=%c q=3]}
                                                                                                                              > b
                                                                                                                              {[p=%e q=4] [p=%f q=5] [p=%a q=2]}
                                                                                                                              
                                                                                                                              > `(map @tas @)`(~(dif by a) b)
                                                                                                                              {[p=%b q=2] [p=%d q=4] [p=%c q=3]}

                                                                                                                              Discussion

                                                                                                                              This only compares keys, so if both maps contain the same key with different values, that key-value pair is not considered a difference and will not be included in the resulting map.


                                                                                                                              ++dig:by

                                                                                                                              Address of key

                                                                                                                              Produce the address of key b within map a.

                                                                                                                              Accepts

                                                                                                                              a is a map, and is the sample of +by.

                                                                                                                              b is a key as a noun.

                                                                                                                              Produces

                                                                                                                              A unit.

                                                                                                                              Source

                                                                                                                              ++  dig
                                                                                                                                |=  b=*
                                                                                                                                =+  c=1
                                                                                                                                |-  ^-  (unit @)
                                                                                                                                ?~  a  ~
                                                                                                                                ?:  =(b p.n.a)  [~ u=(peg c 2)]
                                                                                                                                ?:  (gor b p.n.a)
                                                                                                                                  $(a l.a, c (peg c 6))
                                                                                                                                $(a r.a, c (peg c 7))
                                                                                                                              

                                                                                                                              Examples

                                                                                                                              > =a `(map @tas @)`(malt (limo ~[a+1 b+2 c+3 d+4]))
                                                                                                                              
                                                                                                                              > (~(dig by a) %a)
                                                                                                                              [~ 252]
                                                                                                                              
                                                                                                                              > (~(dig by a) %b)
                                                                                                                              [~ 2]
                                                                                                                              
                                                                                                                              > (~(dig by a) %e)
                                                                                                                              ~

                                                                                                                              ++gas:by

                                                                                                                              Concatenate

                                                                                                                              Insert a list of key-value pairs b into map a. For a key which exists in both a and b, the value is replaced with the value in b.

                                                                                                                              Accepts

                                                                                                                              a is a map, and is the sample of +by.

                                                                                                                              b is a list of cells of key-value nouns p and q.

                                                                                                                              Produces

                                                                                                                              A map.

                                                                                                                              Source

                                                                                                                              ++  gas
                                                                                                                                ~/  %gas
                                                                                                                                |*  b=(list [p=* q=*])
                                                                                                                                =>  .(b `(list _?>(?=(^ a) n.a))`b)
                                                                                                                                |-  ^+  a
                                                                                                                                ?~  b
                                                                                                                                  a
                                                                                                                                $(b t.b, a (put p.i.b q.i.b))
                                                                                                                              

                                                                                                                              Examples

                                                                                                                              > =a `(map @tas @)`(malt (limo ~[a+1 b+2 c+3 d+4]))
                                                                                                                              > a
                                                                                                                              {[p=%b q=2] [p=%d q=4] [p=%a q=1] [p=%c q=3]}
                                                                                                                              
                                                                                                                              > `(map @tas @)`(~(gas by a) ~[e+5 f+6 g+7])
                                                                                                                              {[p=%e q=5] [p=%b q=2] [p=%d q=4] [p=%f q=6] [p=%g q=7] [p=%a q=1] [p=%c q=3]}
                                                                                                                              > =a `(map @tas @)`(malt (limo ~[a+1 b+2]))
                                                                                                                              > a
                                                                                                                              {[p=%b q=2] [p=%a q=1]}
                                                                                                                              
                                                                                                                              > `(map @tas @)`(~(gas by a) ~[a+100 b+200])
                                                                                                                              {[p=%b q=200] [p=%a q=100]}
                                                                                                                              > `(map @tas @)`(~(gas by `(map @tas @)`~) ~[a+100 b+200])
                                                                                                                              {[p=%b q=200] [p=%a q=100]}

                                                                                                                              ++get:by

                                                                                                                              Grab unit value

                                                                                                                              Produce the unit value of the value located at key b within map a.

                                                                                                                              Accepts

                                                                                                                              a is a map, and is the sample of +by.

                                                                                                                              b is a key as a noun.

                                                                                                                              Produces

                                                                                                                              A unit.

                                                                                                                              Source

                                                                                                                              ++  get
                                                                                                                                ~/  %get
                                                                                                                                |*  b=*
                                                                                                                                =>  .(b `_?>(?=(^ a) p.n.a)`b)
                                                                                                                                |-  ^-  (unit _?>(?=(^ a) q.n.a))
                                                                                                                                ?~  a
                                                                                                                                  ~
                                                                                                                                ?:  =(b p.n.a)
                                                                                                                                  (some q.n.a)
                                                                                                                                ?:  (gor b p.n.a)
                                                                                                                                  $(a l.a)
                                                                                                                                $(a r.a)
                                                                                                                              

                                                                                                                              Examples

                                                                                                                              > a
                                                                                                                              {[p=%b q=2] [p=%d q=4] [p=%a q=1] [p=%c q=3]}
                                                                                                                              
                                                                                                                              > (~(get by a) %a)
                                                                                                                              [~ 1]
                                                                                                                              
                                                                                                                              > (~(get by a) %b)
                                                                                                                              [~ 2]
                                                                                                                              
                                                                                                                              > (~(get by a) %z)
                                                                                                                              ~

                                                                                                                              ++got:by

                                                                                                                              Assert

                                                                                                                              Produce the value located at key b within map a. Crash if key b does not exist.

                                                                                                                              Accepts

                                                                                                                              a is a map, and is the sample of +by.

                                                                                                                              b is a key as a noun.

                                                                                                                              Produces

                                                                                                                              A noun.

                                                                                                                              Source

                                                                                                                              ++  got
                                                                                                                                |*  b=*
                                                                                                                                (need (get b))
                                                                                                                              

                                                                                                                              Examples

                                                                                                                              > =a `(map @tas @)`(malt (limo ~[a+1 b+2 c+3 d+4]))
                                                                                                                              > a
                                                                                                                              {[p=%b q=2] [p=%d q=4] [p=%a q=1] [p=%c q=3]}
                                                                                                                              
                                                                                                                              > (~(got by a) %a)
                                                                                                                              1
                                                                                                                              
                                                                                                                              > (~(got by a) %b)
                                                                                                                              2
                                                                                                                              
                                                                                                                              > (~(got by a) %z)
                                                                                                                              dojo: hoon expression failed

                                                                                                                              ++gut:by

                                                                                                                              Grab value with default

                                                                                                                              Produce the value located at key b within map a. Use default value c if key does not exist.

                                                                                                                              Accepts

                                                                                                                              a is a map, and is the sample of +by.

                                                                                                                              b is a key as a noun.

                                                                                                                              c is a noun.

                                                                                                                              Produces

                                                                                                                              A noun.

                                                                                                                              Source

                                                                                                                              ++  gut
                                                                                                                                |*  [b=* c=*]
                                                                                                                                (fall (get b) c)
                                                                                                                              

                                                                                                                              Examples

                                                                                                                              > =a `(map @tas @)`(malt (limo ~[a+1 b+2 c+3 d+4]))
                                                                                                                              > a
                                                                                                                              {[p=%b q=2] [p=%d q=4] [p=%a q=1] [p=%c q=3]}
                                                                                                                              
                                                                                                                              > (~(gut by a) %a 9.999)
                                                                                                                              1
                                                                                                                              
                                                                                                                              > (~(gut by a) %b 9.999)
                                                                                                                              2
                                                                                                                              
                                                                                                                              > (~(gut by a) %z 9.999)
                                                                                                                              9.999

                                                                                                                              ++has:by

                                                                                                                              Key existence check

                                                                                                                              Checks whether map a contains an element with key b, producing a flag.

                                                                                                                              Accepts

                                                                                                                              a is a map, and is the sample of +by.

                                                                                                                              b is a key as a noun.

                                                                                                                              Produces

                                                                                                                              A flag.

                                                                                                                              Source

                                                                                                                              ++  has
                                                                                                                                ~/  %has
                                                                                                                                |*  b=*
                                                                                                                                !=(~ (get b))
                                                                                                                              

                                                                                                                              Examples

                                                                                                                              > =a `(map @tas @)`(malt (limo ~[a+1 b+2 c+3 d+4]))
                                                                                                                              > a
                                                                                                                              {[p=%b q=2] [p=%d q=4] [p=%a q=1] [p=%c q=3]}
                                                                                                                              
                                                                                                                              > (~(has by a) %a)
                                                                                                                              %.y
                                                                                                                              > (~(has by a) %z)
                                                                                                                              %.n

                                                                                                                              ++int:by

                                                                                                                              Intersection

                                                                                                                              Produces a map of the (key) intersection between two maps of the same type, a and b. If both maps have an identical key that point to different values, the element from map b is used.

                                                                                                                              Accepts

                                                                                                                              a is a map, and is the sample of +by.

                                                                                                                              b is a map.

                                                                                                                              Produces

                                                                                                                              A map.

                                                                                                                              Source

                                                                                                                              ++  int
                                                                                                                                ~/  %int
                                                                                                                                =+  b=a
                                                                                                                                |@
                                                                                                                                ++  $
                                                                                                                                  |-  ^+  a
                                                                                                                                  ?~  b
                                                                                                                                    ~
                                                                                                                                  ?~  a
                                                                                                                                    ~
                                                                                                                                  ?:  (mor p.n.a p.n.b)
                                                                                                                                    ?:  =(p.n.b p.n.a)
                                                                                                                                      b(l $(a l.a, b l.b), r $(a r.a, b r.b))
                                                                                                                                    ?:  (gor p.n.b p.n.a)
                                                                                                                                      %-  uni(a $(a l.a, r.b ~))  $(b r.b)
                                                                                                                                    %-  uni(a $(a r.a, l.b ~))  $(b l.b)
                                                                                                                                  ?:  =(p.n.a p.n.b)
                                                                                                                                    b(l $(b l.b, a l.a), r $(b r.b, a r.a))
                                                                                                                                  ?:  (gor p.n.a p.n.b)
                                                                                                                                    %-  uni(a $(b l.b, r.a ~))  $(a r.a)
                                                                                                                                  %-  uni(a $(b r.b, l.a ~))  $(a l.a)
                                                                                                                                --
                                                                                                                              

                                                                                                                              Examples

                                                                                                                              > =a `(map @tas @)`(malt (limo ~[a+1 b+2 c+3 d+4]))
                                                                                                                              > =b `(map @tas @)`(malt (limo ~[c+3 d+4 e+5 f+6]))
                                                                                                                              > a
                                                                                                                              {[p=%b q=2] [p=%d q=4] [p=%a q=1] [p=%c q=3]}
                                                                                                                              > b
                                                                                                                              {[p=%e q=5] [p=%d q=4] [p=%f q=6] [p=%c q=3]}
                                                                                                                              
                                                                                                                              > `(map @tas @)`(~(int by a) b)
                                                                                                                              {[p=%d q=4] [p=%c q=3]}
                                                                                                                              > =a `(map @tas @)`(malt (limo ~[a+1 b+2]))
                                                                                                                              > =b `(map @tas @)`(malt (limo ~[a+100 b+200]))
                                                                                                                              > a
                                                                                                                              {[p=%b q=2] [p=%a q=1]}
                                                                                                                              > b
                                                                                                                              {[p=%b q=200] [p=%a q=100]}
                                                                                                                              
                                                                                                                              > `(map @tas @)`(~(int by a) b)
                                                                                                                              {[p=%b q=200] [p=%a q=100]}

                                                                                                                              ++jab:by

                                                                                                                              Transform value

                                                                                                                              Produce map a with the value at key b transformed by gate c.

                                                                                                                              Accepts

                                                                                                                              a is a map, and is the sample of +by.

                                                                                                                              b is a noun, and a key in a.

                                                                                                                              c is a gate.

                                                                                                                              Produces

                                                                                                                              A map.

                                                                                                                              Source

                                                                                                                              ++  jab
                                                                                                                                ~/  %jab
                                                                                                                                |*  [key=_?>(?=(^ a) p.n.a) fun=$-(_?>(?=(^ a) q.n.a) _?>(?=(^ a) q.n.a))]
                                                                                                                                ^+  a
                                                                                                                                ::
                                                                                                                                ?~  a  !!
                                                                                                                                ::
                                                                                                                                ?:  =(key p.n.a)
                                                                                                                                  a(q.n (fun q.n.a))
                                                                                                                                ::
                                                                                                                                ?:  (gor key p.n.a)
                                                                                                                                  a(l $(a l.a))
                                                                                                                                ::
                                                                                                                                a(r $(a r.a))
                                                                                                                              

                                                                                                                              Examples

                                                                                                                              > =a `(map @tas @)`(malt (limo ~[a+1 b+2 c+3 d+4]))
                                                                                                                              > a
                                                                                                                              {[p=%b q=2] [p=%d q=4] [p=%a q=1] [p=%c q=3]}
                                                                                                                              
                                                                                                                              > `(map @tas @)`(~(jab by a) %d |=(x=@ (pow x 2)))
                                                                                                                              {[p=%b q=2] [p=%d q=16] [p=%a q=1] [p=%c q=3]}
                                                                                                                              
                                                                                                                              > (~(jab by a) %z |=(x=@ (pow x 2)))
                                                                                                                              dojo: hoon expression failed
                                                                                                                              
                                                                                                                              > (~(jab by a) %d |=(a=@ [a a]))
                                                                                                                              -need.?(%~ [n=[p=@tas q=@] l=nlr([p=@tas q=@]) r=nlr([p=@tas q=@])])
                                                                                                                              -have.[n=[p=@tas q=[@ @]] l=nlr([p=@tas q=@]) r=nlr([p=@tas q=@])]
                                                                                                                              nest-fail
                                                                                                                              dojo: hoon expression failed

                                                                                                                              ++key:by

                                                                                                                              Set of keys

                                                                                                                              Produces a set of all keys in map a.

                                                                                                                              Accepts

                                                                                                                              a is a map, and is the sample of +by.

                                                                                                                              Produces

                                                                                                                              A set.

                                                                                                                              Source

                                                                                                                              ++  key
                                                                                                                                =<  $
                                                                                                                                ~/  %key
                                                                                                                                =+  b=`(set _?>(?=(^ a) p.n.a))`~
                                                                                                                                |.  ^+  b
                                                                                                                                ?~  a   b
                                                                                                                                $(a r.a, b $(a l.a, b (~(put in b) p.n.a)))
                                                                                                                              

                                                                                                                              Examples

                                                                                                                              > =a `(map @tas @)`(malt (limo ~[a+1 b+2 c+3 d+4]))
                                                                                                                              
                                                                                                                              > ~(key by a)
                                                                                                                              {%b %d %a %c}

                                                                                                                              ++mar:by

                                                                                                                              Add with validation

                                                                                                                              Produces map a with the addition of key-value pair b and c, where the value is a nonempty unit.

                                                                                                                              Accept a noun and a unit of a noun of the type of the map's keys and values, respectively. Validate that the value is not null and put the pair in the map. If the value is null, delete the key.

                                                                                                                              Accepts

                                                                                                                              a is a map, and is the sample of +by.

                                                                                                                              b is a noun.

                                                                                                                              c is a unit.

                                                                                                                              Produces

                                                                                                                              A map.

                                                                                                                              Source

                                                                                                                              ++  mar
                                                                                                                                |*  [b=* c=(unit *)]
                                                                                                                                ?~  c
                                                                                                                                  (del b)
                                                                                                                                (put b u.c)
                                                                                                                              

                                                                                                                              Examples

                                                                                                                              > =a `(map @tas @)`(malt (limo ~[a+1 b+2 c+3 d+4]))
                                                                                                                              > a
                                                                                                                              {[p=%b q=2] [p=%d q=4] [p=%a q=1] [p=%c q=3]}
                                                                                                                              
                                                                                                                              > `(map @tas @)`(~(mar by a) %e (some 5))
                                                                                                                              {[p=%e q=5] [p=%b q=2] [p=%d q=4] [p=%a q=1] [p=%c q=3]}
                                                                                                                              
                                                                                                                              > `(map @tas @)`(~(mar by a) %a (some 10))
                                                                                                                              {[p=%b q=2] [p=%d q=4] [p=%a q=10] [p=%c q=3]}
                                                                                                                              
                                                                                                                              > `(map @tas @)`(~(mar by a) %a ~)
                                                                                                                              {[p=%b q=2] [p=%d q=4] [p=%c q=3]}

                                                                                                                              ++put:by

                                                                                                                              Add key-value pair

                                                                                                                              Produces a with the addition of the key-value pair of b and c.

                                                                                                                              Accepts

                                                                                                                              a is a map, and is the sample of +by.

                                                                                                                              b is a key of the same type as the keys in a.

                                                                                                                              c is a value of the same type of the values in a.

                                                                                                                              Produces

                                                                                                                              A map.

                                                                                                                              Source

                                                                                                                              ++  put
                                                                                                                                ~/  %put
                                                                                                                                |*  [b=* c=*]
                                                                                                                                |-  ^+  a
                                                                                                                                ?~  a
                                                                                                                                  [[b c] ~ ~]
                                                                                                                                ?:  =(b p.n.a)
                                                                                                                                  ?:  =(c q.n.a)
                                                                                                                                    a
                                                                                                                                  a(n [b c])
                                                                                                                                ?:  (gor b p.n.a)
                                                                                                                                  =+  d=$(a l.a)
                                                                                                                                  ?>  ?=(^ d)
                                                                                                                                  ?:  (mor p.n.a p.n.d)
                                                                                                                                    a(l d)
                                                                                                                                  d(r a(l r.d))
                                                                                                                                =+  d=$(a r.a)
                                                                                                                                ?>  ?=(^ d)
                                                                                                                                ?:  (mor p.n.a p.n.d)
                                                                                                                                  a(r d)
                                                                                                                                d(l a(r l.d))
                                                                                                                              

                                                                                                                              Examples

                                                                                                                              > =a `(map @tas @)`(malt (limo ~[a+1 b+2 c+3]))
                                                                                                                              > a
                                                                                                                              {[p=%b q=2] [p=%a q=1] [p=%c q=3]}
                                                                                                                              
                                                                                                                              > `(map @tas @)`(~(put by a) %d 4)
                                                                                                                              {[p=%b q=2] [p=%d q=4] [p=%a q=1] [p=%c q=3]}
                                                                                                                              
                                                                                                                              > `(map @tas @)`(~(put by a) %a 10)
                                                                                                                              {[p=%b q=2] [p=%a q=10] [p=%c q=3]}
                                                                                                                              
                                                                                                                              > (~(put by a) 42 'foo')
                                                                                                                              mull-grow
                                                                                                                              mull-nice
                                                                                                                              -need.?(%~ [n=[p=@tas q=@] l=nlr([p=@tas q=@]) r=nlr([p=@tas q=@])])
                                                                                                                              -have.[[@ud @t] %~ %~]
                                                                                                                              nest-fail
                                                                                                                              dojo: hoon expression failed

                                                                                                                              ++rep:by

                                                                                                                              Reduce to product

                                                                                                                              Accumulate elements of map a using gate b, producing a noun.

                                                                                                                              Accepts

                                                                                                                              a is a map.

                                                                                                                              b is a gate.

                                                                                                                              Produces

                                                                                                                              A noun.

                                                                                                                              Source

                                                                                                                              ++  rep
                                                                                                                                ~/  %rep
                                                                                                                                |*  b=_=>(~ |=([* *] +<+))
                                                                                                                                |-
                                                                                                                                ?~  a  +<+.b
                                                                                                                                $(a r.a, +<+.b $(a l.a, +<+.b (b n.a +<+.b)))
                                                                                                                              

                                                                                                                              Examples

                                                                                                                              > =a `(map @tas @)`(malt (limo ~[a+1 b+2 c+3 d+4]))
                                                                                                                              > a
                                                                                                                              {[p=%b q=2] [p=%d q=4] [p=%a q=1] [p=%c q=3]}
                                                                                                                              
                                                                                                                              > (~(rep by a) |=([p=[@tas @] q=@] ~&([p q] (add +.p q))))
                                                                                                                              [[%b 2] 0]
                                                                                                                              [[%d 4] 2]
                                                                                                                              [[%c 3] 6]
                                                                                                                              [[%a 1] 9]
                                                                                                                              q=10

                                                                                                                              Discussion

                                                                                                                              The gate will iteratively be fed a cell whose head is a key-value pair from the map and whose tail is an accumulator, producing the final value of the accumulator.


                                                                                                                              ++rib:by

                                                                                                                              Transform + product

                                                                                                                              c is a gate with a sample like [[key value] accumulator] and a product like [accumulator [key value]]. Each key-value pair in map a is passed to c and replaced with the key-value pair c produced. The final value of the accumulator and the modified map are returned. b is the initial value of the accumulator.

                                                                                                                              Accepts

                                                                                                                              a is a map, and is the sample of +by.

                                                                                                                              b is a noun, and is the initial value of the accumulator.

                                                                                                                              c is a gate.

                                                                                                                              Produces

                                                                                                                              A cell of a noun and a map.

                                                                                                                              Source

                                                                                                                              ++  rib
                                                                                                                                |*  [b=* c=gate]
                                                                                                                                |-  ^+  [b a]
                                                                                                                                ?~  a  [b ~]
                                                                                                                                =+  d=(c n.a b)
                                                                                                                                =.  n.a  +.d
                                                                                                                                =+  e=$(a l.a, b -.d)
                                                                                                                                =+  f=$(a r.a, b -.e)
                                                                                                                                [-.f a(l +.e, r +.f)]
                                                                                                                              

                                                                                                                              Examples

                                                                                                                              In this example, all values less than three are changed to zero, and a list of their keys are produced along with the modified map.

                                                                                                                              > =a `(map @t @)`(malt ~[['a' 1] ['b' 2] ['c' 3] ['d' 4] ['e' 5]])
                                                                                                                              > a
                                                                                                                              {[p='e' q=5] [p='b' q=2] [p='d' q=4] [p='a' q=1] [p='c' q=3]}
                                                                                                                              
                                                                                                                              > =c |=  [[k=@t v=@] acc=(list @t)]
                                                                                                                                   ?:  (lth v 3)
                                                                                                                                     [[k acc] [k 0]]
                                                                                                                                   [acc [k v]]
                                                                                                                              
                                                                                                                              > `[(list @t) (map @t @)]`(~(rib by a) *(list @t) c)
                                                                                                                              [<|a b|> {[p='e' q=5] [p='b' q=0] [p='d' q=4] [p='a' q=0] [p='c' q=3]}]

                                                                                                                              Discussion

                                                                                                                              Key-value pairs in the map are transformed in their existing tree location. This means if you change the key, you'd likely produce a map with an incorrect order, so typically you should only change the value.


                                                                                                                              ++run:by

                                                                                                                              Transform values

                                                                                                                              Iterates over every value in map a using gate b, producing a map.

                                                                                                                              Accepts

                                                                                                                              a is a map, and is the sample of +by.

                                                                                                                              b is a gate.

                                                                                                                              Produces

                                                                                                                              A map.

                                                                                                                              Source

                                                                                                                              ++  run
                                                                                                                                ~/  %run
                                                                                                                                |*  b=gate
                                                                                                                                |-
                                                                                                                                ?~  a  a
                                                                                                                                [n=[p=p.n.a q=(b q.n.a)] l=$(a l.a) r=$(a r.a)]
                                                                                                                              

                                                                                                                              Examples

                                                                                                                              > =a `(map @t @)`(malt ~[['a' 1] ['b' 2] ['c' 3] ['d' 4] ['e' 5]])
                                                                                                                              
                                                                                                                              > `(map @t @)`(~(run by a) dec)
                                                                                                                              {[p='e' q=4] [p='b' q=1] [p='d' q=3] [p='a' q=0] [p='c' q=2]}

                                                                                                                              ++rut:by

                                                                                                                              Transform nodes

                                                                                                                              Applies a gate b to nodes in map a. The sample of gate b is a key-value pair, and it produces a new value.

                                                                                                                              Accepts

                                                                                                                              a is a map, and is the sample of +by.

                                                                                                                              b is a gate.

                                                                                                                              Produces

                                                                                                                              A map.

                                                                                                                              Source

                                                                                                                              ++  rut
                                                                                                                                |*  b=gate
                                                                                                                                |-
                                                                                                                                ?~  a  a
                                                                                                                                [n=[p=p.n.a q=(b p.n.a q.n.a)] l=$(a l.a) r=$(a r.a)]
                                                                                                                              

                                                                                                                              Examples

                                                                                                                              > =a `(map @ @)`(malt ~[[1 1] [2 2] [3 3] [4 4] [5 5]])
                                                                                                                              
                                                                                                                              > =b |=  [k=@ v=@]
                                                                                                                                   ?:  (gth v 2)
                                                                                                                                     (mul k v)
                                                                                                                                   v
                                                                                                                              
                                                                                                                              > `(map @ @)`(~(rut by a) b)
                                                                                                                              {[p=5 q=25] [p=1 q=1] [p=2 q=2] [p=3 q=9] [p=4 q=16]}

                                                                                                                              ++tap:by

                                                                                                                              Listify pairs

                                                                                                                              Produces the list of all elements in map a.

                                                                                                                              Accepts

                                                                                                                              a is a map, and is the sample of +by.

                                                                                                                              Produces

                                                                                                                              A list.

                                                                                                                              Source

                                                                                                                              ++  tap
                                                                                                                                =<  $
                                                                                                                                ~/  %tap
                                                                                                                                =+  b=`(list _?>(?=(^ a) n.a))`~
                                                                                                                                |.  ^+  b
                                                                                                                                ?~  a
                                                                                                                                  b
                                                                                                                                $(a r.a, b [n.a $(a l.a)])
                                                                                                                              

                                                                                                                              Examples

                                                                                                                              > =a `(map @ @)`(malt ~[[1 1] [2 2] [3 3] [4 4] [5 5]])
                                                                                                                              
                                                                                                                              > ~(tap by a)
                                                                                                                              ~[[p=4 q=4] [p=3 q=3] [p=2 q=2] [p=1 q=1] [p=5 q=5]]

                                                                                                                              ++uni:by

                                                                                                                              Union, merge

                                                                                                                              Produces a map of the union between the keys of a and b. If b shares a key with a, the tuple from b is preserved.

                                                                                                                              Accepts

                                                                                                                              a is a map, and is the sample +by.

                                                                                                                              b is a map.

                                                                                                                              Produces

                                                                                                                              A map.

                                                                                                                              Source

                                                                                                                              ++  uni
                                                                                                                                ~/  %uni
                                                                                                                                =+  b=a
                                                                                                                                |@
                                                                                                                                ++  $
                                                                                                                                  |-  ^+  a
                                                                                                                                  ?~  b
                                                                                                                                    a
                                                                                                                                  ?~  a
                                                                                                                                    b
                                                                                                                                  ?:  =(p.n.b p.n.a)
                                                                                                                                    b(l $(a l.a, b l.b), r $(a r.a, b r.b))
                                                                                                                                  ?:  (mor p.n.a p.n.b)
                                                                                                                                    ?:  (gor p.n.b p.n.a)
                                                                                                                                      $(l.a $(a l.a, r.b ~), b r.b)
                                                                                                                                    $(r.a $(a r.a, l.b ~), b l.b)
                                                                                                                                  ?:  (gor p.n.a p.n.b)
                                                                                                                                    $(l.b $(b l.b, r.a ~), a r.a)
                                                                                                                                  $(r.b $(b r.b, l.a ~), a l.a)
                                                                                                                                --
                                                                                                                              

                                                                                                                              Examples

                                                                                                                              > =a `(map @ @)`(malt ~[[1 1] [2 2] [3 3]])
                                                                                                                              > =b `(map @ @)`(malt ~[[3 300] [4 400] [5 500]])
                                                                                                                              > a
                                                                                                                              {[p=1 q=1] [p=2 q=2] [p=3 q=3]}
                                                                                                                              > b
                                                                                                                              {[p=5 q=500] [p=3 q=300] [p=4 q=400]}
                                                                                                                              
                                                                                                                              > `(map @ @)`(~(uni by a) b)
                                                                                                                              {[p=5 q=500] [p=1 q=1] [p=2 q=2] [p=3 q=300] [p=4 q=400]}

                                                                                                                              ++uno:by

                                                                                                                              General union

                                                                                                                              Produces a map of the union between the keys of a and b. If b shares a key with a, gate meg is applied to both and its product is used as the new value of the key in question.

                                                                                                                              Accepts

                                                                                                                              a is a map, and is the sample of +by.

                                                                                                                              b is a map, and is the sample of ~(uno by a).

                                                                                                                              meg is a gate, and is the sample of (~(uno by a) b).

                                                                                                                              Produces

                                                                                                                              A map.

                                                                                                                              Source

                                                                                                                              ++  uno
                                                                                                                                =+  b=a
                                                                                                                                |@
                                                                                                                                ++  $
                                                                                                                                  |=  meg=$-([_p:node _q:node _q:node] _q:node)
                                                                                                                                  |-  ^+  a
                                                                                                                                  ?~  b
                                                                                                                                    a
                                                                                                                                  ?~  a
                                                                                                                                    b
                                                                                                                                  ?:  =(p.n.b p.n.a)
                                                                                                                                    :+  [p.n.a (meg p.n.a q.n.a q.n.b)]
                                                                                                                                      $(b l.b, a l.a)
                                                                                                                                    $(b r.b, a r.a)
                                                                                                                                  ?:  (mor p.n.a p.n.b)
                                                                                                                                    ?:  (gor p.n.b p.n.a)
                                                                                                                                      $(l.a $(a l.a, r.b ~), b r.b)
                                                                                                                                    $(r.a $(a r.a, l.b ~), b l.b)
                                                                                                                                  ?:  (gor p.n.a p.n.b)
                                                                                                                                    $(l.b $(b l.b, r.a ~), a r.a)
                                                                                                                                  $(r.b $(b r.b, l.a ~), a l.a)
                                                                                                                                --
                                                                                                                              

                                                                                                                              Examples

                                                                                                                              > =a `(map @ @)`(malt ~[[1 1] [2 2] [3 3]])
                                                                                                                              > =b `(map @ @)`(malt ~[[3 3] [4 4] [5 5]])
                                                                                                                              > a
                                                                                                                              {[p=1 q=1] [p=2 q=2] [p=3 q=3]}
                                                                                                                              > b
                                                                                                                              {[p=5 q=5] [p=3 q=3] [p=4 q=4]}
                                                                                                                              
                                                                                                                              > `(map @ @)`((~(uno by a) b) |=([k=@ v=@ w=@] (add v w)))
                                                                                                                              {[p=5 q=5] [p=1 q=1] [p=2 q=2] [p=3 q=6] [p=4 q=4]}

                                                                                                                              ++urn:by

                                                                                                                              Turn (with key)

                                                                                                                              Iterates over every value in map a using gate b, which accepts both the key and the value of each element as its sample.

                                                                                                                              Accepts

                                                                                                                              a is a map.

                                                                                                                              b is a gate that accepts two nouns.

                                                                                                                              Produces

                                                                                                                              A map.

                                                                                                                              Source

                                                                                                                              ++  urn
                                                                                                                                ~/  %urn
                                                                                                                                |*  b=$-([* *] *)
                                                                                                                                |-
                                                                                                                                ?~  a  ~
                                                                                                                                a(n n.a(q (b p.n.a q.n.a)), l $(a l.a), r $(a r.a))
                                                                                                                              

                                                                                                                              Examples

                                                                                                                              > =a `(map @ @)`(malt ~[[1 1] [2 2] [3 3]])
                                                                                                                              > a
                                                                                                                              {[p=1 q=1] [p=2 q=2] [p=3 q=3]}
                                                                                                                              
                                                                                                                              > (~(urn by a) |=([k=@ v=@] (pow v 2)))
                                                                                                                              {[p=1 q=1] [p=2 q=4] [p=3 q=9]}

                                                                                                                              ++wyt:by

                                                                                                                              Depth

                                                                                                                              Produce the depth of the tree map a.

                                                                                                                              Accepts

                                                                                                                              a is a map, and is the sample of +by.

                                                                                                                              Produces

                                                                                                                              An atom.

                                                                                                                              Source

                                                                                                                              ++  wyt
                                                                                                                                =<  $
                                                                                                                                ~%  %wyt  +  ~
                                                                                                                                |.  ^-  @
                                                                                                                                ?~(a 0 +((add $(a l.a) $(a r.a))))
                                                                                                                              

                                                                                                                              Examples

                                                                                                                              > =a `(map @ @)`(malt ~[[1 1] [2 2] [3 3]])
                                                                                                                              > =b `(map @ @)`(malt ~[[1 1] [2 2] [3 3] [4 4] [5 5]])
                                                                                                                              > a
                                                                                                                              {[p=1 q=1] [p=2 q=2] [p=3 q=3]}
                                                                                                                              > b
                                                                                                                              {[p=5 q=5] [p=1 q=1] [p=2 q=2] [p=3 q=3] [p=4 q=4]}
                                                                                                                              
                                                                                                                              > ~(wyt by a)
                                                                                                                              3
                                                                                                                              
                                                                                                                              > ~(wyt by b)
                                                                                                                              5

                                                                                                                              ++val:by

                                                                                                                              List of values

                                                                                                                              Produces a list of all values in map a.

                                                                                                                              Accepts

                                                                                                                              a is a map.

                                                                                                                              Produces

                                                                                                                              A list.

                                                                                                                              Source

                                                                                                                              ++  val
                                                                                                                                =+  b=`(list _?>(?=(^ a) q.n.a))`~
                                                                                                                                |-  ^+  b
                                                                                                                                ?~  a   b
                                                                                                                                $(a r.a, b [q.n.a $(a l.a)])
                                                                                                                              

                                                                                                                              Examples

                                                                                                                              > =a `(map @t @)`(malt ~[['a' 1] ['b' 2] ['c' 3]])
                                                                                                                              > a
                                                                                                                              {[p='b' q=2] [p='a' q=1] [p='c' q=3]}
                                                                                                                              
                                                                                                                              > ~(val by a)
                                                                                                                              ~[3 1 2]

                                                                                                                              <-

                                                                                                                              2h: Set Logic

                                                                                                                              2j: Jar and Jug Logic

                                                                                                                              ->

                                                                                                                              Edit this page on GitHub