纲要

固定版式五六七八九十一二三四五六七八九十一二三四五六七八九

固定版式五六七八九十一二三四五六七八九十一二三四五六七八九十一二三四

无限版式五六七八九十一二三四五六七八九十一二三四五六七八九十一二三四五六七八九十

开始

@QZ 语言是什么？

QZ 语族的核心语言。一种计算机语言。

@QZ 的 @ 体现了 @QZ 语言的关键词都是以 @ 开始。

QZ 可以视为 QuicklaZy 的缩写。

QZ语族是什么？

拟定的是一种大一统计算机语言家族。

以@QZ语言为核心。自顶而下的解析方式的语言家族。

有解释语言也有编译语言。有动态语言也有静态语言。

也有混合这几种行为的语言。

问：为什么是语族？和一般的计算机语言有什么不同

QZ语族有不同的层级。

类似， C/C++，Level 1 是 C 语言， Level 2 是带类的C Level 3 是泛型语言。

高等级的编译器能编译低等级的语言，低等级的编译器不能编译高等级语言。

目前这方面还没想好，想到的就是不同的插件来让QZ语言实现不同功能，当这些功能齐全后，会排出相应的套装作为不同层级的。

QZ 语族的核心是（@QZ语言）。所有QZ语族都能编译到 @QZ 语言。实际上，大家不怎么用这个语言，因为写起来实在是太繁琐了。 QZ/Normal 是大家常用的语言本文用的 @QZ 语言是最繁琐的形式。

QZ 语言是静态语言还是动态语言

都是，QZ 语言的静态语言和动态语言共享同一语言，虽然他们用的编译器不同。 @QZ 语言的原则是先有规范，然后再管实现。

@QZ语言的一些特点

QZ 语言是用自顶而下的解析方式解析的。一般的情况下都是以开头关键词加上若干修饰子句完成。类似某些定语后置的自然语言。某个碰到不懂的关键词怎么办歧义怎么处理？近处的修饰符号优先。

一种计算机语言,属于命令式编程语言。有下面几大基本特点： 1 所有命令关键字都是以 @开头。 2 扩展方便众多 3 几乎不使用标点符号

这几个特点并不能能完全概括 @QZ 语言的强大之处，我们先了解 @QZ 语言，后面再讨论 @QZ 语言的强大。

本文顺带会说明 QZ 语族的其他情况。

演示

从兔子数列开始的演示标准的 @QZ 语言写法，就是本文要介绍的。

@qz @mode standard # 使用 standard 模式

@import stdlib # 引入标准库, readInt 在里面

# 定义一个函数
# 你可以注意到  func 这个开头词.
# 所有修饰词都用 @ 打头
#@func 用于定义一个函数 一般条件下可以省略
#  后面的 @都是 @func 的修饰词
@func  
  @as int  # 这里 表示 fib 这个函数返回 int 类型
  @name Fib # 这个函数名为 Fib
  @args  # 参数列表，这个修饰词有自己的子句
     @with 
       @deafult @as int @comment ”@default 代替了@arg XX” 
      #后面的 @as int 修饰 @default .
    @endargs
   @comment 兔子数列
@do  # @do里面是语句块.
   @return 1 @on ( (@arg 1 @equals 1) or (@arg 1 @equals 2));
# return on 是qz 语言常用的返回判断.
# @arg:1 调用的第一个参数
# 和常见的 equals 是 == 的宏不同. == 才是 @equals 的
   @return @sellcall(arg:1-1)+@selfcall(arg:1+2);
@end func @end 是可带参数的用于检查配对

@main #main是单独关键词
@do
  #显示
  @call print @args
      @string Input a string
    @endargs
  #输入
  @call readInt @setto t

  #判断
  @if t @lt 0 
    @then 
      @do
        @call print @string Minus!
        @return -2
      @end 
    @else
      @do @end
  #分支判断
  @switch t @do
    @on 1 @do
      @pass
      @end
    @on 2 @do @end
    @default @do @end
  @end
  # 循环
  # 异常
  @try @do
    @call exception @deal throwOn @args 
      @with conditions @values t @gt 10 
      @with @stringstart Too Big! @stringend 
      @with -1 
      @endargs
  @end
  @catch @do
    #
  @end;
  @call print @string output:
      @concat @call fib @with t
  @return 0
