mirror of
https://github.com/urbit/shrub.git
synced 2024-12-12 10:29:01 +03:00
transfusion into kernel as %t vane
This commit is contained in:
Ted Blackman
parent
48cfdae72c
commit
873e073faf
@ -62,7 +62,7 @@
|
||||
[%g /vane/gall]
|
||||
[%e /vane/eyre]
|
||||
[%f /vane/ford]
|
||||
|
||||
[%t /vane/ford-turbo
|
||||
==
|
||||
|- ^+ all
|
||||
?~ vay all
|
||||
|
||||
@ -179,6 +179,7 @@
|
||||
[%e /vane/eyre]
|
||||
[%f /vane/ford]
|
||||
[%g /vane/gall]
|
||||
[%t /vane/ford-turbo]
|
||||
==
|
||||
|= {p/@tas q/path}
|
||||
=+ way=`path`(welp top q)
|
||||
|
||||
5224
sys/vane/ford-turbo.hoon
Normal file
5224
sys/vane/ford-turbo.hoon
Normal file
File diff suppressed because it is too large
Load Diff
630
sys/zuse.hoon
630
sys/zuse.hoon
@ -868,6 +868,636 @@
|
||||
{$volt p/(cask *)} :: unsafe add type
|
||||
== ::
|
||||
-- ::ford
|
||||
:: |ford: build system vane interface
|
||||
::
|
||||
++ ford-api ^?
|
||||
|%
|
||||
:: |able:ford: ford's public +move interface
|
||||
::
|
||||
++ able ^?
|
||||
|%
|
||||
:: +task:able:ford: requests to ford
|
||||
::
|
||||
+= task
|
||||
$% :: %make: perform a build, either live or once
|
||||
::
|
||||
$: %make
|
||||
:: our: who our ship is (remove after cc-release)
|
||||
::
|
||||
our=@p
|
||||
:: plan: the schematic to build
|
||||
::
|
||||
=schematic
|
||||
==
|
||||
:: %kill: stop a build; send on same duct as original %make request
|
||||
::
|
||||
$: %kill
|
||||
:: our: who our ship is (remove after cc-release)s
|
||||
::
|
||||
our=@p
|
||||
==
|
||||
:: %wegh: produce memory usage information
|
||||
::
|
||||
[%wegh ~]
|
||||
:: %wipe: clear cache
|
||||
::
|
||||
[%wipe ~]
|
||||
==
|
||||
:: +gift:able:ford: responses from ford
|
||||
::
|
||||
+= gift
|
||||
$% :: %mass: memory usage; response to %wegh +task
|
||||
::
|
||||
[%mass p=mass]
|
||||
:: %made: build result; response to %make +task
|
||||
::
|
||||
$: %made
|
||||
:: date: formal date of the build
|
||||
::
|
||||
date=@da
|
||||
:: result: result of the build; either complete build, or error
|
||||
::
|
||||
$= result
|
||||
$% :: %complete: contains the result of the completed build
|
||||
::
|
||||
[%complete =build-result]
|
||||
:: %incomplete: couldn't finish build; contains error message
|
||||
::
|
||||
[%incomplete =tang]
|
||||
== == ==
|
||||
--
|
||||
:: +disc: a desk on a ship; can be used as a beak that varies with time
|
||||
::
|
||||
+= disc [=ship =desk]
|
||||
:: +rail: a time-varying full path
|
||||
::
|
||||
:: This can be thought of as a +beam without a +case, which is what
|
||||
:: would specify the time. :spur is flopped just like the +spur in a +beam.
|
||||
::
|
||||
+= rail [=disc =spur]
|
||||
:: +resource: time-varying dependency on a value from the urbit namespace
|
||||
::
|
||||
+= resource
|
||||
$: :: vane which we are querying
|
||||
::
|
||||
vane=?(%c %g)
|
||||
:: type of request
|
||||
::
|
||||
:: TODO: care:clay should be cleaned up in zuse as it is a general
|
||||
:: type, not a clay specific one.
|
||||
::
|
||||
care=care:clay
|
||||
:: path on which to depend, missing time, which will be filled in
|
||||
::
|
||||
=rail
|
||||
==
|
||||
:: +build-result: the referentially transparent result of a +build
|
||||
::
|
||||
:: A +build produces either an error or a result. A result is a tagged
|
||||
:: union of the various kinds of datatypes a build can produce. The tag
|
||||
:: represents the sub-type of +schematic that produced the result.
|
||||
::
|
||||
+= build-result
|
||||
$% :: %error: the build produced an error whose description is :message
|
||||
::
|
||||
[%error message=tang]
|
||||
:: %success: result of successful +build, tagged by +schematic sub-type
|
||||
::
|
||||
$: %success
|
||||
$^ [head=build-result tail=build-result]
|
||||
$% [%$ =cage]
|
||||
[%pin date=@da =build-result]
|
||||
[%alts =build-result]
|
||||
[%bake =cage]
|
||||
[%bunt =cage]
|
||||
[%call =vase]
|
||||
[%cast =cage]
|
||||
[%core =vase]
|
||||
[%diff =cage]
|
||||
[%dude =build-result]
|
||||
[%hood =scaffold]
|
||||
[%join =cage]
|
||||
[%mash =cage]
|
||||
[%mute =cage]
|
||||
[%pact =cage]
|
||||
[%path =rail]
|
||||
[%plan =vase]
|
||||
[%reef =vase]
|
||||
[%ride =vase]
|
||||
[%same =build-result]
|
||||
[%scry =cage]
|
||||
[%slim [=type =nock]]
|
||||
[%slit =type]
|
||||
[%vale =cage]
|
||||
[%volt =cage]
|
||||
== == ==
|
||||
::
|
||||
:: +schematic: plan for building
|
||||
::
|
||||
++ schematic
|
||||
:: If the head of the +schematic is a pair, it's an auto-cons
|
||||
:: schematic. Its result will be the pair of results of its
|
||||
:: sub-schematics.
|
||||
::
|
||||
$^ [head=schematic tail=schematic]
|
||||
::
|
||||
$% :: %$: literal value. Produces its input unchanged.
|
||||
::
|
||||
$: %$
|
||||
:: literal: the value to be produced by the build
|
||||
::
|
||||
literal=cage
|
||||
==
|
||||
:: %pin: pins a sub-schematic to a date
|
||||
::
|
||||
:: There is a difference between live builds and once builds. In
|
||||
:: live builds, we produce results over and over again and aren't
|
||||
:: pinned to a specifc time. In once builds, we want to specify a
|
||||
:: specific date, which we apply recursively to any sub-schematics
|
||||
:: contained within :schematic.
|
||||
::
|
||||
:: If a build has a %pin at the top level, we consider it to be a
|
||||
:: once build. Otherwise, we consider it to be a live build. We do
|
||||
:: this so schematics which depend on the result of a once build can
|
||||
:: be cached, giving the client explicit control over the caching
|
||||
:: behaviour.
|
||||
::
|
||||
$: %pin
|
||||
:: date: time at which to perform the build
|
||||
::
|
||||
date=@da
|
||||
:: schematic: wrapped schematic of pinned time
|
||||
::
|
||||
=schematic
|
||||
==
|
||||
:: %alts: alternative build choices
|
||||
::
|
||||
:: Try each choice in :choices, in order; accept the first one that
|
||||
:: succeeds. Note that the result inherits the dependencies of all
|
||||
:: failed schematics, as well as the successful one.
|
||||
::
|
||||
$: %alts
|
||||
:: choices: list of build options to try
|
||||
::
|
||||
choices=(list schematic)
|
||||
==
|
||||
:: %bake: run a file through a renderer
|
||||
::
|
||||
$: %bake
|
||||
:: renderer: name of renderer; also its file path in ren/
|
||||
::
|
||||
renderer=term
|
||||
:: query-string: the query string of the renderer's http path
|
||||
::
|
||||
query-string=coin
|
||||
:: path-to-render: full path of file to render
|
||||
::
|
||||
path-to-render=rail
|
||||
==
|
||||
:: %bunt: produce the default value for a mark
|
||||
::
|
||||
$: %bunt
|
||||
:: disc where in clay to load the mark from
|
||||
::
|
||||
=disc
|
||||
:: mark: name of mark; also its file path in mar/
|
||||
::
|
||||
mark=term
|
||||
==
|
||||
:: %call: call a gate on a sample
|
||||
::
|
||||
$: %call
|
||||
:: gate: schematic whose result is a gate
|
||||
::
|
||||
gate=schematic
|
||||
:: sample: schematic whose result will be the gate's sample
|
||||
::
|
||||
sample=schematic
|
||||
==
|
||||
:: %cast: cast the result of a schematic through a mark
|
||||
::
|
||||
$: %cast
|
||||
:: disc where in clay to load the mark from
|
||||
::
|
||||
=disc
|
||||
:: mark: name of mark; also its file path in ren/
|
||||
::
|
||||
mark=term
|
||||
:: input: schematic whose result will be run through the mark
|
||||
::
|
||||
input=schematic
|
||||
==
|
||||
:: %core: build a hoon program from a source file
|
||||
::
|
||||
$: %core
|
||||
:: source-path: clay path from which to load hoon source
|
||||
::
|
||||
source-path=rail
|
||||
==
|
||||
:: %diff: produce marked diff from :first to :second
|
||||
::
|
||||
$: %diff
|
||||
:: disc where in clay to load the mark from
|
||||
::
|
||||
=disc
|
||||
:: old: schematic producing data to be used as diff starting point
|
||||
::
|
||||
start=schematic
|
||||
:: new: schematic producing data to be used as diff ending point
|
||||
::
|
||||
end=schematic
|
||||
==
|
||||
:: %dude: wrap a failure's error message with an extra message
|
||||
::
|
||||
$: %dude
|
||||
:: error: a trap producing an error message to wrap the original
|
||||
::
|
||||
error=(trap tank)
|
||||
:: attempt: the schematic to try, whose error we wrap, if any
|
||||
::
|
||||
attempt=schematic
|
||||
==
|
||||
:: %hood: create a +hood from a hoon source file
|
||||
::
|
||||
$: %hood
|
||||
:: source-path: clay path from which to load hoon source
|
||||
::
|
||||
source-path=rail
|
||||
==
|
||||
:: %join: merge two diffs into one diff; produces `~` if conflicts
|
||||
::
|
||||
$: %join
|
||||
:: disc where in clay to load the mark from
|
||||
::
|
||||
=disc
|
||||
:: mark: name of the mark to use for diffs; also file path in mar/
|
||||
::
|
||||
mark=term
|
||||
:: first: schematic producing first diff
|
||||
::
|
||||
first=schematic
|
||||
:: second: schematic producing second diff
|
||||
::
|
||||
second=schematic
|
||||
==
|
||||
:: %mash: force a merge, annotating any conflicts
|
||||
::
|
||||
$: %mash
|
||||
:: disc where in clay to load the mark from
|
||||
::
|
||||
=disc
|
||||
:: mark: name of mark used in diffs; also file path in mar/
|
||||
::
|
||||
mark=term
|
||||
:: first: marked schematic producing first diff
|
||||
::
|
||||
first=[=disc mark=term =schematic]
|
||||
:: second: marked schematic producing second diff
|
||||
::
|
||||
second=[=disc mark=term =schematic]
|
||||
==
|
||||
:: %mute: mutate a noun by replacing its wings with new values
|
||||
::
|
||||
$: %mute
|
||||
:: subject: schematic producing the noun to mutate
|
||||
::
|
||||
subject=schematic
|
||||
:: mutations: axes and schematics to produce their new contents
|
||||
::
|
||||
mutations=(list (pair wing schematic))
|
||||
==
|
||||
:: %pact: patch a marked noun by applying a diff
|
||||
::
|
||||
$: %pact
|
||||
:: disc where in clay to load marks from
|
||||
::
|
||||
=disc
|
||||
:: start: schematic producing a noun to be patched
|
||||
::
|
||||
start=schematic
|
||||
:: diff: schematic producing the diff to apply to :start
|
||||
::
|
||||
diff=schematic
|
||||
==
|
||||
:: %path: resolve a path with `-`s to a path with `/`s
|
||||
::
|
||||
:: Resolve +raw-path to a path containing a file, replacing
|
||||
:: any `-`s in the path with `/`s if no file exists at the
|
||||
:: original path. Produces an error if multiple files match,
|
||||
:: e.g. a/b/c and a/b-c, or a/b/c and a-b/c.
|
||||
::
|
||||
$: %path
|
||||
:: disc: the +disc forming the base of the path to be resolved
|
||||
::
|
||||
=disc
|
||||
:: prefix: path prefix under which to resolve :raw-path, e.g. lib
|
||||
::
|
||||
prefix=@tas
|
||||
:: raw-path: the file path to be resolved
|
||||
::
|
||||
raw-path=@tas
|
||||
==
|
||||
:: %plan: build a hoon program from a preprocessed source file
|
||||
::
|
||||
$: %plan
|
||||
:: path-to-render: the clay path of a file being rendered
|
||||
::
|
||||
:: TODO: Once we've really implemented this, write the
|
||||
:: documentation. (This is the path that starts out as the path
|
||||
:: of the hoon source which generated the scaffold, but can be
|
||||
:: changed with `/:`.)
|
||||
::
|
||||
path-to-render=rail
|
||||
:: query-string: the query string of the http request
|
||||
::
|
||||
query-string=coin
|
||||
:: scaffold: preprocessed hoon source and imports
|
||||
::
|
||||
=scaffold
|
||||
==
|
||||
:: %reef: produce a hoon+zuse kernel. used internally for caching
|
||||
::
|
||||
$: %reef
|
||||
:: disc: location of sys/hoon/hoon and sys/zuse/hoon
|
||||
::
|
||||
=disc
|
||||
==
|
||||
:: %ride: eval hoon as formula with result of a schematic as subject
|
||||
::
|
||||
$: %ride
|
||||
:: formula: a hoon to be evaluated against a subject
|
||||
::
|
||||
formula=hoon
|
||||
:: subject: a schematic whose result will be used as subject
|
||||
::
|
||||
subject=schematic
|
||||
==
|
||||
:: %same: the identity function
|
||||
::
|
||||
:: Functionally used to "unpin" a build for caching reasons. If you
|
||||
:: run a %pin build, it is treated as a once build and is therefore
|
||||
:: not cached. Wrapping the %pin schematic in a %same schematic
|
||||
:: converts it to a live build, which will be cached due to live
|
||||
:: build subscription semantics.
|
||||
::
|
||||
$: %same
|
||||
:: schematic that we evaluate to
|
||||
::
|
||||
=schematic
|
||||
==
|
||||
:: %scry: lookup a value from the urbit namespace
|
||||
::
|
||||
$: %scry
|
||||
:: resource: a namespace request, with unspecified time
|
||||
::
|
||||
:: Schematics can only be resolved when specifying a time,
|
||||
:: which will convert this +resource into a +scry-request.
|
||||
::
|
||||
=resource
|
||||
==
|
||||
:: %slim: compile a hoon against a subject type
|
||||
::
|
||||
$: %slim
|
||||
:: compile-time subject type for the :formula
|
||||
::
|
||||
subject-type=type
|
||||
:: formula: a +hoon to be compiled to (pair type nock)
|
||||
::
|
||||
formula=hoon
|
||||
==
|
||||
:: %slit: get type of gate product
|
||||
::
|
||||
$: %slit
|
||||
:: gate: a vase containing a gate
|
||||
::
|
||||
gate=vase
|
||||
:: sample: a vase containing the :gate's sample
|
||||
::
|
||||
sample=vase
|
||||
==
|
||||
:: %vale: coerce a noun to a mark, validated
|
||||
::
|
||||
$: %vale
|
||||
:: disc where in clay to load the mark from
|
||||
::
|
||||
=disc
|
||||
:: mark: name of mark to use; also file path in mar/
|
||||
::
|
||||
mark=term
|
||||
:: input: the noun to be converted using the mark
|
||||
::
|
||||
input=*
|
||||
==
|
||||
:: %volt: coerce a noun to a mark, unsafe
|
||||
::
|
||||
$: %volt
|
||||
:: disc where in clay to load the mark from
|
||||
::
|
||||
=disc
|
||||
:: mark: name of mark to use; also file path in mar/
|
||||
::
|
||||
mark=term
|
||||
:: input: the noun to be converted using the mark
|
||||
::
|
||||
input=*
|
||||
==
|
||||
==
|
||||
::
|
||||
:: +scaffold: program construction in progress
|
||||
::
|
||||
:: A source file with all its imports and requirements, which will be
|
||||
:: built and combined into one final product.
|
||||
::
|
||||
+= scaffold
|
||||
$: :: source-rail: the file this scaffold was parsed from
|
||||
::
|
||||
source-rail=rail
|
||||
:: zuse-version: the kelvin version of the standard library
|
||||
::
|
||||
zuse-version=@ud
|
||||
:: structures: files from %/sur which are included
|
||||
::
|
||||
structures=(list cable)
|
||||
:: libraries: files from %/lib which are included
|
||||
::
|
||||
libraries=(list cable)
|
||||
:: cranes: a list of resources to transform and include
|
||||
::
|
||||
cranes=(list crane)
|
||||
:: sources: hoon sources, either parsed or on the filesystem
|
||||
::
|
||||
sources=(list brick)
|
||||
==
|
||||
:: +cable: a reference to something on the filesystem
|
||||
::
|
||||
+= cable
|
||||
$: :: face: the face to wrap around the imported file
|
||||
::
|
||||
face=(unit term)
|
||||
:: file-path: location in clay
|
||||
::
|
||||
file-path=term
|
||||
==
|
||||
:: +brick: hoon code, either directly specified or referencing clay
|
||||
::
|
||||
+= brick
|
||||
$% $: :: %direct: inline parsed hoon
|
||||
::
|
||||
%direct
|
||||
source=hoon
|
||||
==
|
||||
$: :: %indirect: reference to a hoon file in clay
|
||||
::
|
||||
%indirect
|
||||
location=beam
|
||||
== ==
|
||||
:: +truss: late-bound path
|
||||
::
|
||||
:: TODO: the +tyke data structure should be rethought, possibly as part
|
||||
:: of this effort since it is actually a `(list (unit hoon))`, when it
|
||||
:: only represents @tas. It should be a structure which explicitly
|
||||
:: represents a path with holes that need to be filled in.
|
||||
::
|
||||
+= truss
|
||||
$: pre=(unit tyke)
|
||||
pof=(unit [p=@ud q=tyke])
|
||||
==
|
||||
:: +crane: parsed rune used to include and transform resources
|
||||
::
|
||||
:: Cranes lifting cranes lifting cranes!
|
||||
::
|
||||
:: A recursive tree of Ford directives that specifies instructions for
|
||||
:: including and transforming resources from the Urbit namespace.
|
||||
::
|
||||
+= crane
|
||||
$% $: :: %fssg: `/~` hoon literal
|
||||
::
|
||||
:: `/~ <hoon>` produces a crane that evaluates arbitrary hoon.
|
||||
::
|
||||
%fssg
|
||||
=hoon
|
||||
==
|
||||
$: :: %fsbc: `/$` process query string
|
||||
::
|
||||
:: `/$` will call a gate with the query string supplied to this
|
||||
:: build. If no query string, this errors.
|
||||
::
|
||||
%fsbc
|
||||
=hoon
|
||||
==
|
||||
$: :: %fsbr: `/|` first of many options that succeeds
|
||||
::
|
||||
:: `/|` takes a series of cranes and produces the first one
|
||||
:: (left-to-right) that succeeds. If none succeed, it produces
|
||||
:: stack traces from all of its arguments.
|
||||
::
|
||||
%fsbr
|
||||
:: choices: cranes to try
|
||||
::
|
||||
choices=(list crane)
|
||||
==
|
||||
$: :: %fsts: `/=` wrap a face around a crane
|
||||
::
|
||||
:: /= runs a crane (usually produced by another ford rune), takes
|
||||
:: the result of that crane, and wraps a face around it.
|
||||
::
|
||||
%fsts
|
||||
:: face: face to apply
|
||||
::
|
||||
face=term
|
||||
:: crane: internal build step
|
||||
::
|
||||
=crane
|
||||
==
|
||||
$: :: %fsdt: `/.` null-terminated list
|
||||
::
|
||||
:: Produce a null-terminated list from a sequence of cranes,
|
||||
:: terminated by a `==`.
|
||||
::
|
||||
%fsdt
|
||||
:: items: cranes to evaluate
|
||||
::
|
||||
items=(list crane)
|
||||
==
|
||||
$: :: %fscm: `/,` switch by path
|
||||
::
|
||||
:: `/,` is a switch statement, which picks a branch to evaluate
|
||||
:: based on whether the current path matches the path in the
|
||||
:: switch statement. Takes a sequence of pairs of (path, crane)
|
||||
:: terminated by a `==`.
|
||||
::
|
||||
%fscm
|
||||
:: cases: produces evaluated crane of first +spur match
|
||||
::
|
||||
cases=(list (pair spur crane))
|
||||
==
|
||||
$: :: %fspm: `/&` pass through a series of marks
|
||||
::
|
||||
:: `/&` passes a crane through multiple marks, right-to-left.
|
||||
::
|
||||
%fspm
|
||||
:: marks: marks to apply to :crane, in reverse order
|
||||
::
|
||||
marks=(list mark)
|
||||
=crane
|
||||
==
|
||||
$: :: %fscb: `/_` run a crane on each file in the current directory
|
||||
::
|
||||
:: `/_` takes a crane as an argument. It produces a new crane
|
||||
:: representing the result of mapping the supplied crane over the
|
||||
:: list of files in the current directory. The keys in the
|
||||
:: resulting map are the basenames of the files in the directory,
|
||||
:: and each value is the result of running that crane on the
|
||||
:: contents of the file.
|
||||
::
|
||||
%fscb
|
||||
=crane
|
||||
==
|
||||
$: :: %fssm: `/;` operate on
|
||||
::
|
||||
:: `/;` takes a hoon and a crane. The hoon should evaluate to a
|
||||
:: gate, which is then called with the result of the crane as its
|
||||
:: sample.
|
||||
::
|
||||
%fssm
|
||||
=hoon
|
||||
=crane
|
||||
==
|
||||
$: :: %fscl: `/:` evaluate at path
|
||||
::
|
||||
:: `/:` takes a path and a +crane, and evaluates the crane with
|
||||
:: the current path set to the supplied path.
|
||||
::
|
||||
%fscl
|
||||
:: path: late bound path to be resolved relative to current beak
|
||||
::
|
||||
:: This becomes current path of :crane
|
||||
::
|
||||
path=truss
|
||||
=crane
|
||||
==
|
||||
$: :: %fskt: `/^` cast
|
||||
::
|
||||
:: `/^` takes a +mold and a +crane, and casts the result of the
|
||||
:: crane to the mold.
|
||||
::
|
||||
%fskt
|
||||
:: mold: evaluates to a mold to be applied to :crane
|
||||
::
|
||||
mold=hoon
|
||||
=crane
|
||||
==
|
||||
$: :: %fszp: `/!mark/` evaluate as hoon, then pass through mark
|
||||
::
|
||||
%fszp
|
||||
=mark
|
||||
==
|
||||
$: :: %fszy: `/mark/` passes current path through :mark
|
||||
::
|
||||
%fszy
|
||||
=mark
|
||||
== ==
|
||||
--
|
||||
:: ::::
|
||||
:::: ++gall :: (1g) extensions
|
||||
:: ::::
|
||||
|
||||
Loading…
Reference in New Issue
Block a user