type OrderedMap[K, V any] struct{ /* private fields */ }

// Constructor function
func NewOrderedMap[K, V any](cmp func(K, K) int) *OrderedMap[K, V] {}

// And Ordered type version, but the name is a bit long 😂
func NewOrderedMapOfOrderedType[K cmp.Ordered, V any]() *OrderedMap[K, V] {
    return NewOrderedMap(cmp.Compare[K])
}

// Method set
// Insert new pair and return previous value if present.
func (m *OrderedMap[K, V]) Insert(k K, v V) (V, bool) {}
// Get get value associated with k, else return empty and false.
func (m *OrderedMap[K, V]) Get(k K) (V, bool) {}
// Contains judge k in OrderedMap ?
func (m *OrderedMap[K, V]) Contains(k K) bool {}
// Delete entry by key and return stored value if present.
func (m *OrderedMap[K, V]) Delete(k K) (V, bool) {}
// Keys return all keys in ascending order.
func (m *OrderedMap[K, V]) Keys() []K {}
// Values return all values in ascending order by key.
func (m *OrderedMap[K, V]) Values() []V {}
// Clear clear the whole map.
func (m *OrderedMap[K, V]) Clear() {}
// Retain will keep those entry which satisfy the given predicate function.
func (m *OrderedMap[K, V]) Retain(f func(K, V) bool) {}
// Len return number of entries of map
func (m *OrderedMap[K, V]) Len() int {}
// First return the minimum entry.
func (m *OrderedMap[K, V]) First() (Entry[K, V], bool) {}
// Last return the maximum entry.
func (m *OrderedMap[K, V]) Last() (Entry[K, V], bool) {}
// Reverse reverse order of all entries.
func (m *OrderedMap[K, V]) Reverse() *Ordered[K, V] {}
// Merge with another OrderedMap, if key exists, replace it
func (m *OrderedMap[K, V]) Merge(o *OrderedMap[K, V]) {}
// SubMap copy entries between start and end to a new OrderedMap.
func (m *OrderedMap[K, V]) SubMap(start K, end K) *OrderedMap[K, V] {}

// Iter API should after it landing in go.
// ForEach iterate over all entries in the map.
func (m *OrderedMap[K, V]) ForEach(f func(K, V) bool) {}
// Range iterate over range [start, end), this maybe replaced by [SubMap]
func (m *OrderedMap[K, V]) Range(start K, end K, f func(K, V)) {}

// Wrapper of OrderedMap with unit value.
type OrderedSet[T any] struct{ inner *OrderedMap[T, struct{}] }

// Constrcutor function
func NewOrderedSet[T any](cmp func(T, T) int) *OrderedSet[T] {}

// Method set
func (s *OrderedSet[T]) Contains(v T) bool {}
func (s *OrderedSet[T]) ContainsAll(elems ...T) bool {}
func (s *OrderedSet[T]) ContainsAny(elems ...T) bool {}
func (s *OrderedSet[T]) Insert(v T) {}
func (s *OrderedSet[T]) InsertMany(elems ...T) {}
func (s *OrderedSet[T]) Delete(elems ...T) {}
func (s *OrderedSet[T]) First() (T, bool) {}
func (s *OrderedSet[T]) Last() (T, bool) {}
func (s *OrderedSet[T]) Reverse() *OrderedSet[T] {}
func (s *OrderedSet[T]) Len() int {}
func (s *OrderedSet[T]) Retain(f func(T) bool) {}
func (s *OrderedSet[T]) SuperSetOf(o *OrderedSet[T]) bool {}
func (s *OrderedSet[T]) SubSetOf(o *OrderedSet[T]) bool {}
func (s *OrderedSet[T]) InterSection(o *OrderedSet[T]) *OrderedSet[T] {}
func (s *OrderedSet[T]) UnionInPlace(o *OrderedSet[T]) {}
func (s *OrderedSet[T]) Union(o *OrderedSet[T]) *OrderedSet[T] {}
func (s *OrderedSet[T]) Difference(o *OrderedSet[T]) *OrderedSet[T] {}
func (s *OrderedSet[T]) SymmetricDifference(o *OrderedSet[T]) *OrderedSet[T] {}

// Iter API should after it landing in go.
func (s *OrderedSet[T]) ForEach(f func(T)) {}