ilyakooo0/urbit

Fork 0

mirror of https://github.com/ilyakooo0/urbit.git synced 2024-12-18 20:31:40 +03:00

Philip C Monk f03263852c main->base, arvo events depth-first

2015-04-29 18:48:45 -04:00

13 KiB

Raw Blame History

section 2eH, parsing (idioms)

`++alf`

Alphabetic characters

++  alf  ;~(pose low hig)                               ::  alphabetic

Parse alphabetic characters, both upper and lowercase.

    ~zod/try=> (scan "a" alf)
    ~~a
    ~zod/try=> (scan "A" alf)
    ~~~41.
    ~zod/try=> (scan "AaBbCc" (star alf))
    "AaBbCc"

`++aln`

Alphanumeric characters

++  aln  ;~(pose low hig nud)                           ::  alphanumeric

Parse alphanumeric characters - both alphabetic characters and numbers.

    ~zod/try=> (scan "0" aln)
    ~~0
    ~zod/try=> (scan "alf42" (star aln))
    "alf42"
    ~zod/try=> (scan "0123456789abcdef" (star aln))
    "0123456789abcdef"

`++alp`

Alphanumeric and -

++  alp  ;~(pose low hig nud hep)                       ::  alphanumeric and -

Parse alphanumeric strings and hep, "-".

    ~zod/try=> (scan "7" alp)
    ~~7
    ~zod/try=> (scan "s" alp)
    ~~s
    ~zod/try=> (scan "123abc-" (star alp))
    "123abc-"

`++bet`

Axis syntax -, +

++  bet  ;~(pose (cold 2 hep) (cold 3 lus))             ::  axis syntax - +

Parse the hep and lus axis syntax.

    ~zod/try=> (scan "-" bet)
    2
    ~zod/try=> (scan "+" bet)
    3

`++bin`

Binary to atom

++  bin  (bass 2 (most gon but))                        ::  binary to atom

Parse a tape of binary (0s and 1s) and produce its atomic representation.

    ~zod/try=> (scan "0000" bin)
    0
    ~zod/try=> (scan "0001" bin)
    1
    ~zod/try=> (scan "0010" bin)
    2
    ~zod/try=> (scan "100000001111" bin)
    2.063

`++but`

Binary digit

++  but  (cook |=(a=@ (sub a '0')) (shim '0' '1'))      ::  binary digit

Parse a single binary digit.

    ~zod/try=> (scan "0" but)
    0
    ~zod/try=> (scan "1" but)
    1
    ~zod/try=> (scan "01" but)
    ! {1 2}
    ! 'syntax-error'
    ! exit
    ~zod/try=> (scan "01" (star but))
    ~[0 1]

`++cit`

Octal digit

++  cit  (cook |=(a=@ (sub a '0')) (shim '0' '7'))      ::  octal digit

Parse a single octal digit.

    ~zod/try=> (scan "1" cit)
    1
    ~zod/try=> (scan "7" cit)
    7
    ~zod/try=> (scan "8" cit)
    ! {1 1}
    ! 'syntax-error'
    ! exit
    ~zod/try=> (scan "60" (star cit))
    ~[6 0]

`++dem`

Decimal to atom

++  dem  (bass 10 (most gon dit))                       ::  decimal to atom

Parse a decimal number to an atom.

    ~zod/try=> (scan "7" dem)
    7
    ~zod/try=> (scan "42" dem)
    42
    ~zod/try=> (scan "150000000" dem)
    150.000.000
    ~zod/try=> (scan "12456" dem)
    12.456

`++dit`

Decimal digit

++  dit  (cook |=(a=@ (sub a '0')) (shim '0' '9'))      ::  decimal digit

Parse a single decimal digit.

    ~zod/try=> (scan "7" dit)
    7
    ~zod/try=> (scan "42" (star dit))
    ~[4 2]
    ~zod/try=> (scan "26000" (star dit))
    ~[2 6 0 0 0]

`++gul`

Axis syntax < or >

++  gul  ;~(pose (cold 2 gal) (cold 3 gar))             ::  axis syntax < >

Parse the axis gal and gar axis syntax.

    ~zod/try=> (scan "<" gul)
    2
    ~zod/try=> (scan ">" gul)
    3

`++gon`

Long numbers

++  gon  ;~(pose ;~(plug bas gay fas) (easy ~))         ::  long numbers \ /

