An One-liner base64 encoder -Non typed version-

tinyBase64NonTyped.d

import std.algorithm,
       std.string,
       std.ascii,
       std.range,
       std.conv;
import std.stdio;

R delegate(Args) Z(R, Args...)(R delegate(R delegate(Args), Args) f){
  return (Args args) => f(Z(f), args);
}

void main() {
  (data =>
    (convb =>
      (table =>
        (converted =>
          (clen =>
            (padded =>
              (plen =>
                (filled =>
                  (flen =>
                    (datasets =>
                      (dlen => 
                        (dlen / 4).iota.map!(i =>
                          4.iota.map!(j => table[datasets[i * 4 + j]]).join
                        ).join ~
                          (dlen % 4 == 0 ? string.init 
                            : datasets[((dlen / 4) * 4 - (data.length > 1 ? 1: 0))..$].map!(e => table[e]).join ~ repeat("=", 4 - dlen % 4 - (data.length > 1 ? 1 : 0)).join)
                      )(datasets.length)
                    )((flen / 6).iota.map!(i => filled[(i * 6)..((i + 1) * 6)]).array)
                  )(filled.length)
                )(plen % 6 == 0 ? padded.join : (padded ~ repeat("0", 6 - plen % 6).join).join)
              )(padded.length)
            )((clen / 6).iota.map!(i => converted[(i * 6)..((i + 1) * 6)].join).array
              ~ ((clen % 6 == 0) ? string.init : (j => converted[(j * 6)..$].join)(clen / 6)))
            )(converted.length)
          )(data.map!(i => 
            (e => e.length == 8 ? e : repeat("0", 8 - e.length).join ~ e)(convb(i, 2))).array)
          )((charset => 
            assocArray(
              zip(
                charset.length.iota.map!(i =>
                  (e =>
                   e.length == 6 ? e : repeat("0", 6 - e.length).join ~ e
                  )(convb(i, 2))),
                charset))
            )((uppercase ~ lowercase ~ digits ~ "+/").split(string.init))
          )
    )((ulong N, int base) =>
      (convbM =>
        convbM(N, N, [], base)
      )(Z((string delegate(ulong, ulong, ulong[], int base) convbM, ulong N, ulong tmp, ulong[] stack, int base) =>
          tmp ? convbM(N, tmp / base, stack ~ (tmp % base), base) : stack.reverse.map!(e => e.to!string).join)))
  )("base64").writeln;//YmFzZTY01
}