1
0
mirror of https://github.com/ilyakooo0/urbit.git synced 2024-12-26 00:12:28 +03:00
urbit/base/pub/doc/hoon/runes/br/brcn.md
Anton Dyudin 6cbb6b060d Revert "remove docs for demo", "remove odds and ends", "demo network", "DEMO ONLY: root beak as %demo.", "DEMO ONLY: don't show doznec flapping.", "Prinrtf."
This reverts commit 8e1e40d75b3ab15c194b6bf9570f3edc46e2de58.
This reverts commit f073c490f9fd7c5abc033af4857df92229877de7.
This reverts commit f187d2d7e01a54823f3e979af9bbd148b398e7e9.
This reverts commit bc272862a73cfce1b118586ca39d3a377d841f1b.
This reverts commit 30a397513f8890a3406dc7ab91c6e067e3bbfbbb.
This reverts commit 4fc6856fb50d88c20a0f533392ca606641c5f38f.

Conflicts:
	urb/urbit.pill
	urb/zod/base/lib/drum.hoon
2015-06-15 18:10:02 -07:00

3.9 KiB

barcen, |%, %brcn

Build Core

|% is a natural rune that produces a core. |% takes a list of arms . The list must be closed with a --.

The product of |% is similar to an object with named properties containing either functions or data. A |% accepts both dry or %elm and wet or %ash arms. For more about variance, see the glossary.

See also

barcab, |_, %brcb barfas, |/, %brfs

Produces

Twig: [%brcn p=(map term foot)]

Sample

p is a map with ++term keys and ++foot values, which are called arms.

Tall form

|%  
++  p.n.q
  q.n.q
+-  p.n.l.q
  q.n.l.q
--

Wide form

None

Irregular form

None

Examples

/~zod/try=> 
=a  |%
    ++  n  100
    ++  g  |=  b=@
            (add b n)
    --
new var %a
/~zod/try=> 
(g.a 1)
101

Here we create a core with two arms n, a constant and g, a simple funciton. g adds our constant n to whatever is passed to it.

/~zod/try=> 
=a  |%
    ++  l  |%
           ++  r  100
           ++  s  4
           --
    ++  g  |=  b=@
            (div (add b r:l) s:l)
    --
changed %a
/~zod/try=> 
(g.a 4)
26

Extending our previous example a bit, we nest a core inside our arm l and make our gate g a bit more complicated. g now computes the sum of its argument and the arm r inside l, and divides that by s inside l.

++  yo
      |%  ++  cet  36.524                 ::  (add 24 (mul 100 365))
          ++  day  86.400                 ::  (mul 24 hor)
          ++  era  146.097                ::  (add 1 (mul 4 cet))
          ++  hor  3.600                  ::  (mul 60 mit)
          ++  jes  106.751.991.084.417    ::  (mul 730.692.561 era)
          ++  mit  60
          ++  moh  `(list ,@ud)`[31 28 31 30 31 30 31 31 30 31 30 31 ~]
          ++  moy  `(list ,@ud)`[31 29 31 30 31 30 31 31 30 31 30 31 ~]
          ++  qad  126.144.001            ::  (add 1 (mul 4 yer))
          ++  yer  31.536.000             ::  (mul 365 day)
      --

++yo, found in hoon.hoon, uses |% to create a core whose arms contain constant data for calculating time. As the following examples shows, |% is also used to encapsulate arms that perform calculations.

    ++  si                                                  ::  signed integer
      |%
      ++  abs  |=(a=@s (add (end 0 1 a) (rsh 0 1 a)))
      ++  dif  |=([a=@s b=@s] (sum a (new !(syn b) (abs b))))
      ++  dul  |=([a=@s b=@] =+(c=(old a) ?:(-.c (mod +.c b) (sub b +.c))))
      ++  fra  |=  [a=@s b=@s]
               (new =(0 (mix (syn a) (syn b))) (div (abs a) (abs b)))
      ++  new  |=([a=? b=@] `@s`?:(a (mul 2 b) ?:(=(0 b) 0 +((mul 2 (dec b))))))
      ++  old  |=(a=@s [(syn a) (abs a)])
      ++  pro  |=  [a=@s b=@s]
               (new =(0 (mix (syn a) (syn b))) (mul (abs a) (abs b)))
      ++  rem  |=([a=@s b=@s] (dif a (pro b (fra a b))))
      ++  sum  |=  [a=@s b=@s]
               ~|  %si-sum
               =+  [c=(old a) d=(old b)]
               ?:  -.c
                 ?:  -.d
                   (new & (add +.c +.d))
                 ?:  (gte +.c +.d)
                   (new & (sub +.c +.d))
                 (new | (sub +.d +.c))
               ?:  -.d
                 ?:  (gte +.c +.d)
                   (new | (sub +.c +.d))
                 (new & (sub +.d +.c))
               (new | (add +.c +.d))
      ++  sun  |=(a=@u (mul 2 a))
      ++  syn  |=(a=@s =(0 (end 0 1 a)))
      --

++si, found in hoon.hoon, uses |% to create a core whose arms contain gates used to calculate with signed integers, @s. In this case our core is made up entirely of gates.