4m: Formatting Functions

++scot

Render dime as cord

Renders a dime mol as a cord.

Accepts

mol is a ++dime.

Produces

A cord.

Source

    ++  scot  |=(mol/dime ~(rent co %$ mol))

Examples

    > (scot %p ~pillyt)
    ~.~pillyt
    > `@t`(scot %p ~pillyt)
    '~pillyt'
    > (scot %ux 0x12)
    ~.0x12
    > `@t`(scot %ux 0x12)
    '0x12'
    > (scot %if .127.0.0.1)
    ~..127.0.0.1
    > `@t`(scot %if .127.0.0.1)
    '.127.0.0.1'
    > (scot %ta ~.asd_a)
    ~.~.asd_a
    > `@t`(scot %ta ~.asd_a)
    '~.asd_a'

++scow

Render dime as tape

Renders a dime mol as a tape.

Accepts

mol is a ++dime.

Produces

A tape.

Source

    ++  scow  |=(mol/dime ~(rend co %$ mol))

Examples

    > (scow %p ~pillyt)
    "~pillyt"
    > (scow %ux 0x12)
    "0x12"
    > (scow %if .127.0.0.1)
    ".127.0.0.1"
    > (scow %ta ~.asd_a)
    "~.asd_a"

++slat

Curried slaw

Produces a gate that parses a term txt to an atom of the odor specified by mod.

Accepts

mod is a term, an atom of odor @tas.

txt is a cord, an atom of odor @ta.

Produces

A gate.

Source

    ++  slat  |=(mod/@tas |=(txt/@ta (slaw mod txt)))

