Processes an `or` assignment in the form of `variable ||= value`.
496604
def after_or_asgn
      variable = variable_stack.pop.first
      value    = value_stack.pop.first

      if variable and value
        conditional_assignment(variable, value, false)
      end
    end
906740
def or_(cls, obj, **kwargs):
        
        return cls.__eval_seqexp(obj, operator.or_, **kwargs)
302176
def coerce(self, value):
        """"""
        if self._coerce is not None:
            value = self._coerce(value)
        return value
737573
function setVars(origEnv, setVars) {
  var key;
  if (typeof setVars !== 'object')
    return;
  if (Array.isArray(setVars))
    return;
  for (key in setVars) {
    if (has(setVars, key)) {
      if (!has(origEnv, key)) {
        origEnv[key] = [
          !!has(process.env, key),
          process.env[key]
        ];
      }
      process.env[key] = setVars[key];
    }
  }
  return;
}
1053402
def assignValue(cfg, playerValue, otherValue):
    """"""
    player = cfg.whoAmI()
    result = {}
    for p in cfg.players:
        if p.name == player.name:   val = playerValue
        else:                       val = otherValue
        result[p.name] = val
    return result
350900
def value_or_default(self, value):
        '''  '''
        if value is None:
            if callable(self.default):
                return self.default()
            else:
                return self.default

        return value
1001725
def X(self, value):
        """"""
        if isinstance(value, (int, float,
                              long, types.NoneType)):
            self._x = value
439367
def bitop_or(self, dest, key, *keys):
        """"""
        return self.execute(b'BITOP', b'OR', dest, key, *keys)
1030398
function(value, type) {
        var result = value;

        if (type === 'string') {
            result = String(value);
        } else if (type === 'number') {
            result = Number(value);
        } else if (type === 'boolean') {
            result = Boolean(value);
        }

        return result;
    }
207204
def from_string(string, _or=''):
        
        if _or:
            and_or = 'or'
        else:
            and_or = ''
        return Input(string, and_or=and_or)
466063
function (value) {
    
            var process = value.split('-');
            value = beyond.css.values;
            for (var i in process) {
    
                value = value[process[i]];
                if (typeof value === 'undefined') return;
    
            }
    
            return value;
    
        }
995460
function parseAssignment() {
                    var expr, value, token, content = [];

                    expr = parseAdditive();

                    if (typeof expr !== 'undefined' && expr.subtype === 'variable') {
                        token = lexer.peek();
                        if (matchOp(token, ':=')) {
                            lexer.next();

                            content.push(expr);
                            value = parseAssignment();

                            while (value.subtype === 'assignment') {
                                content = content.concat(value.content);
                                value = value.value;
                            }

                            return new MathLib.Expression({
                                subtype: 'assignment',
                                content: content,
                                value: value
                            });
                        }
                        return expr;
                    }

                    return expr;
                }
193452
function (opts1 /*, …options*/) {
		var result = create(null);
		forEach.call(arguments, function (options) {
			if (!isValue$2(options)) { return; }
			process(Object(options), result);
		});
		return result;
	}
113991
def set(self, value, parse=False):
        
        self.value = self.parse(value) if parse else value
131751
public static <L, R> Either<L, R> valueOf(R reference) {
        return rightOf(reference);
    }
767861
def process_result_value(self, value: Optional[str],
                             dialect: Dialect) -> List[int]:
        """"""
        retval = self._dbstr_to_intlist(value)
        return retval
1302913
def assign(self, expr):
        """"""
        name = self.variable()
        self.statements.append(ast.Assign([ast.Name(name, ast.Store())], expr))
        return ast.Name(name, ast.Load())