[root]
	└ [doc]				文档目录
	└ [main]
		└ [resources]	资源文件目录
		└ [src]			源码目录，通过目录结构来定义包
			└ main.sc 	主入口文件（编译为可执行文件时有这个文件）
	└ [test]
		└ [src]			测试源码目录，
		└ [resources]	测试用的资源目录
	└ [subject]			子工程目录，除了没有 main.sc，其他和主工程一样，也可以在内部通过链接文件连接到其他目录
			└ 
	└ config.yml		配置文件

const pi=3.1415	// 注意：常量如果可以推断，可以不需要类型定义

enum MyEnum{ red=0, blue=2 }	// 枚举和 int 可以无缝转换

MyEnum.red

var i=10
var x = y = 100		
var a
if(..){
	a = 30.0f
}

var name = "Hei"		// 这里 name 自动成为 String 类型
name = 15			    // 而这里会出错，因为 name 不能改变类型

int[] a=[ 0, 1 ]			// 数组可以直接初始化
Array<int> a = [ 0, 1 ]
int[10] array2				// 初始化一个空的数组  
int v=array2[1]     		// 数组取值

// 通过内置的 size 成员函数来获取数组的长度
var len = a.size()			// 注意，这个是编译期方法

func myFunc( int[] array ){ ... }

int[2, 2, 2] vec = [ [ [1,2], [1,2] ], [ [1,2], [1,2] ]  ] 
int v = vec[0, 1, 1]

int[] s=arr[startIndex:length]

MyCls[2] myClss
var zero=myClss[0].val		// 对象还未构造，但 zero 的值是0，因为内存被置0了
if(myClss[0]) doSome		// 不能这么判断，表达式永远为真，编译会报错误
if(myClss[0].exists) doSome	 // 可以在 MyCls 里定义一个 boolean exists=true, 由于数组默认置空的，就可以用来判断对象是否存在了
myClss[0] = MyCls()		// 可以认为是 myClass[0] = clone(MyCls()), 当然，编译器会进行优化
var v=myClss[0]			// 原则上等于 v=clone(myClass[0])
v.val = 11			    // 数组内的对象不受影响
const x=myClss[0]		// 这样不会进行复制，x 被认为是 myClass[0] 的别名
x.val = 11				// 数组内的对象被改变

Any i=20.0f    // 保存一个 float

assert( i is Any )

when(i){   // 用 when 关键字进行运行期类型判断
	int : print(i)	// 在这个分支，i 被自动转换为 int 类型
	
	float : {
		// do float
	}
	default : {
		printf("unknown Type")
	}
}

if( i is int ){	// if 中如果有类型判断，块中会自动转换为相应的类型
	int b=i+1
	... 
}

Type type=i.type	// 获取类型（参见**反射**）
float x=i			// 或者 (float)i 强制获取 float 类型的值

switch vegetable {
	"celery": vegetableComment = "Add some raisins and make ants on a log."
	"cucumber", "watercress": {
		vegetableComment = "That would make a good tea sandwich."
		comm = "多行需要大括号"
	}
	default: vegetableComment = "Everything tastes good in soup."
}

switch intValue {
	1..10:		v="1 to 10"
	20..30:		v="20 to 30"
}

var a=(1, "second", x)				// 直接创建
print( a[0] )						// 取第一个值（注：[] 操作是编译期的）
if( a[1] is int ) print("yes")		// 通过索引取类型

for( var i : a ){					// 通过 for 循环，在编译期解开元组
	print( i )
}

var n= (10, "Hello") :+ (20, "你好")  // + 可以拼接元组，结果为 (10, "Hello", 20, "你好")
var t=1 :+ (10, 20)					// + 也可以把元素加入元组成为一个新元组，这里等价于 var t = (1, 10, 20) 
PS: var x = you( myFun() :+ 10 )		 // 考虑到函数返回直接用 + 容易引起二意，还是用 :+，冒号代表操作元组

var b0, b1 := a				// 元组的自动解构，注意复制的是引用，变量数量可以比实际的少，但不能多。
int c0, float c1 := (10, 10.0)

var c=(0)			// 这不是元组，c是 int 类型

var tuple=( key=1, value=2 )
print( tuple.key )

( 10, 20 )		// 编译错误

