what, if anything, is a llama?

data Term
  = Var String
  | Lam String Term
  | App Term Term

#37

(λa.a (foo a)) bar

App (Lam "a" (App (Var "foo") (Var "a"))) (Var "bar")

#38

parsing

#39

purescript-parsing

#40

lam :: Parser String Term -> Parser String Term
lam x = do
  _ <- (string "λ") <|> (string "\\")
  p <- identifier
  _ <- (string ".")
  b <- x
  pure (Lam p b)

#41

reserved :: Set.Set Char
reserved = Set.fromFoldable [':', '\\', '≜', 'λ', ' ', '\n', '\t', '.', '(', ')']

identifier :: Parser String String
identifier = many1 (satisfy (\x -> not (Set.member x reserved))) >>= pure <<< listString

#42

(the substitution model for procedure application)

paren :: forall a b m.StringLike a => Monad m => ParserT a m b -> ParserT a m b
paren x = between (string "(") (string ")") x

#43

unparsing

#44

Unparse.purs

pstring :: String -> String
pstring s = "(" <> s <> ")"

argstring :: Term -> String
argstring (Var s) = s
argstring t = pstring (unparse t)

-- | uns the parse
unparse :: Term -> String
unparse (Lam p b) = "λ" <> p <> "." <> unparse b
unparse (App (Lam p b) a) = pstring (unparse (Lam p b)) <> " " <> argstring a
unparse (App f a) = unparse f <> " " <> argstring a
unparse (Var s) = s

#45

computation

#46

(we do not look up
variables in scope but
use substitution)

#47

#48

as if by hand

#49

as if by hand

#50

(btw I like substitution)

(the costs of introducing assignment)

#51

reducible expressions

#52

an application
of a lambda abstraction
to an expression

#53

(λa.a (foo a)) bar

#54

(λa.a (foo a)) bar

#55

beta reduction

#56

lambda-body with
argument substituted
for parameter

#57

(λa.a (foo a)) bar

#58

(λa.a (foo a)) bar

argument: bar

parameter: a

body:

#59

a (foo a)

#60

swoosh

#61

bar (foo bar)

#62

so

#63

(λa.a (foo a)) bar

#64

a (foo a)

#65

bar (foo bar)

#66

finding a reducible expression

#67

(λa.a (foo a)) bar

#68

(λa.a (foo a)) bar

#69

(λa.a (foo a)) bar

#70

assuming we have
data structures and functions
for searching for terms

#71

data Found a = Found TermPath a

findTerm :: forall a. (Term -> Maybe a) -> Term -> Maybe (Found a)

fillTerm :: TermPath -> Term -> Term

#72

Subst.purs

data Redex = Redex Term String Term

Subst.purs

redex :: Term -> Maybe Redex
redex (App (Lam p b) a) = Just (Redex a p b)
redex _ = Nothing

#73

(λa.a (foo a)) bar

given

App (Lam "a" (App (Var "foo") (Var "a"))) (Var "bar")

the match on

redex (App (Lam p b) a) = ...

should match and like bind variables

p = "a"
b = App (Var "foo") (Var "a")
a = (Var "bar")

#74

substitution (swoosh)

#75

(λa.a (foo a)) bar

#76

a (foo a)

#77

bar (foo bar)

#78

Subst.purs

subst :: Redex -> Term
subst (Redex arg param body) = halp body
  where
    halp :: Term -> Term
    halp (App f a) = App (halp f) (halp a)
    halp (Lam p b) = Lam p (if p == param then b else halp b)
    halp (Var s) = if s == param then arg else (Var s)

#79

(additional stuff
toplevel definitions
alpha renaming)

#80

btw there’s a talk

#81

btw there’s a talk

#82

also btw boolean blindness

#83

it can be good to
return the stuff you need for
next part of program

#84

often more good:

data Redex = Redex Term String Term

redex :: Term -> Maybe Redex

subst :: Redex -> Term

possibly less good:

redex :: Term -> Boolean

#85

unsurprisingly

better A and B leads to

better A -> B

#86

(I totally did less good thing in earlier version)

Eval.elm

reducible t = case t of
                (App (Lam _ _) _) -> True
                _                 -> False

leads to non-exhaustive pattern match later on

Eval.elm

reduceRename0 t (App (Lam p b) a) = ...

#87

part 2 is wiring? assembly? architecture?

#88

pure functions inside
layer with state and effects
surrounding the core

#89

io, eff

#90

modernized algol

#91

#92

core domain is done
reasonably properly
(other parts less so)

#93

core domain bit: purescript-lambs

github

pursuit

#94

implementation
of a lambda calculus
evaluator

#95

interop? anti-corruption? purescript-lambness

github

#96

pulp browserify
--optimise --standalone lambs
--to lambs.js

#97

Main.purs

parse :: String -> Maybe Toplevel
parse s = Parse.parseTop s

