Nimrod

It sounds like you want Python's syntax with C's performance, which Nimrod accomplishes well.

I've been playing with Nimrod for a few months now, it's a very nice language, and although productivity can be measured in bugs submitted per hour, it is still fairly usable unless you try to do complicated things with macros or the REPL.

Please note that my experience with Python is limited, so there may be subtle mistakes in my descriptions.

Example Code

import strutils

type
  TAbc = enum
    A = -1, B = 0, C = 1
let arr = [1, 2, 3, 4]
for i, elem in arr:
  echo("Elem #$1 is $2" % [$i, $elem])
if 'g' in {'a'..'b'}:
  echo "`g` is a lowercase letter!"
discard """
Multi-line comment!
"""

proc `*`*(a, b: TAbc): TAbc =
  result = TAbc(ord(a)*ord(b))

iterator myAbcs(): TAbc =
  yield A
  yield B
  yield C

echo(A * B)
echo(`*`(A, B))
echo(A.`*`(B))

for letter in myAbcs():
  echo("Top bound: $1; low bound: $2; letter: $3".format(
       high(TAbc), TAbc.low, letter))

# Possible, not a good idea though
import macros
macro void(body: expr): stmt {.immediate.} =
  let head = body[0]
  let procname = head[0]
  var params = newSeq[PNimrodNode]()
  for node in head.children:
    case node.kind
    of nnkCommand:
      params.add(newIdentDefs(node[1], node[0]))
    else:
      continue
  params = newIdentNode("void") & params
  var inside = newSeq[PNimrodNode]()
  for i in 1..(body.len - 1):
    inside.add(body[i])
    result = newProc(procname, params, newStmtList(inside))

void abc(int a, string b){
  echo("test"),
  echo("test1"),
  echo($a),
  echo(b),
}

abc(1, "passed string")

Similarities

• Garbage collection
• REPL (limited though, no FFI)
• Metaclasses
• Syntax is very similar
  • Similar iterator syntax (yield)
  • Space-based blocks
  • Similar loops, other control flow
  • Similar exception handling
  • Similar, but slightly different type annotations
  • and, not, or, in boolean operators
• Closures
• Tuples (I'm not a big fan of the implementation though)
• Raw and multiline strings
• Portable, though not yet perfectly

Differences

• Statically typed
• proc instead of def
• OOP is more cumbersome
• No for comprehensions, but can be implemented by macros
• Non-insignificant number of bugs at this time

Additions

• Advanced meta-programming
  • Advanced compile-time evaluation
  • Hygienic and non-hygenic templates
  • Macro AST manipulation
  • Term-rewriting macros
• Type Classes
• Zero-overhead iterators
• Optional horizontal whitespace parsing (1+2 * 3 as (1+2)*3)
• Style insensitive (can be changed by compiler param)
• Typically within 90% C performance
• Compiles to C
• Less tested targets:
  • C++
  • Objective C
  • Javascript, Node.js