urbit/shrub
1
1
Fork 0
mirror of https://github.com/urbit/shrub.git synced 2024-12-16 06:51:14 +03:00
Code Issues Packages Projects Releases Wiki Activity
2be23e20db
shrub/lib/xray.hoon
benjamin-tlon a7c967795d
Type Analysis (#865)
2018-10-26 15:43:45 -07:00

1913 lines
62 KiB
Plaintext
Raw Blame History

:: # Type Analysis
::
:: This does analysis on types to produce an `ximage` value, which can
:: be used to print the type (with `ximage-to-spec`) or to print values
:: of that type (using the `pprint` library). Check out `sur/xray.hoon`
:: before digging futher.
::
:: `xray-type` is the main gate of interest here. It's implemented as a
:: series of passes:
::
:: - `analyze-type`: This takes a `type`, which is a lazily-evaluated,
:: recursive data structure, and converts it into an explicit
:: graph. It also collect the information from `%hint` types and
:: decorates the graph nodes with that.
::
:: - `cleanup`: Removes `%pntr` nodes, replacing references to them
:: with references to what they resolve to.
::
:: - `decorate-ximage-with-loops`: Determines which nodes reference
:: themselves recursively.
::
:: - `decorate-ximage-with-patterns`: Adds printing heuristics to types:
:: "Should this be printed as a list?"
::
:: - `decorate-ximage-with-shapes`: Determines the loose shape of each
:: type. This overlaps with, and is used by, the next pass. Doing
:: this as a separate pass removes a lot of difficult edge-cases when
:: determining the `role` of cell-types.
::
:: - `decorate-ximage-with-roles`: Restructures forks to make them
:: coherent. This is important both for printing types (we want to use
:: `$@` `$%` `$%`, etc) and for printing data (we need an efficient
:: way to determine which branch of a fork matches a value.
::
:: # Todos
::
:: - XX It seems (have'nt verified this) that there's a lot of things
:: that are forks that, once void types have been factored out,
:: only actually refer to one thing. It would be nice to discover
:: things of this kind and replace such fork node with the thing the
:: actualy resolve to.
::
:: The reason I think this is what's happening is that I see lots
:: of %unexpected-fork-role messages when converting the kernel type
:: to a spec, and those roles have things like %tall and %atom.
:: However! The `combine` function never produces anything with
:: those roles.
::
:: - XX Create patterns and matchers %map %set.
::
:: - XX Create patterns and matchers for tuples. There's no need to
:: recreate this structure in the printing code, and that's what we're
:: doing now.
::
:: - XX The pattern of an xray could be computed on demand instead of
:: up-front. Possibly a lot faster!
::
:: - XX The loop-detection of an xray could be done on demand instead
:: of up-front. Possibly a lot faster!
::
:: - XX The pattern matching code is basically brute-force.
::
:: If it turns out to be a performance bottleneck, there's lots of
:: low-hanging fruit there. For example:
::
:: - Faces repeat the work done for the type they reference.
:: - When detecting whether a cell is part of an "informal" list,
:: we recurse into the tail repeatedly. For example, the following
:: example will do the "formal-list" test 3 times:
::
:: - `[1 2 `(list @)`~]`
::
:: - XX Try to find a way to drop the `%pntr` constructor from
:: `%data`. The consumer of an `xray` does not care.
::
:: - XX Actually, it would also be really nice to produce another
:: version of this structure that doesn't have the (unit *) wrapper around
:: everything interesting. This would make the on-demand computation
:: of various things hard, though
::
:: - XX Simply lying about the type of deep arms is not robust. I am just
:: claiming that they are nouns, but if another thing in the xray
:: actually needs it, it will think it's a noun too.
::
:: - XX There are probably remaining bugs. Test the shit out of this.
::
:: - XX What should the `role` of a cell with a %noun head be? I
:: think the current design can't handle this case coherently.
::
/? 310
::
/- *xray
::
|^ ^- $: ximage-to-spec=$-(=ximage =spec)
xray-type=$-([@ type] ximage)
focus-on=$-([xtable key] xray)
==
[ximage-to-spec xray-type focus-on]
::
+| %utils
::
:: Left-fold over a list.
::
++ fold
|* [state=mold elem=mold]
|= [[st=state xs=(list elem)] f=$-([state elem] state)]
^- state
|-
?~ xs st
=. st (f st i.xs)
$(xs t.xs, st st)
::
:: This is basically a `mapM` over a list using the State monad.
::
:: Another way to think about this is that it is the same as `turn`,
:: except that a state variable `st` is threaded through the
:: execution. The list is processed from left to right.
::
++ traverse
|* [state=mold in=mold out=mold]
|= [[st=state xs=(list in)] f=$-([state in] [out state])]
^- [(list out) state]
?~ xs [~ st]
=^ r st (f st i.xs)
=^ rs st $(xs t.xs, st st)
[[r rs] st]
::
:: `traverse` over a set.
::
++ traverse-set
|* [state=mold input=mold out=mold]
|= [[st=state xs=(set input)] f=$-([state input] [out state])]
^- [(set out) state]
::
=^ elems st ((traverse state input out) [st ~(tap in xs)] f)
:_ st (~(gas in *(set out)) elems)
::
:: `traverse` over a map, also passing the key to the folding function.
::
++ traverse-map
|* [state=mold key=mold in=mold out=mold]
|= [[st=state dict=(map key in)] f=$-([state key in] [out state])]
^- [(map key out) state]
::
=^ pairs=(list (pair key out)) st
%+ (traverse state (pair key in) (pair key out))
[st ~(tap by dict)]
|= [st=state k=key x=in]
^- [(pair key out) state]
=^ v st (f st k x)
[[k v] st]
::
:_ st
(~(gas by *(map key out)) pairs)
::
:: Given a map, return it's inverse: For each value, what are the set
:: of associated keys?
::
++ reverse-map
|* [key=mold val=mold]
|= tbl=(map key val)
=/ init *(map val (set key))
^- _init
%+ (fold _init (pair key val))
[init ~(tap by tbl)]
|= [acc=_init k=key v=val]
^- _init
=/ mb-keys (~(get by acc) v)
=/ keys=(set key) ?~(mb-keys ~ u.mb-keys)
(~(put by acc) v (~(put in keys) k))
::
+| %helpers
::
+* batt-of [arm] (map term (pair what (map term arm)))
+* chap-of [arm] [doc=what arms=(map term arm)]
::
:: Traverse over a chapter in a battery.
::
++ traverse-chapter
|* [state=mold in=mold out=mold]
|= [[st=state chap=(chap-of in)] f=$-([state term in] [out state])]
^- [(chap-of out) state]
=^ arms st ((traverse-map state term in out) [st arms.chap] f)
[chap(arms arms) st]
::
:: Traverse over a battery.
::
++ traverse-battery
|* [state=mold in=mold out=mold]
|= [[st=state batt=(batt-of in)] f=$-([state term in] [out state])]
^- [(batt-of out) state]
%+ (traverse-map state term (chap-of in) (chap-of out))
[st batt]
|= [st=state chapter-name=term chap=(chap-of in)]
^- [(chap-of out) state]
((traverse-chapter state in out) [st chap] f)
::
:: Map a function over all the arms in a battery.
::
++ turn-battery
|* arm=mold
|= [b=(batt-of arm) f=$-(arm arm)]
^- (batt-of arm)
%- ~(run by b)
|= [w=what chap=(map term arm)]
^- [what (map term arm)]
:- w
%- ~(run by chap)
|= i=arm
^- arm
(f i)
::
:: Create a new xray with `data` set to `d`. If the xray is already in
:: the table, do nothing.
::
++ post-xray
|= [tbl=xtable ty=type d=(unit data)]
^- [key xtable]
::
=/ old (~(get by type-map.tbl) ty)
?^ old [u.old tbl]
::
=/ i=key next.tbl
=/ x=xray [i ty d ~ ~ ~ ~ ~ ~ ~]
::
=. next.tbl +(next.tbl)
=. xrays.tbl (~(put by xrays.tbl) i x)
=. type-map.tbl (~(put by type-map.tbl) ty i)
[i tbl]
::
:: Create an new xray and put it in the xray table. If there's already
:: a stub xray under this type, replace it. Otherwise, allocate a
:: new index and put it there.
::
++ replace-xray
|= [img=xtable x=xray]
^- xtable
img(xrays (~(put by xrays.img) key.x x))
::
:: Get an xray, update it's data, and put it back in.
::
++ set-xray-data
|= [img=xtable i=key d=data]
^- xtable
=/ x=xray (focus-on img i)
(replace-xray img x(data `d))
::
:: Get an xray from an `xtable`, given it's `key`.
::
++ focus-on
|= [img=xtable i=key]
^- xray
=/ res=(unit xray) (~(get by xrays.img) i)
?~ res ~& ['internal error: invalid xray reference' i] !!
u.res
::
:: Return a list of xrays referenced by an xrayed battery. (the context
:: type and the type of each arm).
::
++ battery-refs
|= b=xbattery
^- (list key)
%- zing
%+ turn ~(val by b)
|= [=what =(map term key)]
^- (list key)
~(val by map)
::
:: Just for debugging: print an ximage and then return it.
::
++ trace-ximage
|= img=ximage
^- ximage
~& ['root=' root.img]
~& %+ sort ~(tap by xrays.xtable.img)
|= [[xi=key x=xray] [yi=key y=xray]]
(lth xi yi)
img
::
:: All non-fork xrays referenced by a fork xray. This will recurse
:: into forks-of-forks (and so on) and can handle infinite forks.
::
:: If this is called on a non-fork node, it will return a set with just
:: that one node in it.
::
:: Separating this out really simplifies things, without this handling
:: infinite forks is quite error-prone.
::
:: XX Should we collect face nodes instead of recursing into them (feels
:: like yes, but why did I do it the other way before)?
::
:: XX This is turning out to be useful. Should we add a field to cache
:: the result of this?
::
++ xray-branches
|= [img=xtable i=key]
^- (set key)
::
=/ acc=(set key) ~
=/ stk=(set key) ~
::
|- ^- (set key)
::
?: (~(has in acc) i) acc
?: (~(has in stk) i) acc
::
=. stk (~(put in stk) i)
::
=/ x=xray (focus-on img i)
=/ d=data (need data.x)
::
?- d
%noun (~(put in acc) i)
%void (~(put in acc) i)
[%atom *] (~(put in acc) i)
[%cell *] (~(put in acc) i)
[%core *] (~(put in acc) i)
[%face *] $(i xray.d)
[%pntr *] $(i xray.d)
[%fork *] %+ (fold (set key) key)
[acc ~(tap in set.d)]
|= [=(set key) =key]
^$(acc set, i key)
==
::
+| %entry-point
::
:: The top-level routine: Takes a type, and xrays it to produce an
:: ximage.
::
:: When we analyze a core, we also analyze it's context. `core-depth`
:: controls how deeply we will dig into the context. With `core-depth`
:: at 0, we just pretend that all cores have a context of type `*`.
::
++ xray-type
|= [core-depth=@ =type]
^- ximage
~& %analyze-type
=/ =ximage (analyze-type core-depth type)
~& %cleanup
=. ximage (cleanup ximage)
~& %decorate-ximage-with-loops
=. ximage (decorate-ximage-with-loops ximage)
~& %decorate-ximage-with-patterns
=. ximage (decorate-ximage-with-patterns ximage)
~& %decorate-ximage-with-shapes
=. ximage (decorate-ximage-with-shapes ximage)
:: ~& %trace-ximage
:: =. ximage (trace-ximage ximage)
~& %decorate-ximage-with-roles
(decorate-ximage-with-roles ximage)
:: ~& %trace-ximage
:: (trace-ximage ximage)
::
+| %analysis-passes
::
:: The main analysis code.
::
:: For every type we encounter,
::
:: - First check if an xray for this has already been created. This
:: could either be a recursive reference or just something we've
:: already processed. At this point we don't care.
::
:: - Next, allocate a new xray for this type with empty data. If
:: we encounter this type again recursively, that's fine, that will
:: just produce a reference to this xray and it will eventually
:: have data.
::
:: - Next, recurse into all referenced types and build out graph
:: nodes for those.
::
:: - Finally, create `data` based on the above, and update the xray
:: to have that data.
::
:: - The two edge-cases here are %hint and %hold. For those, we simply
:: do everything in exactly the same way except that `data`
:: will be set to `[%pntr *]`. We will resolve all of these
:: references in the first analysis pass (`cleanup`).
::
++ analyze-type
|= [core-depth=@ud =top=type]
^- ximage
::
|^ (main [0 ~ ~] top-type)
::
++ main
|= [st=xtable ty=type]
^- [key xtable]
::
=/ old (~(get by type-map.st) ty) :: already done
?^ old [u.old st]
::
=^ res=key st (post-xray st ty ~)
::
:- res
?- ty
%void (set-xray-data st res %void)
%noun (set-xray-data st res %noun)
[%atom *] (set-xray-data st res ty)
[%cell *] =^ hed=key st (main st p.ty)
=^ tyl=key st (main st q.ty)
(set-xray-data st res [%cell hed tyl])
[%core *] =^ d=data st (xray-core [p.ty q.ty] st)
(set-xray-data st res d)
[%face *] =^ i=key st (main st q.ty)
(set-xray-data st res [%face p.ty i])
[%fork *] =^ br st ((traverse-set xtable type key) [st p.ty] main)
(set-xray-data st res [%fork br])
[%hint *] =^ ref st (main st q.ty)
=^ updated st (hint st p.ty (focus-on st res))
(set-xray-data (replace-xray st updated) res [%pntr ref])
[%hold *] =^ ref st (main st ~(repo ut ty))
(set-xray-data st res [%pntr ref])
==
::
:: Analyze a %hint type.
::
:: This updates the `helps`, `studs`, and/or `recipe` fields of the
:: given xray.
::
++ hint
|= [st=xtable [subject-of-note=type =note] x=xray]
^- [xray xtable]
?- -.note
%help :_ st x(helps (~(put in helps.x) p.note))
%know :_ st x(studs (~(put in studs.x) p.note))
%made =^ recipe st
?~ q.note [[%direct p.note] st]
=^ params=(list key) st
|- ^- [(list key) xtable]
?~ u.q.note [~ st]
=/ tsld [%tsld [%limb %$] [%wing i.u.q.note]]
=/ part (~(play ut subject-of-note) tsld)
=^ this st (main st part)
=^ more st $(u.q.note t.u.q.note)
[[this more] st]
[[%synthetic p.note params] st]
:_ st x(recipes (~(put in recipes.x) recipe))
==
::
:: Analyze a core.
::
:: When we analyze the context, we decrement `core-depth`. If that
:: ever hits zero, we substitute `%noun` for the type of the context.
::
:: The reason that we switch the varience to %gold is because the
:: core we're creating isn't an actual core, we're just using the arms
:: of this core as a namespace in which to evaluate each arm.
::
:: Also, in general, there's no way to determine the type of an arm
:: of a wet core, so we just assign all wet arms the type `%noun`.
::
:: This seems to work in practice, but I don't think it's actually
:: sound.
::
++ xray-core
|= [[=payload=type =coil] st=xtable]
^- [data xtable]
::
=^ payload-key st (main st payload-type)
=/ ctx=type [%core payload-type coil(r.p %gold)]
::
=^ batt st
%+ (traverse-battery xtable hoon key)
[st q.r.coil]
|= [st=xtable nm=term =hoon]
^- [key xtable]
?: =(%wet q.p.coil) (post-xray st %noun `%noun)
?: =(0 core-depth) (post-xray st %noun `%noun)
=. core-depth (dec core-depth)
(main st [%hold ctx hoon])
::
[[%core p.coil payload-key batt] st]
::
--
::
:: Remove `%pntr` nodes, replacing references to them with references
:: to what they resolve to.
::
:: 1. Build a list of reachable, non-reference nodes.
:: 2. Build a table of references mapped to the node they resolve to.
:: 3. If the root node is a pointer, replace it with what it references.
:: 4. Map over `type-map`, and replace every value using the table from #2.
:: 5. Map over the xrays, drop pointer nodes, replace every reference
:: using the table from #2.
::
++ cleanup
|= xt=ximage
^- ximage
::
=/ img=xtable xtable.xt
::
|^ =/ =key root.xt
~& %build-table
=/ tbl (build-table key)
~& %fix-key
=. key (fix-key tbl key)
~& %fix-type-map
=. type-map.img (fix-type-map tbl type-map.img)
~& %fix-xrays
=. xrays.img (fix-xrays tbl xrays.img)
~& :* %gc-results
%before ~(wyt by xrays.xtable.xt)
%after ~(wyt by xrays.img)
==
[key img]
::
+$ table [live=(set key) refs=(map key key) refs-to=(map key (set key))]
::
:: Given a node that may be a pointer, follow the chain of pointers
:: until we find a non-pointer node.
::
++ deref
|= [img=xtable k=key]
^- key
|-
=/ x=xray (focus-on img k)
=/ d=data (need data.x)
?. ?=([%pntr *] d) key.x
$(k xray.d)
::
:: Walks the graph starting at the root, everything that's a %pntr
:: node becomes a key in the `refs` table and one of the values in the
:: `refs-to` table.
::
++ build-table
|^ |= k=key
^- table
=/ t=table [~ ~ ~]
=. t (recur t k)
=. refs-to.t ((reverse-map key key) refs.t)
t
::
++ recur
|= [acc=table k=key]
^- table
::
?: (~(has in live.acc) k) acc :: already processed
?: (~(has by refs.acc) k) acc :: already processed
::
=/ x=xray (focus-on img k)
=/ d=data (need data.x)
::
=. acc ?. ?=([%pntr *] d)
acc(live (~(put in live.acc) k))
acc(refs (~(put by refs.acc) k (deref img k)))
::
((fold table key) [acc (xray-refs k)] recur)
--
::
:: Rebuild `type-map`:
::
:: - If a type points to a pointer xray, update it to point to what
:: that pointer resolves to
:: - If the type isn't referenced from the root node, ignore it.
:: - Otherwise, just copy it into the resulting table as-is.
::
++ fix-type-map
|= [tbl=table =(map type key)]
^- _map
%+ (fold _map (pair type key))
[*_map ~(tap by map)]
|= [acc=_map [ty=type k=key]]
=/ dest (~(get by refs.tbl) k)
?^ dest (~(put by acc) ty u.dest)
?. (~(has in live.tbl)) acc
(~(put in acc) ty k)
::
:: Rebuild the `xrays` table.
::
:: - If the xray isn't in the `live` set (it wont be there if it's
:: a pointer node or if it's inaccessible from the root node),
:: then ignore it.
:: - Otherwise, copy the xray into the result map while updating
:: all it's references.
::
++ fix-xrays
|= [tbl=table xrays=(map key xray)]
^- _xrays
%+ (fold (map key xray) (pair key xray))
[*(map key xray) ~(tap by xrays)]
|= [acc=(map key xray) [i=key x=xray]]
?. (~(has in live.tbl) i) acc :: Drop unused xrays
(~(put by acc) i (fix-xray tbl x))
::
:: All the xrays which are simply references to `i`.
::
++ all-refs-to
|= [tbl=table i=key]
^- (set key)
=/ res (~(get by refs-to.tbl) i)
?~(res ~ u.res)
::
:: There may be `%hint` data on the `%pntr` xrays. Find all pointer
:: nodes that reference this one, and put all of their hint-data onto
:: this xray.
::
++ collect-hints
|= [tbl=table target=xray]
^- xray
%+ (fold xray key)
[target ~(tap in (all-refs-to tbl key.target))]
|= [acc=xray ref=key]
=/ ref-xray=xray (focus-on img ref)
=/ helps ^- (set help) (~(uni in helps.acc) helps.ref-xray)
=/ recipes ^- (set recipe) (~(uni in recipes.acc) recipes.ref-xray)
::
=/ studs ^- (set stud) :: Type system hack
%+ (fold (set stud) stud)
[studs.acc ~(tap in studs.ref-xray)]
|= [acc=(set stud) new=stud]
(~(put in acc) new)
::
acc(helps helps, studs studs, recipes recipes)
::
:: Note that the `roles` and `pats` fields may contain references
:: to other xrays as well. We don't bother to update those, because this
:: pass runs before those fields are populated.
::
++ fix-xray
|= [tbl=table x=xray]
^- xray
=. x (collect-hints tbl x)
%= x
data `(fix-data tbl (need data.x))
recipes %- ~(gas in *(set recipe))
%+ turn ~(tap in recipes.x)
|= r=recipe (fix-recipe tbl r)
==
::
:: Update all the references in the `data` field.
::
++ fix-data
|= [tbl=table d=data]
^- data
::
=/ fix |=(i=key (fix-key tbl i))
::
?- d
%noun d
%void d
[%atom *] d
[%cell *] d(head (fix head.d), tail (fix tail.d))
[%core *] d(xray (fix xray.d), batt (fix-battery tbl batt.d))
[%face *] d(xray (fix xray.d))
[%fork *] d(set (~(gas in *(set key)) (turn ~(tap in set.d) fix)))
[%pntr *] d(xray (fix xray.d))
==
::
++ fix-battery
|= [tbl=table b=xbattery]
^- xbattery
%+ (turn-battery key) b
|= i=key (fix-key tbl i)
::
++ fix-key
|= [tbl=table i=key]
^- key
=/ res=(unit key) (~(get by refs.tbl) i)
?^ res u.res
i
::
++ fix-recipe
|= [tbl=table r=recipe]
^- recipe
?- r
[%direct *] r
[%synthetic *] r(list (turn list.r |=(i=key (fix-key tbl i))))
==
::
++ xray-refs
|= i=key
^- (list key)
=/ x=xray (focus-on img i)
%- zing
^- (list (list key))
:~ ?~(data.x ~ (data-refs u.data.x))
(zing (turn ~(tap in recipes.x) recipe-refs))
?~(role.x ~ (role-refs u.role.x))
==
::
++ recipe-refs
|= r=recipe
^- (list key)
?- r
[%direct *] ~
[%synthetic *] list.r
==
::
++ role-refs
|= s=role
^- (list key)
?@ s ~
?- -.s
%constant ~
%instance ~
%option ~(val by map.s)
%union ~(val by map.s)
%junction ~[flat.s deep.s]
%conjunction ~[wide.s tall.s]
%misjunction ~[one.s two.s]
==
::
++ data-refs
|= d=data
^- (list key)
?- d
%noun ~
%void ~
[%atom *] ~
[%cell *] ~[head.d tail.d]
[%core *] [xray.d (battery-refs batt.d)]
[%face *] ~[xray.d]
[%pntr *] ~[xray.d]
[%fork *] ~(tap in set.d)
==
--
::
:: Detect loops.
::
:: This works by simply recursing through all the references within an
:: xray while keeping an explicit recursion stack: If we hit a node
:: that's in the stack, that's a loop. If we touch everything without
:: hitting a recursive reference, then it's not a loop.
::
:: Is the short-circuiting sound? I'm not sure now.
::
:: - When could it go wrong?
:: - This graph, for example:
::
:: ```
:: x -> y
:: y -> z
:: y -> y
:: z -> x
:: ```
::
:: - Let's say we process this starting with y, we will see that `y`
:: is a loop, and then when we go to process x, recursing into y will be
:: short-circuited since it's `loop` field is already set.
::
:: - Well, maybe `x` will have been recognized as a loop during the
:: processing of `x`? I think it depends on whether we continue
:: to trace through all references from `y` even after we've found
:: a loop, and I think we do.
::
:: - Put another way, this will recurse into everything referenced
:: by a type, and only mark loops onces it's encountered them:
:: After processing a type, every type that it references
:: (transitive closure) will have been processed correctly.
::
++ decorate-ximage-with-loops
|= xt=ximage
^- ximage
|^ xt(xtable decorated)
::
++ decorated
^- xtable
=/ all-indicies ~(tap in ~(key by xrays.xtable.xt))
((fold xtable key) [xtable.xt all-indicies] decorate)
::
++ decorate
|= [img=xtable i=key]
^- xtable
::
=/ trace=(set key) ~
|- ^- xtable
::
=/ x (focus-on img i)
=/ dat (need data.x)
::
?. =(~ loop.x) img :: already done
?: (~(has in trace) i) (replace-xray img x(loop `%.y))
::
=. trace (~(put in trace) i)
::
=. img
?- dat
%noun img
%void img
[%atom *] img
[%cell *] =. img $(i head.dat)
$(i tail.dat)
[%core *] =. img $(i xray.dat)
%+ (fold xtable key)
[img (battery-refs batt.dat)]
|= [img=xtable i=key]
^$(img img, i i)
[%face *] $(i xray.dat)
[%pntr *] $(i xray.dat)
[%fork *] %+ (fold xtable key)
[img ~(tap in set.dat)]
|= [img=xtable i=key]
^$(img img, i i)
==
::
=. x (focus-on img i) :: get updated xray
?^ loop.x img :: loop found
(replace-xray img x(loop `%.n)) :: no loop found
--
::
:: Fills in the `patterns` fields in each xray (where possible).
::
:: This has a list of pattern "matchers", and, for each xray in the
:: ximage, it tries each matcher until one of them succeeds.
::
++ decorate-ximage-with-patterns
|= xt=ximage
^- ximage
::
=/ img=xtable xtable.xt
::
|^ =/ pairs %+ turn ~(tap by xrays.xtable.xt)
|= [i=key x=xray]
^- [key xray]
[i x(pats (xray-pats x))]
xt(xrays.xtable (~(gas by *(map key xray)) pairs))
::
++ patterns
^- (list $-(xray (unit pattern)))
:~ tree-pattern
list-pattern
unit-pattern
core-pattern
spec-pattern
type-pattern
manx-pattern
vase-pattern
hoon-pattern
json-pattern
nock-pattern
plum-pattern
skin-pattern
==
::
++ xray-pats
|= x=xray
^- (unit pattern)
::
=/ i=key key.x
=/ t=type type.x
=/ d=data (need data.x)
::
:: Atom printing works just fine using the data field.
?: ?=([%atom *] d) ~
::
=/ match patterns
::
|- ^- (unit pattern)
?~ match ~
=/ pat (i.match x)
?^ pat pat
$(match t.match)
::
++ simple-nest-pattern
|= [ty=type pat=pattern]
^- $-(xray (unit pattern))
|= x=xray
^- (unit pattern)
=/ subtype (~(nest ut ty) | type.x)
?:(subtype `pat ~)
::
++ type-pattern (simple-nest-pattern -:!>(*type) %type)
++ spec-pattern (simple-nest-pattern -:!>(*spec) %spec)
++ manx-pattern (simple-nest-pattern -:!>(*manx) %manx)
++ vase-pattern (simple-nest-pattern -:!>(*vase) %vase)
++ hoon-pattern (simple-nest-pattern -:!>(*hoon) %hoon)
++ json-pattern (simple-nest-pattern -:!>(*json) %json)
++ nock-pattern (simple-nest-pattern -:!>(*nock) %nock)
++ plum-pattern (simple-nest-pattern -:!>(*plum) %plum)
++ skin-pattern (simple-nest-pattern -:!>(*skin) %skin)
::
++ focus
|= i=key
^- xray
(focus-on img i)
::
++ is-nil
|= i=key
^- ?
=/ d=data (need data:(focus i))
?+ d %.n
[%atom *] =(d [%atom ~.n `0])
[%face *] $(i xray.d)
==
::
:: Is `ref`, after dereferencing faces, a loop-reference to `target`?
::
++ is-ref-to
|= [target=key ref=key]
^- ?
?: =(target ref) %.y
=/ =data (need data:(focus ref))
?: ?=([%face *] data) $(ref xray.data)
%.n
::
:: Is an xray an atom with the specified aura?
::
++ is-atom-with-aura
|= [c=cord i=key]
^- ?
=/ =data (need data:(focus i))
?+ data %.n
[%atom *] =(data [%atom aura=c constant-unit=~])
[%face *] $(i xray.data)
==
::
:: If the xray is a exactly two things, nil and a cell type, then
:: yield the xray for the cell type.
::
++ fork-of-nil-and-cell
|= x=xray
^- (unit key)
::
=/ d=data (need data.x)
::
?. ?=([%fork *] d) ~
::
=/ branches ~(tap in set.d)
?. ?=([* * ~] branches) ~
::
=/ nil i.branches
=/ node i.t.branches
|-
::
?: (is-nil node) $(node nil, nil node)
?. (is-nil nil) ~
::
`node
::
:: Is this xray a unit? (the %unit pattern)
::
:: This matches strictly. For example `[~ %a]` doesn't match, but
:: `^-((unit @) [~ %a])` does.
::
++ unit-pattern
|^ |= x=xray
^- (unit pattern)
=/ elem (match-unit-type-strict (focus key.x))
?~ elem ~
`[%unit u.elem]
::
++ match-unit-type-strict
|= =input=xray
^- (unit key)
::
=/ node=(unit key) (fork-of-nil-and-cell input-xray)
?~ node ~
::
=/ node-data=data (need data:(focus u.node))
::
?. ?=([%cell *] node-data) ~
?. (is-nil head.node-data) ~
=/ elem-key tail.node-data
=/ elem-data (need data:(focus elem-key))
?. ?=([%face *] elem-data) ~
::
`xray.elem-data
--
::
:: Is this xray a tree? (the %tree pattern)
::
++ tree-pattern
|^ |= =input=xray
^- (unit pattern)
=/ input-key=key key.input-xray
=/ indata=data (need data.input-xray)
?. ?=([%fork *] indata) ~
=/ branches ~(tap in set.indata)
?. ?=([* * ~] branches) ~
=/ nil i.branches
=/ node i.t.branches
|-
?: (is-nil node) $(node nil, nil node)
?. (is-nil nil) ~
=/ node-data=data (need data:(focus node))
?. ?=([%cell *] node-data) ~
?. (is-pair-of-refs-to input-key tail.node-data)
~
=/ elem-data (need data:(focus head.node-data))
?. ?=([%face *] elem-data) ~
`[%tree xray.elem-data]
::
++ is-pair-of-refs-to
|= [target=key cell=key]
^- ?
=/ =data (need data:(focus cell))
?: ?=([%face *] data) $(cell xray.data)
?. ?=([%cell *] data) %.n
?. (is-ref-to target head.data) %.n
?. (is-ref-to target tail.data) %.n
%.y
--
::
::
:: Is this xray a list? (a %list, %tape, %path, or %tour pattern)
::
:: This handles the special case of path literals not having a
:: list type: `/a/b` is just a macro for `[%a %b ~]`, but doesn't
:: accept this for other lists: We don't want ['a' %n ~] to be printed
:: as `['a' ~[%n]]`. However, we WILL print ['a' ~['b' 'c']] as ~['a'
:: 'b' 'c']. And that's what `match-list` matches on.
::
:: `match-list` checks is a type is informally a list: Is it a
:: cell with a (formal or informal) list in it's tail?
::
:: `match-list-type-strict` checks if a list literally has the shape
:: of a `list type`. It must be a loop reference and fork of two
:: types, one of which is the nil type and the other is a cell with a
:: face in it's head and loop reference as it's tail.
::
++ list-pattern
|^ |= x=xray
^- (unit pattern)
=/ elem (match-list x)
?~ elem ~
?: (is-atom-with-aura 'tD' u.elem) [~ %tape]
?: (is-atom-with-aura 'ta' u.elem) [~ %path]
?: (is-atom-with-aura 'c' u.elem) [~ %tour]
?: (is-atom-with-aura 'tas' u.elem) [~ %path]
`[%list u.elem]
::
++ match-list
|= =input=xray
^- (unit key)
=/ d=data (need data.input-xray)
?+ d ~
[%face *] (match-list (focus xray.d))
[%fork *] (match-list-type-strict input-xray)
[%cell *] =/ elem-key=(unit key)
?: ?&((is-nil tail.d) (is-atom-with-aura 'tas' head.d))
`head.d
(match-list (focus tail.d))
?~ elem-key ~
?. (is-ref-to u.elem-key head.d) ~
`u.elem-key
==
::
++ match-list-type-strict
|= =input=xray
^- (unit key)
::
=/ node=(unit key) (fork-of-nil-and-cell input-xray)
?~ node ~
::
=/ node-data=data (need data:(focus u.node))
?. ?=([%cell *] node-data) ~
?. (is-ref-to key.input-xray tail.node-data) ~
::
=/ elem-data (need data:(focus head.node-data))
?. ?=([%face *] elem-data) ~
::
`xray.elem-data
--
::
:: A %gear is any core with a cell context.
::
:: A %gate is a gear with one chapter ('') with one arm ('').
::
++ core-pattern
|^ |= x=xray
^- (unit pattern)
=. x (focus key.x)
=/ gear (match-gear x)
?~ gear ~
=/ gate (match-gate x sample.u.gear batt.u.gear)
?^ gate gate
~ :: XX gear
::
++ match-gear
|= =input=xray
^- (unit [%gear sample=key context=key batt=xbattery])
::
=/ input-data (need data.input-xray)
?. ?=([%core *] input-data) ~
=/ context-key=key xray.input-data
::
=/ context-data=data (need data:(focus context-key))
?. ?=([%cell *] context-data) ~
::
=/ sample-key=key head.context-data
=. context-key tail.context-data
`[%gear sample-key context-key batt.input-data]
::
++ match-gate
|= [=input=xray sample=key batt=xbattery]
^- (unit [%gate key key])
::
=/ input-data (need data.input-xray)
?. ?=([%core *] input-data) ~
=/ chapters ~(tap by batt)
::
?~ chapters ~
?^ t.chapters ~
?. =(p.i.chapters '') ~
::
=/ arms=(list (pair term key)) ~(tap by q.q.i.chapters)
::
?~ arms ~
?^ t.arms ~
?. =(p.i.arms '') ~
::
=/ product=key q.i.arms
::
`[%gate sample product]
--
::
--
::
:: Determines the loose shape of each node in an ximage.
::
:: This is trival for everything besides forks, and for forks, we just
:: find all the non-fork branches with `xray-branches` and then calculate
:: the union type with `combine`.
::
:: Here's some pseudocode for the essence of the logic that we're
:: trying to implement here:
::
:: data Data = Noun | Void
:: | Atom | Cnst
:: | Cell Data Data
:: | Fork Data Data
::
:: data Shape = Noun | Void | Atom | Cnst | Cell | Junc
::
:: shape :: Data -> Shape
:: shape Noun = Noun
:: shape Void = Void
:: shape Atom = Atom
:: shape Cnst = Atom
:: shape (Cell a b) = Cell
:: shape (Fork x y) = forkShape (shape x) (shape y)
::
:: forkShape :: Shape -> Shape -> Shape
:: forkShape Void x = x
:: forkShape Noun _ = Noun
:: forkShape Junc _ = Junc
:: forkShape Atom Cell = Junc
:: forkShape x y | x==y = x
:: forkShape x y = forkShape y x
::
++ decorate-ximage-with-shapes
|^ |= xt=ximage
^- ximage
=/ keys ~(tap in ~(key by xrays.xtable.xt))
%= xt xtable
%+ (fold xtable key)
[xtable.xt keys]
|= [st=xtable i=key]
xtable:(xray-shape st i)
==
::
:: Calculate the xray
::
++ xray-shape
|= [st=xtable i=key]
^- [shape =xtable]
::
=/ x=xray (focus-on st i)
=/ dat (need data.x)
::
?^ shape.x [u.shape.x st] :: already processed
::
=^ res=shape st
?- dat
%noun [%noun st]
%void [%void st]
[%atom *] [%atom st]
[%cell *] [%cell st]
[%core *] [%cell st]
[%fork *] (fork-shape st (xray-branches st key.x))
[%face *] (xray-shape st xray.dat)
[%pntr *] !! :: run `cleanup` first
==
::
=/ y=xray x :: type system hack
=. shape.y `res
=. xrays.st (~(put by xrays.st) key.y y)
[res st]
::
:: Because `branches` comes from `xray-branches`, none of the xrays
:: we're folding over will be forks, therefore, we none of our calls
:: to `xray-shape` will recurse: we wont get stuck in a loop.
::
++ fork-shape
|= [st=xtable branches=(set key)]
^- [shape xtable]
%+ (fold (pair shape xtable) key)
[[%void st] ~(tap in branches)]
|= [acc=(pair shape xtable) i=key]
^- [shape xtable]
=^ res st (xray-shape q.acc i)
[(combine p.acc res) st]
::
:: Given the shapes of two types, determine the shape of their union.
::
++ combine
|= [x=shape y=shape]
^- shape
?: =(x y) x
?: =(x %void) y
?: =(y %void) x
?: =(x %noun) %noun
?: =(y %noun) %noun
%junc
--
::
:: Determine the `role` of each xray node, restructuring forks to make
:: them coherent.
::
:: This is fairly simple for non-role types, and we handle forks the
:: same way we do with `shape` detection. The basic move is to get all
:: of the non-fork branches using `xray-branches`, make a list of them,
:: and fold a function over that. However, the function we're folding with
:: is MUCH more complicated.
::
:: One of the big source of complexity is that we need to restructure
:: the shape of forks, so we will be creating a bunch of new graph
:: nodes, and rearranging them. For example, if we want to merge a
:: junction (a fork of an atom and a cell) with an atom type, we create
:: a new junction xray that is a fork of the old cell type and the
:: union of the two cell types. The function we fold with is `merge`,
:: but the bulk of the logic lives in `combine`.
::
:: Here's some pseudocode for the essence of the logic that we're
:: trying to implement here. Note that the code is actually shaped
:: quite differently than this and is much more detailed. So, try
:: to wrap your head around WHY this makes sense instead of just trying to use
:: this a map for the actual code.
::
:: data Data = Noun | Void
:: | Atom | Cnst
:: | Cell Data Data
:: | Fork Data Data
::
:: data Shape = Noun | Void | Atom | Cnst | Cell | Junc
::
:: data Role = Void | Noun
:: | Atom | Cnst
:: | Tall | Wide | Instance
:: | Option | Union | Conjunc | Junc
:: | Misjunc
::
:: role :: Data -> Unit Role
:: role Noun = ~
:: role Void = ~
:: role Atom = ~
:: role Cnst = ~
:: role (Cell hd _) = `(cellRoleByHead (shape hd))
:: role (Fork x y) = `(forkRole (shape x, role x) (shape y, role y))
::
:: cellRoleByHead :: Shape -> Unit Role
:: cellRoleByHead Cell = `Wide
:: cellRoleByHead Cnst = `Instance
:: cellRoleByHead Atom = `Tall
:: cellRoleByHead _ = ~
::
:: forkRole :: (Shape,Role) + (Shape,Role) -> Role
:: forkRole
:: Option <- option + option
:: Union <- union + union
:: Conjunc <- tall + wide
:: Junc <- atom + cell
:: Misjunc <- otherwise
:: where
:: option = role==Option || role==Instance
:: union = shape==Cnst || role==Union
:: atom = shape==Atom || shape==Cnst
:: cell = shape==Cell
:: tall = role==Tall
:: wide = role==Wide
:: cell = shape==Cell
::
++ decorate-ximage-with-roles
|^ |= xt=ximage
^- ximage
::
=/ keys=(list key) ~(tap in ~(key by xrays.xtable.xt))
::
%= xt xtable
%+ (fold xtable key) [xtable.xt keys]
|= [st=xtable i=key]
^- xtable
xtable:(xray-role st i)
==
::
:: Given a type and data, either find the xray corresponding to that
:: type, or create a new one.
::
:: These xrays are for internal types that we create in order to
:: restructure forks, therefore they will never be loops.
::
++ alloc-fork-xray
|= [st=xtable ty=type d=data]
^- [key xtable]
=/ old=(unit key) (~(get by type-map.st) ty)
?^ old [u.old st]
=/ key next.st
=/ res=xray [key ty `d ~ ~ ~ ~ ~ ~ `%.n]
=. next.st +(key)
=. xrays.st (~(put by xrays.st) key.res res)
=. type-map.st (~(put by type-map.st) type.res key.res)
[key st]
::
:: Produces an xtable updated to have role information for a certain
:: node. For convenience, it also return the role itself.
::
:: Note that the role of a core is always %wide, since the head of
:: a core is a battery, which is always a cell.
::
++ xray-role
|= [st=xtable i=key]
^- [=role =xtable]
=/ x=xray (focus-on st i)
::
=/ old role.x
?^ old [u.old st]
::
=/ dat=data (need data.x)
::
=^ res=role st
?: ?=([~ %void] shape.x) [%void st] :: optimization
?: ?=([~ %noun] shape.x) [%noun st] :: optimization
?- dat
%noun :_ st %noun
%void :_ st %void
[%atom *] :_ st (atom-role dat)
[%cell *] :_ st (cell-role-by-head (focus-on st head.dat))
[%core *] :_ st %wide
[%face *] (xray-role st xray.dat)
[%pntr *] !! :: Run `cleanup` first.
[%fork *] (fork-role st (xray-branches st key.x))
==
::
=. xrays.st (~(put by xrays.st) key.x x(role `res))
[res st]
::
:: Determines the role of an atom xray.
::
++ atom-role
|= [%atom =aura =constant=(unit @)]
^- role
?~ constant-unit %atom
[%constant u.constant-unit]
::
:: Calculate the role of a %cell xray.
::
:: XX I'm not sure this is correct. Should a cell with a noun head
:: be %tall? How about a %void head?
::
:: - A %void head should probably be %void.
:: - A %noun head should probably just be %cell, a role separate from
:: (%wide and %tall) to make the ambiguity explicit. For example,
:: the union of `[* @] + [@ @]` should be a misjunction, which isn't
:: what's happening now.
::
:: XX Also! A cell with a junction in it's head should be a
:: conjunction, right?
::
++ cell-role-by-head
|= head=xray
^- role
::
=/ =shape (need shape.head)
=/ =data (need data.head)
::
=/ const ?. ?=([%atom *] data) ~
constant.data
::
?: =(shape %cell) %wide
?^ const [%instance u.const]
%tall
::
:: Determine the role of %fork type.
::
:: Fold over all the branches off a fork using the `merge` function,
:: and then grab it's `role` using `xray-role`.
::
:: In any non-trivial cases, the xray returned from `merge` will
:: already have it's `role` set, so recursing into `xray-role`
:: shouldn't be dangerous.
::
:: XX This is probably an important part of the control-flow, and it
:: might be helpful to make this invariant more prominent.
::
++ fork-role
|= [st=xtable fork=(set key)]
^- [role xtable]
::
=^ void st (post-xray st %void `%void)
::
=^ i=key st
^- [key xtable]
%+ (fold {key xtable} key)
[[void st] ~(tap in fork)]
|= [[k=key tbl=xtable] branch=key]
^- [key xtable]
(merge tbl k branch)
::
(xray-role st i)
::
:: Return an xray of the union of two xrays.
::
++ merge
|= [st=xtable this=key that=key]
^- [key xtable]
=/ this-xray=xray (focus-on st this)
=/ that-xray=xray (focus-on st that)
?: =(%void type.this-xray) [that st]
?: =(%void type.that-xray) [this st]
(combine st this that)
::
:: =collate-union: merge union maps
::
++ collate-union
|^ |= [st=xtable thick=(map atom key) thin=(map atom key)]
^- [(map atom key) xtable]
::
=/ list=(list (pair atom key)) ~(tap by thin)
::
|- ^- [(map atom key) xtable]
::
?~ list [thick st]
=/ item=(unit key) (~(get by thick) p.i.list)
=^ merged=key st ?~ item [q.i.list st]
(merge-instances st p.i.list u.item q.i.list)
=/ new-thick (~(put by thick) p.i.list merged)
$(list t.list, thick new-thick)
::
:: We want to merge two cell-types that have the same head; gross.
::
:: First, get both tail types, merge them, produce a new cell type
:: with the merged tail.
::
++ merge-instances
|= [st=xtable =atom =x=key =y=key]
^- [key xtable]
::
=/ x-xray=xray (focus-on st x-key)
=/ x-data=data (need data.x-xray)
|- ^- [key xtable]
::
?: ?=([%face *] x-data) $(x-data (need data:(focus-on st xray.x-data)))
?> ?=([%cell *] x-data)
=/ x-tail=key tail.x-data
=/ head-xray=xray (focus-on st head.x-data)
::
=/ y-xray=xray (focus-on st y-key)
=/ y-data=data (need data.y-xray)
|- ^- [key xtable]
::
?: ?=([%face *] y-data) $(y-data (need data:(focus-on st xray.y-data)))
?> ?=([%cell *] y-data)
=/ y-tail=key tail.y-data
::
=^ merged-tail st (merge st x-tail y-tail)
=/ tail-xray=xray (focus-on st merged-tail)
::
=/ res-ty=type [%cell type.head-xray type.tail-xray]
=/ res-data=data [%cell key.head-xray key.tail-xray]
=^ res-key st (alloc-fork-xray st res-ty res-data)
::
=/ res-xray=xray (focus-on st res-key)
=. shape.res-xray `%cell
=. role.res-xray `[%instance atom]
=. xrays.st (~(put by xrays.st) res-key res-xray)
::
[key.res-xray st]
--
::
:: =collate-option: merge option maps
::
++ collate-option
|= [st=xtable thick=(map atom key) thin=(map atom key)]
^- [(map atom key) xtable]
=/ list=(list (pair atom key)) ~(tap by thin)
|-
^- [(map atom key) xtable]
?~ list [thick st]
=/ item=(unit key) (~(get by thick) p.i.list)
=^ merged=key st ?~ item [q.i.list st]
(merge st u.item q.i.list)
=/ new-thick (~(put by thick) p.i.list merged)
$(list t.list, thick new-thick)
::
:: Create a new xray that is the union of two xrays, but with a
:: coherent `role` (where possible, otherwise a %misjunction).
::
:: This often needs to restructure things. For example, if we are
:: combining `{{~ ~} {%a ~}}` and `{{~ ~} {%b ~}}`, we should produce
:: `{{~ ~} ?%({%a ~} {%b ~})}`.
::
:: This is a massive switch on the roles of the two arguments. This
:: is *very* easy to get wrong, so I structured things this in a
:: verbose and explicit way, so that you should be able to easily go
:: through each case and verify that it's doing the right thing.
::
++ combine
|^ |= [st=xtable =this=key =that=key]
^- [key xtable]
::
?: =(this-key that-key) [this-key st]
::
=^ this-role=role st (xray-role st this-key)
=^ that-role=role st (xray-role st that-key)
::
=/ this=[=key =role] [this-key this-role]
=/ that=[=key =role] [that-key that-role]
::
?: ?=(%void role.this) [that-key st]
?: ?=(%void role.that) [this-key st]
?: ?=(%noun role.this) (noun-noun st this that)
?: ?=(%noun role.that) (noun-noun st that this)
?: ?=([%misjunction *] role.this) (misjunkin st this that)
?: ?=([%misjunction *] role.that) (misjunkin st this that)
::
?- role.that
%atom
?- role.this
%atom (atom-atom st that this)
%tall (atom-cell st that this)
%wide (atom-cell st that this)
[%constant *] (atom-atom st that this)
[%instance *] (atom-cell st that this)
[%option *] (atom-optn st that this)
[%union *] (atom-cell st that this)
[%junction *] (atom-junc st that this)
[%conjunction *] (atom-cell st that this)
==
%tall
?- role.this
%atom (atom-cell st this that)
%tall (tall-tall st this that)
%wide (wide-tall st this that)
[%constant *] (atom-cell st this that)
[%instance *] (tall-tall st this that)
[%option *] (atom-cell st this that)
[%union *] (tall-tall st this that)
[%junction *] (cell-junc st that this)
[%conjunction *] (tall-conj st that this)
==
%wide
?- role.this
%atom (atom-cell st this that)
%tall (wide-tall st that this)
%wide (wide-wide st this that)
[%constant *] (atom-cell st this that)
[%instance *] (wide-tall st this that)
[%option *] (atom-cell st this that)
[%union *] (wide-tall st that this)
[%junction *] (cell-junc st that this)
[%conjunction *] (wide-conj st that this)
==
[%constant *]
?- role.this
%atom (atom-atom st that this)
%tall (atom-cell st that this)
%wide (atom-cell st that this)
[%constant *] (cnst-cnst st that this)
[%instance *] (atom-cell st that this)
[%option *] (cnst-optn st that this)
[%union *] (atom-cell st that this)
[%junction *] (atom-junc st that this)
[%conjunction *] (atom-cell st that this)
==
[%instance *]
?- role.this
%atom (atom-cell st this that)
%tall (tall-tall st this that)
%wide (wide-tall st this that)
[%constant *] (atom-cell st this that)
[%instance *] (inst-inst st this that)
[%option *] (atom-cell st this that)
[%union *] (inst-unin st that this)
[%junction *] (cell-junc st that this)
[%conjunction *] (tall-conj st that this)
==
[%option *]
?- role.this
%atom (atom-optn st this that)
%tall (atom-cell st that this)
%wide (atom-cell st that this)
[%constant *] (cnst-optn st this that)
[%instance *] (atom-cell st that this)
[%option *] (optn-optn st this that)
[%union *] (atom-cell st that this)
[%junction *] (atom-junc st that this)
[%conjunction *] (atom-cell st that this)
==
[%union *]
?- role.this
%atom (atom-cell st this that)
%tall (tall-tall st this that)
%wide (wide-tall st this that)
[%constant *] (atom-cell st this that)
[%instance *] (inst-unin st this that)
[%option *] (atom-cell st this that)
[%union *] (unin-unin st this that)
[%junction *] (cell-junc st that this)
[%conjunction *] (tall-conj st that this)
==
[%junction *]
?- role.this
%atom (atom-junc st this that)
%tall (cell-junc st this that)
%wide (cell-junc st this that)
[%constant *] (atom-junc st this that)
[%instance *] (cell-junc st this that)
[%option *] (atom-junc st this that)
[%union *] (cell-junc st this that)
[%junction *] (junc-junc st this that)
[%conjunction *] (cell-junc st this that)
==
[%conjunction *]
?- role.this
%atom (atom-cell st this that)
%tall (tall-conj st this that)
%wide (wide-conj st this that)
[%constant *] (atom-cell st this that)
[%instance *] (tall-conj st this that)
[%option *] (atom-cell st this that)
[%union *] (tall-conj st this that)
[%junction *] (cell-junc st that this)
[%conjunction *] (conj-conj st this that)
==
==
::
:: This guy ACTUALLY constructs the union type by calling `fork`
:: from `hoon.hoon`. To populate the `data` field, we just call
:: `xray-branches` on both of the input xrays and union the result.
::
:: Node that `xray-branches` produces a singleton set when called on
:: a node that isn't a fork, so this works correctly both for
:: joining fork node and non-fork nodes.
::
++ join
|= [st=xtable this=key that=key]
^- [key xtable]
::
?: =(this that) [this st]
::
=/ this-xray=xray (focus-on st this)
=/ that-xray=xray (focus-on st that)
::
=/ union-type=type (fork ~[type.this-xray type.that-xray])
::
=/ this-fork (xray-branches st this)
=/ that-fork (xray-branches st that)
=/ branches (~(uni in this-fork) that-fork)
::
(alloc-fork-xray st union-type [%fork branches])
::
:: Create the join of two xrays with the specified `role`.
::
++ joint
|= [st=xtable x=key y=key =role]
^- [key xtable]
::
=^ joined=key st (join st x y)
=/ jray (focus-on st joined)
=. st (replace-xray st jray(role `role))
[key.jray st]
::
++ atom-atom :: Can't discriminate
|= [st=xtable [x=key role] [y=key role]]
(joint st x y [%misjunction x y])
::
++ atom-cell
|= [st=xtable [a=key role] [c=key role]]
(joint st a c [%junction a c])
::
++ wide-tall
|= [st=xtable [w=key role] [t=key role]]
(joint st w t [%conjunction w t])
::
++ noun-noun :: Can't discriminate
|= [st=xtable [x=key role] [y=key role]]
(joint st x y [%misjunction x y])
::
++ misjunkin
|= [st=xtable [x=key role] [y=key role]]
(joint st x y [%misjunction x y])
::
++ atom-optn :: Can't discriminate
|= [st=xtable [x=key role] [y=key [%option *]]]
(joint st x y [%misjunction x y])
::
++ cnst-optn
|= $: st=xtable
[x=key [%constant xv=atom]]
[y=key [%option ym=(map atom key)]]
==
=^ res st (collate-option st [[xv x] ~ ~] ym)
(joint st x y [%option res])
::
:: XX If the have the same key, produce a new instance who's tail
:: is the union of both tails.
::
++ inst-inst
|= [st=xtable [x=key [%instance xv=atom]] [y=key [%instance yv=atom]]]
=^ res st (collate-union st [[xv x] ~ ~] [[yv y] ~ ~])
(joint st x y [%union res])
::
++ inst-unin
|= $: st=xtable
[x=key [%instance xv=atom]]
[y=key [%union ym=(map atom key)]]
==
=^ res st (collate-union st [[xv x] ~ ~] ym)
(joint st x y [%union res])
::
++ junc-junc
|= $: st=xtable
[x=key [%junction xflat=key xdeep=key]]
[y=key [%junction yflat=key ydeep=key]]
==
=^ flat st (merge st xflat yflat)
=^ deep st (merge st xdeep ydeep)
(joint st x y [%junction flat deep])
::
:: XX Justify why this is always a misjunction. What if they have
:: the same head? Wouldn't producing a wide with that head and the
:: union of the two tails be coherent?
::
:: I *can* get the head and the tail of both and merge them,
:: why would this never make sense?
::
++ tall-tall
|= [st=xtable [x=key role] [y=key role]]
(joint st x y [%misjunction x y])
::
++ unin-unin
|= [st=xtable [x=key [%union xm=(map atom key)]] [y=key [%union ym=(map atom key)]]]
=^ res st (collate-union st xm ym)
(joint st x y [%union res])
::
:: XX Can this ever produce a coherent result? If it can't, should
:: the result be a misjunction, or should the misjunction instead
:: exist in the wide part of the resulting conjunction (what this
:: code will do)?
::
++ wide-conj
|= [st=xtable [x=key role] [y=key [%conjunction ywide=key ytall=key]]]
=^ new-wide st (merge st x ywide)
(joint st x y [%conjunction new-wide ytall])
::
:: XX Justify why this is always a misjunction. What if they have
:: the same head? Wouldn't producing a wide with that head and the
:: union of the two tails be coherent?
::
:: I *can* get the head and the tail and merge
:: them, why would this never make sense?
::
++ wide-wide
|= [st=xtable [x=key role] [y=key role]]
(joint st x y [%misjunction x y])
::
++ cnst-cnst
|= [st=xtable [x=key [%constant xv=atom]] [y=key [%constant yv=atom]]]
=^ res st (collate-option st [[xv x] ~ ~] [[yv y] ~ ~])
(joint st x y [%option res])
::
++ optn-optn
|= [st=xtable [x=key [%option xm=(map atom key)]] [y=key [%option ym=(map atom key)]]]
=^ res st (collate-option st xm ym)
(joint st x y [%option res])
::
++ tall-conj
|= [st=xtable [x=key role] [y=key [%conjunction ywide=key ytall=key]]]
=^ new-tall st (merge st x ytall)
(joint st ywide new-tall [%conjunction ywide new-tall])
::
++ atom-junc
|= [st=xtable [x=key role] [y=key [%junction yflat=key ydeep=key]]]
=^ flat-merged st (merge st x yflat)
(joint st flat-merged ydeep [%junction flat-merged ydeep])
::
++ cell-junc
|= [st=xtable [x=key role] [y=key [%junction yflat=key ydeep=key]]]
=^ deep-merged st (merge st x ydeep)
(joint st yflat deep-merged [%junction yflat deep-merged])
::
++ conj-conj
|= $: st=xtable
[x=key [%conjunction xwide=key xtall=key]]
[y=key [%conjunction ywide=key ytall=key]]
==
=^ new-wide st (merge st xwide ywide)
=^ new-tall st (merge st xtall ytall)
(joint st new-wide new-tall [%conjunction new-wide new-tall])
::
--
--
::
:: Convert an `ximage` to a spec for printing.
::
++ ximage-to-spec
|= [=top=key img=xtable]
^- spec
::
|^ (xray-to-spec ~ top-key)
::
+$ trace (set key)
::
++ xray-to-spec
|= [tr=trace i=key]
^- spec
=/ x=xray (focus-on img i)
=/ d=data (need data.x)
?: (~(has in tr) i) [%loop (synthetic i)]
?^ recipes.x (recipe-to-spec tr n.recipes.x)
%+ wrap-with-loop-binding x
=. tr (~(put in tr) i)
^- spec
?@ d [%base d]
?- -.d
%atom ?~ constant.d [%base %atom aura.d]
?: &(=(%n aura.d) =(`@`0 u.constant.d)) [%base %null]
[%leaf aura.d u.constant.d]
%cell =/ hd `spec`$(i head.d)
=/ tl `spec`$(i tail.d)
=/ both-basic &(=([%base %noun] hd) =([%base %noun] tl))
?: both-basic [%base %cell]
?: ?=(%bscl -.tl) [%bscl hd +.tl]
[%bscl hd tl ~]
%core =/ payld $(i xray.d)
=/ batt ^- (map term spec)
%- ~(run by (flatten-battery batt.d))
|= =key ^$(i key)
?- r.garb.d
%lead [%bszp payld batt]
%gold [%bsdt payld batt]
%zinc [%bstc payld batt]
%iron [%bsnt payld batt]
==
%pntr !!
%face =/ =spec $(i xray.d)
?^(face.d spec [%bsts face.d spec])
%fork =/ =role (need role.x)
|^ ?+ role
~& [%unexpected-fork-role key.x d role choices]
[%bswt choices]
%noun [%base %noun]
%void [%base %void]
[%option *] [%bswt choices]
[%union *] [%bscn choices]
[%misjunction *] [%bswt choices]
[%junction *] [%bsvt ^$(i flat.role) ^$(i deep.role)]
[%conjunction *] [%bskt ^$(i wide.role) ^$(i tall.role)]
==
::
++ choices
^- [i=spec t=(list spec)]
=- ?>(?=(^ -) -)
(turn ~(tap in set.d) |=(=key ^^$(i key)))
--
==
::
:: If this xray references itself, generate a $$ binding in the output
:: spec, and then we can just reference ourselves by name.
::
++ wrap-with-loop-binding
|= [xr=xray sp=spec]
^- spec
?. (need loop.xr) sp
=/ nm (synthetic key.xr)
[%bsbs [%loop nm] [[nm sp] ~ ~]]
::
:: If we have a `recipe`, we can generate much nicer output.
::
++ recipe-to-spec
|= [tr=trace r=recipe]
^- spec
?- -.r
%direct [%like [term.r ~] ~]
%synthetic =/ subs %+ turn list.r
|= =key (xray-to-spec tr key)
[%make [%limb term.r] subs]
==
::
:: Generate symbols to be used for loop references.
::
:: given a small atom (:number), construct a coresponding symbol
:: using the Hebrew alphabet.
::
++ synthetic
|= number=@ud
^- @tas
=/ alf/(list term)
^~ :~ %alf %bet %gim %dal %hej %vav %zay %het
%tet %yod %kaf %lam %mem %nun %sam %ayn
%pej %sad %qof %res %sin %tav
==
?: (lth number 22)
(snag number alf)
(cat 3 (snag (mod number 22) alf) $(number (div number 22)))
::
:: Batterieds in a `spec` do not have chapters, so we just ignore
:: the chapters and flatten the whole battery down to `(map term key)`.
::
++ flatten-battery
|= batt=(batt-of key)
^- (map term key)
=/ chapters ~(tap by batt)
|- ^- (map term key)
?~ chapters ~
(~(uni by q.q.i.chapters) $(chapters t.chapters))
::
--
::
--
Reference in New Issue View Git Blame Copy Permalink