`bleed` Keyword

The bleed keyword is a new concept of NAL which has the following semantic:

A symbol declared/defined with bleed automatically becomes visible in the scope directly outside of the one it is defined in.

This has two main applications: Control structure scope and function scope.

Discussion

A symbol is only bleeded one scope outside, not multiple ones. In order to bleed a symbol further outside, it has to be marked with bleed again upon declaration/definition.
Bleeding a symbol solves one of the ownership problems. When a scope would like to change the content of a variable using a method for example, in C and C+, it provides a "reference" to the object to the method which then changes it. But this disrupts ownership. When a variable though is created inside the method which is then bleeded outwards, the outer scope can simply replace the owned variable with the (bleeded) returned one.

Control Structure Scope

In the following simple example, the index used inside of the for loop becomes visible outside of the loop.


    NAL:
    for (bleed i in myArray) {
      if (myArray[i] == nullptr) break;
    }
    printf("The resulting index is %i", i);


    C:
    size_t _i;
    for (; _i < _nalArraySize(myArray); ++_i) {
      if (myArray[_i] == nullptr) break;
    }
    printf("The resulting index is %d", (int)_i);

Discussion

The symbol name is not available BEFORE the scope declaration.
The lifespan of the symbol is extended till the end of the outer scope.
The symbol name must be unique in the outside scope.
As the symbol name must be unique in the outside scope, prepending a simple underscore _ in C is sufficient.
By default, no matter whether the symbol is const or mutable inside the inner scope, it will be const in the outer scope by default. If desired, an additional mutable keyword makes it mutable in the outer scope: for (mutable bleed i in myArray) { ...
In C++, there are the std library function like find_if. The same example as above would be written like this in C++: auto it = std::find_if(myArray.begin(), myArray.end(), [=](const auto& elem){return elem == nullptr;}); size_t index = it - myArray.begin();
bleed bleed bleed is not possible. Needs to be re-bleeded in the outer scope.
lifetime of bleed. See as an example: https://doc.rust-lang.org/rust-by-example/scope/lifetime.html

Function Scope

In the following simple example, the variable used inside of the function becomes accessible to the calling scope as optional return value.


    NAL:
    getSum(myArray array) f32 {
      bleed size = myArray.size();
      sum = f32(0.);
      for (i in myArray) { sum += myArray[i]; }
      return sum;
    }
    
    {
      theSum, size: theSize = getSum(myArray);
      printf("Average: %f", theSum / mySize);
    }


    C:
    float getSum(_NALArray myArray, i32* _size) {
      _nal_bleeding_size = _nalGetArraySize(myArray);
      float sum = 0.;
      for (size_t i = 0; i < _nal_bleeding_size; ++i) { sum += myArray[i]; }
      _size = _nal_bleeding_size;
      return sum;
    }

    {
      i32* _nal_bleeded_size;
      float theSum = getSum(myArray, _nal_bleeded_size);
      const i32* theSize = _nal_bleeded_size;
      printf("Average: %f", theSum / theSize.toF32());
    }

Other posibility:


    NAL:
    getSum(myArray array) f32{
      bleed size = myArray.size();
      sum = f32(0.);
      for (i in myArray) { sum += myArray[i]; }
      return sum; // will be bleeded as sum:
    }
    
    {
      sum: theSum, size: theSize = getSum(myArray);
      printf("Average: %f", theSum / mySize);
    }


    C:
    float getSum(_NALArray myArray, i32* _size) {
      _nal_bleeding_size = _nalGetArraySize(myArray);
      float sum = 0.;
      for (size_t i = 0; i < _nal_bleeding_size; ++i) { sum += myArray[i]; }
      _size = _nal_bleeding_size;
      return sum;
    }

    {
      i32* _nal_bleeded_size;
      float theSum = getSum(myArray, _nal_bleeded_size);
      const i32* theSize = _nal_bleeded_size;
      printf("Average: %f", theSum / theSize.toF32());
    }

If someone is not interested in the optional size return value, one simply writes the following. The variable _nal_devnull is a variable where anything can be written to but it will be completely ignored.


    NAL:
    {
      theSum = getSum(myArray);
    }


    C:
    {
      float theSum = getSum(myArray, _nal_devnull);
    }

bleed Keyword

Discussion

Control Structure Scope

Discussion

Function Scope

`bleed` Keyword