Examples

    > `(unit @p)`((slat %p) '~pillyt')
    [~ ~pillyt]
    > `(unit @ux)`((slat %ux) '0x12')
    [~ 0x12]
    > `(unit @if)`((slat %if) '.127.0.0.1')
    [~ .127.0.0.1]
    > `(unit @ta)`((slat %ta) '~.asd_a')
    [~ ~.asd_a

++slav

Demand: parse cord with input odor

Parses a cord txt to an atom of the odor specificed by mod. Crashes if it fails to parse.

Accepts

mod is a term, an atom of odor @tas.

txt is a cord, an atom of odor @ta.

Produces

The atom of a (unit @) from ++slaw, or crash.

Source

    ++  slav  |=([mod/@tas txt/@ta] (need (slaw mod txt)))

Examples

    > `@p`(slav %p '~pillyt')
    ~pillyt
    > `@p`(slav %p '~pillam')
    ! exit
    > `@ux`(slav %ux '0x12')
    0x12
    > `@ux`(slav %ux '0b10')
    ! exit
    > `@if`(slav %if '.127.0.0.1')
    .127.0.0.1
    > `@if`(slav %if '.fe80.0.0.202')
    ! exit
    > `@ta`(slav %ta '~.asd_a')
    ~.asd_a
    > `@ta`(slav %ta '~~asd-a')
    ! exit

++slaw

Parse cord to input odor

Parses a cord txt to an atom of the odor specified by mod.

Accepts

mod is a term, an atom of odor @tas.

txt is a cord, an atom of odor @ta.

Produces

A (unit @).

Source

    ++  slaw
      ~/  %slaw
      |=  {mod/@tas txt/@ta}
      ^-  (unit @)
      =+  con=(slay txt)
      ?.(&(?=({$~ $$ @ @} con) =(p.p.u.con mod)) ~ [~ q.p.u.con])

Examples

    > `(unit @p)`(slaw %p '~pillyt')
    [~ ~pillyt]
    > `(unit @p)`(slaw %p '~pillam')
    ~
    > `(unit @ux)`(slaw %ux '0x12')
    [~ 0x12]
    > `(unit @ux)`(slaw %ux '0b10')
    ~
    > `(unit @if)`(slaw %if '.127.0.0.1')
    [~ .127.0.0.1]
    > `(unit @if)`(slaw %if '.fe80.0.0.202')
    ~
    > `(unit @ta)`(slaw %ta '~.asd_a')
    [~ ~.asd_a]
    > `(unit @ta)`(slaw %ta '~~asd-a')
    ~

++slay

Parse cord to coin

Parses a cord txt to the unit of a ++coin.

Accepts

txt is a @ta.

Produces

A (unit coin).

Source

        ++  slay
          |=  txt/@ta  ^-  (unit coin)
          =+  ^=  vex
              ?:  (gth 0x7fff.ffff txt)                         ::  XX  petty cache
                ~+  ((full nuck:so) [[1 1] (trip txt)])
              ((full nuck:so) [[1 1] (trip txt)])
          ?~  q.vex
            ~
          [~ p.u.q.vex]
        ::

Examples

    > (slay '~pillyt')
    [~ [% p=[p=~.p q=32.819]]]
    > (slay '0x12')
    [~ [% p=[p=~.ux q=18]]]
    > (slay '.127.0.0.1')
    [~ [% p=[p=~.if q=2.130.706.433]]]
    > `@ud`.127.0.0.1
    2.130.706.433
    > (slay '._20_0w25_sam__')
    [ ~
      [ %many
        p=~[[% p=[p=~.ud q=20]] [% p=[p=~.uw q=133]] [% p=[p=~.tas q=7.168.371]]]
      ]
    ]
    > `@`%sam
    7.168.371
    > (slay '~0ph')
    [~ [%blob p=[1 1]]]
    > 0ph
    ~ <syntax error at [1 2]>
    > ~0ph
    [1 1]
    > `@uv`(jam [1 1])
    0vph

++smyt

Render path as tank

Renders the path bon as a tank, which is used for pretty-printing.

Accepts

bon is a ++path.

Produces

A tank.

Source

    ++  smyt                                                ::  pretty print path
      |=  bon/path  ^-  tank
      :+  %rose  [['/' ~] ['/' ~] ~]
      (turn bon |=(a/@ [%leaf (trip a)]))
    ::

Examples

    > (smyt %)
    [ %rose
      p=[p="/" q="/" r="/"]
        q
      ~[ [%leaf p="~zod"]
         [%leaf p="try"]
         [%leaf p="~2014.10.28..18.36.58..a280"]
       ]
    ]
    > (smyt /as/les/top)
    [ %rose
      p=[p="/" q="/" r="/"]
      q=~[[%leaf p="as"] [%leaf p="les"] [%leaf p="top"]]
    ]

++spat

Render path as cord

Renders a path pax as cord.

Accepts

pax is a path.

Produces

A cord.

Source

    ++  spat  |=(pax/path (crip (spud pax)))               ::  path to cord

Examples

    > (spat %)
    '~zod/try/~2014.10.28..18.40.20..4287'
    > (spat %/bin)
    '~zod/try/~2014.10.28..18.41.12..3bcd/bin'
    > (spat /as/les/top)
    '/as/les/top'

++spud

Render path as tape

Renders a path pax as tape.

Accepts

pax is a path.

Produces

A tape.

Source

    ++  spud  |=(pax/path ~(ram re (smyt pax)))             ::  path to tape

Examples

    > (spud %)
    "~zod/try/~2014.10.28..18.40.46..e951"
    > (spud %/bin)
    "~zod/try/~2014.10.28..18.41.05..16f2/bin"
    > (spud /as/les/top)
    "/as/les/top"

++stab

Parse cord to path

Parsing rule. Parses a cord zep to a static ++path. Crashes if it fails to parse.

Accepts

zep is a @t.

Produces

A path, or crash.

Source

    ++  stab                                                ::  parse cord to path
      =+  fel=;~(pfix fas (more fas urs:ab))
      |=(zep/@t `path`(rash zep fel))

Examples

    > (stab '/as/lek/tor')
    /as/lek/tor

    > `(pole ,@ta)`(stab '/as/lek/tor')
    [~.as [~.lek [~.tor ~]]]

    > (stab '~zod/arvo/~2014.10.28..18.48.41..335f/zuse')
    ~zod/arvo/~2014.10.28..18.48.41..335f/zuse

    > `(pole ,@ta)`(stab '~zod/arvo/~2014.10.28..18.48.41..335f/zuse')
    [~.~zod [~.arvo [~.~2014.10.28..18.48.41..335f [~.zuse ~]]]]

    > (stab '/a/~pillyt/pals/1')
    /a/~pillyt/pals/1

    > `(pole ,@ta)`(stab '/a/~pillyt/pals/1')
    [~.a [~.~pillyt [~.pals [~.1 ~]]]]