DEV Community: 42Atomys

Introducing Sprout 1.0 🌱💜: A New Era for Go Templates

42Atomys — Thu, 16 Jan 2025 18:34:26 +0000

Hey, Go Developers!

I'm thrilled to announce Sprout 1.0, the ultimate library to take your Go templates to the next level. Whether you’re building something simple or diving into complex templates, Sprout has your back. With powerful features and a focus on ease of use, Sprout brings a new era of possibilities to your Go projects.
Let’s explore why Sprout might just be the best tool you didn’t know you needed. If you’ve been searching for a library that balances power, speed, and simplicity, this is it.

My first v1.0.0 release of all time, thanks to LLama3.3 (local install) to have helped me to write this post 😳

Why Sprout?

Sprout was born out of a need for a more powerful, flexible, and user-friendly templating library for Go. Built on the foundation of Sprig, Sprout adds:

More Functions: A robust set of tools (200+) to handle everything from string manipulation to advanced math, helping you save time and effort.
Error Handling: Fully integrated with Go’s native error-handling mechanisms, making debugging and resilience a breeze.
Customizable Loading: Load only what you need, making your apps lighter and faster without unnecessary overhead.
Consistent Naming: No more cryptic names—Sprout keeps it clear and easy to use, so you can focus on building.
Comprehensive Docs: Dive into detailed examples and guides to master every feature and unlock the library’s full potential.

With Sprout, you’re not just using a library; you’re adding a toolkit designed to simplify and amplify your Go templating experience.

Getting Started

Here’s how you can start using Sprout in your projects:

$ go get github.com/go-sprout/sprout

Once installed, you can use it like this:

package main

import (
    "log"
    "os"
    "text/template"

    "github.com/go-sprout/sprout"
    "github.com/go-sprout/sprout/registry/strings"
)

// This example demonstrates the basic usage of Sprout to enhance Go templates.
// - It uses the "toUpper" function from the "strings" registry to convert text to uppercase.
// - The handler builds the function map and integrates it with the Go "text/template" package.
func main() {
    // Initialize a Sprout handler with the strings registry.
    handler := sprout.New(
        sprout.WithRegistries(strings.NewRegistry()),
    )

    // Build the function map from the handler.
    funcs := handler.Build()

    // Define a template string that uses the "toUpper" function.
    tmplString := `{{ toUpper "hello, sprout!" }}`

    // Parse the template with the custom functions.
    tmpl, err := template.New("example").Funcs(funcs).Parse(tmplString)
    if err != nil {
        log.Fatalf("Error parsing template: %v", err)
    }

    // Execute the template and print the output.
    if err := tmpl.Execute(os.Stdout, nil); err != nil {
        log.Fatalf("Error executing template: %v", err)
    }
}

This simple example shows how Sprout’s toUpper function makes converting text to uppercase a breeze. With just a few lines, you can extend your templates with powerful and efficient functionality. It’s that easy to start making your projects shine.

Deprecation and Alias Example

One of Sprout's coolest features is its ability to handle deprecated functions and aliases. This means you can rename or replace functions without breaking old templates. Here’s how it works:

package main

import (
    "log"
    "os"
    "text/template"

    "github.com/go-sprout/sprout"
    "github.com/go-sprout/sprout/registry/strings"
)

func main() {
    // Initialize the handler with deprecation notices and aliases.
    handler := sprout.New(
        // Register the standard "strings" functions, including operations like toUpper.
        sprout.WithRegistries(strings.NewRegistry()),

        // Add a deprecation notice for "uppercase" to guide users to the new "toUpper" function.
        sprout.WithNotices(
            sprout.NewDeprecatedNotice("uppercase", "please use `toUpper` instead"),
        ),

        // Create an alias so "uppercase" still works but maps to the new "toUpper" function.
        sprout.WithAlias("toUpper", "uppercase"),
    )

    // Define a template string that uses the deprecated "uppercase" function.
    tmplString := `{{ uppercase "Hello, Sprout!" }}`

    // Parse the template with the custom functions.
    tmpl, err := template.New("example").Funcs(handler.Build()).Parse(tmplString)
    if err != nil {
        log.Fatalf("Error parsing template: %v", err)
    }

    // Execute the template and print the output.
    if err := tmpl.Execute(os.Stdout, nil); err != nil {
        log.Fatalf("Error executing template: %v", err)
    }
}

In this example, uppercase is deprecated and redirects to toUpper. A warning is displayed to let you know that the old function will be removed in the future. This feature ensures smooth transitions and future-proof templates without disruption.

What Makes Sprout Stand Out?

Active Development: Sprout is constantly evolving with regular updates and improvements based on user feedback.
Lightweight and Fast: Minimal dependencies ensure your apps stay fast and efficient.
Community-Driven: Feedback from developers like you shapes Sprout’s future, making it a library truly built for the community.
Built for Scalability: Whether you’re managing small projects or large-scale applications, Sprout adapts to your needs effortlessly.

Sprout isn’t just another templating library—it’s a partner in your development journey, simplifying workflows and unlocking creativity.

Want to Contribute or Learn More?

