[Zero]

I think 2+3 has more "energy" than 5, so to speak. Like a ball that's up in the air.

I'm slowly updating the second post of this thread.

Now, var( ) cannot be used wherever a variable can be used anymore (it was too noisy).

An anonymous function is characterized by its return type: in a variable, you can replace an anonymous function by another one, only if they have the same return type. That's what matters, because it's what dictates where you use the function.

I corrected a few typos (the pitbull def was wrong), and added a few types.

I think I'm giving up on type arithmetic. Types are values, yes, but that's it. Same goes for pointers: there will be references, but no arithmetic.

Ed: if I understand correctly, it seems I already put sum types (my "poly" type) and product type (my "pipe type") without knowing what I was doing. Cool!

[ranch vermin]

im just spinning out,  sorry for being irrelevant.

But cant you see when you write your language,  its just another form of what the output is.

you read the code,  and you can also read the output and its the same thing.

so the language.  is the sensor (sorta),    and the output is the motor.    but they are the same.


you say to a french man,  "cant you see that methods are hard to make but easier to copy?"
and he says "no."

[Zero]

You were not being irrelevant, your inputs fit well in this thread.


I'd like source code to be like Calligraphy - a dance of two, empty and full.

[Zero]

[inbox]
    identifiers
        new identifiers should be turned into new numbers?
        keep a map identifier => number?
        known identifiers turned into numbers using map?
    memory access
        a map of maps
        first map from type to second map
        second map from idnum to value

[todo]
    [X] choose architecture
            clone based
    [X] list all possible actions
    [ ] list all possible types
        [ ] find suitable representation

[possible actions]
    declare type
    declare clone
        declare variable
        declare clone reception loop
        assign value to variable
        call a function / call a control
            push new environment
            set return value
            pop environment
            insert return value

[possible types]
    void
    bool
    enum()
    int
    flt
    str
    stk
    list
    arr()
    asso
    pair
    poly
    pipe
    unit
    pct

[Zero]

So, I was looking for a top-level organization mode, and I decided to go clone 

The idea is to have small units that share source code, and which are duplicated 20, 200, 2000 times. They can literally "spread" source code in their group to communicate.

A clone group cannot send directly to another clone group. It's the other way around: groups watch other groups, to receive what they emit. So, you can always add new structures/functionalities to your program without breaking something that already works well.

A program contains only type definitions and clone definitions. Scope of types and clones is program-wide.

See second post update.

There's also the new "source code type". CTRL+F "$int" and see for yourself.

[Zero]

Perhaps the cluster thing is too much. I thought it was good for a certain kind of tasks, but it's maybe too narrowing. Staying simple, with a clean foundation, going towards nodejs -like capabilities would potentially be more rewarding. Leaving libuv behind, since Golang does things differently, the language would allow creation of simple programs with in-browser front-end.