Commit 6d51b9bcdbd1ab7d4cbe8881e72d9ac4a212fc16 - Robin

No need for Either in World results. Chris Pressey 5 years ago

3 changed file(s) with 12 addition(s) and 19 deletion(s). Raw diff Collapse all Expand all

-3

src/HasteMain.hs less more

26	26	Left problem -> do
27	27	setProp resultElem "textContent" $ show $ problem
28	28	showResults results =
29		(foldl (\a x -> x ++ "\n" ++ a) "" (map (showResult) results))
30		showResult (Right result) = show result
31		showResult (Left result) = "uncaught exception: " ++ (show result)
	29	(foldl (\a x -> x ++ "\n" ++ a) "" (map (show) results))

-4

src/Language/Robin/CmdLine.hs less more

4	4	import System.IO
5	5	import System.Exit
6	6
7		import Language.Robin.Expr (Expr(List, Symbol))
	7	import Language.Robin.Expr (Expr(List, Symbol, Abort))
8	8	import Language.Robin.Parser (parseToplevel, parseExpr)
9	9	import Language.Robin.Intrinsics (robinIntrinsics)
10	10	import Language.Robin.TopLevel (initialWorld, destructureWorld, collect, secondaryDefs)

49	49
50	50
51	51	writeResults [] = return ()
52		writeResults ((Right result):results) = do
	52	writeResults (expr@(Abort _):results) =
	53	abortWith $ show expr
	54	writeResults (result:results) = do
53	55	putStrLn $ show result
54	56	writeResults results
55		writeResults ((Left expr):results) =
56		abortWith $ show expr

-12

src/Language/Robin/TopLevel.hs less more

0	0	module Language.Robin.TopLevel where
1	1
2		import Prelude (show, id, fromIntegral, length, ($), (++), Bool(False), Maybe(Just, Nothing), Either(Left, Right))
	2	import Prelude (show, id, fromIntegral, length, ($), (++), Bool(False), Maybe(Just, Nothing))
3	3
4	4	import Language.Robin.Expr
5	5	import Language.Robin.Env (Env, find, insert, empty)

11	11	env :: Env,
12	12	secondaryDefs :: Env,
13	13	reactors :: [Reactor.Reactor],
14		results :: [Either Expr Expr]
	14	results :: [Expr]
15	15	}
16	16
17	17	assertionFailed expr =

32	32	collect [] result = result
33	33
34	34	collect ((List [Symbol "display", expr]):rest) world@World{ env=env, results=results } =
35		let
36		result = case eval env expr id of
37		Abort expr -> Left (Abort expr)
38		other -> Right other
39		in
40		collect rest world{ results=(result:results) }
	35	collect rest world{ results=((eval env expr id):results) }
41	36
42	37	collect ((List [Symbol "assert", expr]):rest) world@World{ env=env, results=results } =
43	38	case eval env expr id of
44	39	Abort expr ->
45		world{ results=((Left (Abort expr)):results) }
	40	world{ results=((Abort expr):results) }
46	41	Boolean False ->
47		world{ results=((Left (Abort $ assertionFailed expr)):results) }
	42	world{ results=((Abort $ assertionFailed expr):results) }
48	43	_ ->
49	44	collect rest world
50	45
51	46	collect ((List [Symbol "require", sym@(Symbol s)]):rest) world@World{ env=env, results=results } =
52	47	case find s env of
53	48	Nothing ->
54		world{ results=((Left (Abort $ assertionFailed (List [Symbol "bound?", sym]))):results) }
	49	world{ results=((Abort $ assertionFailed (List [Symbol "bound?", sym])):results) }
55	50	_ ->
56	51	collect rest world
57	52

77	72	collect rest world{ reactors=(newReactor:reactors) }
78	73
79	74	collect (expr:rest) world@World{ results=results } =
80		world{ results=((Left (Abort $ illegalTopLevel expr)):results) }
	75	world{ results=((Abort $ illegalTopLevel expr):results) }