On: Stabel: A pure, concatenative and statically typed programming language

[Skinney]

def: cube : dup dup * *

def: main : 3 cube

[mikewarot → Skinney]

That looks almost identical, does Stabel offer a way to type check the parameter or anything?

[Skinney → mikewarot]

Yes. Stabel is staticly typed, and types are inferred if the type signature is left out. You could also write the code as:

    def: cube
    type: Int -- Int
    : dup dup * *

[tluyben2 → Skinney]

I never thought about this much but now and it has been so since Forth anyway: why are definitions prefix? Why do they not gobble up the stack? I always found it easier to create everything uniform like [0]. And I did that for many years with asm and c as well because I thought it was faster than porting something (it probably was not but he).

I just like to minimize exceptions to rules and this seems a weird one to me. But probably has reasons I am unaware of (besides subjective readability which is, of course a very good reason).

[0] https://gist.github.com/tluyben/16ee2645c4c8aed813005d51488d...

[retrac → tluyben2]

Yes, in my own toy concatenative language, define is just a regular procedure. It takes two arguments off the stack. The first is a pointer to the name, the second is a pointer to a quotation with the definition body. It intentionally looks Forth-like but it's different under the hood:

    [ dup + ]      \ writes a lambda function to heap and push ptr
      : double ;   \ : writes the next symbol as a string to heap and push ptr
                   \ ; is define, writes definition into dict

The reason Forth did it the classic Forth way originally, I suspect, is because Forth's parser needs to be told to switch modes. Stop executing words directly and start compiling them. There isn't really anywhere to store a temporary string, so you need to tell it to start writing into the dictionary entry before you give it the string. In my language, using [ ] for quotations starts writing to the heap, which is also where strings go. This has the same practical effect.

[Skinney → tluyben2]

I agree in principle about the benefits of everything being uniform. For Stabel, specifically, I need some way of seperating function-definition from function-implementation, and a prefix meta language seemed like the best bet. Didn't look at it too closely, though.

[tluyben2 → Skinney]

Thanks and, nice work with Stabel, we need more experiments in this space.

[a-nikolaev → Skinney]

Does Stable support polymorphic functions? What kinds of data abstractions are possible? (I.e. something like records / structs / classes / Lua-like tables?)

[Skinney → a-nikolaev]

Stabel has generics, but no protocols/interfaces/typeclasses _yet_.

Stabel allows you to define structs and unions, which gives you a lot of flexibility.

[mikewarot → Skinney]

Great, now could you have a second copy of cube that did floating point?

[Skinney → mikewarot]

Stabel doesn’t have floats, yet, but when it does: yes, if you put it in a different module.

[thesz → Skinney]

So Stabel does not support (ad hoc) overloading, right? Will it support it?

[Skinney → thesz]

Right.

Not sure. Ad-hoc polymorphism is currently in the design-phase and I'm looking at many possible solutions. But before I get to that point I still have a lot of stuff to implement first.