Wolfram Language

[vnzio]

Wolfram Mathematica = now called
"Wolfram Language"

has some nice abreviation symbol/shortcuts for typing

But all have the names visible when you invoke
FullForm[]
and the good docs all suggest how to say them out loud
Very nice &important for teaching
And or in any videos

Rebol I think was much inspired by Mathematica

(I don't know for sure)

[bradrn]

This reminds me… related to this thread:

Naming The Infix APPLY Operator

Now that we have the Super Duper APPLY Operator Version 2.0, what's next...? Making It Easier To Use! Imagine if we let <- be an infix operator...taking the name of the function to apply on the left, and a block on the right: <-: enfix func [ 'action [word! tuple! path! group!] args [block] ][ apply (if group? action [do action] else [get action]) args ] It's rather slick! >> append <- [[a b c] <d> /dup 2] == [a b c <d> <d>] >> append/only <- [[a b c] [e f] /dup 2] == [a b c [e…

Mathematica uses f @ x for its equivalent of infix APPLY. (And it uses x // f for the reverse.)

[hostilefork]

@bradrn

Mathematica uses f @ x for its equivalent of infix APPLY

I'm 99.9% sure you won't be able to (and shouldn't be able to) redefine the @ SIGIL! behavior in the evaluator.

@bradrn

And it uses x // f for the reverse.

Historically I've had a lot of trouble with allowing any slash forms to be WORD!, but people very badly want / to be division in the main evaluator.

I wanted it to be a PATH!

>> to path! [_ _]
== /

...because I think Rebol completely sucks for math--and rarely do any in it--I felt like the inconsistency of needing to block these exception words from winding up in paths or tuples was a pain.

But that ship has sailed, really. Things like < or > need to be WORD!, and </> is a TAG!, so to path! [< >] has to know to fail. Might as well accept the slashy words and the checking that has to be done. (Paths are immutable and have a moment at creation time to do the check for illegal words.)

So I imagine // and /// etc. will be WORD!s and you could do this if you wanted.

(It is likely that . and .. and ... etc. will follow the same pattern and be WORD!)

The principal problem with this is that it makes for some annoying edge cases.

 >> compose (void)/1
 == /1

 >> type of compose (void)/1
 == &[path]

 >> compose (void)/(void)
 == /

 >> type of compose (void)/(void)
 == &[word]

You either do something weird when you get to these reduced cases, or you error.

[bradrn]

@hostilefork

...because I think Rebol completely sucks for math

Is this not something which should be improved? Arithmetic is a pretty fundamental thing to be able to do…

[hostilefork]

@bradrn

@hostilefork

...because I think Rebol completely sucks for math

Is this not something which should be improved?

Well, I'm more motivated to think about it now.

Because rather than clone the Rebol/Red DRAW dialect (which nobody uses and has no impressive codebases to dialectize) I was thinking of basically following 3Blue1Brown's Manim as a spec... and see if I could convert some portion of his source to the dialect.

(I'm not sure how mature the JavaScript Manim.js port is is, but I'd hope to build on that.)

And that'd need some math. Anyway, it's traditionally not the domain I've felt interested in targeting... but of course it wouldn't hurt to be better.

[bradrn]

@hostilefork

(I'm not sure how mature the JavaScript Manim.js port is is, but I'd hope to build on that.)

Note that there’s also Haskell Reanimate — not a direct port, but an excellent library nonetheless.