Add env or default function

[sunjayaali]

Hi, is it possible to have function like osext.Env(key, default)? Just a os.GetEnv with default value. If it's possible I'll make a PR for this. Thank you.

[deankarn]

Yes that would seem like a great addition.

Were you thinking of it returning a string or using generics with a constrained type that could handle casting to at least primitive types like ~string, ~int*, ~uint*, ~float*?

Could be cool with generics to avoid needing to cast to primitive types yourself after calling the function.

[sunjayaali]

Yes, using the generic. I'm thinking about [T any] type. What about that?

[deankarn]

I don’t think it should be any and should be constrained using constrains to just primitive types like I mentioned above because if only using any there will be many types that will compile but be unable to cast at runtime vs using constraints and knowing what works at compile time.

[deankarn]

Sorry late here so signing off for the night, I can try and post an example of what I mean tomorrow after work.

[deankarn]

@sunjayaali WDYT about something like this? #56

[sunjayaali]

I don’t think it should be any and should be constrained using constrains to just primitive types like I mentioned above because if only using any there will be many types that will compile but be unable to cast at runtime vs using constraints and knowing what works at compile time.

Yes I agree. But I was thinking, how if we create similar method like stdlib as base, so it feels more an extension of stdlib, like

func Env(key string, defaultValue string) string {
	if v, ok := os.LookupEnv(key); ok {
		return v
	}

	return defaultValue
}

Caller can use it with basic functionality. Then we can create a typed method to handle generic types, I also found that we can use .Bits() method to handle numeric types:

func EnvTyped[T constraintsext.Number | ~string](key string, defaultValue T) T {
	v := Env(key, fmt.Sprint(defaultValue))
	rt := reflect.TypeOf(defaultValue)

	elem := reflect.New(rt).Elem()
	switch rt.Kind() {
	case reflect.String:
		return any(v).(T)
	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
		if i, err := strconv.ParseInt(v, 10, rt.Bits()); err == nil {
			elem.SetInt(i)
		}
	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
		if u, err := strconv.ParseUint(v, 10, rt.Bits()); err == nil {
			elem.SetUint(u)
		}
	case reflect.Float32, reflect.Float64:
		if f, err := strconv.ParseFloat(v, rt.Bits()); err == nil {
			elem.SetFloat(f)
		}
	default:
		return defaultValue
	}

	return elem.Interface().(T)
}

wdyt?

[deankarn]

@sunjayaali

This function seems redundant as EnvTyped|EnvOrDefault can do strings also if that's what you want the type back as, especially since it's already not a drop in replacement to the std lib.

func Env(key string, defaultValue string) string {
	if v, ok := os.LookupEnv(key); ok {
		return v
	}

	return defaultValue
}

Also in EnvTypedfunction using fmt.Sprint() is dangerous as it assumes string output/formatting is the same as the value itself. Because in the constraints we are accepting all underlying types as well using ~ which can have their own String functions eg.

type CustomInt int

func (c CustomInt) String() string {
	return "It's Christmas"
}

fmt.Sprint(CustomInt(22))
-------------------------
Output: It's Christmas

Ah yes Bits() nice catch, I forgot this existed, that'll cleanup the code a bunch, will update the PR. I'll also Look updating to use elem := reflect.New(rt).Elem(), I like that approach, Convert handles a lot more cases but it's heavier and we don't need it to.

I'm also totally open to naming it the same as the std lib with just Env.

---

Ok I've updated the PR @sunjayaali , mind taking another look?

[deankarn]

There is also an alternative approach which would allow detection of the errors, or if we didn't care could treat error as Option instead of Result, then default could be chosen outside the function, something like this.

package osext

import (
	"os"
	"reflect"
	"strconv"

	constraintsext "github.com/go-playground/pkg/v5/constraints"
	. "github.com/go-playground/pkg/v5/values/result"
)

func EnvAlt[T EnvDefaults](key string, defaultValue T) Result[T, error] {
	if v, ok := os.LookupEnv(key); ok {
		ty := reflect.TypeOf(defaultValue)
		elem := reflect.New(ty).Elem()

		switch ty.Kind() {
		case reflect.String:
			elem.SetString(v)
			return Ok[T, error](elem.Interface().(T))
		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
			i, err := strconv.ParseInt(v, 10, ty.Bits())
			if err != nil {
				return Err[T, error](err)
			}
			elem.SetInt(i)
			return Ok[T, error](elem.Interface().(T))

		case reflect.Uintptr, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
			i, err := strconv.ParseUint(v, 10, ty.Bits())
			if err != nil {
				return Err[T, error](err)
			}
			elem.SetUint(i)
			return Ok[T, error](elem.Interface().(T))
		case reflect.Float32, reflect.Float64:
			f, err := strconv.ParseFloat(v, ty.Bits())
			if err != nil {
				return Err[T, error](err)
			}
			elem.SetFloat(f)
			return Ok[T, error](elem.Interface().(T))
		}
	}
	return Ok[T, error](defaultValue)
}

// EnvDefaults interface defines the supported types that can be used for environment variables conversions.
type EnvDefaults interface {
	constraintsext.Number | ~string
}


----- Usage:

v := EnvAlt("MY_ENV_VAR", 10).UnwrapOr(42)

The default could be chosen and could detect errors also.

[sunjayaali]

First time to use resultext package, very useful. Then what about if we remove the defaultVal from argument? so it's like EnvAlt(KEY).UnwrapOr(YOUR_DEFAULT)

[deankarn]

@sunjayaali You read my mind. I updated the PR, take a look, I don't even know if we'd want to keep the Env function or leave for convenience.

I added a LookupEnv to mirror the std lib also, that way people can choose their level of guarantees with each.

Ya I created Option & Result to mirror Rust, as much as possible in Go, it makes it far easier to marry multiple pieces of generic code together IMO.

[sunjayaali]

From caller's perspective, I got confuse which function should I use. IMHO we need only 1 public method to support this functionality, like osext.Env(KEY).UnwrapOr(default). Or I just lack of understanding of Option struct, like it's weird if we can do .UnwrapOr("").Unwrap().

[deankarn]

@sunjayaali we can totally get rid of the Env and keep the other two functions, Env is really only convenient now sonT can be inferred instead of requiring specifying the type.

Although only Getenv is needed to solve the original ask I thought it was important to also add LookupEnv for those that would need to differentiate between unset and parsing error(which we introduced), Getenv doesn’t allow for that.

fwiw the Option struct is a lot like the original std lib Getenv, only the code and intent is clear eg. Original uses a string to indicate not set when it’s blank but could also be set to a blank and why LookupEnv exists to be able to differentiate. Also UnwrapOr().Unwrap() I don’t think is possible with Option alone.

[sunjayaali]

Now I really just want to have Env(key, def) without generic. At first, I needed this because I used this functionality a lot across my projects, I kept retyping this over and over between projects. It would be a nice if I put somewhere and decided to put in this repo. Based on my experience also, 99% of my environment variables are string like db-redis url, 3rd party api url & configs, etc. But it's totally up to you.

[deankarn]

I think it’s all valid stuff, depends on ones guarantees needed, I am good with adding it all and letting the caller decide.

Even if only 1 of the 3 methods you will use, I can see the value in the other two for others.

If your good with the interface and your Env use case, I can merge the PR into this probably tomorrow If I can find time.