@mojir/dvala 0.0.30 → 0.0.32

package/README.md

@@ -41,7 +41,7 @@ $ dvala
 
 # Evaluate Dvala code directly
 $ dvala eval "5 + 3"
-$ dvala eval "[1, 2, 3, 4] filter odd? map inc"
+$ dvala eval "[1, 2, 3, 4] filter isOdd map inc"
 
 # Run a Dvala file
 $ dvala run script.dvala
@@ -184,7 +184,7 @@ rest(numbers);                 // => [2, 3, 4, 5]
 
 // Functional array operations
 numbers map -> $ * 2;      // => [2, 4, 6, 8, 10]
-numbers filter odd?;           // => [1, 3, 5]
+numbers filter isOdd;           // => [1, 3, 5]
 ```
 
 #### Vectors (Number Arrays)
@@ -194,7 +194,7 @@ A vector is simply a non-empty array containing only numbers. The `vec` module p
 ```dvala
 // Import vector and linear algebra modules
 let vec = import(vector);
-let lin = import(linear-algebra);
+let lin = import(linearAlgebra);
 
 // Vectors are just number arrays
 [1, 2, 3, 4, 5];              // This is a vector
@@ -210,30 +210,30 @@ repeat(3.14, 4);               // => [3.14, 3.14, 3.14, 3.14]
 
 // Vector mathematical operations (use lin module for vector math)
 lin.dot([1, 2, 3], [4, 5, 6]);      // => 32 (dot product)
-lin.euclidean-norm([3, 4]);         // => 5.0 (Euclidean norm/magnitude)
-lin.normalize-l2([3, 4]);           // => [0.6, 0.8] (unit vector)
-lin.euclidean-distance([0, 0], [3, 4]); // => 5.0 (Euclidean distance)
-
-// Vector statistical operations (sum, mean, median, prod are core built-ins)
-sum([1, 2, 3, 4]);             // => 10
-mean([1, 2, 3, 4]);            // => 2.5
-median([1, 2, 3, 4, 5]);       // => 3
+lin.euclideanNorm([3, 4]);         // => 5.0 (Euclidean norm/magnitude)
+lin.normalizeL2([3, 4]);           // => [0.6, 0.8] (unit vector)
+lin.euclideanDistance([0, 0], [3, 4]); // => 5.0 (Euclidean distance)
+
+// Vector statistical operations (in the vector module)
+vec.sum([1, 2, 3, 4]);         // => 10
+vec.mean([1, 2, 3, 4]);        // => 2.5
+vec.median([1, 2, 3, 4, 5]);   // => 3
 vec.stdev([1, 2, 3, 4]);       // => 1.29... (standard deviation)
 vec.variance([1, 2, 3, 4]);    // => 1.67... (variance)
 
 // Vector analysis (min and max are core built-ins)
 min([3, 1, 4, 1, 5]); // => 1
 max([3, 1, 4, 1, 5]); // => 5
-vec.min-index([3, 1, 4]);      // => 1 (index of minimum)
-vec.max-index([3, 1, 4]);      // => 2 (index of maximum)
+vec.minIndex([3, 1, 4]);      // => 1 (index of minimum)
+vec.maxIndex([3, 1, 4]);      // => 2 (index of maximum)
 
 // Cumulative operations
 vec.cumsum([1, 2, 3, 4]);      // => [1, 3, 6, 10]
 vec.cumprod([1, 2, 3, 4]);     // => [1, 2, 6, 24]
 
 // Vector predicates
-vec.increasing?([1, 1, 2, 3, 4]);          // => true
-vec.strictly-increasing?([1, 1, 2, 3, 4]); // => false
+vec.isIncreasing([1, 1, 2, 3, 4]);          // => true
+vec.isStrictlyIncreasing([1, 1, 2, 3, 4]); // => false
 
 // Structural equality works with all vectors
 [1, 2, 3] == [1, 2, 3];       // => true
