To try new ideas:
I would make a dynamic-typed functional programming language, it allows you to do all the statement expression tricks and the simplest lambda syntax with pattern matching. Off-side rule enabled.
// a view pattern (or Active Pattern in F#) default = \def val: !!val.Type val def // usage of the pattern greet = \name<(default "world") `and` hasType Str>: p "Hello, \{name}!" (p "Enter your name", .input).greet // (, ) is a sequence expression, returning the last value Here is an explanation:
default = sets the storage, \def val begins a curried function with two arguments, val.Type is same as Type[val], !! converts to boolean, and boolean can be applied, so val and def are after it.
f x = f[x] = x.f .f = f[]
and in greet, it used name<(default "world") and hasType Str>, it means the pattern default "world" will be used and bound to name. The default pattern specifies a default value. and is another pattern that chains two patterns together. the default pattern can't fail while hasType can fail. In that case, it throws an exception.
Variables are actually storages, which can be functionally passed, and storage tables can be references, created and destroyed as scopes change.
Hashes and such will be like in Lua and JavaScript's.
If I'm going to make a compiled language, I'm going to make an F# for Java, with Haskell-like features. It's a pure functional language, except there is a feature that mixes Quotations and Comp Exprs together to achieve imperative programming by writing pseudocode-like blocks.