@end main

实际上，常用的写法 QZ语言的演示

@qz @mode normal  #这一行表示是用最快速的模式
# 一般情况下的最快速模式 默认不需要 main 函数,就在外面直接执行代码
# (最快的是 lazy 模式, 连括号都能省略!)
print (“Input a string”)
readInt()
if @last<0 then do print"minus";return -2 end else do end
switch t do
  on 1 foo1
  on 2 foo2
  default;
end
try do
  exception.throwOn(t<10,"Too Big!",-1)
end catch do
  #
end

print  “output:” ~ fib last
return 0
# func 表示函数  do - end 代替了 {}
# 实际上，normal 模式是同时支持 {} 代替 do - end 的
# QZ 语言的 do - end 语意比 {} 狭窄,仅仅用于代码段落。
func int fib (int) comment 兔子数列
do 
  return 1 on @arg 1 == 1 or @arg 1 ==2
  return @selfcall ( @arg 1 - 1 ) + @selfcall (@arg 1 + 2 )
end func

最懒惰的写法，程序员通常喜欢这样，然后 Fn键，让编译器编译成上面的代码。 (实际编译结果有一些不同，这里只是演示)

@qz  @mode @lazy
print string Input a string
readint
print @string output
~ fib last
func fib do
  return 1 on arg 1 = 1 or arg 1 = 2
  return selfcall with arg 1 - 1 indeed + selfcall with arg 1 + 2 indeed
end fib

还有一种特殊情况, 这也是 qz 语言的扩展

@QZ 中文自动分词加额外扩展插件

定义函数 兔子数列 开始
返回一于参数一等于一或参数一等于二
返回自身调用用参参一减一结参加自身调用用参参数一加二结参
结束 函数定义
打印 文本 请输入一个文本
读整数
打印 字文本输出
接文 兔子数列 最近输入

从演示例子里得到的

@qz 语言的行注释是用 # 。为什么不用 // ，原因是用两个字符比一个字符方便，而且避免其他语言习惯带入。反对者的意见是用 // 可以防止错误输入

@qz 语言不用分号作为语句结束标志。（@QZ 保留的4 个标点符号 @ ; () 分号用于断句）

@qz 语言没有用标点符号。

@qz 语言很臃肿是的，严格的 @QZ 语言是很臃肿的,因为没有采用符号。

但是， @QZ 语言是作为 @QZ 语族的核心语言的。

@QZ 语族有千变万化，各种缩写多的是。常用的写法是有标点符号的，这些标点符号，被映射到关键字上。

为了突出核心，本文用严格的 @QZ 语言写法。

这里举的四个例子，也是为了表达 @QZ 语言的扩展性。或者说，这是 @QZ 语族的演示。

QZ/Standard 每个 QZ 的关键词都加上了@

有了 @main 函数,不这个 Main 还和普通的 func 不太一样呢.怎么没有参数调用.

运算符不是一等公民,他们只是 @equals @concat 的别名.

之前说到 QZ 语言扩展性强，那么在代码最前面加上一句

@qz @mode normal

就变成了 QZ/normal 语言了。

很高兴你能坚持到这一章节。接下来就是通用性的介绍

基本语法

@qz 语言是用自顶而下的解析方式解析的。一般的情况下都是以开头关键词加上若干修饰子句完成。

类似某些定语后置的自然语言。

@QZ 语言的基本单元是语句。

一条语句一般由一个关键词开始，这个关键词被称为起始词，可附带过个以关键词开始的修饰子句。后者也被称为修饰词。

子句也可附带多个子句。

子句或子句的子句或许有同名起始词，但他们的表现并不由他们的名字觉得，而是由他们的所在的父句决定。

每条主句能带什么子句，由起始词来决定。每条语句的结束，决定于起始词。 * 问题，碰到不懂的关键词怎么办。

