Kraks

;; -*- mode: emacs-lisp -*-
;; This file is loaded by Spacemacs at startup.
;; It must be stored in your home directory.

(defun dotspacemacs/layers ()
  "Configuration Layers declaration.
You should not put any user code in this function besides modifying the variable
values."
  (setq-default
   ;; Base distribution to use. This is a layer contained in the directory

Kraks

open Microsoft.FSharp.Quotations

// <@ fun x -> (% <@ x @> ) @> ~ lambda (fun x -> x)
let lambda (f : Expr<'T> -> Expr<'R>) : Expr<'T -> 'R> =
    let var = new Var("__temp__", typeof<'T>)
    Expr.Cast<_>(Expr.Lambda(var,  f (Expr.Cast<_>(Expr.Var var))))


// fixed-point combinator
let rec fix : (('Τ -> 'R) -> ('Τ -> 'R)) -> 'Τ -> 'R = fun f x ->

Kraks

#lang racket

(require rackunit)

#| Negation Normal Form |#

;; TODO: Add biconnection for NNF transformation

(define (nnf prop)
  (match prop

Kraks

class Shift:
    def __init__(self, fun):
        self.fun = fun 

    def map(self, f): return Shift(lambda k: self.fun(lambda x: k(f(x))))

    def bind(self, f): return Shift(lambda k: self.fun(lambda x: f(x).fun(k)))

    def bind2(self, f):
        def aux(k):

Kraks

trait Futamura1 {
  // Roughly follow the idea from http://blog.sigfpe.com/2009/05/three-projections-of-doctor-futamura.html
  type P[_] // program representation type
  type M[_] // machine type

  /* To run a machine: */
  def run[A](ma: M[A]): A

  /* The specializer: a machine that
     takes a program representation of A => B,

Kraks

object Basic {
  trait Expr
  case class Var(x: String) extends Expr
  case class Lam(x: String, body: Expr) extends Expr
  case class App(e1: Expr, e2: Expr) extends Expr

  trait Value
  case class FunV(f: Value ⇒ Value) extends Value

  type Env = Map[String, Value]

Kraks

;; Use Melpa
(require 'package)

(custom-set-variables
 ;; custom-set-variables was added by Custom.
 ;; If you edit it by hand, you could mess it up, so be careful.
 ;; Your init file should contain only one such instance.
 ;; If there is more than one, they won't work right.
 '(custom-safe-themes
   (quote

Kraks

package duality.of.sorts

// A Duality of Sorts
// Ralf Hinze, Jose Pedro Magalhaes, Nicolas Wu
// in The Beauty of Functional Code, LNCS 8106, Springer

// This paper: makes the duality between folds and unfolds explicit,
//             defines sorting algorithms as folds of unfolds,
//             and as unfolds of folds.

Kraks

package thermo

/* Scala implementation of delimited continuations using "thermometer continuations" from
 *   Capturing the future by replaying the past (functional pearl)
 *   https://dl.acm.org/doi/10.1145/3236771
 * Based on its Java artifact: https://github.com/jkoppel/thermometer-continuations
 * Written and translate to Scala by Guannan Wei.
 */

trait Block[A] {