@@ -270,20 +270,20 @@ mat.vandermonde([1, 2, 3]);    // => Vandermonde matrix from vector
 mat.band(4, 1, 1);             // => 4x4 band matrix
 
 // Matrix properties and predicates
-mat.symmetric?([[1, 2], [2, 1]]);    // => true
-mat.invertible?([[1, 2], [3, 4]]);   // => true
-mat.square?([[1, 2], [3, 4]]);       // => true
-mat.diagonal?([[1, 0], [0, 2]]);     // => true
-mat.identity?([[1, 0], [0, 1]]);     // => true
+mat.isSymmetric([[1, 2], [2, 1]]);    // => true
+mat.isInvertible([[1, 2], [3, 4]]);   // => true
+mat.isSquare([[1, 2], [3, 4]]);       // => true
+mat.isDiagonal([[1, 0], [0, 2]]);     // => true
+mat.isIdentity([[1, 0], [0, 1]]);     // => true
 
 // Advanced matrix operations
 mat.adj(matrixA);              // => [[4, -2], [-3, 1]] (adjugate)
 mat.cofactor(matrixA);         // => cofactor matrix
 mat.minor(matrixA, 0, 1);      // => minor by removing row 0, col 1
-mat.frobenius-norm(matrixA);   // => Frobenius norm
-mat.one-norm(matrixA);         // => 1-norm (max column sum)
-mat.inf-norm(matrixA);         // => infinity norm (max row sum)
-mat.max-norm(matrixA);         // => max norm (largest absolute element)
+mat.frobeniusNorm(matrixA);   // => Frobenius norm
+mat.oneNorm(matrixA);         // => 1-norm (max column sum)
+mat.infNorm(matrixA);         // => infinity norm (max row sum)
+mat.maxNorm(matrixA);         // => max norm (largest absolute element)
 
 // Matrix analysis
 mat.rank(matrixA);             // => matrix rank
@@ -320,33 +320,33 @@ Dvala provides predicate functions to check data types at runtime:
 
 ```dvala
 // Basic type predicates
-number?(42);                   // => true
-string?("hello");              // => true
-boolean?(true);                // => true
-function?(x -> x * 2);         // => true
-regexp?(#"[a-z]+");            // => true
-array?([1, 2, 3]);             // => true
-object?({name: "Alice"});      // => true
-null?(null);                   // => true
+isNumber(42);                   // => true
+isString("hello");              // => true
+isBoolean(true);                // => true
+isFunction(x -> x * 2);         // => true
+isRegexp(#"[a-z]+");            // => true
+isArray([1, 2, 3]);             // => true
+isObject({name: "Alice"});      // => true
+isNull(null);                   // => true
 
 // Specialized array predicates
-vector?([1, 2, 3]);            // => true (non-empty number array)
-vector?([1, "hello", 3]);      // => false (mixed types)
-vector?([]);                   // => false (empty)
+isVector([1, 2, 3]);            // => true (non-empty number array)
+isVector([1, "hello", 3]);      // => false (mixed types)
+isVector([]);                   // => false (empty)
 
-matrix?([[1, 2], [3, 4]]);     // => true (2D number array, consistent rows)
-matrix?([[1, 2], [3]]);        // => false (inconsistent row lengths)
-matrix?([[]]);                 // => false (contains empty row)
+isMatrix([[1, 2], [3, 4]]);     // => true (2D number array, consistent rows)
+isMatrix([[1, 2], [3]]);        // => false (inconsistent row lengths)
+isMatrix([[]]);                 // => false (contains empty row)
 
 // Collection predicates
-sequence?([1, 2, 3]);           // => true (sequences: strings and arrays)
-sequence?("hello");             // => true
-sequence?({a: 1});              // => false
+isSequence([1, 2, 3]);           // => true (sequences: strings and arrays)
+isSequence("hello");             // => true
+isSequence({a: 1});              // => false
 
-collection?([1, 2, 3]);         // => true (collections: strings, arrays, objects)
-collection?("hello");           // => true
-collection?({a: 1});            // => true
-collection?(42);                // => false
+isCollection([1, 2, 3]);         // => true (collections: strings, arrays, objects)
+isCollection("hello");           // => true
+isCollection({a: 1});            // => true
+isCollection(42);                // => false
 ```
 
 #### Type Hierarchy
