What about adding a step function to turn it into a Progression?
This is easy, because all we really need to do is provide a step parameter and an implementation of the step infix operator. The way that this works is fairly simple. If we have a for loop:
for(d in startDay..endDay step 2){
println(d)
}
Then the rangeTo function is called with startDay and endDay and this creates a Range object, i.e. a Progression object with a step size of 1. Next the step infix operator is called on the object that the rangeTo function returned i.e. range.step(2) and this has to use the Range object to construct a Progression object with the same start and end dates and a step size as specified.
If we were creating the Progression class "properly" then we would implement it as a class, and the Range class would inherit from it – after all what is a Range but a Progression with step=1.
For simplicity let's just modify the code that we have for Range and turn it into a Progression in all but name.
First we need to update the DataRangeIterator to use a step parameter:
class DateRangeIterator(val start: Date, val endInclusive: Date, val step: Long) : Iterator<Date> {
private var current = start
override fun hasNext(): Boolean {
if (current > endInclusive) return false
return true
}
override fun next(): Date {
var next = Date(current.getTime())
current.setTime(current.getTime() + step * 24 * 60 * 60 * 1000)
return next
}
}
Notice that step is specified in days.
With this change we need to modify the DataRange class to set the new step parameter:
class DateRange(override val start: Date, override val endInclusive: Date, val step: Long = 1) : Iterable<Date>, ClosedRange<Date> { override fun iterator(): Iterator<Date> { return DateRangeIterator(start, endInclusive, step) } }
Notice that the default value of 1 for the step parameter means that this can be called to create a range i.e. without a step argument at all. The rangeTo function stays the same:
operator fun Date.rangeTo(other: Date) = DateRange(this, other)
where the DataRange object really is treated as a DateRange object i.e. step=1.
This is called on the DateRange object that the rangeTo creates, and it uses it to construct a new DateRange object but this time with a step size that is something other than one. In a more general setting this would create an instance of a different class to DateRange i.e. DateProgression, but there is no real difference in implementation.
Now we can write:
val dfm = SimpleDateFormat("yyyy-MM-dd")
val startDay = dfm.parse("2017-01-01")
val endDay = dfm.parse("2017-01-07")
for (d in startDay..endDay step 2) {
println(d)
}
which produces
Sun Jan 01 00:00:00 GMT 2017
Tue Jan 03 00:00:00 GMT 2017
Thu Jan 05 00:00:00 GMT 2017
Sat Jan 07 00:00:00 GMT 2017
There are lots of things missing from this implementation of a Progression object – there are no checks for a positive step size, and there are lots of missing methods – downTo, reversed and so on – but it does illustrate how flexible the implementation of the Kotlin for loop can be.
Chapter Summary
(italicized text refers to material not included in this extract)
Collections store objects as references and make use of generics to work with any type of object.
The base class is Collection but List and MutableList are the best examples of how collections work.
Collections generally have factory methods such as collectionOf to create initialized instances. Some also make use of their constructor and an initialization function.
Kotlin collections come in mutable and immutable versions. The immutable version is more like a read-only type than a true immutable data structure.
The other core collection types are Maps and Sets.
A Map stores key value pairs.
A Set stores objects in no particular order without duplicates.
An iterator is an object with at least two methods – next which returns the next object and hasNext which is true if there is a next object.
Iterators are used to implement for loops and other basic Kotlin constructs and you can implement custom iterators.
Sequences are lazy iterators designed to make functional programming in Kotlin more efficient.
A Range is a special sort of iterator that has a start and stop value.
The Wasmer team has released Wasmer 5.0. The WebAssembly runtime adds experimental support for more back ends including V8, Wasmi and WAMR. It also now has iOS support, and upgraded compilers includin [ ... ]
The offspring of that partnership is pg_duckdb, an extension that embeds the DuckDB engine into the PostgreSQL database, allowing it to handle analytical workloads.