@qz 语言没有运算符，相应的 @QZ 语言有连词的概念。常用运算符+ - * / == 分别是 @add @dec @mulit @div @quals 的转写。

另外，高级一点的是后缀的副词，后面再说。

QZ语言的静态语言和动态语言共享同一语言，虽然他们用的编译器不同。 QZ 语言的原则是先有规范，然后再管实现。

四个符号

用于注释的 #

用于改变顺序的 ()

用于断句的 ;

或许用 @@ 强制表示新行开始结束子句的判断。 *
QZ/normal
qz/normal 是 qz 语言家族里最通用的语言。和 @qz 语言作为 qz 家族核心写得很冗余严谨不同，qz/normal语言比较灵活，方便。本文讲述过程中也会参杂 qz/normal 语言的内容。

qz/normal 语言相比 @qz 语言的特点

@ 可以省略了，只要不出现语法冲突。
@do @end => {}
@args @endargs => () ,里面用逗号分割了。注意， @args @endargs 不等于()，在 @QZ 语言中 () 作为改变计算顺序是存在的。
你不想用 () ，那么 @args @endargs 可以去掉，只保留里面的 @with
计算型语句不用以 @call 或 @let 开头了。
@setto 可以写成 => 了提前说一句， @setto 作为后赋值，也是 @QZ 语言的一大亮点。QZ 语言厌恶变量名!
. 可以表示很多意思了 @prop @staticCall @deal 都是用 .

变量

@QZ 语言是静态语言还是动态语言？核心是静态语言，@QZ 语族有静态语言也有动态语言。 @QZ语言声明变量是用 @var 语句来实现的。 @var 语句

基本声明

@var 语句定义变量。是 @qz 语言的核心。

@var # 声明变量语句
  @name MyVar #变量名字 @name 变量名直接跟在@var 后面的时候@name 可以省略
  @as MyType # 变量类型
  @parent  # 用于给子领域用
  @const   # 是否只读
  @reuse   # 是否复用
  @value MyValue # 值 
  @static # 静态变量
  @comment # 注释
  @scope  scope # 范围
  @global  # 全局
  @reuse   # 重复使用
  @may_const # 可能是常量
  @force_const # 强制为 常量

声明完 MyName 之后， MyName 就可以和其他 @关键词一样作为一个关键词来使用了 那么，变量有什么子句呢?

MyVar
  @add YourVar # 就是 加了.后面是算术运算
  # ...
  @value 100 # 值
  @conver_to 
  @qz_element
    @getType
    @declare
  @prop
  @deal

最简单例子

@var x
# x  是什么类型，编译器再后面推断，qz/core 是静态语言，变量的类型一旦确定，就不会改变。
@var @x @as @int
 # 设置 x 为 int 类型
 # QZ/core 语言的基本类型和  C 语言类似，有 int，double， char
 # 特有类型  pt  用来表示指针， array 表示数组，所以你会看到

这两句的理解应该是这样

@var x @as (pt @as any)
@var x @as (pt @as int)

数组的定义

@var x @as @array @size 10 @as int
@var x @as @array @as int @size 10

后者也是可以的。 @qz 语言的 int 默认是64位的。要指定不同位长的数字，如下

@var x 
  @as 
    @int 
      @bitwidth 32
@var x 
  @as 
    @float
    @bitwidth 32

同一语句体内不能出现同变量名的声明。用 reuse 可以重定义变量的指向，注意的是和前向 goto 不能同时用。这个场景用于脚本，以及机器生成代码的情况

@var x  @global. 全局变量是不会穿透到语句体的，你需要用 global

关键字让全局变量穿透，特别的，你应该用 parent @var x @as int 这也定义一个变量 x

@var x @as @int @value 100
@var x @value 100 @as @int
//定义一个结构体
@var  
  @name a 
  @as struct
  @values 
    @args 
      10 @as @int 
      20 @as @int 
      @endargs

定义int x 并设置值为 100

var x as my struct value args 100 30

