Urbit Developers
  • Hoon

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

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

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

          • Limbs
          • Wings
          • Zuse

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

            • Overview
            • Ames

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

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

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

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

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

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

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

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

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

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

                                • Overview
                                • HTTP API
                                • Reference
                                • Gall

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

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

                                    • Scries
                                    • Subscriptions
                                    • Tutorials

                                      • Move Trace
                                      • Reference

                                        • Cryptography
                                        • Filesystem Hierarchy
                                      • Nock

                                        • Nock Definition
                                        • Explanation
                                        • Example
                                        • Implementations
                                        • Vere

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

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

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

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

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

                                                  • Overview
                                                  • Docket File
                                                  • Glob
                                                Urbit Developers
                                                • Hoon

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

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

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

                                                        • Limbs
                                                        • Wings
                                                        • Zuse

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

                                                          • Overview
                                                          • Ames

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

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

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

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

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

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

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

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

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

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

                                                                              • Overview
                                                                              • HTTP API
                                                                              • Reference
                                                                              • Gall

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

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

                                                                                  • Scries
                                                                                  • Subscriptions
                                                                                  • Tutorials

                                                                                    • Move Trace
                                                                                    • Reference

                                                                                      • Cryptography
                                                                                      • Filesystem Hierarchy
                                                                                    • Nock

                                                                                      • Nock Definition
                                                                                      • Explanation
                                                                                      • Example
                                                                                      • Implementations
                                                                                      • Vere

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

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

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

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

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

                                                                                                • Overview
                                                                                                • Docket File
                                                                                                • Glob
                                                                                              Reference/Arvo/Threads/Examples

                                                                                              Child Thread

                                                                                              Here's a simple example of a thread that starts another thread:

                                                                                              parent.hoon

                                                                                              /- spider
                                                                                              /+ *strandio
                                                                                              =, strand=strand:spider
                                                                                              ^- thread:spider
                                                                                              |= arg=vase
                                                                                              =/ m (strand ,vase)
                                                                                              ^- form:m
                                                                                              ;< tid=tid:spider bind:m (start-thread %child)
                                                                                              (pure:m !>(~))

                                                                                              child.hoon

                                                                                              /- spider
                                                                                              /+ *strandio
                                                                                              =, strand=strand:spider
                                                                                              ^- thread:spider
                                                                                              |= arg=vase
                                                                                              =/ m (strand ,vase)
                                                                                              ^- form:m
                                                                                              %- (slog leaf+"foo" ~)
                                                                                              (pure:m !>(~))

                                                                                              Save parent.hoon and child.hoon in /ted of the %base desk, |commit %base and run -parent. You should see something like:

                                                                                              foo
                                                                                              > -parent
                                                                                              ~

                                                                                              parent.hoon just uses the strandio function start-thread to start child.hoon, and child.hoon just prints foo to the dojo. Since we got foo we can tell the second thread did, in fact, run.

                                                                                              ;< tid=tid:spider bind:m (start-thread %child)

                                                                                              See here how we gave start-thread the name of the thread to run. It returns the tid of the thread, which we could then use to poke it or whatever.

                                                                                              start-thread handles creating the tid for the thread so is quite convenient.

                                                                                              Note that threads we start this way will be a child of the thread that started them, and so will be killed when the parent thread ends.

                                                                                              Start thread and get its result

                                                                                              If we want to actually get the result of the thread we started, it's slightly more complicated. We note that this is mostly the same as await-thread:strandio.

                                                                                              parent.hoon

                                                                                              /- spider
                                                                                              /+ *strandio
                                                                                              =, strand=strand:spider
                                                                                              ^- thread:spider
                                                                                              |= arg=vase
                                                                                              =/ m (strand ,vase)
                                                                                              ^- form:m
                                                                                              ;< =bowl:spider bind:m get-bowl
                                                                                              =/ tid `@ta`(cat 3 'strand_' (scot %uv (sham %child eny.bowl)))
                                                                                              ;< ~ bind:m (watch-our /awaiting/[tid] %spider /thread-result/[tid])
                                                                                              ;< ~ bind:m %- poke-our
                                                                                              :* %spider
                                                                                              %spider-start
                                                                                              !>([`tid.bowl `tid byk.bowl(r da+now.bowl) %child !>(~)])
                                                                                              ==
                                                                                              ;< =cage bind:m (take-fact /awaiting/[tid])
                                                                                              ;< ~ bind:m (take-kick /awaiting/[tid])
                                                                                              ?+ p.cage ~|([%strange-thread-result p.cage %child tid] !!)
                                                                                              %thread-done (pure:m q.cage)
                                                                                              %thread-fail (strand-fail !<([term tang] q.cage))
                                                                                              ==

                                                                                              child.hoon

                                                                                              /- spider
                                                                                              /+ *strandio
                                                                                              =, strand=strand:spider
                                                                                              =>
                                                                                              |%
                                                                                              ++ url "https://sampledataapi.com/API/getcategory"
                                                                                              --
                                                                                              ^- thread:spider
                                                                                              |= arg=vase
                                                                                              =/ m (strand ,vase)
                                                                                              ^- form:m
                                                                                              ;< =cord bind:m (fetch-cord url)
                                                                                              (pure:m !>(cord))

                                                                                              child.hoon simply grabs the JSON response from https://sampledataapi.com/ and returns it as a cord. (There is also a ++fetch-json:strandio gate that could be employed here.)

                                                                                              parent.hoon is a bit more complicated so we'll look at it line-by-line

                                                                                              ;< =bowl:spider bind:m get-bowl

                                                                                              First we grab the bowl

                                                                                              =/ tid `@ta`(cat 3 'strand_' (scot %uv (sham %child eny.bowl)))

                                                                                              Then we generate a tid (thread ID) for the thread we're gonna start

                                                                                              ;< ~ bind:m (watch-our /awaiting/[tid] %spider /thread-result/[tid])

                                                                                              We pre-emptively subscribe for the result. Spider sends the result at /thread-result/<tid> so that's where we subscribe.

                                                                                              ;< ~ bind:m %- poke-our
                                                                                              :* %spider
                                                                                              %spider-start
                                                                                              !>([`tid.bowl `tid byk.bowl(r da+now.bowl) %child !>(~)])
                                                                                              ==

                                                                                              Spider takes a poke with a mark %spider-start and a vase containing [parent=(unit tid) use=(unit tid) =beak file=term =vase] to start a thread, where:

                                                                                              • parent is an optional parent thread. In this case we say the parent is our tid. Specifying a parent means the child will be killed if the parent ends.
                                                                                              • use is the thread ID for the thread we're creating
                                                                                              • beak is a [p=ship q=desk r=case] triple which specifies the desk and revision containing the thread we want to run. In this case we just use byk.bowl, but with the date of revision q changed to now.bowl.
                                                                                              • file is the filename of the thread we want to start
                                                                                              • vase is the vase it will be given as an argument when it's started
                                                                                              ;< =cage bind:m (take-fact /awaiting/[tid])

                                                                                              We wait for a fact which will be the result of the thread.

                                                                                              ;< ~ bind:m (take-kick /awaiting/[tid])

                                                                                              Spider will kick us from the subscription when it ends the thread so we also take that kick.

                                                                                              ?+ p.cage ~|([%strange-thread-result p.cage %child tid] !!)
                                                                                              %thread-done (pure:m q.cage)
                                                                                              %thread-fail (strand-fail !<([term tang] q.cage))
                                                                                              ==

                                                                                              Finally we test whether the thread produced a %thread-done or a %thread-fail. These are the two possible marks produced by spider when it returns the results of a thread. A %thread-done will contain a vase with the result, and a %thread-fail will contain an error message and traceback, so we see which it is and then either produce the result with pure or trigger a %thread-fail with the error we got from the child.

                                                                                              Stop a thread

                                                                                              parent.hoon

                                                                                              /- spider
                                                                                              /+ *strandio
                                                                                              =, strand=strand:spider
                                                                                              ^- thread:spider
                                                                                              |= arg=vase
                                                                                              =/ m (strand ,vase)
                                                                                              ^- form:m
                                                                                              ;< =bowl:spider bind:m get-bowl
                                                                                              =/ tid `@ta`(cat 3 'strand_' (scot %uv (sham %child eny.bowl)))
                                                                                              %- (slog leaf+"Starting child thread..." ~)
                                                                                              ;< ~ bind:m %- poke-our
                                                                                              :* %spider
                                                                                              %spider-start
                                                                                              !>([`tid.bowl byk.bowl(r da+now.bowl) `tid %child !>(~)])
                                                                                              ==
                                                                                              ;< ~ bind:m (sleep ~s5)
                                                                                              %- (slog leaf+"Stopping child thread..." ~)
                                                                                              ;< ~ bind:m %- poke-our
                                                                                              :* %spider
                                                                                              %spider-stop
                                                                                              !>([tid %.y])
                                                                                              ==
                                                                                              ;< ~ bind:m (sleep ~s2)
                                                                                              (pure:m !>("Done"))

                                                                                              child.hoon

                                                                                              /- spider
                                                                                              /+ *strandio
                                                                                              =, strand=strand:spider
                                                                                              =>
                                                                                              |%
                                                                                              ++ looper
                                                                                              =/ m (strand ,~)
                                                                                              ^- form:m
                                                                                              %- (main-loop ,~)
                                                                                              :~ |= ~
                                                                                              ^- form:m
                                                                                              ;< ~ bind:m (sleep `@dr`(div ~s1 2))
                                                                                              %- (slog leaf+"child thread" ~)
                                                                                              (pure:m ~)
                                                                                              ==
                                                                                              --
                                                                                              ^- thread:spider
                                                                                              |= arg=vase
                                                                                              =/ m (strand ,vase)
                                                                                              ^- form:m
                                                                                              ;< ~ bind:m looper
                                                                                              (pure:m !>(~))

                                                                                              child.hoon just prints to the dojo in a loop.

                                                                                              parent.hoon starts child.hoon, and then pokes spider like:

                                                                                              ;< ~ bind:m %- poke-our
                                                                                              :* %spider
                                                                                              %spider-stop
                                                                                              !>([tid %.y])
                                                                                              ==
                                                                                              • %spider-stop is the mark that tells spider to kill a thread.
                                                                                              • tid is the tid of the thread to kill
                                                                                              • %.y tells spider to suppress traceback in the result of the killed thread. If you give it %.n it will include the traceback.

                                                                                              <-

                                                                                              Fetch JSON

                                                                                              Main-loop

                                                                                              ->

                                                                                              Edit this page on GitHub

                                                                                              Last modified March 17, 2023