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 ~]]]]