Is automatic variable declaration better?

[ksenginew]

Currently in Unv, you can assign to variable without worrying about declaration. It's inspired by Python.

x = 3
x = 5

In some other languages like C you should specify the type to declare a variable

int x = 3
x = 5

I hope to add type support to Unv. So this syntax will be supported in the future.
But if you want to access global variables you should use global keyword in Python. Unv has no decision yet.

def myfunc():
  global x
  x = "fantastic"

And if you want to access a variable in parent function, you should use nonlocal keyword in Python. Unv has no decision yet.

def myfunc1():
  x = "John"
  def myfunc2():
    nonlocal x
    x = "hello"
  myfunc2()
  return x

JavaScript handles both cases easily by using var, let or const keywords for variable declaration.

let x;
function myfunc() {
  x = "fantastic"
}

function myfunc1() {
  let x = "John"
  function myfunc2() {
    x = "hello"
  }
  myfunc2()
  return x
}

So I thought to use var keyword in Unv. Please share your ideas with me.
This is a live poll. Tap on your choice in the poll. @UnvLabs/dev and all others are invited.

[Pandademic]

I think the variable syntax would be like this:

class x() :
  private var Int : hello = 8 # only accessible by instances of class x
  global var Int : world = 9 # every thing can use this
  func say_hello() :
     print(hello)
  func xyz(yep: String):
      # example of parameters being variables with types

print(world) # so this makes sense
let b = x() 
print(hello) # error's were in global scope not an instance of x
b.say_hello()  # this does
# parameters again
b.xyz(yep: "yep")

sorry if this is confusing

[Pandademic]

Also to be in the scope of "b" in this example :

#  continuing above code
scope of b :
   print(hello) 
   # We can do this we are acting in the scope of b and are an instance of x so we can access privates of x (inhernt privates of b) 

[ksenginew]

This is my proposal(mostly inspired by your proposal)
This example is simplified. types are not supported yet(coming soon)

class x
    private hello = 8 # only accessible by instances of class x
    global world = 9 # every thing can use this

    function say_hello(self) # `func` is supported in ruby-unv
       print(self.hello)


print(world) # so this makes sense
b = x() 
print(hello) # error's were in global scope not an instance of x
b.say_hello()  # this does

• you can simply declare variables without any keyword

  x = 3

• global keyword makes it global. (but not recommended - view StackOverflow comment)

  global x = 3

• private makes it only accessible by instances of class

  class x
      private hello = 8

• Too many nested functions are not recommended (view StackOverflow comment). But nonlocal keyword can handle it.

  function a ()
      x = 3
      function b ()
          nonlocal x = 5
     b()
     return x # => 5

Thanks for your idea. That made a sense.

[Pandademic]

Should we do these discussions on gitter , it could be easier

[ksenginew]

Ok I'll create a gitter chat.