@@ -356,19 +356,19 @@ The type predicates follow a logical hierarchy:
 ```dvala
 // If something is a matrix, it's also a vector and an array
 let mat = [[1, 2], [3, 4]];
-matrix?(mat);                  // => true
-vector?(mat);                  // => true (matrix is a special vector)
-array?(mat);                   // => true (vector is a special array)
+isMatrix(mat);                  // => true
+isVector(mat);                  // => true (matrix is a special vector)
+isArray(mat);                   // => true (vector is a special array)
 
 // If something is a vector, it's also an array
 let vec = [1, 2, 3];
-vector?(vec);                  // => true
-array?(vec);                   // => true
+isVector(vec);                  // => true
+isArray(vec);                   // => true
 
 // But not all arrays are vectors
 let arr = [1, "hello", 3];
-array?(arr);                   // => true
-vector?(arr);                  // => false (contains non-numbers)
+isArray(arr);                   // => true
+isVector(arr);                  // => false (contains non-numbers)
 ```
 
 Each data type is immutable by design - operations return new values rather than modifying existing ones, ensuring predictable behavior and easier reasoning about code.
@@ -379,15 +379,11 @@ Dvala provides predefined mathematical constants:
 
 ```dvala
 PI;    // => 3.141592653589793
-π;     // => 3.141592653589793 (Unicode alternative)
 E;     // => 2.718281828459045 (Euler's number)
-ε;     // => 2.718281828459045 (Unicode alternative)
 PHI;   // => 1.618033988749895 (Golden ratio)
-φ;     // => 1.618033988749895 (Unicode alternative)
 
 // Infinity values
 POSITIVE_INFINITY; // => Infinity
-∞;                 // => Infinity (Unicode alternative)
 NEGATIVE_INFINITY; // => -Infinity
 
 // Integer and float limits
@@ -562,10 +558,10 @@ let square = x -> x * x;
 let constant = () -> 42;
 
 // Positional arguments
-let add-v2 = -> $1 + $2;
+let addV2 = -> $ + $2;
 
 // Single positional argument
-let square-v2 = -> $ * $;
+let squareV2 = -> $ * $;
 
 // Self-reference for recursion
 let factorial = n ->
@@ -578,7 +574,7 @@ let factorial = n ->
 
 ### Control Flow
 
-#### If/Unless
+#### If
 
 ```dvala
 let x = 15; // Fixed value for compilation
@@ -594,9 +590,9 @@ end;
 if false then "never" end;
 // => null
 
-// Unless (inverted if)
+// Negated condition
 let y = 8;
-unless y > 10 then
+if not(y > 10) then
   "small"
 else
   "large"
@@ -604,28 +600,26 @@ end;
 // => "small"
 ```
 
-#### Cond
+#### If / Else If
 
 ```dvala
 let x = 12;
 
 // Multi-branch conditional
-cond
-  case x < 5 then "small"
-  case x < 10 then "medium"
-  case x < 15 then "large"
-  case true then "extra large" // default case
+if x < 5 then "small"
+else if x < 10 then "medium"
+else if x < 15 then "large"
+else "extra large" // default case
 end;
 // => "large"
 
-// Cond with complex conditions
+// If/else if with complex conditions
 let urgent = true;
 let important = false;
