Renamed NumberSequence to Progression.

runtime/src/jet/ByteProgression.java

@@ -19,12 +19,12 @@ package jet;
 import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
 
 @AssertInvisibleInResolver
-public class ByteSequence implements NumberSequence<Byte> {
+public class ByteProgression implements Progression<Byte> {
     private final byte start;
     private final byte end;
     private final int increment;
 
-    public ByteSequence(byte start, byte end, int increment) {
+    public ByteProgression(byte start, byte end, int increment) {
         if (increment == 0) {
             throw new IllegalArgumentException("Increment must be non-zero: " + increment);
         }
@@ -50,7 +50,7 @@ public class ByteSequence implements NumberSequence<Byte> {
 
     @Override
     public ByteIterator iterator() {
-        return new ByteSequenceIterator(start, end, increment);
+        return new ByteProgressionIterator(start, end, increment);
     }
 
     @Override
@@ -68,7 +68,7 @@ public class ByteSequence implements NumberSequence<Byte> {
         if (this == o) return true;
         if (o == null || getClass() != o.getClass()) return false;
 
-        ByteSequence bytes = (ByteSequence) o;
+        ByteProgression bytes = (ByteProgression) o;
 
         if (end != bytes.end) return false;
         if (increment != bytes.increment) return false;

runtime/src/jet/ByteProgressionIterator.java

@@ -16,12 +16,12 @@
 
 package jet;
 
-class ByteSequenceIterator extends ByteIterator {
+class ByteProgressionIterator extends ByteIterator {
     private byte next;
     private final byte end;
     private final int increment;
 
-    public ByteSequenceIterator(byte start, byte end, int increment) {
+    public ByteProgressionIterator(byte start, byte end, int increment) {
         this.next = start;
         this.end = end;
         this.increment = increment;

runtime/src/jet/ByteRange.java

@@ -19,7 +19,7 @@ package jet;
 import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
 
 @AssertInvisibleInResolver
-public final class ByteRange implements Range<Byte>, NumberSequence<Byte> {
+public final class ByteRange implements Range<Byte>, Progression<Byte> {
     public static final ByteRange EMPTY = new ByteRange((byte) 1, (byte) 0);
 
     private final byte start;
@@ -56,7 +56,7 @@ public final class ByteRange implements Range<Byte>, NumberSequence<Byte> {
 
     @Override
     public ByteIterator iterator() {
-        return new ByteSequenceIterator(start, end, 1);
+        return new ByteProgressionIterator(start, end, 1);
     }
 
     @Override

runtime/src/jet/CharProgression.java

@@ -19,12 +19,12 @@ package jet;
 import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
 
 @AssertInvisibleInResolver
-public class CharacterSequence implements NumberSequence<Character> {
+public class CharProgression implements Progression<Character> {
     private final char start;
     private final char end;
     private final int increment;
 
-    public CharacterSequence(char start, char end, int increment) {
+    public CharProgression(char start, char end, int increment) {
         if (increment == 0) {
             throw new IllegalArgumentException("Increment must be non-zero: " + increment);
         }
@@ -50,7 +50,7 @@ public class CharacterSequence implements NumberSequence<Character> {
 
     @Override
     public CharIterator iterator() {
-        return new CharacterSequenceIterator(start, end, increment);
+        return new CharProgressionIterator(start, end, increment);
     }
 
     @Override
@@ -68,7 +68,7 @@ public class CharacterSequence implements NumberSequence<Character> {
         if (this == o) return true;
         if (o == null || getClass() != o.getClass()) return false;
 
-        CharacterSequence that = (CharacterSequence) o;
+        CharProgression that = (CharProgression) o;
 
         if (end != that.end) return false;
         if (increment != that.increment) return false;

runtime/src/jet/CharProgressionIterator.java

@@ -16,12 +16,12 @@
 
 package jet;
 
-class CharacterSequenceIterator extends CharIterator {
+class CharProgressionIterator extends CharIterator {
     private char next;
     private final char end;
     private final int increment;
 
-    public CharacterSequenceIterator(char start, char end, int increment) {
+    public CharProgressionIterator(char start, char end, int increment) {
         this.next = start;
         this.end = end;
         this.increment = increment;

runtime/src/jet/CharRange.java

@@ -19,7 +19,7 @@ package jet;
 import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
 
 @AssertInvisibleInResolver
-public final class CharRange implements Range<Character>, NumberSequence<Character> {
+public final class CharRange implements Range<Character>, Progression<Character> {
     public static final CharRange EMPTY = new CharRange((char) 1, (char) 0);
 
     private final char start;
@@ -56,7 +56,7 @@ public final class CharRange implements Range<Character>, NumberSequence<Charact
 
     @Override
     public CharIterator iterator() {
-        return new CharacterSequenceIterator(start, end, 1);
+        return new CharProgressionIterator(start, end, 1);
     }
 
     @Override

runtime/src/jet/DoubleProgression.java

@@ -19,12 +19,12 @@ package jet;
 import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
 
 @AssertInvisibleInResolver
-public class DoubleSequence implements NumberSequence<Double> {
+public class DoubleProgression implements Progression<Double> {
     private final double start;
     private final double end;
     private final double increment;
 
-    public DoubleSequence(double start, double end, double increment) {
+    public DoubleProgression(double start, double end, double increment) {
         if (increment == 0.0 || increment == -0.0) {
             throw new IllegalArgumentException("Increment must be non-zero: " + increment);
         }
@@ -50,7 +50,7 @@ public class DoubleSequence implements NumberSequence<Double> {
 
     @Override
     public DoubleIterator iterator() {
-        return new DoubleSequenceIterator(start, end, increment);
+        return new DoubleProgressionIterator(start, end, increment);
     }
 
     @Override
@@ -68,7 +68,7 @@ public class DoubleSequence implements NumberSequence<Double> {
         if (this == o) return true;
         if (o == null || getClass() != o.getClass()) return false;
 
-        DoubleSequence doubles = (DoubleSequence) o;
+        DoubleProgression doubles = (DoubleProgression) o;
 
         if (Double.compare(doubles.end, end) != 0) return false;
         if (Double.compare(doubles.increment, increment) != 0) return false;

runtime/src/jet/DoubleProgressionIterator.java

@@ -16,12 +16,12 @@
 
 package jet;
 
-class DoubleSequenceIterator extends DoubleIterator {
+class DoubleProgressionIterator extends DoubleIterator {
     private double next;
     private final double end;
     private final double increment;
 
-    public DoubleSequenceIterator(double start, double end, double increment) {
+    public DoubleProgressionIterator(double start, double end, double increment) {
         this.next = start;
         this.end = end;
         this.increment = increment;

runtime/src/jet/DoubleRange.java

@@ -19,7 +19,7 @@ package jet;
 import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
 
 @AssertInvisibleInResolver
-public final class DoubleRange implements Range<Double>, NumberSequence<Double> {
+public final class DoubleRange implements Range<Double>, Progression<Double> {
     public static final DoubleRange EMPTY = new DoubleRange(1, 0);
 
     private final double start;
@@ -56,7 +56,7 @@ public final class DoubleRange implements Range<Double>, NumberSequence<Double>
 
     @Override
     public DoubleIterator iterator() {
-        return new DoubleSequenceIterator(start, end, 1.0);
+        return new DoubleProgressionIterator(start, end, 1.0);
     }
 
     @Override

runtime/src/jet/FloatProgression.java

@@ -19,12 +19,12 @@ package jet;
 import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
 
 @AssertInvisibleInResolver
-public class FloatSequence implements NumberSequence<Float> {
+public class FloatProgression implements Progression<Float> {
     private final float start;
     private final float end;
     private final float increment;
 
-    public FloatSequence(float start, float end, float increment) {
+    public FloatProgression(float start, float end, float increment) {
         if (increment == 0.0f || increment == -0.0f) {
             throw new IllegalArgumentException("Increment must be non-zero: " + increment);
         }
@@ -50,7 +50,7 @@ public class FloatSequence implements NumberSequence<Float> {
 
     @Override
     public FloatIterator iterator() {
-        return new FloatSequenceIterator(start, end, increment);
+        return new FloatProgressionIterator(start, end, increment);
     }
 
     @Override
@@ -68,7 +68,7 @@ public class FloatSequence implements NumberSequence<Float> {
         if (this == o) return true;
         if (o == null || getClass() != o.getClass()) return false;
 
-        FloatSequence floats = (FloatSequence) o;
+        FloatProgression floats = (FloatProgression) o;
 
         if (Float.compare(floats.end, end) != 0) return false;
         if (Float.compare(floats.increment, increment) != 0) return false;

runtime/src/jet/FloatProgressionIterator.java

@@ -16,12 +16,12 @@
 
 package jet;
 
-class FloatSequenceIterator extends FloatIterator {
+class FloatProgressionIterator extends FloatIterator {
     private float next;
     private final float end;
     private final float increment;
 
-    public FloatSequenceIterator(float start, float end, float increment) {
+    public FloatProgressionIterator(float start, float end, float increment) {
         this.next = start;
         this.end = end;
         this.increment = increment;

runtime/src/jet/FloatRange.java

@@ -19,7 +19,7 @@ package jet;
 import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
 
 @AssertInvisibleInResolver
-public final class FloatRange implements Range<Float>, NumberSequence<Float> {
+public final class FloatRange implements Range<Float>, Progression<Float> {
     public static final FloatRange EMPTY = new FloatRange(1, 0);
 
     private final float start;
@@ -56,7 +56,7 @@ public final class FloatRange implements Range<Float>, NumberSequence<Float> {
 
     @Override
     public FloatIterator iterator() {
-        return new FloatSequenceIterator(start, end, 1);
+        return new FloatProgressionIterator(start, end, 1);
     }
 
     @Override

runtime/src/jet/IntProgression.java

@@ -19,12 +19,12 @@ package jet;
 import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
 
 @AssertInvisibleInResolver
-public class IntSequence implements NumberSequence<Integer> {
+public class IntProgression implements Progression<Integer> {
     private final int start;
     private final int end;
     private final int increment;
 
-    public IntSequence(int start, int end, int increment) {
+    public IntProgression(int start, int end, int increment) {
         if (increment == 0) {
             throw new IllegalArgumentException("Increment must be non-zero: " + increment);
         }
@@ -50,7 +50,7 @@ public class IntSequence implements NumberSequence<Integer> {
 
     @Override
     public IntIterator iterator() {
-        return new IntSequenceIterator(start, end, increment);
+        return new IntProgressionIterator(start, end, increment);
     }
 
     @Override
@@ -68,7 +68,7 @@ public class IntSequence implements NumberSequence<Integer> {
         if (this == o) return true;
         if (o == null || getClass() != o.getClass()) return false;
 
-        IntSequence sequence = (IntSequence) o;
+        IntProgression sequence = (IntProgression) o;
 
         if (end != sequence.end) return false;
         if (increment != sequence.increment) return false;

runtime/src/jet/IntProgressionIterator.java

@@ -16,12 +16,12 @@
 
 package jet;
 
-class IntSequenceIterator extends IntIterator {
+class IntProgressionIterator extends IntIterator {
     private int next;
     private final int end;
     private final int increment;
 
-    public IntSequenceIterator(int start, int end, int increment) {
+    public IntProgressionIterator(int start, int end, int increment) {
         this.next = start;
         this.end = end;
         this.increment = increment;

runtime/src/jet/IntRange.java

@@ -19,7 +19,7 @@ package jet;
 import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
 
 @AssertInvisibleInResolver
-public final class IntRange implements Range<Integer>, NumberSequence<Integer> {
+public final class IntRange implements Range<Integer>, Progression<Integer> {
     public static final IntRange EMPTY = new IntRange(1, 0);
 
     private final int start;
@@ -56,7 +56,7 @@ public final class IntRange implements Range<Integer>, NumberSequence<Integer> {
 
     @Override
     public IntIterator iterator() {
-        return new IntSequenceIterator(start, end, 1);
+        return new IntProgressionIterator(start, end, 1);
     }
 
     @Override

runtime/src/jet/LongProgression.java

@@ -19,12 +19,12 @@ package jet;
 import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
 
 @AssertInvisibleInResolver
-public class LongSequence implements NumberSequence<Long> {
+public class LongProgression implements Progression<Long> {
     private final long start;
     private final long end;
     private final long increment;
 
-    public LongSequence(long start, long end, long increment) {
+    public LongProgression(long start, long end, long increment) {
         if (increment == 0) {
             throw new IllegalArgumentException("Increment must be non-zero: " + increment);
         }
@@ -50,7 +50,7 @@ public class LongSequence implements NumberSequence<Long> {
 
     @Override
     public LongIterator iterator() {
-        return new LongSequenceIterator(start, end, increment);
+        return new LongProgressionIterator(start, end, increment);
     }
 
     @Override
@@ -68,7 +68,7 @@ public class LongSequence implements NumberSequence<Long> {
         if (this == o) return true;
         if (o == null || getClass() != o.getClass()) return false;
 
-        LongSequence longs = (LongSequence) o;
+        LongProgression longs = (LongProgression) o;
 
         if (end != longs.end) return false;
         if (increment != longs.increment) return false;

runtime/src/jet/LongProgressionIterator.java

@@ -16,12 +16,12 @@
 
 package jet;
 
-class LongSequenceIterator extends LongIterator {
+class LongProgressionIterator extends LongIterator {
     private long next;
     private final long end;
     private final long increment;
 
-    public LongSequenceIterator(long start, long end, long increment) {
+    public LongProgressionIterator(long start, long end, long increment) {
         this.next = start;
         this.end = end;
         this.increment = increment;

runtime/src/jet/LongRange.java

@@ -19,7 +19,7 @@ package jet;
 import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
 
 @AssertInvisibleInResolver
-public final class LongRange implements Range<Long>, NumberSequence<Long> {
+public final class LongRange implements Range<Long>, Progression<Long> {
     public static final LongRange EMPTY = new LongRange(1, 0);
 
     private final long start;
@@ -56,7 +56,7 @@ public final class LongRange implements Range<Long>, NumberSequence<Long> {
 
     @Override
     public LongIterator iterator() {
-        return new LongSequenceIterator(start, end, 1);
+        return new LongProgressionIterator(start, end, 1);
     }
 
     @Override

runtime/src/jet/Progression.java

@@ -19,7 +19,7 @@ package jet;
 import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
 
 @AssertInvisibleInResolver
-public interface NumberSequence<N> extends Iterable<N> {
+public interface Progression<N> extends Iterable<N> {
     N getStart();
     N getEnd();
     Number getIncrement();

runtime/src/jet/ShortProgression.java

@@ -19,12 +19,12 @@ package jet;
 import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
 
 @AssertInvisibleInResolver
-public class ShortSequence implements NumberSequence<Short> {
+public class ShortProgression implements Progression<Short> {
     private final short start;
     private final short end;
     private final int increment;
 
-    public ShortSequence(short start, short end, int increment) {
+    public ShortProgression(short start, short end, int increment) {
         if (increment == 0) {
             throw new IllegalArgumentException("Increment must be non-zero: " + increment);
         }
@@ -50,7 +50,7 @@ public class ShortSequence implements NumberSequence<Short> {
 
     @Override
     public ShortIterator iterator() {
-        return new ShortSequenceIterator(start, end, increment);
+        return new ShortProgressionIterator(start, end, increment);
     }
 
     @Override
@@ -68,7 +68,7 @@ public class ShortSequence implements NumberSequence<Short> {
         if (this == o) return true;
         if (o == null || getClass() != o.getClass()) return false;
 
-        ShortSequence shorts = (ShortSequence) o;
+        ShortProgression shorts = (ShortProgression) o;
 
         if (end != shorts.end) return false;
         if (increment != shorts.increment) return false;

runtime/src/jet/ShortProgressionIterator.java

@@ -16,12 +16,12 @@
 
 package jet;
 
-class ShortSequenceIterator extends ShortIterator {
+class ShortProgressionIterator extends ShortIterator {
     private short next;
     private final short end;
     private final int increment;
 
-    public ShortSequenceIterator(short start, short end, int increment) {
+    public ShortProgressionIterator(short start, short end, int increment) {
         this.next = start;
         this.end = end;
         this.increment = increment;

runtime/src/jet/ShortRange.java

@@ -19,7 +19,7 @@ package jet;
 import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
 
 @AssertInvisibleInResolver
-public final class ShortRange implements Range<Short>, NumberSequence<Short> {
+public final class ShortRange implements Range<Short>, Progression<Short> {
     public static final ShortRange EMPTY = new ShortRange((short) 1, (short) 0);
 
     private final short start;
@@ -56,7 +56,7 @@ public final class ShortRange implements Range<Short>, NumberSequence<Short> {
 
     @Override
     public ShortIterator iterator() {
-        return new ShortSequenceIterator(start, end, 1);
+        return new ShortProgressionIterator(start, end, 1);
     }
 
     @Override