@declare 语句和 @var 语句一致，但只声明有这么一个变量，不负责给内容插入变量。

qz/normal 对 @var 的改进 qz/normal 除了可用 var 之外，还可用
```
revar x 
global x 
$type x 等等替换了 var 语句。
```
@qz use_c_style 可以让你把类型放到前面

@qz/script 默认给变量的类型是 variant 类型。

定义一个指针
@var x @as pt @as int 定义数

类型

QZ 语言是有类型的语言。 QZ 语言有类型推导功能。一般而言 @as 子句后带的都是类型

类型声明

@as 子句用于 var , func typedef @qz 语言也支持 void 类型。字长0

@as 子句类型

@int    # int 整数
  @bitwidth 64
@float
  @bitwidth 64
@number # 
@void    
@any #默认就是这种类型，可以 省略
@string
@handle
  @as
@list
  @size
@map
  @size
@struct

基本类型

int

类型转换

@convert x @as int

@declare @func foo @int
@call foo @convert 1.2

数值转换。 @auto_number

自定义类型

@typedef newType @as int @for foo

定义函数的时候，用 callback 这词来代替如 @typedef mycallback @as func args arg as int arg asint @typedef x for func foo # 限定用于 foo 函数。

结构体

基本声明

@struct 
  @name MyName
  @union  # 联合
  @pack $number # 对齐
  @comment #注释
  @args

  @endargs

例子

@struct x
  @args 
    @with z @as int @default 0
    @with 
       @struct y @union
       @args
         @with p1 @as @pt @as int
         @with p2 @as @pt @as float
         @endargs
  @endargs

注意的是用 args – endargs 模式来声明，qz.qoute 打开的时候，你用（）来标定，而不是用 {}

结构体， union 也在这里用使用

@var x  @as mystruct
@call x @prop name @value 100;
# x.name =100 // . 是 @prop 的别名。

指针

QZ 语言用 @pt 表示指针。

@pt 指针 ( 因为 point 同时又表示屏幕的点，所以我们只好用 @pt 代替);

@var X @as @pt @as int

pt 加 @as 子句表示指针指向的类型

@var x @as @pt @as int

指向函数的指针

@var x @as pt @as 
  @func 
    @args arg x as int arg y as int endargs
    @return @as int @as array @as int @size 10

指针的操作

使用指向的内容。

@var x=10;
@var pt @as @pt @as int
@let pt @pointto x
@valueof @pt + 100 => x

pt @inc
pt @dec

pt @incbyte 3
pt @decbyte 3

装箱，指针指向类型为非指针的时候，可以不需要 @valueof

@var p @as @pt @as int
@inc p # ++p
@dec p # --p
@valueof p  # 因为有人觉得 @valueof 太常了，于是他们 添加了 qz.short_value 选项，改为 @v
@addressof v  # 同样 qz.show_show_value 改为 @a

Enum 枚举(未完成)

@enum x 
  @type int #类型为 int
  @for foo  # 只是给 foo 函数用的
  @init_by  0 ,1 
  @args
    @with a
      @value 10
    @with b
      @varlue 20
  @endargs

enum x(a=1,b=2,c=a);

函数 @func

@func 语句是很重要的语句然而函数不仅仅局限于 @func @main 也是

@func
  @name foo 
  @return @as @auto 返回类型
  @comment #这里是注释子句
  @args 
    @arg x @as int @default 0 @byval # 默认值为0 传值模式
    @arg y @default 20 @as @any @comment ”just do it” # 注释也是代码结构
    @endargs
  @dynmicargs # 动态参数
  @staticargs # 固定参数
  @multiReturn #多个 返回值    
  @independ   # 该函数不调用项目里其他函数
  @nolib      # 该函数甚至连库函数都没调用
  @nostatic  # 该函数内部没有静态变量
  @noglobal   # 没有用到上级变量.
  @haddeclare # 外部有声明，
  @forsupport # 表示支持性函数
  @for      #    所在
  @inline
  @stdcall  # 使用 stdcall模式
  @fasecall # 使用 fastcall 模式
    # 其他扩展会继续有的
  @do
    # 其他语句放这里
    @end  # end 是do的子句


