matthieubulte

var app = angular.module('test', []);

function capitalize(word) {
    return word.charAt(0).toUpperCase() + word.slice(1);
}

function id(a) {
    return a;
}

matthieubulte

function Left(left) {
    this.isLeft = true;
    this.isRight = false;
    
    this.value = left;
}

function Right(right) {
    this.isLeft = false;
    this.isRight = true;

matthieubulte

let slice = Array.prototype.slice;
let str = s => slice.call(s)
let unstr = cs => cs.reduce((c, cs) => c + cs, "")
let concat = xss => xss.reduce((xs, ys) => xs.concat(ys), [])
let id = x => x
let negate = x => -x
let add = (x,y) => x + y
let sub = (x,y) => x - y

// type Parser a = () -> [Char] -> a

matthieubulte

// Array

let split_array = cases => array =>
  array.length ?
  cases.cons(array[0], Array.prototype.slice.call(array, 1)) :
  cases.nil()

let map = f => split_array({
  nil:  ()      => [],
  cons: (x, xs) => [f(x)].concat(map(f)(xs))

matthieubulte

// Utilities functions

function _const(x) {
    return function(_) {
        return x;
    };
}

function _comp(g, f) {
    return function(x) {

matthieubulte

-- Runnable version can be found at: https://glot.io/snippets/e6bg7n3hjs
--
-- Inspired by http://logicaltypes.blogspot.de/2011/04/attributed-variables-their-uses-and-one.html
-- Here, I try to solve the problem by reducing the 2d grid to a list of (Position, Int) contrained
-- by the rules of sudoku enforced by `guard`s.

import Data.List (sort, sortBy, nub, zip, (\\))
import Control.Monad (guard)

type Domain a = [a]

matthieubulte

List of papers (with links to the PDF versions) mentioned in Philip Wadler's presentation on Propositions as Types at StrangeLoop 2015 (https://www.youtube.com/watch?v=IOiZatlZtGU)

• Propositions as Types, Philip Wadler 2014
• Grundzuge der Theoretischen Logik, David Hilbert and Wilhelm Ackermann 1928
  • Unfortunately I couldn't find it available online for free, but you can find it on amazon!
• Über formal unentscheidbare Sätze der Principia Mathematica und verwandter Systeme I (original, translated), Kurt Gödel 1930
• Proof of normalization for natural deduction, Gerhard Gentzen 1935
• An Unsolvable Problem of Elementary Number Theory, Alonzo Church 1936
• [General recursive functions of na

matthieubulte

module Reader where

newtype F r a = F { unF :: r -> a }

instance Functor (F r) where
  fmap g f = F (g . unF f)

{-
  identity : fmap id = id
  -----------------------

matthieubulte

foldl' :: (b -> a -> b) -> b -> [a] -> b
foldl' f z xs = foldr (\x fs z -> fs (f z x)) id xs z

matthieubulte

"use strict";

let lazy = f => {
    let empty = {};
    let val = empty;
    return () => val === empty ? val = f() : val;
};

// force :: lazy a -> a
let force = l => l();