# Thebe

## Jupyter javascript plugin for static sites

A really simple example using the iruby Kernel:

      /*                     __                                               *\
      **     ________ ___   / /  ___     Scala API                            **
      **    / __/ __// _ | / /  / _ |    (c) 2003-2011, LAMP/EPFL             **
      **  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
      ** /____/\___/_/ |_/____/_/ | |                                         **
      **                          |/                                          **
      \*                                                                      */

      package scala.collection

      import generic._
      import mutable.{ Builder, ListBuffer }
      import annotation.{tailrec, migration, bridge}
      import annotation.unchecked.{ uncheckedVariance => uV }
      import parallel.ParIterable

      /** A template trait for traversable collections of type `Traversable[A]`.
       *
       *  $traversableInfo
       *  @define mutability
       *  @define traversableInfo
       *  This is a base trait of all kinds of $mutability Scala collections. It
       *  implements the behavior common to all collections, in terms of a method
       *  `foreach` with signature:
       * {{{
       *     def foreach[U](f: Elem => U): Unit
       * }}}
       *  Collection classes mixing in this trait provide a concrete
       *  `foreach` method which traverses all the
       *  elements contained in the collection, applying a given function to each.
       *  They also need to provide a method `newBuilder`
       *  which creates a builder for collections of the same kind.
       *
       *  A traversable class might or might not have two properties: strictness
       *  and orderedness. Neither is represented as a type.
       *
       *  The instances of a strict collection class have all their elements
       *  computed before they can be used as values. By contrast, instances of
       *  a non-strict collection class may defer computation of some of their
       *  elements until after the instance is available as a value.
       *  A typical example of a non-strict collection class is a
       *
       *  `scala.collection.immutable.Stream`.
       *  A more general class of examples are `TraversableViews`.
       *
       *  If a collection is an instance of an ordered collection class, traversing
       *  its elements with `foreach` will always visit elements in the
       *  same order, even for different runs of the program. If the class is not
       *  ordered, `foreach` can visit elements in different orders for
       *  different runs (but it will keep the same order in the same run).'
       *
       *  A typical example of a collection class which is not ordered is a
       *  `HashMap` of objects. The traversal order for hash maps will
       *  depend on the hash codes of its elements, and these hash codes might
       *  differ from one run to the next. By contrast, a `LinkedHashMap`
       *  is ordered because it's `foreach` method visits elements in the
       *  order they were inserted into the `HashMap`.
       *
       *  @author Martin Odersky
       *  @version 2.8
       *  @since   2.8
       *  @tparam A    the element type of the collection
       *  @tparam Repr the type of the actual collection containing the elements.
       *
       *  @define Coll Traversable
       *  @define coll traversable collection
       */
      trait TraversableLike[+A, +Repr] extends HasNewBuilder[A, Repr]
                                          with FilterMonadic[A, Repr]
                                          with TraversableOnce[A]
                                          with GenTraversableLike[A, Repr]
                                          with Parallelizable[A, ParIterable[A]]
      {
        self =>

        import Traversable.breaks._

        /** The type implementing this traversable */
        protected type Self = Repr

        /** The collection of type $coll underlying this `TraversableLike` object.
         *  By default this is implemented as the `TraversableLike` object itself,
         *  but this can be overridden.
         */
        def repr: Repr = this.asInstanceOf[Repr]

        /** The underlying collection seen as an instance of `$Coll`.
         *  By default this is implemented as the current collection object itself,
         *  but this can be overridden.
         */
        protected[this] def thisCollection: Traversable[A] = this.asInstanceOf[Traversable[A]]

        /** A conversion from collections of type `Repr` to `$Coll` objects.
         *  By default this is implemented as just a cast, but this can be overridden.
         */
        protected[this] def toCollection(repr: Repr): Traversable[A] = repr.asInstanceOf[Traversable[A]]

        /** Creates a new builder for this collection type.
         */
        protected[this] def newBuilder: Builder[A, Repr]

        protected[this] def parCombiner = ParIterable.newCombiner[A]

        /** Applies a function `f` to all elements of this $coll.
         *
         *    Note: this method underlies the implementation of most other bulk operations.
         *    It's important to implement this method in an efficient way.
         *
         *
         *  @param  f   the function that is applied for its side-effect to every element.
         *              The result of function `f` is discarded.
         *
         *  @tparam  U  the type parameter describing the result of function `f`.
         *              This result will always be ignored. Typically `U` is `Unit`,
         *              but this is not necessary.
         *
         *  @usecase def foreach(f: A => Unit): Unit
         */
        def foreach[U](f: A => U): Unit

        /** Tests whether this $coll is empty.
         *
         *  @return    `true` if the $coll contain no elements, `false` otherwise.
         */
        def isEmpty: Boolean = {
          var result = true
          breakable {
            for (x <- this) {
              result = false
              break
            }
          }
          result
        }

        /** Tests whether this $coll is known to have a finite size.
         *  All strict collections are known to have finite size. For a non-strict collection
         *  such as `Stream`, the predicate returns `true` if all elements have been computed.
         *  It returns `false` if the stream is not yet evaluated to the end.
         *
         *  Note: many collection methods will not work on collections of infinite sizes.
         *
         *  @return  `true` if this collection is known to have finite size, `false` otherwise.
         */
        def hasDefiniteSize = true

        def ++[B >: A, That](that: GenTraversableOnce[B])(implicit bf: CanBuildFrom[Repr, B, That]): That = {
          val b = bf(repr)
          if (that.isInstanceOf[IndexedSeqLike[_, _]]) b.sizeHint(this, that.seq.size)
          b ++= thisCollection
          b ++= that.seq
          b.result
        }

        @bridge
        def ++[B >: A, That](that: TraversableOnce[B])(implicit bf: CanBuildFrom[Repr, B, That]): That =
          ++(that: GenTraversableOnce[B])(bf)

        /** Concatenates this $coll with the elements of a traversable collection.
         *  It differs from ++ in that the right operand determines the type of the
         *  resulting collection rather than the left one.
         *
         *  @param that   the traversable to append.
         *  @tparam B     the element type of the returned collection.
         *  @tparam That  $thatinfo
         *  @param bf     $bfinfo
         *  @return       a new collection of type `That` which contains all elements
         *                of this $coll followed by all elements of `that`.
         *
         *  @usecase def ++:[B](that: TraversableOnce[B]): $Coll[B]
         *
         *  @return       a new $coll which contains all elements of this $coll
         *                followed by all elements of `that`.
         */
        def ++:[B >: A, That](that: TraversableOnce[B])(implicit bf: CanBuildFrom[Repr, B, That]): That = {
          val b = bf(repr)
          if (that.isInstanceOf[IndexedSeqLike[_, _]]) b.sizeHint(this, that.size)
          b ++= that
          b ++= thisCollection
          b.result
        }

        /** This overload exists because: for the implementation of ++: we should reuse
         *  that of ++ because many collections override it with more efficient versions.
         *  Since TraversableOnce has no '++' method, we have to implement that directly,
         *  but Traversable and down can use the overload.
         */
        def ++:[B >: A, That](that: Traversable[B])(implicit bf: CanBuildFrom[Repr, B, That]): That =
          (that ++ seq)(breakOut)

        def map[B, That](f: A => B)(implicit bf: CanBuildFrom[Repr, B, That]): That = {
          val b = bf(repr)
          b.sizeHint(this)
          for (x <- this) b += f(x)
          b.result
        }

        def flatMap[B, That](f: A => GenTraversableOnce[B])(implicit bf: CanBuildFrom[Repr, B, That]): That = {
          val b = bf(repr)
          for (x <- this) b ++= f(x).seq
          b.result
        }

        /** Selects all elements of this $coll which satisfy a predicate.
         *
         *  @param p     the predicate used to test elements.
         *  @return      a new $coll consisting of all elements of this $coll that satisfy the given
         *               predicate `p`. The order of the elements is preserved.
         */
        def filter(p: A => Boolean): Repr = {
          val b = newBuilder
          for (x <- this)
            if (p(x)) b += x
          b.result
        }

        /** Selects all elements of this $coll which do not satisfy a predicate.
         *
         *  @param p     the predicate used to test elements.
         *  @return      a new $coll consisting of all elements of this $coll that do not satisfy the given
         *               predicate `p`. The order of the elements is preserved.
         */
        def filterNot(p: A => Boolean): Repr = filter(!p(_))

        def collect[B, That](pf: PartialFunction[A, B])(implicit bf: CanBuildFrom[Repr, B, That]): That = {
          val b = bf(repr)
          for (x <- this) if (pf.isDefinedAt(x)) b += pf(x)
          b.result
        }

        /** Builds a new collection by applying an option-valued function to all
         *  elements of this $coll on which the function is defined.
         *
         *  @param f      the option-valued function which filters and maps the $coll.
         *  @tparam B     the element type of the returned collection.
         *  @tparam That  $thatinfo
         *  @param bf     $bfinfo
         *  @return       a new collection of type `That` resulting from applying the option-valued function
         *                `f` to each element and collecting all defined results.
         *                The order of the elements is preserved.
         *
         *  @usecase def filterMap[B](f: A => Option[B]): $Coll[B]
         *
         *  @param pf     the partial function which filters and maps the $coll.
         *  @return       a new $coll resulting from applying the given option-valued function
         *                `f` to each element and collecting all defined results.
         *                The order of the elements is preserved.
        def filterMap[B, That](f: A => Option[B])(implicit bf: CanBuildFrom[Repr, B, That]): That = {
          val b = bf(repr)
          for (x <- this)
            f(x) match {
              case Some(y) => b += y
              case _ =>
            }
          b.result
        }
         */

        /** Partitions this $coll in two ${coll}s according to a predicate.
         *
         *  @param p the predicate on which to partition.
         *  @return  a pair of ${coll}s: the first $coll consists of all elements that
         *           satisfy the predicate `p` and the second $coll consists of all elements
         *           that don't. The relative order of the elements in the resulting ${coll}s
         *           is the same as in the original $coll.
         */
        def partition(p: A => Boolean): (Repr, Repr) = {
          val l, r = newBuilder
          for (x <- this) (if (p(x)) l else r) += x
          (l.result, r.result)
        }

        def groupBy[K](f: A => K): immutable.Map[K, Repr] = {
          val m = mutable.Map.empty[K, Builder[A, Repr]]
          for (elem <- this) {
            val key = f(elem)
            val bldr = m.getOrElseUpdate(key, newBuilder)
            bldr += elem
          }
          val b = immutable.Map.newBuilder[K, Repr]
          for ((k, v) <- m)
            b += ((k, v.result))

          b.result
        }

        /** Tests whether a predicate holds for all elements of this $coll.
         *
         *  $mayNotTerminateInf
         *
         *  @param   p     the predicate used to test elements.
         *  @return        `true` if the given predicate `p` holds for all elements
         *                 of this $coll, otherwise `false`.
         */
        def forall(p: A => Boolean): Boolean = {
          var result = true
          breakable {
            for (x <- this)
              if (!p(x)) { result = false; break }
          }
          result
        }

        /** Tests whether a predicate holds for some of the elements of this $coll.
         *
         *  $mayNotTerminateInf
         *
         *  @param   p     the predicate used to test elements.
         *  @return        `true` if the given predicate `p` holds for some of the
         *                 elements of this $coll, otherwise `false`.
         */
        def exists(p: A => Boolean): Boolean = {
          var result = false
          breakable {
            for (x <- this)
              if (p(x)) { result = true; break }
          }
          result
        }

        /** Finds the first element of the $coll satisfying a predicate, if any.
         *
         *  $mayNotTerminateInf
         *  $orderDependent
         *
         *  @param p    the predicate used to test elements.
         *  @return     an option value containing the first element in the $coll
         *              that satisfies `p`, or `None` if none exists.
         */
        def find(p: A => Boolean): Option[A] = {
          var result: Option[A] = None
          breakable {
            for (x <- this)
              if (p(x)) { result = Some(x); break }
          }
          result
        }

        def scan[B >: A, That](z: B)(op: (B, B) => B)(implicit cbf: CanBuildFrom[Repr, B, That]): That = scanLeft(z)(op)

        def scanLeft[B, That](z: B)(op: (B, A) => B)(implicit bf: CanBuildFrom[Repr, B, That]): That = {
          val b = bf(repr)
          b.sizeHint(this, 1)
          var acc = z
          b += acc
          for (x <- this) { acc = op(acc, x); b += acc }
          b.result
        }

        @migration(2, 9,
          "This scanRight definition has changed in 2.9.\n" +
          "The previous behavior can be reproduced with scanRight.reverse."
        )
        def scanRight[B, That](z: B)(op: (A, B) => B)(implicit bf: CanBuildFrom[Repr, B, That]): That = {
          var scanned = List(z)
          var acc = z
          for (x <- reversed) {
            acc = op(x, acc)
            scanned ::= acc
          }
          val b = bf(repr)
          for (elem <- scanned) b += elem
          b.result
        }

        /** Selects the first element of this $coll.
         *  $orderDependent
         *  @return  the first element of this $coll.
         *  @throws `NoSuchElementException` if the $coll is empty.
         */
        def head: A = {
          var result: () => A = () => throw new NoSuchElementException
          breakable {
            for (x <- this) {
              result = () => x
              break
            }
          }
          result()
        }

        /** Optionally selects the first element.
         *  $orderDependent
         *  @return  the first element of this $coll if it is nonempty, `None` if it is empty.
         */
        def headOption: Option[A] = if (isEmpty) None else Some(head)

        /** Selects all elements except the first.
         *  $orderDependent
         *  @return  a $coll consisting of all elements of this $coll
         *           except the first one.
         *  @throws `UnsupportedOperationException` if the $coll is empty.
         */
        override def tail: Repr = {
          if (isEmpty) throw new UnsupportedOperationException("empty.tail")
          drop(1)
        }

        /** Selects the last element.
          * $orderDependent
          * @return The last element of this $coll.
          * @throws NoSuchElementException If the $coll is empty.
          */
        def last: A = {
          var lst = head
          for (x <- this)
            lst = x
          lst
        }

        /** Optionally selects the last element.
         *  $orderDependent
         *  @return  the last element of this $coll$ if it is nonempty, `None` if it is empty.
         */
        def lastOption: Option[A] = if (isEmpty) None else Some(last)

        /** Selects all elements except the last.
         *  $orderDependent
         *  @return  a $coll consisting of all elements of this $coll
         *           except the last one.
         *  @throws `UnsupportedOperationException` if the $coll is empty.
         */
        def init: Repr = {
          if (isEmpty) throw new UnsupportedOperationException("empty.init")
          var lst = head
          var follow = false
          val b = newBuilder
          b.sizeHint(this, -1)
          for (x <- this.seq) {
            if (follow) b += lst
            else follow = true
            lst = x
          }
          b.result
        }

        def take(n: Int): Repr = slice(0, n)

        def drop(n: Int): Repr =
          if (n <= 0) {
            val b = newBuilder
            b.sizeHint(this)
            b ++= thisCollection result
          }
          else sliceWithKnownDelta(n, Int.MaxValue, -n)

        def slice(from: Int, until: Int): Repr = sliceWithKnownBound(math.max(from, 0), until)

        // Precondition: from >= 0, until > 0, builder already configured for building.
        private[this] def sliceInternal(from: Int, until: Int, b: Builder[A, Repr]): Repr = {
          var i = 0
          breakable {
            for (x <- this.seq) {
              if (i >= from) b += x
              i += 1
              if (i >= until) break
            }
          }
          b.result
        }
        // Precondition: from >= 0
        private[scala] def sliceWithKnownDelta(from: Int, until: Int, delta: Int): Repr = {
          val b = newBuilder
          if (until <= from) b.result
          else {
            b.sizeHint(this, delta)
            sliceInternal(from, until, b)
          }
        }
        // Precondition: from >= 0
        private[scala] def sliceWithKnownBound(from: Int, until: Int): Repr = {
          val b = newBuilder
          if (until <= from) b.result
          else {
            b.sizeHintBounded(until - from, this)
            sliceInternal(from, until, b)
          }
        }

        def takeWhile(p: A => Boolean): Repr = {
          val b = newBuilder
          breakable {
            for (x <- this) {
              if (!p(x)) break
              b += x
            }
          }
          b.result
        }

        def dropWhile(p: A => Boolean): Repr = {
          val b = newBuilder
          var go = false
          for (x <- this) {
            if (!p(x)) go = true
            if (go) b += x
          }
          b.result
        }

        def span(p: A => Boolean): (Repr, Repr) = {
          val l, r = newBuilder
          var toLeft = true
          for (x <- this) {
            toLeft = toLeft && p(x)
            (if (toLeft) l else r) += x
          }
          (l.result, r.result)
        }

        def splitAt(n: Int): (Repr, Repr) = {
          val l, r = newBuilder
          l.sizeHintBounded(n, this)
          if (n >= 0) r.sizeHint(this, -n)
          var i = 0
          for (x <- this) {
            (if (i < n) l else r) += x
            i += 1
          }
          (l.result, r.result)
        }

        /** Iterates over the tails of this $coll. The first value will be this
         *  $coll and the final one will be an empty $coll, with the intervening
         *  values the results of successive applications of `tail`.
         *
         *  @return   an iterator over all the tails of this $coll
         *  @example  `List(1,2,3).tails = Iterator(List(1,2,3), List(2,3), List(3), Nil)`
         */
        def tails: Iterator[Repr] = iterateUntilEmpty(_.tail)

        /** Iterates over the inits of this $coll. The first value will be this
         *  $coll and the final one will be an empty $coll, with the intervening
         *  values the results of successive applications of `init`.
         *
         *  @return  an iterator over all the inits of this $coll
         *  @example  `List(1,2,3).inits = Iterator(List(1,2,3), List(1,2), List(1), Nil)`
         */
        def inits: Iterator[Repr] = iterateUntilEmpty(_.init)

        /** Copies elements of this $coll to an array.
         *  Fills the given array `xs` with at most `len` elements of
         *  this $coll, starting at position `start`.
         *  Copying will stop once either the end of the current $coll is reached,
         *  or the end of the array is reached, or `len` elements have been copied.
         *
         *  $willNotTerminateInf
         *
         *  @param  xs     the array to fill.
         *  @param  start  the starting index.
         *  @param  len    the maximal number of elements to copy.
         *  @tparam B      the type of the elements of the array.
         *
         *
         *  @usecase def copyToArray(xs: Array[A], start: Int, len: Int): Unit
         */
        def copyToArray[B >: A](xs: Array[B], start: Int, len: Int) {
          var i = start
          val end = (start + len) min xs.length
          breakable {
            for (x <- this) {
              if (i >= end) break
              xs(i) = x
              i += 1
            }
          }
        }

        def toTraversable: Traversable[A] = thisCollection
        def toIterator: Iterator[A] = toStream.iterator
        def toStream: Stream[A] = toBuffer.toStream

        /** Converts this $coll to a string.
         *
         *  @return   a string representation of this collection. By default this
         *            string consists of the `stringPrefix` of this $coll,
         *            followed by all elements separated by commas and enclosed in parentheses.
         */
        override def toString = mkString(stringPrefix + "(", ", ", ")")

        /** Defines the prefix of this object's `toString` representation.
         *
         *  @return  a string representation which starts the result of `toString`
         *           applied to this $coll. By default the string prefix is the
         *           simple name of the collection class $coll.
         */
        def stringPrefix : String = {
          var string = repr.asInstanceOf[AnyRef].getClass.getName
          val idx1 = string.lastIndexOf('.' : Int)
          if (idx1 != -1) string = string.substring(idx1 + 1)
          val idx2 = string.indexOf('$')
          if (idx2 != -1) string = string.substring(0, idx2)
          string
        }

        /** Creates a non-strict view of this $coll.
         *
         *  @return a non-strict view of this $coll.
         */
        def view = new TraversableView[A, Repr] {
          protected lazy val underlying = self.repr
          override def foreach[U](f: A => U) = self foreach f
        }

        /** Creates a non-strict view of a slice of this $coll.
         *
         *  Note: the difference between `view` and `slice` is that `view` produces
         *        a view of the current $coll, whereas `slice` produces a new $coll.
         *
         *  Note: `view(from, to)` is equivalent to `view.slice(from, to)`
         *  $orderDependent
         *
         *  @param from   the index of the first element of the view
         *  @param until  the index of the element following the view
         *  @return a non-strict view of a slice of this $coll, starting at index `from`
         *  and extending up to (but not including) index `until`.
         */
        def view(from: Int, until: Int): TraversableView[A, Repr] = view.slice(from, until)

        /** Creates a non-strict filter of this $coll.
         *
         *  Note: the difference between `c filter p` and `c withFilter p` is that
         *        the former creates a new collection, whereas the latter only
         *        restricts the domain of subsequent `map`, `flatMap`, `foreach`,
         *        and `withFilter` operations.
         *  $orderDependent
         *
         *  @param p   the predicate used to test elements.
         *  @return    an object of class `WithFilter`, which supports
         *             `map`, `flatMap`, `foreach`, and `withFilter` operations.
         *             All these operations apply to those elements of this $coll which
         *             satisfy the predicate `p`.
         */
        def withFilter(p: A => Boolean): FilterMonadic[A, Repr] = new WithFilter(p)

        /** A class supporting filtered operations. Instances of this class are
         *  returned by method `withFilter`.
         */
        class WithFilter(p: A => Boolean) extends FilterMonadic[A, Repr] {

          /** Builds a new collection by applying a function to all elements of the
           *  outer $coll containing this `WithFilter` instance that satisfy predicate `p`.
           *
           *  @param f      the function to apply to each element.
           *  @tparam B     the element type of the returned collection.
           *  @tparam That  $thatinfo
           *  @param bf     $bfinfo
           *  @return       a new collection of type `That` resulting from applying
           *                the given function `f` to each element of the outer $coll
           *                that satisfies predicate `p` and collecting the results.
           *
           *  @usecase def map[B](f: A => B): $Coll[B]
           *
           *  @return       a new $coll resulting from applying the given function
           *                `f` to each element of the outer $coll that satisfies
           *                predicate `p` and collecting the results.
           */
          def map[B, That](f: A => B)(implicit bf: CanBuildFrom[Repr, B, That]): That = {
            val b = bf(repr)
            for (x <- self)
              if (p(x)) b += f(x)
            b.result
          }

          /** Builds a new collection by applying a function to all elements of the
           *  outer $coll containing this `WithFilter` instance that satisfy
           *  predicate `p` and concatenating the results.
           *
           *  @param f      the function to apply to each element.
           *  @tparam B     the element type of the returned collection.
           *  @tparam That  $thatinfo
           *  @param bf     $bfinfo
           *  @return       a new collection of type `That` resulting from applying
           *                the given collection-valued function `f` to each element
           *                of the outer $coll that satisfies predicate `p` and
           *                concatenating the results.
           *
           *  @usecase def flatMap[B](f: A => TraversableOnce[B]): $Coll[B]
           *
           *  @return       a new $coll resulting from applying the given collection-valued function
           *                `f` to each element of the outer $coll that satisfies predicate `p` and concatenating the results.
           */
          def flatMap[B, That](f: A => GenTraversableOnce[B])(implicit bf: CanBuildFrom[Repr, B, That]): That = {
            val b = bf(repr)
            for (x <- self)
              if (p(x)) b ++= f(x).seq
            b.result
          }

          /** Applies a function `f` to all elements of the outer $coll containing
           *  this `WithFilter` instance that satisfy predicate `p`.
           *
           *  @param  f   the function that is applied for its side-effect to every element.
           *              The result of function `f` is discarded.
           *
           *  @tparam  U  the type parameter describing the result of function `f`.
           *              This result will always be ignored. Typically `U` is `Unit`,
           *              but this is not necessary.
           *
           *  @usecase def foreach(f: A => Unit): Unit
           */
          def foreach[U](f: A => U): Unit =
            for (x <- self)
              if (p(x)) f(x)

          /** Further refines the filter for this $coll.
           *
           *  @param q   the predicate used to test elements.
           *  @return    an object of class `WithFilter`, which supports
           *             `map`, `flatMap`, `foreach`, and `withFilter` operations.
           *             All these operations apply to those elements of this $coll which
           *             satisfy the predicate `q` in addition to the predicate `p`.
           */
          def withFilter(q: A => Boolean): WithFilter =
            new WithFilter(x => p(x) && q(x))
        }

        // A helper for tails and inits.
        private def iterateUntilEmpty(f: Traversable[A @uV] => Traversable[A @uV]): Iterator[Repr] = {
          val it = Iterator.iterate(thisCollection)(f) takeWhile (x => !x.isEmpty)
          it ++ Iterator(Nil) map (newBuilder ++= _ result)
        }
      }

