3g: Molds and Mold-Builders

++coin

Noun-literal syntax cases

Syntax cases for nouns-literal: atoms, jammed nouns, and nestable tuples. Parsed and printed using ++so and ++co cores.

Source

    ++  coin  $%  [$$ p=dime]
                  [$blob p=*]
                  [$many p=(list coin)]
              ==

Examples

    > `coin`(need (slay '~s1'))
    [%$ p=[p=~.dr q=18.446.744.073.709.551.616]]

    > `coin`(need (slay '0x2b59'))
    [%$ p=[p=~.ux q=11.097]]

    > ~(rend co [%many ~[[%$ %ud 1] [%$ %tas 'a'] [%$ %s -2]]])
    "._1_a_-2__"
    > ._1_a_-2__
    [1 %a -2]

    > `@uv`(jam [3 4])
    0v2cd1

    > (slay '~02cd1')
    [~ u=[%blob p=[3 4]]]

    > ~02cd1
    [3 4]

++dime

Aura-atom pair

Used in ++coin. Convenience methods ++scot and ++scow print dimes as ++cord and ++tape, respectively. ++slat, ++slav, and ++slaw are used to parse atoms of specific auras.

Source

        ++  dime  [p=@ta q=@]

Examples

    > +>:(slay '0x123')
    p=[p=~.ux q=291]

++edge

Parsing location metadata

Optional result p and parsing continuation q.

Source

    ++  hair  [p=@ud q=@ud]

Examples

    > *edge
    [p=[p=0 q=0] q=~]

    > (tall:vast [1 1] "a b")
    [p=[p=1 q=3] q=[~ u=[p=[%wing p=~[%a]] q=[p=[p=1 q=2] q=" b"]]]]

Discussion

See also: Section 2e, ++rule


++hair

Parsing line and column

A pair of two @ud used in parsing indicating line and column number.

Source

    ++  hair  [p=@ud q=@ud]

Examples

    > *hair
    [p=0 q=0]

    > `hair`[1 1]                                               :: parsing starts at [1 1] as a convention.
    [p=1 q=1]

    > ((plus ace) [1 1] "   --")
    [p=[p=1 q=4] q=[~ u=[p=[~~. "  "] q=[p=[p=1 q=4] q="--"]]]]

    > `hair`p:((plus ace) [1 1] "   --")
    [p=1 q=4]

++like

Generic edge

Generates an ++edge with a parsed result set to a specific type.

Source

    ++  like  |*  a=gate
              |=  b=_`*`[(hair) ~]
              :-  p=(hair -.b)
              ^=  q
              :-  ~
              u=[p=(a +>-.b) q=[p=(hair -.b) q=(tape +.b)]]

Examples

    > *(like char)
    [p=[p=0 q=0] q=~]

    > (ace [1 1] " a")
    [p=[p=1 q=2] q=[~ u=[p=' ' q=[p=[p=1 q=2] q="a"]]]]

    > `(like char)`(ace [1 1] " a")
    [p=[p=1 q=2] q=[~ [p=~~. q=[p=[p=1 q=2] q="a"]]]]

    > `(like ,@)`(ace [1 1] " a")
    [p=[p=1 q=2] q=[~ u=[p=32 q=[p=[p=1 q=2] q="a"]]]]

++nail

Location, remainder of parsed text

Indicates parsing position p, and remaining text to be parsed q.

Source

    ++  nail  [p=hair q=tape]

Examples

    > +<:;~(plug cab cab)
    c=[p=[p=0 q=0] q=""]

++path

Filesystem path

A list of ++knots. ++knot is another name for @ta.

Source

    ++  path  (list knot)

Examples

    > `path`"abc"
    /a/b/c

Discussion

Used in %clay and %eyre extensively.


++pint

Parsing range

A ++pint is a pair of ++hair, indicating from p to q. Mostly used for stack traces.

Source

    ++  pint  [p=[p=@ q=@] q=[p=@ q=@]]

Examples

    > !:(!!)                                                    :: !! always produces a crash
    /~zod/home/~2014.9.20..01.22.04..52e3/:<[1 4].[1 6]>

    > `pint`[[1 4] [1 6]]
    [p=[p=1 q=4] q=[p=1 q=6]]

++rule

Parsing rule

An empty parsing rule, but used to check that parsing rules match this with _.

Source

    ++  rule  _|=(nail *edge)

Examples

    > ([|=(a=nail [p.a ~ u=['a' a]])]:|6 [1 1] "hi")
    [[p=1 q=1] ~ u=['a' p=[p=1 q=1] q="hi"]]

++spot

Stack trace line

The stack trace that is printed after crashing.

Source

    ++  spot  [p=path q=pint]

Examples

    > !:  !!                                                    :: !! always produces a crash
      /~zod/home/~2018.8.8..21.42.40..7852:<[1 5].[1 7]>
    ! exit

++tone

Nock result, error report

Produces either success (%0), a block with list of requests blocked on (%1), or failure with an error report (%2).

Source

    ++  tone  $%  [$0 p=*]                                  ::  success
                  [$1 p=(list)]                             ::  blocks
                  [$2 p=(list [@ta *])]                     ::  error report
              ==

Examples

    > (mink [[20 21] 0 3] $~)
    [%0 p=21]


    > (mink [[1 2] !=(!:(+(.)))] ,~)
    [ %2
      p
    ~[
      [ ~.spot
        [ [ \/72.245.008.048.359.254.300.063.028.130.093.488.830.539.186.242.06\/
              3.318.457.928.725.368.447.417.075.673.617.723.940.025.940.705.343
              .057.601.925.133.611.559.292.046.932.324.629.048.702
            \/                                                                 \/
            1.701.670.760
            \/347.698.068.472.453.194.464.038.059.283.550.210.118.689.128.761.6\/
              88.459.326.078
            \/                                                                 \/
            0
          ]
          [1 20]
          1
          24
        ]
      ]
    ]

++toon

Nock result, stack trace

Produces either success (%0), a block with list of requests blocked on (%1), or failure with a stack trace (%2).

Source

            ++  toon  $%  [$0 p=*]                                  ::  success
                          [$1 p=(list)]                             ::  blocks
                          [$2 p=(list tank)]                        ::  stack trace
                      ==

Examples

    > (mock [[20 21] 0 3] $~)
    [%0 p=21]

    > (mock [[1 2] !=(!:(+(.)))] ,~)
    [%2 p=~[[%leaf p="/~zod/try/~2014.9.23..18.34.32..d3c5/:<[1 20].[1 24]>"]]]

++wonk

Product from edge

Pull result out of a ++edge, or crash if there's no result.

Source

        ++  wonk  |*(veq=edge ?~(q.veq !! p.u.q.veq))

Examples

    > (wide:vast [1 1] "(add 2 2)")
    [ p=[p=1 q=10]
        q
      [ ~
          u
        [ p=[%cnhp p=[%wing p=~[%add]] q=~[[%sand p=%ud q=2] [%sand p=%ud q=2]]]
          q=[p=[p=1 q=10] q=""]
        ]
      ]
    ]

    > (wonk (wide:vast [1 1] "(add 2 2)"))
    [%cnhp p=[%wing p=~[%add]] q=~[[%sand p=%ud q=2] [%sand p=%ud q=2]]]

Discussion

See also: ++edge