1	import Base
2	import ./execution_composer_layout.bend as L
3	import ./execution_query_schema.bend as Routes
4	
5	type Permission is Data:
6	  Unused{}
7	  ReadOnly{}
8	  Writable{}
9	type Entry is Data:
10	  Entry{route:L.Route,key:String,permission:Permission}
11	type Book<-S:Data,-full:L.Layout> is Data:
12	  Book{entries:List<&2,Entry>}
13	def combine(left:Permission,right:Permission) -> Permission:
14	  match left right:
15	    case Writable{} _:Writable{}
16	    case _ Writable{}:Writable{}
17	    case ReadOnly{} _:ReadOnly{}
18	    case _ ReadOnly{}:ReadOnly{}
19	    case _ _:Unused{}
20	def at_entry(permission:Permission,next:Permission,selected:Bool) -> Permission:
21	  match selected:
22	    case True{}:combine(permission,next)
23	    case False{}:next
24	def at(+route:L.Route,entries:List<&2,Entry>) -> Permission:
25	  match entries:
26	    case []:Unused{}
27	    case Entry{selected,_,permission} <> rest:at_entry(permission,at(route,rest),Routes.same_route(route,selected))
28	def valid(~full:L.Layout,entries:List<&2,Entry>) -> Bool:
29	  match entries:
30	    case []:True{}
31	    case Entry{+route,key,_} <> rest:Bool.and(L.valid(full,route),Bool.and(String.eq(L.key(full,route),key),valid(~full,rest)))
32	def conflict(left:Permission,right:Permission) -> Bool:
33	  match left right:
34	    case Unused{} _:False{}
35	    case _ Unused{}:False{}
36	    case ReadOnly{} ReadOnly{}:False{}
37	    case _ _:True{}
38	def conflicts(+right:List<&2,Entry>,left:List<&2,Entry>) -> Bool:
39	  match left:
40	    case []:False{}
41	    case Entry{route,_,permission} <> rest:Bool.or(conflict(permission,at(route,right)),conflicts(right,rest))
42	def compatible(~full:L.Layout,+left:List<&2,Entry>,+right:List<&2,Entry>) -> Bool:
43	  Bool.and(L.unique(full),Bool.and(valid(~full,left),Bool.and(valid(~full,right),Bool.not(conflicts(right,left)))))
44	def same(left:Permission,right:Permission) -> Bool:
45	  match left right:
46	    case Unused{} Unused{}:True{}
47	    case ReadOnly{} ReadOnly{}:True{}
48	    case Writable{} Writable{}:True{}
49	    case _ _:False{}
50	def writes(permission:Permission) -> Bool:
51	  match permission:
52	    case Writable{}:True{}
53	    case _:False{}
54	def uses(permission:Permission) -> Bool:
55	  match permission:
56	    case Unused{}:False{}
57	    case _:True{}