Merge pull request #60 from nature-lang/feature/arm64

feat: basic support arm64

Author: weiwenhao

README.md

@@ -59,51 +59,6 @@ Quickly compile and execute using the docker integrated environment:
 docker run --rm -it -v $PWD:/app --name nature naturelang/nature:latest sh -c 'nature build main.n && ./main'  
 ```  
 
-## 🌱 Release Schedule
-
-Nature's versioning adheres to [Semantic Versioning](https://semver.org/). Versions 0.1 ~ 1.0 have two parts:
-
-The first half always has a beta indication, denoting that it's not ready for production.
-
-The second half is stable with backward-compatible syntax API. By this time, nature is suitable for personal indie/open-source projects, but LTS versions aren't provided.
-
-With the release of version 1.0, nature will be officially used for open-source/commercial projects and will have an LTS version.
-
-| Version     | Content                                      | Expected Release Date |  
-| ----------- | -------------------------------------------- | --------------------- |  
-| v0.1.0-beta | Basic syntax release                         | 2023-05               |  
-| v0.2.0-beta | Type system/Basic syntax refinement          | 2023-07               |  
-| v0.3.0-beta | Package management/Basic syntax refinement   | 2023-09               |  
-| v0.4.0-beta | Small test cases/Basic standard library      | 2023-11               |  
-| v0.5.0-beta | LSP development/Core syntax refinement       | 2024-02               |  
-| v0.6.0-beta | Medium test cases/bug fixes                  | 2024-04               |  
-| v0.7.0      | Large test cases/Stable syntax API           | 2024-07               |  
-| v0.8.0+     | Preparations for the official release        | 2024-09               |  
-| v1.0.0      | Official release                             | 2025-                 |  
-
-Current version: 0.4.0-beta. Key functionalities still being planned will be gradually integrated in upcoming versions.
-
-- Integration and optimization of essential syntaxes like switch/try
-- wasm architecture compilation
-- Coroutine support
-- Compilation for the darwin system
-- Function tags support
-- Progressive GC refinement
-- riscv architecture compilation
-- Compilation for the windows system
-
-## 🧭 Design Philosophy
-
-In programming languages, there's a notion of first-class citizens. For example, in JavaScript, functions are the first-class citizens. Although in nature, functions can also be passed as values and have higher-order usages, they aren't its first-class citizens. So, what's most important for nature?
-
-Compilation speed? Execution speed? Safety? Simplicity? None of these. Even though we aim for simplicity, we won't compromise on developer convenience.
-
-For nature, the developer is paramount. We prioritize offering convenience, ensuring the code is aesthetically pleasing and intuitive. That's not to say nature doesn't provide fast compilation/execution, safety, simplicity, etc. We aim to balance these attributes with user-friendliness. However, when conflicts arise, the developer's convenience takes precedence.
-
-For instance, despite most strong-typed languages opting for double quotes for standard strings, we chose single quotes to save a shift input, reducing strain on the pinky and offering a more concise read. The omission of brackets in 'if' and 'for' also stems from this principle.
-
-Nature rarely introduces new syntactic sugar. Instead, we often choose already-existing, widely-recognized syntactic sugar from other languages, easing the learning curve and mental load for developers. Keyword abbreviations also follow popular abbreviations, e.g., i8 instead of int8_t, fn instead of func/function. fn is a common keystroke, and Rust has already popularized fn/i8, hence it drastically reduces potential misunderstandings and learning burdens.
-
 ## 🍺 Contribution Guide
 
 There are many ways to contribute to nature: reporting BUGs, sharing ideas, participating in community discussions, coding, improving documentation, establishing standards, contributing resources, donations, and more.
@@ -123,145 +78,7 @@ Github Discussion Community: [https://github.com/nature-lang/nature/discussions]
 
 ## 🍼 Coding Example
 
-Error Handling:
-
-```rust
-type test = struct {
-    [i8] list
-    var div = fn(int a, int b):int {
-        if b == 0 {
-            throw 'divisor cannot be zero'
-        }
-        return a / b
-    }
-}
-
-var t = test {
-    list = [1, 2, 3, 4, 5]
-}
-
-var (item, err) = try t.list[8]
-if err.has {
-    println("chain access list error=", err.msg)
-}
-
-var (_, err) = try t.div(10, 0)
-if err.has {
-    println("division error", err.msg)
-}
-```
-
-Generics:
-
-```rust
-// generic fn
-type numbert = gen i8|i16|i32|i64|u8|u16|u32|u64|f32|f64
-
-fn sum(numbert a, numbert b):numbert {
-    return a + b
-}
-fn cmp(numbert a, numbert b):bool {
-    return a > b
-}
-
-// type param
-type box<t> = struct {
-    t width
-    t length
-    var area = fn(self s):t {
-        return s.width * s.length
-    }
-}
-
-fn run() {
-    var b = box<i8> {
-        width = 5,
-        length = 10
-    }
-    println('self area=', b.area())
-}
-
-```
-
-Union Types:
-
-```rust
-type nullable<t> = t|null
-
-nullable<i8> foo = 24
-if foo is null {
-    // logic...
-    return
-}
-
-// x println(foo + 12), foo is a union type, cannot use binary
-
-let foo as i8
-println(foo + 12)
-```
-
-Function Tags:
-
-```java
-@local @retry=5 
-@test 24, 10 -> 4
-@test -5, 10 -> -5
-fn rem(int dividend, int divisor):int {
-    if divisor == 0 {
-        throw 'divisor cannot be zero'
-    }
-    return dividend % divisor
-}
-
-@global @post increase_views
-fn read_blog():int {
-    // logic ...
-}
-
-@comment Based on label prompt + test for automatic code generation testing
-@prompt sum up a and b
-@test 12, 13 -> 25
-@test -5, 10 -> 5
-fn sum(int a, int b):int {}
-```
-
-HTTP Server:
-
-```js
-import http
-import http.router
-import http.resp
-
-var app = http.server()
-
-router.get('/', fn(ctx):resp {
-    return resp.string('hello world')
-})
-
-app.use(router).listen('127.0.0.1', 8000)
-```
-
-For more coding examples 👉 [cases](https://github.com/nature-lang/nature/tree/master/tests/blackbox/cases)
-
-## 📌 FAQ
-
-1.Does nature use type prefix or suffix?
-
-Nature consistently uses type prefixing, including the return type of functions. A primitive design example:
-
-`fn sum(int a, int b):int c` shows that the function return type also uses type prefixing. Omitting all idents can lead to the function type declaration `fn(int,int):int`. Typically, the return value's ident also needs to be omitted, resulting in the formal function declaration `fn sum(int a, int b):int {}`.
-
-2.What is the meaning of nature/logo?
-
-The logo represents a spaceship, symbolizing the "Natural Selection" ship from "Three-Body". The name "nature" is derived from this.
-
-3.Why isn't there any performance testing and comparison?
-
-Nature is currently in its beta phase focusing on core functionality development. There hasn't been any optimization done on the compiler backend. Hence, performance testing would be unfair and meaningless.
-
-4.How long has nature been in development?
-
-The main repository has been under development for almost 3 years. The actual time invested is close to 6 years. What I want to emphasize is that the Nature project won't be abandoned arbitrarily and will be continuously developed and maintained with vitality.
+coding examples 👉 [cases](https://github.com/nature-lang/nature/tree/master/tests/cases)
 
 ## 🪶 License