-let priority = cond
-  case urgent && important then "critical"
-  case urgent then "high"
-  case important then "medium"
-  case true then "low"
+let priority = if urgent && important then "critical"
+  else if urgent then "high"
+  else if important then "medium"
+  else "low"
 end;
 // => "high"
 ```
@@ -667,7 +661,7 @@ for (x in [1, 2, 3, 4]) -> x * 2;
 // => [2, 4, 6, 8]
 
 // With filtering (when clause)
-for (x in [1, 2, 3, 4] when odd?(x)) -> x * 2;
+for (x in [1, 2, 3, 4] when isOdd(x)) -> x * 2;
 // => [2, 6]
 
 // With early termination (while clause)
@@ -701,12 +695,12 @@ for (entry in { a: 1, b: 2 } let [key, value] = entry) -> key ++ ":" ++ str(valu
 // => ["a:1", "b:2"]
 ```
 
-#### Doseq (Side Effects)
+#### For with Side Effects
 
 ```dvala
-// For side effects only (returns null)
-doseq (x in [1, 2, 3]) -> perform(effect(dvala.io.println), x)
-// Prints: 1 2 3, returns null
+// For can also be used for side effects
+for (x in [1, 2, 3]) -> perform(@dvala.io.print, x)
+// Prints: 1 2 3, returns [null, null, null]
 ```
 
 #### Loop (Tail Recursion)
@@ -714,7 +708,7 @@ doseq (x in [1, 2, 3]) -> perform(effect(dvala.io.println), x)
 ```dvala
 // Loop with recur for tail recursion
 loop (n = 5, acc = 1) -> do
-  if zero?(n) then
+  if isZero(n) then
     acc
   else
     recur(n - 1, acc * n)
@@ -724,7 +718,7 @@ end;
 
 // Complex loop with multiple variables
 loop (items = [1, 2, 3, 4, 5], acc = 0, cnt = 0) -> do
-  if empty?(items) then
+  if isEmpty(items) then
     { sum: acc, average: acc / cnt }
   else
     recur(rest(items), acc + first(items), cnt + 1)
@@ -748,7 +742,7 @@ end;
 
 // Tail-recursive function
 let sumToN = (n, acc = 0) -> do
-  if zero?(n) then
+  if isZero(n) then
     acc
   else
     recur(n - 1, acc + n)
@@ -758,59 +752,66 @@ end;
 
 ### Error Handling
 
-#### Do/With Effect Handlers
+#### Handle/With Effect Handlers
 
 ```dvala
-// Basic error handling with do/with
-let riskyOperation = () -> perform(effect(dvala.error), "Something went wrong");
-do
+// Basic error handling with handle/with
+let riskyOperation = () -> perform(@dvala.error, "Something went wrong");
+handle
   riskyOperation()
-with
-  case effect(dvala.error) then (args) -> "Something went wrong"
-end;
+with [(arg, eff, nxt) ->
+  if eff == @dvala.error then "Something went wrong"
+  else nxt(eff, arg)
+  end
+] end;
 
 // With error message binding
-do
+handle
   riskyOperation()
-with
-  case effect(dvala.error) then ([msg]) -> "Error: " ++ msg
-end;
+with [(arg, eff, nxt) ->
+  if eff == @dvala.error then "Error: " ++ arg
+  else nxt(eff, arg)
+  end
+] end;
 
 // Error handling for graceful degradation
 let parseData = () -> { value: 42 };
 let process = (val) -> val * 2;
-do
+handle
   let { value } = parseData();
   process(value)
-with
-  case effect(dvala.error) then (args) -> "Using default value"
-end;
+with [(arg, eff, nxt) ->
+  if eff == @dvala.error then "Using default value"
+  else nxt(eff, arg)
+  end
+] end;
 ```
 
 #### Raising Errors
 
 ```dvala
 // Raising errors
-do
-  perform(effect(dvala.error), "Custom error message")
-with
-  case effect(dvala.error) then (args) -> "Caught an error"
-end;
+handle
+  perform(@dvala.error, "Custom error message")
+with [(arg, eff, nxt) ->
+  if eff == @dvala.error then "Caught an error"
+  else nxt(eff, arg)
+  end
+] end;
 
 // Custom error messages in functions
 let divide = (a, b) ->
