b-studios

require "continuation"

module  Proceedable
  class ProceedableException < Exception

    def initialize(msg, cont)
      super(msg)
      @cont = cont
    end

b-studios

function iterator(f, bindings) {
    
  bindings = bindings || {};

  var matches = f.toString().match(/function[^(]*\(\s*(\w+)\s*\)[^{]*(.*)/);

  if (!matches) {
    console.log("iterator function has wrong format, please use only one argument");
  }  

b-studios

trait DebugRewriter extends org.kiama.rewriting.CallbackRewriter {
  
  import org.bitbucket.inkytonik.dsprofile.Events.{Event, Start}
  import org.bitbucket.inkytonik.dsprofile.Events
  
  Events.profiling = true
  
  // ... some outputbuffering and pretty printing here
  
  override def rewriting[T] (oldTerm : T, newTerm : T) : T = { 

b-studios

function Option(value) {
  this.value = value;
  this.some = arguments.length == 1
}

Option.none = new Option()
Option.some = v => new Option(v)
Option.prototype.iterator = function () {
  if (this.some) yield this.value
}

b-studios

sealed trait Nat
sealed trait Zero extends Nat
sealed trait Succ[N <: Nat] extends Nat

b-studios

package scalavaadin

import com.vaadin.{ ui => orig }
import scala.language.implicitConversions
import scala.collection.mutable
import scala.collection.JavaConversions

package object ui {

  // Adding new Methods

b-studios

package vaadin.scala
package server

import com.vaadin.{ server => orig }

import scala.language.implicitConversions
import scala.PartialFunction.condOpt
import apigen.annotations.accessors

b-studios

package de.bstudios.collection.mutable

import scala.collection.mutable._
import scala.collection.generic._
import scala.collection.convert.Wrappers._

class IdentityHashMap[A, B] extends JMapWrapper[A, B](new java.util.IdentityHashMap)
    with JMapWrapperLike[A, B, IdentityHashMap[A, B]] {
  override def empty = new IdentityHashMap[A, B]
}

b-studios

/**
 * This file contains some notes taken while reading:
 *
 *     Comparing Object Encodings
 *     Kim B. Bruce, Luca Cardelli and Benjamin C. Pierce
 */
package object encodings {

  // Library Stuff
  trait Fix[F[_]] {

b-studios

object monadicOA {

  type ??? = Any

  trait Monad[M[+_]] {
    def unit[A]: A => M[A]
    def bind[A, B]: M[A] => (A => M[B]) => M[B]
    def map[A, B]: M[A] => (A => B) => M[B]
  }
  object Monad {