Sets the transforms to use for the {@link Item} third person.

@param left the left
@param right the right
@return the item transform component
428134
public ItemTransformComponent thirdPerson(Matrix4f left, Matrix4f right)
	{
		this.thirdPersonLeftHand = left;
		this.thirdPersonRightHand = right;
		return this;
	}
732368
private Node rotateLeft(Node node) {
        Node leftChild = node.left;
        node.left = leftChild.right;
        leftChild.right = node;
        node.height = calculateHeight(getHeight(node.left), getHeight(node.right));
        leftChild.height = calculateHeight(getHeight(leftChild.left), node.height);
        return leftChild;
    }
21688
public <P> Q leftJoin(Path<? extends Collection<P>> target, Path<P> alias) {
        getMetadata().addJoin(JoinType.LEFTJOIN, createAlias(target, alias));
        return queryMixin.getSelf();
    }
90651
private LeftJoinNode updateRightNodesAndLJ(LeftJoinNode leftJoinNode,
                                               DataNodeAndSubstitution rightComponent,
                                               Optional<ImmutableExpression> newLJCondition,
                                               Optional<DataNode> proposedRightDataNode,
                                               QueryTreeComponent treeComponent) {
        rightComponent.constructionNode
                .ifPresent(n -> treeComponent.replaceNodeByChild(n, Optional.empty()));
        rightComponent.filterNode
                .ifPresent(n -> treeComponent.replaceNodeByChild(n, Optional.empty()));
        proposedRightDataNode
                .ifPresent(n -> treeComponent.replaceNode(rightComponent.dataNode, n));
        LeftJoinNode newLeftJoinNode = leftJoinNode.changeOptionalFilterCondition(newLJCondition);
        treeComponent.replaceNode(leftJoinNode, newLeftJoinNode);

        return newLeftJoinNode;
    }
188915
public static Boolean and(Object left, Object right) {
        return (Boolean) InfixOpNode.and(left, right, null);
    }
585510
protected Node simpleAssignment(Node left, Node right) {
        int nodeType = left.getType();
        switch (nodeType) {
          case Token.NAME:
              String name = ((Name) left).getIdentifier();
              if (inUseStrictDirective &&
                  ("eval".equals(name) || "arguments".equals(name)))
              {
                  reportError("msg.bad.id.strict", name);
              }
              left.setType(Token.BINDNAME);
              return new Node(Token.SETNAME, left, right);

          case Token.GETPROP:
          case Token.GETELEM: {
              Node obj, id;
              // If it's a PropertyGet or ElementGet, we're in the parse pass.
              // We could alternately have PropertyGet and ElementGet
              // override getFirstChild/getLastChild and return the appropriate
              // field, but that seems just as ugly as this casting.
              if (left instanceof PropertyGet) {
                  obj = ((PropertyGet)left).getTarget();
                  id = ((PropertyGet)left).getProperty();
              } else if (left instanceof ElementGet) {
                  obj = ((ElementGet)left).getTarget();
                  id = ((ElementGet)left).getElement();
              } else {
                  // This branch is called during IRFactory transform pass.
                  obj = left.getFirstChild();
                  id = left.getLastChild();
              }
              int type;
              if (nodeType == Token.GETPROP) {
                  type = Token.SETPROP;
                  // TODO(stevey) - see https://bugzilla.mozilla.org/show_bug.cgi?id=492036
                  // The new AST code generates NAME tokens for GETPROP ids where the old parser
                  // generated STRING nodes. If we don't set the type to STRING below, this will
                  // cause java.lang.VerifyError in codegen for code like
                  // "var obj={p:3};[obj.p]=[9];"
                  id.setType(Token.STRING);
              } else {
                  type = Token.SETELEM;
              }
              return new Node(type, obj, id, right);
          }
          case Token.GET_REF: {
              Node ref = left.getFirstChild();
              checkMutableReference(ref);
              return new Node(Token.SET_REF, ref, right);
          }
        }

        throw codeBug();
    }
753971
public InclusMultiPos<E, L, R> inclus(Boolean left, Boolean right) {
		this.inclusive[0] = checkNotNull(left);
		this.inclusive[1] = checkNotNull(right);
		return this;
	}
1085046
protected <E> List<E> merge(final List<E> leftElements, final List<E> rightElements) {
    int leftIndex = 0;
    int leftSize = leftElements.size();
    int rightIndex = 0;
    int rightSize = rightElements.size();

    List<E> mergedElements = new ArrayList<>(leftSize + rightSize);

    for (int mergeIndex = 0, mergeSize = (leftSize + rightSize); mergeIndex < mergeSize; mergeIndex++) {
      if (leftIndex == leftSize) {
        mergedElements.add(rightElements.get(rightIndex++));
      }
      else if (rightIndex == rightSize) {
        mergedElements.add(leftElements.get(leftIndex++));
      }
      else {
        E leftElement = leftElements.get(leftIndex);
        E rightElement = rightElements.get(rightIndex);

        if (getOrderBy().compare(leftElement, rightElement) <= 0) {
          mergedElements.add(leftElement);
          leftIndex++;
        }
        else {
          mergedElements.add(rightElement);
          rightIndex++;
        }
      }
    }

    return mergedElements;
  }
743061
def right_to_left(self):
        """"""
        self._entry_mode &= ~Command.MODE_INCREMENT
        self.command(self._entry_mode)
1212103
public static <S> List<S> of(S left, List<? extends S> right) {
        if (right.isEmpty()) {
            return Collections.singletonList(left);
        } else {
            List<S> list = new ArrayList<S>(1 + right.size());
            list.add(left);
            list.addAll(right);
            return list;
        }
    }
629985
public ItemsSketch<T> merge(final ItemsSketch<T> other) {
    if (other == null) { return this; }
    if (other.isEmpty()) { return this; }

    final long streamLen = this.streamWeight + other.streamWeight; //capture before merge

    final ReversePurgeItemHashMap.Iterator<T> iter = other.hashMap.iterator();
    while (iter.next()) { //this may add to offset during rebuilds
      this.update(iter.getKey(), iter.getValue());
    }
    this.offset += other.offset;
    this.streamWeight = streamLen; //corrected streamWeight
    return this;
  }
634128
public static Object sub(Object left, Object right) {
        return InfixOpNode.sub(left, right, null);
    }
525299
def merge(left, right):
    
    merged = {}

    left_keys = frozenset(left)
    right_keys = frozenset(right)

    # Items only in the left Mapping
    for key in left_keys - right_keys:
        merged[key] = left[key]

    # Items only in the right Mapping
    for key in right_keys - left_keys:
        merged[key] = right[key]

    # in both
    for key in left_keys & right_keys:
        left_value = left[key]
        right_value = right[key]

        if (isinstance(left_value, Mapping) and
                isinstance(right_value, Mapping)):  # recursive merge
            merged[key] = merge(left_value, right_value)
        else:  # overwrite with right value
            merged[key] = right_value

    return merged
285332
def move_red_left(self):
        

        self = self.flip()
        if self.right is not NULL and self.right.left.red:
            self = self._replace(right=self.right.rotate_right())
            self = self.rotate_left().flip()

        return self
32463
public S setBetn(int leftIndex, int rightIndex) {
		return set(Indexer.of(delegate.get()).between(leftIndex, rightIndex));
	}
307446
public static <L, R> Pair<L, R> create(L left, R right) {
        return new Pair<>(left, right);
    }
732686
public static JPopupMenu leftShift(JPopupMenu self, Component component) {
        self.add(component);
        return self;
    }