Commit 130a23c30efd80e3e45b7d5ba41e74dd4a066146 - Argyle

+11

-11

README.md less more

12	12	also hygienic in the sense that all defined ABT operations are, quite unlike
13	13	Lisp's `cons` lists, designed to preserve their name-binding structure.
14	14
15		_This is an extremely preliminary release of the language, aiming only to_
	15	_This is an embryonic iteration of the language, aiming only to_
16	16	_present a proof-of-concept. The basic ideas are implemented but their exact_
17		_design and implementation surely can and surely will be improved upon._
	17	_design and implementation surely can and ideally will be improved upon._
18	18
19	19	For more details on the language, [see "Documentation" below](#documentation).
20	20

45	45
46	46	What follows is a more informal introduction.
47	47
48		Lisp is usualy promoted as being homoiconic, but explanations of its
	48	Lisp is usualy promoted as being homoiconic, but presentations of its
49	49	homoiconicity often gloss over the following detail: not every
50		valid S-expression is a valid Lisp program. In essence there are
	50	valid S-expression is a valid Lisp program. In essence Lisp has
51	51	two syntaxes, the "low-level syntax" of S-expressions, and the
52		"high-level syntax" of special forms. Despite this, traditionally,
53		`(quote (let 123))` is a perfectly good quoted form (even though
54		`(let 123)` is not a valid expression) and the argument to `eval`
55		is a list (even though it need not contain a valid expression).
	52	"high-level syntax" of special forms. The traditional treatment
	53	is to completely ignore that fact, and allow expressions such as
	54	`(quote (let 123))` to be perfectly acceptable quoted form, even though
	55	`(let 123)` is not a valid expression -- and to have the argument to
	56	`eval` is a list, even though a list need not contain a valid expression.
56	57
57		This is a shortcoming. Argyle intends to address it. Although
58		given in an S-expression syntax, Argyle programs are not parsed
	58	Argyle regards this as a shortcoming, and intends to address it. Although
	59	they are written in an S-expression syntax, Argyle programs are not parsed
59	60	into cons lists. More precisely, even if the implementation parses
60	61	them into cons lists (as the reference implementation does), those
61	62	cons lists are not directly exposed to the interpreter. Rather, the

72	73	----
73	74
74	75	* Continue to clean up ABT helper functions as needed
75		* `if` operator
76	76	* Equality operator
77	77	* Test that equality operator treats ABTs as alpha-equivalent
78	78	* `letrec` - implement in code first, eventually look towards

+8

-0

doc/Definition-of-Argyle.md less more

123	123
124	124	(let ((s "hello")) s)
125	125	===> "hello"
	126
	127	### `if-apply` Function
	128
	129	(if-apply 1 (lambda (x) 123) (lambda (x) "no"))
	130	===> 123
	131
	132	(if-apply 0 (lambda (x) 123) (lambda (x) "no"))
	133	===> "no"
126	134
127	135	### Lambda expressions and function application
128	136

+12

-2

src/Language/Argyle/Interpreter.hs less more

21	21	initialEnv = Map.fromList
22	22	[ -- Arithmetic operators
23	23	("add", VBuiltin "add" $ \case
24		[VNum a, VNum b] -> Right $ VNum (a + b)
25	24	[VNum a] -> Right $ VBuiltin "add" $ \case
26	25	[VNum b] -> Right $ VNum (a + b)
27	26	_ -> Left "add: second argument must be a number"
28	27	_ -> Left "'add' expects two numbers")
29	28
30	29	, ("mul", VBuiltin "mul" $ \case
31		[VNum a, VNum b] -> Right $ VNum (a * b)
32	30	[VNum a] -> Right $ VBuiltin "mul" $ \case
33	31	[VNum b] -> Right $ VNum (a * b)
34	32	_ -> Left "mul: second argument must be a number"

37	35	, ("neg", VBuiltin "neg" $ \case
38	36	[VNum a] -> Right $ VNum (0 - a)
39	37	_ -> Left "'neg' expects one number")
	38
	39	, ("if-apply", VBuiltin "if-apply" $ \args -> case args of
	40	[VNum n] -> Right $ VBuiltin "if-apply" $ \args' -> case args' of
	41	[VClosure _ thenBody thenEnv] -> Right $ VBuiltin "if-apply" $ \args'' -> case args'' of
	42	[VClosure _ elseBody elseEnv] ->
	43	if n /= 0
	44	then runReaderT (eval thenBody) thenEnv
	45	else runReaderT (eval elseBody) elseEnv
	46	_ ->
	47	Left "if-apply: expected 'else' lambda"
	48	_ -> Left "if-apply: expected 'then' lambda"
	49	_ -> Left "if-apply: expected numeric test expression")
40	50
41	51	-- Core homoiconic functions
42	52	, ("eval", VBuiltin "eval" $ \case

+1

-0

src/Language/Argyle/Value.hs less more

101	101	("add", VNum 1)
102	102	, ("mul", VNum 2)
103	103	, ("neg", VNum 3)
	104	, ("if-apply", VNum 4)
104	105	, ("eval", VNum 4)
105	106	, ("subst", VNum 5)
106	107	, ("abt", VNum 6)