Urbit Developers
  • Hoon

    • Overview
    • Cheat Sheet
    • Irregular forms
    • Hoon Errors
    • Hoon Style Guide
    • Basic Types
    • Advanced Types
    • Auras
    • 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

        • 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
          • 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
          • 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
                            • 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

                                            • Ames
                                            • Aqua
                                            • Arm
                                            • Arvo
                                            • Atom
                                            • Azimuth
                                            • Battery
                                            • Behn
                                            • Bridge
                                            • Censures
                                            • chat
                                            • Claims
                                            • Clay
                                            • Comet
                                            • Core
                                            • Delegated Sending
                                            • Desk
                                            • Dill
                                            • Document Proposal
                                            • Dojo
                                            • Door
                                            • Ecliptic
                                            • Event Log
                                            • Eyre
                                            • Galaxy
                                            • Gall
                                            • Gate
                                            • HD Wallet
                                            • Hoon
                                            • Invite Tree
                                            • Iris
                                            • Jael
                                            • Keyfile
                                            • Khan
                                            • 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
                                            • Additional

                                              • Cryptography
                                              • Software Distribution

                                                • Overview
                                                • Docket File
                                                • Glob
                                              Urbit Developers
                                              • Hoon

                                                • Overview
                                                • Cheat Sheet
                                                • Irregular forms
                                                • Hoon Errors
                                                • Hoon Style Guide
                                                • Basic Types
                                                • Advanced Types
                                                • Auras
                                                • 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

                                                    • 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
                                                      • 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
                                                      • 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
                                                                        • 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

                                                                                        • Ames
                                                                                        • Aqua
                                                                                        • Arm
                                                                                        • Arvo
                                                                                        • Atom
                                                                                        • Azimuth
                                                                                        • Battery
                                                                                        • Behn
                                                                                        • Bridge
                                                                                        • Censures
                                                                                        • chat
                                                                                        • Claims
                                                                                        • Clay
                                                                                        • Comet
                                                                                        • Core
                                                                                        • Delegated Sending
                                                                                        • Desk
                                                                                        • Dill
                                                                                        • Document Proposal
                                                                                        • Dojo
                                                                                        • Door
                                                                                        • Ecliptic
                                                                                        • Event Log
                                                                                        • Eyre
                                                                                        • Galaxy
                                                                                        • Gall
                                                                                        • Gate
                                                                                        • HD Wallet
                                                                                        • Hoon
                                                                                        • Invite Tree
                                                                                        • Iris
                                                                                        • Jael
                                                                                        • Keyfile
                                                                                        • Khan
                                                                                        • 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
                                                                                        • Additional

                                                                                          • Cryptography
                                                                                          • Software Distribution

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

                                                                                          2c: Bit Arithmetic

                                                                                          ++bex

                                                                                          Binary exponent

                                                                                          Computes the result of 2^a, where a is a block size (see $bloq), producing an atom.

                                                                                          Accepts

                                                                                          a is an bloq.

                                                                                          Produces

                                                                                          An atom.

                                                                                          Source

                                                                                          ++ bex
                                                                                          ~/ %bex
                                                                                          |= a=bloq
                                                                                          ^- @
                                                                                          ?: =(0 a) 1
                                                                                          (mul 2 $(a (dec a)))

                                                                                          Examples

                                                                                          > (bex 4)
                                                                                          16
                                                                                          > (bex (add 19 1))
                                                                                          1.048.576
                                                                                          > (bex 0)
                                                                                          1

                                                                                          ++can

                                                                                          Assemble

                                                                                          Produces an atom from a list b of length-value pairs p and q, where p is the length in blocks of size a, and q is an atomic value.

                                                                                          Accepts

                                                                                          a is a block size (see $bloq).

                                                                                          b is a list of length-value pairs, p and q:

                                                                                          • p is a step.
                                                                                          • q is a @.

                                                                                          Produces

                                                                                          An atom.

                                                                                          Source

                                                                                          ++ can
                                                                                          ~/ %can
                                                                                          |= [a=bloq b=(list [p=step q=@])]
                                                                                          ^- @
                                                                                          ?~ b 0
                                                                                          (add (end [a p.i.b] q.i.b) (lsh [a p.i.b] $(b t.b)))

                                                                                          Examples

                                                                                          > `@ub`21 :: @ub is the binary aura
                                                                                          0b1.0101
                                                                                          > `@ub`(can 3 ~[[1 21]])
                                                                                          0b1.0101
                                                                                          > `@ub`(can 3 ~[[1 1]])
                                                                                          0b1
                                                                                          > `@ub`(can 0 ~[[1 255]])
                                                                                          0b1
                                                                                          > `@ux`(can 3 [3 0xc1] [1 0xa] ~) :: @ux is the hexadecimal aura
                                                                                          0xa00.00c1
                                                                                          > `@ux`(can 3 [3 0xc1] [1 0xa] [1 0x23] ~)
                                                                                          0x23.0a00.00c1
                                                                                          > `@ux`(can 4 [3 0xc1] [1 0xa] [1 0x23] ~)
                                                                                          0x23.000a.0000.0000.00c1
                                                                                          > `@ux`(can 3 ~[[1 'a'] [2 'bc']])
                                                                                          0x63.6261

                                                                                          ++cat

                                                                                          Concatenate

                                                                                          Concatenates two atoms, b and c, according to block size a, producing an atom.

                                                                                          Accepts

                                                                                          a is a block size (see $bloq).

                                                                                          b is an atom.

                                                                                          c is an atom.

                                                                                          Produces

                                                                                          An atom.

                                                                                          Source

                                                                                          ++ cat
                                                                                          ~/ %cat
                                                                                          |= [a=bloq b=@ c=@]
                                                                                          (add (lsh [a (met a b)] c) b)

                                                                                          Examples

                                                                                          > `@ub`(cat 3 1 0) :: @ub is the binary aura
                                                                                          0b1
                                                                                          > `@ub`(cat 0 1 1)
                                                                                          0b11
                                                                                          > `@ub`(cat 0 2 1)
                                                                                          0b110
                                                                                          > `@ub`(cat 2 1 1)
                                                                                          0b1.0001
                                                                                          > `@ub`256
                                                                                          0b1.0000.0000
                                                                                          > `@ub`255
                                                                                          0b1111.1111
                                                                                          > `@ub`(cat 3 256 255)
                                                                                          0b1111.1111.0000.0001.0000.0000
                                                                                          > `@ub`(cat 2 256 255)
                                                                                          0b1111.1111.0001.0000.0000
                                                                                          > (cat 3 256 255)
                                                                                          16.711.936
                                                                                          > (cat 2 256 255)
                                                                                          1.044.736

                                                                                          ++cut

                                                                                          Slice

                                                                                          Slices c blocks of size a that are positioned b blocks from the end of d. That slice is produced as an atom.

                                                                                          Accepts

                                                                                          a is a block size (see $bloq).

                                                                                          [b c] where:

                                                                                          • b is a step.
                                                                                          • c is a step.

                                                                                          d is an atom.

                                                                                          Produces

                                                                                          An atom.

                                                                                          Source

                                                                                          ++ cut
                                                                                          ~/ %cut
                                                                                          |= [a=bloq [b=step c=step] d=@]
                                                                                          (end [a c] (rsh [a b] d))

                                                                                          Examples

                                                                                          > (cut 0 [1 1] 2)
                                                                                          1
                                                                                          > (cut 0 [2 1] 4)
                                                                                          1
                                                                                          > `@t`(cut 3 [0 3] 'abcdefgh') :: @t is the cord aura
                                                                                          'abc'
                                                                                          > `@t`(cut 3 [1 3] 'abcdefgh')
                                                                                          'bcd'
                                                                                          > `@ub`(cut 0 [0 3] 0b1111.0000.1101) :: @ub is the binary aura
                                                                                          0b101
                                                                                          > `@ub`(cut 0 [0 6] 0b1111.0000.1101)
                                                                                          0b1101
                                                                                          > `@ub`(cut 0 [4 6] 0b1111.0000.1101)
                                                                                          0b11.0000
                                                                                          > `@ub`(cut 0 [3 6] 0b1111.0000.1101)
                                                                                          0b10.0001

                                                                                          ++end

                                                                                          Tail

                                                                                          Produces an atom by taking the last step blocks of size bloq from b.

                                                                                          Accepts

                                                                                          a is an atom slice specifier (see $bite), which is a block size (see $bloq) with optional block count.

                                                                                          b is an atom.

                                                                                          Produces

                                                                                          An atom.

                                                                                          Source

                                                                                          ++ end
                                                                                          ~/ %end
                                                                                          |= [a=bite b=@]
                                                                                          =/ [=bloq =step] ?^(a a [a *step])
                                                                                          (mod b (bex (mul (bex bloq) step)))

                                                                                          Examples

                                                                                          > (end [2 2] 255)
                                                                                          255
                                                                                          > (end [3 1] 255)
                                                                                          255
                                                                                          > (end 3 255)
                                                                                          255
                                                                                          > (end 3 256)
                                                                                          0
                                                                                          > `@ub`12 :: @ub is the binary aura
                                                                                          0b1100
                                                                                          > `@ub`(end [0 3] 12)
                                                                                          0b100
                                                                                          > (end [0 3] 12)
                                                                                          4
                                                                                          > `@ub`(end [1 3] 12)
                                                                                          0b1100
                                                                                          > (end [1 3] 12)
                                                                                          12
                                                                                          > `@ux`'abc' :: @ux is the hexademical aura
                                                                                          0x63.6261
                                                                                          > `@ux`(end [3 2] 'abc')
                                                                                          0x6261
                                                                                          > `@t`(end [3 2] 'abc') :: @t is the cord aura
                                                                                          'ab'

                                                                                          ++fil

                                                                                          Fill bloqstream

                                                                                          Produces an atom by repeating c for b blocks of size a.

                                                                                          Accepts

                                                                                          a is a block size (see $bloq).

                                                                                          b is a step.

                                                                                          c is an atom.

                                                                                          Produces

                                                                                          An atom.

                                                                                          Source

                                                                                          ++ fil
                                                                                          ~/ %fil
                                                                                          |= [a=bloq b=step c=@]
                                                                                          =| n=@ud
                                                                                          =. c (end a c)
                                                                                          =/ d c
                                                                                          |- ^- @
                                                                                          ?: =(n b)
                                                                                          (rsh a d)
                                                                                          $(d (add c (lsh a d)), n +(n))

                                                                                          Examples

                                                                                          > `@t`(fil 3 5 %a) :: @t is the cord (string) aura
                                                                                          'aaaaa'
                                                                                          > `@t`(fil 5 10 %ceeb)
                                                                                          'ceebceebceebceebceebceebceebceebceebceeb'
                                                                                          > `@t`(fil 4 10 'eced')
                                                                                          'ecececececececececec'
                                                                                          > `@tas`(fil 4 10 %bf) :: @tas is the term aura
                                                                                          %bfbfbfbfbfbfbfbfbfbf
                                                                                          > `@ub`(fil 2 6 1) :: @ub is the binary aura
                                                                                          0b1.0001.0001.0001.0001.0001

                                                                                          ++lsh

                                                                                          Left-shift

                                                                                          Produces an atom by left-shifting b by step blocks of size bloq.

                                                                                          Accepts

                                                                                          a is an atom slice specifier (see $bite), which is a block size (see $bloq) with optional block count.

                                                                                          b is an atom.

                                                                                          Produces

                                                                                          An atom.

                                                                                          Source

                                                                                          ++ lsh
                                                                                          ~/ %lsh
                                                                                          |= [a=bite b=@]
                                                                                          =/ [=bloq =step] ?^(a a [a *step])
                                                                                          (mul b (bex (mul (bex bloq) step)))

                                                                                          Examples

                                                                                          > `@ub`1 :: @ub is the binary aura
                                                                                          0b1
                                                                                          > `@ub`(lsh [0 1] 1)
                                                                                          0b10
                                                                                          > (lsh [0 1] 1)
                                                                                          2
                                                                                          > (lsh 0 1)
                                                                                          2
                                                                                          > `@ub`255
                                                                                          0b1111.1111
                                                                                          > `@ub`(lsh [3 1] 255)
                                                                                          0b1111.1111.0000.0000
                                                                                          > (lsh [3 1] 255)
                                                                                          65.280

                                                                                          ++met

                                                                                          Measure

                                                                                          Computes the number of blocks of size a in b, producing an atom.

                                                                                          Accepts

                                                                                          a is a block size (see $bloq).

                                                                                          b is an atom.

                                                                                          Source

                                                                                          ++ met
                                                                                          ~/ %met
                                                                                          |= [a=bloq b=@]
                                                                                          ^- @
                                                                                          =+ c=0
                                                                                          |-
                                                                                          ?: =(0 b) c
                                                                                          $(b (rsh a b), c +(c))

                                                                                          Examples

                                                                                          > (met 0 1)
                                                                                          1
                                                                                          > (met 0 2)
                                                                                          2
                                                                                          > (met 3 255)
                                                                                          1
                                                                                          > (met 3 256)
                                                                                          2
                                                                                          > (met 3 'abcde')
                                                                                          5

                                                                                          ++rap

                                                                                          Assemble non-zero

                                                                                          Concatenates a list of atoms b using block size a, producing an atom.

                                                                                          Accepts

                                                                                          a is a block size (see ++bloq).

                                                                                          b is a list of atoms.

                                                                                          Produces

                                                                                          An atom.

                                                                                          Source

                                                                                          ++ rap
                                                                                          ~/ %rap
                                                                                          |= [a=bloq b=(list @)]
                                                                                          ^- @
                                                                                          ?~ b 0
                                                                                          (cat a i.b $(b t.b))

                                                                                          Examples

                                                                                          > `@ub`(rap 2 [1 2 3 4 ~]) :: @ub is the binary aura
                                                                                          0b100.0011.0010.0001
                                                                                          > `@ub`(rap 1 [1 2 3 4 ~])
                                                                                          0b1.0011.1001
                                                                                          > (rap 0 [0 0 0 ~])
                                                                                          0
                                                                                          > (rap 0 [1 0 1 ~])
                                                                                          3
                                                                                          > `@ub`3
                                                                                          0b11
                                                                                          > (rap 0 [0 1 0 0 1 2 ~])
                                                                                          11
                                                                                          > (rap 0 [1 1 2 ~])
                                                                                          11
                                                                                          > `@ub`11
                                                                                          0b1011

                                                                                          Discussion

                                                                                          Any element of the value 0 is not included in concatenation.


                                                                                          ++rep

                                                                                          Assemble single

                                                                                          Produces an atom by assembling a list of atoms b using block size a.

                                                                                          Accepts

                                                                                          a is an atom slice specifier (see $bite), which is a block size (see $bloq) with optional block count.

                                                                                          b is a list of atoms.

                                                                                          Produces

                                                                                          An atom.

                                                                                          Source

                                                                                          ++ rep
                                                                                          ~/ %rep
                                                                                          |= [a=bite b=(list @)]
                                                                                          =/ [=bloq =step] ?^(a a [a *step])
                                                                                          =| i=@ud
                                                                                          |- ^- @
                                                                                          ?~ b 0
                                                                                          %+ add $(i +(i), b t.b)
                                                                                          (lsh [bloq (mul step i)] (end [bloq step] i.b))

                                                                                          Examples

                                                                                          > `@ub`(rep 2 [1 2 3 4 ~]) :: @ub is the binary aura
                                                                                          0b100.0011.0010.0001
                                                                                          > (rep 0 [0 0 1 ~])
                                                                                          4
                                                                                          > (rep 0 [0 0 0 1 ~])
                                                                                          8
                                                                                          > `@ub`(rep 0 [0 0 0 1 ~])
                                                                                          0b1000
                                                                                          > `@ub`8
                                                                                          0b1000
                                                                                          > `@ub`(rep 0 [1 0 1 0 ~])
                                                                                          0b101
                                                                                          > `@ub`(rep 0 [1 2 3 4 ~])
                                                                                          0b101
                                                                                          > (rep 0 [0 1 0 1 ~])
                                                                                          10
                                                                                          > (rep 0 [1 0 1 0 1 ~])
                                                                                          21
                                                                                          > `@ub`21
                                                                                          0b10.1010
                                                                                          > `@ub`(rep 3 [12 166 8 34 ~])
                                                                                          0b10.0010.0000.1000.1010.0110.0000.1100
                                                                                          > `*`"abcd"
                                                                                          [97 98 99 100 0]
                                                                                          > `@t`(rep 3 "abcd") :: @t is the text aura
                                                                                          'abcd'

                                                                                          ++rev

                                                                                          Reverses block order, accounting for leading zeroes.

                                                                                          Produces an atom from the bits of dat in reverse order according to a block size boz and a size len.

                                                                                          If the total size is less than the length of dat, then only the first bits of dat up to the total size will be taken and reversed. If the total size is longer, trailing zeroes will be added.

                                                                                          Accepts

                                                                                          boz is a block size with optional block count (see $bloq).

                                                                                          len is a @ud of the number of blocks of size boz to be reversed.

                                                                                          dat is an atom.

                                                                                          Produces

                                                                                          An atom.

                                                                                          Source

                                                                                          ++ rev
                                                                                          ~/ %rev
                                                                                          |= [boz=bloq len=@ud dat=@]
                                                                                          ^- @
                                                                                          =. dat (end [boz len] dat)
                                                                                          %+ lsh
                                                                                          [boz (sub len (met boz dat))]
                                                                                          (swp boz dat)

                                                                                          Examples

                                                                                          > =a 0b1111.0000.1111.1010.0011
                                                                                          > `@ub`(rev 0 20 a)
                                                                                          0b1100.0101.1111.0000.1111
                                                                                          > `@ub`(rev 0 12 a)
                                                                                          0b1100.0101.1111
                                                                                          > `@ub`(rev 2 5 a)
                                                                                          0b11.1010.1111.0000.1111
                                                                                          > `@ub`(rev 2 4 a)
                                                                                          0b11.1010.1111.0000
                                                                                          > `@ub`(rev 2 6 a)
                                                                                          0b11.1010.1111.0000.1111.0000
                                                                                          > (rev 1 10 1.000)
                                                                                          179.200
                                                                                          > (rev 2 5 1.000)
                                                                                          582.400
                                                                                          > (rev 1 5 1.000)
                                                                                          175

                                                                                          ++rip

                                                                                          Disassemble

                                                                                          Produces a list of atoms from the bits of b using block size a.

                                                                                          Accepts

                                                                                          a is an atom slice specifier (see $bite), which is a block size (see $bloq) with optional block count.

                                                                                          b is an atom.

                                                                                          Produces

                                                                                          A list of atoms.

                                                                                          Source

                                                                                          ++ rip
                                                                                          ~/ %rip
                                                                                          |= [a=bite b=@]
                                                                                          ^- (list @)
                                                                                          ?: =(0 b) ~
                                                                                          [(end a b) $(b (rsh a b))]

                                                                                          Examples

                                                                                          > `@ub`155 :: @ub is the binary aura
                                                                                          0b1001.1011
                                                                                          > (rip 0 155)
                                                                                          ~[1 1 0 1 1 0 0 1]
                                                                                          > (rip 2 155)
                                                                                          ~[11 9]
                                                                                          > (rip 0 11)
                                                                                          ~[1 1 0 1]
                                                                                          > (rip 1 155)
                                                                                          ~[3 2 1 2]
                                                                                          > `@ub`256
                                                                                          0b1.0000.0000
                                                                                          > (rip 0 256)
                                                                                          ~[0 0 0 0 0 0 0 0 1]
                                                                                          > (rip 2 256)
                                                                                          ~[0 0 1]
                                                                                          > (rip 3 256)
                                                                                          ~[0 1]
                                                                                          > `tape`(rip 3 'abcd')
                                                                                          "abcd"

                                                                                          ++rsh

                                                                                          Right-shift

                                                                                          Right-shifts b by step blocks of size bloq, producing an atom.

                                                                                          Accepts

                                                                                          a is an atom slice specifier (see $bite), which is a block size (see $bloq) with optional block count.

                                                                                          b is an atom.

                                                                                          Produces

                                                                                          An atom.

                                                                                          Source

                                                                                          ++ rsh
                                                                                          ~/ %rsh
                                                                                          |= [a=bite b=@]
                                                                                          =/ [=bloq =step] ?^(a a [a *step])
                                                                                          (div b (bex (mul (bex bloq) step)))

                                                                                          Examples

                                                                                          > `@ub`145 :: @ub is the binary aura
                                                                                          0b1001.0001
                                                                                          > `@ub`(rsh [1 1] 145)
                                                                                          0b10.0100
                                                                                          > (rsh [1 1] 145)
                                                                                          36
                                                                                          > (rsh 1 145)
                                                                                          36
                                                                                          > `@ub`(rsh [2 1] 145)
                                                                                          0b1001
                                                                                          > (rsh [2 1] 145)
                                                                                          9
                                                                                          > `@ub`10
                                                                                          0b1010
                                                                                          > `@ub`(rsh [0 1] 10)
                                                                                          0b101
                                                                                          > (rsh [0 1] 10)
                                                                                          5
                                                                                          > `@ux`'abc'
                                                                                          0x63.6261
                                                                                          > `@t`(rsh [3 1] 'abc')
                                                                                          'bc'
                                                                                          > `@ux`(rsh [3 1] 'abc')
                                                                                          0x6362

                                                                                          ++run

                                                                                          ++turn into atom.

                                                                                          Disassembles atom b into slices specified by a, applies c to each slice, and reassembles the results back into an atom.

                                                                                          Accepts

                                                                                          a is an atom slice specifier (see $bite), which is a block size (see $bloq) with optional block count.

                                                                                          b is an atom.

                                                                                          c is a gate that accepts an atom and produces an atom.

                                                                                          Produces

                                                                                          An atom.

                                                                                          Source

                                                                                          ++ run
                                                                                          ~/ %run
                                                                                          |= [a=bite b=@ c=$-(@ @)]
                                                                                          (rep a (turn (rip a b) c))

                                                                                          Examples

                                                                                          > `@ux`65.535 :: @ux is the hexadecimal aura
                                                                                          0xffff
                                                                                          > `@ux`(run 2 65.535 dec) :: dec is the decrement gate
                                                                                          0xeeee

                                                                                          ++rut

                                                                                          ++turn into list.

                                                                                          Disassembles atom b into slices specified by a, applies c to each slice, and assembles the results back into a.

                                                                                          Accepts

                                                                                          a is an atom slice specifier (see $bite), which is a block size (see $bloq) with optional block count.

                                                                                          b is an atom.

                                                                                          c is a gate that accepts an atom.

                                                                                          Produces

                                                                                          A list.

                                                                                          Source

                                                                                          ++ rut
                                                                                          ~/ %rut
                                                                                          |* [a=bite b=@ c=$-(@ *)]
                                                                                          (turn (rip a b) c)

                                                                                          Examples

                                                                                          > `@ux`65.535 :: @ux is the hexadecimal aura
                                                                                          0xffff
                                                                                          > `(list @ux)`(rut 2 65.535 dec) :: dec is the decrement gate
                                                                                          ~[0xe 0xe 0xe 0xe]

                                                                                          ++sew

                                                                                          Stitch one atom into another

                                                                                          Replace c blocks of size a at offset b of atom e with c blocks of size a from atom d.

                                                                                          That is, take (end [a c] d) from d and overwrite the (cut a [b c] e) part of e.

                                                                                          Or in simpler terms, take from the start of d and replace some part of e with it.

                                                                                          Accepts

                                                                                          a is a $bloq (block size).

                                                                                          [b c d] where:

                                                                                          • b is a step specifying the number of bloqs to offset.
                                                                                          • b is a step specifying the number of bloqs to replace.
                                                                                          • d is the donor atom.

                                                                                          e is the recipient atom.

                                                                                          Produces

                                                                                          An atom.

                                                                                          Source

                                                                                          ++ sew
                                                                                          ~/ %sew
                                                                                          |= [a=bloq [b=step c=step d=@] e=@]
                                                                                          ^- @
                                                                                          %+ add
                                                                                          (can a b^e c^d ~)
                                                                                          =/ f [a (add b c)]
                                                                                          (lsh f (rsh f e))

                                                                                          Examples

                                                                                          > `@t`(sew 3 [0 0 'XXXX'] 'OOOO')
                                                                                          'OOOO'
                                                                                          > `@t`(sew 3 [0 1 'XXXX'] 'OOOO')
                                                                                          'XOOO'
                                                                                          > `@t`(sew 3 [2 1 'XXXX'] 'OOOO')
                                                                                          'OOXO'
                                                                                          > `@t`(sew 3 [2 2 'XXXX'] 'OOOO')
                                                                                          'OOXX'
                                                                                          > `@t`(sew 3 [0 4 'XXXX'] 'OOOO')
                                                                                          'XXXX'

                                                                                          ++swp

                                                                                          Reverse block order

                                                                                          Switches little-endian to big-endian and vice versa: produces an atom by reversing the block order of b using block size a.

                                                                                          Accepts

                                                                                          a is a block size (see $bloq).

                                                                                          b is an atom.

                                                                                          Produces

                                                                                          An atom

                                                                                          Source

                                                                                          ++ swp
                                                                                          ~/ %swp
                                                                                          |= [a=bloq b=@]
                                                                                          (rep a (flop (rip a b)))

                                                                                          Examples

                                                                                          > `@ub`24 :: @ub is the binary aura
                                                                                          0b1.1000
                                                                                          > (swp 0 24)
                                                                                          3
                                                                                          > `@ub`3
                                                                                          0b11
                                                                                          > (swp 0 0)
                                                                                          0
                                                                                          > (swp 0 128)
                                                                                          1

                                                                                          ++xeb

                                                                                          Binary logarithm

                                                                                          Computes the base-2 logarithm of a, producing an atom.

                                                                                          Accepts

                                                                                          a is an atom.

                                                                                          Produces

                                                                                          An atom.

                                                                                          Source

                                                                                          ++ xeb
                                                                                          ~/ %xeb
                                                                                          |= a=@
                                                                                          ^- @
                                                                                          (met 0 a)

                                                                                          Examples

                                                                                          > (xeb 31)
                                                                                          5
                                                                                          > (xeb 32)
                                                                                          6
                                                                                          > (xeb 49)
                                                                                          6
                                                                                          > (xeb 0)
                                                                                          0
                                                                                          > (xeb 1)
                                                                                          1
                                                                                          > (xeb 2)
                                                                                          2

                                                                                          ++fe

                                                                                          Modulo bloq

                                                                                          Core that contains arms for bloq and modular integer operations.

                                                                                          Accepts

                                                                                          a is a bloq.

                                                                                          Source

                                                                                          |_ a=bloq

                                                                                          ++dif:fe

                                                                                          Produces the difference between two atoms in the modular basis representation.

                                                                                          Accepts

                                                                                          a is a bloq (and is the sample of the parent core).

                                                                                          b is an atom.

                                                                                          c is an atom.

                                                                                          Produces

                                                                                          A @s.

                                                                                          Source

                                                                                          ++ dif
                                                                                          |=([b=@ c=@] (sit (sub (add out (sit b)) (sit c))))

                                                                                          Examples

                                                                                          > (~(dif fe 3) 63 64)
                                                                                          255
                                                                                          > (~(dif fe 3) 5 10)
                                                                                          251
                                                                                          > (~(dif fe 3) 0 1)
                                                                                          255
                                                                                          > (~(dif fe 0) 9 10)
                                                                                          1
                                                                                          > (~(dif fe 0) 9 11)
                                                                                          0
                                                                                          > (~(dif fe 0) 9 12)
                                                                                          1
                                                                                          > (~(dif fe 2) 9 12)
                                                                                          13
                                                                                          > (~(dif fe 2) 63 64)
                                                                                          15

                                                                                          ++inv:fe

                                                                                          Inverse

                                                                                          Inverts the order of the modular field.

                                                                                          Accepts

                                                                                          a is a bloq (and is the sample of the parent core).

                                                                                          b is a bloq. (see $bloq)

                                                                                          Produces

                                                                                          An atom.

                                                                                          Source

                                                                                          ++ inv |=(b=@ (sub (dec out) (sit b)))

                                                                                          Examples

                                                                                          > (~(inv fe 3) 255)
                                                                                          0
                                                                                          > (~(inv fe 3) 256)
                                                                                          255
                                                                                          > (~(inv fe 3) 0)
                                                                                          255
                                                                                          > (~(inv fe 3) 1)
                                                                                          254
                                                                                          > (~(inv fe 3) 2)
                                                                                          253
                                                                                          > (~(inv fe 3) 55)
                                                                                          200

                                                                                          ++net:fe

                                                                                          Flip endianness

                                                                                          Reverses bytes within a block.

                                                                                          Accepts

                                                                                          a is a bloq (and the sample of the parent core).

                                                                                          b is a bloq. (see $bloq)

                                                                                          Produces

                                                                                          An atom.

                                                                                          Source

                                                                                          ++ net |= b=@ ^- @
                                                                                          => .(b (sit b))
                                                                                          ?: (lte a 3)
                                                                                          b
                                                                                          =+ c=(dec a)
                                                                                          %+ con
                                                                                          (lsh c $(a c, b (cut c [0 1] b)))
                                                                                          $(a c, b (cut c [1 1] b))

                                                                                          Examples

                                                                                          > (~(net fe 3) 64)
                                                                                          64
                                                                                          > (~(net fe 3) 128)
                                                                                          128
                                                                                          > (~(net fe 3) 255)
                                                                                          255
                                                                                          > (~(net fe 3) 256)
                                                                                          0
                                                                                          > (~(net fe 3) 257)
                                                                                          1
                                                                                          > (~(net fe 3) 500)
                                                                                          244
                                                                                          > (~(net fe 3) 511)
                                                                                          255
                                                                                          > (~(net fe 3) 512)
                                                                                          0
                                                                                          > (~(net fe 3) 513)
                                                                                          1
                                                                                          > (~(net fe 3) 0)
                                                                                          0
                                                                                          > (~(net fe 3) 1)
                                                                                          1
                                                                                          > (~(net fe 0) 1)
                                                                                          1
                                                                                          > (~(net fe 0) 2)
                                                                                          0
                                                                                          > (~(net fe 0) 3)
                                                                                          1
                                                                                          > (~(net fe 6) 1)
                                                                                          72.057.594.037.927.936
                                                                                          > (~(net fe 6) 2)
                                                                                          144.115.188.075.855.872
                                                                                          > (~(net fe 6) 3)
                                                                                          216.172.782.113.783.808
                                                                                          > (~(net fe 6) 4)
                                                                                          288.230.376.151.711.744
                                                                                          > (~(net fe 6) 5)
                                                                                          360.287.970.189.639.680

                                                                                          ++out:fe

                                                                                          Max integer value

                                                                                          Produces the maximum integer value that the current block can store; 2^a^a.

                                                                                          Accepts

                                                                                          a is a bloq (and is the sample of the parent core).

                                                                                          Produces

                                                                                          An atom.

                                                                                          Source

                                                                                          ++ out (bex (bex a))

                                                                                          Examples

                                                                                          > ~(out fe 0)
                                                                                          2
                                                                                          > ~(out fe 1)
                                                                                          4
                                                                                          > ~(out fe 2)
                                                                                          16
                                                                                          > ~(out fe 3)
                                                                                          256
                                                                                          > ~(out fe 4)
                                                                                          65.536
                                                                                          > ~(out fe 10)
                                                                                          \/179.769.313.486.231.590.772.930.519.078.902.473.361.797.697.894.230.657.273\/
                                                                                          .430.081.157.732.675.805.500.963.132.708.477.322.407.536.021.120.113.879.87
                                                                                          1.393.357.658.789.768.814.416.622.492.847.430.639.474.124.377.767.893.424.8
                                                                                          65.485.276.302.219.601.246.094.119.453.082.952.085.005.768.838.150.682.342.
                                                                                          462.881.473.913.110.540.827.237.163.350.510.684.586.298.239.947.245.938.479
                                                                                          .716.304.835.356.329.624.224.137.216
                                                                                          \/ \/

                                                                                          ++rol:fe

                                                                                          Roll left

                                                                                          Rolls d to the left by c b-sized blocks.

                                                                                          Accepts

                                                                                          a is a bloq (and is the sample of the parent core).

                                                                                          b is a bloq.

                                                                                          c is an atom.

                                                                                          d is an atom.

                                                                                          Produces

                                                                                          An atom.

                                                                                          Source

                                                                                          ++ rol |= [b=bloq c=@ d=@] ^- @
                                                                                          =+ e=(sit d)
                                                                                          =+ f=(bex (sub a b))
                                                                                          =+ g=(mod c f)
                                                                                          (sit (con (lsh [b g] e) (rsh [b (sub f g)] e)))

                                                                                          Examples

                                                                                          > `@ux`(~(rol fe 6) 4 3 0xabac.dedf.1213)
                                                                                          0x1213.0000.abac.dedf
                                                                                          > `@ux`(~(rol fe 6) 4 2 0xabac.dedf.1213)
                                                                                          0xdedf.1213.0000.abac
                                                                                          > `@t`(~(rol fe 5) 3 1 'dfgh')
                                                                                          'hdfg'
                                                                                          > `@t`(~(rol fe 5) 3 2 'dfgh')
                                                                                          'ghdf'
                                                                                          > `@t`(~(rol fe 5) 3 0 'dfgh')
                                                                                          'dfgh'

                                                                                          ++ror:fe

                                                                                          Roll right

                                                                                          Rolls d to the right by c b-sized blocks.

                                                                                          Accepts

                                                                                          a is a bloq (and is the sample of the parent core).

                                                                                          b is a bloq.

                                                                                          c is an atom.

                                                                                          d is an atom.

                                                                                          Produces

                                                                                          An atom.

                                                                                          Source

                                                                                          ++ ror |= [b=bloq c=@ d=@] ^- @
                                                                                          =+ e=(sit d)
                                                                                          =+ f=(bex (sub a b))
                                                                                          =+ g=(mod c f)
                                                                                          (sit (con (rsh [b g] e) (lsh [b (sub f g)] e)))

                                                                                          Examples

                                                                                          > `@ux`(~(ror fe 6) 4 1 0xabac.dedf.1213)
                                                                                          0x1213.0000.abac.dedf
                                                                                          > `@ux`(~(ror fe 6) 3 5 0xabac.dedf.1213)
                                                                                          0xacde.df12.1300.00ab
                                                                                          > `@ux`(~(ror fe 6) 3 3 0xabac.dedf.1213)
                                                                                          0xdf12.1300.00ab.acde
                                                                                          > `@t`(~(rol fe 5) 3 0 'hijk')
                                                                                          'hijk'
                                                                                          > `@t`(~(rol fe 5) 3 1 'hijk')
                                                                                          'khij'
                                                                                          > `@t`(~(rol fe 5) 3 2 'hijk')
                                                                                          'jkhi'

                                                                                          ++sum:fe

                                                                                          Sum

                                                                                          Sums two numbers in this modular field.

                                                                                          Accepts

                                                                                          a is a bloq (and is the sample of the parent core).

                                                                                          b is an atom.

                                                                                          c is an atom.

                                                                                          Produces

                                                                                          An atom.

                                                                                          Source

                                                                                          ++ sum |=([b=@ c=@] (sit (add b c)))

                                                                                          Examples

                                                                                          > (~(sum fe 3) 10 250)
                                                                                          4
                                                                                          > (~(sum fe 0) 0 1)
                                                                                          1
                                                                                          > (~(sum fe 0) 0 2)
                                                                                          0
                                                                                          > (~(sum fe 2) 14 2)
                                                                                          0
                                                                                          > (~(sum fe 2) 14 3)
                                                                                          1
                                                                                          > (~(sum fe 4) 10.000 256)
                                                                                          10.256
                                                                                          > (~(sum fe 4) 10.000 100.000)
                                                                                          44.464

                                                                                          ++sit:fe

                                                                                          Enforce modulo

                                                                                          Produces an atom in the current modular block representation.

                                                                                          Accepts

                                                                                          a is a bloq (and is the sample of the parent core).

                                                                                          b is an atom.

                                                                                          Produces

                                                                                          An atom.

                                                                                          Source

                                                                                          ++ sit |=(b=@ (end a b))

                                                                                          Examples

                                                                                          > (~(sit fe 3) 255)
                                                                                          255
                                                                                          > (~(sit fe 3) 256)
                                                                                          0
                                                                                          > (~(sit fe 3) 257)
                                                                                          1
                                                                                          > (~(sit fe 2) 257)
                                                                                          1
                                                                                          > (~(sit fe 2) 10.000)
                                                                                          0
                                                                                          > (~(sit fe 2) 100)
                                                                                          4
                                                                                          > (~(sit fe 2) 19)
                                                                                          3
                                                                                          > (~(sit fe 2) 17)
                                                                                          1
                                                                                          > (~(sit fe 0) 17)
                                                                                          1
                                                                                          > (~(sit fe 0) 0)
                                                                                          0
                                                                                          > (~(sit fe 0) 1)
                                                                                          1

                                                                                          <-

                                                                                          2b: List Logic

                                                                                          2d: Bit Logic

                                                                                          ->

                                                                                          Edit this page on GitHub