ilyakooo0/urbit
1
0
Fork 0
mirror of https://github.com/ilyakooo0/urbit.git synced 2024-12-29 18:06:43 +03:00
Code Issues Packages Projects Releases Wiki Activity

arvo: removes neo-arvo and obsolete pill generators

Browse Source
This commit is contained in:
Joe Bryan 2020-11-23 18:12:52 -08:00
parent f8b2beae32
commit b2eaa5e5b8
4 changed files with 0 additions and 1796 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

255
pkg/arvo/gen/deep.hoon
View File

@ -1,255 +0,0 @@
:- %say
|= $: {now/@da eny/@uvJ bec/beak}
*
==
:- %noun
=>
|%
:: fundamental hierarchical node XX s/b +arch
::
++ node
=< |$ [item]
[fil=(unit item) dir=(map @ta $)]
::
|%
++ de
=| fat=(node)
|@
::
++ get-node
|= pax=path
^+ fat
?~ pax fat
=/ kid (~(get by dir.fat) i.pax)
?~ kid [~ ~]
$(fat u.kid, pax t.pax)
::
++ get
|= pax=path
^+ fil.fat
fil:(get-node pax)
::
++ got
|= pax=path
(need (get pax))
::
++ has
|= pax=path
^- ?
!=(~ (get pax))
::
++ put
|* [pax=path dat=*]
=> .(dat `_?>(?=(^ fil.fat) u.fil.fat)`dat)
^+ fat
?~ pax fat(fil `dat)
=/ kid (~(get by dir.fat) i.pax)
=/ new (fall kid fat(fil ~, dir ~))
fat(dir (~(put by dir.fat) i.pax $(fat new, pax t.pax)))
::
++ gas
|= lit=(list (pair path _?>(?=(^ fil.fat) u.fil.fat)))
^+ fat
?~ lit fat
$(fat (put p.i.lit q.i.lit), lit t.lit)
::
++ tap
=| pax=path
=| out=(list (pair path _?>(?=(^ fil.fat) u.fil.fat)))
|- ^+ out
=? out ?=(^ fil.fat) :_(out [pax u.fil.fat])
=/ dir ~(tap by dir.fat)
|- ^+ out
?~ dir out
%= $
dir t.dir
out ^$(pax (weld pax /[p.i.dir]), fat q.i.dir)
==
-- :: de
-- :: node
--
=>
|%
+$ hoof @t :: hoon source file
+$ news
$: :: use: non-system files
:: new: new set
:: sys: installs + replacements
::
use=(map path plum)
new=(set path)
sys=(map path plum)
==
+$ plum (cask)
+$ seed [hoon=(unit hoof) arvo=hoof]
+$ sprig
$: lull=(unit hoof)
zuse=(unit hoof)
vane=(list (pair term hoof))
==
::
++ wilt :: deep file as source
|= =plum
^- hoof
?>(?=([%hoon @t] plum) q.plum)
::
++ adapt
=* de de:node
|_ fat=(node plum)
::
:: +group: collate changes
::
++ group
|= fal=(list (pair path plum))
=| del=news
|- ^+ del
?~ fal
~? !=(~ use.del)
[%what-use ~(tap in ~(key by use.del))]
~? !=(~ new.del)
[%what-new ~(tap in new.del)]
~? !=(~ sys.del)
[%what-sys ~(tap in ~(key by sys.del))]
del
::
=* pax p.i.fal
=* dat q.i.fal
=/ old (~(get de fat) pax)
::
:: ignore unchanged data
::
?: =(old `dat)
$(fal t.fal)
::
:: classify as user, system install or replacement
::
?. ?=([%sys *] pax)
=. use.del (~(put by use.del) pax dat)
$(fal t.fal)
=? new.del ?=(~ old)
(~(put in new.del) pax)
=. sys.del (~(put by sys.del) pax dat)
$(fal t.fal)
:: +usurp: consider self-replacement
::
++ usurp
|= del=news
^- (unit seed)
::
:: when we get new hoon and arvo system files,
:: we assume they match what's running now
::
=* adopt-new
|=(=path ?:((~(has in new.del) path) ~ (~(get by sys.del) path)))
::
=/ hun (adopt-new /sys/hoon)
=/ arv (adopt-new /sys/arvo)
?~ hun
?~ arv ~
::
:: light reboot, arvo only
::
~& %light-reboot
``(wilt u.arv)
::
:: heavy reboot, hoon and arvo
::
~& %heavy-reboot
:+ ~
`(wilt u.hun)
(wilt ?^(arv u.arv (~(got de fat) /sys/arvo)))
:: +adorn: augment capabilities
::
++ adorn
|= [del=news force=?]
^- sprig
:: lull: shared structures
::
=/ lull
?^ lul=(~(get by sys.del) /sys/lull)
`(wilt u.lul)
?.(force ~ `(wilt (~(got de fat) /sys/lull)))
::
:: zuse: shared library
::
:: %lull is the subject of %zuse; force %zuse if we have a new %lull
::
=/ zuse
=. force ?=(^ lull)
?^ zus=(~(get by sys.del) /sys/zuse)
`(wilt u.zus)
?.(force ~ `(wilt (~(got de fat) /sys/zuse)))
::
:+ lull
zuse
::
:: kernel modules
::
:: %zuse is the subject of the vanes; force all if we have a new %zuse
::
=/ current=(list (pair term hoof))
=. force ?=(^ zuse)
?. force ~
%+ turn
~(tap by dir:(~(get-node de fat) /sys/vane))
|=([name=@ta (node plum)] [`@tas`name (wilt (need fil))])
::
=/ updates=(list (pair term hoof))
%+ turn
%+ skim
~(tap by sys.del)
|=([=path *] ?=([%sys %vane @tas ~] path))
|= [=path =plum]
?> ?=([%sys %vane @tas ~] path)
=* name i.t.t.path
?> ((sane %tas) name)
[`@tas`name (wilt plum)]
::
%+ sort
%~ tap by
%- ~(gas by *(map term hoof))
(weld current updates)
|=([[a=@tas *] [b=@tas *]] (aor a b))
-- :: adapt
::
++ what
|= fat=(node plum)
::
|= fal=(list (pair path plum))
=/ del (~(group adapt fat) fal)
=/ but (~(usurp adapt fat) del)
=/ job (~(adorn adapt fat) del force=?=(^ but))
::
:: adopt system changes
::
=. fat (~(gas de:node fat) ~(tap by sys.del))
::
:: just adopt user changes, which have no systems impact
::
:: XX or ignore? useful for bootstrap?
::
=. fat (~(gas de:node fat) ~(tap by use.del))
::
[[but job] fat]
--
::
=| fat=(node plum)
=^ one fat
%- (what fat)
:~ /sys/hoon^hoon+%a
/sys/arvo^hoon+%a
/sys/lull^hoon+%a
/sys/zuse^hoon+%a
/sys/vane/foo^hoon+%a
/sys/vane/bar^hoon+%a
/sys/vane/baz^hoon+%a
/app/dojo^hoon+%a
/lib/drum^hoon+%a
==
=^ two fat
%- (what fat)
:~ /sys/arvo^hoon+%b
/sys/lull^hoon+%b
/sys/vane/foo^hoon+%b
==
[one two fat]

132
pkg/arvo/gen/glass.hoon
View File

@ -1,132 +0,0 @@
:: Produce a glass pill
::
:::: /hoon/glass/gen
::
/? 310
::
::::
::
:- %say
|= $: {now/@da eny/@uvJ bec/beak}
*
==
=< [%noun ~]
=> |%
++ wasp :: arvo effect
$% {$wack p/@uvJ} :: add entropy
{$what p/(list (pair path (pair term noun)))} :: reset reptile
{$whom p/@p} :: id and boot
==
--
::
:: deterministic test
::
=. eny 0v0
::
:: build arvo with existing compiler
::
|^ ^- *
::
:: neo: root path to boot system, `/~me/[desk]/now/neo`
::
=+ neo=`path`/(scot %p p.bec)/[q.bec]/(scot %da now)/neo
::
:: arvo-source: hoon source file producing arvo kernel, `neo/arvo`
::
=+ arvo-source=.^(@t %cx (welp neo /arvo/hoon))
::
:: arvo-twig: parsed arvo source
::
~& [%parsing `@p`(mug arvo-source)]
=+ arvo-twig=(ream arvo-source)
~& %parsed
::
:: arvo-kernel: a living urbit
::
~& [%compiling `@p`(mug arvo-twig)]
=+ arvo-kernel=+:(slap !>(..ream) arvo-twig)
~& %compiled
::
:: events: list of events to feed our urbit
::
~& %loading
=+ events=main-events
~& [%loaded `@p`(mug events)]
::
:: execute events
::
=+ number=0
|- ^- *
?~ events arvo-kernel
~& number+number
%= $
events t.events
number +(number)
arvo-kernel .*(arvo-kernel(+< i.events) -.arvo-kernel)
==
::
++ main-events
=. now ~2017.3.1
=+ mov=main-moves
|- ^- (list (pair @da ovum))
?~ mov ~
:- [now i.mov]
$(mov t.mov, now (add now (bex 48)))
::
++ main-moves
^- (list ovum)
:~ [[%$ ~] [%what boot-files]]
:: [[%$ ~] [%whom ~zod]]
==
++ boot-files
^- (list (pair path (pair term noun)))
::
:: userspace:
::
:: /app %gall applications
:: /gen :dojo generators
:: /lib %ford libraries
:: /mar %ford marks
:: /sur %ford structures
:: /ren %ford renderers
:: /web %eyre web content
:: /sys system files
:: /neo new system files
::
(user-files /neo ~)
::
++ user-files :: userspace loading
|= :: sal: all spurs to load from
::
sal/(list spur)
^- (list (pair path (pair term noun)))
::
:: hav: all user files
::
=| hav/(list (pair path (pair term noun)))
|- ^+ hav
?~ sal ~
=. hav $(sal t.sal)
::
:: tyl: spur
::
=/ tyl i.sal
|- ^+ hav
::
:: pax: full path at `tyl`
:: lon: directory at `tyl`
::
=/ pax (en-beam:format bec (flop tyl))
=/ lon .^(arch %cy pax)
=? hav ?=(^ fil.lon)
::
:: install only hoon files for now
::
?. ?=({$hoon *} tyl) hav
:_(hav [(flop `path`t.tyl) [%hoon .^(@t %cx pax)]])
::
=/ all ~(tap by dir.lon)
|- ^+ hav
?~ all hav
$(all t.all, hav ^$(tyl [p.i.all tyl]))
--

319
pkg/arvo/gen/metal.hoon
View File

@ -1,319 +0,0 @@
:: Produce a metal pill
::
:::: /hoon/metal/gen
::
/? 310
::
::::
!:
:- %say
|= $: {now/@da * bec/beak}
{{who/@p ~} try/_| ~}
==
::
:: we're creating an event series E whose lifecycle can be computed
:: with the urbit lifecycle formula L, `[2 [0 3] [0 2]]`. that is:
:: if E is the list of events processed by a computer in its life,
:: its final state is S, where S is nock(E L).
::
:: in practice, the first five nouns in E are: two boot formulas,
:: a hoon compiler as a nock formula, the same compiler as source,
:: and the arvo kernel as source.
::
:: after the first five special events, we enter an iterative
:: sequence of regular events which continues for the rest of the
:: computer's life. during this sequence, each state is a function
:: that, passed the next event, produces the next state.
::
:: each event is a `[date wire type data]` tuple, where `date` is a
:: 128-bit Urbit date; `wire` is an opaque path which output can
:: match to track causality; `type` is a symbol describing the type
:: of input; and `data` is input data specific to `type`.
::
:: in real life we don't actually run the lifecycle loop,
:: since real life is updated incrementally and also cares
:: about things like output. we couple to the internal
:: structure of the state machine and work directly with
:: the underlying arvo engine.
::
:: this arvo core, which is at `+7` (Lisp `cddr`) of the state
:: function (see its public interface in `sys/arvo`), gives us
:: extra features, like output, which are relevant to running
:: a real-life urbit vm, but don't affect the formal definition.
::
:: so a real-life urbit interpreter is coupled to the shape of
:: the arvo core. it becomes very hard to change this shape.
:: fortunately, it is not a very complex interface.
::
:- %noun
::
:: boot-one: lifecycle formula
::
=+ ^= boot-one
::
:: event 1 is the lifecycle formula which computes the final
:: state from the full event sequence.
::
:: the formal urbit state is always just a gate (function)
:: which, passed the next event, produces the next state.
::
=> [boot-formula=* full-sequence=*]
!= ::
:: first we use the boot formula (event 1) to set up
:: the pair of state function and main sequence. the boot
:: formula peels off the first n (currently 3) events
:: to set up the lifecycle loop.
::
=+ [state-gate main-sequence]=.*(full-sequence boot-formula)
::
:: in this lifecycle loop, we replace the state function
:: with its product, called on the next event, until
:: we run out of events.
::
|- ?@ main-sequence
state-gate
%= $
main-sequence +.main-sequence
state-gate .*(state-gate [%9 2 %10 [6 %1 -.main-sequence] %0 1])
==
::
:: boot-two: startup formula
::
=+ ^= boot-two
::
:: event 2 is the startup formula, which verifies the compiler
:: and starts the main lifecycle.
::
=> :* :: event 3: a formula producing the hoon compiler
::
compiler-formula=**
::
:: event 4: hoon compiler source, compiling to event 2
::
compiler-source=*@t
::
:: event 5: arvo kernel source
::
arvo-source=*@t
::
:: events 6..n: main sequence with normal semantics
::
main-sequence=**
==
!= :_ main-sequence
::
:: activate the compiler gate. the product of this formula
:: is smaller than the formula. so you might think we should
:: save the gate itself rather than the formula producing it.
:: but we have to run the formula at runtime, to register jets.
::
:: as always, we have to use raw nock as we have no type.
:: the gate is in fact ++ride.
::
~> %slog.[0 leaf+"1-b"]
=+ ^= compiler-gate
.*(0 compiler-formula)
::
:: compile the compiler source, producing (pair span nock).
:: the compiler ignores its input so we use a trivial span.
::
~> %slog.[0 leaf+"1-c"]
=+ ^= compiler-tool
.*(compiler-gate [%9 2 %10 [6 %1 [%noun compiler-source]] %0 1])
::
:: switch to the second-generation compiler. we want to be
:: able to generate matching reflection nouns even if the
:: language changes -- the first-generation formula will
:: generate last-generation spans for `!>`, etc.
::
~> %slog.[0 leaf+"1-d"]
=. compiler-gate .*(0 +:compiler-tool)
::
:: get the span (type) of the kernel core, which is the context
:: of the compiler gate. we just compiled the compiler,
:: so we know the span (type) of the compiler gate. its
:: context is at tree address `+>` (ie, `+7` or Lisp `cddr`).
:: we use the compiler again to infer this trivial program.
::
~> %slog.[0 leaf+"1-e"]
=+ ^= kernel-span
-:.*(compiler-gate [%9 2 %10 [6 %1 [-.compiler-tool '+>']] %0 1])
::
:: compile the arvo source against the kernel core.
::
~> %slog.[0 leaf+"1-f"]
=+ ^= kernel-tool
.*(compiler-gate [%9 2 %10 [6 %1 [kernel-span arvo-source]] %0 1])
::
:: create the arvo kernel, whose subject is the kernel core.
::
~> %slog.[0 leaf+"1-g"]
.*(+>:compiler-gate +:kernel-tool)
::
:: sys: root path to boot system, `/~me/[desk]/now/sys`
::
=+ sys=`path`/(scot %p p.bec)/[q.bec]/(scot %da now)/sys
::
:: compiler-source: hoon source file producing compiler, `sys/hoon`
::
=+ compiler-source=.^(@t %cx (welp sys /hoon/hoon))
::
:: compiler-twig: compiler as hoon expression
::
~& %metal-parsing
=+ compiler-twig=(ream compiler-source)
~& %metal-parsed
::
:: compiler-formula: compiler as nock formula
::
~& %metal-compiling
=+ compiler-formula=q:(~(mint ut %noun) %noun compiler-twig)
~& %metal-compiled
::
:: arvo-source: hoon source file producing arvo kernel, `sys/arvo`
::
=+ arvo-source=.^(@t %cx (welp sys /arvo/hoon))
::
:: main-moves: installation actions
::
=+ ^= main-moves
|^ ^- (list ovum)
:~ ::
:: configure identity
::
[[%name (scot %p who) ~] [%veal who]]
::
:: sys/zuse: standard library
::
(vent %$ /zuse)
::
:: sys/vane/ames: network
::
(vent %a /vane/ames)
::
:: sys/vane/behn: timer
::
(vent %b /vane/behn)
::
:: sys/vane/clay: revision control
::
(vent %c /vane/clay)
::
:: sys/vane/dill: console
::
(vent %d /vane/dill)
::
:: sys/vane/eyre: web
::
(vent %e /vane/eyre)
::
:: sys/vane/gall: applications
::
(vent %g /vane/gall)
::
:: sys/vane/jael: security
::
(vent %j /vane/jael)
::
:: legacy boot event
::
[[%$ %term '1' ~] [%boot %sith who `@uw`who &]]
::
:: userspace:
::
:: /app %gall applications
:: /gen :dojo generators
:: /lib %ford libraries
:: /mar %ford marks
:: /sur %ford structures
:: /ren %ford renderers
:: /web %eyre web content
:: /sys system files
::
(user /app /gen /lib /mar /ren /sec /sur /sys /web ~)
==
:: ::
++ user :: userspace loading
|= :: sal: all spurs to load from
::
sal/(list spur)
^- ovum
::
:: hav: all user files
::
=; hav ~& user-files+(lent hav)
[[%$ %sync ~] [%into %$ & hav]]
=| hav/mode:clay
|- ^+ hav
?~ sal ~
=. hav $(sal t.sal)
::
:: tyl: spur
::
=/ tyl i.sal
|- ^+ hav
::
:: pax: full path at `tyl`
:: lon: directory at `tyl`
::
=/ pax (en-beam:format bec (flop tyl))
=/ lon .^(arch %cy pax)
=? hav ?=(^ fil.lon)
?. ?=({$hoon *} tyl)
::
:: install only hoon files for now
::
hav
::
:: cot: file as plain-text octet-stream
::
=; cot [[(flop `path`tyl) `[/text/plain cot]] hav]
^- octs
?- tyl
{$hoon *}
=/ dat .^(@t %cx pax)
[(met 3 dat) dat]
==
=/ all ~(tap by dir.lon)
|- ^- mode:clay
?~ all hav
$(all t.all, hav ^$(tyl [p.i.all tyl]))
::
++ vent
|= {abr/term den/path}
=+ pax=(weld sys den)
=+ txt=.^(@ %cx (welp pax /hoon))
`ovum`[[%vane den] [%veer abr pax txt]]
--
::
:: main-events: full events with advancing times
::
=. now ~2017.3.1
=+ ^= main-events
|- ^- (list (pair @da ovum))
?~ main-moves ~
:- [now i.main-moves]
$(main-moves t.main-moves, now (add now (bex 48)))
::
~? try
~& %metal-testing
=+ ^= yop
^- @p
%- mug
.* :* boot-one
boot-two
compiler-formula
compiler-source
arvo-source
main-events
==
[2 [0 3] [0 2]]
[%metal-tested yop]
::
:* boot-one
boot-two
compiler-formula
compiler-source
arvo-source
main-events
==

1090
pkg/arvo/neo/arvo.hoon
View File

File diff suppressed because it is too large Load Diff