Basically the same as drive(), but omitting the right motor.
498694
def left_motor(self, speed, durationS=-1.0):
        """"""
        if speed > 0:
            self.left_rev(min(abs(speed), 255))
        else:
            self.left_fwd(min(abs(speed), 255))
        if durationS > 0:
            self.board.sleep(durationS)
            self.left_stop()
942187
def copy(self):
        """"""
        ms = MouseState()
        ms.left_pressed = self.left_pressed
        ms.middle_pressed = self.middle_pressed
        ms.right_pressed = self.right_pressed
        ms.mouse_pos = self.mouse_pos
        return ms
584556
def leaveWhitespace( self ):
        """"""
        self.skipWhitespace = False
        self.exprs = [ e.copy() for e in self.exprs ]
        for e in self.exprs:
            e.leaveWhitespace()
        return self
1344685
function motor (port) {
  port = port || 'a'
  var write = writeAction('motor_write', port)

  /**
   * Run motor forever
   * @param  {Number} speed speed of motor
   * @param  {Object} opts  object of optional params
   */
  function * forever (speed, opts) {
    speed = speed || motorDefaults.speed
    speed = percentToSpeed(speed)

    yield write('run-forever', {
      'speed_sp': speed.toString()
    })
  }

  /**
   * Run motor for a number of degrees
   * @param  {Number} degrees degrees to turn motor
   * @param  {Number} speed   speed at which to turn motors
   */
  function * degrees (deg, speed) {
    speed = speed || motorDefaults.speed
    speed = percentToSpeed(speed)

    yield * writeAndWait('run-to-rel-pos', {
      'position_sp': deg.toString(),
      'speed_sp': speed.toString()
    })
  }

  /**
   * Run motor for a number of rotations
   * @param  {Number} rotations number of rotations to turn the motor
   * @param  {Number} speed     speed at which to turn motors
   */
  function * rotations (rots, speed) {
    speed = speed || motorDefaults.speed
    yield * this.degrees(Math.round(rots * 360), speed)
  }

  /**
   * Run drive motors for a specified amount of time
   * @param  {Number} time  time to run the motors for (in milliseconds)
   * @param  {Number} speed speed at which to turn motors
   */
  function * timed (time, speed) {
    speed = speed || motorDefaults.speed
    speed = percentToSpeed(speed)

    yield * writeAndWait('run-timed', {
      'time_sp': time.toString(),
      'speed_sp': speed.toString()
    })
  }

  /**
   * Stops motors
   */
  function * stop () {
    yield write('stop')
  }

 /**
  * Write and hold execution until the motor are done moving
  * @private
  * @param  {string} command move command
  * @param  {object} opts    move options
  */
  function * writeAndWait (command, opts) {
    var ran = false
    yield write(command, opts)
    while (true) {
      var devices = yield read()
      if (devices.motor(port) === 'running') {
        ran = true
      }
      if (devices.motor(port) === '' && ran) {
        break
      }
    }
  }

  /**
   * @typedef {object} MoveFunctions
   * @property {function} forever     {@link forever}
   * @property {function} degrees     {@link degrees}
   * @property {function} rotations   {@link rotations}
   * @property {function} timed       {@link timed}
   * @property {function} Stops       {@link stop}
   */
  return {
    forever: forever,
    degrees: degrees,
    rotations: rotations,
    timed: timed,
    stop: stop
  }
}
1262109
def rotate_right(self, seconds=None):
        """"""
        self._move(speed=0, steering=-STEER_MAX, seconds=seconds)
900727
function omit(keys, obj) {
  if(!isFoldable(keys)) {
    throw new TypeError('omit: Foldable required for first argument')
  }
  else if(!isObject(obj)) {
    throw new TypeError('omit: Object required for second argument')
  }

  return Object.keys(obj).reduce(omitKeys(keys, obj), {})
}
931754
def _skip(self, cnt):
        

        while cnt > 0:
            # next vol needed?
            if self._cur_avail == 0:
                if not self._open_next():
                    break

            # fd is in read pos, do the read
            if cnt > self._cur_avail:
                cnt -= self._cur_avail
                self._remain -= self._cur_avail
                self._cur_avail = 0
            else:
                self._fd.seek(cnt, 1)
                self._cur_avail -= cnt
                self._remain -= cnt
                cnt = 0
