RAKU is a scripting language that resembles Engish somewhat. 
However it is a stealth lisp with smalltalk like semantics.

In Lisp you would say (function1 arg1 (function2 arg2))
In C you would write function1(arg1, function2(arg2));
In Raku you will write function1 arg1 be function2 arg2 so


attack the greater green gorgon with the large axe

# Core problem: in most languages, arguments of a function are not only 
# delimited, but also the start and end of the function call
# are indicated somehow, so that calling several functions in one statement
# is possible. Similarly for message passing.
# C-like:
# foo(a, b, c)
# foo(a, bar(b , c) ,d ,e)
# Lisp-like:
# (foo a b c)
# (foo a (bar b c) d e) 
# What I'd like for Raku is drop the outer ()
# foo a (bar b c) d e
#  Here the newline at the end, or the . make is clear the statement is finished.
# However, calling functions still requires a special delimiter. 
# Unless if the parser knows that foo and bar are functions/methods/verbs.
# Then it can distinguish between foo and bar and a b c d e. 
# But then it still can't see where an inner call ends and the top level 
# one begins: VERB NOUN PREP VERB NOUN PREP NOUN EOL -> 
# is this VERB(NOUN , VERB(NOUN, NOUN)) or VERB(NOUN , VERB(NOUN), NOUN)?
# Without an end-of call delimiter the parser cannot know.
# For the simple case of VERB NOUN PERP NOUN EOL 
# the EOL acts as the "end of call" marker, but it can't be used twice.
#  
# I checked Inform 7 but it's a huge language with many unnecessary 
# complexities. It's simpler to solve the delimiter problem by using short words.
# 
# an as at ax be by do go if of in is it me no of or ox so to up us we
# 
# 
# set foobar to be add 10 to 10 so
# set foobar to tally add 10 to 10 end
# for i from 0 to be size foo so then do
# 
# end
# do / sub / block      ... so / end / done      -> block
# be / run / call       ... so / end / done      -> sub-call, parenthesis 
# list     / array      ... so / end / done      -> array/list value
# act      / define WORD [NAME [PREP  NAME] BLOCK-> method definition on first NAME, which should be a type or instance. If none is given, "me" is used.
# use NAME                                       -> variable declaration takes values of arguments give to block if any.
# nil / nothing / none /                         -> nil value
# true / false / yes / no                        -> boolean value
# return                                         -> method return
# yield                                          -> block return

This is unambiguous in IO or Potion:

OBJECT METHOD1(ARG1_1, ARG1_2, ...) METHOD2(ARG2_1, ...) METHOD3 EOL

# Inversed, apart from the parameters this becomes: 
METHOD3 METHOD2(ARG_2_1, ...) METHOD1(ARG1_1, ARG1_2, ....) OBJECT 
# 
# So io/potion ish 
Bob name append(" and ", Jane name) println 
# Would invert to
println append(" and ", name Jane ) name Bob
# now substitute the non-words with words
println append of " and " with name Jane end name Bob
# or if we use and for method chaining
println and append " and " with name Jane and name Bob

# So io/potion ish
Bob hp decrease(Bob hp times(10) divide(Bob hpmax))  
# Would invert to
decrease(divide(hpmax Bob) times(10) hp Bob) hp Bob
# now substitute the non-words with words
decrease tally divide of hpmax Bob end times tally 10 end hp Bob end hp Bob
# or if we use and for method chaining
decrease tally divide tally hpmax Bob end and times tally 10 end and hp Bob end and hp Bob

# Conclusion, mere complete inversion is undesirable because the sequence 
# becomes unclear, what happens last is set first.
# What is desirable is that like in English the verb comes before the object, 
# but only once, UNLESS it's prettier after. So it's better to start out 
# quasi-procedural 
decrease(hp(Bob),  divide(times(hp(Bob), 10), hpmax(Bob)))  
#
decrease hp of Bob by call divide call multiply hp of Bob by 10 end with hpmax of Bob end
# of course that sucks somewhat. Probably it would be split up.
# but that's the pricve toi pay to keep thing sipmle. 
# Requiring a call/end before most method/function calls resolves the 
# bracketing problem, and allows multi-word names, without a symtab. 

set newhp to hp of Bob
multiply newhp by 10
divide newhp by hpmax of Bob 

# So, raku is a small english like language with an OOP like syntax, 
# but no symtab lookup that happens only at runtime.  
# The next question is then, how much syntax to provide.
# Since, unlike TCL, I can't use pure string substitutons, some built in constructs are needed.
# However, these can be limited to Smalltalk-level constructs. 
# No if/while/etc is really needed, these can be methods in stead.