Enum TsBinaryOp 

pub enum TsBinaryOp {
    NullishCoalescing,
    Or,
    And,
    StrictEq,
    StrictNotEq,
    GreaterThan,
    InstanceOf,
    LessThan,
    Add,
    In,
    GreaterThanEq,
    LessThanEq,
}

?? (events_fanout.rs’s env ?? {}), plus three more real operators #1321 (workers.rs) grounds: ||/&& (the Bearer-header presence checks, __authz === null || !__authz.startsWith(...) / __authz !== null && __authz.startsWith(...)) and ===/!== (pervasive throughout the file’s own tagged-result and header checks). #1323 (workers_entry.rs) grounds one more: > (the request-body- ceiling guard’s own Number(__contentLength) > <cap> — the one real site anywhere in bynk-emit that needs a relational, not equality, comparison). Not the full JS/TS operator table (Decision B’s own “extend narrowly” posture) — see the printer’s own binary_precedence (bynk-ts/src/printer.rs, private) for why a nested Binary operand’s parenthesisation needed to become precedence-aware once more than one operator existed. Arc C, step (11) (#1388) grounds one more: + (string concatenation) — the ICU-formatting cluster’s own dominant structural pattern, every literal/placeholder segment in a message template joins this way. Real JS/TS precedence (binds tighter than every comparison/logical operator this table already has) and real left-associativity ("a" + "b" + "c" needs no parens, the same way a same-operator ||/&& chain already prints flat) both matter here, not just the operator symbol itself.

Variants

NullishCoalescing

Or

And

StrictEq

StrictNotEq

GreaterThan

InstanceOf

instanceof — Arc C slice 34 (tests_emit.rs slice D, #1403)’s own real gap: emit_test_case_function’s own catch clause (e instanceof ExpectationError) is the first real instanceof anywhere in bynk-emit’s own content. Real JS/TS precedence puts it at the same tier as the relational comparisons (</>) — sharing TsBinaryOp::LessThan’s own tier, not a new one — rendered as the keyword " instanceof ", textually the same shape as &&/|| rather than symbol punctuation.

LessThan

< — Arc C slice 33 (tests_emit.rs slice C, #1401)’s own real gap: emit_stub_class’s ReturnsEach sequence-cursor guard (this.__seq_N < <bound>) is the first real < comparison anywhere in bynk-emit’s own content. Same precedence tier as TsBinaryOp::GreaterThan (real JS/TS relational operators all share one level) — added alongside it rather than folding into a single “relational” variant, matching this enum’s own existing one-variant-per-real-operator convention.

Add

In

in — Arc E slice 5 (serialisation.rs, #1443)’s own real gap: emit_record_codec’s per-field default-value prevalidation line ("<field>" in obj ? obj["<field>"] : <default>) needs a real “is this wire key present at all” test, distinct from !== undefined (Events slice 3a, #972’s own Decision D: a wire key present with an explicit null/{"kind":"None"} value must NOT fall through to the default, only a genuinely absent key may). Real JS/TS grammar puts in at the exact same RelationalExpression precedence tier as </>/instanceof (all five — plus <=/>=, unmodelled here — share one level in the spec), so it joins TsBinaryOp::LessThan’s tier rather than a new one, the same “share, don’t multiply, tiers” convention InstanceOf/LessThan already set. Rendered as the keyword " in ", the same textual-keyword-operator shape InstanceOf already established (not symbol punctuation).

GreaterThanEq

>= — #1471’s own real gap: pred_condition_and_message’s (bynk-emit) NonNegative/InRange/InRangeF/MinLength arms each build a real “at least” comparison ({receiver} >= 0, {receiver} >= {a}, {receiver}.length >= {n}) that this enum had no home for — TsBinaryOp::In’s own doc already named this exact gap (“plus <=/>=, unmodelled here”). Same RelationalExpression precedence tier as TsBinaryOp::GreaterThan/[TsBinaryOp:: LessThan]/TsBinaryOp::InstanceOf/TsBinaryOp::In (real JS/TS puts all six at one level), rendered " >= " — symbol punctuation, matching GreaterThan/LessThan’s own convention, not a keyword like InstanceOf/In.

LessThanEq

<= — the same gap’s other half: InRange/InRangeF/MaxLength’s own “at most” comparison ({receiver} <= {b}, {receiver}.length <= {n}). Same tier and rendering convention as TsBinaryOp::GreaterThanEq, symmetric with it the way GreaterThan/LessThan already are.

Trait Implementations

impl Clone for TsBinaryOp

fn clone(&self) -> TsBinaryOp

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for TsBinaryOp

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for TsBinaryOp

fn eq(&self, other: &TsBinaryOp) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for TsBinaryOp

impl Eq for TsBinaryOp

impl StructuralPartialEq for TsBinaryOp