     @op of <[ ++ -- delete ]> and If.unfoldSoak o, this, 'first'
 
   compileNode: (o) ->
-    return @compileUnary     o if not @second
-    return @compileChain     o if @isChainable() and @first.isChainable()
+    return @compileUnary o if not @second
+    return @compileChain o if @first instanceof Op and
+                              @op in COMPARERS and @first.op in COMPARERS
     return @compileExistence o if @op is '?'
     return @compileMultiIO   o if @op is 'instanceof' and @second.isArray()
     @first import {@front}

        call.newInstance()
        return first
      first = Parens first, true if first instanceof Code and first.bound
    this import {op, first, second, flip}

  # The map of invertible/chainable operators.
  INVERSIONS = '===':'!==', '==':'!=', '>':'<=', '<':'>='
  INVERSIONS[val] = key for all key, val in INVERSIONS

  children: <[ first second ]>

  isChainable: -> @op in INVERSIONS

  invert: ->
    if op = INVERSIONS[@op]
      @op = op
      this
    else if @second

# When for the purposes of walking the contents of a function body, the Code
# has no *children* -- they're within the inner scope.
class exports.Code extends Base
  (@params = [], @body = Expressions(), arrow) =>
    @bound = 'this' if arrow is '=>'

  children: <[ params body ]>

