

My newest invention: The Glas Language (A Pythonic offshot) - bhdz

<p><pre><code>    #!/usr/bin/env glas

    print: "Welcome to Glas language"

    Person:
        name: last:"Random" &#38; first: "Joe" &#38; fathers: "Someone"
        # name = {'last':"Random", "first": "Joe", "fathers": "Someone" }
    
    
    print: person's name            # print(person.name)
    print: person's name's last     # print(person.name.last)
    print: last' person's name
    arguments = alpha, beta, gamma
    function application: *arguments

    a, b, c = 1, 2, 3
    calc discriminant: a, b, c      # calc_discriminant(a,b,c)

    # Glas doesn't care much about ','
    calc discriminant: a b c        # Same as before
    call discriminant: top segment, b, c 
                                    # If it sees ',' it combines 
                                    # all that is listed &#38; adds it to current 
                                    # first param and moves on to the 
                                    # next one with "," (switches modes)

    object's perform something:
    quit:' my's company
    kill yourself:' motherfreaker
    kill:' and maim:' opponent
    check dead:' kill: with pistol' and maim: blunt object' opponent
    kill: with pistol' and maim: blunt object' opponent's check dead:

    # And he walked through the valey of 
    #  the shadows of death and he feared no evil
    # he.and_walked(
    #     through: "valey of shadows of death")
    #         .and_feared(not("evil")
    #     )

    and walked: "through the valey"' he's 
        and feared: not: "evil"
        # Ideal for code poetry hackatons! :D
        # Almost sounds like a real preacher, this Glas

    and warneth: "of temptation"' thee's and ignoreth: me
    # ahahahahahaa sorry 'bout that :)

    my: last: "Random" &#38; first: "Joe"
    if len:  my's last' name &#62; 10:
        print: "Your name is too big!"

    Bank Clerk: Person:
        initialize = my, name, job, salary, project:
            # my.name = name ...
            with my:
                name, job, salary, project' do:
                =: *project
                start working: project
                start slacking: "Doom3"
            start working: project' my
            receive payment: salary' my
        
            if my's hours &#62; 40:
                complain: hours' my's boss
            if my's salary &#60; 1500:
                complain: salary' my's boss
                start slacking' my # Oh my!
        </code></pre>
Tell me what you think ;)<p>~
ps: Glas means Voice in Bulgarian (Глас) or even Russian!
======
bhdz
In fact, the symbols that form the syntax, doesn't matter at

all: standard symbol set:

    
    
        ~  # access, forward (standard)
        object ~ property
        -> # access, backward ("homosexual" call if you will)
        method -> object
        ->> # access, backward high ("homosexual" call with higher precedence than ~ and ->... very gay...)
        some ~ linkage ~ method ->> object
        <- # backcall semantics, normal precedence, "tailored" calling
        "eenie", "meeenie", "minie", "moe" <- count toes:
        take: basket: "apples", "oranges", "bananas" <<- fill basket:
        # take(basket().fill_basket("apples",...), ...)
        # BE CAREFUL with that code above
        # basket doesn't get created with the fruits, just empty basket which 
        # is subsequently filled with goodies
    

All these operators can be a different set, but these glyphs are the best in
my opinion

~ # PS: PLEASE do NOT get offended by my characterization

# of certain method calls as "homosexual"

#

# Don't! This is just for laughs at the language

# I am not against gay community in any way

# and "homosexual" calls are actually the most

# useful feature of this language

#

# Thank you.

