kyouko-taiga

Generic programming with type classes

Generic programming is a discipline that encourages the construction of abstractions and the reuse of software component without loss of efficiency. Subtyping through inheritance can be adversary to this goal because it encourages type erasure, promising that efficiency is maintained thanks to dynamic dispatch. Sadly, this promise gets broken when generic data structures and algorithms depend on more than one generic receiver. In those instances, one must resort to generic parameters to preserve type information, introducing expensive annotation costs. This short article examine this problem and then discusses how type classes, an alternative approach to practice generic programming, can address many of the issues presented by subtyping through inheritance.

Disclaimer:

kyouko-taiga

/// A type representing a collection of values.
public trait Collection {

  /// The type of the `Self`'s elements.
  type Element

  /// The type of a position in `Self`.
  type Index: Equatable

  /// Returns `self`'s first position.

kyouko-taiga

import Darwin

/// A slab allocator, implemented as a collection of "arrays with tombstones".
///
/// It's a kind of array with stable indices.
public struct Slab<T> {

  public struct Index {

    fileprivate let bucket: Int

kyouko-taiga

infix operator ➡️: AdditionPrecedence

enum 🖇<🤖>: Collection, CustomStringConvertible {

    indirect case 📎(🤖, 🖇)
    case 🚫

    func makeIterator() -> AnyIterator<🤖> {
        var 📌 = self
        return AnyIterator {

kyouko-taiga

# This snippet was written by Dimitri Racordon (kyouko.taiga@gmail.com)
#
# Copyright (c) 2015 Dimitri Racordon
# Licensed under the The MIT License (MIT).

class lazy(object):

    # This class is heavily inspired by the werkzeug.utils.cached_property
    # decorator. It transforms a class method to a lazy property, evaluated
    # the first time the property is accessed.