void setup() {
  Serial.begin(9600);
}

void loop() {}

sketch.ino

diagram.json

# Wokwi Library List
# See https://docs.wokwi.com/guides/libraries

libraries.txt

#pragma once


inline void mPrint(Stream&) {}

template <class H, class... Tail> void mPrint(Stream& stream, H const head, Tail const... tail) {
  stream.print(head);
  mPrint(stream, tail...);
}

template <class... Args> void mPrintln(Stream& stream, Args const... args) {
  mPrint(stream, args..., "\r\n");
}

/* Example.
mPrintln(Serial, "This would normally take ", 3, " lines.");
*/

mprint.h

#pragma once


template <class T> String show(T const) {
  String s(__PRETTY_FUNCTION__);

  return s.substring(25, s.length() - 1);
}

/* Example.
Serial.println(show(analogRead));
*/

show.h

#pragma once


template <class T, size_t n> size_t arraySize(T const (&)[n]) { return n; }

/* Example.
int myArray[] = {0, 1, 2, 3, 4};
Serial.println(arraySize(myArray));
*/

array.h

#pragma once


struct seconds {
  unsigned long x;
};

struct milliseconds {
  unsigned long x;
};

constexpr seconds operator"" s(unsigned long long x) {
  return seconds{x};
}

constexpr milliseconds operator"" ms(unsigned long long x) {
  return milliseconds{x};
}

types.h

#pragma once


template <size_t N>
void parseLine(int (&result)[N], char const line[]) {
  char* endptr = const_cast<char*>(line);
  for (size_t i = 0; i < N and endptr[0]; i++) {
    result[i] = strtol(endptr + static_cast<int>(i != 0), &endptr, 10);
  }
}

template <size_t N>
void parseLine(double (&result)[N], char const line[]) {
  char* endptr = const_cast<char*>(line);
  for (size_t i = 0; i < N and endptr[0]; i++) {
    result[i] = strtod(endptr + static_cast<int>(i != 0), &endptr);
  }
}

/* Examples.
char const line[] = "12, 3, 123";
int result[3];
parseLine(result, line);
for (int const& value: result) {
  Serial.println(value);
}

char const line[] = "1.2, 3, 12.3";
double result[3];
parseLine(result, line);
for (double const& value: result) {
  Serial.println(value);
}
*/

parse.h

#pragma once


class C {
  int data_ = 10;
public:
  void print() {
    Serial.println(data_);
  }
};

/* Example:
void test(C& obj, void (C::*f)()) {
 (obj.*f)();
}

void setup() {
  Serial.begin(9600);

  C c;
  test(c, &C::print);
}
 */

class_member.h

template <class T>
struct Format {
  T data;
  int modifier;
};

template <class T>
Format<T> format(T const data, int const modifier) {
  Format<T> fmt {data, modifier};
  return fmt;
}


template <class T>
Stream& operator <<(Stream& stream, T const data) {
  stream.print(data);
  return stream;
}

template <class T>
Stream& operator <<(Stream& stream, Format<T> const& parameters) {
  stream.print(parameters.data, parameters.modifier);
  return stream;
}