DEV Community: Swastik Baranwal

Modern C++: Variadic Templates

Swastik Baranwal — Wed, 12 Nov 2025 20:07:00 +0000

This follows my series to cover lesser known features of Modern C++

Today, we have variadic templates, which is an improvement over variadic arguments (...), a type of argument that can take variable arguments.

Before we start with variadic templates, an introduction to variadic arguments is required.

Variadic Arguments

Variadic arguments have been around since the time of C and old C++ but it has a lot of limitations, which can be seen in the code demonstration below:

#include <iostream>
#include <cstdarg>

void printNumbers(int count, ...) {
    va_list args; // Hold and make argument list with capacity "count"
    va_start(args, count); // Start processing variable args

    for (int i = 0; i < count; ++i) {
        int num = va_arg(args, int); // Get next argument
        std::cout << num << " ";
    }

    va_end(args); // Clean up
    std::cout << std::endl;
}

int main() {
    printNumbers(1, 2, 3, 4); // Works completely fine
    printNumbers(4, 34, '4', 12.3, "12"); // It doesn't raise error but IT SHOULD!
    return 0;
}

As can be seen above:

Number of arguments need to be provided manually (most of the time, it's dynamic)
The compiler doesn't raise any error if variable arguments have different types
Need to import header file <cstdarg> to use them
It only works with basic primitive types (std::string is NOT)

This is very limited and doesn't work for the Modern C++ world where classes, objects and templates are used all the time.

Variadic Templates

Variadic Templates were introduced in C++ 11 to eliminate the limitations of variadic arguments by providing type safety, dynamic argument length and lesser usage of macros.

The following code is a basic example of variadic templates used to sum numbers:

#include <iostream>

template<typename... Args>
auto sum(Args... args) {
    return (args + ...); // Fold expression (C++17)
}

int main() {
    std::cout << sum(1, 2, 3, 4, 5) << std::endl; // Output: 15
    std::cout << sum(2.5, 3.5) << std::endl;      // Output: 6.0
}

The function sum has a packet parameter Args... args which can accept any number of arguments

(args + ...) is a fold expression, introduced in C++ 17, and is a clean and concise way to perform operations over variadic templates.

This code is then expanded to ((1 + 2) + 3) + 4 + 5, which returns the value of 15.

More than Functions

Variadic Templates have more usage than just using them with basic functions. They can be used in situations like:

Logical AND / OR Boolean Operations

#include <iostream>

template<typename... Bools>
bool allTrue(Bools... bs) {
    return (bs && ...);
}

template<typename... Bools>
bool anyTrue(Bools... bs) {
    return (bs || ...);
}

int main() {
    std::cout << allTrue(true, true, false) << "\n"; // false
    std::cout << anyTrue(false, false, true) << "\n"; // true
}

This operation is used in flag evaluation and validation checks

Calling a Function on Each Argument

#include <iostream>

void log(int x) { std::cout << "[int] " << x << "\n"; }
void log(const char* s) { std::cout << "[str] " << s << "\n"; }

template<typename... Args>
void logAll(Args... args) {
    (log(args), ...); // C++17 fold expression with comma
}

int main() {
    logAll(1, "hello", 42, "world");
}

The code snippet logs all the arguments according to their type.

[int] 1
[str] hello
[int] 42
[str] world

Custom Factory functions

#include <memory>
#include <utility>
#include <iostream>

template<typename T, typename... Args>
std::unique_ptr<T> make_instance(Args&&... args) {
    return std::make_unique<T>(std::forward<Args>(args)...); // preserve the argument was originally passed
}


struct Foo {
    Foo(int x, const std::string& y) {
        std::cout << "Foo constructed: " << x << ", " << y << "\n"
    }
};



int main() {
    auto f = make_instance<Foo>(10, "bar");
}

The code snippet is a custom factory function which makes a class with any number of parameters.

Foo constructed: 10, bar

Real life applications

Variadic templates are heavily used by C++ STL such as std::tuple, std::pair, std::array std::make_unique, std::make_shared libraries

When to use C variadic arguments `va_arg`

Working with C functions such as printf, scanf, syslog, etc
Extending C code on top of C++ code
Writing bindings for legacy support

Variadic Arguments to Variadic Templates

Variadic Arguments can easily be wrapped with Variadic Templates incase there's a need to do it:

#include <cstdarg>
#include <cstdio>
#include <string>

void c_log(const char* fmt, ...) {
    va_list args;
    va_start(args, fmt);
    vprintf(fmt, args);
    va_end(args);
}

template<typename... Args>
void logSafe(const std::string& fmt, Args... args) {
    // c_str() method turns std::string into char*
    c_log(fmt.c_str(), args...);
}

int main() {
    logSafe("Number: %d, Text: %s\n", 42, "Hello");
}

This example demonstrates how a C-style variadic, which logs a message, is wrapped by a Variadic Template.

Conclusion

Use C variadic functions only when you need to interop with legacy C code or third-party libraries.
For all modern C++ code, prefer variadic templates for type safety, maintainability, and cleaner syntax.
You can even wrap C variadic functions with variadic templates when needed.

Code

All the code used in this article is available here.

Delta456 / modern_cpp_series

Code for my Modern C++ Articles

Modern C++ Series

Code for my Modern C++ Article Series.

Articles

View on GitHub

Kubernetes' minikube uses my Go Lang Project!

Swastik Baranwal — Sat, 06 Aug 2022 13:01:00 +0000

I am very honoured to announce that my Go Language Project Box CLI Maker which makes Highly Customized Boxes for CLI is being used in Kubernetes's minikube which implements a local Kubernetes cluster for Mac OS, Linux and Windows, according to the description.

They are the first major user of my module which has been out for 2-3 years. This is a big achievement for me as it inspires me to make more Open source projects and continue as an Open source contributor throughout my career.

They added my module in PR #10818 which was merged 1 year ago and it is also used in their cmd and out sub-packages.

Currently, my module has 222 🌟 stars and 14 📦 importers which is a good sign and motivation for me to develop on this open source project even further.

I would like to thank the open source and Go Lang community for all the support and love that made this feat possible!

I am back!

Swastik Baranwal — Sat, 06 Aug 2022 11:33:12 +0000

Finally after 2 years of studies, I am back! I will finally be coding, making projects, blogging and what not again. I hope to do my future goals well and perfectly.

My Review of 2020

Swastik Baranwal — Thu, 31 Dec 2020 04:18:00 +0000

The 2020 year has been hard almost for everyone due to the pandemic. My year was almost alright, but then my family also got infected with COVID-19 recently. However, we luckily fought through it and now we are safe.

I hope everyone's safe and I pray for those who are going through this tough time. Since I was always at home, I was over-productive this year as I had a lot of time to learn and make stuff. I believed that such an opportunity to improve will never come again, so I made the best use of it.

And as 2020 is about to end soon, these are the things I accomplished this year:

Accomplished

My Dev.to account articles have passed more than 100K views in less than one year of creation!
I made small 5 projects and learned a lot of things and met a lot of people who helped me to implement those features! I would like to thank them very much ^-^
My GoLang library: Box Cli Maker has 100+ stars in just 8 months!!
V By Example has also 100+ stars :)
I have done a total of 200 Pull Requests in my whole life.
I have completed Hacktoberfest 2020 and I did around 7 PRs this time during October because I was busy that time with other things!
I learnt more about V's internal compiler and started to implement small features and fix bugs and issues slowly and step by step!
I had started taking part in discussions of Python's Pattern Matching syntax and was against the favour of using _ for denoting else case in match syntax as it would be inconsistent and wouldn't make it Pythonic anymore. I tried giving some issues and I got acknowledged from them. Though my proposal was rejected as I wasn't a part of them.
I got some "job offers" but I feel those were scams so I rejected them as who can hire someone like that? I think it's still an achievement as people are coming to me xD
I made a Github Profile README.md in such a unique style that others liked and copied it.
Opened several issues in Golang, V and Deno etc.
Became a collaborator of Bhupesh-V/30-seconds-of-cpp.
Got 90+ followers on GitHub.
My proposal for Windows Terminal got accepted!

