grrr

Author: sharpchen

docs/document/Articles/docs/Language Thoughts.md

@@ -29,7 +29,7 @@ impl Foo {
 
 ## Conversion operator
 
-Should happens between nonminal types.
+Should happens between nominal types.
 
 ```ts
 let foo = Foo {} as Bar
@@ -87,8 +87,6 @@ It should offer benefits:
 - If each unit type is nominal, we will have `m*m` conversion explosion.
 - Another way is extension upon the data type, but it's just a problem of form.
 
-
-
 ```ts
 let foo = 360deg
 let bar = 6.28rad // for literal
@@ -160,3 +158,54 @@ type Foo = {
 }
 type Bar = Foo with { foo: double, baz: any } // [!code highlight] 
 ```
+
+## Constant members
+
+Constants as special members, including functions and fields.
+
+```ts
+// should be evaluated at compile-time
+function foo(): const string { // implies the function returns const
+    return "I am an constant"
+}
+
+type Foo {
+    foo: const string = foo() // only constant can be assigned from an constant generator function
+    bar: const string = "I am also an constant"
+    fn = (): const string => "foo"
+}
+
+_ = Foo::foo // use :: to access constant members
+_ = Foo::fn() // this evaluates to an constant too
+
+```
+
+### Reflection constants
+
+Some reflection properties should be just constants.
+Any type should have some default constant members like `name`, `fullName`, `namespace`(if we do plan to design the module system like this)
+Which means they're preserved constants.
+
+```ts
+
+type Bar {
+    typeName: any  // preserved member name can not be set // [!code error] 
+}
+// Use `::` as constant accessor.
+_ = Foo::typeName // -> `Foo`
+_ = Bar::name
+```
+
+## Default parameter mutation
+
+```ts
+type Person {
+    name: string
+    age: uint
+}
+function foo(arg: Person = { name = "John", age = 18 }): void {
+
+}
+// use `default` to represent the default value of the parameter
+foo(default with { name = "jane" })
+```

docs/document/Articles/docs/String nature in .NET.md

@@ -8,7 +8,7 @@ In .NET, the string pool (also known as the intern pool) is a special area of me
 
 We are able to mutate the string in pool in `unsafe` block to demonstrate this characteristic.
 
-```c#
+```cs
 string text = "abc";
 
 unsafe 
@@ -26,7 +26,7 @@ Console.Write("abc"); // dbc
 For string from external resources, we may need to registered it into string pool using `string.Intern(str: string): string`.
 This approach is the same as declaring a string literal, they will all exist during application domain.
 
-```c#
+```cs
 string url = /* ... */;
 HttpResponseMessage response = await httpClient.GetAsync(url);
 string responseBody = await response.Content.ReadAsStringAsync();