cm-lang / cm-document Goto Github PK

我们的字符串字面量应该是转化成string这个类型的，但是这个类型到底是什么？它是否应该是高度封装的？还是就是一个vec<i8>的别名？

Java中，字符串是高度封装的，immutable。 C++中，字符串是（因为**C）char*，而且辣鸡clang还合并常量，性质极其恶劣。

你们如何评价？如何看待？要不要char这个类型？或者干脆和i8当成一个东西？

以及，要不要提供多种不同的字符串字面量？比如，"boy next door"c 变成vec<i8>，"boy next door"变成string。

应该搞那种，全inline模式和强制某个方法或者lambda不被inline。

指针是肯定必须成为AST的一部分的，起码后端得知道啥是指针。然后才能调用各种C语言函数。

我并不认为这个东西是必须暴露的(我其实更希望它被包起来)，但是它不可避免啊(puts要的可不是i8的数组)。

目前允许不声明 lambda 的返回值类型，并通过里面的 return 语句推导。请说说你们的看法。

根据我在群里的说法，我们现在想到的各种non-OO的特性已经可以基本上代替OO了。

实际上，完全去掉class的概念，保留struct、扩展函数、操作符重载、lambda变量重载，基本上就很牛批了。

学C++手动声明还是自动检测？我觉得应该是后者，但是这件事应该经过商量。

帅不帅

放在 https://github.com/ice1000/NppExtension 里的

比如Lambda与Primary之间是否可以重载。

func foo : void
{ f : i32() -> f(); }

var foo:i32 = 1;

以上代码是否合法？

lambda类型的变量需要这样：

val lambda: func i8(int) = xxx
val lambda: func i8(string) = xxx
lambda(233) // 会resolve为上面那个

以此来支持重载。

而且只会在这种情况下这样处理：

• 函数调用语句的函数名是直接给出的，不是什么东西的返回值

比如lambda(xx) 就是直接给出lambda这个名字，如果你是findLambda(xxx)(xxx)，就不这样，就认定那个返回的lambda（好像也只能这样）。

目前不允许直接在定义 lambda 的时候指定类型，仅允许直接推导。请说说你们的看法。

要不要考虑加入宏来实现一定程度的代码复用？

而且C风格宏和Rust风格宏，实现难度不一样，做出来后用起来爽的程度也不一样。我不是很清楚，看你们的想法。（表达式拆分做起来蛋疼啊）

请求加入

For-each语法糖
For comprehension/do notation语法糖
类似C# Linq的语法糖

这些东西Parse的时候就处理掉。或者我整个desugar的util

请求允许手动声明inline。

字符串字面量，应该有很多种。

目前想的：

• "balabala" 朴素字符串，string类型
• #"balabala" 直接输入字符串在LLVM IR中的样子，出车祸后果自负，其他后端不支持这个特性
• @"balabala" 和C#一样

*.bc is the extension name for LLVM's bitcode(LLVM IR) files.

@SmallLuma 我要求Parser在解析的时候把二进制和16进制处理了，分别使用0b和0x作为前缀。

0o作为8进制，后期再决定要不要。

我们应该想要引入的是Rust那样的类型系统。我假定你们比较了解Rust。

请说说我们要作出哪些不一样的事情。比如，不把内存管理和类型系统放在一起。

在语法定义中，最后一个实参如果是lambda，那么可以写在括号外面：

unless (xxx) {
}

但素，如果一个函数就只有一个参数，而且是lambda，那么应该是这样的：

async() {
  // do something
}

辣么我们棱不棱把仄个括号也省掉呢？就是这样的：

async {
}

如何设计 module 这一概念？

如何设计ffi

我想到了用 extern 或者 foreign 来声明 然后在链接的时候解决

泥萌如何看待

我觉得我们应该引入不支持继承的接口（或者叫trait，名字不一样而已），然后使用合成类型来代替继承。很妙。按理说。

但是也有很多严重的问题，比如这肯定涉及类似虚函数表的东西。我觉得我们可以在编译后把这个搞成模板。你们怎么看？

两种想法：

0. 随便你怎么定义二元运算符，反正当成函数（Haskell
1. 像C++/Kotlin那样钦点几个，然后特殊处理

如果是前者，是否要允许自定义优先级和结合性（Haskell支持

如果是后者，有哪些钦点。我目前想的是：

+ - * % ^ & | $ ! !! ? () / += -= *= /= |= &= < > >= <= <=> <+> <*> <> <|> <$> >>= =<< >>> <<< || && \\

I need a string type while developing the compiler. Currently, it's string.

Possible alternatives:

• String
• vec<u8>

添加对rec（或者叫recur）的支持。它只能在lambda内部被使用，代表这个lambda自身。

比如，我们需要写一个匿名的递归函数。举的例子是阶乘。

execFun(10) { n: i32 ->
  if (n == 0) return 1;
  else return n * recur(n - 1);
}

如何给匿名lambda命名？使用什么规则？

关于类型系统

• 建议添加tensor模板
  tensor<T, int dim>
• 增强泛型能力，引入类型函数（适应复杂的业务逻辑

struct TexCoord
{
	u : f32;
	v : f32;
} 
// 类型函数 接受类型参数返回类型
/*
用于处理复杂的泛型情况。
可以引入流控制if-else。
*/
typefunc myConstrait
{
   TexCoord , i32                 -> f32
   TexCoord , i32 , i32           -> i32
   TexCoord  a,  TexCoord b       -> a.u + b.v // 通过a.u+b.v推导返回类型，类似decltype
   otherwise                      -> nulltype
}

typefunc rangeConstraint   //利用控制语句，根据数据范围定义函数类型。
{ i32 a, i32 b -> 
         if (a>10)   i32           
         else        i64
}

关于语法

• Pipeline
  用于复杂的函数调用与被调用情况。

   let a: i32 = 10;
   let b      =  a |> func1 |> func2 |> func3;// 等价于 let b = func3(func2(func1(a)));
   let c      = func1.func2.func3 (a); //等价于 c = func3(...func1(a))

• Control Flow
  在函数模拟的控制流程中，是否可以跳出该函数向上级函数返回值？

  func someFunc : nulltype
  {
    let a: i32 = 1;
    unless(a)
    {
       //do something
       if(someCondition) ret ; 
        /*是否可以跳出unless函数，直接结束someFunc函数。
          这看起来有歧义，因为unless函数的返回值类型也可以是nulltype
          是否加入label break?
        */
     }
  }

AST
没有DoubleLiteralExpression和FloatLiteralExpression，这个东西是打算怎么做？

便于debug啊还有toJS什么的

@AkimotoAkari 提到了一个问题

func a void(x: i8) {}

这种写法应该已经被废除了，我们应该统一成

func a { x: i8 -> }

岂不美哉

首先，我们原本的lambda设计，是参考的Kotlin语法：

const a = { x: i8 -> x + 1 }

然鹅，在只有一个表达式的时候，这对大括号看起来挺捉鸡的。因此就有这么个可能性：增加一个语法糖，只对函数体只有一个表达式的lambda有效，可以多参数，需要括起来，即：

val a = x: i8 -> x + 1
(1..10).someHof(x->x+1, y->y+1, (z, k)->z+k)

解析方法：把->视为一个二元操作符

必要性：我觉得不是很有必要，只是Kotlin群讨论的时候说到了，我提一下而已。主要是做那种

a -> b -> c -> a + b + c

这种东西，如果按照原本的语法，就比较猥琐：

{ a -> { b -> { c -> a + b + c } } }