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/Zuse

                                                                                          2d(6): From JSON

                                                                                          ++dejs:format

                                                                                          Container arm for JSON decoding reparsers

                                                                                          The core inside this arm contains a large collection of functions for converting json data to other kinds of nouns. The json type is defined in lull.hoon as:

                                                                                          +$ json :: normal json value
                                                                                          $@ ~ :: null
                                                                                          $% [%a p=(list json)] :: array
                                                                                          [%b p=?] :: boolean
                                                                                          [%o p=(map @t json)] :: object
                                                                                          [%n p=@ta] :: number
                                                                                          [%s p=@t] :: string
                                                                                          == ::

                                                                                          This container arm doesn't do anything by itself. It just contains the core with the rest of the +dejs functions which are documented below, plus it defines a couple of things for those functions:

                                                                                          => |% ++ grub *
                                                                                          ++ fist $-(json grub)
                                                                                          -- ::

                                                                                          A fist is a gate which takes json and produces a grub. Apart from a handful of exceptions, all of the functions below are fists. If the functions below aren't adequate for a particular use case, custom fists can easily be written, as long as they conform to the $-(json grub) type definition.

                                                                                          A grub is just defined as *, and is the type of the product of a fist. In the case of +dejs, it can be absolutely any noun.

                                                                                          Keep in mind that +grub:dejs:format and +fist:dejs:format defined here (and subsequently referred to as simply fist and grub) are different to +grub:dejs-soft:format and +fist:dejs-soft:format for the +dejs-soft functions, which return units.


                                                                                          ++ar:dejs:format

                                                                                          Array as list

                                                                                          Convert array jon to a list, decoding each item in jon with wit.

                                                                                          The +ar function is a wet gate that takes wit and produces a new gate which takes jon.

                                                                                          Accepts

                                                                                          wit is a fist and is the sample of the wet gate.

                                                                                          jon is a json array containing the kind of json that wit handles. jon is the sample of the gate produced by the wet gate.

                                                                                          Produces

                                                                                          A (list [type]) where [type] is the type produced by wit.

                                                                                          Source

                                                                                          ++ ar
                                                                                          |* wit=fist
                                                                                          |= jon=json ^- (list _(wit *json))
                                                                                          ?> ?=([%a *] jon)
                                                                                          (turn p.jon wit)

                                                                                          Examples

                                                                                          > ((ar so):dejs:format a+[s+'foo' s+'bar' s+'baz' ~])
                                                                                          <|foo bar baz|>

                                                                                          ++as:dejs:format

                                                                                          Array as set

                                                                                          Convert array jon to a set, decoding each item in jon with a.

                                                                                          The +as function is a wet gate that takes a and produces a new gate which takes jon.

                                                                                          Accepts

                                                                                          a is a fist, and is the sample of the wet gate.

                                                                                          jon is a json array containing the kind of json that a takes. jon is the sample of the gate produced by the wet gate.

                                                                                          Produces

                                                                                          A (set [type]) where [type] is the type produced by a.

                                                                                          Source

                                                                                          ++ as
                                                                                          |* a=fist
                                                                                          (cu ~(gas in *(set _$:a)) (ar a))

                                                                                          Examples

                                                                                          > ((as so):dejs:format a+[s+'foo' s+'bar' s+'baz' ~])
                                                                                          [n='baz' l={'bar'} r={'foo'}]

                                                                                          ++at:dejs:format

                                                                                          Array as tuple

                                                                                          Convert array jon to a tuple, decoding each item in the array with the corresponding fist in list wil.

                                                                                          The +at function is a wet gate that takes wil and produces a new gate which takes jon.

                                                                                          Accepts

                                                                                          wil is a (pole fist), and is the sample of the wet gate. A pole is a faceless list.

                                                                                          jon is a json array whose elements are the same kinds of json accepted by the fists in wil and in the same order. jon is the sample of the gate produced by the wet gate.

                                                                                          Produces

                                                                                          A tuple of the same types and in the same order as those produced by the fists in wil.

                                                                                          Source

                                                                                          ++ at
                                                                                          |* wil=(pole fist)
                                                                                          |= jon=json
                                                                                          ?> ?=([%a *] jon)
                                                                                          ((at-raw wil) p.jon)

                                                                                          Examples

                                                                                          > ((at ~[so ni bo]):dejs:format a+[s+'foo' n+'123' b+& ~])
                                                                                          ['foo' 123 %.y]
                                                                                          > ((at ~[so ni bo]):dejs:format a+[b+& s+'foo' n+'123' ~])
                                                                                          dojo: hoon expression failed

                                                                                          ++at-raw:dejs:format

                                                                                          Array as tuple, raw

                                                                                          This function is used internally by +at and would not typically be used directly.

                                                                                          +at-raw converts list jol to a tuple, decoding each item in the list with the corresponding function in list wil.

                                                                                          The +at-raw function is a wet gate that takes wil and produces a new gate which takes jol.

                                                                                          Accepts

                                                                                          wil is a (pole fist), and the sample of the wet gate. A pole is a faceless list.

                                                                                          jol is a (list json) whose items are the same kinds of json accepted by the fists in wil and in the same order. jol is the sample of the gate produced by the wet gate.

                                                                                          Produces

                                                                                          A tuple of the types and in the same order as those produced by the fists in wil.

                                                                                          Source

                                                                                          ++ at-raw
                                                                                          |* wil=(pole fist)
                                                                                          |= jol=(list json)
                                                                                          ?~ jol !!
                                                                                          ?- wil
                                                                                          :: [wit=* t=*]
                                                                                          [* t=*]
                                                                                          => .(wil [wit *]=wil)
                                                                                          ?~ t.wil ?^(t.jol !! (wit.wil i.jol))
                                                                                          [(wit.wil i.jol) ((at-raw t.wil) t.jol)]
                                                                                          ==

                                                                                          Examples

                                                                                          > ((at-raw ~[so ni bo]):dejs:format ~[s+'foo' n+'123' b+&])
                                                                                          ['foo' 123 %.y]
                                                                                          > ((at-raw ~[so ni bo]):dejs:format ~[n+'123' s+'foo' b+&])
                                                                                          dojo: hoon expression failed

                                                                                          ++bo:dejs:format

                                                                                          Boolean

                                                                                          Convert boolean jon to a ?.

                                                                                          Accepts

                                                                                          jon is a json boolean.

                                                                                          Produces

                                                                                          A ?.

                                                                                          Source

                                                                                          ++ bo
                                                                                          |=(jon=json ?>(?=([%b *] jon) p.jon))

                                                                                          Examples

                                                                                          > (bo:dejs:format b+|)
                                                                                          %.n

                                                                                          ++bu:dejs:format

                                                                                          Boolean NOT

                                                                                          Convert the logical NOT of boolean jon to a ?.

                                                                                          Accepts

                                                                                          jon is a json boolean.

                                                                                          Produces

                                                                                          A ?.

                                                                                          Source

                                                                                          ++ bu
                                                                                          |=(jon=json ?>(?=([%b *] jon) !p.jon))

                                                                                          Examples

                                                                                          > (bu:dejs:format [%b %.y])
                                                                                          %.n

                                                                                          ++ci:dejs:format

                                                                                          Maybe transform

                                                                                          Decode jon with wit, then transform it with gate poq which produces a unit. Crash if the unit is ~ or else unwrap it and produce its data.

                                                                                          The +ci function is a wet gate that takes a poq and wit and produces a new gate that takes jon.

                                                                                          Accepts

                                                                                          poq is a gate that produces a unit.

                                                                                          wit is a fist.

                                                                                          The wet gate takes [poq=gate wit=fist].

                                                                                          jon is json of the kind accepted by wit. jon is the sample of the gate produced by the wet gate.

                                                                                          Produces

                                                                                          If gate poq produces (unit [type]), produce [type] or else crash.

                                                                                          Source

                                                                                          ++ ci
                                                                                          |* [poq=gate wit=fist]
                                                                                          |= jon=json
                                                                                          (need (poq (wit jon)))

                                                                                          Examples

                                                                                          > ((ci |=(a=? ?:(=(a &) `'foo' ~)) bo):dejs:format b+&)
                                                                                          'foo'
                                                                                          > ((ci |=(a=? ?:(=(a &) `'foo' ~)) bo):dejs:format b+|)
                                                                                          dojo: hoon expression failed

                                                                                          ++cu:dejs:format

                                                                                          Transform

                                                                                          Decode jon with wit, then transform it with gate poq.

                                                                                          The +cu function is a wet gate that takes poq and wit and produces a new gate that takes jon.

                                                                                          Accepts

                                                                                          poq is a gate.

                                                                                          wit is a fist.

                                                                                          The wet gate takes [poq=gate wit=fist].

                                                                                          jon is json of the kind handled by wit. jon is the sample of the gate produced by the wet gate.

                                                                                          Produces

                                                                                          The type produced by the gate given in poq.

                                                                                          Source

                                                                                          ++ cu
                                                                                          |* [poq=gate wit=fist]
                                                                                          |= jon=json
                                                                                          (poq (wit jon))

                                                                                          Examples

                                                                                          > ((cu |=([email protected] [t t t]) so):dejs:format s+'foo')
                                                                                          ['foo' 'foo' 'foo']

                                                                                          ++di:dejs:format

                                                                                          Millisecond date

                                                                                          Convert number jon, containing a Unix milliseconds timestamp, to a date.

                                                                                          Accepts

                                                                                          jon is a json number.

                                                                                          Produces

                                                                                          A @da.

                                                                                          Source

                                                                                          ++ di
                                                                                          (cu from-unix-ms:chrono:userlib ni)

                                                                                          Examples

                                                                                          > =time (time:enjs:format now)
                                                                                          > time
                                                                                          [%n p=~.1630471202176]
                                                                                          > (di:dejs:format time)
                                                                                          ~2021.9.1..04.40.02..2d0e.5604.1893.74bc

                                                                                          ++du:dejs:format

                                                                                          Second date

                                                                                          Convert number jon, containing a Unix seconds timestamp, to a date.

                                                                                          Accepts

                                                                                          jon is a json number.

                                                                                          Produces

                                                                                          A @da.

                                                                                          Source

                                                                                          ++ du
                                                                                          (cu from-unix:chrono:userlib ni)

                                                                                          Examples

                                                                                          > =sec (sect:enjs:format now)
                                                                                          > sec
                                                                                          [%n p=~.1630471524]
                                                                                          > (du:dejs:format sec)
                                                                                          ~2021.9.1..04.45.24

                                                                                          ++mu:dejs:format

                                                                                          True unit

                                                                                          Decode jon with wit, then wrap it in a unit. Produce ~ if jon is ~.

                                                                                          The +mu function is a wet gate that takes wit and produces a gate which takes jon.

                                                                                          Accepts

                                                                                          wit is a fist.

                                                                                          The wet gate takes wit=fist.

                                                                                          jon is json of the kind wit handles. jon is the sample of the gate produced by the wet gate.

                                                                                          Produces

                                                                                          A (unit [type]), where [type] is the type produced by the fist specified in wit.

                                                                                          Source

                                                                                          ++ mu
                                                                                          |* wit=fist
                                                                                          |= jon=json
                                                                                          ?~(jon ~ (some (wit jon)))

                                                                                          Examples

                                                                                          > ((mu so):dejs:format s+'foo')
                                                                                          [~ 'foo']
                                                                                          > ((mu so):dejs:format ~)
                                                                                          ~

                                                                                          ++ne:dejs:format

                                                                                          Number as real

                                                                                          Convert number jon to a @rd.

                                                                                          Accepts

                                                                                          jon is a json number.

                                                                                          Produces

                                                                                          A @rd.

                                                                                          Source

                                                                                          ++ ne
                                                                                          |= jon=json
                                                                                          ^- @rd
                                                                                          ?> ?=([%n *] jon)
                                                                                          (rash p.jon (cook ryld (cook royl-cell:^so json-rn)))

                                                                                          Examples

                                                                                          > (ne:dejs:format n+'123')
                                                                                          .~123
                                                                                          > (ne:dejs:format n+'2.47')
                                                                                          .~2.47

                                                                                          ++ni:dejs:format

                                                                                          Number as integer

                                                                                          Convert number jon to a @ud. jon must be an integer or it will crash.

                                                                                          Accepts

                                                                                          jon is a json number.

                                                                                          Produces

                                                                                          A @ud.

                                                                                          Source

                                                                                          ++ ni
                                                                                          |= jon=json
                                                                                          ?> ?=([%n *] jon)
                                                                                          (rash p.jon dem)

                                                                                          Examples

                                                                                          > (ni:dejs:format n+'123')
                                                                                          123
                                                                                          > (ni:dejs:format n+'2.47')
                                                                                          {1 2}
                                                                                          syntax error

                                                                                          ++no:dejs:format

                                                                                          Number as knot

                                                                                          Convert number jon to a @ta.

                                                                                          Accepts

                                                                                          jon is a json number.

                                                                                          Produces

                                                                                          A @ta.

                                                                                          Source

                                                                                          ++ no
                                                                                          |=(jon=json ?>(?=([%n *] jon) p.jon))

                                                                                          Examples

                                                                                          > (no:dejs:format n+'2.47')
                                                                                          ~.2.47
                                                                                          > (no:dejs:format n+'123')
                                                                                          ~.123

                                                                                          ++nu:dejs:format

                                                                                          Parse string as hex

                                                                                          Parse string jon as hexadecimal or crash.

                                                                                          Accepts

                                                                                          jon is a json string.

                                                                                          Produces

                                                                                          A @.

                                                                                          Source

                                                                                          ++ nu
                                                                                          |= jon=json
                                                                                          ?> ?=([%s *] jon)
                                                                                          (rash p.jon hex)

                                                                                          Examples

                                                                                          > `@ux`(nu:dejs:format s+'DEADBEEF')
                                                                                          0xdead.beef
                                                                                          > `@ux`(nu:dejs:format s+'deadbeef')
                                                                                          0xdead.beef
                                                                                          > `@ux`(nu:dejs:format s+'0xdeadbeef')
                                                                                          {1 2}
                                                                                          syntax error

                                                                                          ++of:dejs:format

                                                                                          Object as frond

                                                                                          Convert object jon, which contains a single key-value pair, to a key-value tuple using the fist in wer which matches the key.

                                                                                          The +of function is a wet gate that takes a list of pairs of keys and fists and produces a new gate that takes json.

                                                                                          Note: While technically the type of an item in the list wer is specified as [cord fist], actually using a cord may result in incorrect type inferrence. Instead, you'll want to format it as a @tas like %foo, so the type system correctly interprets it as a tagged union. If the key contains characters that would be invalid in an ordinary @tas, you can format it like %'foo_bar' - a % then single quotes.

                                                                                          Accepts

                                                                                          wer is a (pole [cord fist]), and is the sample of the wet gate. A pole is a faceless list.

                                                                                          jon is a json object containing a single key. jon is the sample of the gate produced by the wet gate.

                                                                                          Produces

                                                                                          A [@t [type]] where [type] is the type produced by the matching fist.

                                                                                          Source

                                                                                          ++ of
                                                                                          |* wer=(pole [cord fist])
                                                                                          |= jon=json
                                                                                          ?> ?=([%o [@ *] ~ ~] jon)
                                                                                          |-
                                                                                          ?- wer
                                                                                          :: [[[email protected] wit=*] t=*]
                                                                                          [[key=@t *] t=*]
                                                                                          => .(wer [[* wit] *]=wer)
                                                                                          ?: =(key.wer p.n.p.jon)
                                                                                          [key.wer ~|(key+key.wer (wit.wer q.n.p.jon))]
                                                                                          ?~ t.wer ~|(bad-key+p.n.p.jon !!)
                                                                                          ((of t.wer) jon)
                                                                                          ==

                                                                                          Examples

                                                                                          First, let's store some objects containing key-value pairs:

                                                                                          > =obj-1 o+(malt ['foo' s+'hello']~)
                                                                                          > (crip (en-json:html obj-1))
                                                                                          '{"foo":"hello"}'
                                                                                          > =obj-2 o+(malt ~[['bar' a+~[n+'123' n+'456']]])
                                                                                          > (crip (en-json:html obj-2))
                                                                                          '{"bar":[123,456]}'
                                                                                          > =obj-3 o+(malt ['baz' b+&]~)
                                                                                          > (crip (en-json:html obj-3))
                                                                                          '{"baz":true}'

                                                                                          Next, let's construct a +of function and try it on our objects:

                                                                                          > ((of ~[foo+so bar+(ar ni)]):dejs:format obj-1)
                                                                                          [%'foo' 'hello']
                                                                                          > ((of ~[foo+so bar+(ar ni)]):dejs:format obj-2)
                                                                                          [%'bar' ~[123 456]]
                                                                                          > ((of ~[foo+so bar+(ar ni)]):dejs:format obj-3)
                                                                                          [%bad-key 'baz']
                                                                                          dojo: hoon expression failed

                                                                                          ++ot:dejs:format

                                                                                          Object as tuple.

                                                                                          Convert object jon to a tuple by decoding each value with the matching fist in wer. Each key in wer must be matched to a key in jon. On the other hand, if there are keys in jon with no corresponding key in wer, they'll simply be ignored.

                                                                                          The +ot function is a wet gate that takes a list of key-fist pairs, and produces a gate which takes json.

                                                                                          Note: While technically the type of an item in the list wer is specified as [cord fist], actually using a cord may result in incorrect type inferrence. Instead, you'll want to format it as a @tas like %foo, so the type system correctly interprets it as a tagged union. If the key contains characters that would be invalid in an ordinary @tas, you can format it like %'foo_bar' - a % then single quotes.

                                                                                          Accepts

                                                                                          wer is a (pole [cord fist]), and is the sample of the wet gate. A pole is a faceless list.

                                                                                          jon is a json object, and is the sample of the gate produced by the wet gate.

                                                                                          Produces

                                                                                          A tuple where the type of each item is the product of the corresponding fist in wer. The order of items in the tuple will match the order of items in wer.

                                                                                          Source

                                                                                          ++ ot
                                                                                          |* wer=(pole [cord fist])
                                                                                          |= jon=json
                                                                                          ?> ?=([%o *] jon)
                                                                                          ((ot-raw wer) p.jon)

                                                                                          Examples

                                                                                          > %- (ot ~[foo+so bar+ni]):dejs:format
                                                                                          o+(malt (limo ~[['bar' n+'123'] ['foo' s+'hello'] ['baz' b+&]]))
                                                                                          ['hello' 123]
                                                                                          > %- (ot ~[foo+so bar+ni]):dejs:format
                                                                                          o+(malt (limo ~[['bar' n+'123'] ['baz' b+&]]))
                                                                                          [%key 'foo']
                                                                                          dojo: hoon expression failed

                                                                                          ++ot-raw:dejs:format

                                                                                          Object as tuple, raw

                                                                                          This function is used internally by +ot and would not typically be used directly.

                                                                                          +ot-raw converts map jom to a tuple by decoding each value with the matching fist in wer. Each key in wer must be matched to a key in the given map. On the other hand, if there are keys in the map with no corresponding key in wer, they'll simply be ignored.

                                                                                          The +ot-raw function is a wet gate that takes a list of key-fist pairs, and produces a gate which takes a map of keys to json.

                                                                                          Note: While technically the type of an item in the list wer is specified as [cord fist], actually using a cord may result in incorrect type inferrence. Instead, you'll want to format it as a @tas like %foo, so the type system correctly interprets it as a tagged union. If the key contains characters that would be invalid in an ordinary @tas, you can format it like %'foo_bar' - a % then single quotes.

                                                                                          Accepts

                                                                                          wer is a (pole [cord fist]), and is the sample of the wet gate. A pole is a faceless list.

                                                                                          jom is a (map @t json), and is the sample of the gate produced by the wet gate.

                                                                                          Produces

                                                                                          A tuple where the type of each item is the product of the corresponding fist in wer. The order of items in the tuple will match the order of items in wer.

                                                                                          Source

                                                                                          ++ ot-raw
                                                                                          |* wer=(pole [cord fist])
                                                                                          |= jom=(map @t json)
                                                                                          ?- wer
                                                                                          :: [[[email protected] wit=*] t=*]
                                                                                          [[key=@t *] t=*]
                                                                                          => .(wer [[* wit] *]=wer)
                                                                                          =/ ten ~|(key+key.wer (wit.wer (~(got by jom) key.wer)))
                                                                                          ?~(t.wer ten [ten ((ot-raw t.wer) jom)])
                                                                                          ==

                                                                                          Examples

                                                                                          > %- (ot-raw ~[foo+so bar+ni]):dejs:format
                                                                                          (malt (limo ~[['bar' n+'123'] ['foo' s+'hello'] ['baz' b+&]]))
                                                                                          ['hello' 123]
                                                                                          > %- (ot-raw ~[foo+so bar+ni]):dejs:format
                                                                                          (malt (limo ~[['bar' n+'123'] ['baz' b+&]]))
                                                                                          [%key 'foo']
                                                                                          dojo: hoon expression failed

                                                                                          ++ou:dejs:format

                                                                                          Object of units

                                                                                          Convert object jon to a tuple by decoding each value with the function in wer that matches its key. Keys in jon with no matching key in wer are ignored. This is the same as +ot except that:

                                                                                          • It wraps each value in jon in a unit before passing it to the corresponding function in wer.
                                                                                          • If a key in wer has no matching key in jon, it passes ~ to that function.

                                                                                          Therefore, the functions must take a (unit json) rather than just json, so they are not fists but rather $-((unit json) grub) (despite what the source code says). There are two +dejs functions that can be used in +ou and take units: +uf and +un. Both of them wrap fists like (uf so) or (un so). The former, +uf, lets you replace a null unit with something of your choosing. The latter, +un, crashes if the unit is null. Using both in a +ou allows you to set some values as mandatory and others as optional, replacing any missing optional ones with whatever you want. This is the ultimate purpose of +ou.

                                                                                          The +ou function is a wet gate that takes a list of key-function pairs, and produces a gate which takes json.

                                                                                          Note: While technically the type of an item in the list wer is specified as [cord fist], actually using a cord may result in incorrect type inferrence. Instead, you'll want to format it as a @tas like %foo, so the type system correctly interprets it as a tagged union. If the key contains characters that would be invalid in an ordinary @tas, you can format it like %'foo_bar' - a % then single quotes.

                                                                                          Accepts

                                                                                          wer is a (pole [cord $-((unit json) grub)]), despite saying (pole [cord fist]) in the source code. wer is the sample of the wet gate. A pole is a faceless list.

                                                                                          jon is a json object, and is the sample of the gate produced by the wet gate.

                                                                                          Produces

                                                                                          A tuple where the type of each item is the product of the corresponding function in wer. The order of items in the tuple will match the order of items in wer.

                                                                                          Source

                                                                                          ++ ou
                                                                                          |* wer=(pole [cord fist])
                                                                                          |= jon=json
                                                                                          ?> ?=([%o *] jon)
                                                                                          ((ou-raw wer) p.jon)

                                                                                          Examples

                                                                                          > %- (ou ~[foo+(un so) bar+(uf missing+ni)]):dejs:format
                                                                                          o+(malt (limo ~[['foo' s+'hello']]))
                                                                                          ['hello' %missing]
                                                                                          > %- (ou ~[foo+(un so) bar+(uf missing+ni)]):dejs:format
                                                                                          o+(malt (limo ~[['bar' n+'123']]))
                                                                                          [%key 'foo']
                                                                                          dojo: hoon expression failed
                                                                                          > %- (ou ~[foo+(un so) bar+(uf missing+ni)]):dejs:format
                                                                                          o+(malt (limo ~[['foo' s+'hello'] ['bar' n+'123']]))
                                                                                          ['hello' 123]

                                                                                          ++ou-raw:dejs:format

                                                                                          Object of units, raw

                                                                                          This function is used internally by +ou, you would not typically use it directly.

                                                                                          Convert map jom to a tuple by decoding each value with the function in wer that matches its key. Keys in jom with no matching key in wer are ignored. This is the same as +ot-raw except that:

                                                                                          • It wraps each value in jom in a unit before passing it to the corresponding function in wer.
                                                                                          • If a key in wer has no matching key in jom, it passes ~ to that function.

                                                                                          Therefore, the functions must take a (unit json) rather than just json, so they are not fists but rather $-((unit json) grub) (despite what the source code says). There are two +dejs functions that can be used in +ou-raw and take units: +uf and +un. Both of them wrap fists like (uf so) or (un so). The former, +uf, lets you replace a null unit with something of your choosing. The latter, +un, crashes if the unit is null. Using both in a +ou-raw allows you to set some values as mandatory and others as optional, replacing any missing optional ones with whatever you want.

                                                                                          The +ou-raw function is a wet gate that takes a list of key-function pairs, and produces a gate which takes a map of @t keys to json.

                                                                                          Note: While technically the type of an item in the list wer is specified as [cord fist], actually using a cord may result in incorrect type inferrence. Instead, you'll want to format it as a @tas like %foo, so the type system correctly interprets it as a tagged union. If the key contains characters that would be invalid in an ordinary @tas, you can format it like %'foo_bar' - a % then single quotes.

                                                                                          Accepts

                                                                                          wer is a (pole [cord $-((unit json) grub)]), despite saying (pole [cord fist]) in the source code. wer is the sample of the wet gate. A pole is a faceless list.

                                                                                          jon is a (map @t json), and is the sample of the gate produced by the wet gate.

                                                                                          Produces

                                                                                          A tuple where the type of each item is the product of the corresponding function in wer. The order of items in the tuple will match the order of items in wer.

                                                                                          Source

                                                                                          ++ ou-raw
                                                                                          |* wer=(pole [cord fist])
                                                                                          |= jom=(map @t json)
                                                                                          ?- wer
                                                                                          :: [[[email protected] wit=*] t=*]
                                                                                          [[key=@t *] t=*]
                                                                                          => .(wer [[* wit] *]=wer)
                                                                                          =/ ten ~|(key+key.wer (wit.wer (~(get by jom) key.wer)))
                                                                                          ?~(t.wer ten [ten ((ou-raw t.wer) jom)])
                                                                                          ==

                                                                                          Examples

                                                                                          > %- (ou-raw ~[foo+(un so) bar+(uf missing+ni)]):dejs:format
                                                                                          (malt (limo ~[['foo' s+'hello']]))
                                                                                          ['hello' %missing]
                                                                                          > %- (ou-raw ~[foo+(un so) bar+(uf missing+ni)]):dejs:format
                                                                                          (malt (limo ~[['bar' n+'123']]))
                                                                                          [%key 'foo']
                                                                                          dojo: hoon expression failed
                                                                                          > %- (ou-raw ~[foo+(un so) bar+(uf missing+ni)]):dejs:format
                                                                                          (malt (limo ~[['foo' s+'hello'] ['bar' n+'123']]))
                                                                                          ['hello' 123]

                                                                                          ++oj:dejs:format

                                                                                          Object as jug

                                                                                          Convert jon, an object of arrays, to a jug. Decode each element in each array with fist.

                                                                                          The +oj function is a wet gate that takes fist and produces a gate that takes jon.

                                                                                          Accepts

                                                                                          fist is a fist, and is the sample of the wet gate.

                                                                                          jon is a json object of arrays. Each element in each array is of the same json kind. jon is the sample of the gate produced by the wet gate.

                                                                                          Produces

                                                                                          A (jug cord [type]), where [type] is the type produced by fist.

                                                                                          Source

                                                                                          ++ oj
                                                                                          |* =fist
                                                                                          ^- $-(json (jug cord _(fist *json)))
                                                                                          (om (as fist))

                                                                                          Examples

                                                                                          > =jon (need (de-json:html '{"foo":["aaa","bbb","ccc"],"bar":["xxx","yyy","zzz"]}'))
                                                                                          > ((oj so):dejs:format jon)
                                                                                          {[p='bar' q={'xxx' 'zzz' 'yyy'}] [p='foo' q={'bbb' 'ccc' 'aaa'}]}

                                                                                          ++om:dejs:format

                                                                                          Object as map

                                                                                          Convert object jon to a map, decoding each value with wit.

                                                                                          The +om function is a wet gate that takes wit and produces a gate that takes jon.

                                                                                          Accepts

                                                                                          wit is a fist, and is the sample of the wet gate.

                                                                                          jon is a json object whose values are the kind of json that wit takes. jon is the sample of the gate produced by the wet gate.

                                                                                          Produces

                                                                                          A (map cord [type]), where [type] is the type produced by wit.

                                                                                          Source

                                                                                          ++ om
                                                                                          |* wit=fist
                                                                                          |= jon=json
                                                                                          ?> ?=([%o *] jon)
                                                                                          (~(run by p.jon) wit)

                                                                                          Examples

                                                                                          > =jon (need (de-json:html '{"foo":"aaa","bar":"bbb"}'))
                                                                                          > ((om so):dejs:format jon)
                                                                                          {[p='bar' q='bbb'] [p='foo' q='aaa']}

                                                                                          ++op:dejs:format

                                                                                          Parse keys of map

                                                                                          Convert object jon to a map, parsing each key with fel and decoding each value with wit.

                                                                                          The +op function is a wet gate that takes fel and wit, and produces a gate that takes jon.

                                                                                          Accepts

                                                                                          The wet gate takes a cell of [fel wil], where fel is a parsing rule and wil is a fist.

                                                                                          jon is a json object, whose keys are parsable by fel and whose values are json of the kind wit takes. jon is the sample of the gate produced by the wet gate.

                                                                                          Produces

                                                                                          A (map [a] [b]) where [a] is the type produced by fel and [b] is the type produced by wit.

                                                                                          Source

                                                                                          ++ op
                                                                                          |* [fel=rule wit=fist]
                                                                                          |= jon=json ^- (map _(wonk *fel) _*wit)
                                                                                          =/ jom ((om wit) jon)
                                                                                          %- malt
                                                                                          %+ turn ~(tap by jom)
                                                                                          |* [a=cord b=*]
                                                                                          => .(+< [a b]=+<)
                                                                                          [(rash a fel) b]

                                                                                          Examples

                                                                                          > =jon (need (de-json:html '{"123":"aaa","456":"bbb"}'))
                                                                                          > ((op dem so):dejs:format jon)
                                                                                          {[p=456 q='bbb'] [p=123 q='aaa']}

                                                                                          ++pa:dejs:format

                                                                                          String as path

                                                                                          Convert jon and parse to a path.

                                                                                          Accepts

                                                                                          jon is a json string encoding a path.

                                                                                          Produces

                                                                                          A (list @) which can be cast to a path.

                                                                                          Source

                                                                                          ++ pa
                                                                                          (su stap)

                                                                                          Examples

                                                                                          > `path`(pa:dejs:format s+'/foo/bar/baz')
                                                                                          /foo/bar/baz

                                                                                          ++pe:dejs:format

                                                                                          Prefix

                                                                                          Decode jon with wit, and prefix the result with pre.

                                                                                          The +pe function is a wet gate that takes pre and wit, and produces a gate that takes jon.

                                                                                          Accepts

                                                                                          The wet gate takes a cell of [pre wit], where pre is any noun and wit is a fist.

                                                                                          jon is json of the kind accepted by wit. jon is the sample of the gate produced by the wet gate.

                                                                                          Produces

                                                                                          A cell of [[a] [b]], where [a] is the noun given in pre and [b] is the type produced by wit.

                                                                                          Source

                                                                                          ++ pe
                                                                                          |* [pre=* wit=fist]
                                                                                          (cu |*(* [pre +<]) wit)

                                                                                          Examples

                                                                                          > ((pe %foo so):dejs:format s+'bar')
                                                                                          [%foo 'bar']

                                                                                          ++sa:dejs:format

                                                                                          String as tape

                                                                                          Convert jon to a tape.

                                                                                          Accepts

                                                                                          jon is a json string.

                                                                                          Produces

                                                                                          A tape.

                                                                                          Source

                                                                                          ++ sa
                                                                                          |=(jon=json ?>(?=([%s *] jon) (trip p.jon)))

                                                                                          Examples

                                                                                          > (sa:dejs:format s+'foo')
                                                                                          "foo"

                                                                                          ++sd:dejs:format

                                                                                          String @ud as date

                                                                                          Convert jon to a @da, parsing it as a date in @ud form.

                                                                                          Accepts

                                                                                          jon is a json string encoding a date in @ud form.

                                                                                          Produces

                                                                                          A @da.

                                                                                          Source

                                                                                          ++ sd
                                                                                          |= jon=json
                                                                                          ^- @da
                                                                                          ?> ?=(%s -.jon)
                                                                                          `@da`(rash p.jon dem:ag)

                                                                                          Examples

                                                                                          > (sd:dejs:format s+(scot %ud now))
                                                                                          ~2021.9.8..01.02.41..e5db

                                                                                          ++se:dejs:format

                                                                                          String as aura

                                                                                          Convert and parse jon to an atom of the type specified in aur.

                                                                                          The +se function is a gate within a gate. The first gate takes aur and the second takes jon.

                                                                                          Accepts

                                                                                          aur is a @tas denoting an aura like %ud, %tas, %p, etc. aur is the sample of the first gate

                                                                                          jon is a json string encoding an atom of the type specified in aur. jon is the sample of the second nested gate.

                                                                                          Produces

                                                                                          A @ which can then be cast to the type specified in aur.

                                                                                          Source

                                                                                          ++ se
                                                                                          |= aur=@tas
                                                                                          |= jon=json
                                                                                          ?>(?=([%s *] jon) (slav aur p.jon))

                                                                                          Examples

                                                                                          > `@p`((se %p):dejs:format s+(scot %p our))
                                                                                          ~zod
                                                                                          > `@da`((se %da):dejs:format s+(scot %da now))
                                                                                          ~2021.9.8..01.12.28..4f6a

                                                                                          ++so:dejs:format

                                                                                          String as cord

                                                                                          Convert jon to a cord.

                                                                                          Accepts

                                                                                          jon is a json string.

                                                                                          Produces

                                                                                          A @t.

                                                                                          Source

                                                                                          ++ so
                                                                                          |=(jon=json ?>(?=([%s *] jon) p.jon))

                                                                                          Examples

                                                                                          > (so:dejs:format s+'foo')
                                                                                          'foo'

                                                                                          ++su:dejs:format

                                                                                          Parse string

                                                                                          Convert and parse jon with sab.

                                                                                          The +su function is a wet gate that takes sab, and produces a gate that takes jon.

                                                                                          Accepts

                                                                                          sab is a parsing rule, and is the sample of the wet gate.

                                                                                          jon is a json string, and is the sample of the gate produced by the wet gate.

                                                                                          Produces

                                                                                          The type produced by sab.

                                                                                          Source

                                                                                          ++ su
                                                                                          |* sab=rule
                                                                                          |= jon=json ^+ (wonk *sab)
                                                                                          ?> ?=([%s *] jon)
                                                                                          (rash p.jon sab)

                                                                                          Examples

                                                                                          > ((su dem):dejs:format s+'123456')
                                                                                          123.456
                                                                                          > `@ub`((su bin):dejs:format s+'00001011101110001101')
                                                                                          0b1011.1011.1000.1101

                                                                                          ++uf:dejs:format

                                                                                          Unit fall

                                                                                          Convert the json data in unit jon with wit unless jon is ~, in which case return def. Note this deals with (unit json) rather than the usual json. This would typically be used inside a +ou function to replace missing values with the given values.

                                                                                          The +uf function is a wet gate that takes def and wit, and produces a gate that takes jon.

                                                                                          Accepts

                                                                                          The wet gate takes a cell of [def wit], where def is any noun and wit is a fist.

                                                                                          jon is a (unit json), and is the sample of the gate produced by the wet gate.

                                                                                          Produces

                                                                                          Either the type produced by wit, or else the noun given in def if jon is null.

                                                                                          Source

                                                                                          ++ uf
                                                                                          |* [def=* wit=fist]
                                                                                          |= jon=(unit json)
                                                                                          ?~(jon def (wit u.jon))

                                                                                          Examples

                                                                                          > ((uf %missing so):dejs:format `s+'foo')
                                                                                          'foo'
                                                                                          > ((uf %missing so):dejs:format ~)
                                                                                          %missing

                                                                                          ++un:dejs:format

                                                                                          Unit need

                                                                                          Convert the json data in unit jon with wit unless jon is ~, in which case crash. Note this deals with (unit json) rather than the usual json. This would typically be used inside a +ou function and in conjunction with +uf to specify mandatory values.

                                                                                          The +un function is a wet gate that takes wit and produces a gate that takes jon.

                                                                                          Accepts

                                                                                          wit is a fist, and is the sample of the wet gate.

                                                                                          jon is a (unit json), and is the sample of the gate returned by the wet gate.

                                                                                          Produces

                                                                                          The type produced by wit or crash if jon is null.

                                                                                          Source

                                                                                          ++ un
                                                                                          |* wit=fist
                                                                                          |= jon=(unit json)
                                                                                          (wit (need jon))

                                                                                          Examples

                                                                                          > ((un so):dejs:format `s+'foo')
                                                                                          'foo'
                                                                                          > ((un so):dejs:format ~)
                                                                                          dojo: hoon expression failed

                                                                                          ++ul:dejs:format

                                                                                          Null

                                                                                          Return ~ if jon is null or else crash.

                                                                                          Accepts

                                                                                          jon is null json.

                                                                                          Produces

                                                                                          ~ if jon is null, otherwise crashes.

                                                                                          Source

                                                                                          ++ ul
                                                                                          |=(jon=json ?~(jon ~ !!))

                                                                                          Examples

                                                                                          > (ul:dejs:format ~)
                                                                                          ~
                                                                                          > (ul:dejs:format b+&)
                                                                                          dojo: hoon expression failed

                                                                                          ++za:dejs:format

                                                                                          Full unit pole

                                                                                          Check whether all units in list pod are non-null. This is used internally by some functions and would not typically be used directly.

                                                                                          Accepts

                                                                                          pod is a (pole (unit)). A pole is a faceless list.

                                                                                          Produces

                                                                                          A ?, which is %.n if any of the units in pod are ~, and %.y otherwise.

                                                                                          Source

                                                                                          ++ za
                                                                                          |* pod=(pole (unit))
                                                                                          ?~ pod &
                                                                                          ?~ -.pod |
                                                                                          (za +.pod)

                                                                                          Examples

                                                                                          > (za:dejs:format ~[`1 `2 `3 `4])
                                                                                          %.y
                                                                                          > (za:dejs:format ~)
                                                                                          %.y
                                                                                          > (za:dejs:format ~[`1 `2 ~ `4])
                                                                                          %.n

                                                                                          ++zl:dejs:format

                                                                                          Collapse unit list

                                                                                          Convert lut, a list of units, to a (unit (list)) by stripping the unit from each item. The resulting unit is null if any of the units in the list are null. This is used internally by some functions, you would not typically use it directly.

                                                                                          Accepts

                                                                                          A (list (unit)).

                                                                                          Produces

                                                                                          A (unit (list)) which is null if any of the units in lut were null.

                                                                                          Source

                                                                                          ++ zl
                                                                                          |* lut=(list (unit))
                                                                                          ?. |- ^- ?
                                                                                          ?~(lut & ?~(i.lut | $(lut t.lut)))
                                                                                          ~
                                                                                          %- some
                                                                                          |-
                                                                                          ?~ lut ~
                                                                                          [i=u:+.i.lut t=$(lut t.lut)]

                                                                                          Examples

                                                                                          > (zl:dejs:format (limo ~[`1 `2 `3 `4 `5 `6]))
                                                                                          [~ [i=1 t=~[2 3 4 5 6]]]
                                                                                          > (zl:dejs:format (limo ~[`1 `2 ~ `4 `5 `6]))
                                                                                          ~

                                                                                          ++zp:dejs:format

                                                                                          Unit tuple

                                                                                          Convert but, a list of units, to a tuple by stripping the unit from each item. Crashes if any of the units are null. This is used internally by some functions, you would not typically use it directly.

                                                                                          Accepts

                                                                                          but is a (pole (unit)). A pole is a faceless list.

                                                                                          Produces

                                                                                          A tuple containing each unwrapped element from the original list, or crashes if any of the units were null.

                                                                                          Source

                                                                                          ++ zp
                                                                                          |* but=(pole (unit))
                                                                                          ?~ but !!
                                                                                          ?~ +.but
                                                                                          u:->.but
                                                                                          [u:->.but (zp +.but)]

                                                                                          Examples

                                                                                          > (zp:dejs:format ~[`1 `2 `3 `4 `5 `6])
                                                                                          [1 2 3 4 5 6]
                                                                                          > (zp:dejs:format ~[`1 `2 ~ `4 `5 `6])
                                                                                          mull-none
                                                                                          dojo: hoon expression failed

                                                                                          ++zm:dejs:format

                                                                                          Collapse unit map

                                                                                          Strip units from values in lum, a map of units. Returns null if any of the units are null. This is used internally by some functions, you would not typically use it directly.

                                                                                          Accepts

                                                                                          lum is a (map term (unit))

                                                                                          Produces

                                                                                          A (unit (map term [type])), where [type] is the type the units in lum contained. Produces ~ if any of the units were null.

                                                                                          Source

                                                                                          ++ zm
                                                                                          |* lum=(map term (unit))
                                                                                          ?: (~(rep by lum) |=([[@ a=(unit)] b=_|] |(b ?=(~ a))))
                                                                                          ~
                                                                                          (some (~(run by lum) need))

                                                                                          Examples

                                                                                          > (zm:dejs:format (malt ~[['foo' `1] ['bar' `2]]))
                                                                                          [~ {[p='bar' q=2] [p='foo' q=1]}]
                                                                                          > (zm:dejs:format (malt (limo ~[['foo' `1] ['bar' ~]])))
                                                                                          ~

                                                                                          <-

                                                                                          2d(1-5): To JSON, Wains

                                                                                          2d(7): From JSON (unit)

                                                                                          ->

                                                                                          Edit this page on GitHub