Slideshow | Text Formatting For A Future Range-Based Standard Library

class: middle

# Range-Based Text Formatting
## For a Future Range-Based Standard Library

---
# Text Formatting

- Text formatting everywhere
- Many different libraries/approaches
- Here is yet another one

---
background-image: url(/assets/en/career/talks/formatting/standards.png)
# Text Formatting

- Text formatting everywhere
- Many different libraries/approaches
- Here is yet another one
  
--

Input
- components of text
- order of these components
- per component, conversion parameters 
  * e.g., number of decimal places

Output
- a string

---
# Syntax Options

Order of components and parameters described by

--
- format string
  * `printf("Hello %f", 3.14);`
  * `absl::StrFormat` (printf syntax)
  * C++20 `std::format` (P0645) (Python syntax)

--
- 'Just C++': functions, parameters, operators
  * `std::stringstream() << std::setprecision(2) << 3.14;`
  * `"Hello " + std::to_string(3.14)`

---
# Format Strings: Pros

- format string
  * `printf("Hello %f", 3.14);`
  * `absl::StrFormat` (printf syntax)
  * C++20 `std::format` (P0645) (Python syntax)

Pros
- syntax closer to resulting string
- can decide format string at runtime
  * forgoes compile-time format check

---
# Format Strings: Cons

- format string
  * `printf("Hello %f", 3.14);`
  * `absl::StrFormat` (printf syntax)
  * C++20 `std::format` (P0645) (Python syntax)

Cons
- must escape format string (and remember it!)

--
- extra language for parameters
  * why not use C++?
  * user-defined types need parser for parameters

--
- no gradual change in syntax from string concatenation to formatting
  * `str1 + str2` vs.
    * `std::format("{0}{1}", str1, str2)` vs.
    * `std::format("{0}{1}{2}", str1, n, str2)`
	
---
# Format Strings: I8N

- translation outsourced to agencies
- set up to deal with text, not code
    * XLIFF (XML Localization Interchange File Format)

- text may contain placeholders

`Dear {0}, thank you for your interest in our product.`

- So must use format strings!

--
- BUT: give agency only as much control as necessary
    * insertion position
- formatting parameters provided by OS setting/culture database
    * decimal separator (comma vs. period)
    * number of decimal places
    * date format

---
# Just C++: iostream

```cpp
std::stringstream() << std::setprecision(2) << 3.14;
```

- abuse of operator overloading
  * only because no variadic templates?
- stateful ("manipulators")
  * `std::setprecision` applies to all following items,
  * `std::width` only to next item, ARGH!
- slow due to
  * virtual calls
  * extra copy `std::stringstream` -> `std::string`
```cpp
(std::stringstream() << std::setprecision(2) << 3.14).str()
```

---
#Just C++: string concatenation

```cpp
"Hello " + std::to_string(3.14)
```

- different abuse of operator overloading
- no formatting options
- slow
    * many temporaries

- BUT: conceptually the essence of formatting
  * turn data into string snippets
  * concatenate the snippets into whole text
  * naturally extends to user-defined types/parameters: call a function
- Overcome weaknesses with Ranges!

---
# Introduction to Ranges

- Who knows the range-based `for`-loop?
--

- Who knows C++20 Ranges?
--

- Who knows Eric Niebler's Range-v3 library?
--

- Who uses ranges every day?
  * Range-v3?
--

* Boost.Range?
--

* think-cell library?
--

* home-grown?

---
# Essence of Ranges

```cpp
std::find(itBegin, itEnd, x)
```
->
```cpp
std::ranges::find(rng, x) // C++20
```

- `rng` anything with `begin`, `end`
--

* containers that own elements (`vector`, `basic_string`, etc.)
--

* views that reference elements (= iterator pairs wrapped into single object)
--

- ranges may do lazy calculations
  * `rng | std::view::filter(pred)` only captures `rng` and `pred`, performs no work
  * skips elements while iterating

---
# Why do I think I know something about ranges?

- think-cell has range library
  * evolved from Boost.Range
  * more powerful than std::ranges
- 1 million lines of production code use it
- chicken-and-egg problem of library design
  * can only learn good design by lots of use
  * with lots of use, cannot change design
- avoid by
  * all code in-house
  * extra resources dedicated to refactoring

---
# Ranges for Text 101: Replace basic_string Member Functions by Range Algorithms

```cpp
index = str.find(...);
```
->
```cpp
iterator = std::ranges::find(str,...); // C++20 or tc::find_*
```

- same generic algorithms for character and other sequences
- flexible with string types
  * wrap OS-/library-specific string types in range interface
  * treat uniformly in syntax/algorithms

--
- C++17 `basic_string_view` perpetuates `basic_string` member interface:-(

---
# Ranges for Text Formatting (1)

- All Range libraries already have concatenation

```cpp
tc::concat("Hello ", strName) // similar syntax in Range-v3, not yet in C++20
```

- To format data, add formatting functions like `tc::as_dec`

```cpp
double f=3.14;
tc::concat("You won ", tc::as_dec(f,2), " dollars.")
```

- not like `<iostream>`: `double` itself is not a character range:

```cpp
tc::concat("You won ", f, " dollars.") // DOES NOT COMPILE
```

- No need for special `format` function

---
# Ranges for Text Formatting (2)

- Extensible by functions returning ranges

```cpp
auto dollars(double f) {
	return tc::concat(tc::as_dec(f,2), " dollars");
}

double f=3.14;
tc::concat("You won ", dollars(f), ".");
```

- Range algorithms work

```cpp
tc::for_each(
	tc::as_dec(f,2),
	[](char c){...}
);

if( tc::all_of/tc::any_of(
	tc::concat("You won ", tc::as_dec(f,2), " dollars."),
	[](char c){ return c!='1'; }
) ) {...}
```

---
# Formatting Into Containers (1)

`std::string` gives us
- Empty Construction
```cpp
std::string s; // compiles
```

- Construction from literal, another string
```cpp
std::string s1("Hello"); // compiles
std::string s2(s1); // compiles
```

--
- Add construction from 1 Range
```cpp
std::string s3(tc::as_dec(3.14,2)); // suggested
std::string s4(tc::concat("You won ", tc::as_dec(3.14,2), " dollars.")); // suggested
```
--
- Add construction from N Ranges
```cpp
std::string s5("Hello", " World"); // suggested
std::string s6("You won ", tc::as_dec(3.14,2), " dollars."); // suggested
```