Parse long numbers - Numbers which wrap around the shell with the line break characters bas and fas.

    ~zod/try=> (scan "\\/" gon)
    [~~~5c. ~ ~~~2f.]
    ~zod/try=> (gon [[1 1] "\\/"])
    [p=[p=1 q=3] q=[~ u=[p=[~~~5c. ~ ~~~2f.] q=[p=[p=1 q=3] q=""]]]]

`++hex`

Hex to atom

++  hex  (bass 16 (most gon hit))                       ::  hex to atom

Parse any hexadecimal number to an atom.

    ~zod/try=> (scan "a" hex)
    10
    ~zod/try=> (scan "A" hex)
    10
    ~zod/try=> (scan "2A" hex)
    42
    ~zod/try=> (scan "1ee7" hex)
    7.911
    ~zod/try=> (scan "1EE7" hex)
    7.911
    ~zod/try=> (scan "1EE7F7" hex)
    2.025.463
    ~zod/try=> `@ux`(scan "1EE7F7" hex)
    0x1e.e7f7

`++hig`

Uppercase

++  hig  (shim 'A' 'Z')                                 ::  uppercase

Parse a single uppercase letter.

    ~zod/try=> (scan "G" hig)
    ~~~47.
    ~zod/try=> `cord`(scan "G" hig)
    'G'
    ~zod/try=> (scan "ABCDEFGHIJKLMNOPQRSTUVWXYZ" (star hig))
    "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    ~zod/try=> (hig [[1 1] "G"])
    [p=[p=1 q=2] q=[~ [p=~~~47. q=[p=[p=1 q=2] q=""]]]]

`++hit`

Hex digits

++  hit  ;~  pose                                       ::  hex digits
           dit
           (cook |=(a=char (sub a 87)) (shim 'a' 'f'))
           (cook |=(a=char (sub a 55)) (shim 'A' 'F'))
         ==

Parse a single hexadecimal digit.

    ~zod/try=> (scan "a" hit)
    10
    ~zod/try=> (scan "A" hit)
    10
    ~zod/try=> (hit [[1 1] "a"])
    [p=[p=1 q=2] q=[~ [p=10 q=[p=[p=1 q=2] q=""]]]]
    ~zod/try=> (scan "2A" (star hit))
    ~[2 10]

`++low`

Lowercase

++  low  (shim 'a' 'z')                                 ::  lowercase

Parse a single lowercase letter.

    ~zod/try=> (scan "g" low)
    ~~g
    ~zod/try=> `cord`(scan "g" low)
    'g'
    ~zod/try=> (scan "abcdefghijklmnopqrstuvwxyz" (star low))
    "abcdefghijklmnopqrstuvwxyz"
    ~zod/try=> (low [[1 1] "g"])
    [p=[p=1 q=2] q=[~ [p=~~g q=[p=[p=1 q=2] q=""]]]]

`++mes`

Hexbyte

++  mes  %+  cook                                       ::  hexbyte
           |=([a=@ b=@] (add (mul 16 a) b))
         ;~(plug hit hit)

Parse a hexbyte.

    ~zod/try=> (scan "2A" mes)
    42
    ~zod/try=> (mes [[1 1] "2A"])
    [p=[p=1 q=3] q=[~ u=[p=42 q=[p=[p=1 q=3] q=""]]]]
    ~zod/try=> (scan "42" mes)
    66

`++nix`

Letters, -, and _

++  nix  (boss 256 (star ;~(pose aln cab)))             ::

Letters, -, and _

~zod/try=> (scan "as_me" nix)
q=435.626.668.897
~zod/try=> `@t`(scan "as_me" nix)
'as_me'

`++nud`

Numeric

++  nud  (shim '0' '9')                                 ::  numeric

Parse a numeric character - A number.

~zod/try=> (scan "0" nud)
~~0
~zod/try=> (scan "7" nud)
~~7
~zod/try=> (nud [[1 1] "1"])
[p=[p=1 q=2] q=[~ [p=~~1 q=[p=[p=1 q=2] q=""]]]]
~zod/try=> (scan "0123456789" (star nud))
"0123456789"

`++prn`

Printable character

++  prn  ;~(less (just `@`127) (shim 32 256))

Parse any printable character

~zod/try=> (scan "h" prn)
~~h
~zod/try=> (scan "!" prn)
~~~21.
~zod/try=> (scan "\01" prn)
! {1 1}
! exit

`++qat`

Chars in blockcord

++  qat  ;~  pose                                       ::  chars in blockcord
             prn
             ;~(less ;~(plug (just `@`10) soqs) (just `@`10))
         ==

Parse character in cord block.

~zod/try=> (scan "h" qat)
~~h
~zod/try=> (scan "!" qat)
~~~21.
~zod/try=> (scan "\0a" qat)
~~~a.
~zod/try=> (scan "\00" qat)
! {1 1}
! exit

