t0yv0

type Async<'T> = ('T -> unit) -> unit

[<Sealed>]
type Async() =
    static let self = Async()

    member inline this.Return(x: 'T) : Async<'T> =
        fun f -> f x
    member inline this.ReturnFrom(x: Async<'T>) = x
    member inline this.Bind

t0yv0

(* Consider lists indexed by length. *)

Inductive List (t : Type) : nat -> Type :=
  | Nil : List t 0
  | Cons : forall n, t -> List t n -> List t (S n).

(* Every non-empty list has a head element. *)

Definition Head : forall t n, List t (S n) -> t.
intros t n list. inversion list. assumption. Defined.

t0yv0

type IList<'T> =
    abstract member Tail : #IListConsumer<'T,'R> -> 'R
    abstract member Head : 'T
    abstract member IsEmpty : bool

and IListConsumer<'T,'R> =
    abstract member Consume : #IList<'T> -> 'R

[<Struct>]
type Nil<'T> =

t0yv0

    let rec loop : Async<unit> =
        async {
            let! req = HttpRequestParser.Parse buf read
            let! resp = app.Handle req
            let kA = isKeepAlive req
            do! respond socket buf (setKeepAlive kA resp)
            if isKeepAlive req then
                return! loop
            else
                return ()

t0yv0

var http = require('http');
http.createServer(function (req, res) {
  res.writeHead(200, {'Content-Type': 'text/plain',
                      'Connection': 'keep-alive'});
  res.end('Hello World\n');
}).listen(8080, "192.168.56.1");
console.log('Server running');

t0yv0

open System.Net.Sockets

type A = System.Net.Sockets.SocketAsyncEventArgs
type B = System.ArraySegment<byte>

exception SocketIssue of SocketError with
    override this.ToString() =
        string this.Data0

/// Wraps the Socket.xxxAsync logic into F# async logic.

t0yv0

(*

We start designing a representation for some functional language.
Keeping it simple, we use strings to represent identifiers (to be
changed later by something more fancy), define a few primitives,
constants, and finally expressions.

*)

type Id = string

t0yv0

[<JavaScript>]
let Factorial (n: int) =
    let rec fac n acc =
        match n with
        | 0 | 1 -> acc
        | n -> fac (n - 1) (acc * n)
    fac n 1

t0yv0

/// generated JavaScript for k=16

function bind(x,f) {return f(x)}
function test(x0) {
var k0;
k0 = function (x1) {
var k1;
k1 = function (x2) {
var k2;
k2 = function (x3) {

t0yv0

{-# OPTIONS -XDoRec -XDeriveDataTypeable #-}

module Example where

import Text.Earley
import Data.Dynamic
import Control.Applicative

data E = Nat Int
       | Add E E deriving (Show, Typeable)