Projects made

Box CLI Maker

Delta456 / box-cli-maker

Make Highly Customized Boxes for CLI

Features

Make a Terminal Box in 8️⃣ inbuilt different styles
16 Inbuilt Colors and True Color Support 🎨
Custom Title Positions 📏
Make your Terminal Box style 📦
Support for ANSI, Tabbed, Multi-line and Line Wrapping boxes 📑
Align the text according to your needs 📐
Unicode, Emoji and Windows Console Support 😋
Written in 🇬 🇴

Installation

 go get github.com/Delta456/box-cli-maker/v2

Usage Tutorial

In main.go

package main

import "github.com/Delta456/box-cli-maker/v2"

func main() {
 Box := box.New(box.Config{Px: 2, Py: 5, Type: "Single", Color: "Cyan"})
 Box.Print("Box CLI Maker", "Highly Customized Terminal Box Maker")
}

box.New(config Config) takes Box Config and returns a Box from the given Config.

Parameters
- Px : Horizontal Padding
- Py : Vertical Padding
- ContentAlign : Content Alignment inside Box i.e. Center, Left and Right
- Type: Box…

View on GitHub

random

Delta456 / random

An all purpose random library written in V.

THIS MODULE HAS BEEN DEPRECATED AND V'S RAND MODULE SHOULD BE USED INSTEAD!

random

An all purpose random library written in V.

Features

All variate functions possible.
Generate random int and string with ease.
range functions for int and f32.
Array functions like shuffle, choose, sample etc.
Makes life easier sorta
Many more features coming soon!

Installation

Via git clone
- git clone https://github.com/Delta456/random
Via v install
- v install random
Via vpkg
- vpkg install random

Docs

// struct for `triangular()`
struct Triangular {
mut
        low  f32 = 1.0
        high f32 = 1.0
        mode int = 1
}

// struct for `int_range()`
struct IntRange {
        start int
        stop  int
        step  int = 1
}

// struct for `float_range()`
struct FloatRange {
        start f32
        stop  f32
        step  f32 = 1.0
}

// normal_variate is the normal distribution where mu is the 
// mean, and stigma is the standard deviation

…

View on GitHub

CLI Badges

Delta456 / cli_badges

Generate Badges for your CLI written in 🦕 Deno and TS

CLI Badges

Generate Badges for your CLI.

NOTE: It is recommended to update pre-exisiting versions of this module to ^v0.1.0 as there are many breaking changes from this release in the API.

Features

Make Beautiful Badges for CLI 🤩
Works across all terminals 🦄
Link support 🔗
Variety of colors to choose from 🎨
Written in TS with Deno 🦕

Warning ⚠️: If your terminal has a custom theme then the colors will blend according to your configuration which can cause unwanted results.

Usage

Simple Example

Showcases failed, success and skipped badge on the terminal

import { badge } from "https://deno.land/x/cli_badges@v0.1.1/mod.ts";
console.log(badge("failed", "2", { msgBg: "red" }));

console.log(badge("success", "2", { msgBg: "green" }));

