Use Rust to improve performance of string methods, use HTML templating

Author: philippeitis

prolog/Makefile

@@ -1,7 +1,9 @@
 FASTFUNC_SERVER_PORT = 4999
 .PHONY: build
 build:
-	swipl main.pl --quit setup
+	mkdir -p bin
+	cd util-rs && cargo +nightly build --release && cp ./target/release/libutils_rs.so ../bin/libutils_rs.so
+#	swipl main.pl --quit setup
 .PHONY: test
 test:
 	make build

prolog/constraints.pl

@@ -37,15 +37,15 @@
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %% Meta Constraints: These apply operations to other constraints
 
-%% and_constraint(+Lhs, +Rhs, -Func, -CostOut, -NewConstraints)
+%! and_constraint(+Lhs, +Rhs, -Func, -CostOut, -NewConstraints)
 % Tests if Func satisfies all constraints, producing a cost for this function,
 % CostOut, and a set of constraints which follow Constraints, NewConstraints.
 and_constraint(Lhs, Rhs, Fn, Cost, and_constraint(NewConstraint0, NewConstraint1)) :-
     call(Lhs, Fn, Cost0, NewConstraint0),
     call(Rhs, Fn, Cost1, NewConstraint1),
     Cost is Cost0 + Cost1.
 
-%% at_most_n_constraint(+N, +Constraint, -Func, -Cost, -NewConstraint)
+%! at_most_n_constraint(+N, +Constraint, -Func, -Cost, -NewConstraint)
 % Evaluates at most N+1 times (if base case is reached, )
 at_most_n_constraint(N, Constraint, Func, Cost, at_most_n_constraint(NSub, Constraint)) :-
     call(Constraint, Func, Cost, _), !,

prolog/function.pl

@@ -94,7 +94,7 @@
 init_uuid(Uuid) :- \+var(Uuid), !.
 
 init_uuid(Uuid) :-
-    var(Uuid), uuid(Uuid), !.
+    var(Uuid), uuid(Uuids), atom_concat('u', Uuids, Uuid), !.
 
 add_function(Uuid, Name, Generics, InputTypes, OutputTypes, Docs) :-
     init_uuid(Uuid),

prolog/function/parse.pl

@@ -4,11 +4,12 @@
     parse_types/4,
     parse_trait/2,
     parse_type/2,
-    format_func/2,
-    format_skeleton/6
+    format_skeleton/6,
+    format_signature/2
 ]).
 :- use_module(function).
 :- use_module(library(dcg/basics)).
+:- use_module(sequence_ops).
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 subst_generics_into(
@@ -149,13 +150,51 @@
     subst_generics(Generics, UInputs, Inputs),
     subst_generics(Generics, UOutputs, Outputs), !.
 
-%% Formats the function with the given name
-format_func(String, Uuid) :-
-    function(Uuid, Name, Generics, Inputs, Outputs, Docs),
-    format_skeleton(String, Name, Generics, Inputs, Outputs, Docs).
-
 %% Formats the function skeleton.
 format_skeleton(String, Name, [], Inputs, Outputs, Docs) :-
     format(string(String), '~w :: ~w -> ~w | ~w', [Name, Inputs, Outputs, Docs]).
 format_skeleton(String, Name, Generics, Inputs, Outputs, Docs) :-
     format(string(String), '~w<~w> :: ~w -> ~w | ~w', [Name, Generics, Inputs, Outputs, Docs]).
+
+format_generic(generic(Name, Bounds), String) :-
+    \+is_list(Bounds),
+    format(string(String), "~w", Name), !.
+
+format_generic(generic(Name, Bounds), String) :-
+    is_list(Bounds),
+    join(Bounds, " + ", SubStr),
+    format(string(String), "~w: ~w", [Name, SubStr]), !.
+
+format_generic(G, String) :-
+    format(string(String), "~w", [G]), !.
+
+format_generics([], "") :- !.
+format_generics(Generics, String) :-
+    maplist(format_generic, Generics, GenericSubs),
+    join(GenericSubs, ", ", GenericContents),
+    format(string(String), "<~w>", GenericContents).
+
+format_type(type(Name, SubTypes), String) :-
+    is_list(SubTypes),
+    SubTypes = [_|_],
+    maplist(format_type, SubTypes, SubTys),
+    join(SubTys, ", ", Tys),
+    format(string(String), "~w<~w>", [Name, Tys]), !.
+
+format_type(type(Name, _), String) :-
+    format(string(String), "~w", [Name]).
+
+format_type(gen(Ty), String) :-
+    format(string(String), "~w", Ty).
+
+
+format_type(Ty, String) :-
+    format(string(String), "~w", Ty).
+
+format_signature(function(_, _, Generics, Inputs, Outputs, _), String) :-
+    format_generics(Generics, GenString),
+    maplist(format_type, Inputs, Inputsf),
+    join(Inputsf, ", ", Inputsff),
+    maplist(format_type, Outputs, Outputsf),
+    join(Outputsf, ", ", Outputsff),
+    format(string(String), '~w :: [~w] -> [~w]', [GenString, Inputsff, Outputsff]).

prolog/function/serde.pl

@@ -2,6 +2,7 @@
     write_json_metadata/4,
     read_json_metadata/4,
     jsonify_fns/2,
+    jsonify_fn/2,
     jsonify_type/2,
     jsonify_types/2
 ]).

