Urbit Developers
  • Hoon

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

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

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

          • Limbs
          • Wings
          • Zuse

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

            • Overview
            • Ames

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

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

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

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

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

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

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

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

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

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

                                • Overview
                                • HTTP API
                                • Reference
                                • Gall

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

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

                                    • Scries
                                    • Subscriptions
                                    • Tutorials

                                      • Move Trace
                                      • Reference

                                        • Cryptography
                                        • Filesystem Hierarchy
                                      • Nock

                                        • Nock Definition
                                        • Explanation
                                        • Example
                                        • Implementations
                                        • Vere

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

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

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

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

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

                                                  • Overview
                                                  • Docket File
                                                  • Glob
                                                Urbit Developers
                                                • Hoon

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

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

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

                                                        • Limbs
                                                        • Wings
                                                        • Zuse

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

                                                          • Overview
                                                          • Ames

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

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

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

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

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

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

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

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

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

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

                                                                              • Overview
                                                                              • HTTP API
                                                                              • Reference
                                                                              • Gall

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

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

                                                                                  • Scries
                                                                                  • Subscriptions
                                                                                  • Tutorials

                                                                                    • Move Trace
                                                                                    • Reference

                                                                                      • Cryptography
                                                                                      • Filesystem Hierarchy
                                                                                    • Nock

                                                                                      • Nock Definition
                                                                                      • Explanation
                                                                                      • Example
                                                                                      • Implementations
                                                                                      • Vere

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

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

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

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

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

                                                                                                • Overview
                                                                                                • Docket File
                                                                                                • Glob
                                                                                              Reference/Hoon/Standard Library

                                                                                              2a: Unit Logic

                                                                                              ++biff

                                                                                              Unit as argument

                                                                                              Applies a function b that produces a unit to the unwrapped value of unit a (u.a). If a is empty, ~ is produced.

                                                                                              Accepts

                                                                                              a is a unit.

                                                                                              b is a function that accepts a noun and produces a unit.

                                                                                              Produces

                                                                                              A unit.

                                                                                              Source

                                                                                              ++ biff
                                                                                              |* [a=(unit) b=$-(* (unit))]
                                                                                              ?~ a ~
                                                                                              (b u.a)

                                                                                              Examples

                                                                                              > (biff (some 5) |=([email protected] (some (add a 2))))
                                                                                              [~ u=7]
                                                                                              > (biff ~ |=([email protected] (some (add a 2))))
                                                                                              ~

                                                                                              ++bind

                                                                                              Non-unit function to unit, producing unit

                                                                                              Applies a function b to the value (u.a) of a unit a, producing a unit. Used when you want a function that does not accept or produce a unit to both accept and produce a unit.

                                                                                              Accepts

                                                                                              a is a unit.

                                                                                              b is a function.

                                                                                              Produces

                                                                                              A unit.

                                                                                              Source

                                                                                              ++ bind
                                                                                              |* [a=(unit) b=gate]
                                                                                              ?~ a ~
                                                                                              [~ u=(b u.a)]

                                                                                              Examples

                                                                                              > (bind ((unit @) [~ 97]) ,@t)
                                                                                              [~ u='a']
                                                                                              > =a |=([email protected] (add a 1))
                                                                                              > (bind ((unit @) [~ 2]) a)
                                                                                              [~ u=3]

                                                                                              ++bond

                                                                                              Replace null

                                                                                              Replaces an empty unit b with the product of a called trap a. If the unit is not empty, then the original unit is produced.

                                                                                              Accepts

                                                                                              a is a trap.

                                                                                              b is a unit.

                                                                                              Produces

                                                                                              Either the product of a or the value inside of unit b.

                                                                                              Source

                                                                                              ++ bond
                                                                                              |* a=(trap)
                                                                                              |* b=(unit)
                                                                                              ?~ b $:a
                                                                                              u.b

                                                                                              Examples

                                                                                              > (bex 10)
                                                                                              1.024
                                                                                              > ((bond |.((bex 10))) ~)
                                                                                              1.024
                                                                                              > ((bond |.((bex 10))) (slaw %ud '123'))
                                                                                              123

                                                                                              ++both

                                                                                              Group unit values into pair

                                                                                              Produces ~ if either a or b are empty. Otherwise, produces a unit whose value is a cell of the values of two input units a and b.

                                                                                              Accepts

                                                                                              a is a unit.

                                                                                              b is a unit.

                                                                                              Produces

                                                                                              A unit of the two initial values.

                                                                                              Source

                                                                                              ++ both
                                                                                              |* [a=(unit) b=(unit)]
                                                                                              ?~ a ~
                                                                                              ?~ b ~
                                                                                              [~ u=[u.a u.b]]

                                                                                              Examples

                                                                                              > (both (some 1) (some %b))
                                                                                              [~ u=[1 %b]]
                                                                                              > (both ~ (some %b))
                                                                                              ~

                                                                                              ++clap

                                                                                              Combine two units with function

                                                                                              Applies a binary function c--which does not usually accept or produce a unit-- to the values of two units, a and b, producing a unit.

                                                                                              If a is null, produces b. If b is null, produces a. Otherwise, produces the produce of c in a unit.

                                                                                              Accepts

                                                                                              a is a unit.

                                                                                              b is a unit.

                                                                                              c is a function that performs a binary operation.

                                                                                              Produces

                                                                                              A unit.

                                                                                              Source

                                                                                              ++ clap
                                                                                              |* [a=(unit) b=(unit) c=_=>(~ |=(^ +<-))]
                                                                                              ?~ a b
                                                                                              ?~ b a
                                                                                              [~ u=(c u.a u.b)]

                                                                                              Examples

                                                                                              > (clap ~ `'b' |=([[email protected] [email protected]] `tape`[a b ~]))
                                                                                              [~ u='b']
                                                                                              > (clap `'a' ~ |=([[email protected] [email protected]] `tape`[a b ~]))
                                                                                              [~ u='a']
                                                                                              > (clap `'a' `'b' |=([[email protected] [email protected]] `tape`[a b ~]))
                                                                                              [~ u="ab"]

                                                                                              ++clef

                                                                                              Compose two units with function

                                                                                              Applies a binary function c--which does not usually accept units-- to the values of two units, a and b, producing a unit.

                                                                                              If a or b are null, produces null. Otherwise, produces the produce of c.

                                                                                              Accepts

                                                                                              a is a unit.

                                                                                              b is a unit.

                                                                                              c is a gate that takes a cell and produces a unit.

                                                                                              Produces

                                                                                              A unit.

                                                                                              Source

                                                                                              ++ clef
                                                                                              |* [a=(unit) b=(unit) c=_=>(~ |=(^ `+<-))]
                                                                                              ?~ a ~
                                                                                              ?~ b ~
                                                                                              (c u.a u.b)

                                                                                              Examples

                                                                                              > (clef ~ `'b' |=([[email protected] [email protected]] `(unit tape)`[~ [a b ~]]))
                                                                                              ~
                                                                                              > (clef `'a' ~ |=([[email protected] [email protected]] `(unit tape)`[~ [a b ~]]))
                                                                                              ~
                                                                                              > (clef `'a' `'b' |=([[email protected] [email protected]] `(unit tape)`[~ [a b ~]]))
                                                                                              [~ "ab"]

                                                                                              ++drop

                                                                                              Unit to list

                                                                                              Makes a ++list of the unwrapped value (u.a) of a unit a.

                                                                                              Accepts

                                                                                              a is a unit.

                                                                                              Produces

                                                                                              A list.

                                                                                              Source

                                                                                              ++ drop
                                                                                              |* a=(unit)
                                                                                              ?~ a ~
                                                                                              [i=u.a t=~]

                                                                                              Examples

                                                                                              > =a ((unit @) [~ 97])
                                                                                              > (drop a)
                                                                                              [i=97 t=~]
                                                                                              > =a ((unit @) [~])
                                                                                              > (drop a)
                                                                                              ~

                                                                                              ++fall

                                                                                              Give unit a default value

                                                                                              Produces a default value b for a unit a in cases where a is null.

                                                                                              Accepts

                                                                                              a is a unit.

                                                                                              b is a noun that's used as the default value.

                                                                                              Produces

                                                                                              Either a noun b or the unwrapped value of unit a.

                                                                                              Source

                                                                                              ++ fall
                                                                                              |* [a=(unit) b=*]
                                                                                              ?~(a b u.a)

                                                                                              Examples

                                                                                              > (fall ~ 'a')
                                                                                              'a'
                                                                                              > (fall [~ u=0] 'a')
                                                                                              0

                                                                                              ++flit

                                                                                              Make filter

                                                                                              Accepts gate a which produces a ?. Applies a to b, producing b wrapped in a unit if true, otherwise produces null.

                                                                                              +flit is a wet gate that takes a and produces a new wet gate that takes b.

                                                                                              Accepts

                                                                                              a is a gate which produces ?, and is the sample of the outer wet gate.

                                                                                              b is any noun, and is the sample of the inner wet gate.

                                                                                              Produces

                                                                                              (unit [type]), where [type] is the type of b.

                                                                                              Source

                                                                                              ++ flit
                                                                                              |* a=$-(* ?)
                                                                                              |* b=*
                                                                                              ?.((a b) ~ [~ u=b])

                                                                                              Examples

                                                                                              > =f (flit |=([email protected] ?:(=(ud 1) %.y %.n)))
                                                                                              > (f 1)
                                                                                              [~ 1]
                                                                                              > (f 2)
                                                                                              ~

                                                                                              ++hunt

                                                                                              First of units

                                                                                              Apply binary gate ord, which produces a ?, to units a and b. Produce a if true and b if false. If a is null, produce b. If b is null, produce a.

                                                                                              This allows selecting between two units by some rule.

                                                                                              Accepts

                                                                                              ord is a $-(^ ?) - a binary gate that produces ?.

                                                                                              a is a unit.

                                                                                              b is a unit.

                                                                                              Produces

                                                                                              A unit.

                                                                                              Source

                                                                                              ++ hunt
                                                                                              |* [ord=$-(^ ?) a=(unit) b=(unit)]
                                                                                              ^- %- unit
                                                                                              $? _?>(?=(^ a) u.a)
                                                                                              _?>(?=(^ b) u.b)
                                                                                              ==
                                                                                              ?~ a b
                                                                                              ?~ b a
                                                                                              ?:((ord u.a u.b) a b)

                                                                                              Examples

                                                                                              > (hunt gte ~ `20)
                                                                                              [~ 20]
                                                                                              > (hunt gte `10 ~)
                                                                                              [~ 10]
                                                                                              > (hunt gte `10 `20)
                                                                                              [~ 20]

                                                                                              ++lift

                                                                                              Curried bind

                                                                                              Accepts function a and produces a function that accepts unit b to which it applies a. Used when you want a function that does not accept or produce a unit to both accept and produce a unit.

                                                                                              Accepts

                                                                                              a is a mold.

                                                                                              b is a unit.

                                                                                              Produces

                                                                                              A unit.

                                                                                              Source

                                                                                              ++ lift
                                                                                              |* a=mold
                                                                                              |* b=(unit)
                                                                                              (bind b a)

                                                                                              Examples

                                                                                              > ((lift dec) `(unit @)`~)
                                                                                              ~
                                                                                              > ((lift dec) `(unit @)`[~ 20])
                                                                                              [~ 19]

                                                                                              ++mate

                                                                                              Choose

                                                                                              Accepts two units a and b whose values are expected to be equivalent. If either is empty, then the value of the other is produced. If neither are empty, it asserts that both values are the same and produces that value. If the assertion fails, ++mate crashes with 'mate' in the stack trace.

                                                                                              Accepts

                                                                                              a is a unit.

                                                                                              b is a unit.

                                                                                              Produces

                                                                                              A unit or crash.

                                                                                              Source

                                                                                              ++ mate
                                                                                              |* [a=(unit) b=(unit)]
                                                                                              ?~ b a
                                                                                              ?~ a b
                                                                                              ?.(=(u.a u.b) ~>(%mean.'mate' !!) a)

                                                                                              Examples

                                                                                              > =a ((unit @) [~ 97])
                                                                                              > =b ((unit @) [~ 97])
                                                                                              > (mate a b)
                                                                                              [~ 97]
                                                                                              > =a ((unit @) [~ 97])
                                                                                              > =b ((unit @) [~])
                                                                                              > (mate a b)
                                                                                              [~ 97]
                                                                                              > =a ((unit @) [~ 97])
                                                                                              > =b ((unit @) [~ 98])
                                                                                              > (mate a b)
                                                                                              ! 'mate'
                                                                                              ! exit

                                                                                              ++need

                                                                                              Unwrap unit

                                                                                              Retrieve the value from a unit and crash if the unit is null.

                                                                                              Accepts

                                                                                              a is a unit.

                                                                                              Produces

                                                                                              Either the unwrapped value of a (u.a), or crash.

                                                                                              Source

                                                                                              ++ need
                                                                                              ~/ %need
                                                                                              |* a=(unit)
                                                                                              ?~ a ~>(%mean.'need' !!)
                                                                                              u.a

                                                                                              Examples

                                                                                              > =a ((unit [@t @t]) [~ ['a' 'b']])
                                                                                              > (need a)
                                                                                              ['a' 'b']
                                                                                              > =a ((unit @ud) [~ 17])
                                                                                              > (need a)
                                                                                              17
                                                                                              > =a ((unit @) [~])
                                                                                              > (need a)
                                                                                              ! exit

                                                                                              ++some

                                                                                              Wrap value in a unit

                                                                                              Takes any noun a and produces a unit with the value set to a.

                                                                                              Accepts

                                                                                              a is a noun.

                                                                                              Produces

                                                                                              A unit.

                                                                                              Source

                                                                                              ++ some
                                                                                              |* a=*
                                                                                              [~ u=a]

                                                                                              Examples

                                                                                              > (some ['a' 'b'])
                                                                                              [~ u=['a' 'b']]
                                                                                              > (some &)
                                                                                              [~ u=%.y]

                                                                                              <-

                                                                                              1c: Molds and Mold-Builders

                                                                                              2b: List Logic

                                                                                              ->

                                                                                              Edit this page on GitHub

                                                                                              Last modified March 17, 2023