-  if zero?(b) then
-    perform(effect(dvala.error), "Cannot divide by zero")
+  if isZero(b) then
+    perform(@dvala.error, "Cannot divide by zero")
   else
     a / b
   end;
 
 // Conditional error raising
 let validateAge = (age) ->
-  cond
-    case age < 0 then perform(effect(dvala.error), "Age cannot be negative")
-    case age > 150 then perform(effect(dvala.error), "Age seems unrealistic")
-    case true then age
+  if age < 0 then perform(@dvala.error, "Age cannot be negative")
+  else if age > 150 then perform(@dvala.error, "Age seems unrealistic")
+  else age
   end;
 ```
 
@@ -834,10 +835,10 @@ let loadData = () -> [1, 2, 3];
 let processData = (data) -> data map -> $ * 2;
 
 do
-  perform(effect(dvala.io.println), "Starting process...");
+  perform(@dvala.io.print, "Starting process...");
   let data = loadData();
   let processed = processData(data);
-  perform(effect(dvala.io.println), "Process completed");
+  perform(@dvala.io.print, "Process completed");
   processed
 end
 ```
@@ -854,8 +855,8 @@ end
 array(1, 2, 3, 4);
 
 // With spread
-let small-set = [3, 4, 5];
-[1, 2, ...small-set, 6];
+let smallSet = [3, 4, 5];
+[1, 2, ...smallSet, 6];
 // => [1, 2, 3, 4, 5, 6]
 ```
 
@@ -958,134 +959,61 @@ true || "never reached";  // => true
 ```dvala
 // Null coalescing operator
 null ?? "default";     // => "default"
-0 ?? "default";        // => 0 (only null/undefined are coalesced)
+0 ?? "default";        // => 0 (only null is coalesced)
 false ?? "default";    // => false
 "" ?? "default";       // => ""
 ```
 
-### Ternary Operator
+### Conditional Expression
 
 ```dvala
-// Conditional expression
+// Conditional expression (if/then/else/end)
 let age = 25;
-let result = age >= 18 ? "adult" : "minor";
+let result = if age >= 18 then "adult" else "minor" end;
 
-// Nested ternary
+// Nested conditional
 let score = 85;
-let category = score >= 90 ? "A" : score >= 80 ? "B" : "C";
+let category = if score >= 90 then "A" else if score >= 80 then "B" else "C" end;
 
 // With complex expressions
 let isLoggedIn = () -> true;
 let hasPermission = () -> true;
-let status = isLoggedIn() && hasPermission() ? "authorized" : "unauthorized";
+let status = if isLoggedIn() && hasPermission() then "authorized" else "unauthorized" end;
 ```
 
 ## Variable Names
 
-Dvala is generous with variable naming conventions, allowing a wide range of characters that would be invalid in many other programming languages.
+Dvala uses JavaScript-style identifiers for variable names.
 
 ### Basic Rules
 
-Variable names in Dvala can contain almost any character except for a small set of reserved symbols. The only restrictions are:
-
-**Illegal characters anywhere in a variable name:**
-- Parentheses: `(` `)`
-- Brackets: `[` `]`
-- Braces: `{` `}`
-- Quotes: `'` `"` `` ` ``
-- Punctuation: `,` `.` `;`
-- Whitespace: spaces, newlines, tabs
-
-**Additional restrictions for the first character:**
-- Cannot start with digits `0-9`
+Variable names must match the pattern `[a-zA-Z_$][a-zA-Z0-9_$]*`:
 
-### Unicode and Emoji Support
-
-Beyond these minimal restrictions, Dvala supports Unicode characters, including emojis, in variable names:
+- **First character:** a letter (`a-z`, `A-Z`), underscore (`_`), or dollar sign (`$`)
+- **Subsequent characters:** letters, digits (`0-9`), underscores, or dollar signs
 
 ```dvala
-// Unicode characters are welcome
-let résultat = 42;
-let naïve = "simple approach";
-let coöperation = "working together";
-
-// Emojis work too!
-let 😅 = "grinning face with sweat";
-let 🚀 = "rocket ship";
-let result = 😅 ++ " " ++ 🚀;
-// => "grinning face with sweat rocket ship"
+let userName = "alice";
+let isValid = true;
+let _private = 42;
+let $special = "dollar";
+let counter2 = 0;
 ```
 
 ### Quoted Variable Names
 
