tel

import scala.language.higherKinds

trait Tc1 {
  type T[_]
}

trait Functor extends Tc1 {
  def map[A, B](f: A => B)(ta: T[A]): T[B]
}

tel

/**
 * Partially (!) specializes Graphs signature.
 * 
 * Note that Node and Edge are still abstract! We add new 
 * functionality by concretely specifying Graph, but the DSL
 * still works in its limited initial form since newGraph abstracted
 * over Graph construction
 * 
 */

tel

package tutorial.webapp

import japgolly.scalajs.react._
import japgolly.scalajs.react.vdom.prefix_<^._
import org.scalajs.dom

import scala.scalajs.js.JSApp

trait Component {
  type Params

tel

{-# LANGUAGE ConstraintKinds       #-}
{-# LANGUAGE DataKinds             #-}
{-# LANGUAGE FlexibleContexts      #-}
{-# LANGUAGE FlexibleInstances     #-}
{-# LANGUAGE GADTs                 #-}
{-# LANGUAGE KindSignatures        #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE StandaloneDeriving    #-}
{-# LANGUAGE TypeFamilies          #-}
{-# LANGUAGE TypeOperators         #-}

tel

/*

"Concrete" sums are by default open. They are values of the form

  { variant: String, params: {[String]: *} }

 */

/** 

tel

{-# LANGUAGE TypeOperators, TupleSections, LambdaCase, RecordWildCards, RankNTypes #-}

module Rou where

import Control.Lens
import Data.Map (Map)
import qualified Data.Map as Map
import Data.Monoid
import Control.Monad
import Control.Applicative

tel

/* eslint-disable new-cap */

/**
 * Lens types.
 * ===========
 *
 * a * b = {fst: a, snd: b}
 * a + b = {index: Boolean, value: a | b}
 *
 * Iso   s t a b = forall (~>) . Profunctor (~>) => (a ~> b) -> (s ~> t)

tel

/// PRELIMINARIES

/**
 * Generalized "products" of any size. For gluing things together. A tuple is a
 * "2"-meet.
 *
 * The type `Meet a b c d ...` indicates a `Meet` of the given size with values
 * at each type in the sequence.
 */

tel

const IdModule = {
  fmap: (fn) => (x) => fn(x),
}

const ConstModule = {
  fmap: (fn) => (x) => x,
}

/**

tel

function Cont(contHandler) {
  this.contHandler = contHandler;
};

Cont.unit = function(value) {
  return new Cont(function (continue) { return continue(value); });
};

Cont.prototype.run = function(resume) {
  return this.contHandler(resume);