evaluate.m

(* ::Package:: *)

(* Wolfram Language Package *)
(* Created by the Wolfram Language Plugin for IntelliJ, see http://wlplugin.halirutan.de/ *)

(* :Title: evaluate *)
(* :Context: evaluate` *)
(* :Author: marcus/phil *)
(* :Date: 2025-09-26 *)

(* :Package Version: 0.1 *)
(* :Mathematica Version: 14.0 *)
(* :Copyright: (c) 2025 Lambda Feedback *)
(* :Keywords: *)
(* :Discussion: *)

(* For new style packages see: https://mathematica.stackexchange.com/a/176489) *)
(* Declare package context *)
Get["utils.m"];
BeginPackage["evaluate`", {"utils`"}];

EvaluationFunction::usage = 
    "EvaluationFunction[\!\(\*
StyleBox[\"answer\",\nFontSlant->\"Italic\"]\), \!\(\*
StyleBox[\"response\",\nFontSlant->\"Italic\"]\), \!\(\*
StyleBox[\"params\",\nFontSlant->\"Italic\"]\)] compares the string \!\(\*
StyleBox[\"response\",\nFontSlant->\"Italic\"]\), a student's response to a task, with the string \!\(\*
StyleBox[\"answer\",\nFontSlant->\"Italic\"]\), the correct or expected outcome of the task; details of the comparison method are set by \!\(\*
StyleBox[\"params\",\nFontSlant->\"Italic\"]\). The return value is an Association with keys \"is_correct\", \"feedback\" and \"error\"."

EvaluationFunction[answer_, response_, params_] := Module[{result, feedback, type},
  type = params["type"];
  Print["Running Evaluation Function"];
  result = evalQ[type, answer, response, params];
  feedback = If[result["is_correct"],
      Lookup[params, "correct_response_feedback", "Correct!"],
      Lookup[params, "incorrect_response_feedback", "Incorrect!"]
      ];

  <|
    "is_correct" -> result["is_correct"],
    "feedback" -> feedback,
    "error" -> result["error"]
  |>
];

Begin["`Private`"];

(* inertFunctionRules lives in utils.m, shared with preview` *)

equalQNumeric[answer_, response_, params_] := Module[{tolerance, error},
  Print["Evaluating Equal Numeric"];
  tolerance = If[Lookup[params, "tolerance_is_absolute", False],
    Lookup[params, "tolerance", 0],
    Lookup[params, "tolerance", 0] * answer
  ];
  error = Abs[answer - response];
  <|
    "error" -> Null,
    "is_correct" -> TrueQ[error <= tolerance]
  |>
]

equalQOther[answer_, response_, params_] := Module[{correctQ},
  Print["Evaluating Equal Other"];
  <|
    "error" -> Null,
    "is_correct" -> TrueQ[answer == response]
  |>
];

(* Patternize: a function that takes an expression and a list of \
named variables, and converts all unnamed symbols in the expression \
into Optional[..] patterns *)

Options[PatternizeSymbol] = {Atomic -> False};

PatternizeSymbol[a_Symbol, namedVariables_, OptionsPattern[]] /; 
  Not[MemberQ[namedVariables, a]]&&(StringTake[ToString[a],Min[4,StringLength[ToString[a]]]]!="$sym") := \!\(\*
TagBox[
StyleBox[
RowBox[{"\n", "  ", 
RowBox[{"If", "[", 
RowBox[{
RowBox[{"OptionValue", "[", "Atomic", "]"}], ",", 
RowBox[{"(", 
RowBox[{"Optional", "[", 
RowBox[{"PatternTest", "[", 
RowBox[{
RowBox[{"pattern", "[", 
RowBox[{"a", ",", 
RowBox[{"Blank", "[", "]"}]}], "]"}], ",", "AtomQ"}], "]"}], "]"}], ")"}], ",", "\n", "  ", 
RowBox[{"(", 
RowBox[{"Optional", "[", 
RowBox[{"pattern", "[", 
RowBox[{"a", ",", 
RowBox[{"Blank", "[", "]"}]}], "]"}], "]"}], ")"}]}], "]"}]}],
ShowSpecialCharacters->False,
ShowStringCharacters->True,
NumberMarks->True],
FullForm]\) /. pattern -> Pattern

PatternizeSymbol[a_, namedVariables_, OptionsPattern[]] := a

ComplexResolve[Optional[a_Symbol] + I Optional[b_Symbol]] := 
 Complex[a, b]

ComplexResolve[I Optional[b_Symbol]*Pi] := Complex[0, b]*Pi

ComplexResolve[Complex[0, Optional[b_Symbol]] + Optional[a_Symbol]] :=
  Complex[a, b]

ComplexResolve[a_] := a

DepatternizePattern[pattern_Optional] := pattern[[1, 1, 1]]

DepatternizePattern[pattern_] := pattern

Options[Patternize] = {Atomic -> False};

Patternize[expression_, namedVariables_, OptionsPattern[]] := 
 Map[PatternizeSymbol[#, Union[namedVariables,{E,Pi}], 
    Atomic -> OptionValue[Atomic]] &, 
  MapAll[ComplexResolve, expression], {-1}]

Depatternize[pattern_] := MapAll[DepatternizePattern, pattern]

(* StandardizeString and StandardizeExpression live in utils.m, shared with preview` *)

(* FullStandardizeString *)

Options[FullStandardizeString] = {SuppressIndependentVariable -> True};

FullStandardizeString[str_,OptionsPattern[]] := Module[{output,suppress},
	output=StandardizeString[str,PlusMinusSplit->True];
	output = ToExpression[output,TraditionalForm];
	output=StandardizeExpression[output,SuppressIndependentVariable->OptionValue[SuppressIndependentVariable]];
	ToString[output,InputForm]]

(*StructureMatchQ: a function that checks whether a user's response \
has the same structure as a given answer template, given a set of \
named variables.*)

SymbolizeNumber[a_Integer?Positive]:=Symbol["$sym"<>ToString[a]]

SymbolizeNumber[a_Integer?Negative]:=(-Symbol["$sym"<>ToString[-a]])

SymbolizeNumber[a_Rational] :=Symbol["$num"<>ToString[Numerator[a]]<>"den"<>ToString[Denominator[a]]]

SymbolizeNumber[0]:=0

SymbolizeNumber[arg_]:=arg

SymbolizeNumber[Complex[a_,b_]]:=SymbolizeNumber[a]+SymbolizeNumber[b] I

SymbolizeNumber[Complex[0,1]]:=I

(* CanonicComplex function is currently no longer used

CanonicComplex[Complex[a_,b_]]:=SymbolizeNumber[a]+SymbolizeNumber[b] I

CanonicComplex[a_.+I*b_]:=SymbolizeNumber[a]+SymbolizeNumber[b] I

CanonicComplex[I]:=I

CanonicComplex[arg_]:=arg *)
   
Options[StructureMatchQ] = {Atomic -> False};

StructureMatchQ[answerTemplate_String,response_String,namedVariables_List,multipleAnswersInterpretation_String] := 
	Module[{response2,answerTemplate2},
	    response2=MapAll[SymbolizeNumber,ReplaceAll[ToExpression[response],inertFunctionRules]];
		answerTemplate2=MapAll[SymbolizeNumber,ReplaceAll[ToExpression[answerTemplate],inertFunctionRules]];
		StructureMatchQ[answerTemplate2,response2,namedVariables,multipleAnswersInterpretation]]

StructureMatchQ[answerTemplate_,response_,namedVariables_List,multipleAnswersInterpretation_String] := 
	MatchQ[response,Patternize[answerTemplate,namedVariables]]

StructureMatchQ[answerTemplate_List,response_List,namedVariables_List,"match_all"]:=Apply[And,Apply[Or,Apply[StructureMatchQ[#1,#2,namedVariables,"match_all"]&,Outer[List,answerTemplate,response],{2}],{1}]]

StructureMatchQ[answerTemplate_List,response_,namedVariables_List,"match_all"]:=False

StructureMatchQ[answerTemplate_List,response_List,namedVariables_List,"match_any"]:=Apply[And,Apply[Or,Apply[StructureMatchQ[#1,#2,namedVariables,"match_all"]&,Outer[List,answerTemplate,response],{2}],{1}]]

StructureMatchQ[answerTemplate_List,response_,namedVariables_List,"match_any"]:=Apply[Or,Map[StructureMatchQ[#1,response,namedVariables,"match_any"]&,answerTemplate]]

StructureMatchQ[answerTemplate_List,response_List,namedVariables_List,"match_order"]:=Apply[And,Apply[Or,Apply[StructureMatchQ[#1,#2,namedVariables,"match_all"]&,Outer[List,answerTemplate,response],{2}],{1}]]

StructureMatchQ[answerTemplate_List,response_,namedVariables_List,"match_order"]:=Apply[And,Apply[StructureMatchQ[#1,#2,namedVariables,"match_order"]&,Transpose[{answerTemplate,response}],{1}]]

equalQStructure[answer_String, response_String, params_Association] := Module[{namedVariables,correctQ,standardizedAnswer,standardizedResponse,suppress,multipleAnswersInterpretation},
  Print["Evaluating Structure"];
    suppress = Lookup[params,"suppress_independent_variable",True];
	namedVariables = ToExpression[Lookup[params,"named_variables",{}],TraditionalForm];
	standardizedAnswer = FullStandardizeString[answer,SuppressIndependentVariable->suppress];
	standardizedResponse= FullStandardizeString[response,SuppressIndependentVariable->suppress];
    multipleAnswersInterpretation=Lookup[params,"multiple_answers_interpretation","match_all"];
	correctQ = StructureMatchQ[standardizedAnswer,standardizedResponse,namedVariables,multipleAnswersInterpretation];

	<|
		"error" -> Null,
		"is_correct" -> correctQ
    |>
]

(* SemanticAndStructureMatchQ: a function that checks whether a user's response both 
	(a) is the same mathematical object as a given answer,and (b) has the same structure as a given answer template,
	given a set of named variables. *)
	
SemanticMatchQ[answer_,response_,multipleAnswersInterpretation_String] := 
    TrueQ[Simplify[((response-answer)/.activeFunctionRules)/.Integrate[integrand_,{var_,min_,max_}]:>Integrate[integrand/.var->$dummy,{$dummy,min,max}]] == 0] || 
    TrueQ[FullSimplify[((response-answer)/.activeFunctionRules)/.Integrate[integrand_,{var_,min_,max_}]:>Integrate[integrand/.var->$dummy,{$dummy,min,max}]] == 0]

SemanticMatchQ[answer_List,response_List,"match_all"]:=Apply[And,Apply[Or,Apply[SemanticMatchQ[#1,#2,"match_all"]&,Outer[List,answer,response],{2}],{1}]];

SemanticMatchQ[answer_List,response_,"match_all"]:=False;

SemanticMatchQ[answer_List,response_List,"match_any"]:=Apply[And,Apply[Or,Apply[SemanticMatchQ[#1,#2,"match_any"]&,Outer[List,answer,response],{2}],{1}]];

SemanticMatchQ[answer_List,response_,"match_any"]:=Apply[Or,Map[SemanticMatchQ[#1,response,"match_any"]&,answer]];

SemanticMatchQ[answer_List,response_List,"match_order"]:=Apply[And,Apply[SemanticMatchQ[#1,#2,"match_order"]&,Transpose[{answer,response}],{1}]];

SemanticMatchQ[answer_List,response_,"match_order"]:=False;

SemanticMatchQ[answer:Equal[arg1_,arg2_], response:Equal[arg3_,arg4_], multipleAnswersInterpretation_String] := Module[
    {ratio1, ratio2},
	SemanticMatchQ[answer[[1]]-answer[[2]], response[[1]]-response[[2]], multipleAnswersInterpretation]||
	SemanticMatchQ[answer[[1]]-answer[[2]], response[[2]]-response[[1]], multipleAnswersInterpretation]||
	(ratio1 = Cancel[(answer[[1]]-answer[[2]])/(response[[1]]-response[[2]])/.Integrate[integrand_,{var_,min_,max_}]:>Integrate[integrand/.var->$dummy,{$dummy,min,max}]];
	 ratio2 = Cancel[(response[[1]]-response[[2]])/(answer[[1]]-answer[[2]])/.Integrate[integrand_,{var_,min_,max_}]:>Integrate[integrand/.var->$dummy,{$dummy,min,max}]];
	 SemanticMatchQ[Denominator[ratio1], 1, multipleAnswersInterpretation]||
	 SemanticMatchQ[Denominator[ratio2], 1, multipleAnswersInterpretation]||
	 NumericQ[ratio1]||AtomQ[ratio1]||AtomQ[ratio2])]

SemanticMatchQ[answer:Equal[arg1_,args1__], response:Equal[arg2_,args2__],multipleAnswersInterpretation_String]/;(Length[{args1}]!=Length[{args2}]) := False

Subrelations[equality_Equal] := Apply[Equal,Partition[Apply[List,equality],2,1],1]

SemanticMatchQ[answer:Equal[arg1_,args1__], response:Equal[arg2_,args2__], multipleAnswersInterpretation_String] := Module[
    {subrelations1 = Subrelations[answer],subrelations2 = Subrelations[response]},
        Thread[SemanticMatchQ[#1,#2,"match_any"]&[subrelations1,subrelations2]]]

SemanticMatchQ[answer_Equal, response:Except[_Equal],multipleAnswersInterpretation_String] := False

SemanticMatchQ[answer:Except[_Equal], response_Equal,multipleAnswersInterpretation_String] := False

InequalityRelations = {LessEqual, GreaterEqual, Less, Greater};
  
SemanticMatchQ[answer:rel_[arg1_,arg2_], response:rel_[arg3_,arg4_], multipleAnswersInterpretation_String]/;MemberQ[InequalityRelations, rel] := 
    Module[
        {ratio1, ratio2},
	    SemanticMatchQ[answer[[1]]-answer[[2]], response[[1]]-response[[2]], multipleAnswersInterpretation]||
	    (ratio1 = Cancel[(answer[[1]]-answer[[2]])/(response[[1]]-response[[2]])/.Integrate[integrand_,{var_,min_,max_}]:>Integrate[integrand/.var->$dummy,{$dummy,min,max}]];
	     ratio2 = Cancel[(response[[1]]-response[[2]])/(answer[[1]]-answer[[2]])/.Integrate[integrand_,{var_,min_,max_}]:>Integrate[integrand/.var->$dummy,{$dummy,min,max}]];
	     (NumericQ[ratio1]&&(ratio1>0)))]

SemanticMatchQ[answer:rel_[arg1_,args1__], response:rel_[arg2_,args2__],multipleAnswersInterpretation_String]/;(Length[{args1}]!=Length[{args2}]&&MemberQ[InequalityRelations, rel]) := False

Subrelations[inequality:rel_[args__]]/;MemberQ[InequalityRelations, rel] := Apply[rel,Partition[Apply[List,inequality],2,1],1]

SemanticMatchQ[answer:rel_[arg1_,args1__], response:rel_[arg2_,args2__], multipleAnswersInterpretation_String]/;MemberQ[InequalityRelations, rel] := 
    Module[
        {subrelations1 = Subrelations[answer],subrelations2 = Subrelations[response]},
            Thread[SemanticMatchQ[#1,#2,"match_any"]&[subrelations1,subrelations2]]]

SemanticMatchQ[answer_LessEqual, response:Except[_LessEqual|_GreaterEqual],multipleAnswersInterpretation_String] := False

SemanticMatchQ[answer:Except[_LessEqual|_GreaterEqual], response_LessEqual,multipleAnswersInterpretation_String] := False

SemanticMatchQ[answer_GreaterEqual, response:Except[_LessEqual|_GreaterEqual],multipleAnswersInterpretation_String] := False

SemanticMatchQ[answer:Except[_LessEqual|_GreaterEqual], response_GreaterEqual,multipleAnswersInterpretation_String] := False

SemanticMatchQ[answer:LessEqual[arg1_,args1__], response:GreaterEqual[arg2_,args2__], multipleAnswersInterpretation_String] :=
    Module[{argList2 = Join[Reverse[{args2}], {arg2}]}, SemanticMatchQ[answer, Apply[LessEqual, argList2], multipleAnswersInterpretation]]

SemanticMatchQ[answer:GreaterEqual[arg1_,args1__], response:LessEqual[arg2_,args2__], multipleAnswersInterpretation_String] :=
    Module[{argList2 = Join[Reverse[{args2}], {arg2}]}, SemanticMatchQ[answer, Apply[GreaterEqual, argList2], multipleAnswersInterpretation]]
  
SemanticMatchQ[answer_Less, response:Except[_Less|_Greater],multipleAnswersInterpretation_String] := False

SemanticMatchQ[answer:Except[_Less|_Greater], response_Less,multipleAnswersInterpretation_String] := False

SemanticMatchQ[answer_Greater, response:Except[_Less|_Greater],multipleAnswersInterpretation_String] := False

SemanticMatchQ[answer:Except[_Less|_Greater], response_Greater,multipleAnswersInterpretation_String] := False

SemanticMatchQ[answer:Less[arg1_,args1__], response:Greater[arg2_,args2__], multipleAnswersInterpretation_String] :=
    Module[{argList2 = Join[Reverse[{args2}], {arg2}]}, SemanticMatchQ[answer, Apply[Less, argList2], multipleAnswersInterpretation]]

SemanticMatchQ[answer:Greater[arg1_,args1__], response:Less[arg2_,args2__], multipleAnswersInterpretation_String] :=
    Module[{argList2 = Join[Reverse[{args2}], {arg2}]}, SemanticMatchQ[answer, Apply[Greater, argList2], multipleAnswersInterpretation]]
    
ResolveInequalities[relationExpression_Inequality]:= Apply[#2[#1,#3]&,Partition[Apply[List,relationExpression],3,2],{1}]

SemanticMatchQ[answer_Inequality, response_Inequality, multipleAnswersInterpretation_String] := 
    Module[{subrelations1 = ResolveInequalities[answer], subrelations2 = ResolveInequalities[response]},
        Thread[SemanticMatchQ[#1,#2,"match_any"]&[subrelations1,subrelations2]]]

SemanticMatchQ[answer_String,response_String,multipleAnswersInterpretation_String] := 
  SemanticMatchQ[
    ToExpression[answer],
    ToExpression[response],
	multipleAnswersInterpretation
  ]

SemanticAndStructureMatchQ[answer_String,response_String,answerTemplate_String,namedVariables_List,multipleAnswersInterpretation_String] :=
	TrueQ[SemanticMatchQ[answer,response,multipleAnswersInterpretation]&&
	      StructureMatchQ[answerTemplate,response,namedVariables,multipleAnswersInterpretation]]

equalQSemantic[answer_String, response_String, params_Association] := Module[{correctQ, standardizedAnswer,standardizedResponse,suppress,multipleAnswersInterpretation},
  Print["Evaluating Semantic"];    
    suppress = Lookup[params,"suppress_independent_variable",True];
	standardizedAnswer = FullStandardizeString[answer,SuppressIndependentVariable->suppress];
	standardizedResponse = FullStandardizeString[response,SuppressIndependentVariable->suppress];
	multipleAnswersInterpretation=Lookup[params,"multiple_answers_interpretation","match_all"];
	correctQ = SemanticMatchQ[standardizedAnswer,standardizedResponse,multipleAnswersInterpretation];
		
	<|
		"error" -> Null,
		"is_correct" -> correctQ
    |>
]

equalQSemanticAndStructure[answer_String, response_String, params_Association] := Module[{
   namedVariables,standardizedAnswer,standardizedResponse,answerTemplate,standardizedAnswerTemplate,correctQ,suppress,multipleAnswersInterpretation},
    Print["Evaluating SemanticAndStructure"];
    namedVariables = ToExpression[Lookup[params,"named_variables",{}],TraditionalForm];    
    answerTemplate = Lookup[params,"answer_template",Automatic]; 
    suppress = Lookup[params,"suppress_independent_variable",True];
	standardizedAnswer= FullStandardizeString[answer,SuppressIndependentVariable->suppress];
	standardizedResponse= FullStandardizeString[response,SuppressIndependentVariable->suppress];
	multipleAnswersInterpretation=Lookup[params,"multiple_answers_interpretation","match_all"];
	standardizedAnswerTemplate=If[TrueQ[answerTemplate==Automatic],
		standardizedAnswer,
		FullStandardizeString[answerTemplate,SuppressIndependentVariable->suppress]];
	correctQ = SemanticAndStructureMatchQ[standardizedAnswer,standardizedResponse,standardizedAnswerTemplate,namedVariables,multipleAnswersInterpretation];

	<|
		"error" -> Null,
		"is_correct" -> correctQ
    |>
]

(* UnnamedSymbols: a function that takes an expression and a list of named variables,
   and returns all other symbolic quantities in the expression. *)

UnnamedSymbols[expression_,namedVariables_] := 
	Cases[Reap[Scan[Sow,expression,{-1}]][[2,1]],a_Symbol/;Not[MemberQ[namedVariables,a]]]

(* StrictStructureMatchQ: a function that matches structures more strictly,taking account of the unnamed symbols 
	in each.*)

(* THIS FUNCTION IS FLAWED, AND REPRESENTS A CRUDE FIRST GO *)

(* IN PARTICULAR, THE COMPARISON OF THE LENGTHS OF THE SYMBOL LISTS IS VERY HAMFISTED *)

StrictStructureMatchQ[answerTemplate_String,response_String,namedVariables_List,multipleAnswersInterpretation_String] := 
	StructureMatchQ[answerTemplate,response,namedVariables,multipleAnswersInterpretation]&&
	TrueQ[
		(Length[Union[UnnamedSymbols[ToExpression[response],namedVariables]]]==
		 Length[Union[UnnamedSymbols[ToExpression[StandardizeString[answerTemplate],TraditionalForm],namedVariables]]])]

(* SemanticAndStrictStructureMatchQ: a function that combines a strict structure comparison with a test of
	mathematical equivalence  *)

SemanticAndStrictStructureMatchQ[answer_String,response_String,answerTemplate_String,namedVariables_List,multipleAnswersInterpretation_String] := 
	TrueQ[SemanticMatchQ[answer,response,multipleAnswersInterpretation]&&StrictStructureMatchQ[answerTemplate,response,namedVariables,multipleAnswersInterpretation]]
	
equalQStrictStructure[answer_String, response_String, params_Association] := Module[{namedVariables,correctQ,suppress,standardizedAnswer,standardizedResponse,multipleAnswersInterpretation},
  Print["Evaluating Strict Structure"];
	namedVariables = ToExpression[Lookup[params,"named_variables",{}],TraditionalForm];
    suppress = Lookup[params,"suppress_independent_variable",True];
	standardizedAnswer = FullStandardizeString[answer,SuppressIndependentVariable->suppress];
	standardizedResponse= FullStandardizeString[response,SuppressIndependentVariable->suppress];
	multipleAnswersInterpretation=Lookup[params,"multiple_answers_interpretation","match_all"];
	correctQ = StrictStructureMatchQ[standardizedAnswer,standardizedResponse,namedVariables,multipleAnswersInterpretation];

	<|
		"error" -> Null,
		"is_correct" -> correctQ
    |>
]

equalQSemanticAndStrictStructure[answer_String, response_String, params_Association] := Module[{
    namedVariables,answerTemplate,correctQ,suppress,standardizedAnswer,standardizedResponse,standardizedAnswerTemplate,multipleAnswersInterpretation},
  Print["Evaluating SemanticAndStrictStructure"];
    namedVariables = ToExpression[Lookup[params,"named_variables",{}],TraditionalForm];    
    answerTemplate = Lookup[params,"answer_template",Automatic]; 
    suppress = Lookup[params,"suppress_independent_variable",True];
	standardizedAnswer= FullStandardizeString[answer,SuppressIndependentVariable->suppress];
	standardizedResponse= FullStandardizeString[response,SuppressIndependentVariable->suppress];
standardizedAnswerTemplate=If[TrueQ[answerTemplate==Automatic],
standardizedAnswer,
FullStandardizeString[answerTemplate,SuppressIndependentVariable->suppress]];
multipleAnswersInterpretation=Lookup[params,"multiple_answers_interpretation","match_all"];
	correctQ = SemanticAndStrictStructureMatchQ[standardizedAnswer,standardizedAnswer,standardizedAnswerTemplate,namedVariables,multipleAnswersInterpretation];

	<|
		"error" -> Null,
		"is_correct" -> correctQ
    |>
]

(* The evaluation function itself *)

evalQ[type_, answer_, response_, params_] := Module[{},
  Which[
	type == "structure",
	equalQStructure[answer, response, params],
	type == "semantic",
	equalQSemantic[answer, response, params],
	type == "semantic_and_structure",	
	equalQSemanticAndStructure[answer, response, params],
	type == "strict_structure",	
	equalQStrictStructure[answer, response, params],
	type == "semantic_and_strict_structure",	
	equalQSemanticAndStrictStructure[answer, response, params],
	NumericQ[answer],
    equalQNumeric[answer, response, params],
    True,
    equalQOther[answer, response, params]
  ]
];
End[];
EndPackage[]