Main.purs

step :: Maybe Toplevel -> String
step Nothing = ":("
step (Just (Def (Define s _))) = s <> " is defined :)"
step (Just (Undef (Undefine s))) = s <> " is undefined :o"
step (Just (Trm term)) = execStr (Just (stepExec term))

Main.purs

isJust :: forall a. Maybe a -> Boolean
isJust Nothing = false
isJust _ = true

#98

we can test some stuff in js console

lambs.step(lambs.parse("(λx.λy.y x) foo"))

lambs.isJust(lambs.parse("(λx.λy.y x foo"))

#99

reqmain.js

var lambs;
var defs;
var getDefs;
var updateDefs;

require(['lambs'], function (foo) {
    lambs = foo;

    defs = lambs.noDefs;
    updateDefs = function (d) {
      defs = lambs.updateDefs(d)(defs);
    };
});

#100

the mo in monaco stands for moo, the co for cow

#101

monaco

#102

downloaded a thing
put it somewhere within reach
require bit me

#103

require.config({ paths: { 'vs': 'monaco-editor/min/vs' }});

#104

var startMonaco = function() {

  var res = [];
  var elems = document.getElementsByName("lambs");
  require(['vs/editor/editor.main'], function() {

    for (var i = 0; i < elems.length; i++) {
      var elem = elems[i];
      if (elem.getAttribute("prelude") === "true") {
        res.push(startPreluditor(elem));
      } else {
        res.push(startEditor(elem));
      }

    }});
    return res;
};

#105

var content = element.textContent;
element.textContent = "";

var editor = monaco.editor.create(element, {
    value: content,
    lineNumbers: false,
    quickSuggestions: false,
    mouseWheelZoom: true
});

#106

   editor.addCommand([monaco.KeyMod.CtrlCmd | monaco.KeyCode.KEY_L], function() {
       var range = editor.getSelection();
       var id = { major: 1, minor: 1 };
       var text = 'λ';
       var op = {identifier: id, range: range, text: text, forceMoveMarkers: true};
       editor.executeEdits("lambs", [op]);
});

#107

http://llama-the-ultimate.org/lists/lambs.html

editor.addCommand([monaco.KeyMod.CtrlCmd | monaco.KeyCode.Enter], function() {
    var selection = editor.getSelection();
    var line = selection.positionLineNumber;
    var model = editor.getModel();
    var s = model.getLineContent(line);
    var pos = new monaco.Position(line, s.length + 1);
    editor.setPosition(pos);
    var range = editor.getSelection();
    var id = { major: 1, minor: 1 };
    var parsed = lambs.parse(s);
    updateDefs(parsed);
    var text = '\n' + lambs.step(parsed);
    var op = {identifier: id, range: range, text: text, forceMoveMarkers: true};
    editor.pushUndoStop();
    editor.executeEdits("lambs", [op]);
    editor.pushUndoStop();
    editor.revealPosition(editor.getPosition());
});

#108

html+css

I use racket for this but it basically amounts to

<html>
...
<body>
  ...
  <p>blah blah hello goodbye</p>
  <div name="lambs">
    (λx.λy.y x) foo bar
  </div>
  <p>blah blah blah</p>
  <div name="lambs">
    (λx.λy.y x) foo bar
  </div>
  ...

#109

part conclusion is okay yes

#110

appendix A is like, misc

#111

a new version of
purescript broke some of my stuff
but only one time

#112

typeclasses, show and ord and such

PSCi, version 0.11.7
Type :? for help

import Prelude
> { x: 1 }

#113

typeclasses, show and ord and such

PSCi, version 0.11.7
Type :? for help

import Prelude
> { x: 1 }
Error found:
in module $PSCI
at <internal> line 0, column 0 - line 0, column 0

   No type class instance was found for

     Data.Show.Show { x :: Int
                    }


 while applying a function eval
   of type Eval t2 => t2
                      -> Eff
                           ( console :: CONSOLE
                           )
                           Unit
   to argument it
 while checking that expression eval it
   has type Eff t0 t1
 in value declaration $main

 where t0 is an unknown type
       t1 is an unknown type
       t2 is an unknown type

 See https://github.com/purescript/documentation/blob/master/errors/NoInstanceFound.md for more information,
 or to contribute content related to this error.

#114

imported module
has thing of type T in it
don’t know where T is

#115

record punning

if you have e.g.

x = "hello"

and you wanna do

{ x: x, y: 5 }

you can do

{ x, y: 5 }

instead.

(I think that’s weird)

#116

does not have tuples
oogly boogly beep boop bap
currying instead

#117

#118

Could not match type

  Ren -> Exec

with type

  Exec


while checking that type Ren -> Exec
  is at least as general as type Exec
while checking that expression renameHalp f
  has type Exec
in value declaration stepExec

#119