Can you make your (proposed?) patch (to DS, presumably?) even more explicit?*

[ok, y is “seconds” peeking out from the other “si unit”]

To me, it makes more sense to say (<- what you said)

  string (representing expression) to expression ( <- destructure value to env)
  expression to (shorter) string ( <- eval expression )

(Trying not to make “string”/“word”/“expression” interchangeable)

*i sometimes cannot ask my friends questions (similarly, but also different, to this) as it would be too embarrassing XOR explicit => better (even more symmetric?) sibboleth?

that could make sense, yes. I think one way to keep them from being interchangeable is to say that a (linear) string is composed associatively:

    A,(B,C) == A,B,C == (A,B),C

while an (arboreal) expression is not:

    A,[B,C] <> [A,B],C

one syntax I've played around with is due to physics envy:

    ⟨expression∣intermediate bindings∣pattern⟩

eg

    fib := ⟨n*fib(n-1)∣n>1⟩ + ⟨1|n<=1⟩
    gcd := ⟨gcd(x,y-x)∣x,y>x⟩ + ⟨gcd(x-y,y)∣x,y<x⟩ + ⟨x∣x,y==x⟩

    ftoc := ⟨c∣ c:=t*5/9; t:=f-32 ∣f⟩    NB. °F to C

note that (for codegen purposes) we can simplify expressions and (with failure provision) patterns by expanding them into the intermediate section, similar to ANF; if we were going all the way down to assembly we might want to lower through

    ftoc' := ⟨c∣ c:=t*m; t:=f-a; m:=0.56; a:=32.0 ∣f⟩

but on the other had could have raised to

    ftoc'' := ⟨(f-32)*5/9 ∣ f⟩

and, on the gripping hand, if we wished to be austere, maybe it could be worth it to even insist that in the expression place, computations be injections, in the intermediate isos (changes of representation), and in the pattern surjections?

(note also that here for simplicity I've deliberately used non-overlapping patterns; there's a nice pattern-calculus that allows for both simpler programs and simpler interpreters if one allows algebraic combination with overlapping patterns. However, I've probably made my language unadoptable because no matter what the syntax, combination of patterns is always deliberately unordered — ordering can be achieved if the user insists, but as a 2nd class construct)

finally, everything is given here in the identity monad for simplicity, but the same ideas carry over unchanged to other monads.

Exciting, i.e. might even play with this soonish

alternate syntax at https://oortcloud.flounder.online/junk/ (sorry, very telegraphic!)

[with mostly up-to-date semantics, but this year I gave up on approximating (≲), which is \refines in the suite, in the language itself; the following seems to be more productive (for technical reasons related to using an implementation-specific total order):

    FNull <= f && f <= f    NB. <= is discrete

where equality of closures is pessimistic, based on lexical source and equality of the captured environments, so:

    f <= g ==> f \refines g 
    f \refines g <=> f`x ~ g`x

using (`) as application]

it may help to read chapter 2 of https://www.cs.utoronto.ca/~hehner/aPToP/ for the basic data structure inspiration; another alternate syntax would be to stick with his (for data; this all grew out of wishing to treat functions very differently)

I've also been inspired by the Boom Hierarchy (in terms of trying to put laws, especially distributive/module laws, first) but as my areas of interest don't run to commercial proggys, I haven't found a use for the bag level. [Lamport stuttering, otoh, suggests that ordered but absorbing would be a useful abstraction — and I think that'd easily be buildable on top of this basis]

if I can remember out my creds for oortcloud, and it would help, I can make available a browser-based precedence tool that translates expressions in the JUNK syntax into their abstract trees.

Sorry, waiting for w.a.o to debug themselves, using it as an us-heirs-approved (or rather judgement-mostly-withheld) pro-bono to the su-heirs-approved alternative (which has a largely orthogonal feature set)

It does smell like there is something here*, but judging by your scleras (shall we say, sclera-pupillary boundaries) we should focus on the GR-QM convo, just a tad more..

(Where tad = some kind of dot product with this convo)

(*the (non)associativity)

Percival: Arithmetical properties of strongly chaotic motion ?

TIL Scwhinger was on the Bonaparte counter-clockual programme...

Any chance you could sketch to me why SM works with SR but not GR? Curvature?

[squinting hard enough, is the Wick Theorem related to how algebraically, given pairs (2-things, and hence rel'ns) one automatically gets all finite n-things?]

[another squint: separated at birth: space-ordered vs normal-ordered, and all the sign gymnastics* in computer graphics geometry, where re-ordering matters and vertices are connected by digons of two half-edges?]

is there anything related to the notion that one might have a bunch of geodesic paths connecting events, but that we might apply creation and annihilation to these as well, so fewer geodesics would lead to positive curvatures and more to negative?

* what I like about my algebraic CS model is that I often skim systems papers, and think, "oh, this is just exploiting this particular instance of distributivity..."