cpressey

module OperationalSansGADTs where

import Control.Monad (liftM, ap)

--
-- Adapted from "The Operational Monad Tutorial":
-- https://apfelmus.nfshost.com/articles/operational-monad.html
--

data Program instr a b = Then (instr a) (a -> Program instr a b)

cpressey

module PipelineCombinators where

import Data.Either
import qualified Data.Functor.Alt
import qualified Data.Function
import qualified Control.Monad

--
-- Combinators for pipelines.  Each of these functions takes one or more
-- parameters and yields a combinator that is intended to map functions

cpressey

Future directions for SixtyPical

SixtyPical has reached a mature stage of development. There are small features that could be added, but they are minor compared to the main features (abstract-interpretation/symbolic-execution/flow-typing-based static analysis and optimization of low-level 6502 programs). So the question arises -- what would be next for SixtyPical?

cpressey

Just a little survey of what code to create an anonymous function and immediately call it looks like in a handful of high-level languages. All of these expressions should evaluate to 10.

Language	Code
Python	(lambda x: x+1)(9)
Ruby	(lambda {|x| x+1}).call(9)
Lua	(function(x) return x+1 end)(9)
Erlang	(fun(X) -> X+1 end)(9)
Haskell	(\x -> x+1)(9)

cpressey

Some Notes on Software Preservation

Docker

Is there an old Erlang image?

Yes, https://hub.docker.com/r/andreineculau/erlang-r16b03-1 -- but there is no good way to assure provenance of it. What Docker has for provenance

cpressey

Programming Language Feature Desiderata

Draft, very draft

This is a list of programming language features that I like (sometimes contrasted with features I don't like) with the hopeful goal of informing a future language design.

For sake of background: almost all of the code I write in my day job

cpressey

(define reduce
  (lambda (subject complete-rules rules generation-id)
    (if (null? rules)
      subject
      (let* ((rule-pair     (car rules))
             (rest-of-rules (cdr rules))
             (pattern       (car rule-pair))
             (replacements  (cdr rule-pair))
             (new-gen-id    (+ generation-id 1))
             (new-subject   (apply-rule subject pattern replacements generation-id)))

cpressey

NOTE: this document is out of date. See the Wagon distribution for the latest version of this document.

Wagon

In a conventional concatenative language, every symbol represents a function which takes program states to program states, and the program is a concatenation (sequential composition) of such functions. This is fine when it comes to manipulating state, but what about control?

cpressey

-- implementation of https://esolangs.org/wiki/An_Odd_Rewriting_System
-- I, Chris Pressey, hereby place this source code into the public domain.

import Data.Char

-- A program in An Odd Rewriting System consists an alphabet of symbols,
-- each of which belongs to one of two categories (an odd symbol or an even symbol),
-- except for a special halt symbol that appears in neither category;
-- two definitions for each symbol (an odd definition and an even definition);
-- and an initial string.  Both the initial string, and each definition, is simply a

cpressey

#
# "The Defeat at Procyon V"
# Chris Pressey, Cat's Eye Technologies
# for NaNoGenMo 2018
#


#
# General Utility
#