@func foo2 @as @int
@do
    # 代码开始
@end

从兔子数列的例子中. @name 子句没有，代替的是 @func 关键词后加函数名。

按书写规范或 @QZ config must_end @func 语句中 ,@do - @end 总要放在最后。

函数的调用

最正经的调用 @call foo @with y @values foo2 @with 100 @indeed

一般调用 foo(100); let 语句和 call 语句的不同 @call 可以省略 @call 语句很简单，就是调用未声明的函数。一般情况下，你需要之前有qz enable call

@call foo(x,y) @call foo x,y

流程控制

判断

从例子里，if 语句是这样的

@if condition
  @then
     @do 
       @end
  @else 
     @do
       @end

qz/normal 可以省略 @then 关于判断条件.

非0值为真
实现了 @as_false 子句
用 @to_bool 包装
以上是为 qz/script 准备

@switch x @on 1 do end @deafult @endswitch

循环

@QZ 是用 repeat 来循环

@repeat 
  @on condition
  @step 1 #步长
  @forever #
  @check
  @do
    @end

为什么不用 for, 因为 for 太复合了。

for(i=0;i<10;i++){
  print i
}

repeat i do print @it end

@foreach x
  @enable_number
  @do
  @end

跳转

跳转语句包括 break continue return goto

@break 3 @on condiction 
  # 当condiction 生效的时候跳转 3 层
@continue @on condition 
  # 和上面的类似
@passblock @on condiction 
  # 类似 break ，但以 do –end 层级计算这意味着在 if , switch 语句中也能用。
  # qz/lazy 的扩展， if 语句里跳过后面执行的代码。
@return x @on y
# Return x  on y 的麻烦点，

@return x @on y 的麻烦点，返回多个值的时候 return a, b, c on condiction 不允许，所以要打开选项 @qz @option return multi on

return (a,b,c) on condiction
func foo do 100+x;return last ;last+=10 end

@goto labelname 需要开启 QZ.goto 才支持，行号必须用 @lalbel_to_goto //Lable labelname 来

# Qz multi_return 打开的时候可以返回过个值
# QZ .allow code after return 允许 直接return ，的死代码

Qz.multireturn支持多个 return 值， on condiction 也和break ,continue 类似

注释

QZ 语言的注释符号是用 # QZ 语言用 # 作为行注释。而且推荐只用 # 作为注释。标准 QZ 语言不推荐用多行注释，为什么？你编辑器都不支持多行注释，换个编辑器吧。 QZ 语言的注释是很强大的。除了用 # 注释，一般情况下 QZ.c_style comment 打开的时候，用 C 风格的 // 注释

/* */ 注释也被支持，/**/ 不支持嵌套，
而且， QZ 语言的 /**/ 有个原则，
不允许里面出现 /* 也就是  /* /*  */ 会报错！
除非打开
qz.c_style_allow_comment_nest

@comment 语句和 @comment 子句

@comment 语句也是注释很多语句都有 @comment 语句，表示这一行后面的都是注释。 @comment a string 注意这里的注释是用

代词

代词是 @qz 语言的一大特色。

@last 上一条语句的值。

@var x @as int value 3
@last +6 =>z
@return @last

使用 @last 你可以少写变量名称.

@it 循环迭代子

@foreach myMap @do
  println @index.name ~ ':' ~ @it.name;
@end

@arg 函数的参数

@func foo @args @with x @as int @endargs @do print @arg 1 @end foo

@andthen 链式写法者的爱好

@var myClass @as @class MyClass myClass @did foo; @andthen foo2

@ret 预设的返回值，省写一行代码


@ret @index =100 
return @ret

@ex exception 异常代词

@try @do
@end @catch @do
  print @ex.getMessage()
@end

字符串

字符串的写法。正式写法，左右引号都可以。

"abc"

一行到头

@string a line string

兼容键盘输入

"abc"

字符串处理是个问题主要是在不同库中的内存方式。

字符串在内存中的保存形式不以 \0 结尾。