-For cases where you need to use the normally illegal characters in variable names, Dvala supports quoted variable names using single quotes:
+For cases where you need characters outside the normal rules, Dvala supports quoted variable names using single quotes:
 
 ```dvala
 // Variables with spaces and special characters
 let 'A strange variable' = 42;
 let 'user.name' = "John Doe";
 let 'data[0]' = "first element";
-let 'function()' = "callable";
 
 // Access them the same way
 'A strange variable' + 8;
 // => 50
 ```
-
-### Practical Examples
-
-Here are some examples showcasing the flexibility of Dvala variable naming:
-
-```dvala
-// Mathematical notation with Greek letters (avoiding reserved symbols)
-let α = 0.5;
-let β = 1.2;
-let γ = 2.0;
-let Δ = β - α;
-
-// Descriptive names with special characters
-let user-name = "alice";
-let is-valid? = true;
-let counter! = 0;
-
-// Mixed styles
-let dataSet₁ = [1, 2, 3];
-let dataSet₂ = [4, 5, 6];
-let 🔧config = { debug: true };
-```
-
-### Important: Operator Spacing
-
-Due to Dvala' flexible variable naming, **operators must be separated by whitespace**. This is crucial to understand:
-
-```dvala
-// This is a variable name, NOT addition!
-let x+1 = 42;
-let result1 = x+1;  // => 42
-
-// To perform addition, use spaces
-let x = 5;
-let result2 = x + 1;  // => 6
-
-// More examples of what looks like operations but are actually variable names
-let a-b = "subtraction variable";
-let c*d = "multiplication variable"; 
-let e/f = "division variable";
-let g<h = "comparison variable";
-
-// To use these as actual operations, add spaces
-let a = 10;
-let b = 3;
-let a-sum = a + b;      // Addition
-let a-diff = a - b;     // Subtraction
-let a-prod = a * b;     // Multiplication
-let a-quot = a / b;     // Division
-let a-comp = a < b;     // Comparison
-```
-
-Without whitespace, Dvala treats the entire sequence as a single variable identifier. This applies to all operators, including comparison operators, logical operators, and arithmetic operators.
-
-This flexibility allows for expressive and readable code while maintaining the functional programming paradigm that Dvala embodies.
 ## Operators and Functions
 
 ### Algebraic Notation
@@ -1248,10 +1176,10 @@ Dvala favors subject-first parameter order for better operator chaining:
 
 ```dvala
 // Function style
-filter([1, 2, 3, 4], odd?);  // => [1, 3]
+filter([1, 2, 3, 4], isOdd);  // => [1, 3]
 
 // Operator style (more readable)
-[1, 2, 3, 4] filter odd?;    // => [1, 3]
+[1, 2, 3, 4] filter isOdd;    // => [1, 3]
 ```
 
 ### Pipe Operator
