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 from C to English.\n"
           "The English code should be explicit enough that the C code can be recreated from it. We also have a context, which describes some general principles.\n"
           "\n"
           "Context:\n"
           "\n"
           "```{langtag}\n"
           "{context}\n"
           "```\n"
           "\n"
           "Code:\n"
           "\n"
           "```c\n"
           "{code}\n"
           "```\n"
           "\n"
           "Translate the above code. Reply with a C block comment, inside a markdown code section, like this:\n"
           "\n"
           "```c\n"
           "/* [block_id]\n"
           "\n"
           "Function:\n"
           "[C function declaration]\n"
           "\n"
           "Purpose:\n"
           "[Summary sentence]\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"
           "If there are comments in the original code, include them verbatim, but remove the comment syntax and again make them flush left.\n"
           "Reply only with the C code block, with no other commentary, beginning with \"```c\".\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");
}