363462
def has_rotational(self):
        """"""
        for member in self._drives_list():
            if member.media_type == constants.MEDIA_TYPE_HDD:
                return True
        return False
965112
private int skipArc(int offset) {
		if (isNextSet(offset)) {
			if (isLabelCompressed(offset)) {
				offset++;
			} else {
				offset += 1 + 1;
			}
		} else {
			offset += 1 + gtl;
		}
		return offset;
	}
36813
void robotMove(int nx, int ny)
    {
        oldX = x;
        oldY = y;
        x = nx;
        y = ny;
        wx = nx;
        wy = ny;
        mx = x - oldX;
        my = y - oldY;
        moved = true;
    }
1231984
function omit(object, keysToOmit) {
  const result = {};

  Object.keys(object).forEach(key => {
    if (keysToOmit.indexOf(key) === -1) {
      result[key] = object[key];
    }
  });

  return result;
}
1021357
function omit(a, elt) {
  var index = a.indexOf(elt);
  if (index !== -1) {
    a.splice(index, 1);
  }
  return a;
}
650308
private void copy() {
        if (elems.nonEmpty()) {
            List<A> orig = elems;

            elems = last = List.of(orig.head);

            while ((orig = orig.tail).nonEmpty()) {
                last.tail = List.of(orig.head);
                last = last.tail;
            }
        }
    }
1273595
function exit()
{
    if (motor)
    {
	motor = null;
	mdObj.cleanUp();
    }
    mdObj = null;
    console.log("Exiting");
    process.exit(0);	
}
1217568
def _set_speed(self, motor, speed):
        
        self._validate_motor(motor)
        en, in1, in2 = self._motors[motor-1]

        if speed == 0:
            en.pwm_stop()
            in1.set(False)
            in2.set(False)
        elif speed > 0:
            en.pwm_start(abs(speed))
            in1.set(True)
            in2.set(False)
        else:
            en.pwm_start(abs(speed))
            in1.set(False)
            in2.set(True)
1248258
def _set_vibration_nix(self, left_motor, right_motor, duration):
        """"""
        code = self.__get_vibration_code(left_motor, right_motor, duration)
        secs, msecs = convert_timeval(time.time())
        outer_event = struct.pack(EVENT_FORMAT, secs, msecs, 0x15, code, 1)
        self._write_device.write(outer_event)
        self._write_device.flush()
909115
private int skipAhead(RunContainer skippingOn, int pos, int targetToExceed) {
    int left = pos;
    int span = 1;
    int probePos = 0;
    int end;
    // jump ahead to find a spot where end > targetToExceed (if it exists)
    do {
      probePos = left + span;
      if (probePos >= skippingOn.nbrruns - 1) {
        // expect it might be quite common to find the container cannot be advanced as far as
        // requested. Optimize for it.
        probePos = skippingOn.nbrruns - 1;
        end = toIntUnsigned(skippingOn.getValue(probePos))
            + toIntUnsigned(skippingOn.getLength(probePos)) + 1;
        if (end <= targetToExceed) {
          return skippingOn.nbrruns;
        }
      }
      end = toIntUnsigned(skippingOn.getValue(probePos))
          + toIntUnsigned(skippingOn.getLength(probePos)) + 1;
      span *= 2;
    } while (end <= targetToExceed);
    int right = probePos;
    // left and right are both valid positions. Invariant: left <= targetToExceed && right >
    // targetToExceed
    // do a binary search to discover the spot where left and right are separated by 1, and
    // invariant is maintained.
    while (right - left > 1) {
      int mid = (right + left) / 2;
      int midVal = toIntUnsigned(skippingOn.getValue(mid))
          + toIntUnsigned(skippingOn.getLength(mid)) + 1;
      if (midVal > targetToExceed) {
        right = mid;
      } else {
        left = mid;
      }
    }
    return right;
  }