A wrapper around `Http.Fetch` that's a bit nicer for using in the Par playground.

fetch.par

dec Fetch : [String, String, List<(String) String>, String]
	Result<Http.Error, (Nat, List<(String) String>) List<Result<Http.Error, String>>>
def Fetch = [method, url, headers, body] chan yield {
	catch e => { yield <> .err e }

	let try url = Url.FromString(url)
	let req = (method, url, headers) Bytes.Reader(body)
	let try (status, headers) body = Http.Fetch(req)
	let headers = ToStringHeaders(headers)
	let body = ToLines(type Http.Error)(body)

	yield <> .ok (status, headers) body
}

dec ToStringHeaders : [List<(String) Bytes>] List<(String) String>
def ToStringHeaders = [headers] headers.begin.case {
	.end! => .end!,
	.item((name) val) next => .item((name) String.FromBytes(val)) next.loop,
}

// Unfortunately, it seems that local type aliases aren't possible at the moment.
type ToLines.ParserResult<e> =
	(dual List<Result<e, String>>)
	Result<e, Option<String.Parser<e>>>

dec ToLines : [type e] [Bytes.Reader<e>] List<Result<e, String>>
def ToLines = [type e] [r] chan yield {
	catch e: e => {
		yield.item(.err e)
		yield.end!
	}

	let parser = String.ParserFromReader(type e)(r)
	let result: ToLines.ParserResult<e> = parser.begin.match(.repeat.one.any!, .str "\n").case {
		.end r => r.case {
			.err e => (yield) .err e,
			.ok! => (yield) .ok .err!,
		},
		.fail parser => parser.remainder.case {
			.err e => (yield) .err e,
			.ok line => do {
				yield.item(.ok line)
			} in (yield) .ok .err!,
		},
		.match(line, _) parser => do {
			yield.item(.ok line)
			let (yield) parser = parser.loop
		} in (yield) parser,
	}

	let (yield) try parser = result
	parser.case {
		.err! => {},
		.ok parser => { parser.close.try },
	}
	yield.end!
}