Commit experimental-envs - Robin - git @ Cat's Eye Technologies

+3

-4

src/Language/Robin/Builtins.hs less more

65	65
66	66	robinEnv :: Evaluable
67	67	robinEnv i env (List _) cc =
68		cc $ envToExpr env
	68	cc $ env
69	69
70	70	choose :: Evaluable
71	71	choose i env (List [(List [(Symbol "else"), branch])]) cc =

103	103	robinBindArgs i env (List [(List formals), givenArgs, givenEnvExpr, body]) cc =
104	104	eval i env givenArgs (\(List actuals) ->
105	105	eval i env givenEnvExpr (\outerEnvExpr ->
106		assertExprToEnv i outerEnvExpr (\outerEnv ->
107		evalArgs formals actuals actuals outerEnv i (\argEnv ->
108		eval i (mergeEnvs argEnv env) body cc))))
	106	evalArgs formals actuals actuals outerEnvExpr i (\argEnv ->
	107	eval i (mergeEnvs argEnv env) body cc)))
109	108	robinBindArgs i env other cc = raise i $ errMsg "illegal-arguments" other
110	109
111	110	robinFun :: Evaluable

+1

-8

src/Language/Robin/Eval.hs less more

71	71	(Symbol envFormal)]) = argList
72	72	newEnv = insert argSelf m closedEnv
73	73	newEnv' = insert argFormal actuals newEnv
74		newEnv'' = insert envFormal (envToExpr env) newEnv'
	74	newEnv'' = insert envFormal env newEnv'
75	75	in
76	76	newEnv''
77	77

97	97	assertList i = assert i (isList) "expected-list"
98	98	assertNumber i = assert i (isNumber) "expected-number"
99	99	assertMacro i = assert i (isMacro) "expected-macro"
100
101		assertExprToEnv i envExpr k =
102		case exprToEnv envExpr of
103		Right env ->
104		k env
105		Left (msg, value) ->
106		raise i $ errMsg msg value⏎

+1

-28

src/Language/Robin/Expr.hs less more

68	68	\| s == t = Just value
69	69	\| otherwise = find s (List rest)
70	70	find s (List (_:rest)) = find s (List rest)
	71	find _ (_) = Nothing
71	72
72	73	fromList :: [(String, Expr)] -> Env
73	74	fromList [] = empty

82	83
83	84	append (List x) (List y) =
84	85	List (x ++ y)
85
86		--
87		-- Given a list of pairs (two-elements lists) of symbols and values,
88		-- return either an Env where each symbol is associated with its value,
89		-- or an error message describing why the Env could not be created.
90		--
91
92		-- exprToEnv :: Expr -> Either (String, Expr) Env
93		-- exprToEnv (List []) = Right empty
94		-- exprToEnv (List (first:rest)) =
95		-- case first of
96		-- List [Symbol s, value] ->
97		-- case exprToEnv (List rest) of
98		-- Right remainder -> Right (insert s value remainder)
99		-- other -> other
100		-- List [other, _] ->
101		-- Left ("expected-symbol", other)
102		-- other ->
103		-- Left ("expected-env-entry", other)
104		-- exprToEnv other = Left ("expected-env-alist", other)
105
106
107		exprToEnv :: Expr -> Either (String, Expr) Env
108		exprToEnv env@(List _) = Right env
109		exprToEnv other = Left ("expected-env-alist", other)
110
111		envToExpr :: Env -> Expr
112		envToExpr env = env
113	86
114	87	--
115	88	-- Predicates

+1

-5

src/Language/Robin/Intrinsics.hs less more

76	76	robinEval i env (List [envlist, form]) cc =
77	77	eval i env envlist (\newEnvVal ->
78	78	eval i env form (\body ->
79		case exprToEnv newEnvVal of
80		Right newEnv ->
81		eval i newEnv body cc
82		Left (msg, value) ->
83		raise i (errMsg msg value)))
	79	eval i newEnvVal body cc))
84	80	robinEval i env other cc = raise i (errMsg "illegal-arguments" other)
85	81
86	82	robinMacro :: Evaluable

+3

-10

src/QuickCheckTests.hs less more

21	21	robinExpr str = insist $ parseExpr str
22	22
23	23	stdEval env expr = eval (IEnv stop) env expr id
24
25
26		propEnvExpr :: [(String, Int32)] -> Bool
27		propEnvExpr entries =
28		exprToEnv (envToExpr env) == Right env
29		where
30		env = fromList $ map (\(k,v) -> (k, Number v)) entries
31	24
32	25
33	26	--

56	49	stdEval env expr == Boolean True
57	50	where
58	51	expr = List [Symbol "env?", List [Symbol "literal", alist]]
59		alist = envToExpr $ fromList $ map (\(k,v) -> (k, Number v)) entries
	52	alist = fromList $ map (\(k,v) -> (k, Number v)) entries
60	53
61	54
62	55	--

69	62	where
70	63	litSym = List [Symbol "literal", Symbol sym]
71	64	expr = List [Symbol "lookup", litSym, List [Symbol "delete", litSym, List [Symbol "literal", alist]]]
72		alist = envToExpr $ fromList $ map (\(k,v) -> (k, Number v)) entries
	65	alist = fromList $ map (\(k,v) -> (k, Number v)) entries
73	66
74	67	--
75	68	-- The following should be true for any symbol s and binding alist a:

81	74	where
82	75	litSym = List [Symbol "literal", Symbol sym]
83	76	expr = List [Symbol "lookup", litSym, List [Symbol "extend", litSym, Number 1, List [Symbol "literal", alist]]]
84		alist = envToExpr $ fromList $ map (\(k,v) -> (k, Number v)) entries
	77	alist = fromList $ map (\(k,v) -> (k, Number v)) entries
85	78
86	79
87	80	testAll = do

+2

-2

stdlib/eval.robin less more

41	41
42	42	`eval` will happily use whatever type of value you like as the
43	43	environment, however, subsequent evaluation will fail when it
44		tries to look up things in that environment.
	44	tries to look up things in that environment. FIXME: (expected-env-alist 103)
45	45
46	46	\| (eval 103 (literal
47	47	\| (prepend (literal a)
48	48	\| (prepend (literal b) ()))))
49		? uncaught exception: (expected-env-alist 103)
	49	? uncaught exception
50	50
51	51	Evaluation expects the contents of the list which makes up the
52	52	environment to be two-element lists. FIXME