praeclarum

module AlgorithmW

// HINDLEY-MILNER TYPE INFERENCE
// Based on http://catamorph.de/documents/AlgorithmW.pdf
// (Now at http://web.archive.org/web/20170704013532/http://catamorph.de/documents/AlgorithmW.pdf)

type Lit =
    | LInt of int
    | LBool of bool

praeclarum

module k


(*

type TypeIdent = string

type TypeExpr = name:string? (string | TypeIdent | Or TypeExpr TypeExpr | And TypeExpr)

type TypeDecl = Type string TypeExpr

praeclarum

//
//  Script.swift
//
//  Created by Frank A. Krueger on 6/28/15.
//  Copyright © 2015 Krueger Systems, Inc. All rights reserved.
//

import Foundation

enum Val {

queertypes

Reading

Title	Author(s)	Year
Intuitionistic Type Theory	Per Martin-Löf	1984
On the Meanings of the Logical Constants and the Justification of the Logical Laws	Per Martin-Löf	1996
[[http://mat.uab.cat/~kock/crm/h

jeapostrophe

This is ApacheBench, Version 2.3 <$Revision: 1604373 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking localhost (be patient).....done


Server Software:        Racket
Server Hostname:        localhost
Server Port:            9000

jozefg

This is my short-ish tutorial on how to implement closures in
a simple functional language: Foo.

First, some boilerplate.

> {-# LANGUAGE DeriveFunctor, TypeFamilies #-}
> import Control.Applicative
> import Control.Monad.Gen
> import Control.Monad.Writer
> import Data.Functor.Foldable

bobatkey

This is a type constructor

class FunctionType:
    def __init__(self, tyA, tyB):
        self.tyA = tyA
        self.tyB = tyB

    def __eq__(self, other):
 return self.tyA == other.tyA and self.tyB == other.tyB

mflatt

#lang racket
(require rackunit)

;; A singly linked list is either
;; - NULL
;; - pointer to data and a pointer a sll
(struct node (data-ptr next-ptr))

(define n4 (node 4 null))

jj-issuu

module AVL = struct
  type height = int
  type int = height
  module Elt = Int32

  type t = Leaf | Node of t * Elt.t * t * height

  exception Impossible

  let height = function

bobatkey

(* This is a demonstration of the use of the SML module system to
   encode (Generalized Algebraic Datatypes) GADTs via Church
   encodings. The basic idea is to use the Church encoding of GADTs in
   System Fomega and translate the System Fomega type into the module
   system. As I demonstrate below, this allows things like the
   singleton type of booleans, and the equality type, to be
   represented.

   This was inspired by Jon Sterling's blog post about encoding proofs
   in the SML module system: