@param Common\Join\Options        $options
@param Functions\ConnectorMutator $mutatorFunction

@return JoinApply
16026
public function update(
            Common\Join\Options $options,
            Functions\ConnectorMutator $mutatorFunction
    ) {
        if ($this->options === $options && $this->mutatorFunction === $mutatorFunction) {
            return $this;
        }

        return new self($options, $mutatorFunction);
    }
1056334
@Provides
  @Singleton
  ImmutableMap<String, ? extends SoyFunction> provideSoyFunctionsMap(
      Set<SoyFunction> soyFunctionsSet) {
    Map<String, SoyFunction> mapBuilder = new LinkedHashMap<>();
    for (SoyFunction function : soyFunctionsSet) {
      SoyFunction old = mapBuilder.put(function.getName(), function);
      if (old != null && !old.getClass().getName().equals(function.getClass().getName())) {
        throw new IllegalStateException(
            "Found two functions with the same name: '"
                + function.getName()
                + "' and different implementations: "
                + function
                + " vs "
                + old);
      }
    }
    return ImmutableMap.copyOf(mapBuilder);
  }
784635
private Optional<ConcreteProposal> propose(InnerJoinNode joinNode, ImmutableMultimap<RelationPredicate, ExtensionalDataNode> initialDataNodeMap,
                                               ImmutableList<Variable> priorityVariables,
                                               IntermediateQuery query, DBMetadata dbMetadata)
            throws AtomUnificationException {

        ImmutableList.Builder<PredicateLevelProposal> proposalListBuilder = ImmutableList.builder();

        for (RelationPredicate predicate : initialDataNodeMap.keySet()) {
            ImmutableCollection<ExtensionalDataNode> initialNodes = initialDataNodeMap.get(predicate);
            Optional<PredicateLevelProposal> predicateProposal = proposePerPredicate(joinNode, initialNodes, predicate, dbMetadata,
                    priorityVariables, query);
            predicateProposal.ifPresent(proposalListBuilder::add);
        }

        return createConcreteProposal(proposalListBuilder.build(), priorityVariables);
    }
394357
public static <K, N, V> Mutator<K> createMutator(Keyspace keyspace,
      Serializer<K> keySerializer) {
    return new MutatorImpl<K>(keyspace, keySerializer);
  }
996044
public function mutate($updateQuery, $options = array())
    {
        if(!is_array($updateQuery)) throw new \Exception('$updateQuery should be an array');
        if(!is_array($options)) throw new \Exception('$options should be an array');

        $default = array(
            'w' => 1
        );
        $options = array_merge($default, $options);

        try {
            $this->_connection->update($this->collectionName(), array('_id' => $this->cleanData['_id']), $updateQuery, $options);
        } catch (\MongoCursorException $e) {
            return false;
        }

        return true;
    }
839428
public function addJoins(Join ...$joins): MutableQuery
    {
        $cloned = clone $this;

        $activeJoins = iterator_to_array($this->joins);
        $activeJoins = array_merge($activeJoins, $joins);

        $cloned->joins = new JoinCollection(...$activeJoins);

        return $cloned;
    }
1339902
public void executeActivitiesConcurrent(List<PvmActivity> activityStack, PvmActivity targetActivity,
                                          PvmTransition targetTransition, Map<String, Object> variables, Map<String, Object> localVariables,
                                          boolean skipCustomListeners, boolean skipIoMappings) {


    ScopeImpl flowScope = null;
    if (!activityStack.isEmpty()) {
      flowScope = activityStack.get(0).getFlowScope();
    } else if (targetActivity != null) {
      flowScope = targetActivity.getFlowScope();
    } else if (targetTransition != null) {
      flowScope = targetTransition.getSource().getFlowScope();
    }

    PvmExecutionImpl propagatingExecution = null;
    if (flowScope.getActivityBehavior() instanceof ModificationObserverBehavior) {
      ModificationObserverBehavior flowScopeBehavior = (ModificationObserverBehavior) flowScope.getActivityBehavior();
      propagatingExecution = (PvmExecutionImpl) flowScopeBehavior.createInnerInstance(this);
    } else {
      propagatingExecution = createConcurrentExecution();
    }

    propagatingExecution.executeActivities(activityStack, targetActivity, targetTransition, variables, localVariables,
      skipCustomListeners, skipIoMappings);
  }