`++qit`

Chars in cord

++  qit  ;~  pose                                       ::  chars in a cord
             ;~(less bas soq prn)
             ;~(pfix bas ;~(pose bas soq mes))          ::  escape chars
         ==

Parse an individual character to its cord atom representation.

~zod/try=> (scan "%" qit)
37
~zod/try=> `@t`(scan "%" qit)
'%'
~zod/try=> (scan "0" qit)
48
~zod/try=> (scan "E" qit)
69
~zod/try=> (scan "a" qit)
97
~zod/try=> (scan "\\0a" qit)
10
~zod/try=> `@ux`(scan "\\0a" qit)
0xa
~zod/try=> (scan "cord" (star qit))
~[99 111 114 100]

`++qut`

Cord

++  qut  ;~  pose                                       ::  cord
             ;~  less  soqs
               (ifix [soq soq] (boss 256 (more gon qit)))
             ==
             %-  inde  %+  ifix
               :-  ;~  plug  soqs
                     ;~(pose ;~(plug (plus ace) vul) (just '\0a'))
                   ==
               ;~(plug (just '\0a') soqs)
             (boss 256 (star qat))
         ==
::

Parse single-soq cord with \{gap}/ anywhere in the middle, or triple-soq cord which must be in an indented block.

~zod/try=> (scan "'cord'" qut)
q=1.685.221.219
~zod/try=> 'cord'
'cord'
~zod/try=> `@ud`'cord'
1.685.221.219
/~zod/try=> '''
            Heredoc isn't prohibited from containing quotes
            '''
'Heredoc isn't prohibited from containing quotes'

`++soqs`

Delimiting '''

++  soqs  ;~(plug soq soq soq)                          ::  delimiting '''

Triple single quote

~zod/try=> (scan "'''" soqs)
[~~~27. ~~~27. ~~~27.]
~zod/try=> (rash '"""' soqs)
! {1 1}
! exit

`++sym`

Term

++  sym
  %+  cook
    |=(a=tape (rap 3 ^-((list ,@) a)))
  ;~(plug low (star ;~(pose nud low hep)))
::

A term: a letter(lowercase), followed by letters, numbers, or -.

~zod/try=> (scan "sam-2" sym)
215.510.507.891
~zod/try=> `@t`(scan "sam-2" sym)
'sam-2'
~zod/try=> (scan "sym" sym)
7.174.515

`++ven`

+>- axis syntax

++  ven  ;~  (comp |=([a=@ b=@] (peg a b)))             ::  +>- axis syntax
           bet
           =+  hom=`?`|
           |=  tub=nail
           ^-  (like axis)
           =+  vex=?:(hom (bet tub) (gul tub))
           ?~  q.vex
             [p.tub [~ 1 tub]]
           =+  wag=$(p.tub p.vex, hom !hom, tub q.u.q.vex)
           ?>  ?=(^ q.wag)
           [p.wag [~ (peg p.u.q.vex p.u.q.wag) q.u.q.wag]]
         ==

Axis syntax parser

~zod/arvo=/hoon/hoon> (scan "->+" ven)
11
~zod/arvo=/hoon/hoon> `@ub`(scan "->+" ven)
0b1011
~zod/arvo=/hoon/hoon> (peg (scan "->" ven) (scan "+" ven))
11
~zod/arvo=/hoon/hoon> ->+:[[1 2 [3 4]] 5]
[3 4]

`++vit`

Base64 digit

++  vit                                                 ::  base64 digit
  ;~  pose
    (cook |=(a=@ (sub a 65)) (shim 'A' 'Z'))
    (cook |=(a=@ (sub a 71)) (shim 'a' 'z'))
    (cook |=(a=@ (add a 4)) (shim '0' '9'))
    (cold 62 (just '-'))
    (cold 63 (just '+'))
  ==

Terran base64

~zod/arvo=/hoon/hoon> (scan "C" vit)
2
~zod/arvo=/hoon/hoon> (scan "c" vit)
28
~zod/arvo=/hoon/hoon> (scan "2" vit)
54
~zod/arvo=/hoon/hoon> (scan "-" vit)
62

13 KiB Raw Blame History

section 2eH, parsing (idioms)

++alf

++aln

++alp

++bet

++bin

++but

++cit

++dem

++dit

++gul

++gon

++hex

++hig

++hit

++low

++mes

++nix

++nud

++prn

++qat

++qit

++qut

++soqs

++sym

++ven

++vit