什么是 Nessa？

Nessa 是一种具有强类型系统的命令式概念编程语言。许多想法来自我同时也是其作者的 ULAN 语言（仅限西班牙语），该语言的目的是挑战经典软件可维护性的观念，并将可扩展编程推向极致，以最大限度地减少语法和语义噪声。

访问 官方页面 了解该语言及其功能！

我可以使用 Nessa 吗？

当然可以！ 该语言处于 实验 阶段，因此确实可以使用，但请注意可能会出现一些问题。您可以在 此处 查看安装解释器的说明。

特性

以下是您可以使用 Nessa 做的事情：

• 任意精度整数算术.

• 完整的参数化代数类型:

  Int | String;        // Either a number or a string
  (Int, String);       // A number followed by a string
  Array<Int | String>; // An array of elements that are either numbers of strings
  

• 递归类型:

  class Nil {}
  type Tree<T> = Nil | ('T, Tree<'T>, Tree<'T>);
  
  let t: Tree<Int> = (
      3, 
      (
          1, 
          Nil(), 
          (
              3, 
              (1, Nil(), Nil()), 
              (2, Nil(), Nil())
          )
      ), 
      (2, Nil(), Nil())
  );
  

• 强大的函数重载语义：您将能够使用这种丰富的类型系统定义函数，并利用调用多态语义

  fn this_is_a_test(a: Int) -> Bool {
      return true;
  }
  
  fn this_is_a_test(a: String) -> Bool {
      return false;
  }
  
  // Both valid
  this_is_a_test(5);      // Returns true
  this_is_a_test("Test"); // Returns false
  

• 基于模板的泛型编程：参数化类型也通过类似于 C++ 的模板方式得到支持

  fn<T> is_number(a: 'T) -> Bool {
      return a.is<Int>();
  }
  
  // Template arguments are automatically inferred from the parameters if possible
  5.is_number();        // This is true
  "Test".is_number();   // This is false
  5.is_number<Int>();   // You can also explicitly instantiate the template
  

• 自定义字面量：您可以使用内部语言 NDL（Nessa 定义语言）创建新的字面量

  class Dice {
      // Syntax definition
      syntax from Arg(1{d}, rolls) 'D' Arg(1{d}, faces)
  
      faces: Int
      rolls: Int
  }
  
  //Usage
  dice = 4D20; // Four dice of twenty sides
  

• 编译时语法扩展：您可以通过使用 NDL 中的高级模式来扩展语言的语法

  syntax array_initialization from "<" Arg(<type>, type) ">[" [{Arg(<expr>, elems) "," [s]} Arg(<expr>, elems)] "]" {
      let res = arr<$type>();
  
      @elems.i {
          res.push($elems.i);
      }
      
      return move(res);
  }
  
  let array = <Int>[1, 2, 3, 4];
  

• 运算符和操作定义：该语言允许使用简单的语法定义新的运算符和操作

  // Operator definition
  unary postfix op "++" (500);
  binary op "<=>" (1000);
  nary op from "`" to "´" (1500);
  
  // Operation definition for each operator
  // These can be overloaded and templated just the same as functions
  op (a: &Int) ++ -> Int {
      return a + 1;
  }
  
  op (a: &Int) <=> (b: &Int) -> Int {
      if a < b {
          return -1;
      }
      
      if a > b {
          return 1;
      }
    
      return 0;
  }
  
  op (a: &Int) `(b: &Int, c: &Int)´ -> Int {
      return a + b * c;
  }
  

• 内置测试框架：您可以使用 @test 注解构建单元测试，而无需外部库

  @test
  fn fill_test() -> Bool {
      let res = arr_with_capacity<Int>(3);
      res.fill(100);
  
      for i in res {
          if i != 100 {
              return false;
          }
      }
  
      return true;
  }
  

• 内置文档生成器：您可以使用 @doc 注解来记录项目文档，并使用 nessa docs 命令生成可读的 markdown 文件，其中包含项目的文档。

  @doc(
      "Fills every available position in an array with a given value. The filling starts in the current `len`.",
      array: "the array to fill.",
      value: "the value to fill the available positions with.",
      "An array where every position starting from the previous `len` is `value`"
  )
  fn<T> fill(array: @Array<'T>, value: 'T) -> @Array<'T> {
      while array.capacity() > array.len() {
          array.push(*value);
      }
  
      return array;
  }
  

使用 Nessa 编写的项目

如果您想在这里展示一个项目，您可以提交一个拉取请求或打开一个问题 :)

Chessa 引擎

Chessa（有意为之）是一个用 Nessa 编写的简单棋引擎，旨在展示该语言在中型项目中的应用。此外，它还用作内部基准，以衡量优化。

Genessa

Genessa（再次，有意为之）是一个用 Nessa 编写的遗传算法库。它允许创建自定义的交叉和变异函数，并包括例如 N-Queens 问题等示例。

贡献

您可以通过在解释器中找到错误或提出改进语言或文档的建议时打开问题来为项目做出贡献。所有贡献，无论大小，都受到欢迎 :)