Returns a parser that applies the produced value of this parser to the produced value of `other`.
15470
def parsecapp(self, other):
        ''''''
        # pylint: disable=unnecessary-lambda
        return self.bind(lambda res: other.parsecmap(lambda x: res(x)))
961986
def coerce(other)
      if other.matched?
        return other, self
      else
        return Node.match(other, self).new(other), self
      end
    end
770717
def cmp(other)
			if (!other.kind_of?(Mask128))
				raise ArgumentError, "Expected an Mask128 object for 'other' but got a #{other.class}."
			end
			if (self.prefix_len < other.prefix_len)
				return 1
			elsif (self.prefix_len > other.prefix_len)
				return -1
			end
			return 0
		end
585211
def resolve(self, other) -> Optional[Type]:
        """"""
        if not isinstance(other, NltkComplexType):
            return None
        other_first = other.first.resolve(other.second)
        if not other_first:
            return None
        other_second = other.second.resolve(other_first)
        if not other_second:
            return None
        return UnaryOpType(other_first, self._allowed_substitutions, self._signature)
720739
def create_from_other( Class, other, values=None ):
        
        m = Class()
        m.alphabet = other.alphabet
        m.sorted_alphabet = other.sorted_alphabet
        m.char_to_index = other.char_to_index
        if values is not None:
            m.values = values
        else:
            m.values = other.values
        return m
340041
def _get_parser_compound(cls, *parse_methods):
        
        def parse(value):
            parsed = value

            for method in parse_methods:
                parsed = method(parsed)

            return parsed

        return parse
1186111
def coerce(other)
      if other.is_a? InternalComplex
        return other, self
      elsif other.is_a? Complex
        return InternalComplex.new( other.real, other.imag ), self
      else
        return InternalComplex.new( other, 0 ), self
      end
    end
226518
def ends_with(self, other):
        ''''''
        @Parser
        def ends_with_parser(text, index):
            res = self(text, index)
            if not res.status:
                return res
            end = other(text, res.index)
            if end.status:
                return res
            else:
                return Value.failure(end.index, 'ends with {}'.format(end.expected))
        return ends_with_parser
969464
def replace(other)
      if other.is_a?(AbstractSet)
        other
      else
        copy(:mask => as_mask(other, true))
      end
    end
1010418
def Concat(self: Iterable, *others):
    
    return concat_generator(self, *[unbox_if_flow(other) for other in others])
1143312
def plus(other)
      type = other.is_a?(Sass::Script::Value::String) ? other.type : :identifier
      Sass::Script::Value::String.new(to_s(:quote => :none) + other.to_s(:quote => :none), type)
    end
723771
def +(other)
      if other.is_a?(Volt::Duration)
        Volt::Duration.new(value + other.value, parts + other.parts)
      else
        Volt::Duration.new(value + other, parts + [[:seconds, other]])
      end
    end
698493
def _le_from_lt(self, other):
    """"""
    op_result = self.__lt__(other)
    return op_result or self == other
34605
function(parser, expr) {
    var mod = parser.evaluateExpression(expr.arguments[0]);
    return this._addDependency(parser, expr, mod);
  }
518359
def replace_with(self, other):
        """"""
        self.after(other)
        self.parent.pop(self._own_index)
        return other
227126
def **(other)
      case other
      when Integer
        if other > 0
          num = @numerator**other
          den = @denominator**other
          self.class.new(num, den)
        elsif other < 0
          num = @denominator**-other
          den = @numerator**-other
          self.class.new(num, den)
        elsif other.zero?
          unity
        end
      else
        x, y = other.coerce(self)
        x**y
      end
    end
337959
def +(other)
      self.class.new(*(
        [
          usage,
          processor_id == other.processor_id ? processor_id : 0,
        ] +
        values_at(2..-3).zip(other.values_at(2..-3)).map { |x, y| x + y } +
        [
          [ start_at, other.start_at ].min,
          [ stop_at, other.stop_at ].max
        ])
      )
    end