core :: Range :: reverse_iterator
Gets an iterator starting at the end and going backwardscore :: Collection :: CONCURRENT
Type of the concurrent variant of this collectioncore :: Object :: class_factory
Implementation used byget_class
to create the specific class.
core :: Collection :: combinations
Allr
-length combinations on self (in same order) without repeated elements.
core :: Collection :: combinations_with_replacement
Allr
-length combination on self (in same order) with repeated elements.
core :: Object :: defaultinit
core :: Collection :: defaultinit
core :: Collection :: has_all
Does the collection contain at least each element ofother
?
core :: Collection :: has_any
Does the collection contain at least one element ofother
?
core :: Collection :: has_exactly
Does the collection contain exactly all the elements ofother
?
core :: Object :: is_same_instance
Return true ifself
and other
are the same instance (i.e. same identity).
core :: Object :: is_same_serialized
Isself
the same as other
in a serialization context?
core :: Object :: is_same_type
Return true ifself
and other
have the same dynamic type.
core :: Object :: output_class_name
Display class name on stdout (debug only).core :: Collection :: permutations
Allr
-length permutations on self (all possible ordering) without repeated elements.
core :: Collection :: product
Cartesian product, overr
times self
.
core :: Range :: reverse_iterator
Gets an iterator starting at the end and going backwardscore :: Collection :: to_concurrent
Wrapsself
in a thread-safe collection
core :: Collection :: to_counter
Create and fill up a counter with the elements of `self.core :: Collection :: to_curlslist
Convert Collection[String] to CURLSListcore :: Collection :: to_shuffle
Return a new array made of elements in a random order.
# Range of discrete objects.
class Range[E: Discrete]
super Collection[E]
redef var first
# Get the last element.
var last: E
# Get the element after the last one.
var after: E
# assert [1..10].has(5)
# assert [1..10].has(10)
# assert not [1..10[.has(10)
redef fun has(item) do return item isa Comparable and item >= first and item <= last
# assert [1..1].has_only(1)
# assert not [1..10].has_only(1)
redef fun has_only(item) do return first == item and item == last or is_empty
# assert [1..10].count(1) == 1
# assert [1..10].count(0) == 0
redef fun count(item)
do
if has(item) then
return 1
else
return 0
end
end
redef fun iterator do return new IteratorRange[E](self)
# Gets an iterator starting at the end and going backwards
#
# var reviter = [1..4].reverse_iterator
# assert reviter.to_a == [4,3,2,1]
#
# reviter = [1..4[.reverse_iterator
# assert reviter.to_a == [3,2,1]
fun reverse_iterator: Iterator[E] do return new ReverseIteratorRange[E](self)
# assert [1..10].length == 10
# assert [1..10[.length == 9
# assert [1..1].length == 1
# assert [1..-10].length == 0
redef fun length
do
if is_empty then return 0
var nb = first.distance(after)
if nb > 0 then
return nb
else
return 0
end
end
# assert not [1..10[.is_empty
# assert not [1..1].is_empty
# assert [1..-10].is_empty
redef fun is_empty do return first >= after
# Create a range [`from`, `to`].
# The syntax `[from..to]` is equivalent.
#
# var a = [10..15]
# var b = new Range[Int] (10,15)
# assert a == b
# assert a.to_a == [10, 11, 12, 13, 14, 15]
init(from: E, to: E) is old_style_init do
first = from
last = to
after = to.successor(1)
end
# Create a range [`from`, `to`[.
# The syntax `[from..to[` is equivalent.
#
# var a = [10..15[
# var b = new Range[Int].without_last(10,15)
# assert a == b
# assert a.to_a == [10, 11, 12, 13, 14]
init without_last(from: E, to: E)
do
first = from
if from <= to then
last = to.predecessor(1)
after = to
else
last = to.successor(1)
after = to
end
end
# Two ranges are equals if they have the same first and last elements.
#
# var a = new Range[Int](10, 15)
# var b = new Range[Int].without_last(10, 15)
# assert a == [10..15]
# assert a == [10..16[
# assert not a == [10..15[
# assert b == [10..15[
# assert b == [10..14]
# assert not b == [10..15]
redef fun ==(o) do
return o isa Range[E] and self.first == o.first and self.last == o.last
end
# var a = new Range[Int](10, 15)
# assert a.hash == 455
# var b = new Range[Int].without_last(10, 15)
# assert b.hash == 432
redef fun hash do
# 11 and 23 are magic numbers empirically determined to be not so bad.
return first.hash * 11 + last.hash * 23
end
# Gets an iterator that progress with a given step.
#
# The main usage is in `for` construction.
#
# ~~~
# for i in [10..25].step(10) do assert i == 10 or i == 20
# ~~~
#
# But `step` is usable as any kind of iterator.
#
# ~~~
# assert [10..27].step(5).to_a == [10,15,20,25]
# ~~~
#
# If `step == 1`, then it is equivalent to the default `iterator`.
#
# ~~~
# assert [1..5].step(1).to_a == [1..5].to_a
# ~~~
#
# If `step` is negative, then the iterator will iterate on ranges whose `first` > `last`.
#
# ~~~
# assert [25..12].step(-5).to_a == [25,20,15]
# ~~~
#
# On such ranges, the default `iterator` will be empty
#
# ~~~
# assert [5..1].step(1).to_a.is_empty
# assert [5..1].iterator.to_a.is_empty
# assert [5..1].to_a.is_empty
# assert [5..1].is_empty
# ~~~
#
# Note that on non-empty range, iterating with a negative step will be empty
#
# ~~~
# assert [1..5].step(-1).to_a.is_empty
# ~~~
fun step(step: Int): Iterator[E]
do
var i
if step >= 0 then
i = iterator
else
i = new DowntoIteratorRange[E](self)
step = -step
end
if step == 1 then return i
return i.to_step(step)
end
end
lib/core/collection/range.nit:18,1--189,3