Rewrite intercalate in a more direct way

[ethercrow]

One thing that seems suspicious was that there's supposedly efficient intercalateWithByte, but it only works on two strings.

This PR takes the approach from intercalateWithByte to intercalate. Unfortunately there are not any benchmarks for either function so I don't know where the performance claims of intercalateWithByte come from.

[Bodigrim]

A related, but more general question is whether concat implementation makes sense in modern environment:

bytestring/Data/ByteString/Internal.hs

Lines 663 to 705 in b701111

	concat :: [ByteString] -> ByteString
	concat = \bss0 -> goLen0 bss0 bss0
	-- The idea here is we first do a pass over the input list to determine:
	--
	-- 1. is a copy necessary? e.g. @concat []@, @concat [mempty, "hello"]@,
	-- and @concat ["hello", mempty, mempty]@ can all be handled without
	-- copying.
	-- 2. if a copy is necessary, how large is the result going to be?
	--
	-- If a copy is necessary then we create a buffer of the appropriate size
	-- and do another pass over the input list, copying the chunks into the
	-- buffer. Also, since foreign calls aren't entirely free we skip over
	-- empty chunks while copying.
	--
	-- We pass the original [ByteString] (bss0) through as an argument through
	-- goLen0, goLen1, and goLen since we will need it again in goCopy. Passing
	-- it as an explicit argument avoids capturing it in these functions'
	-- closures which would result in unnecessary closure allocation.
	where
	-- It's still possible that the result is empty
	goLen0 _ [] = mempty
	goLen0 bss0 (BS _ 0 :bss) = goLen0 bss0 bss
	goLen0 bss0 (bs :bss) = goLen1 bss0 bs bss
	-- It's still possible that the result is a single chunk
	goLen1 _ bs [] = bs
	goLen1 bss0 bs (BS _ 0 :bss) = goLen1 bss0 bs bss
	goLen1 bss0 bs (BS _ len:bss) = goLen bss0 (checkedAdd "concat" len' len) bss
	where BS _ len' = bs
	-- General case, just find the total length we'll need
	goLen bss0 !total (BS _ len:bss) = goLen bss0 total' bss
	where total' = checkedAdd "concat" total len
	goLen bss0 total [] =
	unsafeCreate total $ \ptr -> goCopy bss0 ptr
	-- Copy the data
	goCopy [] !_ = return ()
	goCopy (BS _ 0 :bss) !ptr = goCopy bss ptr
	goCopy (BS fp len:bss) !ptr = do
	unsafeWithForeignPtr fp $ \p -> memcpy ptr p len
	goCopy bss (ptr `plusPtr` len)
	{-# NOINLINE concat #-}

I suspect that the reasoning to thread bss0 through all recursive calls is invalid since join points' advent. Also filtering out empty elements strikes me as a very ad-hoc optimization, which is more likely to hurt than to help in a general case.

[Bodigrim]

camelCase please.

[Bodigrim]

Please adorn fromIntegral with type applications, explaining what kind of conversion is going on, e. g., fromIntegral @Int @CInt.

[ethercrow]

Looks like quite a few of those were redundant in that file, I've removed them.

[ethercrow]

Before / After

[sjakobi]

Cheers!