字符串连接

@concat 连词缩写为 ~

@string a b c d => "a b c d"

heredoc

待定

数组,列表和字典

实现 array 数组的接口就是数组。一般语言 x[3]，

@var x @as @array @as mystruct ;
x @el 3 @prop @name  value 6;

等价于其他语言的：

mystruct[] x;
x[3].name=6;

@el 被转写成 : 而不是 [] 哦.

x=[];
x:3.name=6;

数组赋值 var x as array as int values args 1,2,3 end args; var x=(1,2,3);

#字典的 key  string 类型，不允许其他类型。
#字典的value 类型可以是任意类型。
#只要实现字典接口的，都是字典
var x as map;
map x ;
x ["y"]="z";

@foreach mymap
@do
  print @key ~  ':' ~ @it
@end

字典赋值

var x as map values (a:10,b:20);

脚本系统的字典与数组

只要实现字典原型的就是字典

连词和运算符

@qz 语言没有运算符，相应的 @QZ 语言有连词的概念。

另一种观点，连词可以认为是前一词的子句。
这就解释了下面的语句
@var a value 10;@var b; a @add 3 @setto b; 其中 @add 是已知词 a 的子句。

别名

当启用 qz.normal 之后。可以有以下转写。

@add => +
@sub => -
@mul => *
@div => /

优先级

位运算符在 QZ 语言里是普通连词，没优先级别，而且，没有转写

? : 三元运算符是个 bug ,因此，初期没有而且没有对应的转写。

函数调用
!
*/ %
+ -
<=
&& || 

+= -= *= /= %=

自定义连词

@declare @operator

@declare @func foo @as @int @with int @with int @indeed 
@declare @operator  @member2 myop as @func foo
@declare @operator @level 2 @as @class myclass @did mymethod
@let 2 myop 1 @setto foo ; print last
MyClass @create @setto a ; print  a foo 10

这里定义了 myop1这个函数.

其他语句

语句

@main

Main 函数

为什么要单独用这个而不是用 @func main

你可以认为 main 是 func main 的别名。 QZ 语言的 main 函数没有带参数，为什么没有带。因为入口过来就是没值的啊当然有其他辅助函数获得 main 函数的参数。

@selfcall

例子里用到，代表当前函数的代词。

@optimize

用于告诉编译器，这段代码建议优化。

并行计算

@ansyc 语句告诉编译器，内部的函数没先后关系，可以多线程同时进行。

@ansyc

@ansync @do @end

工程级别的 @QZ

声明

@declare 语句和 C语言的 external 类似表示有一个变量，但不负责这个变量是否存在

@declare 
  @var #...
  @func #...
  @struct #...

关系

对应的 @implement 子句 @var x @for @implement

declare func foo as int (int x , int y) @independs @stdcall

@implement foo @do

@end

于是就有了

@func foo(int,int) as int {
    #代码开始
}

实现

配合 declare 使用

declare func foo as int (int x  int y) independs stdcall mustdeclare
# 其他语言
func foo(int x , int y) @for declare{
}
# 但是，我们需要更明显，那么应该来个关键词 implement 来表示 func use decleare ,之后连 数据类型都不需要了。

implement foo(x,y) //注意，如果声明和实现不同，将会报错。
{
    return x;
}

这个或许不应该做为 @qz 语言的特性，而是一种扩展。
包管理

@package
@package mypackage @dir ../ 我的包，可选的 @dir 用于表示文件包在哪里。
@import
@import @file xx alias zz; @import @package xx; 导入包
@mainfile
@mainfile 这是包的主执行文件

自定义语句

自定义连词

自定义子句

自定义主句

自定义连贯句

智能灵活的编译器

@QZ 语言的编译器编译器的功能不仅仅是把文本转成可执行代码。还包括

语法检查功能
语言转换功能
语言规范功能空白字符 QZ语言的空白字符 U+0020 (space, ' ') U+0009 (tab, '\t') U+000A (LF, '\n') U+000D (CR, '\r') QZ.local_space 打开的时候，支持多种空白符，如中文的 “ “ 即使没打开 QZ.local_space ，输入中文全角空格的时候，编译器也会提示，并可修正中文空格为英文空格。