------
bhdz

        a space adventure = space ship, blasters, rockets, lasers, *, **:  -> Space Ship:
            space ship ~ attach weapons: blasters, rockets, lasers:
                {{ "Eeeekkrrrrgh! Weapons attached successfully!" }}
                {{ "listing:" }}
                for weapon in *: #all arguments of attach weapons
                     {{ "Weapon:", weapon }}
            else:
                {{ "WARNING! WARNING! Ship weaponry attachment FAILED }}
                {{ "You're defenseless!" }}
    
            detach weapons: -> space ship:
                {{ "Weaponry detached, seek cover!" }}
            else:
                {{ "Weaponry detachment FAILED!" }}
                {{ \t, "AUTODESTRUCT SEQ. INITIATED" }}
                {{ \t, "EJECT EJECT EJECT!" }}
                auto destruct: 20s -> space ship

~~~
bhdz
Ah yes!

    
    
        {{ \t, "eject eject eject!" }}
        auto destruct: 20s -> space ship
        {> user ejected % wait: 20s, any -> input <}
    
        {{ "Your ship explodes in a gigantic fireball!" }}
    
        if: empty: -> input ->> user ejected
            {{ "You fail to eject, Ouch!" }}
            space ship ~ pilot ~ die: "massive splosion"
        space ship ~ destruct: "massive splosion"

------
bhdz
New ROCKING syntax!

    
    
        #!/usr/bin/env glas
        #
        # Yay, and hear these spoken words of wisdom, Stranger:
        #
            and: he ~ walked: through the valley ~ 
                    valley + shadows & 
                    valley + shadows + death --> 
                        and: he ~ feared: not: evil
        #
        # versus the barbaric cries of the past!
        #
        #! old pythonic
        #
            and( 
                he.walked( through_the_valley.combine(
                    [valley, shadows], [valley, shadows, death] )
            ).and( he.feared(not(evil)) )

~~~
bhdz
Now you can use the familiar

    
    
        do something: a dict ['some key'], coordinates['x']

------
bhdz
Glas doesn't care about keywords actually, the only "keywords" are the
syntactic elements like ~ -> ->> { [ {{ {> <}

so you write:

    
    
        if: something ~ happened: and: something else ~ happened:
            logic ~ did: something ~ happened # ?
    

and

    
    
        for: x in: range: 12, 32
            {{ x }}
    

this chains the needed things nicely in fact you can write like this:

    
    
        in: range: 5, 13
            perform: a task
    
        for: x in: iter: person
            {{ x }}

------
bhdz
If you find '.' and ''' and ''s' offending, you can change the symbol to the
old dot and "@" for instance.

and that's much better than that.much better, don't you think?

    
    
        cookie adventure: my @ Cookie Monster = 
            print "Cookie Monster, why is the Cookie jar empty?"
            why: my.cookie.jar.empty: @ cookie monster 
    
            # why cookie monster, why? :)
            why: my.cookie.jar.empty: @ cookie monster .why: "tell me!"

------
bhdz
For more:

    
    
        git clone https://github.com/bhdz/glaslang.git

------
lifeisstillgood
Afaik my's last' name is equivalent to

my.name['last']

How does the ' operator decide between need for 's and not?

Where is the GitHub page? :-) What did you learn :-) Who are you ?

Nice one

~~~
bhdz
Just like Python, Glas (Глас) doesn't really distinguish between dicts,
objects or methods/functions. For it functions are just a fancier version of
objects which are a fancier version of normal dicts. Later on, during
evaluation, Glas makes a distinction, not before though.

I am planning on adding additional features like adding statements after each
method call with the ':' operator, like this:

    
    
        # ship.attach_weapons(...):
    
        ship's attach weapons: blasters, rockets, lasers:
            print "Eeeekkrrrrgh! Weapons attached successfully!"
            print "listing:"
            for weapon in *: #all arguments of attach weapons
                 print "Weapon:", weapon
        else:
            print "WARNING! WARNING! Ship weaponry attachment FAILED"
            print "You're defenseless!"
    
        detach weapons:' ship:
            print "Weaponry detached, seek cover!"
        else:
            print "Weaponry detachment FAILED!"
            print "  AUTODESTRUCT SEQ. INITIATED"
            print "  EJECT EJECT EJECT!"
            auto destruct: 20s' ship

