Add orEmpty extensions for immutable collections

[Goooler]

Closes #182.

[st-hocnguyen]

What about PersistentList.orEmpty: PersistentList, PersistentMap.orEmpty: PersistentMap and PersistentSet.orEmpty: PersistentSet overloads 🙏 ?

[Goooler]

Persistent* extends Immutable*, these extensions work for both of them.

[st-hocnguyen]

Persistent* extends Immutable*, these extensions work for both of them.

But when we need a value of Persistent*, we must do orEmpty().toPersistent*(). I think adding above overloads is useful 🙏 . Just call val nonEmpty: PersistentList<T> = persistentList.orEmpty()

[Goooler]

Seems we can return Persistent* as the value, WHYT?

[hoc081098]

Seems we can return Persistent* as the value, WHYT?

The change of return type to Persistent is inefficient.

For example, if the list is ImmutableList, but is not PersistentList, orEmpty will convert it to PersistentList, it is inefficient.

The better way is having two overloads, that avoids unnecessary operations.

[Goooler]

I didn't take immutable*Of as the implementation due to the deprecations, they are not suggested to be used.

kotlinx.collections.immutable/core/commonMain/src/extensions.kt

Lines 513 to 570 in 1d18389

	/**
	* Returns a new persistent list of the specified elements.
	*/
	@Deprecated("Use persistentListOf instead.", ReplaceWith("persistentListOf(*elements)"))
	public fun <E> immutableListOf(vararg elements: E): PersistentList<E> = persistentListOf(*elements)
	/**
	* Returns an empty persistent list.
	*/
	@Deprecated("Use persistentListOf instead.", ReplaceWith("persistentListOf()"))
	public fun <E> immutableListOf(): PersistentList<E> = persistentListOf()
	/**
	* Returns a new persistent set with the given elements.
	*
	* Elements of the returned set are iterated in the order they were specified.
	*/
	@Deprecated("Use persistentSetOf instead.", ReplaceWith("persistentSetOf(*elements)"))
	public fun <E> immutableSetOf(vararg elements: E): PersistentSet<E> = persistentSetOf(*elements)
	/**
	* Returns an empty persistent set.
	*/
	@Deprecated("Use persistentSetOf instead.", ReplaceWith("persistentSetOf()"))
	public fun <E> immutableSetOf(): PersistentSet<E> = persistentSetOf()
	/**
	* Returns a new persistent set with the given elements.
	*
	* Order of the elements in the returned set is unspecified.
	*/
	@Deprecated("Use persistentHashSetOf instead.", ReplaceWith("persistentHashSetOf(*elements)"))
	public fun <E> immutableHashSetOf(vararg elements: E): PersistentSet<E> = persistentHashSetOf(*elements)
	/**
	* Returns a new persistent map with the specified contents, given as a list of pairs
	* where the first component is the key and the second is the value.
	*
	* If multiple pairs have the same key, the resulting map will contain the value from the last of those pairs.
	*
	* Entries of the map are iterated in the order they were specified.
	*/
	@Deprecated("Use persistentMapOf instead.", ReplaceWith("persistentMapOf(*pairs)"))
	public fun <K, V> immutableMapOf(vararg pairs: Pair<K, V>): PersistentMap<K, V> = persistentMapOf(*pairs)
	/**
	* Returns a new persistent map with the specified contents, given as a list of pairs
	* where the first component is the key and the second is the value.
	*
	* If multiple pairs have the same key, the resulting map will contain the value from the last of those pairs.
	*
	* Order of the entries in the returned map is unspecified.
	*/
	@Deprecated("Use persistentHashMapOf instead.", ReplaceWith("persistentHashMapOf(*pairs)"))
	public fun <K, V> immutableHashMapOf(vararg pairs: Pair<K, V>): PersistentMap<K, V> = persistentHashMapOf(*pairs)

[qurbonzoda]

It makes sense to add the same extensions for Persistent counterparts as well.
However, let's postpone adding new extensions until we have a clear solution for handling the issue of stdlib overloads having precedence. See #10 and #181 for details.