21777
public ApiFuture<Void> add(final RowMutation rowMutation) {
    Preconditions.checkState(!closed, "BulkMutations has been closed");
    numOutstanding.incrementAndGet();

    ApiFuture<Void> future = callable.futureCall(rowMutation);

    ApiFutures.addCallback(
        future,
        new ApiFutureCallback<Void>() {
          @Override
          public void onFailure(Throwable throwable) {
            onMutationComplete(false);
          }

          @Override
          public void onSuccess(Void aVoid) {
            onMutationComplete(true);
          }
        },
        MoreExecutors.directExecutor());

    return future;
  }
264510
protected function registerMutator(string $operator, $callable, bool $stack = false, string $property = null): self
    {
        $this->mutators[$operator] = [
            'callable' => $callable,
            'stack'    => $stack,
            'property' => $property ?? $this->name,
        ];

        return $this;
    }
233394
public <U extends T, A, B, C> OngoingMatchingC3<T, U, A, B, C> when(
      DecomposableMatchBuilder3<U, A, B, C> decomposableMatchBuilder) {
    return new OngoingMatchingC3<>(this, decomposableMatchBuilder.build());
  }
1296658
public Mutations<S> combineWith(final Mutations<S> other) {
        IntArrayList result = new IntArrayList(mutations.length + other.mutations.length);

        //mut2 pointer
        int p2 = 0, position0 = 0, delta = 0;

        for (int p1 = 0; p1 < mutations.length; ++p1) {

            position0 = getPosition(mutations[p1]);

            while (p2 < other.mutations.length && // There are mutations in m2
                    (getPosition(other.mutations[p2]) < position0 + delta || // Before current point
                            (getPosition(other.mutations[p2]) == position0 + delta && // On the current point and it is insertion
                                    getRawTypeCode(other.mutations[p2]) == RAW_MUTATION_TYPE_INSERTION)))
                appendInCombine(result, Mutation.move(other.mutations[p2++], -delta));

            switch (getRawTypeCode(mutations[p1])) {
                case RAW_MUTATION_TYPE_INSERTION:
                    if (p2 < other.mutations.length && getPosition(other.mutations[p2]) == delta + position0) {
                        if (getTo(mutations[p1]) != getFrom(other.mutations[p2]))
                            throw new IllegalArgumentException();

                        if (isSubstitution(other.mutations[p2]))
                            appendInCombine(result, (mutations[p1] & (~LETTER_MASK)) | (other.mutations[p2] & LETTER_MASK));

                        ++p2;
                    } else
                        appendInCombine(result, mutations[p1]);
                    ++delta;
                    break;
                case RAW_MUTATION_TYPE_SUBSTITUTION:
                    if (p2 < other.mutations.length && getPosition(other.mutations[p2]) == delta + position0) {

                        if (getTo(mutations[p1]) != getFrom(other.mutations[p2]))
                            throw new IllegalArgumentException();

                        if (isSubstitution(other.mutations[p2])) {
                            if (getFrom(mutations[p1]) != getTo(other.mutations[p2]))
                                appendInCombine(result, (mutations[p1] & (~LETTER_MASK)) | (other.mutations[p2] & LETTER_MASK));
                        } else if (isDeletion(other.mutations[p2]))
                            appendInCombine(result, createDeletion(position0, getFrom(mutations[p1])));
                        else
                            throw new RuntimeException("Insertion after Del. or Subs.");

                        ++p2;

                    } else
                        appendInCombine(result, mutations[p1]);

                    break;
                case RAW_MUTATION_TYPE_DELETION:
                    --delta;
                    appendInCombine(result, mutations[p1]);
                    break;
            }

        }

        while (p2 < other.mutations.length)
            appendInCombine(result, Mutation.move(other.mutations[p2++], -delta));

        return new Mutations<S>(alphabet, result.toArray(), true);
    }
1221218
protected function getMutator(string $field, string $mutator)
    {
        /**
         * Every document composition is valid accessor but defined a bit differently.
         */
        if (isset($this->documentSchema[self::SH_COMPOSITIONS][$field])) {
            return $this->documentSchema[self::SH_COMPOSITIONS][$field];
        }

        return parent::getMutator($field, $mutator);
    }
930299
def list_combiner(value, mutator, *args, **kwargs):
    
    value.append(mutator(*args, **kwargs))
    return value
422626
@Override
	protected boolean mutatesTo(Object o1, Object o2)
	{
		if (null == o2)
		{
			return false;
		}
		return o1.equals(o2);
	}
