def number_tail_acc

qasim-bend-kit@0.1.0.2 · proof/JSON_RenderLexProof.bend:90

import Base
import qasim-bend-kit@0.1.0.2/libs/JSON.bend as J
import qasim-bend-kit@0.1.0.2/proof/JSON_NumberLexProof.bend as Num
import qasim-bend-kit@0.1.0.2/proof/JSON_StringProof.bend as S

90def number_tail_acc(+text: String,
91                    +state: J.NumberState,
92                    +rev_head: Char,
93                    +rev_tail: String,
94                    +first: Char,
95                    +prefix_tail: String,
96                    +acc: List<&2, J.Lexeme>,
97                    +reverse_prefix: {String.reverse(SCon{rev_head, rev_tail}) == SCon{first, prefix_tail} : String},
98                    +evidence: {J.number_valid_end(J.number_valid_step(text, state)) == True{} : Bool}) -> {J.lex_scan(text, J.Outside{}, SCon{rev_head, rev_tail}, acc) == (List.reverse(&2, J.Lexeme, J.Payload{SCon{first, prefix_tail} ++ text} <> acc)) : List<&2, J.Lexeme>}:
99    match text:
100        case SNil{}:
101            Equal.trans(List<&2, J.Lexeme>,
102                J.lex_scan(SNil{}, J.Outside{}, SCon{rev_head, rev_tail}, acc),
103                List.reverse(&2, J.Lexeme, J.Payload{String.reverse(SCon{rev_head, rev_tail})} <> acc),
104                List.reverse(&2, J.Lexeme, J.Payload{SCon{first, prefix_tail} ++ SNil{}} <> acc),
105                {==},
106                Equal.trans(List<&2, J.Lexeme>,
107                    List.reverse(&2, J.Lexeme, J.Payload{String.reverse(SCon{rev_head, rev_tail})} <> acc),
108                    List.reverse(&2, J.Lexeme, J.Payload{SCon{first, prefix_tail}} <> acc),
109                    List.reverse(&2, J.Lexeme, J.Payload{SCon{first, prefix_tail} ++ SNil{}} <> acc),
110                    Equal.cong(String, List<&2, J.Lexeme>, s => List.reverse(&2, J.Lexeme, J.Payload{s} <> acc),
111                        String.reverse(SCon{rev_head, rev_tail}), SCon{first, prefix_tail}, reverse_prefix),
112                    Equal.cong(String, List<&2, J.Lexeme>, s => List.reverse(&2, J.Lexeme, J.Payload{s} <> acc),
113                        SCon{first, prefix_tail}, SCon{first, prefix_tail} ++ SNil{},
114                        Equal.sym(String, SCon{first, prefix_tail} ++ SNil{}, SCon{first, prefix_tail}, S.append_nil(SCon{first, prefix_tail})))))
115        case SCon{+head, +tail}:
116            Equal.trans(List<&2, J.Lexeme>,
117                J.lex_scan(text, J.Outside{}, SCon{rev_head, rev_tail}, acc),
118                J.lexemes(text, J.Outside{}, SCon{rev_head, rev_tail}, acc, J.LexRaw{}),
119                List.reverse(&2, J.Lexeme, J.Payload{SCon{first, prefix_tail} ++ text} <> acc),
120                Equal.cong(J.LexAction, List<&2, J.Lexeme>, action => J.lexemes(text, J.Outside{}, SCon{rev_head, rev_tail}, acc, action),
121                    J.lex_seed_action(text, J.Outside{}), J.LexRaw{},
122                    Num.number_char_action(head, J.number_char(head), {==}, tail, state, evidence)),
123                Equal.trans(List<&2, J.Lexeme>,
124                    J.lexemes(text, J.Outside{}, SCon{rev_head, rev_tail}, acc, J.LexRaw{}),
125                    J.lex_scan(tail, J.Outside{}, SCon{head, SCon{rev_head, rev_tail}}, acc),
126                    List.reverse(&2, J.Lexeme, J.Payload{SCon{first, prefix_tail} ++ text} <> acc),
127                    {==},
128                    Equal.trans(List<&2, J.Lexeme>,
129                        J.lex_scan(tail, J.Outside{}, SCon{head, SCon{rev_head, rev_tail}}, acc),
130                        List.reverse(&2, J.Lexeme, J.Payload{(SCon{first, prefix_tail} ++ SCon{head, SNil{}}) ++ tail} <> acc),
131                        List.reverse(&2, J.Lexeme, J.Payload{SCon{first, prefix_tail} ++ text} <> acc),
132                        number_tail_acc(tail, J.number_next(state, head), head, SCon{rev_head, rev_tail}, first,
133                            prefix_tail ++ SCon{head, SNil{}}, acc,
134                            Equal.trans(String,
135                                String.reverse(SCon{head, SCon{rev_head, rev_tail}}),
136                                String.reverse(SCon{rev_head, rev_tail}) ++ SCon{head, SNil{}},
137                                SCon{first, prefix_tail} ++ SCon{head, SNil{}},
138                                S.reverse_cons(head, SCon{rev_head, rev_tail}),
139                                Equal.cong(String, String, x => x ++ SCon{head, SNil{}},
140                                    String.reverse(SCon{rev_head, rev_tail}), SCon{first, prefix_tail}, reverse_prefix)),
141                            Num.number_valid_cons(head, tail, state, evidence)),
142                        Equal.cong(String, List<&2, J.Lexeme>, s => List.reverse(&2, J.Lexeme, J.Payload{s} <> acc),
143                            (SCon{first, prefix_tail} ++ SCon{head, SNil{}}) ++ tail,
144                            SCon{first, prefix_tail} ++ text,
145                            S.append_assoc(SCon{first, prefix_tail}, SCon{head, SNil{}}, tail)))))