One quibble I have with the piece is the quotes.

        There is a bark of an Englifh tree, which I have found by experience to be a powerful aftringent, and very efficacious in curing aguifh [agues] and intermitting diforders.


        My curiofity prompted me to look into the difpenfatories and books of botany, and examine what they faid concerning it; but there it exifted only by name. I could not find, that it hath, or ever had, any place in pharmacy, or any fuch qualities, as I fufpected afcribed to it by the botanifts.

If (as it appears) the author was unable to type in a long-S, he could at least have used a normal one, making the text more readable.

i.e. Englifh => English; aftringent => astringent; aguifh => aguish; diforders => disorders; curiofity => curiosity; difpenfatories => dispensatories; faid => said; exifted => existed; fuch => such; fufpected afcribed => suspected ascribed; botanifts => botanists

Partially "slamming" where agents would try to get folks to switch to a different billing provider, and get paid a commission. So some fraudulently "sign up" random addresses they were supposed to visit.

The other case has been miscommunication over phone or email to someone actually requesting to change billing provider. Or error on the part of the potential customer.

I've had a bill from some random billing provider. In my case it is common for folks newly arriving in the block of flats to get the digits of the address transposed. Due to them using the common English convention, whereas the part of Scotland I'm in uses a different convention.

The other example of nested functions which you've not mentioned was in Metaware High C.

There they allowed nested functions, but also what they termed "full function values", being a form of fat pointer. Certainly I came across it in High-C v1.7 in 1990, and the full manual for an earlier version (1.2?) from around '85 can be found on Bitsavers.

It had a syntax like:

    extern void Quick_sort(
      int Lo, int Hi, int Compare(int a, int b)!,
      void Swap(int a,int b)!
    );

    static Sort_private_table() {
      Entry Entries[100];
      int Compare(int a,int b) {
        return Entries[a] < Entries[b];
      }
      void Swap(int a,int b) {
        Entry Temp = Entries[a];
        Entries[a] = Entries[b];
        Entries[b] = Temp;
      }
      ...
      Quick_sort(1,100,Compare,Swap);
    }

The above is an extract from their language reference, which you can find here:

https://archive.org/download/Yoshizuki_UnRenamed_Files__D-V/...

Note - as far as I can see, it has similar behaviour to what you propose with _Wide for a wide pointer. Just that it is existing practice, from 40 years ago.

I believe the High-C compiler with this support is still available, for modern embedded CPUs.

Yes, I know about High-C although I did not know that it still exists. Thanks!

I ran across it recently. From a quick search now, possibly this lot:

https://www.synopsys.com/dw/ipdir.php?ds=arc-metaware-mx

Meaning something that generates code similar to what I have in this comment?

https://news.ycombinator.com/item?id=46243298

Yeah something like that, though built-in to the compiler.

It is possible to transform the pure Rosetta form of GNU nested function similar to the pure C, such that it doesn't need any stack trampoline. I wonder if that would be closer in performance to the pure C form.

(I can't be bothered to run his benchmarks)

    #include <stdio.h>
    typedef struct env_ E;
    typedef struct fat_ptr_ Fp;
    typedef int fn(E*);
    struct fat_ptr_ {
      fn *f;
      E  *e;
    };
    #define INT(body) ({ int lambda(E*){ return body; }; (Fp){lambda,0}; })
    struct env_ {
      int k;
      Fp xl; Fp x2; Fp x3; Fp x4;
    };
    #define FpMk(fn,e) {fn, e}
    #define FpCall(fn) (fn.f(fn.e))
    int main(){
      int a(E env, Fp x5){
        int b(E *ep){
          return a( (E){--(ep->k), FpMk(b, ep), ep->xl, ep->x2, ep->x3}, ep->x4 );
        }
        return env.k<=0 ? FpCall(env.x4) + FpCall(x5) : b(&env);
      }
      printf(" %d\n", a( (E){10, INT(1), INT(-1), INT(-1), INT(1)}, INT(0)) );
    }

Even for 'normal' rebases of a multi-commit series (without named feature branches), I habitually use the --onto form. It is simply easier to conceptualise what is happening if one is explicit about the 3 references.

As such, using it for the situation described in the piece then becomes a trivial matter, especially if one also habitually runs a graph viewer - I generally have one or more instances of gitk running all the time.

yet if one does that, and has suitable warnings turned on, GCC will complain:

    array2.c: In function ‘main’:
    array2.c:25:17: warning: passing argument 1 of ‘arr_fn2’ from incompatible pointer type [-Wincompatible-pointer-types]
       25 |         arr_fn2(array);
          |                 ^~~~~
          |                 |
          |                 char *
    array2.c:13:22: note: expected ‘char (*)[15]’ but argument is of type ‘char *’
       13 | void arr_fn2(Arr_15 *arr) {
          |              ~~~~~~~~^~~

The above was -Wall -Wextra

Or are you just referring to the function where one defines it as apparently 'pass by value'?

depending upon how one has structured the code, a less painful way to write the same is:

    typedef char array[5];

    void do_something(array *a) {
        enum { a_Size = sizeof *a };
        memset(*a, 'x', a_Size);
    }

it rather depends upon how painful it will be to create a bunch of typedefs.

Beyond a certain point, if there are too many arrays of the same size with different purposes, my inclination is to wrap the array in a struct, and pass that around (either by pointer or value depending upon circumstances.)

The existence of the decaying form is if I recall correctly a backward compatibility thing from either B or NB; simply because in one or the other pointers were written in the (current) array syntax form.

It stems from B, because it didn't have either pointers or arrays on the type level. Declaring an array allocated the storage, but the variable itself was still a word-typed pointer to said array. In fact, you could even reassign it!

   foo(a) {
      return(&a[1]);
   }
   bar() { 
      auto a[10];
      a = foo(a);
   }

The decaying system made it mostly work with minimal changes in C.

They're not gone yet. They have to pass legislation to achieve the scrapping.

So we still have the ability to make our views known. Write to MPs in the first instance. Basically, they need to be informed that this is a bright red line.

However, I suspect it'll take a mass demo in London to really drive the point home.

Only 110k at the UTK rally? I'd hope a demo in opposition to this proposal would completely choke up London.

Well even at the GE, his party was less popular than the previous offer by Corbyn. Labour only really got in because of the collapse of the Tory vote.

2019 GE Votes

    Labour: 10,269,051   22% R  32% T
    Tory:   13,966,454   29% R  44% T
    LibDem:  3,696,419    8% R  12% T

2024 GE Votes

    Labour:  9,708,716   20% R  34% T
    Tory:    6,828,925   14% R  24% T
    LibDem:  3,519,143    7% R  12% T

Also % Registered, % Turnout

So that he got even more unpopular seemed a given, unless he managed to be competent and actually improve things for the people who elected his party.