@@ -1260,18 +1188,18 @@ The pipe operator `|>` passes the result of the left expression as the first arg
 
 ```dvala
 // Without pipe operator
-reduce(map(filter([1, 2, 3, 4, 5, 6], odd?), -> $ * $), +, 0);
+reduce(map(filter([1, 2, 3, 4, 5, 6], isOdd), -> $ * $), +, 0);
 
 // With pipe operator (much more readable)
 [1, 2, 3, 4, 5, 6]
-  |> filter(_, odd?)
+  |> filter(_, isOdd)
   |> map(_, -> $ * $)
   |> reduce(_, +, 0);
 // => 35
 
 // Simple transformations
 "hello world"
-  |> upper-case
+  |> upperCase
   |> split(_, " ")
   |> reverse
   |> join(_, "-");
@@ -1287,7 +1215,7 @@ reduce(map(filter([1, 2, 3, 4, 5, 6], odd?), -> $ * $), +, 0);
 // Data processing pipeline
 { numbers: [1, 2, 3, 4, 5], multiplier: 3 }
   |> get(_, "numbers")
-  |> filter(_, even?)
+  |> filter(_, isEven)
   |> map(_, *(_, 3))
   |> reduce(_, +, 0);
 // => 18 (even numbers [2, 4] -> [6, 12] -> sum = 18)
@@ -1311,8 +1239,7 @@ Here's the complete precedence table, from highest to lowest:
 | 5 | `&` `xor` `\|` | Bitwise operations | `4 \| 2 & 1` → `4 \| 0` → `4` |
 | 4 | `&&` `\|\|` `??` | Logical operations | `true && false \|\| true` → `false \|\| true` → `true` |
 | 3 | *function operators* | Binary functions used as operators | `5 max 3 + 2` → `5 max 5` → `5` |
-| 2 | `\|>` | Pipe operator | `[1,2] \|> map(_, inc) \|> sum` |
-| 1 | `?` `:` | Conditional (ternary) operator | `true ? 1 + 2 : 3` → `true ? 3 : 3` → `3` |
+| 2 | `\|>` | Pipe operator | `[1,2] \|> map(_, inc) \|> reduce(_, 0, +)` |
 
 #### Examples of Precedence in Action
 
@@ -1330,11 +1257,11 @@ Here's the complete precedence table, from highest to lowest:
 3 > 2 && 1 < 2;      // => true && true = true
 
 // Pipe has very low precedence
-let vec = import(vector);
+let { sum } = import(vector);
 [1, 2, 3] |> map(_, inc) |> sum;      // Evaluates left to right
 
-// Conditional has lowest precedence
-true ? 2 + 3 : 4 + 5;             // => true ? 5 : 9 = 5
+// Conditional expression
+if true then 2 + 3 else 4 + 5 end;   // => 5
 ```
 
 #### Using Parentheses
@@ -1356,7 +1283,7 @@ let d = true;
 let e = false;
 let f = 10;
 let g = 5;
-((a + b) * c) > (d && e ? f : g)  // => (5 * 4) > (false ? 10 : 5) = 20 > 5 = true;
+((a + b) * c) > (if d && e then f else g end)  // => (5 * 4) > (if false then 10 else 5 end) = 20 > 5 = true;
 ```
 
 #### Associativity
@@ -1427,7 +1354,7 @@ let square = x -> x * x;
 ### Factorial
 
 ```dvala
-let factorial = n -> n <= 1 ? 1 : n * self(n - 1);
+let factorial = (n) -> if n <= 1 then 1 else n * self(n - 1) end;
 
 factorial(5);  // => 120
 ```
@@ -1439,13 +1366,13 @@ let numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
 
 // Get even numbers squared
 let evenSquares = numbers
-  |> filter(_, even?)
+  |> filter(_, isEven)
   |> map(_, -> $ * $);
 // => [4, 16, 36, 64, 100]
 
 // Sum of odd numbers
 let oddSum = numbers
-  |> filter(_, odd?)
+  |> filter(_, isOdd)
   |> reduce(_, +, 0);
 // => 25
 ```
@@ -1465,7 +1392,7 @@ let wordCount = text
 let longWords = text
   |> split(_, #"\s+")
   |> filter(_, -> count($) > 4)
-  |> map(_, upper-case);
+  |> map(_, upperCase);
 // => ["HELLO,", "WORLD!", "TODAY?"]
 ```
 
@@ -1480,7 +1407,7 @@ let users = [
 ];
 
 // Group by department and get average age
-let grouped = users |> su.group-by(_, "department");
+let grouped = users |> su.groupBy(_, "department");
 let departmentAges = grouped
   |> entries(_)
   |> map(_, ([dept, people]) -> do