But the majority of our discussion centered around the use of ?fewer? and ?less.? The rule Bunny was taught was to use ?fewer? for a countable number of items and ?less? for uncountable or fungible items. For example, we have fewer cookies around here because we had less flour to make them (I originally ended this sentence with ?to work with? but I wanted to avoid ending with a preposition). I always say ?less? but I suspect this has less to do with my descriptivism and more to do with programming, where x < 3 is translated to ?x is less than three.? It just seems weird to say ?x is fewer than three,? despite most numbers on a computer system being countable, if potentially large (the only exceptions would be ±inifinty and NaN).

I also wondered about the opposites of ?fewer? and ?less.? When I asked Bunny for the opposite for ?fewer? she said ?more,? and when asked for the opposite of ?less? she also said ?more.? To her, the word ?more? could be applied to either countable items, like ?I need more cookies,? and for fungible items, like ?I need more flour.? But that struck me as odd?why separate words for ?a smaller number or amount of? and not for ?a greater number or amount of?? Why does ?more? get a pass for both concepts, and not something like ?many? for countable items, and ?more? for fungible items? Why the rule for ?less? and ?fewer?? I need many cookies, and I need more flour to make them.

After our discussion, I thought about this for a bit. While Robert Baker made this distinction in 1770 (per the video), I have to wonder why he felt the distinction needed to be made, applying ?fewer? to numbers rather than ?less.?

At first, I thought it may have something to do with the Norman conquest of England. As my 1924 copy of Roget's Treasury Of Words says: ?[i]t is interesting to note that the French names for different kinds of food became restricted to the cooked meats; while the English names were reserved for the living animals.? It also noted the act of word doubling?using both the Norman-French and Saxxon terms, such as humble and lowly, poor and needy, act and deed, aid and abet, use and wont, will and testament, and assault and battery.

Could this be a reason for the distinction between ?fewer? and ?less??

It's not due to the Norman invasion that's for sure.

While looking through my copy of the Oxford English Dictionary, I found the word ?less? is an Old English word from Northumbria, having been a word in both Old Frisian and Old Teutonic. The usage meaning ?smaller quantity? didn't first appear until 1314. And as Oxford states, the opposite is ?more.?

The word ?few? is also an Old English word, also in Old Frisian and Old Teutonic but importantly, not from Northumbria! It's meaning of ?smaller quantity? or ?a small number? is documented from around 900, and it's ?antithesis? (as Oxford calls it) is ?many!?

How about that?

But I'm now of the opinion that Robert Baker wanted to signal he wasn't part of the hoi polloi and came up with a pointless distinction. Bunny remains unconvinced of my theory.

: FOO	... FOO .. ;

doesn't work. It will either error out as FOO isn't found, or it will call the previous definition of FOO if it exists. This is a quirk of Forth, and it one reason why globals aren't as much of an issue as they are in other languages?if you define the word REPEAT it won't break existing code that called REPEAT, they will just keep using the old version of REPEAT while new words will use the new version. In fact, the ANS Forth standard says as much: ?The current definition shall not be findable in the dictionary until [colon] is ended.? Thus the reason for the word RECURSE, an immedate word (which is run durring compilation, not compiled) to exist in Forth?to do recursion.

This was an easy word to implement:

forth_core_recurse		; ( -- )
		fdb	forth_core_r_fetch
		fdb	_IMMED | _NOINTERP :: .xt - .name
.name		fcc	"RECURSE"
.xt		fdb	.body
.body		ldx	forth__here		; get current comp location
		ldd	forth__create_xt	; get xt of current word
		std	,x++			; recurse
		stx	forth__here
		ldx	,y++			; NEXT
		jmp	[,x]

So the above would be written as:

: FOO ... RECURSE ... ;

And the resulting code would look like:

foo		fdb	...
		fdb	.xt - .name
.name		fcc	"FOO"
.xt		fdb	forth_core_colon.runtime
.body		fdb	dot_dot_dot.xt
		fdb	foo.xt		; FOO's xt
		fdb	dot_dot_dot.xt
		fdb	forth_core_exit.xt

The only reason I'm mentioning this word is because of this bit from the Standard: ?An ambiguous condition exists if RECURSE appears in a definition after DOES>.? There's a reason for that?depending upon the implementation, it may be impossible to do recursion after DOES>. Why?

In my Forth implementation, the code following DOES> doesn't have an xt to reference. The xt of any word is the address of the .xt field. So using the example from my explaination of DOES>, the xt of MAN would be of its .xt field:

man		fdb	shape	; link to next word
		fdb	.xt - .name
.name		fcc	'man'
.xt		fdb	shape.does ; the XT of this word is this address
.body		fcb	$24
		fcb	$24
		fcb	$24
		fcb	$99
		fcb	$5A
		fcb	$3C
		fcb	$18
		fcb	$18

But the problem is?that address doesn't exist until the word is defined! If, for example, the definition of SHAPE used RECURSE:

: SHAPE CREATE 8 0 DO C, LOOP
  DOES> ... RECURSE ... ;

when RECURSE is executed, there is no xt for it to use. We can't use the xt for SHAPE?that's not the word we want to recurse on. And we can't use the address of shape.does because that's not an actual xt. And the code following DOES> can be shared by multiple words:

... SHAPE MAN
... SHAPE FACE-HUGGER
... SHAPE ALIEN
... SHAPE FLAME-THROWER

so there's no single xt that RECURSE could use when compiling the code after DOES> (never mind the fact that that happens before the words that use the code are created).

So, in my Forth implementation, no RECURSE after DOES>. Which is fine, because it's an ambiguous condition.

Could I make it work? Maybe. But it would be a lot of work for a feature that Forth programmers can't rely upon anyway.