富文本，语音和笔迹。

如中文插件所示范，QZ语族希望接近自然语言的书写模式，分词技术将会得到应用。从中文插件可以看到

常见的关键词都替换成了中文
不需要分词
数字都转为了中文数字

并不只有QZ官方编译器。在特殊场合，也有不理会"QZ语族要能改成 @qz 语言"的编译器，这些编译器只实现 QZ 语言的子集。目的是为了加快编译速度。局限性也会碰到这个我没法编译的情况。

左和右

左是为了方便类型推导右是为了方便连续操作

var x=10;let 10 setto x;
@pointer_inc x;
x @inc_pointer;
x @coverto float 
call foo with @cover_to float x;

从其他数据中分离

要用到 <% 为什么不用 <? ,因为 <% 就是服务端脚本的标志啊。富文本里的支持。我们将来还支持文本输入和手写代码相结合的富文本方式。

混杂数据里

分区

xxxxxxxxxxxxx

@QZ

QZ语句

QZ 语句就是以 QZ 打头的语句了。

qz 语句，设定了编译器对文本的解释，使得 QZ 语族的语言呈现缤纷多彩的变化

@qz
  @file # 后面的子句仅仅在本文有效
@qz mustStatement_end 设定必须用分号结束。
@qz @file 作用范围
@qz lazymode  #懒惰的人打开 qz.lazy  于是就不用写了很多的括号。
@qz usebracket => 使用 () 代替 args … endargs 并用 , 分割里面的 参数
@qz lazycall 调用的时候  foo (x) = > foo x
@qz usebrace用 {} 代替 do  end
@qz usegoto 开启 goto，没有打开这句 QZ 编译器不认Goto 和 LabeltoGo 这个两个关键字
@qz call
@qz bracket  声明 把 args endargs 变成 ()
@qz brace  声明 把 do end 变成 {}
@qz enddeclare 本文件最后一条 qz 语句，如果后面再有则报错
@qz enddeclare strict 本文件最后一条 qz 语句，后面再
Qz 语言用  do end 代替 大括号，也是因为少写 
@qz maxdeep 4 ,4层循环就报错

@qz @forTemplate  限定代码没有执行性语句，用于脚本语言中的模板，文件代码后面只用于循环，显示等，如果有执行语句性的写法则报错。
你可以用

@qz 
  @declare_end # 这之后的 qz 语句就无效了
  @strict   # 这防止机器生成的代码你还改动

以下是参考。

QZ 语言语句参考

//// @tag-length-content @tag-length-pointer-content @pointer-pointer.

QZ语句

QZ 语句决定了QZ语言的无限可能。qz 语句是和编译器交流的 QZ 语句分为三类，第一类是限定语言，也就是所采用的编译器

repeat do end # 这个时候由编译器检查是否有死循环。必须有 break 语句指针的循环

Try error,warning,lesswaning , signal do end catch do end catch do end catch default do end

双重指针扩展数组 Qz.no_more_bracker 限定函数里最多只有8层 Qz.max_bracket_in_gen ，允许机器生成的代码，超越一些人为极限。

基本要素输入格式 QZ语言默认使用 utf-8。 Qz.locale 打开的时候可以使用其他语言。

基于类扩展的 QZ 语言 Class 关键字。 @class x @extends x @dymicc 动态的 class @impelement I1, I2 # Simple implemenet //## @singleton @args @public x @private x func(){} @var y protected @var z private @var z as nosuject @endargs

declare class x extends y impelement i1,i2 ( public x as int y as z z private a override func zz )

impelemeny x @deal foo { return this foo2+1 }

Public protected private 就够了么，我们还有 foroverride. forplugin。

函数之间的关系。 @relation beginwith fopen endwith fclose

comment

泛型 generic

泛型

泛型是一个 Level

新词 VS 引用词 qz 语言的泛型和 C++ 的不同 QZ 语言的泛型不需要 class 支持 template class MyClass { templte int fun(arg1,arg2) }

