{"prompt": "Write a Hemlock program that prints \"hello\".", "chosen": "print(\"hello\");", "rejected": "println(\"hello\");"} {"prompt": "Write a Hemlock program that prints \"done\".", "chosen": "print(\"done\");", "rejected": "println(\"done\");"} {"prompt": "Write a Hemlock program that prints \"processing\".", "chosen": "print(\"processing\");", "rejected": "println(\"processing\");"} {"prompt": "Write a Hemlock program that prints \"result ready\".", "chosen": "print(\"result ready\");", "rejected": "println(\"result ready\");"} {"prompt": "Write a Hemlock program that prints \"ok\".", "chosen": "print(\"ok\");", "rejected": "println(\"ok\");"} {"prompt": "Write a Hemlock program that prints \"started\".", "chosen": "print(\"started\");", "rejected": "println(\"started\");"} {"prompt": "Write a Hemlock program that prints \"finished\".", "chosen": "print(\"finished\");", "rejected": "println(\"finished\");"} {"prompt": "Write a Hemlock program that prints \"loading\".", "chosen": "print(\"loading\");", "rejected": "println(\"loading\");"} {"prompt": "Write a Hemlock program that prints the length of the array [1, 2, 3].", "chosen": "let a = [1, 2, 3];\nprint(a.length);", "rejected": "let a = [1, 2, 3];\nprint(len(a));"} {"prompt": "Write a Hemlock program that prints the length of the array [5, 5].", "chosen": "let a = [5, 5];\nprint(a.length);", "rejected": "let a = [5, 5];\nprint(len(a));"} {"prompt": "Write a Hemlock program that prints the length of the array [9].", "chosen": "let a = [9];\nprint(a.length);", "rejected": "let a = [9];\nprint(len(a));"} {"prompt": "Write a Hemlock program that prints the length of the array [10, 20, 30, 40].", "chosen": "let a = [10, 20, 30, 40];\nprint(a.length);", "rejected": "let a = [10, 20, 30, 40];\nprint(len(a));"} {"prompt": "Write a Hemlock program that prints the length of the array [0].", "chosen": "let a = [0];\nprint(a.length);", "rejected": "let a = [0];\nprint(len(a));"} {"prompt": "Write a Hemlock program that prints the length of the array [7, 14].", "chosen": "let a = [7, 14];\nprint(a.length);", "rejected": "let a = [7, 14];\nprint(len(a));"} {"prompt": "Write a Hemlock program that prints the length of the array [100, 200, 300].", "chosen": "let a = [100, 200, 300];\nprint(a.length);", "rejected": "let a = [100, 200, 300];\nprint(len(a));"} {"prompt": "Write a Hemlock program that prints the length of the array [2, 4, 6, 8].", "chosen": "let a = [2, 4, 6, 8];\nprint(a.length);", "rejected": "let a = [2, 4, 6, 8];\nprint(len(a));"} {"prompt": "Write a Hemlock program that prints whether \"hello\" contains \"ell\".", "chosen": "let s = \"hello\";\nprint(s.contains(\"ell\"));", "rejected": "let s = \"hello\";\nprint(s.includes(\"ell\"));"} {"prompt": "Write a Hemlock program that prints whether \"hemlock\" contains \"lock\".", "chosen": "let s = \"hemlock\";\nprint(s.contains(\"lock\"));", "rejected": "let s = \"hemlock\";\nprint(s.includes(\"lock\"));"} {"prompt": "Write a Hemlock program that prints whether \"banana\" contains \"nan\".", "chosen": "let s = \"banana\";\nprint(s.contains(\"nan\"));", "rejected": "let s = \"banana\";\nprint(s.includes(\"nan\"));"} {"prompt": "Write a Hemlock program that prints whether \"systems\" contains \"stem\".", "chosen": "let s = \"systems\";\nprint(s.contains(\"stem\"));", "rejected": "let s = \"systems\";\nprint(s.includes(\"stem\"));"} {"prompt": "Write a Hemlock program that prints whether \"poison\" contains \"son\".", "chosen": "let s = \"poison\";\nprint(s.contains(\"son\"));", "rejected": "let s = \"poison\";\nprint(s.includes(\"son\"));"} {"prompt": "Write a Hemlock program that prints whether \"apothecary\" contains \"thec\".", "chosen": "let s = \"apothecary\";\nprint(s.contains(\"thec\"));", "rejected": "let s = \"apothecary\";\nprint(s.includes(\"thec\"));"} {"prompt": "Write a Hemlock program that prints whether \"formula\" contains \"mul\".", "chosen": "let s = \"formula\";\nprint(s.contains(\"mul\"));", "rejected": "let s = \"formula\";\nprint(s.includes(\"mul\"));"} {"prompt": "Write a Hemlock program that prints whether \"tincture\" contains \"tin\".", "chosen": "let s = \"tincture\";\nprint(s.contains(\"tin\"));", "rejected": "let s = \"tincture\";\nprint(s.includes(\"tin\"));"} {"prompt": "Write a Hemlock program that prints \"count=\" then 5 via a template string.", "chosen": "let v = 5;\nprint(`count=${v}`);", "rejected": "let v = 5;\nprint(f\"count={v}\");"} {"prompt": "Write a Hemlock program that prints \"total=\" then 42 via a template string.", "chosen": "let v = 42;\nprint(`total=${v}`);", "rejected": "let v = 42;\nprint(f\"total={v}\");"} {"prompt": "Write a Hemlock program that prints \"n=\" then 7 via a template string.", "chosen": "let v = 7;\nprint(`n=${v}`);", "rejected": "let v = 7;\nprint(f\"n={v}\");"} {"prompt": "Write a Hemlock program that prints \"size=\" then 128 via a template string.", "chosen": "let v = 128;\nprint(`size=${v}`);", "rejected": "let v = 128;\nprint(f\"size={v}\");"} {"prompt": "Write a Hemlock program that prints \"score=\" then 95 via a template string.", "chosen": "let v = 95;\nprint(`score=${v}`);", "rejected": "let v = 95;\nprint(f\"score={v}\");"} {"prompt": "Write a Hemlock program that prints \"len=\" then 3 via a template string.", "chosen": "let v = 3;\nprint(`len=${v}`);", "rejected": "let v = 3;\nprint(f\"len={v}\");"} {"prompt": "Write a Hemlock program that prints \"idx=\" then 0 via a template string.", "chosen": "let v = 0;\nprint(`idx=${v}`);", "rejected": "let v = 0;\nprint(f\"idx={v}\");"} {"prompt": "Write a Hemlock program that prints \"sum=\" then 100 via a template string.", "chosen": "let v = 100;\nprint(`sum=${v}`);", "rejected": "let v = 100;\nprint(f\"sum={v}\");"} {"prompt": "Write a Hemlock program using @stdlib/json to parse a JSON object and print field \"a\".", "chosen": "import { parse } from \"@stdlib/json\";\nlet o = parse(\"{\\\"a\\\":1}\");\nprint(o[\"a\"]);", "rejected": "import { loads } from \"@stdlib/json\";\nlet o = loads(\"{\\\"a\\\":1}\");\nprint(o[\"a\"]);"} {"prompt": "Write a Hemlock program using @stdlib/json to parse a JSON object and print field \"score\".", "chosen": "import { parse } from \"@stdlib/json\";\nlet o = parse(\"{\\\"score\\\":95}\");\nprint(o[\"score\"]);", "rejected": "import { loads } from \"@stdlib/json\";\nlet o = loads(\"{\\\"score\\\":95}\");\nprint(o[\"score\"]);"} {"prompt": "Write a Hemlock program using @stdlib/json to parse a JSON object and print field \"n\".", "chosen": "import { parse } from \"@stdlib/json\";\nlet o = parse(\"{\\\"n\\\":7}\");\nprint(o[\"n\"]);", "rejected": "import { loads } from \"@stdlib/json\";\nlet o = loads(\"{\\\"n\\\":7}\");\nprint(o[\"n\"]);"} {"prompt": "Write a Hemlock program using @stdlib/json to parse a JSON object and print field \"id\".", "chosen": "import { parse } from \"@stdlib/json\";\nlet o = parse(\"{\\\"id\\\":42}\");\nprint(o[\"id\"]);", "rejected": "import { loads } from \"@stdlib/json\";\nlet o = loads(\"{\\\"id\\\":42}\");\nprint(o[\"id\"]);"} {"prompt": "Write a Hemlock program using @stdlib/json to parse a JSON object and print field \"x\".", "chosen": "import { parse } from \"@stdlib/json\";\nlet o = parse(\"{\\\"x\\\":3}\");\nprint(o[\"x\"]);", "rejected": "import { loads } from \"@stdlib/json\";\nlet o = loads(\"{\\\"x\\\":3}\");\nprint(o[\"x\"]);"} {"prompt": "Write a Hemlock program using @stdlib/json to parse a JSON object and print field \"ok\".", "chosen": "import { parse } from \"@stdlib/json\";\nlet o = parse(\"{\\\"ok\\\":true}\");\nprint(o[\"ok\"]);", "rejected": "import { loads } from \"@stdlib/json\";\nlet o = loads(\"{\\\"ok\\\":true}\");\nprint(o[\"ok\"]);"} {"prompt": "Write a Hemlock program using @stdlib/json to parse a JSON object and print field \"count\".", "chosen": "import { parse } from \"@stdlib/json\";\nlet o = parse(\"{\\\"count\\\":10}\");\nprint(o[\"count\"]);", "rejected": "import { loads } from \"@stdlib/json\";\nlet o = loads(\"{\\\"count\\\":10}\");\nprint(o[\"count\"]);"} {"prompt": "Write a Hemlock program using @stdlib/json to parse a JSON object and print field \"val\".", "chosen": "import { parse } from \"@stdlib/json\";\nlet o = parse(\"{\\\"val\\\":5}\");\nprint(o[\"val\"]);", "rejected": "import { loads } from \"@stdlib/json\";\nlet o = loads(\"{\\\"val\\\":5}\");\nprint(o[\"val\"]);"} {"prompt": "Write a Hemlock program using @stdlib/json to stringify { a: 1 } and print it.", "chosen": "import { stringify } from \"@stdlib/json\";\nprint(stringify({ a: 1 }));", "rejected": "import { dumps } from \"@stdlib/json\";\nprint(dumps({ a: 1 }));"} {"prompt": "Write a Hemlock program using @stdlib/json to stringify { x: 10, y: 20 } and print it.", "chosen": "import { stringify } from \"@stdlib/json\";\nprint(stringify({ x: 10, y: 20 }));", "rejected": "import { dumps } from \"@stdlib/json\";\nprint(dumps({ x: 10, y: 20 }));"} {"prompt": "Write a Hemlock program using @stdlib/json to stringify { ok: true } and print it.", "chosen": "import { stringify } from \"@stdlib/json\";\nprint(stringify({ ok: true }));", "rejected": "import { dumps } from \"@stdlib/json\";\nprint(dumps({ ok: true }));"} {"prompt": "Write a Hemlock program using @stdlib/json to stringify { name: 1 } and print it.", "chosen": "import { stringify } from \"@stdlib/json\";\nprint(stringify({ name: 1 }));", "rejected": "import { dumps } from \"@stdlib/json\";\nprint(dumps({ name: 1 }));"} {"prompt": "Write a Hemlock program using @stdlib/json to stringify { n: 7 } and print it.", "chosen": "import { stringify } from \"@stdlib/json\";\nprint(stringify({ n: 7 }));", "rejected": "import { dumps } from \"@stdlib/json\";\nprint(dumps({ n: 7 }));"} {"prompt": "Write a Hemlock program using @stdlib/json to stringify { p: 1, q: 2 } and print it.", "chosen": "import { stringify } from \"@stdlib/json\";\nprint(stringify({ p: 1, q: 2 }));", "rejected": "import { dumps } from \"@stdlib/json\";\nprint(dumps({ p: 1, q: 2 }));"} {"prompt": "Write a Hemlock program using @stdlib/json to stringify { score: 95 } and print it.", "chosen": "import { stringify } from \"@stdlib/json\";\nprint(stringify({ score: 95 }));", "rejected": "import { dumps } from \"@stdlib/json\";\nprint(dumps({ score: 95 }));"} {"prompt": "Write a Hemlock program using @stdlib/json to stringify { id: 3 } and print it.", "chosen": "import { stringify } from \"@stdlib/json\";\nprint(stringify({ id: 3 }));", "rejected": "import { dumps } from \"@stdlib/json\";\nprint(dumps({ id: 3 }));"} {"prompt": "Write a Hemlock program that builds an object map, deletes key \"a\", and prints whether each key still exists.", "chosen": "let m = {};\nm[\"a\"] = 1;\nm[\"b\"] = 2;\nm[\"c\"] = 3;\nm.delete(\"a\");\nprint(m.has(\"a\"));\nprint(m.has(\"b\"));\nprint(m.has(\"c\"));", "rejected": "let m = {};\nm[\"a\"] = 1;\nm[\"b\"] = 2;\nm[\"c\"] = 3;\nm.remove(\"a\");\nprint(m.has(\"a\"));\nprint(m.has(\"b\"));\nprint(m.has(\"c\"));"} {"prompt": "Write a Hemlock program that builds an object map, deletes key \"y\", and prints whether each key still exists.", "chosen": "let m = {};\nm[\"x\"] = 10;\nm[\"y\"] = 20;\nm.delete(\"y\");\nprint(m.has(\"x\"));\nprint(m.has(\"y\"));", "rejected": "let m = {};\nm[\"x\"] = 10;\nm[\"y\"] = 20;\nm.remove(\"y\");\nprint(m.has(\"x\"));\nprint(m.has(\"y\"));"} {"prompt": "Write a Hemlock program that builds an object map, deletes key \"age\", and prints whether each key still exists.", "chosen": "let m = {};\nm[\"name\"] = 5;\nm[\"age\"] = 30;\nm.delete(\"age\");\nprint(m.has(\"name\"));\nprint(m.has(\"age\"));", "rejected": "let m = {};\nm[\"name\"] = 5;\nm[\"age\"] = 30;\nm.remove(\"age\");\nprint(m.has(\"name\"));\nprint(m.has(\"age\"));"} {"prompt": "Write a Hemlock program that builds an object map, deletes key \"v\", and prints whether each key still exists.", "chosen": "let m = {};\nm[\"id\"] = 1;\nm[\"v\"] = 2;\nm.delete(\"v\");\nprint(m.has(\"id\"));\nprint(m.has(\"v\"));", "rejected": "let m = {};\nm[\"id\"] = 1;\nm[\"v\"] = 2;\nm.remove(\"v\");\nprint(m.has(\"id\"));\nprint(m.has(\"v\"));"} {"prompt": "Write a Hemlock program that builds an object map, deletes key \"q\", and prints whether each key still exists.", "chosen": "let m = {};\nm[\"p\"] = 1;\nm[\"q\"] = 2;\nm[\"r\"] = 3;\nm.delete(\"q\");\nprint(m.has(\"p\"));\nprint(m.has(\"q\"));\nprint(m.has(\"r\"));", "rejected": "let m = {};\nm[\"p\"] = 1;\nm[\"q\"] = 2;\nm[\"r\"] = 3;\nm.remove(\"q\");\nprint(m.has(\"p\"));\nprint(m.has(\"q\"));\nprint(m.has(\"r\"));"} {"prompt": "Write a Hemlock program that builds an object map, deletes key \"one\", and prints whether each key still exists.", "chosen": "let m = {};\nm[\"one\"] = 1;\nm[\"two\"] = 2;\nm.delete(\"one\");\nprint(m.has(\"one\"));\nprint(m.has(\"two\"));", "rejected": "let m = {};\nm[\"one\"] = 1;\nm[\"two\"] = 2;\nm.remove(\"one\");\nprint(m.has(\"one\"));\nprint(m.has(\"two\"));"} {"prompt": "Write a Hemlock program that builds an object map, deletes key \"k2\", and prints whether each key still exists.", "chosen": "let m = {};\nm[\"k1\"] = 9;\nm[\"k2\"] = 4;\nm.delete(\"k2\");\nprint(m.has(\"k1\"));\nprint(m.has(\"k2\"));", "rejected": "let m = {};\nm[\"k1\"] = 9;\nm[\"k2\"] = 4;\nm.remove(\"k2\");\nprint(m.has(\"k1\"));\nprint(m.has(\"k2\"));"} {"prompt": "Write a Hemlock program that builds an object map, deletes key \"alpha\", and prints whether each key still exists.", "chosen": "let m = {};\nm[\"alpha\"] = 1;\nm[\"beta\"] = 2;\nm.delete(\"alpha\");\nprint(m.has(\"alpha\"));\nprint(m.has(\"beta\"));", "rejected": "let m = {};\nm[\"alpha\"] = 1;\nm[\"beta\"] = 2;\nm.remove(\"alpha\");\nprint(m.has(\"alpha\"));\nprint(m.has(\"beta\"));"} {"prompt": "Write a Hemlock program that builds an object map and prints whether key \"a\" is present.", "chosen": "let m = {};\nm[\"a\"] = 1;\nm[\"b\"] = 2;\nm[\"c\"] = 3;\nif (m.has(\"a\")) { print(\"found\"); } else { print(\"missing\"); }", "rejected": "let m = {};\nm[\"a\"] = 1;\nm[\"b\"] = 2;\nm[\"c\"] = 3;\nif (\"a\" in m) { print(\"found\"); } else { print(\"missing\"); }"} {"prompt": "Write a Hemlock program that builds an object map and prints whether key \"y\" is present.", "chosen": "let m = {};\nm[\"x\"] = 10;\nm[\"y\"] = 20;\nif (m.has(\"y\")) { print(\"found\"); } else { print(\"missing\"); }", "rejected": "let m = {};\nm[\"x\"] = 10;\nm[\"y\"] = 20;\nif (\"y\" in m) { print(\"found\"); } else { print(\"missing\"); }"} {"prompt": "Write a Hemlock program that builds an object map and prints whether key \"age\" is present.", "chosen": "let m = {};\nm[\"name\"] = 5;\nm[\"age\"] = 30;\nif (m.has(\"age\")) { print(\"found\"); } else { print(\"missing\"); }", "rejected": "let m = {};\nm[\"name\"] = 5;\nm[\"age\"] = 30;\nif (\"age\" in m) { print(\"found\"); } else { print(\"missing\"); }"} {"prompt": "Write a Hemlock program that builds an object map and prints whether key \"v\" is present.", "chosen": "let m = {};\nm[\"id\"] = 1;\nm[\"v\"] = 2;\nif (m.has(\"v\")) { print(\"found\"); } else { print(\"missing\"); }", "rejected": "let m = {};\nm[\"id\"] = 1;\nm[\"v\"] = 2;\nif (\"v\" in m) { print(\"found\"); } else { print(\"missing\"); }"} {"prompt": "Write a Hemlock program that builds an object map and prints whether key \"q\" is present.", "chosen": "let m = {};\nm[\"p\"] = 1;\nm[\"q\"] = 2;\nm[\"r\"] = 3;\nif (m.has(\"q\")) { print(\"found\"); } else { print(\"missing\"); }", "rejected": "let m = {};\nm[\"p\"] = 1;\nm[\"q\"] = 2;\nm[\"r\"] = 3;\nif (\"q\" in m) { print(\"found\"); } else { print(\"missing\"); }"} {"prompt": "Write a Hemlock program that builds an object map and prints whether key \"one\" is present.", "chosen": "let m = {};\nm[\"one\"] = 1;\nm[\"two\"] = 2;\nif (m.has(\"one\")) { print(\"found\"); } else { print(\"missing\"); }", "rejected": "let m = {};\nm[\"one\"] = 1;\nm[\"two\"] = 2;\nif (\"one\" in m) { print(\"found\"); } else { print(\"missing\"); }"} {"prompt": "Write a Hemlock program that builds an object map and prints whether key \"k2\" is present.", "chosen": "let m = {};\nm[\"k1\"] = 9;\nm[\"k2\"] = 4;\nif (m.has(\"k2\")) { print(\"found\"); } else { print(\"missing\"); }", "rejected": "let m = {};\nm[\"k1\"] = 9;\nm[\"k2\"] = 4;\nif (\"k2\" in m) { print(\"found\"); } else { print(\"missing\"); }"} {"prompt": "Write a Hemlock program that builds an object map and prints whether key \"alpha\" is present.", "chosen": "let m = {};\nm[\"alpha\"] = 1;\nm[\"beta\"] = 2;\nif (m.has(\"alpha\")) { print(\"found\"); } else { print(\"missing\"); }", "rejected": "let m = {};\nm[\"alpha\"] = 1;\nm[\"beta\"] = 2;\nif (\"alpha\" in m) { print(\"found\"); } else { print(\"missing\"); }"} {"prompt": "Write a Hemlock program that iterates the keys of an object map and prints each.", "chosen": "let m = {};\nm[\"a\"] = 1;\nm[\"b\"] = 2;\nm[\"c\"] = 3;\nfor (k in m.keys()) { print(k); }", "rejected": "let m = {};\nm[\"a\"] = 1;\nm[\"b\"] = 2;\nm[\"c\"] = 3;\nfor (k in Object.keys(m)) { print(k); }"} {"prompt": "Write a Hemlock program that iterates the keys of an object map and prints each.", "chosen": "let m = {};\nm[\"x\"] = 10;\nm[\"y\"] = 20;\nfor (k in m.keys()) { print(k); }", "rejected": "let m = {};\nm[\"x\"] = 10;\nm[\"y\"] = 20;\nfor (k in Object.keys(m)) { print(k); }"} {"prompt": "Write a Hemlock program that iterates the keys of an object map and prints each.", "chosen": "let m = {};\nm[\"name\"] = 5;\nm[\"age\"] = 30;\nfor (k in m.keys()) { print(k); }", "rejected": "let m = {};\nm[\"name\"] = 5;\nm[\"age\"] = 30;\nfor (k in Object.keys(m)) { print(k); }"} {"prompt": "Write a Hemlock program that iterates the keys of an object map and prints each.", "chosen": "let m = {};\nm[\"id\"] = 1;\nm[\"v\"] = 2;\nfor (k in m.keys()) { print(k); }", "rejected": "let m = {};\nm[\"id\"] = 1;\nm[\"v\"] = 2;\nfor (k in Object.keys(m)) { print(k); }"} {"prompt": "Write a Hemlock program that iterates the keys of an object map and prints each.", "chosen": "let m = {};\nm[\"p\"] = 1;\nm[\"q\"] = 2;\nm[\"r\"] = 3;\nfor (k in m.keys()) { print(k); }", "rejected": "let m = {};\nm[\"p\"] = 1;\nm[\"q\"] = 2;\nm[\"r\"] = 3;\nfor (k in Object.keys(m)) { print(k); }"} {"prompt": "Write a Hemlock program that iterates the keys of an object map and prints each.", "chosen": "let m = {};\nm[\"one\"] = 1;\nm[\"two\"] = 2;\nfor (k in m.keys()) { print(k); }", "rejected": "let m = {};\nm[\"one\"] = 1;\nm[\"two\"] = 2;\nfor (k in Object.keys(m)) { print(k); }"} {"prompt": "Write a Hemlock program that iterates the keys of an object map and prints each.", "chosen": "let m = {};\nm[\"k1\"] = 9;\nm[\"k2\"] = 4;\nfor (k in m.keys()) { print(k); }", "rejected": "let m = {};\nm[\"k1\"] = 9;\nm[\"k2\"] = 4;\nfor (k in Object.keys(m)) { print(k); }"} {"prompt": "Write a Hemlock program that iterates the keys of an object map and prints each.", "chosen": "let m = {};\nm[\"alpha\"] = 1;\nm[\"beta\"] = 2;\nfor (k in m.keys()) { print(k); }", "rejected": "let m = {};\nm[\"alpha\"] = 1;\nm[\"beta\"] = 2;\nfor (k in Object.keys(m)) { print(k); }"} {"prompt": "Write a Hemlock program that iterates over [1, 2, 3] directly and prints each element.", "chosen": "let a = [1, 2, 3];\nfor (x in a) { print(x); }", "rejected": "let a = [1, 2, 3];\nfor (i in range(len(a))) { print(a[i]); }"} {"prompt": "Write a Hemlock program that iterates over [5, 5] directly and prints each element.", "chosen": "let a = [5, 5];\nfor (x in a) { print(x); }", "rejected": "let a = [5, 5];\nfor (i in range(len(a))) { print(a[i]); }"} {"prompt": "Write a Hemlock program that iterates over [9] directly and prints each element.", "chosen": "let a = [9];\nfor (x in a) { print(x); }", "rejected": "let a = [9];\nfor (i in range(len(a))) { print(a[i]); }"} {"prompt": "Write a Hemlock program that iterates over [10, 20, 30, 40] directly and prints each element.", "chosen": "let a = [10, 20, 30, 40];\nfor (x in a) { print(x); }", "rejected": "let a = [10, 20, 30, 40];\nfor (i in range(len(a))) { print(a[i]); }"} {"prompt": "Write a Hemlock program that iterates over [0] directly and prints each element.", "chosen": "let a = [0];\nfor (x in a) { print(x); }", "rejected": "let a = [0];\nfor (i in range(len(a))) { print(a[i]); }"} {"prompt": "Write a Hemlock program that iterates over [7, 14] directly and prints each element.", "chosen": "let a = [7, 14];\nfor (x in a) { print(x); }", "rejected": "let a = [7, 14];\nfor (i in range(len(a))) { print(a[i]); }"} {"prompt": "Write a Hemlock program that iterates over [100, 200, 300] directly and prints each element.", "chosen": "let a = [100, 200, 300];\nfor (x in a) { print(x); }", "rejected": "let a = [100, 200, 300];\nfor (i in range(len(a))) { print(a[i]); }"} {"prompt": "Write a Hemlock program that iterates over [2, 4, 6, 8] directly and prints each element.", "chosen": "let a = [2, 4, 6, 8];\nfor (x in a) { print(x); }", "rejected": "let a = [2, 4, 6, 8];\nfor (i in range(len(a))) { print(a[i]); }"} {"prompt": "Write a Hemlock program that appends a value to an array and prints its length.", "chosen": "let a = [1, 2];\na.push(99);\nprint(a.length);", "rejected": "let a = [1, 2];\na.append(99);\nprint(a.length);"} {"prompt": "Write a Hemlock program that appends a value to an array and prints its length.", "chosen": "let a = [5];\na.push(99);\nprint(a.length);", "rejected": "let a = [5];\na.append(99);\nprint(a.length);"} {"prompt": "Write a Hemlock program that appends a value to an array and prints its length.", "chosen": "let a = [];\na.push(99);\nprint(a.length);", "rejected": "let a = [];\na.append(99);\nprint(a.length);"} {"prompt": "Write a Hemlock program that appends a value to an array and prints its length.", "chosen": "let a = [10, 20, 30];\na.push(99);\nprint(a.length);", "rejected": "let a = [10, 20, 30];\na.append(99);\nprint(a.length);"} {"prompt": "Write a Hemlock program that appends a value to an array and prints its length.", "chosen": "let a = [7];\na.push(99);\nprint(a.length);", "rejected": "let a = [7];\na.append(99);\nprint(a.length);"} {"prompt": "Write a Hemlock program that appends a value to an array and prints its length.", "chosen": "let a = [100, 200];\na.push(99);\nprint(a.length);", "rejected": "let a = [100, 200];\na.append(99);\nprint(a.length);"} {"prompt": "Write a Hemlock program that appends a value to an array and prints its length.", "chosen": "let a = [2, 4, 6];\na.push(99);\nprint(a.length);", "rejected": "let a = [2, 4, 6];\na.append(99);\nprint(a.length);"} {"prompt": "Write a Hemlock program with an anonymous function that squares its input; print the square of 4.", "chosen": "let sq = fn(x) { return x * x; };\nprint(sq(4));", "rejected": "let sq = lambda x: x * x;\nprint(sq(4));"} {"prompt": "Write a Hemlock program with an anonymous function that squares its input; print the square of 9.", "chosen": "let sq = fn(x) { return x * x; };\nprint(sq(9));", "rejected": "let sq = lambda x: x * x;\nprint(sq(9));"} {"prompt": "Write a Hemlock program with an anonymous function that squares its input; print the square of 6.", "chosen": "let sq = fn(x) { return x * x; };\nprint(sq(6));", "rejected": "let sq = lambda x: x * x;\nprint(sq(6));"} {"prompt": "Write a Hemlock program with an anonymous function that squares its input; print the square of 3.", "chosen": "let sq = fn(x) { return x * x; };\nprint(sq(3));", "rejected": "let sq = lambda x: x * x;\nprint(sq(3));"} {"prompt": "Write a Hemlock program with an anonymous function that squares its input; print the square of 7.", "chosen": "let sq = fn(x) { return x * x; };\nprint(sq(7));", "rejected": "let sq = lambda x: x * x;\nprint(sq(7));"} {"prompt": "Write a Hemlock program with an anonymous function that squares its input; print the square of 8.", "chosen": "let sq = fn(x) { return x * x; };\nprint(sq(8));", "rejected": "let sq = lambda x: x * x;\nprint(sq(8));"} {"prompt": "Write a Hemlock program with an anonymous function that squares its input; print the square of 5.", "chosen": "let sq = fn(x) { return x * x; };\nprint(sq(5));", "rejected": "let sq = lambda x: x * x;\nprint(sq(5));"} {"prompt": "Write a Hemlock program with an anonymous function that squares its input; print the square of 12.", "chosen": "let sq = fn(x) { return x * x; };\nprint(sq(12));", "rejected": "let sq = lambda x: x * x;\nprint(sq(12));"} {"prompt": "Write a Hemlock program that stores the JSON text [1,2,3] in a string and prints it.", "chosen": "let raw = \"[1,2,3]\";\nprint(raw);", "rejected": "let raw = '[1,2,3]';\nprint(raw);"} {"prompt": "Write a Hemlock program that stores the JSON text [10,20] in a string and prints it.", "chosen": "let raw = \"[10,20]\";\nprint(raw);", "rejected": "let raw = '[10,20]';\nprint(raw);"} {"prompt": "Write a Hemlock program that stores the JSON text [100] in a string and prints it.", "chosen": "let raw = \"[100]\";\nprint(raw);", "rejected": "let raw = '[100]';\nprint(raw);"} {"prompt": "Write a Hemlock program that stores the JSON text [1,2,3,4,5] in a string and prints it.", "chosen": "let raw = \"[1,2,3,4,5]\";\nprint(raw);", "rejected": "let raw = '[1,2,3,4,5]';\nprint(raw);"} {"prompt": "Write a Hemlock program that stores the JSON text [42] in a string and prints it.", "chosen": "let raw = \"[42]\";\nprint(raw);", "rejected": "let raw = '[42]';\nprint(raw);"} {"prompt": "Write a Hemlock program that stores the JSON text [7,8,9] in a string and prints it.", "chosen": "let raw = \"[7,8,9]\";\nprint(raw);", "rejected": "let raw = '[7,8,9]';\nprint(raw);"} {"prompt": "Write a Hemlock program that stores the boolean true and prints it.", "chosen": "let flag = true;\nprint(flag);", "rejected": "let flag = True;\nprint(flag);"} {"prompt": "Write a Hemlock program that stores the boolean false and prints it.", "chosen": "let flag = false;\nprint(flag);", "rejected": "let flag = False;\nprint(flag);"} {"prompt": "Write a Hemlock program that assigns null and prints whether it equals null.", "chosen": "let x = null;\nprint(x == null);", "rejected": "let x = None;\nprint(x == None);"} {"prompt": "Using @stdlib/uuid, write a Hemlock program to use equals(), compare(), and is_nil() to classify relationships between a handful of hard-coded UUID strings.", "chosen": "import { equals, compare, is_nil } from \"@stdlib/uuid\";\n\nlet a = \"550e8400-e29b-41d4-a716-446655440000\";\nlet b = \"550E8400-E29B-41D4-A716-446655440000\";\nlet c = \"00000000-0000-0000-0000-000000000000\";\nlet d = \"6ba7b810-9dad-11d1-80b4-00c04fd430c8\";\n\nprint(`equals(a, b): ${equals(a, b)}`);\nprint(`equals(a, d): ${equals(a, d)}`);\nprint(`compare(a, d): ${compare(a, d)}`);\nprint(`is_nil(c): ${is_nil(c)}`);\nprint(`is_nil(a): ${is_nil(a)}`);", "rejected": "import { equals, compare, is_nil } from \"@stdlib/uuid\";\n\nlet a = \"550e8400-e29b-41d4-a716-446655440000\";\nlet b = \"550E8400-E29B-41D4-A716-446655440000\";\nlet c = \"00000000-0000-0000-0000-000000000000\";\nlet d = \"6ba7b810-9dad-11d1-80b4-00c04fd430c8\";\n\nprintln(`equals(a, b): ${equals(a, b)}`);\nprintln(`equals(a, d): ${equals(a, d)}`);\nprintln(`compare(a, d): ${compare(a, d)}`);\nprintln(`is_nil(c): ${is_nil(c)}`);\nprintln(`is_nil(a): ${is_nil(a)}`);"} {"prompt": "What imports do I need from @stdlib/strings to truncate a list of article titles to 30 characters with '...' suffix and print each? Write the full Hemlock program.", "chosen": "import { truncate } from \"@stdlib/strings\";\n\nlet titles = [\n \"A Short Title\",\n \"This one is medium length here\",\n \"A significantly longer headline that should be clipped when shown in a compact list\"\n];\n\nfor (t in titles) {\n print(truncate(t, 30, \"...\"));\n}", "rejected": "import { truncate } from \"@stdlib/strings\";\n\nlet titles = [\n \"A Short Title\",\n \"This one is medium length here\",\n \"A significantly longer headline that should be clipped when shown in a compact list\"\n];\n\nfor (t in titles) {\n println(truncate(t, 30, \"...\"));\n}"} {"prompt": "Write a Hemlock program to compute the arithmetic mean and population standard deviation of a list of numbers and print each rounded to 2 decimals. Use @stdlib/math.", "chosen": "import { sqrt } from \"@stdlib/math\";\nimport { to_fixed } from \"@stdlib/decimal\";\n\nfn mean(xs: array): f64 {\n let s = 0.0;\n for (x in xs) { s += x; }\n return s / xs.length;\n}\n\nfn stddev(xs: array): f64 {\n let m = mean(xs);\n let sq = 0.0;\n for (x in xs) {\n let d = x - m;\n sq += d * d;\n }\n return sqrt(sq / xs.length);\n}\n\nlet data = [2.0, 4.0, 4.0, 4.0, 5.0, 5.0, 7.0, 9.0];\nprint(`mean=${to_fixed(mean(data), 2)}`);\nprint(`stddev=${to_fixed(stddev(data), 2)}`);", "rejected": "import { sqrt } from \"@stdlib/math\";\nimport { to_fixed } from \"@stdlib/decimal\";\n\nfn mean(xs: array): f64 {\n let s = 0.0;\n for (x in xs) { s += x; }\n return s / xs.length;\n}\n\nfn stddev(xs: array): f64 {\n let m = mean(xs);\n let sq = 0.0;\n for (x in xs) {\n let d = x - m;\n sq += d * d;\n }\n return sqrt(sq / xs.length);\n}\n\nlet data = [2.0, 4.0, 4.0, 4.0, 5.0, 5.0, 7.0, 9.0];\nprintln(`mean=${to_fixed(mean(data), 2)}`);\nprintln(`stddev=${to_fixed(stddev(data), 2)}`);"} {"prompt": "Show the imports and Hemlock code to use replace_all with REG_EXTENDED to collapse runs of spaces into a single space and to replace every digit run with 'NUM', then print both results.", "chosen": "import { replace_all, REG_EXTENDED } from \"@stdlib/regex\";\n\nlet messy = \"hello world foo bar\";\nlet clean = replace_all(\" +\", messy, \" \", REG_EXTENDED);\nprint(clean);\n\nlet cleaned = replace_all(\"[0-9]+\", \"order 123 and 456 done\", \"NUM\", REG_EXTENDED);\nprint(cleaned);", "rejected": "import { replace_all, REG_EXTENDED } from \"@stdlib/regex\";\n\nlet messy = \"hello world foo bar\";\nlet clean = replace_all(\" +\", messy, \" \", REG_EXTENDED);\nprintln(clean);\n\nlet cleaned = replace_all(\"[0-9]+\", \"order 123 and 456 done\", \"NUM\", REG_EXTENDED);\nprintln(cleaned);"} {"prompt": "Show the imports and Hemlock code to count word occurrences in a space-separated string using a hash map, then print each word and its count.", "chosen": "import { HashMap } from \"@stdlib/collections\";\n\nfn word_count(text: string) {\n let counts = HashMap();\n for (w in text.split(\" \")) {\n if (counts.has(w)) {\n counts.set(w, counts.get(w) + 1);\n } else {\n counts.set(w, 1);\n }\n }\n return counts;\n}\n\nlet counts = word_count(\"the quick brown fox the lazy dog the\");\nfor (k in counts.keys()) {\n print(`${k}: ${counts.get(k)}`);\n}", "rejected": "import { HashMap } from \"@stdlib/collections\";\n\nfn word_count(text: string) {\n let counts = HashMap();\n for (w in text.split(\" \")) {\n if (counts.has(w)) {\n counts.set(w, counts.get(w) + 1);\n } else {\n counts.set(w, 1);\n }\n }\n return counts;\n}\n\nlet counts = word_count(\"the quick brown fox the lazy dog the\");\nfor (k in counts.keys()) {\n println(`${k}: ${counts.get(k)}`);\n}"} {"prompt": "In Hemlock (importing from @stdlib/math), seed the RNG to 42, roll ten six-sided dice using floor(rand_range(1.0, 7.0)), print the rolls comma-separated, and print the sum.", "chosen": "import { rand_range, floor, seed } from \"@stdlib/math\";\n\nseed(42);\nlet rolls = [];\nfor (let i = 0; i < 10; i++) {\n rolls.push(floor(rand_range(1.0, 7.0)));\n}\nprint(`rolls: ${rolls.join(\", \")}`);\n\nlet sum = 0;\nfor (r in rolls) { sum += r; }\nprint(`sum: ${sum}`);", "rejected": "import { rand_range, floor, seed } from \"@stdlib/math\";\n\nseed(42);\nlet rolls = [];\nfor (let i = 0; i < 10; i++) {\n rolls.push(floor(rand_range(1.0, 7.0)));\n}\nprintln(`rolls: ${rolls.join(\", \")}`);\n\nlet sum = 0;\nfor (r in rolls) { sum += r; }\nprintln(`sum: ${sum}`);"} {"prompt": "What imports do I need from @stdlib/toml to parse a TOML config with a nested [app.limits] table and read four dotted paths using get()? Write the full Hemlock program.", "chosen": "import { parse, get } from \"@stdlib/toml\";\n\nlet doc = parse(\"[app]\\nname = \\\"hemlock\\\"\\nversion = \\\"2.0.0\\\"\\n\\n[app.limits]\\nmax_users = 1000\\nmax_memory_mb = 512\\n\");\n\nprint(get(doc, \"app.name\"));\nprint(get(doc, \"app.version\"));\nprint(get(doc, \"app.limits.max_users\"));\nprint(get(doc, \"app.limits.max_memory_mb\"));", "rejected": "import { parse, get } from \"@stdlib/toml\";\n\nlet doc = parse(\"[app]\\nname = \\\"hemlock\\\"\\nversion = \\\"2.0.0\\\"\\n\\n[app.limits]\\nmax_users = 1000\\nmax_memory_mb = 512\\n\");\n\nprintln(get(doc, \"app.name\"));\nprintln(get(doc, \"app.version\"));\nprintln(get(doc, \"app.limits.max_users\"));\nprintln(get(doc, \"app.limits.max_memory_mb\"));"} {"prompt": "What imports do I need from @stdlib/decimal to build a CSV document using StringBuilder (sb_new/sb_append/sb_to_string) and print the result? Write the full Hemlock program.", "chosen": "import { sb_new, sb_append, sb_to_string } from \"@stdlib/decimal\";\n\nlet rows = [\n [\"name\", \"age\", \"city\"],\n [\"Alice\", \"30\", \"NYC\"],\n [\"Bob\", \"25\", \"LA\"],\n [\"Charlie\", \"40\", \"Chicago\"]\n];\n\nlet sb = sb_new();\nfor (row in rows) {\n sb_append(sb, row.join(\",\"));\n sb_append(sb, \"\\n\");\n}\nprint(sb_to_string(sb));", "rejected": "import { sb_new, sb_append, sb_to_string } from \"@stdlib/decimal\";\n\nlet rows = [\n [\"name\", \"age\", \"city\"],\n [\"Alice\", \"30\", \"NYC\"],\n [\"Bob\", \"25\", \"LA\"],\n [\"Charlie\", \"40\", \"Chicago\"]\n];\n\nlet sb = sb_new();\nfor (row in rows) {\n sb_append(sb, row.join(\",\"));\n sb_append(sb, \"\\n\");\n}\nprintln(sb_to_string(sb));"} {"prompt": "In Hemlock, parse a compact JSON config string and print it pretty-printed with 2-space indentation.", "chosen": "import { parse, pretty } from \"@stdlib/json\";\n\nlet raw = \"{\\\"server\\\":{\\\"host\\\":\\\"localhost\\\",\\\"port\\\":8080},\\\"features\\\":[\\\"auth\\\",\\\"logging\\\"]}\";\nlet cfg = parse(raw);\nprint(pretty(cfg, 2));", "rejected": "import { parse, pretty } from \"@stdlib/json\";\n\nlet raw = \"{\\\"server\\\":{\\\"host\\\":\\\"localhost\\\",\\\"port\\\":8080},\\\"features\\\":[\\\"auth\\\",\\\"logging\\\"]}\";\nlet cfg = parse(raw);\nprintln(pretty(cfg, 2));"} {"prompt": "In Hemlock (importing from @stdlib/math), print floor, ceil, round, and trunc of a handful of positive and negative decimals so the difference between the four modes is visible.", "chosen": "import { floor, ceil, round, trunc } from \"@stdlib/math\";\n\nlet values = [2.3, 2.5, 2.7, -2.3, -2.5, -2.7];\nfor (v in values) {\n print(`${v}: floor=${floor(v)} ceil=${ceil(v)} round=${round(v)} trunc=${trunc(v)}`);\n}", "rejected": "import { floor, ceil, round, trunc } from \"@stdlib/math\";\n\nlet values = [2.3, 2.5, 2.7, -2.3, -2.5, -2.7];\nfor (v in values) {\n println(`${v}: floor=${floor(v)} ceil=${ceil(v)} round=${round(v)} trunc=${trunc(v)}`);\n}"} {"prompt": "Solve this in Hemlock: use test() with REG_EXTENDED to validate a few candidate email addresses against a pattern and print true/false for each.", "chosen": "import { test, REG_EXTENDED } from \"@stdlib/regex\";\n\nlet pattern = \"^[a-zA-Z0-9._+-]+@[a-zA-Z0-9.-]+\\\\.[a-zA-Z]{2,}$\";\nlet inputs = [\n \"alice@example.com\",\n \"bob.smith+tag@mail.co\",\n \"not-an-email\",\n \"missing@tld\",\n \"@nope.com\"\n];\n\nfor (addr in inputs) {\n print(`${addr} -> ${test(pattern, addr, REG_EXTENDED)}`);\n}", "rejected": "import { test, REG_EXTENDED } from \"@stdlib/regex\";\n\nlet pattern = \"^[a-zA-Z0-9._+-]+@[a-zA-Z0-9.-]+\\\\.[a-zA-Z]{2,}$\";\nlet inputs = [\n \"alice@example.com\",\n \"bob.smith+tag@mail.co\",\n \"not-an-email\",\n \"missing@tld\",\n \"@nope.com\"\n];\n\nfor (addr in inputs) {\n println(`${addr} -> ${test(pattern, addr, REG_EXTENDED)}`);\n}"} {"prompt": "Show the imports and Hemlock code to parse a CSV string into rows, print each row joined with ' | ', then re-serialize with stringify().", "chosen": "import { parse, stringify } from \"@stdlib/csv\";\n\nlet text = \"name,age,city\\nAlice,30,NYC\\nBob,25,LA\\nCharlie,40,Chicago\";\nlet rows = parse(text);\n\nprint(`rows: ${rows.length}`);\nfor (row in rows) {\n print(row.join(\" | \"));\n}\n\nprint(\"--- re-serialized ---\");\nprint(stringify(rows));", "rejected": "import { parse, stringify } from \"@stdlib/csv\";\n\nlet text = \"name,age,city\\nAlice,30,NYC\\nBob,25,LA\\nCharlie,40,Chicago\";\nlet rows = parse(text);\n\nprintln(`rows: ${rows.length}`);\nfor (row in rows) {\n println(row.join(\" | \"));\n}\n\nprintln(\"--- re-serialized ---\");\nprintln(stringify(rows));"} {"prompt": "Show the imports and Hemlock code to normalize a handful of messy paths (redundant slashes, '..' and '.') using normalize() and also print is_absolute() for each.", "chosen": "import { normalize, is_absolute } from \"@stdlib/path\";\n\nlet paths = [\n \"/a/b/../c/./d\",\n \"./foo/bar\",\n \"/usr//local///bin\",\n \"/tmp/\"\n];\n\nfor (p in paths) {\n print(`${p} -> ${normalize(p)} (absolute=${is_absolute(p)})`);\n}", "rejected": "import { normalize, is_absolute } from \"@stdlib/path\";\n\nlet paths = [\n \"/a/b/../c/./d\",\n \"./foo/bar\",\n \"/usr//local///bin\",\n \"/tmp/\"\n];\n\nfor (p in paths) {\n println(`${p} -> ${normalize(p)} (absolute=${is_absolute(p)})`);\n}"} {"prompt": "Show the imports and Hemlock code to starting from 2026-01-01, compute dates +7 days, +30 days, and +365 days using add_days, then print diff_days between first and last.", "chosen": "import { from_date } from \"@stdlib/datetime\";\n\nlet start = from_date(2026, 1, 1);\nlet week = start.add_days(7);\nlet month = start.add_days(30);\nlet year = start.add_days(365);\n\nprint(`start: ${start.to_date_string()}`);\nprint(`+7d: ${week.to_date_string()}`);\nprint(`+30d: ${month.to_date_string()}`);\nprint(`+365d: ${year.to_date_string()}`);\nprint(`days between start and +365d: ${year.diff_days(start)}`);", "rejected": "import { from_date } from \"@stdlib/datetime\";\n\nlet start = from_date(2026, 1, 1);\nlet week = start.add_days(7);\nlet month = start.add_days(30);\nlet year = start.add_days(365);\n\nprintln(`start: ${start.to_date_string()}`);\nprintln(`+7d: ${week.to_date_string()}`);\nprintln(`+30d: ${month.to_date_string()}`);\nprintln(`+365d: ${year.to_date_string()}`);\nprintln(`days between start and +365d: ${year.diff_days(start)}`);"} {"prompt": "In Hemlock, build a playlist in a LinkedList using append, prepend, and insert; iterate by index to print each item; print contains/index_of checks; then remove the head, reverse in place, and print the final order.", "chosen": "import { LinkedList } from \"@stdlib/collections\";\n\nlet playlist = LinkedList();\nplaylist.append(\"intro\");\nplaylist.append(\"verse\");\nplaylist.append(\"outro\");\nplaylist.insert(2, \"chorus\");\nplaylist.prepend(\"silence\");\n\nprint(`size: ${playlist.size}`);\nfor (let i = 0; i < playlist.size; i++) {\n print(`${i}: ${playlist.get(i)}`);\n}\n\nprint(`contains chorus: ${playlist.contains(\"chorus\")}`);\nprint(`index of outro: ${playlist.index_of(\"outro\")}`);\n\nplaylist.remove(0);\nplaylist.reverse();\nprint(`reversed: ${playlist.to_array().join(\" -> \")}`);", "rejected": "import { LinkedList } from \"@stdlib/collections\";\n\nlet playlist = LinkedList();\nplaylist.append(\"intro\");\nplaylist.append(\"verse\");\nplaylist.append(\"outro\");\nplaylist.insert(2, \"chorus\");\nplaylist.prepend(\"silence\");\n\nprint(`size: ${playlist.size}`);\nfor (let i = 0; i < playlist.size; i++) {\n print(`${i}: ${playlist.get(i)}`);\n}\n\nprint(`contains chorus: ${playlist.includes(\"chorus\")}`);\nprint(`index of outro: ${playlist.index_of(\"outro\")}`);\n\nplaylist.remove(0);\nplaylist.reverse();\nprint(`reversed: ${playlist.to_array().join(\" -> \")}`);"} {"prompt": "What imports do I need from @stdlib/args to parse a synthetic argv like ['script.hml', 'build', '--verbose', '--output', 'out.txt', 'src/main.hml'] and print the flag, an option with default, and the positionals? Write the full Hemlock program.", "chosen": "import { parse, has_flag, get_option, get_positionals } from \"@stdlib/args\";\n\nlet argv = [\"script.hml\", \"build\", \"--verbose\", \"--output\", \"out.txt\", \"src/main.hml\"];\nlet parsed = parse(argv);\n\nprint(`verbose: ${has_flag(parsed, \"verbose\")}`);\nprint(`output: ${get_option(parsed, \"output\", \"default.txt\")}`);\nprint(`target: ${get_option(parsed, \"target\", \"debug\")}`);\nprint(`positionals: ${get_positionals(parsed).join(\", \")}`);", "rejected": "import { parse, has_flag, get_option, get_positionals } from \"@stdlib/args\";\n\nlet argv = [\"script.hml\", \"build\", \"--verbose\", \"--output\", \"out.txt\", \"src/main.hml\"];\nlet parsed = loads(argv);\n\nprint(`verbose: ${has_flag(parsed, \"verbose\")}`);\nprint(`output: ${get_option(parsed, \"output\", \"default.txt\")}`);\nprint(`target: ${get_option(parsed, \"target\", \"debug\")}`);\nprint(`positionals: ${get_positionals(parsed).join(\", \")}`);"} {"prompt": "Solve this in Hemlock: parse a full filesystem path into {root, dir, base, name, ext} components, print each field, and reassemble via format().", "chosen": "import { parse, format } from \"@stdlib/path\";\n\nlet p = parse(\"/home/alice/docs/report.pdf\");\nprint(`root: ${p.root}`);\nprint(`dir: ${p.dir}`);\nprint(`base: ${p.base}`);\nprint(`name: ${p.name}`);\nprint(`ext: ${p.ext}`);\n\nlet rebuilt = format(p);\nprint(`rebuilt: ${rebuilt}`);", "rejected": "import { parse, format } from \"@stdlib/path\";\n\nlet p = loads(\"/home/alice/docs/report.pdf\");\nprint(`root: ${p.root}`);\nprint(`dir: ${p.dir}`);\nprint(`base: ${p.base}`);\nprint(`name: ${p.name}`);\nprint(`ext: ${p.ext}`);\n\nlet rebuilt = format(p);\nprint(`rebuilt: ${rebuilt}`);"} {"prompt": "In Hemlock (importing from @stdlib/collections), build a LinkedList, Queue, and Stack; call to_array() on each and pipe the result through array sort/map/filter/reverse, printing each transformed result.", "chosen": "import { LinkedList, Queue, Stack } from \"@stdlib/collections\";\n\nlet ll = LinkedList();\nll.append(3); ll.append(1); ll.append(4); ll.append(1); ll.append(5);\n\nlet sorted = ll.to_array();\nsorted.sort();\nprint(`sorted: ${sorted.join(\",\")}`);\n\nlet doubled = ll.to_array().map(fn(x) { return x * 2; });\nprint(`doubled: ${doubled.join(\",\")}`);\n\nlet q = Queue();\nq.enqueue(10); q.enqueue(25); q.enqueue(4); q.enqueue(99); q.enqueue(17);\nlet big = q.to_array().filter(fn(x) { return x > 20; });\nprint(`filtered: ${big.join(\",\")}`);\n\nlet s = Stack();\ns.push(\"a\"); s.push(\"b\"); s.push(\"c\");\nlet reversed = s.to_array();\nreversed.reverse();\nprint(`stack reversed: ${reversed.join(\",\")}`);", "rejected": "import { LinkedList, Queue, Stack } from \"@stdlib/collections\";\n\nlet ll = LinkedList();\nll.append(3); ll.append(1); ll.append(4); ll.append(1); ll.append(5);\n\nlet sorted = ll.to_array();\nsorted.sort();\nprint(`sorted: ${sorted.join(\",\")}`);\n\nlet doubled = ll.to_array().map(fn(x) { return x * 2; });\nprint(`doubled: ${doubled.join(\",\")}`);\n\nlet q = Queue();\nq.enqueue(10); q.enqueue(25); q.enqueue(4); q.enqueue(99); q.enqueue(17);\nlet big = q.to_array().filter(fn(x) { return x > 20; });\nprint(`filtered: ${big.join(\",\")}`);\n\nlet s = Stack();\ns.append(\"a\"); s.append(\"b\"); s.append(\"c\");\nlet reversed = s.to_array();\nreversed.reverse();\nprint(`stack reversed: ${reversed.join(\",\")}`);"} {"prompt": "Solve this in Hemlock: parse a CSV of users into objects, filter rows where status is 'active', and re-emit them using stringify_objects().", "chosen": "import { parse_objects, stringify_objects } from \"@stdlib/csv\";\n\nlet text = \"user,status\\nalice,active\\nbob,inactive\\ncarol,active\\ndave,banned\";\nlet users = parse_objects(text);\n\nlet active = [];\nfor (u in users) {\n if (u.status == \"active\") { active.push(u); }\n}\n\nprint(`active: ${active.length}`);\nprint(stringify_objects(active, [\"user\", \"status\"]));", "rejected": "import { parse_objects, stringify_objects } from \"@stdlib/csv\";\n\nlet text = \"user,status\\nalice,active\\nbob,inactive\\ncarol,active\\ndave,banned\";\nlet users = parse_objects(text);\n\nlet active = [];\nfor (u in users) {\n if (u.status == \"active\") { active.append(u); }\n}\n\nprint(`active: ${active.length}`);\nprint(stringify_objects(active, [\"user\", \"status\"]));"} {"prompt": "Show the imports and Hemlock code to use a Stack to check whether several bracket expressions are balanced and print true/false for each.", "chosen": "import { Stack } from \"@stdlib/collections\";\n\nfn matches(open: rune, close: rune): bool {\n if (open == '(' && close == ')') { return true; }\n if (open == '[' && close == ']') { return true; }\n if (open == '{' && close == '}') { return true; }\n return false;\n}\n\nfn balanced(expr: string): bool {\n let s = Stack();\n for (let i = 0; i < expr.length; i++) {\n let ch = expr.char_at(i);\n if (ch == '(' || ch == '[' || ch == '{') {\n s.push(ch);\n } else if (ch == ')' || ch == ']' || ch == '}') {\n if (s.is_empty() || !matches(s.pop(), ch)) { return false; }\n }\n }\n return s.is_empty();\n}\n\nlet tests = [\"()\", \"([]{})\", \"(]\", \"((())\", \"{[()]}\", \"\"];\nfor (t in tests) {\n print(`\"${t}\" -> ${balanced(t)}`);\n}", "rejected": "import { Stack } from \"@stdlib/collections\";\n\nfn matches(open: rune, close: rune): bool {\n if (open == '(' && close == ')') { return true; }\n if (open == '[' && close == ']') { return true; }\n if (open == '{' && close == '}') { return true; }\n return false;\n}\n\nfn balanced(expr: string): bool {\n let s = Stack();\n for (let i = 0; i < expr.length; i++) {\n let ch = expr.char_at(i);\n if (ch == '(' || ch == '[' || ch == '{') {\n s.append(ch);\n } else if (ch == ')' || ch == ']' || ch == '}') {\n if (s.is_empty() || !matches(s.pop(), ch)) { return false; }\n }\n }\n return s.is_empty();\n}\n\nlet tests = [\"()\", \"([]{})\", \"(]\", \"((())\", \"{[()]}\", \"\"];\nfor (t in tests) {\n print(`\"${t}\" -> ${balanced(t)}`);\n}"} {"prompt": "Solve this in Hemlock: parse three version strings into objects, print their components, then use compare() to order a few pairs.", "chosen": "import { parse, compare } from \"@stdlib/semver\";\n\nlet v1 = parse(\"1.2.3\");\nlet v2 = parse(\"2.0.0-rc.1\");\nlet v3 = parse(\"1.2.3-beta+build.42\");\n\nprint(`v1: major=${v1.major} minor=${v1.minor} patch=${v1.patch}`);\nprint(`v2: major=${v2.major} prerelease=${v2.prerelease}`);\nprint(`v3: build=${v3.build}`);\n\nprint(`compare(1.2.3, 2.0.0-rc.1): ${compare(\"1.2.3\", \"2.0.0-rc.1\")}`);\nprint(`compare(2.0.0, 2.0.0): ${compare(\"2.0.0\", \"2.0.0\")}`);\nprint(`compare(2.0.0-rc.1, 2.0.0): ${compare(\"2.0.0-rc.1\", \"2.0.0\")}`);", "rejected": "import { parse, compare } from \"@stdlib/semver\";\n\nlet v1 = loads(\"1.2.3\");\nlet v2 = loads(\"2.0.0-rc.1\");\nlet v3 = loads(\"1.2.3-beta+build.42\");\n\nprint(`v1: major=${v1.major} minor=${v1.minor} patch=${v1.patch}`);\nprint(`v2: major=${v2.major} prerelease=${v2.prerelease}`);\nprint(`v3: build=${v3.build}`);\n\nprint(`compare(1.2.3, 2.0.0-rc.1): ${compare(\"1.2.3\", \"2.0.0-rc.1\")}`);\nprint(`compare(2.0.0, 2.0.0): ${compare(\"2.0.0\", \"2.0.0\")}`);\nprint(`compare(2.0.0-rc.1, 2.0.0): ${compare(\"2.0.0-rc.1\", \"2.0.0\")}`);"} {"prompt": "Show the imports and Hemlock code to parse a TOML document with a top-level key and two tables, print a summary, then re-serialize it.", "chosen": "import { parse, stringify } from \"@stdlib/toml\";\n\nlet input = \"title = \\\"Example\\\"\\n\\n[owner]\\nname = \\\"Alice\\\"\\nage = 30\\n\\n[database]\\nserver = \\\"localhost\\\"\\nport = 8001\\n\";\nlet doc = parse(input);\n\nprint(`title: ${doc.title}`);\nprint(`owner: ${doc.owner.name} (age ${doc.owner.age})`);\nprint(`server: ${doc.database.server}:${doc.database.port}`);\nprint(\"---\");\nprint(stringify(doc));", "rejected": "import { parse, stringify } from \"@stdlib/toml\";\n\nlet input = \"title = \\\"Example\\\"\\n\\n[owner]\\nname = \\\"Alice\\\"\\nage = 30\\n\\n[database]\\nserver = \\\"localhost\\\"\\nport = 8001\\n\";\nlet doc = loads(input);\n\nprint(`title: ${doc.title}`);\nprint(`owner: ${doc.owner.name} (age ${doc.owner.age})`);\nprint(`server: ${doc.database.server}:${doc.database.port}`);\nprint(\"---\");\nprint(stringify(doc));"} {"prompt": "Solve this in Hemlock: url-encode a list of query-parameter key/value pairs and print them joined as a single URL query string.", "chosen": "import { url_encode } from \"@stdlib/encoding\";\n\nlet params = [\n { key: \"q\", value: \"hello world\" },\n { key: \"lang\", value: \"en-US\" },\n { key: \"email\", value: \"a+b@example.com\" }\n];\n\nlet parts = [];\nfor (p in params) {\n parts.push(`${url_encode(p.key)}=${url_encode(p.value)}`);\n}\nprint(`?${parts.join(\"&\")}`);", "rejected": "import { url_encode } from \"@stdlib/encoding\";\n\nlet params = [\n { key: \"q\", value: \"hello world\" },\n { key: \"lang\", value: \"en-US\" },\n { key: \"email\", value: \"a+b@example.com\" }\n];\n\nlet parts = [];\nfor (p in params) {\n parts.append(`${url_encode(p.key)}=${url_encode(p.value)}`);\n}\nprint(`?${parts.join(\"&\")}`);"} {"prompt": "Solve this in Hemlock: set_seed(12345) and print five randint(1,100) values, a choice from a color list, and a sample of 3.", "chosen": "import { set_seed, randint, choice, sample } from \"@stdlib/random\";\n\nset_seed(12345);\n\nlet rolls = [];\nfor (let i = 0; i < 5; i++) { rolls.push(randint(1, 100)); }\nprint(`randint: ${rolls.join(\", \")}`);\n\nlet colors = [\"red\", \"green\", \"blue\", \"yellow\", \"purple\"];\nprint(`choice: ${choice(colors)}`);\nprint(`sample: ${sample(colors, 3).join(\", \")}`);", "rejected": "import { set_seed, randint, choice, sample } from \"@stdlib/random\";\n\nset_seed(12345);\n\nlet rolls = [];\nfor (let i = 0; i < 5; i++) { rolls.append(randint(1, 100)); }\nprint(`randint: ${rolls.join(\", \")}`);\n\nlet colors = [\"red\", \"green\", \"blue\", \"yellow\", \"purple\"];\nprint(`choice: ${choice(colors)}`);\nprint(`sample: ${sample(colors, 3).join(\", \")}`);"} {"prompt": "In Hemlock, parse a nested YAML document and read three dotted paths with get().", "chosen": "import { parse, get } from \"@stdlib/yaml\";\n\nlet doc = parse(\"database:\\n host: db.local\\n credentials:\\n user: admin\\n pass: secret\\nretries: 3\\n\");\n\nprint(get(doc, \"database.host\"));\nprint(get(doc, \"database.credentials.user\"));\nprint(get(doc, \"retries\"));", "rejected": "import { parse, get } from \"@stdlib/yaml\";\n\nlet doc = loads(\"database:\\n host: db.local\\n credentials:\\n user: admin\\n pass: secret\\nretries: 3\\n\");\n\nprint(get(doc, \"database.host\"));\nprint(get(doc, \"database.credentials.user\"));\nprint(get(doc, \"retries\"));"} {"prompt": "Solve this in Hemlock: apply three deep updates to a parsed JSON document using set() (nested object field, array index, and a second-level field), then print the re-serialized JSON.", "chosen": "import { parse, stringify, set } from \"@stdlib/json\";\n\nlet doc = parse(\"{\\\"user\\\":{\\\"name\\\":\\\"Alice\\\",\\\"settings\\\":{\\\"theme\\\":\\\"light\\\"}},\\\"counts\\\":[1,2,3]}\");\n\nset(doc, \"user.name\", \"Bob\");\nset(doc, \"user.settings.theme\", \"dark\");\nset(doc, \"counts.1\", 99);\n\nprint(stringify(doc));", "rejected": "import { parse, stringify, set } from \"@stdlib/json\";\n\nlet doc = loads(\"{\\\"user\\\":{\\\"name\\\":\\\"Alice\\\",\\\"settings\\\":{\\\"theme\\\":\\\"light\\\"}},\\\"counts\\\":[1,2,3]}\");\n\nset(doc, \"user.name\", \"Bob\");\nset(doc, \"user.settings.theme\", \"dark\");\nset(doc, \"counts.1\", 99);\n\nprint(stringify(doc));"} {"prompt": "Solve this in Hemlock: parse a full URL with userinfo, port, path, query, and fragment using parse(), then print each component.", "chosen": "import { parse } from \"@stdlib/url\";\n\nlet u = parse(\"https://user:pass@example.com:8080/api/v2/users?limit=10&sort=name#top\");\n\nprint(`scheme: ${u.scheme}`);\nprint(`host: ${u.host}`);\nprint(`port: ${u.port}`);\nprint(`path: ${u.path}`);\nprint(`query: ${u.query}`);\nprint(`fragment: ${u.fragment}`);", "rejected": "import { parse } from \"@stdlib/url\";\n\nlet u = loads(\"https://user:pass@example.com:8080/api/v2/users?limit=10&sort=name#top\");\n\nprint(`scheme: ${u.scheme}`);\nprint(`host: ${u.host}`);\nprint(`port: ${u.port}`);\nprint(`path: ${u.path}`);\nprint(`query: ${u.query}`);\nprint(`fragment: ${u.fragment}`);"} {"prompt": "Using @stdlib/json, write a Hemlock program to spread an overrides object over a defaults object to produce a merged configuration, then print the merged JSON.", "chosen": "import { stringify } from \"@stdlib/json\";\n\nlet defaults = { host: \"localhost\", port: 8080, debug: false, retries: 3 };\nlet overrides = { port: 9000, debug: true };\nlet merged = { ...defaults, ...overrides };\n\nprint(stringify(merged));", "rejected": "import { stringify } from \"@stdlib/json\";\n\nlet defaults = { host: \"localhost\", port: 8080, debug: false, retries: 3 };\nlet overrides = { port: 9000, debug: true };\nlet merged = { ...defaults, ...overrides };\n\nprint(dumps(merged));"} {"prompt": "What imports do I need from @stdlib/csv to parse a CSV and sum the values of a numeric column using get_column() and parse_int()? Write the full Hemlock program.", "chosen": "import { parse, get_column } from \"@stdlib/csv\";\nimport { parse_int } from \"@stdlib/decimal\";\n\nlet text = \"item,qty,price\\napple,10,1\\nbread,3,4\\nmilk,6,2\";\nlet rows = parse(text);\n\nlet qty_col = get_column(rows, 1);\nlet total = 0;\nfor (let i = 1; i < qty_col.length; i++) {\n total += parse_int(qty_col[i], 10);\n}\nprint(`header: ${qty_col[0]}`);\nprint(`total qty: ${total}`);", "rejected": "import { parse, get_column } from \"@stdlib/csv\";\nimport { parse_int } from \"@stdlib/decimal\";\n\nlet text = \"item,qty,price\\napple,10,1\\nbread,3,4\\nmilk,6,2\";\nlet rows = loads(text);\n\nlet qty_col = get_column(rows, 1);\nlet total = 0;\nfor (let i = 1; i < qty_col.length; i++) {\n total += parse_int(qty_col[i], 10);\n}\nprint(`header: ${qty_col[0]}`);\nprint(`total qty: ${total}`);"} {"prompt": "What imports do I need from @stdlib/json to parse a JSON array of order records and print the count, total amount, and max amount formatted to 2 decimals? Write the full Hemlock program.", "chosen": "import { parse } from \"@stdlib/json\";\nimport { to_fixed } from \"@stdlib/decimal\";\n\nlet raw = \"[{\\\"id\\\":1,\\\"amount\\\":19.99},{\\\"id\\\":2,\\\"amount\\\":5.50},{\\\"id\\\":3,\\\"amount\\\":42.00},{\\\"id\\\":4,\\\"amount\\\":8.25}]\";\nlet orders = parse(raw);\n\nlet total = 0.0;\nlet max_amount = 0.0;\nfor (o in orders) {\n total += o.amount;\n if (o.amount > max_amount) { max_amount = o.amount; }\n}\n\nprint(`orders: ${orders.length}`);\nprint(`total: $${to_fixed(total, 2)}`);\nprint(`max: $${to_fixed(max_amount, 2)}`);", "rejected": "import { parse } from \"@stdlib/json\";\nimport { to_fixed } from \"@stdlib/decimal\";\n\nlet raw = \"[{\\\"id\\\":1,\\\"amount\\\":19.99},{\\\"id\\\":2,\\\"amount\\\":5.50},{\\\"id\\\":3,\\\"amount\\\":42.00},{\\\"id\\\":4,\\\"amount\\\":8.25}]\";\nlet orders = loads(raw);\n\nlet total = 0.0;\nlet max_amount = 0.0;\nfor (o in orders) {\n total += o.amount;\n if (o.amount > max_amount) { max_amount = o.amount; }\n}\n\nprint(`orders: ${orders.length}`);\nprint(`total: $${to_fixed(total, 2)}`);\nprint(`max: $${to_fixed(max_amount, 2)}`);"} {"prompt": "Show the imports and Hemlock code to parse a JSON user record, increment the age field, append a tag to the tags array, and print the re-serialized JSON.", "chosen": "import { parse, stringify } from \"@stdlib/json\";\n\nlet input = \"{\\\"name\\\":\\\"alice\\\",\\\"age\\\":30,\\\"tags\\\":[\\\"admin\\\",\\\"ops\\\"]}\";\nlet obj = parse(input);\nobj.age = obj.age + 1;\nobj.tags.push(\"active\");\nprint(stringify(obj));", "rejected": "import { parse, stringify } from \"@stdlib/json\";\n\nlet input = \"{\\\"name\\\":\\\"alice\\\",\\\"age\\\":30,\\\"tags\\\":[\\\"admin\\\",\\\"ops\\\"]}\";\nlet obj = parse(input);\nobj.age = obj.age + 1;\nobj.tags.append(\"active\");\nprint(stringify(obj));"} {"prompt": "In Hemlock (importing from @stdlib/yaml), parse a small YAML config (server block + features list), print a few fields, then re-emit it with stringify().", "chosen": "import { parse, stringify } from \"@stdlib/yaml\";\n\nlet input = \"server:\\n host: localhost\\n port: 8080\\nfeatures:\\n - auth\\n - logging\\n\";\nlet cfg = parse(input);\n\nprint(`host: ${cfg.server.host}`);\nprint(`port: ${cfg.server.port}`);\nprint(`features: ${cfg.features.join(\", \")}`);\nprint(\"---\");\nprint(stringify(cfg));", "rejected": "import { parse, stringify } from \"@stdlib/yaml\";\n\nlet input = \"server:\\n host: localhost\\n port: 8080\\nfeatures:\\n - auth\\n - logging\\n\";\nlet cfg = loads(input);\n\nprint(`host: ${cfg.server.host}`);\nprint(`port: ${cfg.server.port}`);\nprint(`features: ${cfg.features.join(\", \")}`);\nprint(\"---\");\nprint(stringify(cfg));"}