spelling: truthy

Compiler/include/Luau/Bytecode.h

@@ -208,14 +208,14 @@ enum LuauOpcode
     LOP_MODK,
     LOP_POWK,
 
-    // AND, OR: perform `and` or `or` operation (selecting first or second register based on whether the first one is truthful) and put the result into target register
+    // AND, OR: perform `and` or `or` operation (selecting first or second register based on whether the first one is truthy) and put the result into target register
     // A: target register
     // B: source register 1
     // C: source register 2
     LOP_AND,
     LOP_OR,
 
-    // ANDK, ORK: perform `and` or `or` operation (selecting source register or constant based on whether the source register is truthful) and put the result into target register
+    // ANDK, ORK: perform `and` or `or` operation (selecting source register or constant based on whether the source register is truthy) and put the result into target register
     // A: target register
     // B: source register
     // C: constant table index (0..255)

Compiler/src/Compiler.cpp

@@ -712,7 +712,7 @@ struct Compiler
     }
 
     // compile expr to target temp register
-    // if the expr (or not expr if onlyTruth is false) is truthful, jump via skipJump
+    // if the expr (or not expr if onlyTruth is false) is truthy, jump via skipJump
     // if the expr (or not expr if onlyTruth is false) is falsy, fall through (target isn't guaranteed to be updated in this case)
     // if target is omitted, then the jump behavior is the same - skipJump or fallthrough depending on the truthiness of the expression
     void compileConditionValue(AstExpr* node, const uint8_t* target, std::vector<size_t>& skipJump, bool onlyTruth)
@@ -722,7 +722,7 @@ struct Compiler
 
         if (cv && cv->type != Constant::Type_Unknown)
         {
-            // note that we only need to compute the value if it's truthful; otherwise we cal fall through
+            // note that we only need to compute the value if it's truthy; otherwise we cal fall through
             if (cv->isTruthful() == onlyTruth)
             {
                 if (target)
@@ -741,7 +741,7 @@ struct Compiler
             case AstExprBinary::And:
             case AstExprBinary::Or:
             {
-                // disambiguation: there's 4 cases (we only need truthful or falsy results based on onlyTruth)
+                // disambiguation: there's 4 cases (we only need truthy or falsy results based on onlyTruth)
                 // onlyTruth = 1: a and b transforms to a ? b : dontcare
                 // onlyTruth = 1: a or b transforms to a ? a : a
                 // onlyTruth = 0: a and b transforms to !a ? a : b
@@ -786,7 +786,7 @@ struct Compiler
                 {
                     // since target is a temp register, we'll initialize it to 1, and then jump if the comparison is true
                     // if the comparison is false, we'll fallthrough and target will still be 1 but target has unspecified value for falsy results
-                    // when we only care about falsy values instead of truthful values, the process is the same but with flipped conditionals
+                    // when we only care about falsy values instead of truthy values, the process is the same but with flipped conditionals
                     bytecode.emitABC(LOP_LOADB, *target, onlyTruth ? 1 : 0, 0);
                 }
 

docs/_pages/library.md

@@ -18,7 +18,7 @@ While most library functions are provided as part of a library like `table`, a f
 function assert<T>(value: T, message: string?): T
 ```
 
-`assert` checks if the value is truthful; if it's not (which means it's `false` or `nil`), it raises an error. The error message can be customized with an optional parameter.
+`assert` checks if the value is truthy; if it's not (which means it's `false` or `nil`), it raises an error. The error message can be customized with an optional parameter.
 Upon success the function returns the `condition` argument.
 
 ```

docs/_pages/performance.md

@@ -88,7 +88,7 @@ The mechanism works by directly invoking a highly specialized and optimized impl
 
 As a result, builtin calls are very fast in Luau - they are still slightly slower than core instructions such as arithmetic operations, but only slightly so. The set of fastcall builtins is slowly expanding over time and as of this writing contains `assert`, `type`, `typeof`, `rawget`/`rawset`/`rawequal`, all functions from `math` and `bit32`, and some functions from `string` and `table` library.
 
-> Note: The partial specialization mechanism is cute in that for `assert`, it only specializes on truthful conditions; hopefully performance of `assert(false)` isn't crucial for most code!
+> Note: The partial specialization mechanism is cute in that for `assert`, it only specializes on truthy conditions; hopefully performance of `assert(false)` isn't crucial for most code!
 
 ## Optimized table iteration
 

rfcs/syntax-if-expression.md

@@ -12,7 +12,7 @@ Introduce a form of ternary conditional using `if cond then value else alternati
 
 Luau does not have a first-class ternary operator; when a ternary operator is needed, it is usually emulated with `and/or` expression, such as `cond and value or alternative`.
 
-This expression evaluates to `value` if `cond` and `value` are truthful, and `alternative` otherwise. In particular it means that when `value` is `false` or `nil`, the result of the entire expression is `alternative` even when `cond` is truthful - which doesn't match the expected ternary logic and is a frequent source of subtle errors.
+This expression evaluates to `value` if `cond` and `value` are truthy, and `alternative` otherwise. In particular it means that when `value` is `false` or `nil`, the result of the entire expression is `alternative` even when `cond` is truthy - which doesn't match the expected ternary logic and is a frequent source of subtle errors.
 
 Instead of `and/or`, `if/else` statement can be used but since that requires a separate mutable variable, this option isn't ergonomic. An immediately invoked function expression is also unergonomic and results in performance issues at runtime.
 
@@ -22,7 +22,7 @@ To solve these problems, we propose introducing a first-class ternary conditiona
 
 Concretely, the `if-then-else` expression must match `if <expr> then <expr> else <expr>`; it can also contain an arbitrary number of `elseif` clauses, like `if <expr> then <expr> elseif <expr> then <expr> else <expr>`. Note that in either case, `else` is mandatory.
 
-The result of the expression is the then-expression when condition is truthful (not `nil` or `false`) and else-expression otherwise. Only one of the two possible resulting expressions is evaluated.
+The result of the expression is the then-expression when condition is truthy (not `nil` or `false`) and else-expression otherwise. Only one of the two possible resulting expressions is evaluated.
 
 Example: