Gatlin Johnson gatlin

## keepassalong.pl
#!/usr/bin/env perl

use v5.14;
use strict;
use warnings;

use File::KeePass;
use Text::CSV;
use Data::Dump qw(pp);
use Term::ReadPassword;

## free_monad_functor_adt.hs
{-# LANGUAGE RankNTypes #-}

data F f = F {
    _map :: forall a b. (a -> b) -> f a -> f b
}

data Mu f a
    = Term { retract :: a }
    | Cont (f (Mu f a))

## freestream.hs
{- | THIS HAS MOVED
 -
 - https://github.com/gatlin/FreeStream
 -}

## typeops.lhs
Type operators!
===

Turns out a GHC language extension makes a lot of cool things possible that I
think you hinted at:

> {-# LANGUAGE TypeOperators #-}

> data a + b = Inl a | Inr b deriving Show

## gatsby.hs
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE FunctionalDependencies #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE UndecidableInstances #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE NoMonomorphismRestriction #-}
{-# LANGUAGE DeriveFunctor #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE ExistentialQuantification #-}

## id.js
var getId = function() {
    var _id = 0;
    return function() {
        return _id++;
    }
}()

// usage

console.log(getId());

## closurewanking.js
/***
 * Fun with closures!
 *
 * Run this with node.js:
 *
 *     $> node closurewanking.js
 */

var http = require('http');

## slurp.rkt
#lang racket

(require db)
(require "utils.rkt")

; open a connection to our database
(define (call-with-conn db proc)
  (let ([conn (sqlite3-connect #:database db
                               #:mode     'read/write)])
    (proc conn)))

## prototype.rkt
#lang racket

;; Wherein we define a prototypal object system

; A λ-function which abstracts the basic operations one can perform on an "object":
; - getting a property
; - setting a property
; - yielding its state
; - replacing its state
(define (make-object state)

## eqdef.rkt
#lang typed/racket

(define-syntax (= stx)
  (syntax-case stx ()
    [(= sym expr)
     #'(define sym expr)]
    [(= sym (arg ...) expr)
     #'(define (sym arg ...) expr)]))

;; example usage
	#!/usr/bin/env perl

	use v5.14;
	use strict;
	use warnings;

	use File::KeePass;
	use Text::CSV;
	use Data::Dump qw(pp);
	use Term::ReadPassword;
	{-# LANGUAGE RankNTypes #-}

	data F f = F {
	_map :: forall a b. (a -> b) -> f a -> f b
	}

	data Mu f a
	= Term { retract :: a }
	\| Cont (f (Mu f a))
	{- \| THIS HAS MOVED
	-
	- https://github.com/gatlin/FreeStream
	-}
	Type operators!
	===

	Turns out a GHC language extension makes a lot of cool things possible that I
	think you hinted at:

	> {-# LANGUAGE TypeOperators #-}

	> data a + b = Inl a \| Inr b deriving Show
	{-# LANGUAGE RankNTypes #-}
	{-# LANGUAGE MultiParamTypeClasses #-}
	{-# LANGUAGE FunctionalDependencies #-}
	{-# LANGUAGE FlexibleInstances #-}
	{-# LANGUAGE UndecidableInstances #-}
	{-# LANGUAGE FlexibleContexts #-}
	{-# LANGUAGE NoMonomorphismRestriction #-}
	{-# LANGUAGE DeriveFunctor #-}
	{-# LANGUAGE StandaloneDeriving #-}
	{-# LANGUAGE ExistentialQuantification #-}
	var getId = function() {
	var _id = 0;
	return function() {
	return _id++;
	}
	}()

	// usage

	console.log(getId());
	/***
	* Fun with closures!
	*
	* Run this with node.js:
	*
	* $> node closurewanking.js
	*/

	var http = require('http');
	#lang racket

	(require db)
	(require "utils.rkt")

	; open a connection to our database
	(define (call-with-conn db proc)
	(let ([conn (sqlite3-connect #:database db
	#:mode 'read/write)])
	(proc conn)))
	#lang racket

	;; Wherein we define a prototypal object system

	; A λ-function which abstracts the basic operations one can perform on an "object":
	; - getting a property
	; - setting a property
	; - yielding its state
	; - replacing its state
	(define (make-object state)
	#lang typed/racket

	(define-syntax (= stx)
	(syntax-case stx ()
	[(= sym expr)
	#'(define sym expr)]
	[(= sym (arg ...) expr)
	#'(define (sym arg ...) expr)]))

	;; example usage