v0.3.0

[Champii]

---

This discussion was created from the release v0.3.0.

[oraqlle]

Nice work Champii, everything from the README works and I like what you've done with the traits using the .trait-name! style. Looks really good. Keep up the good work.

[Champii]

Thank you ! Having someone around testing things has fueled me with some intense motivation. I've more syntax change for the function declarations that I'm trying right now.
It would look something like

trait T a
  t: a -> a

impl T Int64
  @t: -> @

id: a -> a.t!

main: -> id 1

I would love to have your opinion on this :)

[oraqlle]

Yeah, glad to help. Its super interesting project and I'm glad to see it progress.
In terms of the arrow for functions, I think it best used like in Haskell or in function notation from mathematics. But if you want to keep it, you might just want to separate types and variables. So something like this:

trait T A
    t :: A ->> A

impl T Int64
  @t: -> @

id: a -> a.t!

main: -> id 1

I would also keep the equal sign for main as I feel this is a bit clearer but if you want constancy between all other functions then that also makes sense.

Eg.

main := id 1

I'm also assuming that the @ is similar to the this and self keywords from other languages.
If you're trying to figure out how you want the syntax to look and flow, right some arbitrary "phrases" (some code) that you might write in rock and see how they look.

Also because this language I'm assuming is very Haskell inspired based on the function notation and the use of symbols, I would highly recommend documenting it down somewhere so at least you can compose it all together at a later point. And also document the compiler so you and others can at least figure out what you are attempting to do within the compiler so if you change it later, you know what your were trying to do.

[Champii]

I am still undecided about this syntax.
I'm in love with Livescript (I recommend you to check :) ) that itself inherit from Coffeescript. Both have an arrow syntax for function definition that also allow for closure definition. I'm a little bit ahead of time here because Rock doesn't have them yet, but this is a consideration to have in the future.
With a =, we have a more cleaner syntax that is consistent with the assignation syntax, but I am afraid of what it would look like when applied to closure definition:

id a = a
main =
  let closure = a, b = a + b

It might indeed be cleaner to keep the = and to add the arrow notation to keep some consistency between function and closure definition

id = a -> a
main = ->
  let closure = a, b -> a + b

This is definitely more like Livescript and I like it :)

But I was also thinking about replacing the = with : to be consistent with struct and trait declaration/implementation and keep = only for variable assignation, as you saw in my previous snippet

The fact that -> collides with the trait's prototype definition is a little bit annoying, but it can be ignored if we keep the :: notation for the prototype

trait T a
    t :: a -> a

impl T Int64
  @t: -> @

id: a -> a.t!

main: -> 
  let closure = a, b -> a + id b

I like that in that case all function definitions can be parsed the same way at toplevel, in the impl, and as a closure.

About the public documentation, I was considering writing one, but I'm somewhat reticent because everything is still moving fast and change often, and the burden of updating a well crafted documentation with each little syntax change is annoying. I might start something soon, when the syntax is a little more fixed :)

As of today, the readme contains the most useful constructs, and I keep the embryo of stdlib up to date with the latest syntax available. I think this can be enough for now, as there is no real exposure to the public right now. (and the bearded developers coming across this repo would probably get along with it ^^)

I should nevertheless write an in-code doc for the compiler, at least, you are totally right ! Let's add it to the monstrous pile of work left to do :p

[oraqlle]

Certainly, this is your language after all and its not like the syntax doesn't make sense and I see what you mean with LiveScript and CoffeeScript. As for documentation of the language that comes with time, don't wanna put any stress on you that is unnecessary. The : -> notation is much cleaner then then the = -> notation. I would keep the :: for prototypes as this might make it clearer your dealing with types (as you said). My one major critique that you might wanna consider is not having the closure keyword (if it is a keyword) and adopt a capture clause like C++'s [ ] or Rust's | |, if indeed the closure is a keyword but you still want some marker denoting a closure to coders and the parser. But if the = also denotes the closure and you've just named the lambda 'closure' that also makes sense, realised after the thought.

[Champii]

Your opinion on the subject really matter to me, I like to challenge my ideas before implementing them :)

You make a great point concerning the closure keyword. In the snippet I wrote it is just a variable named closure but I just realized that the parser would never succeed to disambiguate the closure notation I've wrote. I think I will have to introduce a special notation like in haskell \x -> x or in rust |x| x but I really don't like the rust syntax for closures, that I find unreadable and difficult to edit.
This will need further tests and investigations.

main: ->
  let closure = \x, y -> x + y
  let res = closure 1, 1

main: ->
  let closure = |x, y| -> x + y
  let res = closure 1, 1

main: ->
  let closure = (x, y) -> x + y
  let res = closure 1, 1

main: ->
  let closure = (x, y -> x + y)
  let res = closure 1, 1

I'm close to having the syntax rework done, we could have a better overview of what it would look like, and produce better criticism about it :)