console.log(badge("skipped", "2"

…

View on GitHub

range

Delta456 / range

Functionality of Python's range() in V

range

Numeric ranges in V.

Why

a..b in V can only be in increasing order and not in negative order.
Lacks inbuilt step which most people need or want.
No support for float type.
Solution for vlang/v#5944.

Features

Make range easily
Make ranges for int and f32
Positive as well as negative support!
No need to write the whole for loop! (this maybe slower than the normal one)
Use range for functional programming
Support iterators. Long ranges without high memory allocation.
Half open-open ranges [from,to]

Installation

Via git clone
- git clone https://github.com/Delta456/range
Via v install
- v install Delta456.range
Via vpkg
- vpkg install range

Usage

Use an iterator if you need a large range but don't want to allocate space in memory for all numbers in the range.

import delta456.range
mut iter := range.to_iterator(from: 0, to: 1000000, step: 2)
for v in iter

…

View on GitHub

ASCII Robot

Delta456 / ascii_robot

ASCII Robot Generator in V

ascii robot

ASCII Robot Generator in V

Installation:

Via git clone
- git clone https://github.com/Delta456/ascii_robot
Via v install
- v install ascii_robot
Via vpkg
- vpkg install ascii_robot

Usage

random_id() returns a random 5 digit hex number in string.
generate(string) returns a string optional. string returns random made ASCII bot depending upon the 5 digit number.
must_generate(string) is same as generate() but returns an empty string if the hex number provided is not valid.
random_robot() returns a random ASCII robot.

In main.v

import delta456.ascii_robot as robot
import rand

fn main() {
    rand.seed([u32(42), 0]) // or use your seeder
    println(robot.must_generate('1f35a'))

    for i := 0; i < 5; i++ {
        println(robot.random_robot())
    }
}

Bot Types

Total ASCII Robot Types possible:

   _ _,_,_ _
   \( q p )/   
     \_#_/     
  .==|>o<|==:=L
  '=c|___|     
     ]| |[     
    [_| |_]     




     ,_,_,     
     \O

…

View on GitHub

Hacktoberfest 2020 Stats

GitHub Stats

Dev.to Dashboard

Hacktoberfest 2020 Swags

Dev.to Badges Earned

Conclusion

I think this will be my last article for now as I have to study for the next 1.5 years for preparation! I hope you all liked this article and wish me to achieve more!!

I thank all of the people who I have met and taught me a lot of things, especially people from V Community!!

Happy New Year's Eve to All! I hope everyone achieves what they want to :)

Uses and difference b/w switch and match

Swastik Baranwal — Thu, 10 Sep 2020 08:22:00 +0000

Everyone must be using selection statements for pattern matching or equality checking. Some language like Rust, F#, Kotlin, Scala, V and Python (future) use match and while some use switch like C, C++, Go, C# etc.

What was the need for separate names for the same purpose? This article tries to clarify the difference and usage between these two.

`switch` statement

A switch statement allows a variable to be tested for equality against a list of values. Each value is called case but needs to be terminated by break. switch can also have a default case for handling other cases which are not listed.

Here's a simple switch Statement Program in C++.

#include <iostream>

int main()
{
  int i = 0;
  switch (i)
    {
    case 0:
      std::cout << "i is zero";
      break;

    case 1:
      std::cout << "i is one";
      break;

    default:
      std::cout << "invalid";
      break;
    }
}

This program declares variable i as int and the switch statement checks the value of i. The first case will be evaluated as it satisfied the condition i == 0 so i is zero will be printed.

Though switch has certain limitations:

switch only works with integral values i.e. int, char and enum
switch can only be used for checking equality
switch cannot be used as an expression

`match` statement/expression

match can be used both used as a statement and expression accordingly and are much like switch except it solves the above limitation stated plus saves additional keywords over switch like no default or case (though Python has case and it's a statement). default is either replaced with else or _ (some may just use default).

match also supports range like 1..2 which means in a range of [1, 2) and 1..=3 or 1...3 which means [1, 3], 2 | 3 | 4 or 3, 4, 5 for matching if either of them is true plus matching them as a var/object.

The following examples of match are written in Rust.

Taken from Learn Rust by Examples

Simple example

fn main() {
    let x = 1;

    match x {
        1 => println!("one"),
        2 => println!("two"),
        3 => println!("three"),
        4 => println!("four"),
        5 => println!("five"),
       // else clause, executed when none of the values matches
        _ => println!("something else"),
    }
}

Using ranges and combining multiple values as an expression

fn main() {
    let x = 1;
    let message = match x {
        0 | 1 => "not many",  // check if matches either to 0 or 1
        2..=9 => "a few",     // check if its in a range of `[2, 9]`
        10..15 => "too many", // check if its in a range of `[10, 15)`
        // else clause, if neither of the cases matches then "lots of
        // many" will be assigned
        _ => "lots of many",
    };

    assert_eq!(message, "a few");
}

Exceptions

Some languages like Go, JS, TS etc have switch statements but support all primitive data types though they don't have support for ranges, using them as expressions and have default as the keyword, pattern matching etc.

In Go, there's no need to put break on every case, it does it automatically plus you can use interface{} to detect the type of the variable.

An example of Go's switch

Taken from Go By Examples

Simple example

package main

import (
    "fmt"
    "time"
)

func main() {

    // Here's a basic `switch`.
    i := 2
    fmt.Print("Write ", i, " as ")
    switch i {
    case 1:
        fmt.Println("one")
    case 2:
        fmt.Println("two")
    case 3:
        fmt.Println("three")
    }

    // You can use commas to separate multiple expressions
    // in the same `case` statement. We use the optional
    // `default` case in this example as well.
    switch time.Now().Weekday() {
    case time.Saturday, time.Sunday:
        fmt.Println("It's the weekend")
    default:
        fmt.Println("It's a weekday")
    }

    // `switch` without an expression is an alternate way
    // to express if/else logic. Here we also show how the
    // `case` expressions can be non-constants.
    t := time.Now()
    switch {
    case t.Hour() < 12:
        fmt.Println("It's before noon")
    default:
        fmt.Println("It's after noon")
    }

    // A type `switch` compares types instead of values.  You
    // can use this to discover the type of an interface
    // value.  In this example, the variable `t` will have the
    // type corresponding to its clause.
    whatAmI := func(i interface{}) {
        switch t := i.(type) {
        case bool:
            fmt.Println("I'm a bool")
        case int:
            fmt.Println("I'm an int")
        default:
            fmt.Printf("Don't know type %T\n", t)
        }
    }
    whatAmI(true)
    whatAmI(1)
    whatAmI("hey")
}

Conclusions

match and switch are just convenient ways of writing long if-else statements for increasing readability and making code more robust etc.

Usually, match is used for pattern matching and also it can be a statement and as well as expression whereas switch is used for equality checking and is a statement only.

Some languages might not even use switch (f.e. Kotlin with the when which has the same semantics as match)

Dynamically and statically typed languages often do things differently on their specific use cases. Some may provide or disallow certain features so that the language doesn't become much complex.

Similarly, V only supports the inclusive range of the last element i.e. start...end which is the same as [start, end] to remove the complexity.

Some languages may even keep switch for simplicity and easiness to use.

References

If there's anything wrong in this article then please reply in the comments.

CLI Badges: Generate Badges for your CLI

Swastik Baranwal — Sat, 29 Aug 2020 14:18:13 +0000

CLI Badges

Generate Badges for your CLI.

Features

Make Beautiful Badges for CLI 🤩
Works across all terminals 🦄
Link support 🔗
Variety of colors to choose from 🎨
Written in TS with Deno 🦕

Usage

import { badge } from "https://deno.land/x/cli_badges@v0.1.0/mod.ts";

console.log(badge("failed", "2", { msgBg: "red" }));

console.log(badge("success", "2", { msgBg: "green" }));

console.log(badge("skipped", "2", { msgBg: "yellow" }));

Output

`badge` function

badge function accepts the following arguments:

label: label of the badge
msg: message of the badge
opts: accepts an interface of BadgeOptions

`BadgeOptions` Interface

interface BadgeOptions {
  msgBg: string; // default is blue
  labelBg: string; // default is brightBlack
  msgColor: string; // default is white
  labelColor: string; // default is white
  msgStyle?: string; // default is null
  labelStyle?: string; // default is null
  msgWidth?: number; // default is msg length + 2
  labelWidth?: number; // default is label length + 2
  is_8bit?: boolean; // default is false as it uses 24 bits
  hyper_link?: string; // hyperlink for the badge
}

Available Options

Foreground Colors

black
red
blue
green
yellow
magenta
cyan
white
brightBlack
brightRed
brightBlue
brightGreen
brightYellow
brightMagenta
brightCyan
brightWhite

Background Colors

black
red
blue
green
yellow
magenta
cyan
white
brightBlack
brightRed
brightBlue
brightGreen
brightYellow
brightMagenta
brightCyan
brightWhite

Styles

bold
italic
inverse
dim
strike
underline

Custom Colors

Custom Colors are available and can be used for msgBg, labelmsg, msgColor and labelColor only. There are options to make 8 bit and 24 bit colors respectively. Set is_8bit to true if you want custom 8 bit RGB colors else it will be set to 24 bit RBG colors by default.

NOTE: 24 bit Colors must be in a range of 0x000000 and 0xffffff and 8 bit Colors must in a range of 0x0 and 0xFF.

Hyperlink Support

Hyperlink is only supported on some terminals.

Acknowledgments

I thank the author of nombrekeff/cli-badges for his original implementation in JS wth Node and also helped me with some Deno issues and giving me guidance on this project as this is my first project with TS.

GitHub

Delta456 / cli_badges

Generate Badges for your CLI written in 🦕 Deno and TS

CLI Badges

Generate Badges for your CLI.

NOTE: It is recommended to update pre-exisiting versions of this module to ^v0.1.0 as there are many breaking changes from this release in the API.

Features

Make Beautiful Badges for CLI 🤩
Works across all terminals 🦄
Link support 🔗
Variety of colors to choose from 🎨
Written in TS with Deno 🦕

Warning ⚠️: If your terminal has a custom theme then the colors will blend according to your configuration which can cause unwanted results.

Usage

Simple Example

Showcases failed, success and skipped badge on the terminal

import { badge } from "https://deno.land/x/cli_badges@v0.1.1/mod.ts";
console.log(badge("failed", "2", { msgBg: "red" }));

console.log(badge("success", "2", { msgBg: "green" }));

console.log(badge("skipped", "2"

…

View on GitHub

Package Validator for V

Swastik Baranwal — Tue, 18 Aug 2020 14:52:56 +0000

This workflow is a package validator for V Language. It uses V Actions for building and using V for Windows 10, Ubuntu 18.04 LTS and MacOS. This is a pretty simple workflow as V is really a new language and most things are handled by V itself!

It took a lot of time to create as I was backed by the limitations of V so I had to tell the creator about these issues which he fixed it in his free time but of course he couldn't solve all.

More things will be added soon. Any suggestions are welcome!

My Workflow

I am using this as my Actions for V as its made by the community.

nocturlab / setup-vlang-action

Github Action that allow you to compile v programs without the use of docker (because it's very slow)

This repository will be ARCHIVED soon !! Check the official action

Setup V environment

GitHub Action that allows you to compile V programs without the use of Docker (because it's very slow).

Usage

You just have to setup your workflow like this:

# file: .github/workflows/vlang-build-pipeline.yml
name: vlang-build-pipeline

on:
  push:
    paths-ignore:
      - '**.md'

jobs:
  run:
    name: Run
    runs-on: ubuntu-latest
    steps:
    - name: Checkout
      uses: actions/checkout@v2
    - name: Set up V version latest
      uses: nocturlab/setup-vlang-action@v1
      with:
        v-version: latest
      id: v
    - name: Build repository app
      run: v .
    - name: Run V tests
      run: v test .

Inputs

v-version: V version. Can be either exact version number, latest (by default), or master (use the master branch instead of release).

View on GitHub

Submission Category:

Maintainer Must-Haves

Yaml File or Link to Code

name: CI
on:
  push:
    branches: [master]
  pull_request:
    types: [opened, synchronize]
jobs:  
 test:
  name: Run tests on ${{ matrix.os }} ${{ matrix.v-version }}
  strategy:
      matrix:
        os: [ubuntu-latest, macos-latest, windows-latest]
        v-version: [master, latest]
  runs-on: ${{ matrix.os }}
  steps:
      - uses: actions/checkout@v1
      - uses: nocturlab/setup-vlang-action@master
        with:
          v-version: master
      - name: Run vet
        run: v vet .
      - name: Run tests
        run: v test .
      - name: vfmt verify
        run: v fmt -verify -diff *.v

How it works

This workflow uses the master branch of V repo. It goes through all the .v files in the current directory which includes vet i.e. find unnecessary code which can be optimized, test which tests all files with __test as suffix and fmt which formats the code but here we are using using -verify flag to see it's the files are formatted or not.

Currently v fmt -verify -diff shows the diff of the original and formatted files as -verify doesn't assert true even though they are formatted, its due to line endings. (LF v/s CRLF)

Additional Resources / Info

Example of Repo using it:

v-community / repo_template

Template for V Repos

V Repo Template

Template for V Repos

Purpose

This repo template tries to solve the complexity behind creating V repos as many people don't how to make one or people are lazy.

Overview

Makefile for formatting files, running examples and tests
GitHub Actions workflow for V
v.mod A file for initalising V projects
MIT License for Repo (though you can change the license)
A .gitignore made for V
ISSUE_TEMPLATE, CODE_OF_CONDUCT etc written
More things coming soon...

Installation

git clone https://github.com/v-community/repo_template

Acknowledgments

Thanks to moul/golang-template for his ISSUE_TEMPLATE and other things written by him and inspiration.

License

Licensed under MIT

Contributing

Contribution is welcome. Please read Code of Conduct.

View on GitHub

Python: removeprefix() and removesuffix()

Swastik Baranwal — Tue, 18 Aug 2020 07:08:00 +0000

In Python 3.9 which is scheduled to be released in October 2020
has introduced two new string methods str.removeprefix() and str.removesuffix() respectively.

Why

There were a lot of confusion as people thought str.lstrip() and str.rstrip() that can be used to trim prefix and suffix but the parameter accepts a set of characters not the substring.

These methods are useful for trimming prefix/suffix and also make code short and readable.

Purpose

str.removeprefix(substring: string) is a method which returns a new string with the trimmed prefix if the str starts with it else it will return the original string.
str.removesuffix(substring: string) is a method which returns a new string with the trimmed suffix if the str ends with it else it will return the original string.

Implementation

These functions were implemented in python/cpython#18939.

removepreifx()

def removeprefix(self: str, prefix: str, /) -> str:
    if self.startswith(prefix):
        return self[len(prefix):]
    else:
        return self[:]

removesuffix()

def removesuffix(self: str, suffix: str, /) -> str:
    if self.endswith(suffix):
        return self[:-len(suffix)]
    else:
        return self[:]

Usage

This shows the usage of the functions and the output of all the cases.

s = 'Hello World from Python 3.9!'
print(s.removeprefix('Hello World')) // from Python 3.9!
print(s.removeprefix('')) // Hello World from Python 3.9!

print(s.removesuffix('3.9!')) // Hello World from Python
print(s.removesuffix('Python')) // Hello World from Python 3.9!

Conclusion

Python is always evolving with the community's needs and it will be the most used language in the future.

What would you do if you had a Time Machine?

Swastik Baranwal — Thu, 13 Aug 2020 07:32:57 +0000

If I had a Time Machine then I would probably won't ever use it because it will affect my present if I tried to travel and altered my past and future. What I have now, I may not have now as you have to give sacrifices to achieve in life and you learn lessons when you make mistakes and improve further. At least that's my way of thinking.

So if you had a time machine then what you would do?

How Dev.to has improved you?

Swastik Baranwal — Sun, 02 Aug 2020 09:41:47 +0000

Pretty self explanatory but I would like to know it in more detail

Go2: Map and Filter with Generics

Swastik Baranwal — Fri, 24 Jul 2020 05:09:31 +0000

Go plans to add generics in their next big release since 2016 and they have been working upon the syntax so that it matches with current semantics.

In June 2020 they had released a draft for how about they have planned the syntax to match with their semantics.

One of the problems of Go which it was a lot criticized was that it had never had map and filter in built which is a lot used for functional programming. Gophers had to write a for loop to achieve but Rob Pike had written a filter package to achieve this but it contains a lot of boilerplate and he suggests to use for loop. With Generics map and filter can be implemented quiet easily.

While going through the Go Reddit. I had found this code which implements map, filter, any and all in Go with Generics. You must have noticed that they use [T] instead of <T> for denoting them. They are currently testing and asking for feedback as <T> doesn't match with Go semantics. You can find the thread here.

I hope Go2 will be best release of Go Language ever!

Rate my GitHub Profile README

Swastik Baranwal — Mon, 13 Jul 2020 14:34:17 +0000

As GitHub recently launched their README.md feature for Profiles so I decided to make one too. I really putted all my efforts to make this small and beautiful. I want people to rate this and gimme feedback about this. If I can do more edits on it!

DEV Community: Swastik Baranwal

Modern C++: Variadic Templates

Variadic Arguments

Variadic Templates

More than Functions

When to use C variadic arguments va_arg

Variadic Arguments to Variadic Templates

Conclusion

Code

Delta456 / modern_cpp_series

Code for my Modern C++ Articles

Modern C++ Series

Articles

Kubernetes' minikube uses my Go Lang Project!

I am back!

My Review of 2020

Accomplished

Projects made

Delta456 / box-cli-maker

Make Highly Customized Boxes for CLI

Features

Installation

Usage Tutorial

Delta456 / random

An all purpose random library written in V.

THIS MODULE HAS BEEN DEPRECATED AND V'S RAND MODULE SHOULD BE USED INSTEAD!

random

Features

Installation

Docs

Delta456 / cli_badges

Generate Badges for your CLI written in 🦕 Deno and TS

CLI Badges

Features

Usage

Simple Example

Delta456 / range

Functionality of Python's range() in V

range

Why

Features

Installation

Usage

Delta456 / ascii_robot

ASCII Robot Generator in V

ascii robot

Installation:

Usage

Bot Types

Hacktoberfest 2020 Stats

GitHub Stats

Dev.to Dashboard

Hacktoberfest 2020 Swags

Dev.to Badges Earned

Conclusion

Uses and difference b/w switch and match

switch statement

match statement/expression

Simple example

Using ranges and combining multiple values as an expression

Exceptions

Simple example

Conclusions

References

CLI Badges: Generate Badges for your CLI

CLI Badges

Features

Usage

Output

badge function

BadgeOptions Interface

Available Options

Foreground Colors

Background Colors

Styles

Custom Colors

Hyperlink Support

Acknowledgments

GitHub

Delta456 / cli_badges

When to use C variadic arguments `va_arg`

`switch` statement

`match` statement/expression

`badge` function

`BadgeOptions` Interface