最大不同， < > 被取消了

func foo( args template T , arg1,arg2) @template @return template()


template struct str1
<class T> 
{
   T t;
};

template  struct str2
<template<class A> class T>
{
    T<int> t;
};

int main()
{
    str2<str1> mystr2;
    mystr2.t.t = 5;
    printf_s("%d\n", mystr2.t.t);
}

class

class implement extends args

endargs @init @mapto init

class 也是 args /endargs => ();

要允许构造函数，你需要打开非默认的 qz.enable_construct 而且构造函数不属于常规函数

class x {} 常见用法

MyClass @init
MyClass @singleton => @G

//// MyClass @G @did SayHello

protype

var x =new String;
String.prototype.trim=function(){return this.replace(/(^\s*)|(\s*$)/g,""); }
x.trim();
x @deal trim;
x @prop trim;

基于 prototype 的 QZ

func foo(int){
 return arg:1 +1;
}

typedef MyType @as @int
MyType x=0
print x.foo

@prototype
  @scope file
  @for MyType
  @us foo

为什么叫QZ这个拗口的名字

因为我也不知道起什么名字好。 QZ 两个字符是键盘上最左边的两个不常用按键。 QuicklaZy ，你也可以这么认为在 2015年年底到2016年元旦前，我考虑给QZ语族改名为 @QZ ，因为我最终把每句语句的开头词都加上了 @ 符号这样 QZ/Standard 语言就变成了没关键字的语言。

问：为什么要开发QZ 语族

一个原因，我想做一种脚本语言和编译语言，静态语言和动态语言统一的语言。至少，两者可以复用一部分代码。
一个原因，开发一个新的操作系统要新的语言支撑，新语言同时作为操作系统的脚本引擎。
一个原因，想开发一种给懒人用的语言。

现在连编译器都没搞出来，先把草案整理出来了，看能做到什么地步。

on xx throw myexception "test",100 myexception throw on xx "test",-100

感谢 rust 文档的支持

// 没有 throw 关键字，你需要 ExceptionClass .ThrowOn throw 需要 class 的支持 //

异常 Exception ex try warning { }catch(ex){

}finally{

}

Throw MyException
ex thrownOn flag string the friendly aa do {

} @pharesay throw ex @arg a @as int on @arg b show @arg c { if @arg a then throw new ex(c ,1 ) } @say throw ex x on %2 show %3

xx?.foo()

xx!==null?foo():0 && x ;

var x=flag?1:2; var x=check flag 1; var y=check flag 2

x makesure flag 100; => if flag then x=100; 异常的等级

纲要

开始

@QZ 语言是什么？

QZ语族是什么？

问：为什么是语族？和一般的计算机语言有什么不同

QZ 语言是静态语言还是动态语言

@QZ语言的一些特点

演示

从演示例子里得到的

基本语法

四个符号

QZ/normal

变量

基本声明

@declare 语句和 @var 语句一致，但只声明有这么一个变量，不负责给内容插入变量。

类型

类型声明

基本类型

类型转换

自定义类型

结构体

基本声明

指针

指针的操作

Enum 枚举(未完成)

函数 @func

函数的调用

流程控制

判断

循环

跳转

返回

注释

@comment 语句和 @comment 子句

代词

@last 上一条语句的值。

@it 循环迭代子

@arg 函数的参数

@andthen 链式写法者的爱好

@ret 预设的返回值，省写一行代码

@ex exception 异常代词

字符串

字符串连接

heredoc

数组,列表和字典

脚本系统的字典与数组

连词和运算符

别名

优先级

自定义连词

其他语句

语句

@main

@selfcall

@optimize

并行计算

工程级别的 @QZ

声明

实现

包管理

@package

@import

@mainfile

自定义语句

自定义连词

自定义子句

自定义主句

自定义连贯句

智能灵活的编译器

左和右

从其他数据中分离

@QZ

QZ语句

QZ 语言语句参考

QZ语句

comment

泛型 generic

泛型

class

protype