int[] arrays = [10, 20]
for( var i : arrays ){
	i = 30		// i是引用，这里将改变 arrays 中的内容
}

for( int i : 1..20 ){
	...
}

for( var i : list ){
	free i		// 等价于 i=list.remove(i) continue
}

for( var k,v : map ){	// 同样，注意复制的是引用，因此改变 v 会改变 map 内的值
	free k
}

String eng="Hello world!"			
String str="中文"					
char aChar=str[0]					// a='中', 取出某个字符，为 UCS-4 编码
String str( bytes, Charsets.utf8) )	// 通过 bytes 指定编码来创建
str.bytes()				    		// 获取 byte，不指定编码，会默认返回 utf-8

String s=str[0:1]	// 注意，这里不会复制内部字符串

String s = "Hello " "World"

String s="" + 16		// 结果是字符串 "16"
s=R("Hello", "zhCN")	// 从资源文件获取字符串

String s="Value=$val and key=${cls.key}"  // 字符串模板
var x = 'No $Template'

func first( int a ) : int {
	return a
}

var x = first( 10 )

func second( int a, var b, int ... args ) : int retval, int val {
	// 这里 args 被视为数组 array
	if( args.size > 0 )
		val = args[0]
	retval = a + b		// 直接操作返回值
	return	   // 可以省略变量列表
	int x = 12 // 编译错误，return 必须在块的最后 
}

func add(int a, int b) = a + b

func varFunc( int a, var ... args ){
	for( var i : args ){    // 这个 For 会在编译期被展开
		run(i)
	}
}

func varFunc2( int a, Any ... args ){
	//  args 被视为 Any 数组
	for( var i : args ){    // 这个 For 会在运行期被展开
		run(i)
	}
}

var first, second := fun( 10, 20 )

func second( int a, var b ) : int, float, int {
	return 0, 15.0, 2	
}

String old="Hello"
cut2(old)
print(old)	// 输出 "Hell"

func third( int a ) : int {
	return a+1
}

func myFunc( var a, int b ) : var ret {
   return a+b   // 这时推断返回值为 int 类型
}

int x=myFunc( 10, 20 )

func myFunc( clone int clonedValue ) {
	clonedValue.x = xxx	// 不影响原始变量
}

var first, second := fun( 10, 20 )

var v = fun( name="myname", value=20 )

fun( 10, 20, name="myname" )

var v= fun( name="myname", 10, 20 )

var add=func(int a, int b) : int{ return a+b }	// 匿名函数
int a=add(10, 20)								// 执行

var my1=func(int a){ ... }			// 无返回值
var my4={ return 20 }				// 语法糖: 无参数时 = 后面 func 可以省略， 返回值类型自动推导
func(int):float itIsAFunctor		// 明确的类型

int myVal = 10
var x=func(int a){ return a+myVal }		// 注意这个 myVal 是引用，在匿名函数调用时取*当前*值

assert( x(20)==30 )

/// 语言内部异常，所有异常的基类
class Exception{
	String message	// 异常信息字符串
}

// 定义一个异常
class IOException : Exception		// 定义一个新异常
class HttpException : IOException{		
	int code
}

try{
	var a=func( 10 )
}catch( HttpException IOException e ){	// catch 允许多个异常类型
	print( e.message )
}finally{
	// 最后会执行的代码
}

// 简化的异常处理格式，对函数的异常直接处理，需要注意的是，函数后面的 catch 只能有一个
var i=func( 10 ) catch(e) {
	print(it)  // it 是 Exception 类型
}

func(10) catch {}	//明确忽略异常

func nothrow willNotThrow() : int 

String k = null 		
assert (k is null)
k = "10""
k = null
k = "20"

data MyData{
	int val;
	String str;
	
	// 默认生成
	init(int val=0, string str=null);
}

MyData x(10, "你好")