prolog/main.pl

@@ -198,6 +198,9 @@
 :- if(prolog_version_eight).
 execute_command(String) :-
     split_left(String, " ", 1, ["launch", PortStr]),
+    split_left(String, " ", 1, Splits),
+    format("~w~n", [String]),
+    format("!!~w~n", [Splits]),
     number_string(Port, PortStr),
     catch(
         server(Port),

prolog/search.pl

@@ -4,8 +4,7 @@
     func_path_no_cycles/4,
     find_item/3,
     find_items/2,
-    func_search/7,
-    fn_member_constraint/1
+    func_search/7
 ]).
 :- use_module(function).
 :- use_module(constraints, [
@@ -107,16 +106,6 @@
     append(Candidates, NewPaths, NewCand),
     func_path_bfs(NewCand, PathConstraint, NextPath).
 
-%% cmp_constraint_list(?Order, @L1, @L2)
-% Determine Cmp between L1 and L2 cost/constraint/list triples.
-cmp_candidate(Cmp, (CostA, _, _), (CostB, _, _)) :-
-    compare(Cmp, CostA, CostB).
-
-cmp_or_continue(=, Cmp, L1, L2) :- 
-    compare(Cmp, L1, L2).
-cmp_or_continue(>, >, _, _).
-cmp_or_continue(<, <, _, _).
-
 func_path_best_fs([(_, FnConstraint, Visited)|_], PathConstraint, Path) :-
     % If no constraints left, add path to paths
     test_path(Visited, FnConstraint, PathConstraint, Path).

prolog/sequence_ops.pl

@@ -13,16 +13,18 @@
 :- table(fuzzy_substr/3).
 :- endif.
 
+:- use_foreign_library('./bin/libutils_rs.so').
+
 :- meta_predicate run_levenshtein(+, +, 2, -).
 
-%% list_subset(?List1, ?List2)
+%! list_subset(?List1, ?List2)
 % Returns true if List1 is a subset of List2.
 list_subset([], _).
 list_subset([First|Rest], B) :-
     member(First, B),
     list_subset(Rest, B), !.
 
-%% join(+Items, +Sep, -Output)
+%! join(+Items, +Sep, -Output)
 % Joins the string with the provided separator string
 join([], _Sep, "") :- !.
 join([Item], _Sep, Item) :- !.
@@ -31,7 +33,7 @@
     string_concat(Head, Sep, HeadSep),
     string_concat(HeadSep, TailOutput, Output), !.
 
-%% sequence_match/2(+Sequence, +String)
+%! sequence_match/2(+Sequence, +String)
 % sequence_match is true if the all elements in Sequence appear in
 % String, in sequential order.
 sequence_match(Sequence, String) :-
@@ -48,114 +50,19 @@
 sequence_match(Sequence, [_|Tail1]) :-
     sequence_match(Sequence, Tail1).
 
-%% split_left/4(String, Sep, N, -Substrings)
-% split_left splits the provided string on the characters in Sep,
-% up to a maximum of N times into Substrings. Multiple seperator characters
-% will be treated as one.
-split_left(String, Sep, N, Substrings) :-
-    string_chars(String, Chars),
-    string_chars(Sep, Sep_),
-    split_left(Chars, Sep_, N, [], CharSubstrings),
-    maplist(
-        string_chars,
-        Substrings,
-        CharSubstrings
-    ), !.
-
-%% Splits the string from left to right, on the provided separator,
-% up to a maximum of n times, and stores intermediate state in Accumulator
-split_left([], _Sep, _, Accumulator, [Reversed]) :-
-    reverse(Accumulator, Reversed), !.
-split_left([Head|Tail], Sep, 0, Accumulator, [Whole]) :-
-    member(Head, Sep),
-    split_left(Tail, Sep, 0, Accumulator, [Whole]), !.
-split_left(String, _Sep, 0, Accumulator, [Whole]) :-
-    reverse(Accumulator, Reversed),
-    append(Reversed, String, Whole), !.
-split_left([Head|Tail], Sep, N, [], Strings) :-
-    member(Head, Sep),
-    split_left(Tail, Sep, N, [], Strings), !.
-split_left([Head|Tail], Sep, N, Accumulator, [Reversed|Strings]) :-
-    member(Head, Sep),
-    reverse(Accumulator, Reversed),
-    % Force early evaluation
-    NSub is N - 1,
-    split_left(Tail, Sep, NSub, [], Strings), !.
-split_left([Head|Tail], Sep, N, Accumulator, Strings) :-
-    split_left(Tail, Sep, N, [Head|Accumulator], Strings), !.
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%% Development notes:
-% Haskell impl is ~3x faster (with the backtracking functionality)
-% BUT: 
-% - +1.2GB of disk usage in Docker
-% - Requires reading/writing to streams (annoying)
-% - Requires compilation and extra steps in Makefiles
-
-%% Basic implementation of substitution cost.
-lev_cost(C, C, 0.0) :- !.
-lev_cost(A, B, 0.4) :- downcase_atom(A, C), downcase_atom(B, C), !.
-lev_cost(_, _, 1.0) :- !.
-
-%% Fills the current row with the cheapest action
-fill_row(_, Row, _, [], Row).
-fill_row(PrevRow, Row, Ca, [Cb|StrB], Out) :-
-    PrevRow = [Subst,Delete|PRest],
-    Row = [Insert|Rest],
-    lev_cost(Ca, Cb, SubstCost),
-    Substx is Subst + SubstCost,
-    Deletex is Delete + 1.0,
-    Insertx is Insert + 1.0,
-    min_list([Substx, Deletex, Insertx], MinC),
-    fill_row([Delete|PRest], [MinC,Insert|Rest], Ca, StrB, Out).
-
-%% Rearranges arguments as needed for initial fill_row call.
-% can do [Head|Tail], [HRow, Head|Tail] to keep the full table
-% for backtracking purposes
-fill_row_helper(StrA, Num, Char, [Head|_], [HRow, Head]) :-
-    Numf is float(Num),
-    fill_row(Head, [Numf], Char, StrA, RRow),
-    reverse(RRow, HRow).
-
-%% Helper which builds the levenshtein distance table (or in this case, a single row).
-run_levenshtein(A, "", RowFn, [FirstRow]) :-
-    string(A),
-    string_chars(A, AChars),
-    length(AChars, LA),
-    call(RowFn, LA, FirstRow), !.
-
-run_levenshtein(A, B, RowFn, Table) :-
-    string(A),
-    string(B),
-    string_chars(A, AChars),
-    string_chars(B, BChars),
-    length(AChars, LA),
-    length(BChars, LB),
-    call(RowFn, LA, FirstRow),
-    numlist(1, LB, Nums),
-    foldl(fill_row_helper(AChars), Nums, BChars, [FirstRow], Table), !.
-
-to_float(X, Y) :- Y is float(X).
-
-numlist_helper(LA, List) :-
-    numlist(0, LA, NList), maplist(to_float, NList, List).
+%% Documentation for foreign library
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
-%% levenshtein_distance(+A:str, +B:str, -Distance:float)
+%! levenshtein_distance(+A:str, +B:str, -Distance:float) is semidet
 % Returns the Levenshtein distance between A and B
 % https://en.wikipedia.org/wiki/Levenshtein_distance
-% Uses the two-row table solution to optimize for memory and runtime characteristics
-levenshtein_distance(A, B, Distance) :-
-    run_levenshtein(A, B, numlist_helper, [Row|_]),
-    last(Row, Distance).
 
-zeros_helper(LA, List) :-
-    LAPlus is LA + 1,
-    length(List, LAPlus), maplist(=(0.0), List).
-
-%% levenshtein_distance_fuzzy(+A:str, +B:str, -Distance:float)
+%! levenshtein_distance_fuzzy(+A:str, +B:str, -Distance:float) is semidet
 % https://en.wikipedia.org/wiki/Approximate_string_matching#Problem_formulation_and_algorithms
-% Use min_list for minimum distance. Ignore first item in row.
-fuzzy_substr(A, B, Distance) :-
-    run_levenshtein(A, B, zeros_helper, [[_|Out]|_]),
-    min_list(Out, Distance).
 
+%! split_left/4(String, Sep, N, -Substrings)
+% split_left splits the provided string on the characters in Sep,
+% up to a maximum of N times into Substrings. Multiple seperator characters
+% will be treated as one.