prompt_templates.c

// GENERATED CODE, do not edit (see Makefile)
/* #prompt_list
agreement_to_nl_diff
agreement_to_pl_diff
agreement
nl2algo
nl2pl_rewrite
pl2nl_rewrite
summarize_block
*/

span pt_agreement_to_nl_diff() {
  return S(""
           "The context:\n"
           "\n"
           "```{langtag}\n"
           "{context}\n"
           "```\n"
           "\n"
           "The NL (natural language) part:\n"
           "\n"
           "```{langtag}\n"
           "{comment}\n"
           "```\n"
           "\n"
           "The PL (programming language) part:\n"
           "\n"
           "```{langtag}\n"
           "{code}\n"
           "```\n"
           "\n"
           "There is a discrepancy between the NL part and the PL part which was described as follows:\n"
           "\n"
           "{agreement}\n"
           "\n"
           "Reply only with a unified diff to the NL part (not the PL part!) which would bring it into line with what the PL part implements.\n"
           "\n"
           "Note that the discrepancy is reported in terms of the PL part's implementation of the NL part, but here we want a diff to the NL part.\n");
}

span pt_agreement_to_pl_diff() {
  return S(""
           "The context:\n"
           "\n"
           "```{langtag}\n"
           "{context}\n"
           "```\n"
           "\n"
           "The NL (natural language) part:\n"
           "\n"
           "```{langtag}\n"
           "{comment}\n"
           "```\n"
           "\n"
           "The PL (programming language) part:\n"
           "\n"
           "```{langtag}\n"
           "{code}\n"
           "```\n"
           "\n"
           "There is a discrepancy between the NL part and the PL part which was described as follows:\n"
           "\n"
           "{agreement}\n"
           "\n"
           "Reply only with a unified diff to the PL part which would bring it into line with what the NL part describes.\n");
}

span pt_agreement() {
  return S(""
           "The context:\n"
           "\n"
           "```{langtag}\n"
           "{context}\n"
           "```\n"
           "\n"
           "The comment:\n"
           "\n"
           "```{langtag}\n"
           "{comment}\n"
           "```\n"
           "The code:\n"
           "\n"
           "```{langtag}\n"
           "{code}\n"
           "```\n"
           "\n"
           "Does the code correctly implement what the comment describes? Reply only with \"Yes\" or with \"No\" followed by a sentence describing the problem.\n");
}

span pt_nl2algo() {
  return S(""
           "You are now translating requirements and a high-level description into a step-by-step algorithm.\n"
           "\n"
           "The algorithm should be expressed as bullet points.\n"
           "\n"
           "Examples:\n"
           "\n"
           "Input:\n"
           "\n"
           "```{langtag}\n"
           "/*\n"
           "Function: int add(int, int)\n"
           "\n"
           "Here we implement a function that adds its arguments.\n"
           "*/\n"
           "```\n"
           "\n"
           "Your reply:\n"
           "\n"
           "```{langtag}\n"
           "/*\n"
           "- Return a + b\n"
           "*/\n"
           "```\n"
           "\n"
           "Input:\n"
           "\n"
           "```\n"
           "/*\n"
           "Function: int sum(ints xs)\n"
           "\n"
           "Here we implement a sum function using a simple loop.\n"
           "*/\n"
           "```\n"
           "\n"
           "Your reply:\n"
           "\n"
           "```\n"
           "/*\n"
           "- declare a variable to hold the return value, initialized to zero\n"
           "- for each x in xs:\n"
           "  - accumulate into the running total\n"
           "- return it\n"
           "*/\n"
           "```\n"
           "\n"
           "Focus on high-level algorithmic approach, as we will map into low-level coding syntax in a following step.\n"
           "Prefer simple, iterative approaches, and focus on correctness rather than performance.\n"
           "Be concise.\n"
           "You may include hints towards proof of correctness.\n"
           "\n"
           "Here is context information, and a comment containing the high-level description.\n"
           "\n"
           "Context:\n"
           "\n"
           "```{langtag}\n"
           "{context}\n"
           "```\n"
           "\n"
           "Comment:\n"
           "\n"
           "```{langtag}\n"
           "{comment}\n"
           "```\n"
           "\n"
           "Reply only with a code block containing a block comment containing your step-by-step algorithm implementing what the Comment describes.\n");
}

span pt_nl2pl_rewrite() {
  return S(""
           "```{langtag}\n"
           "{context}\n"
           "```\n"
           "\n"
           "(above: references)\n"
           "---\n"
           "(below: current task)\n"
           "\n"
           "```{langtag}\n"
           "{comment}\n"
           "```\n"
           "\n"
           "Write the code only for the current task. Reply only with a code block beginning with \"```{langtag}\". Do not include comments.\n");
}

span pt_pl2nl_rewrite() {
  return S(""
           "We are translating code into to English, at a level of detail that the code can be recreated from it.\n"
           "We also have a context, which describes general principles and other information about the rest of the code.\n"
           "\n"
           "Reply with a block comment, inside a markdown code section, like this:\n"
           "\n"
           "```{langtag}\n"
           "/* [block_id]\n"
           "\n"
           "[Summary sentence]\n"
           "\n"
           "[C function declaration]\n"
           "\n"
           "[Original comments]\n"
           "\n"
           "[Further details]\n"
           "\n"
           "Algorithm:\n"
           "[Detailed step-by-step translation]\n"
           "*/\n"
           "```\n"
           "\n"
           "Do not use any indentation inside the code block (every line begins flush left).\n"
           "Be concise, and use newlines sparingly, trying to make your English shorter than the original code.\n"
           "Use the existing code to write the function declaration, include parameter names as they are in the existing code, and include the semicolon.\n"
           "Assume that the context, which is provided above, is already known.\n"
           "Don't repeat the context in your output, but rely on it to make the translation more precise, idiomatic, and concise.\n"
           "Create the block id by taking the function (or struct) name and prepending a \"#\", e.g. if the function declaration is \"int add(int a, int b);\" the block id should be \"#id\".\n"
           "\n"
           "In the [Original comments] section, include verbatim any comments in the original code, but remove the comment syntax and make them flush left.\n"
           "(Leave this out if there are no comments, of course.)\n"
           "\n"
           "In the [Further details] section, write detailed English sentences that fully explain the reasoning behind the algorithm that is used.\n"
           "Start each sentence on a new line.\n"
           "This section should be sufficient to recreate the decisions made when writing the code.\n"
           "Incorporate all the information in the original comments, but using full sentences.\n"
           "Try to explain the reasoning behind the code, so that another programmer could understand the decisions made.\n"
           "\n"
           "Code comments that are general to the whole block of code or that are about usage or purpose should go in the [Further details] section, but code comments that are specific to a line of code should be incorporated into the algorithm bullet points.\n"
           "Use markdown dash syntax for the algorithm bullet points.\n"
           "\n"
           "Context:\n"
           "\n"
           "```{langtag}\n"
           "{context}\n"
           "```\n"
           "\n"
           "Code:\n"
           "\n"
           "```{langtag}\n"
           "{code}\n"
           "```\n"
           "\n"
           "Reply only with the C code block, with no other commentary, beginning with \"```{langtag}\".\n");
}

span pt_summarize_block() {
  return S(""
           "Write a summary of the following code.\n"
           "\n"
           "```{langtag}\n"
           "{comment}\n"
           "\n"
           "{code}\n"
           "```\n"
           "\n"
           "The summary should focus on the purpose of the code, in relation to the rest of the system, not the implementation details.\n"
           "\n"
           "Reply only with a single sentence.\n");
}