Prelude.cs

/* Prelude.cs : What happens when a haskell programmer learns C#.
   Copyright (c) 2011 Clark Gaebel

   Permission is hereby granted, free of charge, to any person obtaining
   a copy of this software and associated documentation files (the "Software"),
   to deal in the Software without restriction, including without limitation
   the rights to use, copy, modify, merge, publish, distribute, sublicense,
   and/or sell copies of the Software, and to permit persons to whom the
   Software is furnished to do so, subject to the following conditions:

palladin

// http://blogs.msdn.com/b/ericlippert/archive/2009/04/15/comma-quibbling.aspx

#time
#r "FSharp.PowerPack.dll"
open System
open System.Text


let format (words : seq<string>) =
    let sb (value : string) = new StringBuilder(value)

palladin

// http://okmij.org/ftp/Computation/fixed-point-combinators.html

let force (value : Lazy<_>) = value.Force()
let fix f = let rec x = lazy (f x) in x

let fix' (fs : list<Lazy<list<'a -> 'b>> -> 'a -> 'b>) : Lazy<list<'a -> 'b>> = 
    fix (fun r -> fs |> List.map (fun f -> f r)) 

let fe l x = 
    let [e; o] = force l

palladin

open System
open FSharp.Extensions.Joinads

// Init
let n = 5
let chopsticks = [| for i = 1 to n do yield new Channel<unit>() |]
let hungry = [| for i = 1 to n do yield new Channel<unit>() |]
let philosophers = [| "Plato"; "Konfuzius"; "Socrates"; "Voltaire"; "Descartes" |]

let randomDelay (r : Random) = System.Threading.Thread.Sleep(r.Next(1, 10) * 1000)

jboner

Latency Comparison Numbers (~2012)
----------------------------------
L1 cache reference                           0.5 ns
Branch mispredict                            5   ns
L2 cache reference                           7   ns                      14x L1 cache
Mutex lock/unlock                           25   ns
Main memory reference                      100   ns                      20x L2 cache, 200x L1 cache
Compress 1K bytes with Zippy             3,000   ns        3 us
Send 1K bytes over 1 Gbps network       10,000   ns       10 us
Read 4K randomly from SSD*             150,000   ns      150 us          ~1GB/sec SSD

palladin

type HList = interface end
and HNil = HNil with
    static member inline (|*|) (f, HNil) = f $ HNil
    interface HList
and HCons<'a, 'b when 'b :> HList> = HCons of 'a * 'b with
    static member inline (|*|) (f, HCons(x, xs)) = f $ HCons(x, xs) 
    interface HList 

type Peano = interface end
and Zero = Zero with

palladin

type Church =
    abstract Apply<'T> : ('T -> 'T) * 'T -> 'T

let zero = 
    { 
        new Church with
            member self.Apply(f, x) = x 
    }

let succ (nat : Church) = 

pthariensflame

The Indexed Continuation Monad in Haskell, Scala, and C#

The indexed state monad is not the only indexed monad out there; it's not even the only useful one. In this tutorial, we will explore another indexed monad, this time one that encapsulates the full power of delimited continuations: the indexed continuation monad.

Motivation

The relationship between the indexed and regular state monads holds true as well for the indexed and regular continuation monads, but while the indexed state monad allows us to keep a state while changing its type in a type-safe way, the indexed continuation monad allows us to manipulate delimited continuations while the return type of the continuation block changes arbitrarily. This, unlike the regular continuation monad, allows us the full power of delimited continuations in a dynamic language like Scheme while still remaining completely statically typed.

paulp

scala> baseMap[List[Int]].kinds
res0: List[improving.Kind] = List(* -> *, (*, *) -> *, (*, * -> *) -> *, *)

scala> baseMap[List[Int]] ofKind (*, * -> *) -> * foreach println
scala.collection.generic.GenericTraversableTemplate[Int,List]

scala> baseMap[List[Int]] ofKind (*, *) -> * foreach println
scala.collection.LinearSeqOptimized[Int,List[Int]]
scala.collection.LinearSeqLike[Int,List[Int]]

xeno-by

import scala.annotation.StaticAnnotation
import scala.reflect.macros.Macro
import language.experimental.macros

class body(tree: Any) extends StaticAnnotation

trait Macros extends Macro {
  import c.universe._

  def selFieldImpl = {