`Module` is actually the superclass of `Class`, so every Ruby class is also a module. Throughout this book we talk about using methods of `Module` from within classes. The same methods will work exactly the same way within modules. The only thing you can’t do with a module is instantiate an object from it:

    Class.superclass    # => Module
    Math.class          # => Module
    Math.new
    # NoMethodError: undefined method `new' for Math:Module

## Simulating Multiple Inheritance with Mixins

### Problem

You want to create a class that derives from two or more sources, but Ruby doesn’t support multiple inheritance.

### Solution

Suppose you created a class called `Taggable` that lets you associate tags (short strings of informative metadata) with objects. Every class whose objects should be taggable could derive from `Taggable`.

This would work if you made `Taggable` the top-level class in your class structure, but that won’t work in every situation. Eventually you might want to do something like make a string taggable. One class can’t subclass both `Taggable` and `String`, so you’d have a problem.

Furthermore, it makes little sense to instantiate and use a `Taggable` object by itself—there is nothing there to tag! Taggability is more of a feature of a class than a fullfledged class of its own. The `Taggable` functionality works only in conjunction with some other data structure.

This makes `Taggable` an ideal candidate for implementation as a Ruby module instead of a class. Once it’s in a module, any class can include it and use the methods it defines:

    require 'set' # Deals with a collection of unordered values with no duplicates

    # Include this module to make your class taggable. The names of the
    # instance variable and the setup method are prefixed with "taggable_"
    # to reduce the risk of namespace collision. You must call
    # taggable_setup before you can use any of this module's methods.
    module Taggable
      attr_accessor :tags

      def taggable_setup
        @tags = Set.new
      end

      def add_tag(tag)
        @tags << tag
      end

      def remove_tag(tag)
        @tags.delete(tag)
      end
    end

Here is a taggable string class; it subclasses `String`, but it also includes the functionality of `Taggable`:

    class TaggableString < String
      include Taggable
      def initialize(*args)
        super
        taggable_setup
      end
    end
    s = TaggableString.new('It was the best of times, it was the worst of times.')
    s.add_tag 'dickens'
    s.add_tag 'quotation'
    s.tags # =>                       #<Set: {"dickens", "quotation"}>

    IRuby.display IRuby.table({a:[11,12,13,14],b:[21,22,23],c:[31,32,33,34]})

    $stderr.puts 'Error!'

    Math.sqrt(2)

An plot example:

    require 'gnuplot'

    Gnuplot::Plot.new do |plot|
        plot.xrange '[-0.5:0.5]'
        plot.title  'Example plot'
        plot.ylabel 'x'
        plot.xlabel 'sin(1/x)'
        plot.samples 10000
        plot.data << Gnuplot::DataSet.new('sin(1/x)') do |ds|
            ds.with = 'lines'
            ds.linewidth = 2
        end
    end

Mathjax support built in:

\begin{align} \dot{x} & = \sigma(y-x) \ \dot{y} & = \rho x - y - xz \ \dot{z} & = -\beta z + xy \end{align}