/* File MyCls.sc 开始 *
class MyCls {	// 定义类
	// 语法糖在变量前加个点，会自动赋值到内部变量
	init(int .privateValue = 20 ){}	// 变量前加 . 等同 this.privateValue = privateValue

	finalize{           // 析构函数始终是无参数的，不需要括号
	}

	clone{              // 克隆函数
		return MyCls(){
			it.key = clone(this.key)
			it.value = clone(this.value)
		}
	}

	int key = 1			// 创建时初始化（先于构造函数）
	int value			// 创建时默认为0
	
	func do_something(){
		this.key++  // this 是自己
	}
protected:	// 类中有且仅能有一个 protected 分割线，分割线上部的是公开的变量、方法，下部是
			// 保护的，只有在同一个类、子类或继承类内可以访问
	int privateValue	// 内置类型初始化为 0
}

class Base{
	func cantOverload(){	// 普通函数不可以重载

	}
	
	func(int) virtualFunction = null 	// 代替纯虚函数
	func(int) canOverload = func(int v) {
		doSomethine()
	}

	var myFunc = func(int v){		// 函数对象
		print(v)
		virtualFunction(v)	// 调用虚函数
	}
	
	const func(int) constVirtualFunction = null 	// 真纯虚函数
}

// 类可以继承，只能单继承，但可以有多个接口
class Second : Base, Interface0, Interface1 {        
	func cantOverload(){	  // 这会是个全新函数，编译器报警

	}

	virtualFunction = func(int v){	// 重载虚函数
		print(v)
	}

	myFunc = func(int v){
		Base:canOverload(v)		// 强制调用基类函数
	}
	
	constVirtualFunction = func(int v) {
	
	}
}

Interface0 obj = Second()
obj.virtualFunction = xxx // 还能改
obj.constVirtualFunction = xxx // 编译错误，不能更改

class MyCls {
	int valueA;
    
    get valueA {	
        return valueA
    } 
    set valueA(int newValue){  
	    valueA = newValue
    }
    
    get fakeValue: int {		// 可以 let x = myCls.fakeValue 这样调用
    	return valueA + 10
    }
	
	get virtualValue = func(): int {	// 可以 let x = myCls.virtualValue 这样使用
									 //   另外可以 get(myCls.virtualValue) = func() -> int {}	这样“重载”
	}
	
	set virtualValue = func(int newValue) {
	
	}
}

class YouCls : MyCls {
	get(virtualValue) = ...	// 继承内重写
	int b
}

YouCls you
print(you.valueA)	// 返回 b值

MyCls cls
get(cls.virtualValue)=func(): int{ // 外部重写 set 方法

}

MyCls my              	// 括号可省略
var a=MyCls(10, 20)		// 通过构造函数构造，参数表使用逗号分割，当然可以 var 推断
List<String> arr= （"Hello", "World"）	// 通过元组初始化列表

MyCls c(10){     		// 小技巧，在构造时，后面直接接大括号，在构造后，直接执行语句块
	key=0				// 在构造函数执行后执行
	val=20
}

MyCls a = null

MyCls a=clone(b)	// clone 会调用复制函数进行深 copy。

MyCls x=null
if( x==null ){			// 可空对象和 null 的比较，会判断对象是否为空
	x=Cs()          	// 这里会改变 x 指向的对象
}

Cs a
Cs b = a    // b 指向 a
b.val = 1   // 这里同时会改变 a 指向的对象值

int a = nullable() ?: defaultValue		// 为空时 a 赋值为默认值

fun MyCls.other(){	// 本函数定义在外部，通过 import org.other 引入
	this.val++
}

MyCls cls()
cls.other()			// 可以像内部方法一样使用

class MyCls3{
	int var=0
	class SubCls{
		int subVar=2

		func incVar(){
			var+=subVar // 子类可以访问父类的成员变量
			super.print()  // super 是父类的指针
		}
	}

	SubCls cls=SubCls()

	func print(){
		Console.print(cls.subVar)
	}
}

var managed = ManagedClass() 	// 托管的
free(managed)					// 调用析构函数

var unsafe = new Unsafe()
free(unsafe)			// 析构

var i = a {		// if(a!=null) 才执行
	doSomething()
	it.name = "hello"	  // it 关键字代替本身
}

if(a != null)){
	a.doSomething()
	a.name = "hello"
}
var i=a

class MyCla{
	fun my(){
		a { other :
			other.hello()	
		}
	}
}

var a=(MyClass)b			// 尝试将 b 转换为 MyClass 类型
(MyClass)b.funcInMyClass()	// 先转换在调用
(MyClass)b{					// 转换再调用对象作用区
	funcInMyclass()
}

////// 文件开始 ////////
singleton MySingleton{	// 单例的公开定义部分
	func astCallit(){}
}

import org.MySingleton	// 引用就初始化

class MyTuple {
	var left
	var right
	init( var .left, var .right ){}		
}

MyTuple<int, int> v = MyTuple(10,20)	// 通过构造函数确定所有类型

class MyMap<KEY, VAL>{	// 注意：类型占位符的约束是必须全大写
	KEY key
	VAL val

	init(String name){	// 
  	}

	func templateFunc( var a ){		// 函数直接使用 var 来定义模板函数
		if( a is int ){		        // 这里的 is 是编译期的操作符，因此这里的 if 也是编译期的
			a++
		}

		def A = b
		A b							// b 定义为 a 相同的类型

		Type c=typeof(a)			// Type 是种描述类型的特殊类型
		when( a ){					// 用 when 判断类型
			int : {

			}
			float : {

			}
			default : {

			}
		}
	}
}

var my = MyMap<String,int>("Hello")		// 构造时必须可以推导类中所有类型

func templateFunc( var a, int b ) {
	...
}

func<T> templateFunc( T a, T b ) = {
	return a+b
}

def AFun = func(int, int):int
def MapClass = MyMap<int, String>		// 定义模板类

var m = MyMap( 10, "Hi" )
def IntMap = m						// 可以理解为 def IntMap = typeof(m) 的语法糖

func myTemp( const a ) : var c{ // 通过 const 关键字保证只有常量可以传入
	if( a == 1 ){
		return a+10
	}else if(a=="Hello"){	// 传入 常量整数时，这分支都不会被编译
		return "World"
	}
}

myTemp( 10 )	// 在编译时不会生成函数，直接替换为 a+10

var x = 10
myTemp( x )		// 编译错误，禁止传入变量

const y = "Hello"
myTems( y )			// 传入的是常量，按模板编译

A is B

A === B

if(a is int){		// 当 a 类型为 int 时被编译
	int b = a+10	// 这里 a 会自动改为 int 类型，不需要强制转换代码
}else{
	a = "Hello"	// 虽然类型错误，但这里没编译，因此不会报错
}

 if( a`name` ) ...
 if( a`myfunc` is func(int, String):String ) ...

func my( var ... attrs ){
	for( var i: attrs ){
		// 这里 i 的类型会按输入变化
	}

	var x=( 10, 20, "Hello")
	for( var i: x ){
		print i
	}
}

var a=(1==1)		// 1

func TplFunc( var a, var b ) = {
	if( a is int && b is int)
		return 1		// 真类型，if( TRUE ) 永远真，并且在编译期就处理
	else
		return 0
}

var a = 10, b=10
if( TplFunc(a,b) ){	// 静态语句，在编译期展开
	int c = 10
}

interface MyInterface{
	int value
	func getSome():int	// 这是个函数定义
}
func notTemplateFunc( MyInterface inc ) // 函数体通过二进制（c函数）方式导出 	

void aFunc( <int a, String b> inc ){ // 传入对象必须有个int型成员变量a, 一个 String型变量b
	inc.a++
}

class MyClass : Base, MyInterface{	   
}

MyInterface i=MyClass()		// i 被认为是 MyClass 的基类

void bFunc(MyInterface v){  // 必须从 MyInterface 继承的对象，才能传入
                            
}

class MyClass {
	int value;
	func getSome(): int {
	
	}
}	
// 虽然 MyClass 并没有显式实现 MyInterface，但它包含了 MyInterface 所需要的所有元素，因此也可以直接传递给接受 MyInterface 作为参数的函数。
func myFunc( MyInterface a ){} 
MyClass x
myFunc(x)	

Optional<int> opt=12
opt.isPresent()	// 是否存在

opt->(int v){ // 当值存在时被调用

}

int? optInt	// 其实是  Optional<int> 的简化写法

Thread thread(daemon=true, level=3, loop=false) // loop = true 时线程函数会反复执行，直到线程收到中断信号
thread->{       // 运行线程
	aFunc()
}
thread.cancel()		// 尝试发送信号关闭线程
thread.join()	 	// 等待结束

Mutex myMutex=Mutex()			// 定义一个锁
myMutex -> {
	// 锁内
}													// 这里解锁

var a=Atomic(10)	// 原子的 int
int v=a++           // 原子的 +1 并返回新值
int cur=a.compareAndSet( 11, newValue )

func myLibFunc( $MyObject obj ) // 这说明 obj 在函数内会逃逸

go {	// 通过go来创建一个并行任务
	print( "go" )
	yield();  // 放弃 cpu
	sleep(x); // 放弃 cpu 并等待最少 x 毫秒后继续
}

go dosomthing()		// 并行执行函数

func doSomthing() : int 

Coroutine<int> c1=go doSomethine()
Coroutine<int> c2=go doSomethine()
....
var v1= c1.await(4000)  // 等待协程执行完毕，最少 4000 毫秒后还未结束将抛异常
var v2= c2.await()

var chan=Chan<int>()	// 实例化一个通道

go {				 // 并行执行语句块
	int i = chan.await(4000) // 这里会阻塞，直到 4000毫秒后超时抛出 TimeoutException 异常，或者 chan 被其他线程调用，参数会作为 await 的返回值返回。
		catch(TimeoutException e){

		}		 

	// 后续的代码
	print(i)	// 输出 10
}
chan(10)	// 调用通道，把数据塞进去，这里会阻塞，一直到数据被取走

var cachedChan=CachedChan<int>(10) // 带缓存的通道，缓存满前不会阻塞

import org.simplelang

import org.simplelang as sl

org.simplelang:printLine("Hello")

org.simplelang.inner:StringImp imp	// 编译错误，无法访问

func myTemplateFunc( var param ){
	for( var i,name of param ){	// 枚举 param 的成员变量、成员函数，它会被展开为代码，name 是它的名称，是个静态字符串，由编译器支持
		if("open"==name){	// 如果这个字段叫 open
		
		}
		if(name.startWith("my")){ // 
		
		}
		
		if(i is int){
		
		}else if(i is func){	// 如果是成员函数
		
		}else if(i is func(int, int)){
		
		}
	}
}

class MyClass{
	@ReflectName( name="value", idx=12 )	// 使用注解对象来进行注解
	int a 

	void doFun(){
	}
}

@Clang("my_c_object")
class MyCObject
{
	@Clang("my_obj_add" )
    func at( int idx ) : int  // int my_obj_add( my_c_object* me, int idx )

    func size() : int  // int my_c_object_size( my_c_object* me )
}

class MyClass{
	operator + ( int right ){	// 二元操作符的函数重载（默认的返回 MyClass 类型）
		return this
	}

	operator ++{					// 自增在后
		// return this 可省略
	}
}

trans_data( get_data(), x)

func trans_data( var v, bool x ){
	if(x) print(v)
}

void trans_data( bool x ){
	if(x) print( get_data() )
}

trans_data( get_data(), x)		// trans_data 的第一个参数必须是 Delay<?> 类型

func<T> trans_data( Delay<T> v, bool x ){
	if(x) print(v)
}

Delay<int> x={ get_data() }		// 这时 get_date() 其实没有被执行
var k=x							// 这时才会执行，并且只会执行一次
var k2=x						// 注意，这里不会重复执行

10 :: fun 	// 等价于 func(10)

(10, 20) :: myFunc 	// 等价于 myFunc(10, 20)
let tuple=(10, 20)
tuple :: myFunc		// 等价于 myFunc(10,  20)
let v = ((10, 20) :: firstFunc) :+ 30 :: second // 等价于 let v = second( firstFunc(10, 20), 30 )

class *UnmanagedClass{
}

var unmanaged=UnmanagedClass()
free(unmanaged)

class Connect

class MyObject

var conn = Connect()
var my = MyObject() link conn
var myRef = (my:conn)

var json = ```json```
  { im : " }
```

interface MyProxy{
	func run(String data)
}

class MyProxyImp {
	func invoke(String methodName, Any[] args) : Any
}

MyProxyImp obj()

MyProxy imp = proxy<MyProxy>(obj)	// proxy 是内部函数
imp.run("Hello")	// 

class A
A a

for( def i : A ){
	a[i] = xx // 赋值
	if( i.name == "hi" ){ // 编译期比较

	}
	i.annotations["CLang"] {
		var n = it["name"]  
	} 
	def T = i
}