构建自己的编译器(十四) 变量声明

# 注释

注释，用[足以

如果多行注释，用[]足以

# 变量

[基本声明方式，声明必须是声明，在执行前必须先声明，声明就是分配内存嘛，没内存你搞啥]

i: 0.

i.int: 0.

[注意i与i.int是两个不同的变量，前者可以转换类型，而后者不可以]

i: int. [说明i为int类型，但是值并未初始化]

i: any. [说明i类型也未初始化，值也未初始化]

a: b: c: d: 0.

a<-b [b的值赋予a的值，但类型并不会转换，数值会隐式转换]

a<=b [b不仅将值赋予a，并且类型也会赋予a]

# 数列

用大括号：

i.ar: {1, 2, 3, 4, ...}. [加不加end都可以]

i.ar: {0}*100.

i.ar: i.ar+{b.int, c.int}.

i.ar: i.ar\1~3.

使用其中的元素则用反斜杠

t <= i.ar\1. [从1开始]

[数列式定义变量]

{a, b, c}: {1, 2, 3}.

[数列的操作]

myarr <= myarr + {1}.

myarr\i. [但这样看起来就跟普通的函数没什么两样了]

myarr <= myarr\1~2 + {1} + myar\3~-1. [说实话，有没有空格其实不重要，反正是可以辨别出来的]

[ar是单层数列，arr是多层数列]

func.ar: (

    a:1, b:2. 

    func<={a, b}

).

|a|这样表示一个数列或者字符串有多少个，或者数字的绝对值

# 映射

仍用大括号 

i.map: {"hello":1, 7:2, 6.5:3}. 

t <= i.map\"hello".

如果不存在，返回nul

如果省略key的话，就是当前最小的整数+1开始 

域的映射转换，例如

{a, b}<= {c, d}.

{a, b}<= {b, a}.

{a, b, c, d}: {1, 2, 3, 4}.

 例子：

[普通变量声明]
a: 0. [最普通的变量声明
a.int: 0.
b: a.
b.int: a.
c: 0.2.
c.flo: 0.2.
d.int: -2.
d.flo: -2.0.
e: "hello world".
e.str: "hello world".
f: true.
f.boo: false.
[不允许连续声明，因为这样很难看，而且单个声明也不是很长的句子]
[数列，映射声明]
g.ar: {1, 2, 3}.
g.arr: {{1, 2, 3}, 4, 5}.
g.map: {"key1":"val1", "key2":"val2"}.
g: {1, 2.0, "3", {4, "5":"6", 7:8}}.