__Falcon-Games__ wrote:

(a, b){a + b}(10, 10)

NFlex23 wrote:

__Falcon-Games__ wrote:

(a, b){a + b}(10, 10)

That's going to be pretty hard to parse without lookahead.

Assuming that you use parenthesis for grouping expressions, that is.

Standard.Function({ a+b }, args=["a", "b"])(10, 10)

__Falcon-Games__ wrote:

You can also do this but idk why you would want to.

Standard.Function({ a+b }, args=["a", "b"])(10, 10)

ajskateboarder wrote:

__Falcon-Games__ wrote:

You can also do this but idk why you would want to.

Standard.Function({ a+b }, args=["a", "b"])(10, 10)

Wouldn't this raise an error in your lang since the variable doesn't exist in scope?

__Falcon-Games__ wrote:

ajskateboarder wrote:

__Falcon-Games__ wrote:

You can also do this but idk why you would want to.

Standard.Function({ a+b }, args=["a", "b"])(10, 10)

Wouldn't this raise an error in your lang since the variable doesn't exist in scope?

Could you explain what you mean?

Standard.Function({ a+b }, args=[“a”, “b”])(10, 10)

ajskateboarder wrote:

__Falcon-Games__ wrote:

ajskateboarder wrote:

__Falcon-Games__ wrote:

You can also do this but idk why you would want to.

Standard.Function({ a+b }, args=["a", "b"])(10, 10)

Wouldn't this raise an error in your lang since the variable doesn't exist in scope?

Could you explain what you mean?

Standard.Function({ a+b }, args=[“a”, “b”])(10, 10)

The part in red contains the variables for the block, but they are referenced as strings. The part in blue is a literal code block, so the code would probably be evaluated at actual runtime, not at function runtime. Since the variables haven't been declared in the code block, it would raise a variable lookup error, unless you make it so the variables exist in the block scope

rdococ wrote:

Here is a dynamic, purely object-oriented scripting language I've been working on in the past few days.

The main concept behind it is that objects are scopes. You can wrap any code in `(| object scope |)` and any variables and functions defined within become properties and methods of the resulting object.

snip

rdococ wrote:

Here is a dynamic, purely object-oriented scripting language I've been working on in the past few days.
snip

PlNG_ wrote:

rdococ wrote:

Here is a dynamic, purely object-oriented scripting language I've been working on in the past few days.
snip

1. Is it treewalked, bytecode-compiled or native-compiled?
2. Will it have foreign function interface?

ajskateboarder wrote:

rdococ wrote:

Here is a dynamic, purely object-oriented scripting language I've been working on in the past few days.

The main concept behind it is that objects are scopes. You can wrap any code in `(| object scope |)` and any variables and functions defined within become properties and methods of the resulting object.

snip

Looks very satisfying, but would this language let you run any code at class instance creation time? Otherwise, this is just like any other OOP language, in my opinion

Person(name, age) -> (|
    name := name;
    age := age;
    
    greet(stranger) -> (
        print("Hello there, " ++ stranger name ++ ", I'm " ++ name ++ "!");
    );
    birthday -> (
        age <- age + 1;
        print("It's my birthday today!");
    );
|);

alice := Person("Alice", 23);
bob := Person("Bob", 21);

bob greet(alice);

NFlex23 wrote:

It looks like you can customize the “class function” (the constructor) with the code you need at creation time. In fact, if you look at this example, that is what is already happening (specifically the parameters in the Person function):

Person(name, age) -> (|
    name := name;
    age := age;
    
    greet(stranger) -> (
        print("Hello there, " ++ stranger name ++ ", I'm " ++ name ++ "!");
    );
    birthday -> (
        age <- age + 1;
        print("It's my birthday today!");
    );
|);

alice := Person("Alice", 23);
bob := Person("Bob", 21);

bob greet(alice);

ajskateboarder wrote:

This means it has to create all of these functions at class instantiation, right? That wouldn't be particularly efficient

NFlex23 wrote:

ajskateboarder wrote:

This means it has to create all of these functions at class instantiation, right? That wouldn't be particularly efficient

Isn't that how instance methods always work? Or am I missing something?

NFlex23 wrote:

ajskateboarder wrote:

Looks very satisfying, but would this language let you run any code at class instance creation time? Otherwise, this is just like any other OOP language, in my opinion

