1	import Base
2	import ./change_tick.bend as Tick
3	import ./restore_data.bend as R
4	import ./restore_leaf.bend as Stage
5	import ./snapshot_leaf.bend as Leaf
6	import ./ordinary_declaration.bend as Identity
7	import ./decode_data.bend as D
8	import ./column.bend as Col
9	import ./world.bend as W
10	import ./entity_key.bend as Key
11	import ./persistence_declaration.bend as Decl
12	
13	def inserted(~S:Data,~Context:Type,~I:Type,~P:Type,+position:R.Position,undo:P -> I,context:Context,records:List<Stage.Record<I,P>>,returned:List<I>,removed:List<P>,applied:List<Stage.Applied<I,P>>,+target:W.Handle<S>,tick:Tick.Tick,result:Col.SwapOutcome<S,P>) -> Col.Column<S,P> & Stage.State<Context,I,P>:
14	  match result:
15	    case Col.Accepted{column,None{}}:(Col.mark(~S,~P,column,W.handle_index(~S,target),True{},False{},tick),Stage.State{context,records,returned,removed,Stage.Applied{position,undo} <> applied})
16	    case Col.Accepted{column,Some{old}}:(Col.mark(~S,~P,column,W.handle_index(~S,target),True{},True{},tick),Stage.State{context,records,returned,old <> removed,Stage.Applied{position,undo} <> applied})
17	    case Col.Rejected{column,Some{owner}}:(column,Stage.State{context,Stage.Record{position,owner,undo} <> records,returned,removed,applied})
18	    case Col.Rejected{column,None{}}:(column,Stage.State{context,records,returned,removed,Stage.Applied{position,undo} <> applied})
19	def mapped(~S:Data,~Context:Type,~I:Type,~P:Type,+saved:Key.Key,owner:P,undo:P -> I,state:Stage.State<Context,I,P>,column:Col.Column<S,P>,tick:Tick.Tick,target:Maybe<&2,W.Handle<S>>) -> Col.Column<S,P> & Stage.State<Context,I,P>:
20	  match state target:
21	    case Stage.State{context,records,returned,removed,applied} None{}:(column,Stage.State{context,Stage.Record{R.Component{saved},owner,undo} <> records,returned,removed,applied})
22	    case Stage.State{context,records,returned,removed,applied} Some{+target}:inserted(~S,~Context,~I,~P,R.Component{saved},undo,context,records,returned,removed,applied,target,tick,Col.swap(~S,~P,Col.ensure(~S,~P,column,W.handle_index(~S,target)),W.handle_index(~S,target),Some{owner}))
23	def component_record(~S:Data,~Context:Type,~I:Type,~P:Type,record:Stage.Record<I,P>,state:Stage.State<Context,I,P>,column:Col.Column<S,P>,+bindings:List<&2,R.Binding<S>>,tick:Tick.Tick) -> Col.Column<S,P> & Stage.State<Context,I,P>:
24	  match record state:
25	    case Stage.Record{R.Component{+saved},owner,undo} state:mapped(~S,~Context,~I,~P,saved,owner,undo,state,column,tick,R.lookup(~S,saved,bindings))
26	    case record Stage.State{context,records,returned,removed,applied}:(column,Stage.State{context,record <> records,returned,removed,applied})
27	def components_next(~S:Data,~Context:Type,~I:Type,~P:Type,next:Col.Column<S,P> -> Stage.State<Context,I,P> -> Col.Column<S,P> & Stage.State<Context,I,P>,observed:Col.Column<S,P> & Stage.State<Context,I,P>) -> Col.Column<S,P> & Stage.State<Context,I,P>:
28	  match observed:
29	    case (column,state):next(column,state)
30	def component_records(~S:Data,~Context:Type,~I:Type,~P:Type,records:List<Stage.Record<I,P>>,state:Stage.State<Context,I,P>,column:Col.Column<S,P>,+bindings:List<&2,R.Binding<S>>,+tick:Tick.Tick) -> Col.Column<S,P> & Stage.State<Context,I,P>:
31	  match records:
32	    case []:(column,state)
33	    case record <> rest:components_next(~S,~Context,~I,~P,column => state => component_records(~S,~Context,~I,~P,rest,state,column,bindings,tick),component_record(~S,~Context,~I,~P,record,state,column,bindings,tick))
34	def component_join(~S:Data,~Context:Type,~I:Type,~P:Type,~identity:Identity.Declaration<S,P>,~project:P -> P & D.Raw,declaration:Decl.Constructed<S,P,identity,project>,observed:Col.Column<S,P> & Stage.State<Context,I,P>) -> Leaf.Component<S,P,identity,project> & Stage.State<Context,I,P>:
35	  match observed:
36	    case (column,state):(Leaf.Component{column,declaration},state)
37	def components(~S:Data,~Context:Type,~I:Type,~P:Type,~identity:Identity.Declaration<S,P>,~project:P -> P & D.Raw,owner:Leaf.Component<S,P,identity,project>,state:Stage.State<Context,I,P>,bindings:List<&2,R.Binding<S>>,tick:Tick.Tick) -> Leaf.Component<S,P,identity,project> & Stage.State<Context,I,P>:
38	  match owner state:
39	    case Leaf.Component{column,declaration} Stage.State{context,records,returned,removed,applied}:component_join(~S,~Context,~I,~P,~identity,~project,declaration,component_records(~S,~Context,~I,~P,List.reverse(&1,Stage.Record<I,P>,records),Stage.State{context,[],returned,removed,applied},column,bindings,tick))
40	def resource_record(~Context:Type,~I:Type,~P:Type,record:Stage.Record<I,P>,state:Stage.State<Context,I,P>,previous:P) -> P & Stage.State<Context,I,P>:
41	  match record state:
42	    case Stage.Record{R.Resource{},owner,undo} Stage.State{context,records,returned,removed,applied}:(owner,Stage.State{context,records,returned,previous <> removed,Stage.Applied{R.Resource{},undo} <> applied})
43	    case record Stage.State{context,records,returned,removed,applied}:(previous,Stage.State{context,record <> records,returned,removed,applied})
44	def resource_next(~Context:Type,~I:Type,~P:Type,next:P -> Stage.State<Context,I,P> -> P & Stage.State<Context,I,P>,observed:P & Stage.State<Context,I,P>) -> P & Stage.State<Context,I,P>:
45	  match observed:
46	    case (owner,state):next(owner,state)
47	def resource_records(~Context:Type,~I:Type,~P:Type,records:List<Stage.Record<I,P>>,state:Stage.State<Context,I,P>,owner:P) -> P & Stage.State<Context,I,P>:
48	  match records:
49	    case []:(owner,state)
50	    case record <> rest:resource_next(~Context,~I,~P,owner => state => resource_records(~Context,~I,~P,rest,state,owner),resource_record(~Context,~I,~P,record,state,owner))
51	def resource_join(~S:Data,~Context:Type,~I:Type,~P:Type,~identity:Identity.Declaration<S,P>,~project:P -> P & D.Raw,declaration:Decl.Constructed<S,P,identity,project>,observed:P & Stage.State<Context,I,P>) -> Leaf.Resource<S,P,identity,project> & Stage.State<Context,I,P>:
52	  match observed:
53	    case (owner,state):(Leaf.Resource{owner,declaration},state)
54	def resources(~S:Data,~Context:Type,~I:Type,~P:Type,~identity:Identity.Declaration<S,P>,~project:P -> P & D.Raw,owner:Leaf.Resource<S,P,identity,project>,state:Stage.State<Context,I,P>) -> Leaf.Resource<S,P,identity,project> & Stage.State<Context,I,P>:
55	  match owner state:
56	    case Leaf.Resource{owner,declaration} Stage.State{context,records,returned,removed,applied}:resource_join(~S,~Context,~I,~P,~identity,~project,declaration,resource_records(~Context,~I,~P,List.reverse(&1,Stage.Record<I,P>,records),Stage.State{context,[],returned,removed,applied},owner))