Verbing Nouns Revisited: COMBINATOR and COMB

We've long lamented the unfortunate nature of "verbing" nouns like FUNCTION.

And again, we have this situation where if we use COMBINATOR as the way of declaring a combinator, what do we call instances? C? COMB?

It feels a bit sad that we can't just write something like:

combinator: select state.combinators group!  ; get the GROUP! combinator

If you do that, you're overwriting the function you use to make combinators. And that's no good.

So I wind up writing:

comb: select state.combinators group!  ; get the GROUP! combinator

But it seems that COMBINATOR rightly belongs to the instance, and the thing that makes combinators should be called something like MAKE-COMBINATOR. If anything, COMB should be the shorthand for MAKE-COMBINATOR and we allow the word COMBINATOR for instances of combinators.

I got to wondering why we don't like MAKE-FUNCTION or MAKE-COMBINATOR. Is it the hyphen? What if it were make function and make combinator and it dispatched to the "makers" based on quoting the words?

This would create a little bit of confusion, but we've gotten used to:

length: length of block

Why can't we accept:

combinator: make combinator [...] [...]

I hate to beat this old dead horse again. But FUNCTION is a noun. COMBINATOR is a noun. It still feels like something is wrong with verbing these nouns just for the sake of brevity and familiarity, and then having to contort the names of instances to avoid overwriting the verb.

NEW is shorter and not contentious with the historical meaning of MAKE:

combinator: new combinator [...] [...]

It just seems like we're fighting against the English language to be using nouns wrong, just because other languages have done it. :frowning:

I'm hitting this yet again with the verbing of module.

>> module [Title: "This is annoying"] [i: <can't>, print "Stand it!"]
Stand it!
== make module! [
   i: <can't>

...said Yoda...


We don't make modules nearly as often as we make functions, so make module seems like not a burden to type.

And in fact, I can kind of type make module about as fast as I can type module!, because typing the exclamation point is awkward. Typewriters did not optimize for it.

Note that if you use a shorthand here, you're overwriting the infix modulus operator.

mod: make module! [...] [...]  ; whoops, there went `1 = 10 mod 3 `

So is it really so bad to put this on the table?

module: make module [...] [...]

There are some details to think about here. Maybe it does have to be another operator like NEW so that the low-level MAKE MODULE! is still available for implementing higher level operations like MAKE MODULE.

Just wanted to bump this to say I really feel this "nouning" is a sticking point that needs to be forcibly confronted.

For me (and that's just personal) make sth doesn't flow. New would be OK.