It looks like you can customize the “class function” (the constructor) with the code you need at creation time. In fact, if you look at this example, that is what is already happening (specifically the parameters in the Person function)

ajskateboarder wrote:

I mean, if it doesn't usually work like that, I guess this would be a cool innovation. Whatever language the interpreter is written in could look at class functions, transpile (?) it into the native interpreter language, store it in a dict/table/etc. and run that code when class instances are made and instance functions are initialized

__Falcon-Games__ wrote:

One of my scrapped programming language ideas was Stem. Take a look yourself.

snip

# printing
say "Hello world"
say 42

# def variable
make a variable named "best string number" with value of: "12"

# get variable
say (get value of "best string number")

# set variable
set variable "best string number" to: "12"

# def function
make a function named "my function" that does:
    say "42 auuugh"
    give "done"

# call function
call "my function"

say (call "my function") # done

# debugging
debug
breakpoint

# assertions
make sure ((call "my function") is "done")
make sure (1 is 1)
make sure (1 > 12)

# numbers (includes 32-bit, 64-bit, floating point numbers, and complex numbers)
make a variable named "best real number" with value of: 12
make a variable named "also real number" with [number] value of: 1+2i
make a variable named "best real float" with [number] value of: 0.1

# math operations (must be in parenthesis)
make a variable named "some number" with value of: (2(1*12+1))

# boolean evaluations (must also be in parenthesis)
make a variable named "some bool" with value of: (2 > 1)

# square roots just use sqrt(). It's treated as an expression rather than a function

# multi-line string variable
make a variable named "best string" with value of: "Hello
    world"

# def list
make a list named "my list" with values:
- "12"
- 123
- 12+8i
- (2(12+1))

# reassign list
set list "my list" with values:
- "12"
- (2(12+1))

# add and remove list items
add to list "my list" the values:
- "asdfghjkl"
- "zxcvbnm"
- "qwertyuiop"

# access list stuffs
say (get "1st" value of "my list")
say (get value of "my list") # prints string representation of list

ajskateboarder wrote:

__Falcon-Games__ wrote:

One of my scrapped programming language ideas was Stem. Take a look yourself.

snip

Looks obviously confusing – callback hell as a language

• Keywords (so this, `hello world`, and ~!@#$%^&*) are atoms (primitive types like numbers and strings). You can store it on fields or pass it as a value on a function. In fact, this is essentially how you do operations to other atoms, since:
  
• Every atom act as functions. Though it's mostly for selecting which operation to perform, it nevertheless accepts some input.
  For example:
  

  1 + 1

  is interpreted as:
  

  1(+)(1)

  which returns 2 as another number.
  
• Fields (which is created by a scope) is also an atom. You can even assign a field into a field if you really want to:
  

  print {
      a := 1;
      print (a !); # This prints 1 `(without the ! it will print "(a := 1)")`
      inner_scope := {
          b := 2
      };
      c := (inner_scope b);
      c ! := 3;
  }; # This prints "{a := 1; inner_scope := {b := 3;}; c := (b := 3);}"

  Note the # function, which is a special function that given any input, returns # itself. This is useful for commenting code, although it's kinda useless since it defeats the norm that “the interpreter can't read comments”.
  
• Each line is executed as currentScope(atom1)(atom2)(atom3)…(atomN).
  For example:
  

  1 + 1;

  is interpreted as:
  

  currentScope(1)(+)(1)

  As a scope (which, by the way, is also an atom, even though it could be subdivided unlike an atom), it returns back anything that is not a keyword. So, this code just returns the number 2.
  Parenthesis are used to access the current scope in the middle of an argument. For example:
  

  print (a + 1);

  is interpreted as:
  

  currentScope(print)(currentScope(a)(+)(1))

  When a scope got a keyword as an input, it returns a field of that name, creating one if it doesn't exist. In this case, the keyword print is a built-in function, while a is the current scope's own field.
  Except special keywords like := for assignment, ! for fetching, and ? for identification, fields will return the value stored on itself, called by the given input.
  

• A way to make inner scopes be able to access fields of parent scopes
  
• More builtin functions
  
• Custom functions (need to implement the interpreter first)
  
• Control structures (the interpreter needs to be done first)
  
• Lazy evaluation? (this may require the interpreter to be revamped)
  
• Bits
  
• Iterators?
  
• Import system (though this may not be implemented)
  
• many more…