text stringlengths 12 786k |
|---|
let map_lets t ~ for_defining_expr ~ for_last_body ~ after_rebuild = let rec loop ( t : t ) ~ rev_lets = match t with | Let { var ; defining_expr ; body ; _ } -> let new_defining_expr = for_defining_expr var defining_expr in let original = if new_defining_expr == defining_expr then Some t els... |
type maybe_named = | Is_expr of t | Is_named of named |
let iter_general ~ toplevel f f_named maybe_named = let rec aux ( t : t ) = match t with | Let _ -> iter_lets t ~ for_defining_expr ( : fun _var named -> aux_named named ) ~ for_last_body : aux ~ for_each_let : f | _ -> f t ; match t with | Var _ | Apply _ | Assign _ | Send _ | Prov... |
module With_free_variables = struct type ' a t = | Expr : expr * Variable . Set . t -> expr t | Named : named * Variable . Set . t -> named t let of_defining_expr_of_let let_expr = Named ( let_expr . defining_expr , let_expr . free_vars_of_defining_expr ) let of_body_of_let let_expr = Ex... |
let fold_lets_option t ~ init ( ~ for_defining_expr ( ' : a -> Variable . t -> named -> ' a * Variable . t * named ) ) ~ for_last_body ( ~ filter_defining_expr ( ' : b -> Variable . t -> named -> Variable . Set . t -> ' b * Variable . t * named option ) ) = let fini... |
let free_symbols_helper symbols ( named : named ) = match named with | Symbol symbol | Read_symbol_field ( symbol , _ ) -> symbols := Symbol . Set . add symbol ! symbols | Set_of_closures set_of_closures -> Variable . Map . iter ( fun _ ( function_decl : function_declaration ) -> sy... |
let free_symbols expr = let symbols = ref Symbol . Set . empty in iter_general ~ toplevel : true ( fun ( _ : t ) -> ( ) ) ( fun ( named : named ) -> free_symbols_helper symbols named ) ( Is_expr expr ) ; ! symbols |
let free_symbols_named named = let symbols = ref Symbol . Set . empty in iter_general ~ toplevel : true ( fun ( _ : t ) -> ( ) ) ( fun ( named : named ) -> free_symbols_helper symbols named ) ( Is_named named ) ; ! symbols |
let free_symbols_allocated_constant_helper symbols ( const : constant_defining_value ) = match const with | Allocated_const _ -> ( ) | Block ( _ , fields ) -> List . iter ( function | ( Symbol s : constant_defining_value_block_field ) -> symbols := Symbol . Set . add s ! symbols ... |
let free_symbols_program ( program : program ) = let symbols = ref Symbol . Set . empty in let rec loop ( program : program_body ) = match program with | Let_symbol ( _ , const , program ) -> free_symbols_allocated_constant_helper symbols const ; loop program | Let_rec_symbol ( defs , ... |
let update_body_of_function_declaration ( func_decl : function_declaration ) ~ body : function_declaration = { closure_origin = func_decl . closure_origin ; params = func_decl . params ; alloc_mode = func_decl . alloc_mode ; region = func_decl . region ; body ; free_variables = free_var... |
let rec check_param_modes mode = function | [ ] -> ( ) | p :: params -> let m = Parameter . alloc_mode p in if not ( Lambda . sub_mode mode m ) then Misc . fatal_errorf " Nonmonotonic partial modes " ; check_param_modes m params |
let create_function_declaration ~ params ~ alloc_mode ~ region ~ body ~ stub ~ dbg ( ~ inline : Lambda . inline_attribute ) ( ~ specialise : Lambda . specialise_attribute ) ~ is_a_functor ~ closure_origin : function_declaration = begin match stub , inline with | true , ( Never_inline |... |
let update_function_declaration_body fun_decl ~ body = let free_variables = free_variables body in let free_symbols = free_symbols body in { fun_decl with body ; free_variables ; free_symbols } |
let create_function_declarations ~ is_classic_mode ~ funs = let compilation_unit = Compilation_unit . get_current_exn ( ) in let set_of_closures_id = Set_of_closures_id . create compilation_unit in let set_of_closures_origin = Set_of_closures_origin . create set_of_closures_id in { is_classic_mode ; ... |
let create_function_declarations_with_origin ~ is_classic_mode ~ funs ~ set_of_closures_origin = let compilation_unit = Compilation_unit . get_current_exn ( ) in let set_of_closures_id = Set_of_closures_id . create compilation_unit in { is_classic_mode ; set_of_closures_id ; set_of_closures_origin ;... |
let update_function_declarations function_decls ~ funs = let is_classic_mode = function_decls . is_classic_mode in let compilation_unit = Compilation_unit . get_current_exn ( ) in let set_of_closures_id = Set_of_closures_id . create compilation_unit in let set_of_closures_origin = function_decls . set... |
let create_function_declarations_with_closures_origin ~ is_classic_mode ~ funs ~ set_of_closures_origin = let compilation_unit = Compilation_unit . get_current_exn ( ) in let set_of_closures_id = Set_of_closures_id . create compilation_unit in { is_classic_mode ; set_of_closures_id ; set_of_closures... |
let import_function_declarations_for_pack function_decls import_set_of_closures_id import_set_of_closures_origin = let is_classic_mode = function_decls . is_classic_mode in let set_of_closures_id = import_set_of_closures_id function_decls . set_of_closures_id in let set_of_closures_origin = import_set_of_closur... |
let create_set_of_closures ~ function_decls ~ free_vars ~ specialised_args ~ direct_call_surrogates = if ! Clflags . flambda_invariant_checks then begin let all_fun_vars = Variable . Map . keys function_decls . funs in let expected_free_vars = Variable . Map . fold ( fun _fun_var function_decl ex... |
let used_params function_decl = Variable . Set . filter ( fun param -> Variable . Set . mem param function_decl . free_variables ) ( Parameter . Set . vars function_decl . params ) |
let compare_const ( c1 : const ) ( c2 : const ) = match c1 , c2 with | Int i1 , Int i2 -> compare i1 i2 | Char i1 , Char i2 -> Char . compare i1 i2 | Int _ , Char _ -> - 1 | Char _ , Int _ -> 1 |
let compare_constant_defining_value_block_field ( c1 : constant_defining_value_block_field ) ( c2 : constant_defining_value_block_field ) = match c1 , c2 with | Symbol s1 , Symbol s2 -> Symbol . compare s1 s2 | Const c1 , Const c2 -> compare_const c1 c2 | Symbol _ , Const _ -> - 1 | Cons... |
module Constant_defining_value = struct type t = constant_defining_value include Identifiable . Make ( struct type nonrec t = t let compare ( t1 : t ) ( t2 : t ) = match t1 , t2 with | Allocated_const c1 , Allocated_const c2 -> Allocated_const . compare c1 c2 | Block ( tag1 , fields1 ) ... |
let equal_call_kind ( call_kind1 : call_kind ) ( call_kind2 : call_kind ) = match call_kind1 , call_kind2 with | Indirect , Indirect -> true | Direct cid1 , Direct cid2 -> Closure_id . equal cid1 cid2 | ( Indirect | Direct _ ) , _ -> false |
let equal_specialised_to ( spec_to1 : specialised_to ) ( spec_to2 : specialised_to ) = Variable . equal spec_to1 . var spec_to2 . var && begin match spec_to1 . projection , spec_to2 . projection with | None , None -> true | Some _ , None | None , Some _ -> false | Some proj1 , So... |
module Compilation_unit = struct include Flambda2_identifiers . Compilation_unit let of_flambda1_compilation_unit comp_unit = let ident = Flambda1_compilation_unit . get_persistent_ident comp_unit in let linkage_name = comp_unit |> Flambda1_compilation_unit . get_linkage_name |> Flambda1_linkage_name . to... |
let symbol_for_module_block id = assert ( Ident . global id ) ; assert ( not ( Ident . is_predef id ) ) ; let comp_unit = Compilenv . unit_for_global id |> Compilation_unit . of_flambda1_compilation_unit in Symbol . unsafe_create comp_unit ( Linkage_name . create ( Compilenv . symbo... |
let symbol_for_global ? comp_unit id = if Ident . global id && not ( Ident . is_predef id ) then symbol_for_module_block id else let comp_unit = match comp_unit with | Some comp_unit -> comp_unit | None -> if Ident . is_predef id then Compilation_unit . predefined_exception ( ) else Compilation_... |
let get_global_info comp_unit = if Compilation_unit . is_predefined_exception comp_unit then Misc . fatal_error " get_global_info is not for use with predefined exception compilation \ units " ; if Compilation_unit . is_external_symbols comp_unit then None else let id = Compilation_unit . get_persisten... |
let print_rawflambda ppf unit = if Flambda_features . dump_rawflambda ( ) then Format . fprintf ppf " \ n % sAfter CPS conversion :% s @ % a . " @ ( Flambda_colours . each_file ( ) ) ( Flambda_colours . normal ( ) ) Flambda_unit . print unit ; if Flambda_features . dump_ra... |
let print_flambda name ppf unit = if Flambda_features . dump_flambda ( ) then Format . fprintf ppf " \ n % sAfter % s :% s @ % a . " @ ( Flambda_colours . each_file ( ) ) name ( Flambda_colours . normal ( ) ) Flambda_unit . print unit ; if Flambda_features . dump_fexpr ( ... |
let output_flexpect ~ ml_filename ~ raw_flambda : old_unit new_unit = if Flambda_features . dump_flexpect ( ) then let basename = Filename . chop_suffix ml_filename " . ml " in let filename = basename ^ " . flt " in let before = old_unit |> Flambda_to_fexpr . conv in let after = new_unit... |
let lambda_to_cmm ~ ppf_dump : ppf ~ prefixname ~ filename ~ module_ident ~ module_block_size_in_words ~ module_initializer ~ keep_symbol_tables = if Flambda_features . classic_mode ( ) then Clflags . use_linscan := true ; Misc . Color . setup ( Flambda_features . colour ( ) ) ; if C... |
module Typing_env = struct include Typing_env let add_equation t name ty = add_equation t name ty ~ meet_type : Meet_and_join . meet let add_equations_on_params t ~ params ~ param_types = add_equations_on_params t ~ params ~ param_types ~ meet_type : Meet_and_join . meet let add_env_extension t extension... |
module Typing_env_extension = struct include Typing_env_extension let meet env t1 t2 = Meet_and_join . meet_env_extension ( Typing_env . Meet_env . create env ) t1 t2 end |
let meet env t1 t2 : _ Or_bottom . t = let meet_env = Typing_env . Meet_env . create env in meet meet_env t1 t2 |
let join ? bound_name central_env ~ left_env ~ left_ty ~ right_env ~ right_ty = let join_env = Typing_env . Join_env . create central_env ~ left_env ~ right_env in match join ? bound_name join_env left_ty right_ty with | Unknown -> unknown_like left_ty | Known ty -> ty |
let extract_symbol_approx env symbol find_code = let rec type_to_approx ( ty : t ) : _ Value_approximation . t = let expand ty : _ Value_approximation . t = let expanded = Expand_head . expand_head env ty in match Expand_head . Expanded_type . descr expanded with | Unknown | Bottom -> Value_un... |
type t = Flambda_kind . t list |
let create t = t |
let length t = List . length t |
let to_list t = t type nonrec t = t let compare t1 t2 = List . compare Flambda_kind . compare t1 t2 let equal t1 t2 = compare t1 t2 = 0 let hash = Hashtbl . hash let print ppf t = match t with | [ ] -> Format . pp_print_string ppf " Nullary " | _ -> Format . fprintf ppf " [ @% a ] ... |
let is_all_values t = List . for_all Flambda_kind . is_value t |
let is_all_naked_floats t = List . for_all Flambda_kind . is_naked_float t |
let is_singleton_value t = match t with | [ kind ] when Flambda_kind . equal kind Flambda_kind . value -> true | _ -> false |
module With_subkinds = struct type t = Flambda_kind . With_subkind . t list let create t = t let to_list t = t include Container_types . Make ( struct type nonrec t = t let compare t1 t2 = List . compare Flambda_kind . With_subkind . compare t1 t2 let equal t1 t2 = compare t1 t2 = 0 let hash = H... |
let format_default flag = if flag then " ( default ) " else " " |
let format_not_default flag = if flag then " " else " ( default ) " |
let mk_ocamlcfg f = " - ocamlcfg " , Arg . Unit f , " Use ocamlcfg " |
let mk_no_ocamlcfg f = " - no - ocamlcfg " , Arg . Unit f , " Do not use ocamlcfg " ; ; |
let mk_dcfg f = " - dcfg " , Arg . Unit f , " ( undocumented ) " ; ; |
let mk_dcfg_invariants f = " - dcfg - invariants " , Arg . Unit f , " Extra sanity checks on Cfg " |
let mk_dcfg_equivalence_check f = " - dcfg - equivalence - check " , Arg . Unit f , " Extra sanity checks on Cfg transformations " |
let mk_reorder_blocks_random f = " - reorder - blocks - random " , Arg . Int f , Printf . sprintf " < seed > Randomly reorder basic blocks in every function , \ using the provided seed ( intended for testing , off by default ) . " |
let mk_heap_reduction_threshold f = " - heap - reduction - threshold " , Arg . Int f , Printf . sprintf " Threshold ( in major words , defaulting to % d ) to trigger a heap reduction before code emission " Flambda_backend_flags . default_heap_reduction_threshold ; ; |
let mk_dump_inlining_paths f = " - dump - inlining - paths " , Arg . Unit f , " Dump inlining paths when dumping flambda2 terms " |
let mk_flambda2_result_types_functors_only f = " - flambda2 - result - types - functors - only " , Arg . Unit f , Printf . sprintf " Infer result types for functors ( but no other \ n \ \ functions ) % s ( Flambda 2 only ) " ( format_default ( match Flambda2 . Default . functi... |
let mk_flambda2_result_types_all_functions f = " - flambda2 - result - types - all - functions " , Arg . Unit f , Printf . sprintf " Infer result types for all functions \ n \ \ ( including functors ) % s ( Flambda 2 only ) " ( format_default ( match Flambda2 . Default . funct... |
let mk_no_flambda2_result_types f = " - flambda2 - result - types " , Arg . Unit f , Printf . sprintf " Do not infer result types for functions ( or \ n \ \ functors ) % s ( Flambda 2 only ) " ( format_default ( match Flambda2 . Default . function_result_types with | Never -> ... |
let mk_flambda2_join_points f = " - flambda2 - join - points " , Arg . Unit f , Printf . sprintf " Propagate information from all incoming edges to a join \ n \ \ point % s ( Flambda 2 only ) " ( format_default Flambda2 . Default . join_points ) ; ; |
let mk_no_flambda2_join_points f = " - no - flambda2 - join - points " , Arg . Unit f , Printf . sprintf " Propagate information to a join point only if there are \ n \ \ zero or one incoming edge ( s ) % s ( Flambda 2 only ) " ( format_not_default Flambda2 . Default . join_point... |
let mk_flambda2_unbox_along_intra_function_control_flow f = " - flambda2 - unbox - along - intra - function - control - flow " , Arg . Unit f , Printf . sprintf " Pass values within \ n \ \ a function as unboxed where possible % s ( Flambda 2 only ) " ( format_default Flambda2 . Def... |
let mk_no_flambda2_unbox_along_intra_function_control_flow f = " - no - flambda2 - unbox - along - intra - function - control - flow " , Arg . Unit f , Printf . sprintf " Pass values within \ n \ \ a function in their normal representation % s ( Flambda 2 only ) " ( format_not_defaul... |
let mk_flambda2_backend_cse_at_toplevel f = " - flambda2 - backend - cse - at - toplevel " , Arg . Unit f , Printf . sprintf " Apply the backend CSE pass to module \ n \ \ initializers % s ( Flambda 2 only ) " ( format_default Flambda2 . Default . backend_cse_at_toplevel ) ; ; |
let mk_no_flambda2_backend_cse_at_toplevel f = " - no - flambda2 - backend - cse - at - toplevel " , Arg . Unit f , Printf . sprintf " Do not apply the backend CSE pass to \ n \ \ module initializers % s ( Flambda 2 only ) " ( format_not_default Flambda2 . Default . backend_cse_at_... |
let mk_flambda2_cse_depth f = " - flambda2 - cse - depth " , Arg . Int f , Printf . sprintf " Depth threshold for eager tracking of CSE equations \ n \ \ ( default % d ) ( Flambda 2 only ) " Flambda2 . Default . cse_depth ; ; |
let mk_flambda2_join_depth f = " - flambda2 - join - depth " , Arg . Int f , Printf . sprintf " Depth threshold for alias expansion in join \ n \ \ ( default % d ) ( Flambda 2 only ) " Flambda2 . Default . join_depth ; ; |
let mk_flambda2_expert_fallback_inlining_heuristic f = " - flambda2 - expert - fallback - inlining - heuristic " , Arg . Unit f , Printf . sprintf " Prevent inlining of functions \ n \ \ whose bodies contain closures % s ( Flambda 2 only ) " ( format_default Flambda2 . Expert . Defa... |
let mk_no_flambda2_expert_fallback_inlining_heuristic f = " - no - flambda2 - expert - fallback - inlining - heuristic " , Arg . Unit f , Printf . sprintf " Allow inlining of functions \ n \ \ whose bodies contain closures % s ( Flambda 2 only ) " ( format_not_default Flambda2 . Expe... |
let mk_flambda2_expert_inline_effects_in_cmm f = " - flambda2 - expert - inline - effects - in - cmm " , Arg . Unit f , Printf . sprintf " Allow inlining of effectful \ n \ \ expressions in the produced Cmm code % s ( Flambda 2 only ) " ( format_default Flambda2 . Expert . Default ... |
let mk_no_flambda2_expert_inline_effects_in_cmm f = " - no - flambda2 - expert - inline - effects - in - cmm " , Arg . Unit f , Printf . sprintf " Prevent inlining of effectful \ n \ \ expressions in the produced Cmm code % s ( Flambda 2 only ) " ( format_not_default Flambda2 . Expe... |
let mk_flambda2_expert_phantom_lets f = " - flambda2 - expert - phantom - lets " , Arg . Unit f , Printf . sprintf " Generate phantom lets when - g \ n \ \ is specified % s ( Flambda 2 only ) " ( format_default Flambda2 . Expert . Default . phantom_lets ) ; ; |
let mk_no_flambda2_expert_phantom_lets f = " - no - flambda2 - expert - phantom - lets " , Arg . Unit f , Printf . sprintf " Do not generate phantom lets even when - g \ n \ \ is specified % s ( Flambda 2 only ) " ( format_not_default Flambda2 . Expert . Default . phantom_lets ) ... |
let mk_flambda2_expert_max_block_size_for_projections f = " - flambda2 - expert - max - block - size - for - projections " , Arg . Int f , Printf . sprintf " Do not simplify projections \ n \ \ from blocks if the block size exceeds this value ( default % s ) \ n \ \ ( Flambda 2 only ... |
let mk_flambda2_expert_max_unboxing_depth f = " - flambda2 - expert - max - unboxing - depth " , Arg . Int f , Printf . sprintf " Do not unbox ( nested ) values deeper \ n \ \ than this many levels ( default % d ) ( Flambda 2 only ) " Flambda2 . Expert . Default . max_unboxi... |
let mk_flambda2_expert_can_inline_recursive_functions f = " - flambda2 - expert - can - inline - recursive - functions " , Arg . Unit f , Printf . sprintf " Consider inlining \ n \ \ recursive functions ( default % s ) ( Flambda 2 only ) " ( format_default Flambda2 . Expert . D... |
let mk_no_flambda2_expert_can_inline_recursive_functions f = " - no - flambda2 - expert - can - inline - recursive - functions " , Arg . Unit f , Printf . sprintf " Only inline recursive \ n \ \ functions if forced to so do by an attribute \ n \ \ ( default % s ) ( Flambda 2 only ) ... |
let mk_flambda2_debug_concrete_types_only_on_canonicals f = " - flambda2 - debug - concrete - types - only - on - canonicals " , Arg . Unit f , Printf . sprintf " Check that concrete \ n \ \ types are only assigned to canonical \ n \ \ names % s ( Flambda 2 only ) " ( format_defaul... |
let mk_no_flambda2_debug_concrete_types_only_on_canonicals f = " - no - flambda2 - debug - concrete - types - only - on - canonicals " , Arg . Unit f , Printf . sprintf " Do not check that \ n \ \ concrete types are only assigned to canonical \ n \ \ names % s ( Flambda 2 only ) " (... |
let mk_flambda2_debug_keep_invalid_handlers f = " - flambda2 - debug - keep - invalid - handlers " , Arg . Unit f , Printf . sprintf " Keep branches simplified \ n \ \ to Invalid % s ( Flambda 2 only ) " ( format_default Flambda2 . Debug . Default . keep_invalid_handlers ) ; ;... |
let mk_no_flambda2_debug_keep_invalid_handlers f = " - no - flambda2 - debug - keep - invalid - handlers " , Arg . Unit f , Printf . sprintf " Delete branches simplified \ n \ \ to Invalid % s ( Flambda 2 only ) " ( format_not_default Flambda2 . Debug . Default . keep_invalid_han... |
let mk_flambda2_inline_max_depth f = " - flambda2 - inline - max - depth " , Arg . String f , Printf . sprintf " < int >|< round >=< int [ , . . . ] >\ n \ \ Maximum depth of search for inlining opportunities inside \ n \ \ inlined functions ( default % d ) ( Flambda 2 on... |
let mk_flambda2_inline_max_rec_depth f = " - flambda2 - inline - max - rec - depth " , Arg . String f , Printf . sprintf " < int >|< round >=< int [ , . . . ] >\ n \ \ Maximum depth of search for inlining opportunities inside \ n \ \ inlined recursive functions ( default % d ... |
let mk_flambda2_inline_cost arg descr ~ default f = Printf . sprintf " - flambda2 - inline -% s - cost " arg , Arg . String f , Printf . sprintf " < float >|< round >=< float [ , . . . ] >\ n \ \ The cost of not removing % s during inlining \ n \ \ ( default . % 03f , ... |
let mk_flambda2_inline_call_cost = mk_flambda2_inline_cost " call " " a call " ~ default : Flambda_backend_flags . Flambda2 . Inlining . Default . call_cost |
let mk_flambda2_inline_alloc_cost = mk_flambda2_inline_cost " alloc " " an allocation " ~ default : Flambda_backend_flags . Flambda2 . Inlining . Default . alloc_cost |
let mk_flambda2_inline_prim_cost = mk_flambda2_inline_cost " prim " " a primitive " ~ default : Flambda_backend_flags . Flambda2 . Inlining . Default . prim_cost |
let mk_flambda2_inline_branch_cost = mk_flambda2_inline_cost " branch " " a conditional " ~ default : Flambda_backend_flags . Flambda2 . Inlining . Default . branch_cost |
let mk_flambda2_inline_indirect_call_cost = mk_flambda2_inline_cost " indirect " " an indirect call " ~ default : Flambda_backend_flags . Flambda2 . Inlining . Default . indirect_call_cost |
let mk_flambda2_inline_poly_compare_cost = mk_flambda2_inline_cost " poly - compare " " a polymorphic comparison " ~ default : Flambda_backend_flags . Flambda2 . Inlining . Default . poly_compare_cost |
let mk_flambda2_inline_small_function_size f = " - flambda2 - inline - small - function - size " , Arg . String f , Printf . sprintf " < int >|< round >=< int [ , . . . ] >\ n \ \ Functions with a cost less than this will always be inlined \ n \ \ unless an attribute instructs o... |
let mk_flambda2_inline_large_function_size f = " - flambda2 - inline - large - function - size " , Arg . String f , Printf . sprintf " < int >|< round >=< int [ , . . . ] >\ n \ \ Functions with a cost greater than this will never be inlined \ n \ \ unless an attribute instructs... |
let mk_flambda2_inline_threshold f = " - flambda2 - inline - threshold " , Arg . String f , Printf . sprintf " < float >|< round >=< float [ , . . . ] >\ n \ \ Aggressiveness of inlining ( default . % 02f , higher numbers mean \ n \ \ more aggressive ) ( Flambda 2 onl... |
let mk_flambda2_speculative_inlining_only_if_arguments_useful f = " - flambda2 - speculative - inlining - only - if - arguments - useful " , Arg . Unit f , Printf . sprintf " Only \ n \ \ perform speculative inlining if the Flambda type system has \ n \ \ useful information about the argumen... |
let mk_no_flambda2_speculative_inlining_only_if_arguments_useful f = " - no - flambda2 - speculative - inlining - only - if - arguments - useful " , Arg . Unit f , Printf . sprintf " Ignore \ n \ \ whether the Flambda type system has useful information \ n \ \ about the argument ( s ) a... |
let mk_flambda2_inlining_report_bin f = " - flambda2 - inlining - report - bin " , Arg . Unit f , " Write inlining report \ n \ \ in binary format ( Flambda 2 only ) " ; ; |
let mk_flambda2_unicode f = " - flambda2 - unicode " , Arg . Unit f , " Use Unicode output when printing \ n \ \ Flambda 2 code " ; ; |
let mk_drawfexpr f = " - drawfexpr " , Arg . Unit f , " Like - drawflambda but outputs fexpr language \ n \ \ ( Flambda 2 only ) " ; ; |
let mk_dfexpr f = " - dfexpr " , Arg . Unit f , " Like - dflambda but outputs fexpr language \ n \ \ ( Flambda 2 only ) " ; ; |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.