(10.times (do (th)
  (puts "Hello, world! #:#{th}")))

(-> File std::File)
(-> a_file (File::open 'a.txt :r))
(puts (a_file.read))

FooHash::FooKey::NestingClass::new.call_a_func

(class A
  (super std::Object)
  (def self.classmethod (puts 'a))
  (def a_method 1))

(class B
  (super A)
  (include FooHash::FooMod)
  (initialize)
  (def a self::a)
  (def a= (value)
    (self::a= value)))

(r :(B::new).a) ;=> nil
(-> b_obj (B::new))
(b_obj.a= 1)
(b_obj.a) ;=> 1
(b_obj.a_method) ;=> 1
(b_obj.class) ;=> "B"
(b_obj.class.superclass) ;=> "A"

P.S: 最原始的其实是这样
(-> B (=>
  name: "B"
  class: "std::Class"
  superclass: "A"
  ;......
(-> A (=>
  name: "A"
  class: "std::Class"
  superclass: "std::Object"
  #a_method: (# 1)
  classmethod: (# (puts 'a))))

module Lime
  module Builtins
    symbol '^#', 'Create a macro object'
    def macro_ctor(args_or_body, body = nil)
      body.nil? ? Lime::Macro.new([], args_or_body) : Lime::Macro.new(args_or_body, body)
    end
    make_symtbl
  end
end

(# 1)
(# (puts '我爱北京包子铺))
(# () ())
(# (arg) (puts arg))

Type       | (tostring T) | textual repr.
Macro    | lmacro         | (# arg_tbl body) (# body) ; by built-in macro ^#
Hash       | lhash            | (=> key1: value1 key2: value2) ; by built-in macro ^=>
List          | llist                 | () (()) (()())
String     |  lstring           | 'string "string"
Symbol  | lsymbol        | :a :"it's a symbol" :(car list) :'ssss'
Bool        | lboolean       | #t #f
Number| lnumeric       | 0x21212i32 0b3232 43 0.4 768f32
Nil            | lnull               | ⚪️ () ; expanded to nil

ending -> ' '|')'|'\t'|'\n'
number -> (0x|0b|0o) [0-9]* (u8|i8|u16|i16|u32|i32|u64|i64|u128|i128|f32|f64) ending
stringa -> '\'' string_data ending
stringb -> '"' string_data '"'
string -> stringa|stringb
nil -> ⚪️
bool -> '#' t|f
symbol -> ':' string|list ; 其实有一些特殊逻辑...
list -> '(' obj* ')'
obj -> list|number|string|nil|bool|symbol|

-> define
-? defined?
-x undef
<- read
. send
=> hash
# macro
: as_symbol
:< back_symbol
:' as_sexp
' as_array
" as_string_array
~ sequence
~~ must_sequence
` loop
`` must_loop
? cond
% typeof
:: index
::= indexeq
ext< loadext
ext> unloadext
require require
eval eval
dup dup
^ car
$ cdr
λ lambda ;就是让 macro 内联上当前(全局，Lime里没作用域的概念)环境变量而已
@ puts
@> warn
@< input
#< macro_args
#> macro_body
[] index_dynamic
[]= indexeq_dynamic
[]? haskey
[]- length
[]* allkey
"- strlen
"< gsub
"> match
"? is_include
": locate
+ add
++ inc
-- dec
- sub
* mul
/ div
** pwr
% mod
> lt
< bg
>= le
<= bg
<=> cmp
<< shl
>> shr
& and
| or
! not
^ xor
eh errorhandler
!! raise
r valueof(just_return)
p print
-># tomacro
->> tohash
->[] tolist
->" tostring
->: tosymbol
->B toboolean
->N tonumber
->() tonil

LVERSION lime version
LENGINE lime engine
LENV lime environment
LLIBPATH lime lib path
ENV os environ
ARGV cmdline argument
LFILE expanding file
$* argv
$_ file
$__ file parent dir
$: loaded files
$! exception
$@ exception postion
$~ match
$$ pid
$? child status
$. last readline number
$= ignorecase