1	import Base
2	import ./ordinary_app_execution_recipe.bend as Exec
3	import ./ordinary_app_registration_fields.bend as Fields
4	import ./ordinary_app_records.bend as Records
5	import ./ordinary_app_composer.bend as Build
6	import ./execution_context.bend as Ctx
7	import ./schedule_provision.bend as SP
8	import ./schedule.bend as Sch
9	import ./system.bend as Sys
10	import ./local.bend as Local
11	import ./ordinary_reader_system.bend as Reader
12	import ./ordinary_app_recipe.bend as Tree
13	import ./world.bend as W
14	
15	def folded(~S:Data,~O:Type,~Shared:Type,shared:Shared,result:O & Fields.Fields<S>) -> (O & Shared) & List<&2,Fields.Fields<S>>:
16	  match result:
17	    case (owner,fields):((owner,shared),[fields])
18	def fold(~S:Data,~O:Type,~Shared:Type,~catalog:O -> O & Fields.Fields<S>,value:O & Shared) -> (O & Shared) & List<&2,Fields.Fields<S>>:
19	  match value:
20	    case (owner,shared):folded(~S,~O,~Shared,shared,catalog(owner))
21	def selected_plan(~S:Data,enabled:Bool,field:Fields.Fields<S>,needs:List<&2,SP.Requirement<S>>) -> SP.Plan<S>:
22	  match enabled:
23	    case True{}:SP.Entry{Sch.System{Exec.registration_id(~S,field),0},needs}
24	    case False{}:SP.Empty{}
25	def planned(~S:Data,~O:Type,~Shared:Type,needs:List<&2,SP.Requirement<S>>,result:O & Fields.Fields<S>,selection:Shared & Bool) -> (O & Shared) & SP.Plan<S>:
26	  match result selection:
27	    case (owner,fields),(shared,enabled):((owner,shared),selected_plan(~S,enabled,fields,needs))
28	def plan(~S:Data,~O:Type,~Shared:Type,~catalog:O -> O & Fields.Fields<S>,~enabled:Shared -> Shared & Bool,~needs:List<&2,SP.Requirement<S>>,value:O & Shared) -> (O & Shared) & SP.Plan<S>:
29	  match value:
30	    case (owner,shared):planned(~S,~O,~Shared,needs,catalog(owner),enabled(shared))
31	def returned(~World:Type,~O:Type,~Shared:Type,~Error:Data,result:O & (Shared & Sys.Outcome<Ctx.Context<World>,Error,Unit>)) -> (O & Shared) & Sys.Outcome<Ctx.Context<World>,Error,Unit>:
32	  match result:
33	    case (owner,(shared,outcome)):((owner,shared),outcome)
34	def invoked(~S:Data,~World:Type,~O:Type,~Shared:Type,~Error:Data,~invoke:O -> Shared -> Ctx.Context<World> -> O & (Shared & Sys.Outcome<Ctx.Context<World>,Error,Unit>),~refused:Error,allowed:Bool,owner:O,shared:Shared,context:Ctx.Context<World>) -> (O & Shared) & Sys.Outcome<Ctx.Context<World>,Error,Unit>:
35	  match allowed:
36	    case False{}:((owner,shared),Sys.Failed{context,refused})
37	    case True{}:returned(~World,~O,~Shared,~Error,invoke(owner,shared,context))
38	def catalogued(~S:Data,~World:Type,~O:Type,~Shared:Type,~Error:Data,~invoke:O -> Shared -> Ctx.Context<World> -> O & (Shared & Sys.Outcome<Ctx.Context<World>,Error,Unit>),~refused:Error,shared:Shared,context:Ctx.Context<World>,id:U32,result:O & Fields.Fields<S>) -> (O & Shared) & Sys.Outcome<Ctx.Context<World>,Error,Unit>:
39	  match result:
40	    case (owner,fields):invoked(~S,~World,~O,~Shared,~Error,~invoke,~refused,U32.is_eq(Exec.registration_id(~S,fields),id),owner,shared,context)
41	def dispatch(~S:Data,~World:Type,~O:Type,~Shared:Type,~Error:Data,~catalog:O -> O & Fields.Fields<S>,~invoke:O -> Shared -> Ctx.Context<World> -> O & (Shared & Sys.Outcome<Ctx.Context<World>,Error,Unit>),~refused:Error,value:O & Shared,context:Ctx.Context<World>,id:U32) -> (O & Shared) & Sys.Outcome<Ctx.Context<World>,Error,Unit>:
42	  match value:
43	    case (owner,shared):catalogued(~S,~World,~O,~Shared,~Error,~invoke,~refused,shared,context,id,catalog(owner))
44	def right_folded(~S:Data,~L:Type,~R:Type,~Shared:Type,left:L,first:List<&2,Fields.Fields<S>>,result:(R & Shared) & List<&2,Fields.Fields<S>>) -> ((L & R) & Shared) & List<&2,Fields.Fields<S>>:
45	  match result:
46	    case ((right,shared),last):(((left,right),shared),List.append(&2,Fields.Fields<S>,first,last))
47	def left_folded(~S:Data,~L:Type,~R:Type,~Shared:Type,~rightFold:(R & Shared) -> (R & Shared) & List<&2,Fields.Fields<S>>,right:R,result:(L & Shared) & List<&2,Fields.Fields<S>>) -> ((L & R) & Shared) & List<&2,Fields.Fields<S>>:
48	  match result:
49	    case ((left,shared),fields):right_folded(~S,~L,~R,~Shared,left,fields,rightFold((right,shared)))
50	def pair_fold(~S:Data,~L:Type,~R:Type,~Shared:Type,~leftFold:(L & Shared) -> (L & Shared) & List<&2,Fields.Fields<S>>,~rightFold:(R & Shared) -> (R & Shared) & List<&2,Fields.Fields<S>>,value:(L & R) & Shared) -> ((L & R) & Shared) & List<&2,Fields.Fields<S>>:
51	  match value:
52	    case ((left,right),shared):left_folded(~S,~L,~R,~Shared,~rightFold,right,leftFold((left,shared)))
53	def right_planned(~S:Data,~L:Type,~R:Type,~Shared:Type,left:L,before:SP.Plan<S>,result:(R & Shared) & SP.Plan<S>) -> ((L & R) & Shared) & SP.Plan<S>:
54	  match result:
55	    case ((right,shared),after):(((left,right),shared),SP.Sequence{before,after})
56	def left_planned(~S:Data,~L:Type,~R:Type,~Shared:Type,~rightPlan:(R & Shared) -> (R & Shared) & SP.Plan<S>,right:R,result:(L & Shared) & SP.Plan<S>) -> ((L & R) & Shared) & SP.Plan<S>:
57	  match result:
58	    case ((left,shared),before):right_planned(~S,~L,~R,~Shared,left,before,rightPlan((right,shared)))
59	def pair_plan(~S:Data,~L:Type,~R:Type,~Shared:Type,~leftPlan:(L & Shared) -> (L & Shared) & SP.Plan<S>,~rightPlan:(R & Shared) -> (R & Shared) & SP.Plan<S>,value:(L & R) & Shared) -> ((L & R) & Shared) & SP.Plan<S>:
60	  match value:
61	    case ((left,right),shared):left_planned(~S,~L,~R,~Shared,~rightPlan,right,leftPlan((left,shared)))
62	def left_returned(~World:Type,~L:Type,~R:Type,~Shared:Type,~Error:Data,right:R,result:(L & Shared) & Sys.Outcome<Ctx.Context<World>,Error,Unit>) -> ((L & R) & Shared) & Sys.Outcome<Ctx.Context<World>,Error,Unit>:
63	  match result:
64	    case ((left,shared),outcome):(((left,right),shared),outcome)
65	def right_returned(~World:Type,~L:Type,~R:Type,~Shared:Type,~Error:Data,left:L,result:(R & Shared) & Sys.Outcome<Ctx.Context<World>,Error,Unit>) -> ((L & R) & Shared) & Sys.Outcome<Ctx.Context<World>,Error,Unit>:
66	  match result:
67	    case ((right,shared),outcome):(((left,right),shared),outcome)
68	def pair_selected(~World:Type,~L:Type,~R:Type,~Shared:Type,~Error:Data,~leftDispatch:(L & Shared) -> Ctx.Context<World> -> U32 -> (L & Shared) & Sys.Outcome<Ctx.Context<World>,Error,Unit>,~rightDispatch:(R & Shared) -> Ctx.Context<World> -> U32 -> (R & Shared) & Sys.Outcome<Ctx.Context<World>,Error,Unit>,selected:Bool,left:L,right:R,shared:Shared,context:Ctx.Context<World>,id:U32) -> ((L & R) & Shared) & Sys.Outcome<Ctx.Context<World>,Error,Unit>:
69	  match selected:
70	    case True{}:left_returned(~World,~L,~R,~Shared,~Error,right,leftDispatch((left,shared),context,id))
71	    case False{}:right_returned(~World,~L,~R,~Shared,~Error,left,rightDispatch((right,shared),context,id))
72	def pair_catalogued(~S:Data,~World:Type,~L:Type,~R:Type,~Shared:Type,~Error:Data,~leftDispatch:(L & Shared) -> Ctx.Context<World> -> U32 -> (L & Shared) & Sys.Outcome<Ctx.Context<World>,Error,Unit>,~rightDispatch:(R & Shared) -> Ctx.Context<World> -> U32 -> (R & Shared) & Sys.Outcome<Ctx.Context<World>,Error,Unit>,right:R,context:Ctx.Context<World>,+id:U32,result:(L & Shared) & List<&2,Fields.Fields<S>>) -> ((L & R) & Shared) & Sys.Outcome<Ctx.Context<World>,Error,Unit>:
73	  match result:
74	    case ((left,shared),fields):pair_selected(~World,~L,~R,~Shared,~Error,~leftDispatch,~rightDispatch,Exec.member(~S,fields,id),left,right,shared,context,id)
75	def pair_dispatch(~S:Data,~World:Type,~L:Type,~R:Type,~Shared:Type,~Error:Data,~leftFold:(L & Shared) -> (L & Shared) & List<&2,Fields.Fields<S>>,~leftDispatch:(L & Shared) -> Ctx.Context<World> -> U32 -> (L & Shared) & Sys.Outcome<Ctx.Context<World>,Error,Unit>,~rightDispatch:(R & Shared) -> Ctx.Context<World> -> U32 -> (R & Shared) & Sys.Outcome<Ctx.Context<World>,Error,Unit>,value:(L & R) & Shared,context:Ctx.Context<World>,id:U32) -> ((L & R) & Shared) & Sys.Outcome<Ctx.Context<World>,Error,Unit>:
76	  match value:
77	    case ((left,right),shared):pair_catalogued(~S,~World,~L,~R,~Shared,~Error,~leftDispatch,~rightDispatch,right,context,id,leftFold((left,shared)))
78	def barrier_plan(~S:Data,enabled:Bool,before:SP.Plan<S>) -> SP.Plan<S>:
79	  match enabled:
80	    case False{}:before
81	    case True{}:SP.Sequence{before,SP.Entry{Sch.Barrier{},[]}}
82	def after_selected(~S:Data,~O:Type,~Shared:Type,owner:O,before:SP.Plan<S>,selection:Shared & Bool) -> (O & Shared) & SP.Plan<S>:
83	  match selection:
84	    case (shared,enabled):((owner,shared),barrier_plan(~S,enabled,before))
85	def after_planned(~S:Data,~O:Type,~Shared:Type,~after:Shared -> Shared & Bool,result:(O & Shared) & SP.Plan<S>) -> (O & Shared) & SP.Plan<S>:
86	  match result:
87	    case ((owner,shared),before):after_selected(~S,~O,~Shared,owner,before,after(shared))
88	def after(~S:Data,~O:Type,~Shared:Type,~plan:(O & Shared) -> (O & Shared) & SP.Plan<S>,~after:Shared -> Shared & Bool,value:O & Shared) -> (O & Shared) & SP.Plan<S>:
89	  after_planned(~S,~O,~Shared,~after,plan(value))
90	def local_fields(~S:Data,~C:Type,~R:Type,~E:Data,~L:Type,~Args:Type,~Error:Data,~Out:Type,~runner:W.World<S,C,R,E> -> L -> Args -> Local.Outcome<W.World<S,C,R,E>,L,Error,Out>,value:Local.Instance<S,C,R,E,L,Args,Error,Out,runner>) -> Local.Instance<S,C,R,E,L,Args,Error,Out,runner> & Fields.Fields<S>:
91	  match value:
92	    case Local.Instance{+namespace,+id,+name,+access,local}:(Local.Instance{namespace,id,name,access,local},Fields.Fields{namespace,id,name,access,None{},name,[],Fields.MixedKind{[]}})
93	def system_fields(~S:Data,~C:Type,~R:Type,~E:Data,~Args:Type,~Error:Data,~Out:Type,~runner:W.World<S,C,R,E> -> Args -> Sys.Outcome<W.World<S,C,R,E>,Error,Out>,value:Sys.Registry<S,C,R,E,Args,Error,Out,runner>) -> Sys.Registry<S,C,R,E,Args,Error,Out,runner> & Fields.Fields<S>:
94	  match value:
95	    case Sys.Registry{+namespace,+id,+name,+access,+cursor}:(Sys.Registry{namespace,id,name,access,cursor},Fields.Fields{namespace,id,name,access,cursor,name,[],Fields.MixedKind{[]}})
96	def reader_fields(~S:Data,~C:Type,~R:Type,~E:Data,~Args:Type,~Error:Data,~Out:Type,~runner:W.World<S,C,R,E> -> Args -> Sys.Outcome<W.World<S,C,R,E>,Error,Out>,~Owner:Type,~Param:Type,~Decl:Type,value:Reader.Provider<Sys.Registry<S,C,R,E,Args,Error,Out,runner>,Owner,Param,Decl>) -> Reader.Provider<Sys.Registry<S,C,R,E,Args,Error,Out,runner>,Owner,Param,Decl> & Fields.Fields<S>:
97	  match value:
98	    case Reader.Provider{Sys.Registry{+namespace,+id,+name,+access,+cursor},owner,param,decl}:(Reader.Provider{Sys.Registry{namespace,id,name,access,cursor},owner,param,decl},Fields.Fields{namespace,id,name,access,cursor,name,[],Fields.MixedKind{[]}})
99	
100	def registered(~S:Data,~World:Type,~H:Type,~fold:H -> H & List<&2,Fields.Fields<S>>,~Error:Data,~plan:H -> H & SP.Plan<S>,~dispatch:H -> Ctx.Context<World> -> U32 -> H & Sys.Outcome<Ctx.Context<World>,Error,Unit>,~provide:World -> World & List<&2,SP.Requirement<S>>,world:World,owners:H) -> Exec.Registered<S,World,H,Unit,Build.empty_observe(~World),fold,Error,plan,dispatch,provide>:
101	  Exec.Registered{Build.Registered{world,owners,Tree.Recipe{},False{}},Exec.Recipe{}}