GitHub: Explore the code and give us a star: https://github.com/go-sprout/sprout
Docs: Check out detailed guides: https://docs.atom.codes/sprout
Getting Started: See how to use it: https://docs.atom.codes/sprout/introduction/getting-started

Whether you’re here to learn or contribute, Sprout welcomes everyone to join its growing community. Together, we can shape the future of Go templating.

Join the Conversation

What do you think of Sprout 1.0? Have ideas or features you’d like to see? Drop a comment below or contribute on GitHub.
Together, let’s make Go templates better for everyone!
I truly think Go templates need some improvement, and I want Sprout to be the place for that evolution!
Share your experiences, showcase your projects, and inspire others to build amazing things with Sprout.

Happy Coding! 🚀💜

✨ How will Go Generics in Go 1.18 change your life? 💜

42Atomys — Wed, 09 Mar 2022 17:20:37 +0000

With the arrival of a long awaited update for some, or an update like the others for others. Generics in Go are about to be your new code companion in your Go projects.

A concrete example? Yes

For me one of the easiest ways to understand a new feature is to have an example. Until 1.17 (without Generics) having a function that created a slice of an element was easy for a type but if you wanted to manage several types it was immediately less fun.

// 1.17 without generic
func JoinBool(elements ...bool) []bool {
  return elements
}

func JoinInt(elements ...int) []int {
  return elements
}

func JoinString(elements ...string) []string {
  return elements
}

func main() {
  slice := JoinInt(1, 2, 3)
  slice2 := JoinBool(true, true, false)
  slice3 := JoinString("a", "b", "c")
}

In 1.17, you had to create a function for each type and call it individually.

🎉 A new foe has appeared : Go Generic

// 1.18 with generics
func Join[E any](elements ...E) []E {
  return elements
}

func main() {
  slice := Join[int](1, 2, 3)
  slice2 := Join[bool](true, true, false)
  slice3 := Join[string]("a", "b", "c")
}

In 1.18 the generics allow you to program your types. Yes, I think it's sexy to say it like that!

What am I reading? From Go!
everything between [] is the definition of your types.

In the definition of the function func Join[E any](elements ...E) []E as well as in the call slice := Join[int](1, 2, 3).
The type is defined when the function is called and used in the function code.

Let's split the function Join with the call Join[int](1, 2, 3)

func Join[E any](elements ...E) []E {
  return elements
}

In the example above I create an E type which can be of type any (keyword to say that everything is accepted). If you want a hint of understanding, imagine that at runtime you replace all E by int in a dynamic way.

Your function will then run like this if I simplify

// E type become int
func Join(elements ...int) []int {
  return elements
}

Now I let you imagine with all the other guys
Do you see it? Do you feel the power of Generics?

`any` is the new `interface{}` ?

Yes, but... No. Until now, if you wanted a function to accept several types, you used the interface{} hack which allowed you to receive anything. However it was to be used with care! And a type check was mandatory.

Let's take our Join function coded with interface{} again

func Join(elements ...interface{}) ([]interface{}, error) {
  // Check the interface type
  switch t := elements.(type) {
    case []int, []string:
      return elements, nil
    default:
      return nil, errors.New("Unsupported type")
  }
}

func main() {
  slice, err := Join(1, 2, 3)
  if err != nil {
    panic(err)
  }
  // slice is now a type of `[]interface{}`
  // Not a good idea. A Disaster ! To convert to []int again we needs to apply 
  // a second for loop
  var intSlice = []int{}
  for _, v := range slice {
    // Cast and check if the type of the interface{} is castable to `int` type
    if intCasted, ok := v.(int); ok {
      intSlice := append(intSlice, intCasted)
    }
  }

  // intSlice is not usable after a lot of pain...
}

When you use interface{}, it is mandatory to test your cast. Otherwise it's a crash! The cast is done at runtime which is quite risky for your programs.

🎉 A new foe has appeared : Go Generic
Here they come again! Version 1.18 is much nicer to read now that we know that our types are defined and checked at buildtime. If you use an IDE like VSCode, it will even warn you before building.

`any` everywhere !

NO! Never assume to set any by default! You should only start with the desired types, and as a last resort use any.

You will say yes, but Atomys, how can I do if my function can receive several types? The answer is simple, you can list as many types as you want:

func JoinNumeric[E int | int8 | int16 | int32 | int64 | uint | uint8 | uint16 | uint32 | uint64 | float32 | float64](elemets ...E) []E

My function accepts here a generic type E which could ONLY be of type numeric.

Yikes, but I'll have to write this every time? No, don't worry!

It is possible to create your own type, using interfaces. And yes, they are not going to disappear.

Let's create our Numeric type!

type Numeric interface {
    int | int8 | int16 | int32 | int64 | uint | uint8 | uint16 | uint32 | uint64 | float32 | float64
}

And now let's update our Join function declaration

func JoinNumeric[E Numeric](elemets ...E) []E

WOW! So much cleaner. Yes I'll give you that.

This is a concrete example of what Go Generics can bring in 1.18. But that's not all two new features comparable and the constraints package. We will see that in a next article !

Thanks for taking the time to read my article, it was my first one !

🙏 Please don't hesitate to support me with a follow on Github/42Atomys and DEV.to/42Atomys. New Go projects are coming soon.

💜💜