This language has been encouraging me to ruminate on data provenance and traceability tonight.

The point is attaching meta info to values which aren't pointless. Say:

    weight = 42 /* pounds */;

That said, there are better way of typing values without boxing them.

https://docs.microsoft.com/en-us/dotnet/fsharp/language-refe...

    /** Half the number **
     *********************
     ** Multiplies the number by one half (0.5)
     */
    float x2 = x * 0.5F;
    
    /** Copy the number **
     *********************
     ** Stores a copy of the number in a new variable
     */
    float y = x;
    
    /** Pointer cast **
     ******************
     ** Take the address of the number,
     ** cast the pointer to a pointer pointing to long,
     ** and dereference that pointer,
     ** then store the result in a new variable.
     */
    long i  = * ( long * ) &y;
    
    /** Subtract and shift **
     ************************
     ** Shift the number one bit position to the right,
     ** then subtract the result from the constant 0x5f3759df
     */
    i  = 0x5f3759df - ( i >> 1 ); 
    
    /** Pointer cast **
     ******************
     ** Take the address of the number,
     ** cast the pointer to a pointer pointing to float,
     ** and dereference that pointer,
     ** then store the result in an existing variable.
     */
    y  = * ( float * ) &i;
    
    /** Multiply twice, subtract and multiply again **
     *************************************************
     ** Multiplies the number by itself,
     ** then multiplies the result by the other number,
     ** then subtracts that from the constant three halfs (1.5),
     ** then multiplies that by the number.
     ** The original number.
     ** The first number.
     ** You know what I mean.
     */
    y  = y * ( 1.5F - ( x2 * y * y ) );
    
    
    /** Multiply twice, subtract and multiply again **
     *************************************************
     ** Multiplies the number by itself,
     ** then multiplies the result by the other number,
     ** then subtracts that from the constant three halfs (1.5),
     ** then multiplies that by the number.
     ** The original number.
     ** The first number.
     ** You know what I mean.
     ** This can be removed.
     */
    //  y  = y * ( 1.5F - ( x2 * y * y ) );
    
    /** Return from function **
     **************************
     ** Returns the number
     */
    return y;

I would like to see the outcome of people trying to design a language with first-class scope.

Just to scratch my own itch, and it's stringly so I could throw it together in about 3 days.

If that is mildly interesting to you.

[0] https://git.sr.ht/~shakna/scriptlang

Which you can also see here [0], in the interpreter, or here[1] for the "let" example. Everything gets it's own scope, with only "global!" and "set!" being able to escape that. (And all the usual flow control like "if", "cond", "for", etc. are just ordinary function calls.)

[0] https://git.sr.ht/~shakna/scriptlang/tree/master/item/script...

[1] https://git.sr.ht/~shakna/scriptlang/tree/master/item/exampl...

What I see is: The scope is not a first-class object. You can't "touch" it.

I see variable shadowing. And I think something that's called "dynamic scope"—or maybe it's just references, not sure.

I'm not 100% sure even what "first-class" scope would look like. I don't know any language that claims having it. I have a few ideas but would like to see some more to find out whether this idea make any sense at all. It's not in the ballpark of "first-class comments" and could be even useful. Maybe. But to know that we would need to have some language to play with.

Scope in my scripting language is also similar - you can definently touch it. That's how "set!" allows you to create a variable, for example. Assignment isn't special. set! is reaching into the scope above itself to place the variable, otherwise it wouldn't be accessible after the set! call. But it is just a function call. (And there's a couple other things like scopedepth to help you index a given scope).

[0] https://www.lua.org/pil/14.html

Yes, "scope" is in the end the evaluation environment of some funktion. Usually it's not a first-class object in a particular language, and only available implicitly.

Having it first-class would mean being able to directly manipulate and pass function environments.

Like I said, I'm not sure this makes sense at all. But maybe it could open up some possibilities.

(I came up with the general idea when thinking about what the "implicit scope" in Scala is, or could be seen as).

Basically... bang on for a code jam language.

1: https://llvm.org/doxygen/classllvm_1_1Twine.html#details

>>> print(x?) /* the number 4.0 */

Should yield

/* the number 4.0 */ /* a comment */

Right?

It's a terrible name, and even the person who came up with the name admits that it's terrible: "The word dynamic was chosen [...] because it sounded impressive."

[1] https://en.wikipedia.org/wiki/Dynamic_programming

  let x = 40 + 2 /* the number fourtytwo */;

  let x = 40 + 2 anno "the number fourtytwo";

  let x = 40 + 2 @"the number fourtytwo";

EDIT: Oh, another user pointed out the origin for it.