text stringlengths 12 786k |
|---|
let actns_sh_map_fold ( f_actn : cnl_action -> ' a -> cnl_action * ' a ) ( f_closed : unit node -> ' a -> unit node * ' a ) ( actns : cnl_actions ) ( acc : ' a ) : cnl_actions * ' a = let f_desc desc acc = node_list_sh_map_fold f_actn f_closed desc acc in let node , acc = no... |
let actns_sh_map ( f_actn : cnl_action -> cnl_action ) ( f_closed : unit node -> unit node ) ( actns : cnl_actions ) : cnl_actions = let actns , ( ) = actns_sh_map_fold ( fun x ( ) -> f_actn x , ( ) ) ( fun x ( ) -> f_closed x , ( ) ) actns ( ) in actns |
let actns_sh_fold ( f_actn : cnl_action -> ' a -> ' a ) ( f_closed : unit node -> ' a -> ' a ) ( actns : cnl_actions ) ( acc : ' a ) : ' a = let _ , acc = actns_sh_map_fold ( fun x acc -> x , f_actn x acc ) ( fun x acc -> x , f_closed x acc ) actns acc in acc |
let actn_sh_map_fold ( f_expr : cnl_expr -> ' a -> cnl_expr * ' a ) ( actn : cnl_action ) ( acc : ' a ) : cnl_action * ' a = let f_desc desc acc = begin match desc with | A_print e -> let e , acc = f_expr e acc in A_print e , acc | A_emit e -> let e , acc = f_expr e acc in A_em... |
let actns_sh_map ( f_expr : cnl_expr -> cnl_expr ) ( actn : cnl_action ) : cnl_action = let actn , ( ) = actn_sh_map_fold ( fun x ( ) -> f_expr x , ( ) ) actn ( ) in actn |
let actn_sh_fold ( f_expr : cnl_expr -> ' a -> ' a ) ( actn : cnl_action ) ( acc : ' a ) : ' a = let _ , acc = actn_sh_map_fold ( fun x acc -> x , f_expr x acc ) actn acc in acc |
let expr_sh_map_fold ( f_expr : cnl_expr -> ' a -> cnl_expr * ' a ) ( expr : cnl_expr ) ( acc : ' a ) : cnl_expr * ' a = let f_desc expr_desc acc = begin match expr_desc with | E_lit x -> E_lit x , acc | E_var x -> E_var x , acc | E_get ( e , x ) -> let e , acc = f_expr ... |
let expr_sh_map ( f_expr : cnl_expr -> cnl_expr ) ( expr : cnl_expr ) : cnl_expr = let expr , ( ) = expr_sh_map_fold ( fun x ( ) -> f_expr x , ( ) ) expr ( ) in expr |
let expr_sh_fold ( f_expr : cnl_expr -> ' a -> ' a ) ( expr : cnl_expr ) ( acc : ' a ) : ' a = let _ , acc = expr_sh_map_fold ( fun x acc -> x , f_expr x acc ) expr acc in acc |
type ' acc map_fold_over_node_fun = { poly_map_fold_fun : ' a . cnl_kind -> ' a node -> ' acc -> ' a node * ' acc ; rule_map_fold_fun : ( cnl_rule_desc node -> ' acc -> cnl_rule_desc node * ' acc ) ; evnt_map_fold_fun : ( cnl_evnt_desc node -> ' acc -> cnl_evnt_desc node * ... |
type map_over_node_fun = { poly_map_fun : ' a . cnl_kind -> ' a node -> ' a node ; rule_map_fun : ( cnl_rule_desc node -> cnl_rule_desc node ) ; evnt_map_fun : ( cnl_evnt_desc node -> cnl_evnt_desc node ) ; cond_map_fun : ( cnl_cond_desc node -> cnl_cond_desc node ) ; actns_map_f... |
type ' acc fold_over_node_fun = { poly_fold_fun : ' a . cnl_kind -> ' a node -> ' acc -> ' acc ; rule_fold_fun : ( cnl_rule_desc node -> ' acc -> ' acc ) ; evnt_fold_fun : ( cnl_evnt_desc node -> ' acc -> ' acc ) ; cond_fold_fun : ( cnl_cond_desc node -> ' acc -> ' ... |
let id_map_fold_over_node_fun = let id node acc = ( node , acc ) in { poly_map_fold_fun = ( fun kind node acc -> ( node , acc ) ) ; rule_map_fold_fun = id ; evnt_map_fold_fun = id ; cond_map_fold_fun = id ; actns_map_fold_fun = id ; actn_map_fold_fun = id ; expr_map_fold_fun = id... |
let id_map_over_node_fun = let id node = node in { poly_map_fun = ( fun kind node -> node ) ; rule_map_fun = id ; evnt_map_fun = id ; cond_map_fun = id ; actns_map_fun = id ; actn_map_fun = id ; expr_map_fun = id ; } |
let id_fold_over_node_fun = let id node acc = acc in { poly_fold_fun = ( fun kind node acc -> acc ) ; rule_fold_fun = id ; evnt_fold_fun = id ; cond_fold_fun = id ; actns_fold_fun = id ; actn_fold_fun = id ; expr_fold_fun = id ; } |
let map_fold_over_node_fun_of_map_over_node_fun f = { poly_map_fold_fun = ( fun kind node acc -> ( f . poly_map_fun kind node , acc ) ) ; rule_map_fold_fun = ( fun node acc -> ( f . rule_map_fun node , acc ) ) ; evnt_map_fold_fun = ( fun node acc -> ( f . evnt_map_fun node , ... |
let map_fold_over_node_fun_of_fold_over_node_fun f = { poly_map_fold_fun = ( fun kind node acc -> ( node , f . poly_fold_fun kind node acc ) ) ; rule_map_fold_fun = ( fun node acc -> ( node , f . rule_fold_fun node acc ) ) ; evnt_map_fold_fun = ( fun node acc -> ( node , f . ... |
let rec expr_dp_map_fold_over_nodes ( f : ' a map_fold_over_node_fun ) ( expr : cnl_expr ) ( acc : ' a ) : cnl_expr * ' a = let node , acc = f . poly_map_fold_fun ( K_expr expr . expr_field ) expr . expr_node acc in let node , acc = f . expr_map_fold_fun node acc in expr_sh_map... |
let expr_dp_map_over_nodes ( f : map_over_node_fun ) ( expr : cnl_expr ) : cnl_expr = let node , _ = expr_dp_map_fold_over_nodes ( map_fold_over_node_fun_of_map_over_node_fun f ) expr ( ) in node |
let expr_dp_fold_over_nodes ( f : ' a fold_over_node_fun ) ( expr : cnl_expr ) ( acc : ' a ) : ' a = let _ , acc = expr_dp_map_fold_over_nodes ( map_fold_over_node_fun_of_fold_over_node_fun f ) expr acc in acc |
let evnt_dp_map_fold_over_nodes ( f : ' a map_fold_over_node_fun ) ( evnt : cnl_event ) ( acc : ' a ) : cnl_event * ' a = let node , acc = f . poly_map_fold_fun K_evnt evnt . evnt_node acc in let node , acc = f . evnt_map_fold_fun node acc in evnt_sh_map_fold ( fun ( ) acc -> ... |
let evnt_dp_map_over_nodes ( f : map_over_node_fun ) ( evnt : cnl_event ) : cnl_event = let node , _ = evnt_dp_map_fold_over_nodes ( map_fold_over_node_fun_of_map_over_node_fun f ) evnt ( ) in node |
let evnt_dp_fold_over_nodes ( f : ' a fold_over_node_fun ) ( evnt : cnl_event ) ( acc : ' a ) : ' a = let _ , acc = evnt_dp_map_fold_over_nodes ( map_fold_over_node_fun_of_fold_over_node_fun f ) evnt acc in acc |
let cond_dp_map_fold_over_nodes ( f : ' a map_fold_over_node_fun ) ( cond : cnl_cond ) ( acc : ' a ) : cnl_cond * ' a = let node , acc = f . poly_map_fold_fun K_cond cond . cond_node acc in let node , acc = f . cond_map_fold_fun node acc in cond_sh_map_fold ( expr_dp_map_fold_over_... |
let cond_dp_map_over_nodes ( f : map_over_node_fun ) ( cond : cnl_cond ) : cnl_cond = let node , _ = cond_dp_map_fold_over_nodes ( map_fold_over_node_fun_of_map_over_node_fun f ) cond ( ) in node |
let cond_dp_fold_over_nodes ( f : ' a fold_over_node_fun ) ( cond : cnl_cond ) ( acc : ' a ) : ' a = let _ , acc = cond_dp_map_fold_over_nodes ( map_fold_over_node_fun_of_fold_over_node_fun f ) cond acc in acc |
let actn_dp_map_fold_over_nodes ( f : ' a map_fold_over_node_fun ) ( actn : cnl_action ) ( acc : ' a ) : cnl_action * ' a = let node , acc = f . poly_map_fold_fun K_actn actn . actn_node acc in let node , acc = f . actn_map_fold_fun node acc in actn_sh_map_fold ( expr_dp_map_fold_o... |
let actn_dp_map_over_nodes ( f : map_over_node_fun ) ( actn : cnl_action ) : cnl_action = let node , _ = actn_dp_map_fold_over_nodes ( map_fold_over_node_fun_of_map_over_node_fun f ) actn ( ) in node |
let actn_dp_fold_over_nodes ( f : ' a fold_over_node_fun ) ( actn : cnl_action ) ( acc : ' a ) : ' a = let _ , acc = actn_dp_map_fold_over_nodes ( map_fold_over_node_fun_of_fold_over_node_fun f ) actn acc in acc |
let actns_dp_map_fold_over_nodes ( f : ' a map_fold_over_node_fun ) ( actns : cnl_actions ) ( acc : ' a ) : cnl_actions * ' a = let node , acc = f . poly_map_fold_fun K_actns actns . actns_node acc in let node , acc = f . actns_map_fold_fun node acc in actns_sh_map_fold ( actn_dp_m... |
let actns_dp_map_over_nodes ( f : map_over_node_fun ) ( actns : cnl_actions ) : cnl_actions = let node , _ = actns_dp_map_fold_over_nodes ( map_fold_over_node_fun_of_map_over_node_fun f ) actns ( ) in node |
let actns_dp_fold_over_nodes ( f : ' a fold_over_node_fun ) ( actns : cnl_actions ) ( acc : ' a ) : ' a = let _ , acc = actns_dp_map_fold_over_nodes ( map_fold_over_node_fun_of_fold_over_node_fun f ) actns acc in acc |
let rule_dp_map_fold_over_nodes ( f : ' a map_fold_over_node_fun ) ( rule : cnl_rule ) ( acc : ' a ) : cnl_rule * ' a = let node , acc = f . poly_map_fold_fun K_rule rule . rule_node acc in let node , acc = f . rule_map_fold_fun node acc in rule_sh_map_fold ( evnt_dp_map_fold_over_... |
let rule_dp_map_over_nodes ( f : map_over_node_fun ) ( rule : cnl_rule ) : cnl_rule = let node , _ = rule_dp_map_fold_over_nodes ( map_fold_over_node_fun_of_map_over_node_fun f ) rule ( ) in node |
let rule_dp_fold_over_nodes ( f : ' a fold_over_node_fun ) ( rule : cnl_rule ) ( acc : ' a ) : ' a = let _ , acc = rule_dp_map_fold_over_nodes ( map_fold_over_node_fun_of_fold_over_node_fun f ) rule acc in acc |
let cnl_dp_map_fold_over_nodes ( f : ' a map_fold_over_node_fun ) ( cnl : cnl_ast ) ( acc : ' a ) : cnl_ast * ' a = begin match cnl with | Cnl_expr expr -> let expr , acc = expr_dp_map_fold_over_nodes f expr acc in Cnl_expr expr , acc | Cnl_actn actn -> let actn , acc = actn_dp_map_f... |
let mk_expr_with_loc node ofname loc = { expr_node = node ; expr_field = ofname ; expr_loc = loc ; } |
let mk_expr node = mk_expr_with_loc node None ( Parsing . symbol_start_pos ( ) , Parsing . symbol_end_pos ( ) ) |
let mk_expr_undefined ( ) = mk_expr ( N_undefined None ) |
let mk_expr_f desc = mk_expr ( N_filled ( None , desc ) ) |
let mk_expr_in_field node field_info = mk_expr_with_loc node ( Some field_info ) ( Parsing . symbol_start_pos ( ) , Parsing . symbol_end_pos ( ) ) |
let mk_expr_in_field_undefined field_info = mk_expr_in_field ( N_undefined None ) field_info |
let mk_expr_in_field_f desc field_info = mk_expr_in_field ( N_filled ( None , desc ) ) field_info |
let mk_boolean_f b = mk_expr_f ( E_lit ( L_boolean b ) ) |
let mk_int_f i = mk_expr_f ( E_lit ( L_int i ) ) |
let mk_int_as_string_f i = mk_expr_f ( E_lit ( L_int_as_string i ) ) |
let mk_float_f f = mk_expr_f ( E_lit ( L_real f ) ) |
let mk_float_as_string_f i = mk_expr_f ( E_lit ( L_real_as_string i ) ) |
let mk_boolean_as_string_f i = mk_expr_f ( E_lit ( L_boolean_as_string i ) ) |
let mk_string_f s = mk_expr_f ( E_lit ( L_string s ) ) |
let mk_enum_f s = mk_expr_f ( E_lit ( L_enum s ) ) |
let mk_var_f v = mk_expr_f ( E_var v ) |
let mk_get_f e ( fname : field_name ) = mk_expr_f ( E_get ( e , fname ) ) |
let mk_aggregate_f e ( op : Cnl_t . cnl_aggop ) ( fname : field_name ) = mk_expr_f ( E_agg ( op , e , fname ) ) |
let mk_get_var_f ( vname : variable_name ) ( fname : field_name ) = mk_get_f ( mk_var_f vname ) fname |
let mk_concat_f e1 e2 = mk_expr_f ( E_binop ( Op_concat , e1 , e2 ) ) |
let mk_concat_list_f el = begin match el with | [ ] -> mk_string_f " " | [ e1 ] -> e1 | e1 :: el -> List . fold_left mk_concat_f e1 el end |
let mk_lt_f e1 e2 = mk_expr_f ( E_binop ( Op_lt , e1 , e2 ) ) |
let mk_plus_f e1 e2 = mk_expr_f ( E_binop ( Op_plus , e1 , e2 ) ) |
let mk_div_f e1 e2 = mk_expr_f ( E_binop ( Op_div , e1 , e2 ) ) |
let mk_binop_expr_f op e1 e2 = mk_expr_f ( E_binop ( op , e1 , e2 ) ) |
let mk_binop_f op = mk_expr_f ( E_binop ( op , mk_expr_undefined ( ) , mk_expr_undefined ( ) ) ) |
let mk_unop_f op = mk_expr_f ( E_unop ( op , mk_expr_undefined ( ) ) ) |
let mk_this_f ename = mk_expr_f ( E_this ename ) |
let mk_new_event_f ename setters = mk_expr_f ( E_new ( ename , setters ) ) |
let mk_new_event_for_concept_f ename field_names = let setters = List . map ( fun fname -> ( fname , mk_expr_in_field_undefined ( ename , fname ) ) ) field_names in mk_new_event_f ename setters |
let mk_avg_f fname e = mk_expr_f ( E_agg ( A_avg , e , fname ) ) |
let mk_evnt_with_loc node loc = { evnt_node = node ; evnt_loc = loc ; } |
let mk_evnt node = mk_evnt_with_loc node ( Parsing . symbol_start_pos ( ) , Parsing . symbol_end_pos ( ) ) |
let mk_evnt_undefined ( ) = mk_evnt ( N_undefined None ) |
let mk_evnt_f desc = mk_evnt ( N_filled ( None , desc ) ) |
let mk_cond_with_loc node loc = { cond_node = node ; cond_loc = loc ; } |
let mk_cond node = mk_cond_with_loc node ( Parsing . symbol_start_pos ( ) , Parsing . symbol_end_pos ( ) ) |
let mk_cond_undefined ( ) = mk_cond ( N_undefined None ) |
let mk_cond_f desc = mk_cond ( N_filled ( None , desc ) ) |
let mk_actn_with_loc node loc = { actn_node = node ; actn_loc = loc ; } |
let mk_actn node = mk_actn_with_loc node ( Parsing . symbol_start_pos ( ) , Parsing . symbol_end_pos ( ) ) |
let mk_actn_f node = mk_actn ( N_filled ( None , node ) ) |
let mk_actn_undefined ( ) = mk_actn ( N_undefined None ) |
let mk_print_f e = mk_actn_f ( A_print e ) |
let mk_emit_f e = mk_actn_f ( A_emit e ) |
let mk_define_f vname e = mk_actn_f ( A_define ( vname , e ) ) |
let mk_set_desc_f fname vname e = A_set ( fname , vname , e ) |
let mk_set_f fname vname e = mk_actn_f ( mk_set_desc_f fname vname e ) |
let mk_actns_with_loc node loc = { actns_node = node ; actns_loc = loc ; } |
let mk_actns node = mk_actns_with_loc node ( Parsing . symbol_start_pos ( ) , Parsing . symbol_end_pos ( ) ) |
let mk_actns_undefined ( ) = mk_actns ( N_undefined None ) |
let mk_actns_f desc = mk_actns ( N_filled ( None , desc ) ) |
let mk_actns_desc_undefined ( ) : cnl_actns_desc = { list_elems = [ mk_actn_undefined ( ) ] ; list_closed = N_undefined None ; } |
let mk_rule_desc evnt cond actns = { rule_evnt = evnt ; rule_cond = cond ; rule_actns = actns ; } |
let mk_rule_f evnt cond actns = { rule_node = N_filled ( None , mk_rule_desc evnt cond actns ) ; rule_loc = ( Parsing . symbol_start_pos ( ) , Parsing . symbol_end_pos ( ) ) ; } |
let mk_rule_init evnt_desc cond_desc actns_desc = mk_rule_f ( mk_evnt_f evnt_desc ) ( mk_cond_f cond_desc ) ( mk_actns_f actns_desc ) |
let mk_rule_undefined ( ) = { rule_node = N_undefined None ; rule_loc = ( Parsing . symbol_start_pos ( ) , Parsing . symbol_end_pos ( ) ) ; } |
let cnl_instr_to_string instr = begin match instr with | I_repl_expr ( id , e ) -> " [ REPL EXPR ] " | I_repl_actn ( id , a ) -> " [ REPL ACTN ] " | I_repl_evnt ( id , w ) -> " [ REPL EVNT ] " | I_repl_cond ( id , i ) -> " [ REPL COND ] " | I_repl_actns ... |
let notyet instr = raise ( Failure ( " Instruction : " ^ ( cnl_instr_to_string instr ) ^ " not supported " ) ) |
let replace_desc ( id : int ) ( new_x : ' a ) ( node : ' a node ) : ' a node = begin match node with | N_undefined ( Some id ' ) | N_filled ( Some id ' , _ ) | N_rejected ( Some id ' , _ ) -> if id = id ' then N_filled ( Some id , new_x ) else node | N_undefi... |
let repl_expr ( id : int ) new_x r = Cnl2cnl . rule_dp_map_over_nodes { Cnl2cnl . id_map_over_node_fun with Cnl2cnl . expr_map_fun = ( replace_desc id new_x ) } r |
let repl_actn ( id : int ) new_x r = Cnl2cnl . rule_dp_map_over_nodes { Cnl2cnl . id_map_over_node_fun with Cnl2cnl . actn_map_fun = ( replace_desc id new_x ) } r |
let repl_evnt ( id : int ) new_x r = Cnl2cnl . rule_dp_map_over_nodes { Cnl2cnl . id_map_over_node_fun with Cnl2cnl . evnt_map_fun = ( replace_desc id new_x ) } r |
let repl_cond ( id : int ) new_x r = Cnl2cnl . rule_dp_map_over_nodes { Cnl2cnl . id_map_over_node_fun with Cnl2cnl . cond_map_fun = ( replace_desc id new_x ) } r |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.