751251
protected function generatePinqTypeData(
            $traversableType,
            $orderedTraversableType,
            $joiningOnTraversableType,
            $joiningToTraversableType,
            $mutable = false
    ) {
        $pinqTypes                  = [];
        $traversableTypeId          = TypeId::getObject($traversableType);
        $orderedTraversableTypeId   = TypeId::getObject($orderedTraversableType);
        $joiningOnTraversableTypeId = TypeId::getObject($joiningOnTraversableType);
        $joiningToTraversableTypeId = TypeId::getObject($joiningToTraversableType);

        $commonMethods = [
                'asArray'           => INativeType::TYPE_ARRAY,
                'asTraversable'     => TypeId::getObject(Pinq\ITraversable::ITRAVERSABLE_TYPE),
                'asCollection'      => TypeId::getObject(Pinq\ICollection::ICOLLECTION_TYPE),
                'isSource'          => INativeType::TYPE_BOOL,
                'getSource'         => $traversableTypeId,
                'iterate'           => INativeType::TYPE_NULL,
                'getIterator'       => TypeId::getObject('Traversable'),
                'getTrueIterator'   => TypeId::getObject('Traversable'),
                'getIteratorScheme' => TypeId::getObject(IIteratorScheme::IITERATOR_SCHEME_TYPE),
                'first'             => INativeType::TYPE_MIXED,
                'last'              => INativeType::TYPE_MIXED,
                'count'             => INativeType::TYPE_INT,
                'isEmpty'           => INativeType::TYPE_BOOL,
                'aggregate'         => INativeType::TYPE_MIXED,
                'maximum'           => INativeType::TYPE_MIXED,
                'minimum'           => INativeType::TYPE_MIXED,
                'sum'               => INativeType::TYPE_MIXED,
                'average'           => INativeType::TYPE_MIXED,
                'all'               => INativeType::TYPE_BOOL,
                'any'               => INativeType::TYPE_BOOL,
                'implode'           => INativeType::TYPE_STRING,
                'contains'          => INativeType::TYPE_BOOL,
                'where'             => $traversableTypeId,
                'orderBy'           => $orderedTraversableTypeId,
                'orderByAscending'  => $orderedTraversableTypeId,
                'orderByDescending' => $orderedTraversableTypeId,
                'skip'              => $traversableTypeId,
                'take'              => $traversableTypeId,
                'slice'             => $traversableTypeId,
                'indexBy'           => $traversableTypeId,
                'keys'              => $traversableTypeId,
                'reindex'           => $traversableTypeId,
                'groupBy'           => $traversableTypeId,
                'join'              => $joiningOnTraversableTypeId,
                'groupJoin'         => $joiningOnTraversableTypeId,
                'select'            => $traversableTypeId,
                'selectMany'        => $traversableTypeId,
                'unique'            => $traversableTypeId,
                'append'            => $traversableTypeId,
                'whereIn'           => $traversableTypeId,
                'except'            => $traversableTypeId,
                'union'             => $traversableTypeId,
                'intersect'         => $traversableTypeId,
                'difference'        => $traversableTypeId,
        ];

        if ($mutable) {
            $commonMethods += [
                    'apply'       => INativeType::TYPE_NULL,
                    'addRange'    => INativeType::TYPE_NULL,
                    'remove'      => INativeType::TYPE_NULL,
                    'removeRange' => INativeType::TYPE_NULL,
                    'removeWhere' => INativeType::TYPE_NULL,
                    'clear'       => INativeType::TYPE_NULL,
            ];
        }

        $pinqTypes[$traversableType] = [
                'methods' => $commonMethods
        ];

        $pinqTypes[$orderedTraversableType] = [
                'methods' => [
                                'thenBy'           => $orderedTraversableTypeId,
                                'thenByAscending'  => $orderedTraversableTypeId,
                                'thenByDescending' => $orderedTraversableTypeId,
                        ] + $commonMethods
        ];

        $joiningMethods = [
                'withDefault' => $joiningToTraversableTypeId,
                'to'          => $traversableTypeId,
        ];

        if ($mutable) {
            $joiningMethods += [
                    'apply' => INativeType::TYPE_NULL,
            ];
        }

        $pinqTypes[$joiningToTraversableType] = [
                'methods' => $joiningMethods
        ];

        $pinqTypes[$joiningOnTraversableType] = [
                'methods' => [
                                'on'         => $joiningToTraversableTypeId,
                                'onEquality' => $joiningToTraversableTypeId,
                        ] + $joiningMethods
        ];

        return $pinqTypes;
    }
423269
def replace_combiner(value, mutator, *args, **kwargs):
    
    args = list(args) + [value]
    return mutator(*args, **kwargs)
1341743
public static function push($callable, $args = [], $options = [])
    {
        $config = Hash::get($options, 'config', 'default');
        $queue = static::queue($config);

        return $queue->push($callable, $args, $options);
    }