Refactor: Replace documentation text with placeholders

index.html

@@ -53,9 +53,7 @@
           const mdContent=`
 # A corely symbolic language
 
-**Hi** is a programming language inspired by JavaScript, designed with a symbolic core to be more universal, AI-friendly, and conducive to code golfing. The syntax prioritizes symbols over keywords.
+[placeholder topic]
-
-The underscore \`_\` is the global output function.
 
 \`\`\`javascript
 _("Hi world")
@@ -63,10 +61,7 @@ _("Hi world")
 
 ## Declaration and Assignment
 
-Variable lifecycle is split into two distinct symbolic operations.
+[placeholder topic]
-
-- \`:\` **Declaration**: Binds a name in the current scope.
-- \`=\` **Assignment**: Reassigns the value of an existing name.
 
 \`\`\`javascript
 version: 1.0 // Declaration and initialization
@@ -75,10 +70,10 @@ version = 1.1 // Assignment
 
 ## Unifying Objects, Functions, and Classes
 
-The **Block** (\`{}\`) is Hi's foundational structure, unifying objects and functions.
+[placeholder topic]
 
 ### As a Data Structure (Object)
-A block can hold \`key: value\` pairs. A \`#\` prefix denotes a private property.
+[placeholder topic]
 
 \`\`\`javascript
 player: {
@@ -91,7 +86,7 @@ _(player.hp)   // ~0 (null) because #hp is private
 \`\`\`
 
 ### As Executable Code (Function)
-Invoking a block with \`()\` executes its expressions. The value of the last expression is implicitly returned.
+[placeholder topic]
 
 \`\`\`javascript
 // Simple invocation
@@ -104,7 +99,7 @@ _(add(2, 3)) // Prints 5
 \`\`\`
 
 ### As a Hybrid (Factory/Class)
-A block can contain both data and logic. When invoked, its internal declarations are re-initialized, making it a natural factory. The context symbol \`@\` can be used to return the newly created instance.
+[placeholder topic]
 
 \`\`\`javascript
 createPlayer: (name) {
@@ -119,7 +114,7 @@ _(player1.hp)   // 100
 \`\`\`
 
 ### Expression Separators
-Newlines act as implicit separators. Commas (\`,\`) or semicolons (\`;\`) are required for single-line blocks.
+[placeholder topic]
 
 \`\`\`javascript
 // Multi-line
@@ -134,9 +129,7 @@ point: { x: 10, y: 20 }
 
 ## Arrow Expressions
 
-For concise single-expression functions, Hi provides the \`=>\` arrow syntax, inspired by JavaScript. It serves as a shorthand for a Block that immediately returns an expression, making it ideal for callbacks and functional patterns.
+[placeholder topic]
-
-It's a direct replacement for \`(params) { ^ expression }\`.
 
 \`\`\`javascript
 // Standard block
@@ -153,17 +146,11 @@ _(doubled) // [2, 4, 6]
 
 ## Booleans and Equality
 
-Hi dispenses with boolean keywords in favor of canonical numeric values for truthiness.
+[placeholder topic]
-
-- \`0\` is **falsy** (the canonical false).
-- \`!0\` is **truthy** (the canonical true, representing a logical NOT 0).
-- \`???\` represents null/undefined values.
-- All other numbers, and any non-empty string, block, or array are "truthy".
-- The \`==\` operator performs strict equality comparison (equivalent to JavaScript's \`===\`).
 
 ## Conditional Expressions
 
-Hi uses a single ternary-like expression for all conditional logic. The simplest form acts like a standard \`if\` statement.
+[placeholder topic]
 
 \`\`\`javascript
 // A simple 'if' to execute code conditionally
@@ -171,7 +158,7 @@ status: "active"
 (status == "active") ? { _("User is active.") }
 \`\`\`
 
-You can provide an \`else\` branch using the colon (\`:\`) symbol to choose between two actions.
+[placeholder topic]
 
 \`\`\`javascript
 // if / else for choosing an action
@@ -179,14 +166,14 @@ isOnline: !0
 (isOnline == !0) ? { _("Online") } : { _("Offline") } // Prints "Online"
 \`\`\`
 
-This structure is powerful because it's an *expression* that always evaluates to a value. The value of the executed block becomes the value of the entire expression, allowing you to assign the result directly to a variable.
+[placeholder topic]
 
 \`\`\`javascript
 // if / else returning a value
 result: (1 > 2) ? { "A" } : { "B" } // result is "B"
 \`\`\`
 
-Expressions can be chained to create \`if / else if / else\` logic.
+[placeholder topic]
 
 \`\`\`javascript
 // if / else if / else
@@ -198,12 +185,12 @@ grade: (score >= 90) ? { "A" }
 _(grade) // Prints "C"
 \`\`\`
 
-If a condition is false and no \`else\` branch is provided, the expression evaluates to \`~0\` (null). 
+[placeholder topic]
 
 ## Data Structures
 
 ### Arrays
-Arrays are 0-indexed lists of values. They support random access via \`[]\` and are iterable.
+[placeholder topic]
 
 \`\`\`javascript
 primes: [2, 3, 5, 7]
@@ -213,7 +200,7 @@ _(primes)     // Mutation: [1, 3, 5, 7]
 \`\`\`
 
 ### Strings
-Strings are sequences of characters. They are immutable but support random access and iteration.
+[placeholder topic]
 
 \`\`\`javascript
 greeting: "Hi"
@@ -222,11 +209,7 @@ _(greeting[1]) // "i"
 
 ## Destructuring
 
-Destructuring provides an expressive way to extract data from Blocks and Arrays. The extraction operator \`->\` is used to unpack values, mirroring its use in module imports.
+[placeholder topic]
-
-- \`source -> { pattern }\`: Extracts properties from a Block.
-- \`source -> [ pattern ]\`: Extracts elements from an Array.
-- \`prop -> alias\`: The same operator is used within the pattern for aliasing.
 
 \`\`\`javascript
 // Setup
@@ -248,10 +231,10 @@ _(y) // -5
 
 ## Repetition
 
-Repetition is handled by a unified iteration protocol: \`(source -> pattern) * { ... }\`. This single, concise syntax adapts to iterate over any collection type.
+[placeholder topic]
 
 ### Iterating Collections
-The \`->\` operator extracts elements from a source into a pattern.
+[placeholder topic]
 
 \`\`\`javascript
 // Iterate over an Array's values
@@ -272,7 +255,7 @@ users: [{ name: "Orion" }]
 \`\`\`
 
 ### Numeric Ranges
-The \`..\` operator creates an iterable numeric range for concise, traditional loops.
+[placeholder topic]
 
 \`\`\`javascript
 // A range from 0 up to (but not including) 3
@@ -282,10 +265,7 @@ The \`..\` operator creates an iterable numeric range for concise, traditional l
 \`\`\`
 
 ### Loop Control
-Control flow within loops is managed by distinct symbols:
+[placeholder topic]
-- \`><\`: **Break**. Immediately terminates the loop.
-- \`>>\`: **Continue**. Skips to the next iteration.
-- \`^\`: **Return**. Exits the parent block, not just the loop.
 
 \`\`\`javascript
 (0..10 -> i) * {
@@ -298,7 +278,7 @@ Control flow within loops is managed by distinct symbols:
 
 ## Imports
 
-Modules are imported using the \`+\` and \`->\` operators. This allows for destructuring and aliasing of imported members. Placing the module source first allows development tools to provide immediate, context-aware autocompletion for the members being imported—a direct ergonomic improvement over JavaScript's syntax.
+[placeholder topic]
 
 \`\`\`javascript
 // Import 'block1' and 'block2' (as 'alias2') from a module
@@ -310,7 +290,7 @@ alias2("some value")
 
 ## Context Reference: @
 
-The \`@\` symbol provides a reference to the current execution context, similar to \`this\` in JavaScript. This allows a Block to refer to the object it was called on, making methods portable and reusable.
+[placeholder topic]
 
 \`\`\`javascript
 // This block is a portable method.
@@ -328,12 +308,7 @@ item.log() // Prints "ID is: abc-789" (@ is 'item')
 
 ## Expression Blocks and Fluent Chaining
 
-Hi adopts an expression-oriented design, similar to Rust. Every **Block** is an expression that yields a value.
+[placeholder topic]
-
-- The value of the *last expression* in a Block is implicitly returned.
-- To return early or explicitly, use the return symbol \`^\`.
-
-This makes code more concise by eliminating the need for explicit \`return\` keywords in most cases.
 
 \`\`\`javascript
 // The last expression, \`a + b\`, is returned.
@@ -353,7 +328,7 @@ check: (n) {
 
 ### Fluent Chaining
 
-To enable fluent method chaining, Hi adds one special rule: if the last expression in a block produces no value (e.g., an assignment), the block returns its own context (\`@\`) by default. This allows subsequent method calls on the same object.
+[placeholder topic]
 
 \`\`\`javascript
 calculator: {
@@ -369,63 +344,6 @@ result: calculator.add(10).sub(4).get()
 _(result) // Prints 6
 \`\`\`
 
-## Core Language Blueprint
-
-To create the initial Hi-to-JS transpiler, the following primitives and built-in functionalities must be defined. This serves as the blueprint for the core standard library.
-
-### Built-in Definitions Table
-
-| Type | Name / Symbol | Description | Example |
-| :--- | :--- | :--- | :--- |
-| **Global** | \`_\` | The global output function. Transpiles to \`console.log\`. | \`_("hello")\` |
-| **Global** | \`Math\` | A global block containing mathematical constants and functions. | \`_(Math.PI)\` |
-| | | | |
-| **Number** | \`.str()\` | Converts the number to its string representation. | \`age: 21; _(age.str())\` |
-| **Number** | \`.fix(d)\` | Formats a number using fixed-point notation. | \`n: 3.14159; _(n.fix(2)) // "3.14"\` |
-| | | | |
-| **String** | \`.len\` | **Property**: Returns the number of characters in the string. | \`"hi".len // 2\` |
-| **String** | \`.num()\` | Parses the string, returning a number. | \`"42".num() // 42\` |
-| **String** | \`.upper()\` | Returns the string converted to uppercase. | \`"hi".upper() // "HI"\` |
-| **String** | \`.lower()\` | Returns the string converted to lowercase. | \`"HI".lower() // "hi"\` |
-| **String** | \`.trim()\` | Removes whitespace from both ends of a string. | \`" hi ".trim() // "hi"\` |
-| **String** | \`.split(d)\` | Divides a string into an ordered list of substrings. | \`"a-b-c".split("-") // ["a","b","c"]\` |
-| **String** | \`.slice(s,e)\`| Extracts a section of a string and returns it as a new string. | \`"hello".slice(1,3) // "el"\` |
-| **String** | \`.has(sub)\`| Determines whether a string contains a given substring. | \`"hi".has("i") // !0 (true)\` |
-| **String** | \`.replace(f,r)\` | Replaces the first occurrence of a substring. | \`"hi hi".replace("i","o") // "ho hi"\` |
-| **String** | \`.replaceAll(f,r)\` | Replaces all occurrences of a substring. | \`"hi hi".replaceAll("i","o") // "ho ho"\` |
-| | | | |
-| **Array** | \`.len\` | **Property**: Returns the number of elements in the array. | \`[1,2].len // 2\` |
-| **Array** | \`.add(v)\` | Adds one or more elements to the end of an array. | \`a:[1]; a.add(2) // a is now [1,2]\` |
-| **Array** | \`.pop()\` | Removes the last element from an array and returns it. | \`a:[1,2]; a.pop() // returns 2\` |
-| **Array** | \`.pre(v)\` | Adds one or more elements to the beginning of an array. | \`a:[2]; a.pre(1) // a is now [1,2]\` |
-| **Array** | \`.shift()\` | Removes the first element from an array and returns it. | \`a:[1,2]; a.shift() // returns 1\` |
-| **Array** | \`.each(fn)\` | Executes a provided function once for each array element. | \`[1,2].each((n)=>{_(n)})\` |
-| **Array** | \`.map(fn)\` | Creates a new array with the results of calling a function on every element. | \`[1,2].map((n)=>n*2) // [2,4]\` |
-| **Array** | \`.filter(fn)\` | Creates a new array with all elements that pass the test implemented by the provided function. | \`[1,2,3].filter((n)=>n>1) // [2,3]\` |
-| **Array** | \`.reduce(fn,iv)\`| Executes a reducer function on each element, resulting in a single output value. | \`[1,2,3].reduce((a,c)=>a+c, 0) // 6\` |
-| **Array** | \`.find(fn)\` | Returns the first element in the array that satisfies the provided testing function. | \`[1,2].find((n)=>n>1) // 2\` |
-| **Array** | \`.has(v)\` | Determines whether an array includes a certain value. | \`[1,2].has(2) // !0 (true)\` |
-| **Array** | \`.join(d)\` | Joins all elements of an array into a string. | \`["a","b"].join("-") // "a-b"\` |
-| **Array** | \`.slice(s,e)\`| Returns a shallow copy of a portion of an array into a new array object. | \`[1,2,3].slice(1) // [2,3]\` |
-| **Array** | \`.reverse()\`| Reverses an array in place. | \`a:[1,2]; a.reverse() // a is [2,1]\` |
-| **Array** | \`.sort(fn)\` | Sorts the elements of an array in place. | \`[3,1,2].sort() // [1,2,3]\` |
-| | | | |
-| **Block** | \`.keys()\` | Returns an array of a given block's own property names. | \`{a:1}.keys() // ["a"]\` |
-| **Block** | \`.values()\` | Returns an array of a given block's own property values. | \`{a:1}.values() // [1]\` |
-| **Block** | \`.has(key)\` | Checks if a block has a specified property as its own. | \`{a:1}.has("a") // !0 (true)\` |
-| | | | |
-| **Math** | \`.PI\` | **Property**: Ratio of a circle's circumference to its diameter. | \`Math.PI // 3.14159...\` |
-| **Math** | \`.abs(n)\` | Returns the absolute value of a number. | \`Math.abs(-5) // 5\` |
-| **Math** | \`.floor(n)\` | Returns the largest integer less than or equal to a number. | \`Math.floor(5.9) // 5\` |
-| **Math** | \`.ceil(n)\` | Returns the smallest integer greater than or equal to a number. | \`Math.ceil(5.1) // 6\` |
-| **Math** | \`.round(n)\` | Returns the value of a number rounded to the nearest integer. | \`Math.round(5.5) // 6\` |
-| **Math** | \`.max(a,b,..)\`| Returns the largest of the given numbers. | \`Math.max(1,5,2) // 5\` |
-| **Math** | \`.min(a,b,..)\`| Returns the smallest of the given numbers. | \`Math.min(1,5,2) // 1\` |
-| **Math** | \`.pow(b,e)\` | Returns base to the exponent power. | \`Math.pow(2,3) // 8\` |
-| **Math** | \`.sqrt(n)\` | Returns the square root of a number. | \`Math.sqrt(9) // 3\` |
-| **Math** | \`.rand()\` | Returns a pseudo-random number between 0 and 1. | \`Math.rand() // e.g., 0.123...\` |
-
-
 ---
 
 <p class="text-sm text-gray-600">Hi is in early development. The syntax and features are subject to change.</p>