markphelps/optional

Optional is a library of optional Go types

Hi, I'm Mark 👋

• Creator of Flipt, an open source, self-hosted feature flag solution
• Former Staff Engineer @github
• Dad x2, Husband, Human

👷 Check out what I'm currently working on

• flipt-io/flipt-node - Official Node.js SDK for the Flipt API (1 day ago)
• flipt-io/docs - https://www.flipt.io/docs (powered by https://mintlify.com/) (1 day ago)
• flipt-io/flipt-client-sdks - Flipt Client-Side Evaluation SDKs (1 day ago)
• flipt-io/flipt - Enterprise-ready, GitOps enabled, CloudNative feature management solution (1 day ago)
• flipt-io/flipt-python - (1 day ago)

🌱 My latest projects

• markphelps/zero2prod -
• markphelps/flipt.io - Flipt Homepage
• markphelps/retry - (Another) retriable errors package for go
• markphelps/optional - Optional is a library of optional Go types
• markphelps/go-trace - Implementing a path tracer in Go

📜 My recent blog posts

• Dependency Injection Explained (2 years ago)
• Trying Out Generics in Go (2 years ago)
• Switching My gRPC Project to Use Buf (2 years ago)
• 4 Things to Consider When Choosing a Go API Framework (2 years ago)
• Writing Tests for Your Database Code in Go (2 years ago)

📫 How to reach me

• Twitter: https://twitter.com/mark_a_phelps
• Blog: https://markphelps.me/

optional's Issues

JSON Marshal For Primitive Wrappers

I would like your primitive wrappers, such as optional.Bool, to marshal and unmarshal to json accordingly. Right now they are marshaled as objects.

package main

import (
	"encoding/json"
	"github.com/markphelps/optional"
	"os"
)

type Foo struct {
	Bar optional.Bool `json:"bar"`
}

func main() {
	json.NewEncoder(os.Stdout).Encode(&Foo{Bar:optional.Bool{}}) // {}
	json.NewEncoder(os.Stdout).Encode(&Foo{Bar:optional.NewBool(true)}) // {"bar": true}
	json.NewEncoder(os.Stdout).Encode(&Foo{Bar:optional.NewBool(false)}) // {"bar":false}
}

`Get` without error / `Unwrap` method useful ?

Hey,

thanks for this utility :)

Coming from other languages, I wondered that there was not Unwrap which would return the value (or else panic if not set).

My thinking was, that I wrote code like this:

if s.field.Present() {
  doSth(s.field.Unwrap())
}

And then it didn't make sense to me to check the presence again / call Get which could return an error but never would in this case.

Then it occurred to me that I could write:

if field, err := s.field.Get(); err == nil {
  doSth(field)
}

The fact that error would always be errors.New("value not present") and never anything "bad" made me think though if this isn't too complicated to understand for the next reader (who might wonder why we wouldn't log the error etc.)

So basically I have 2 questions:

• Do you think it's worth to add this succinct if to the docs, or would that be obvious to most Go programmers? My thinking is, is that there is no general way to "handle the error", as mostly I would assume having an optional value not set is totally expected when using this library.
• Do you think it makes sense to align Get() (or a new method) with the map's behavior of returning value, ok ? That seems a lot less "dramatic" to me, and consumers can still handle cases when they didn't get a value but required one in some branch of their code.

How do I actually create bottom values?

It's not clear to me at all from the README or from the generated code, how to create the bottom value (or Nothing in Haskell parlance).

I have this generated code:

// OptionalFlavor is an optional Flavor.
type OptionalFlavor struct {
        value *Flavor
}

// NewOptionalFlavor creates an optional.OptionalFlavor from a Flavor.
func NewOptionalFlavor(v Flavor) OptionalFlavor {
        return OptionalFlavor{&v}
}

so if I have a Flavor I know how to get an OptionalFlavor. What I expected to find here was a nullary function that returns the Nothing case.

Perhaps I don't understand how this is supposed to work, or the README needs clarification.

Combinators

Did you leave out combinators like Map, FlatMap, etc. on purpose?

Calling Get() on empty optional crashes

Calling Get() on an empty optional leads to a nil pointer dereference. It seems like it would be okay to return a zero value with a non-nil error in the case that Get() fails. I'm willing to do this work if you approve of my suggested fix, I also understand if crashing is the desired behavior. In the case that you want the crash the Get() method doesn't seem like it needs to call Present().

Crashing example:

package main

import (
	"fmt"
	"github.com/markphelps/optional"
)

func main() {
    valOpt := optional.Int64{}
    val, err := valOpt.Get() // crash here
    if err == nil {
        fmt.Println("Got expected nil err for empty optional")
    }
    fmt.Printf("Got value: '%d' from empty optional\n", val)
}

Suggested fix for int64 type:

func (i Int64) Get() (int64, error) {
	if !i.Present() {
		var zero int64
		return zero, errors.New("value not present")
	}
	return *i.value, nil
}

Complex Types are not supported by JSON encoder

Attempting to marshal/unmarshal Complex64 and Complex128 will throw json: unsupported type: complex[64/128] as they are not supported by the JSON encoder.

https://github.com/golang/go/blob/129bb1917b4914f0743ec9b4ef0dfb74df39c07d/src/encoding/json/encode.go#L150

If optional is only used for user types, go mod tidy will remove it from project dependencies

The way around this is to add
import _ "github.com/markphelps/optional"
to the file that would contain the //go:generate command. It would be very helpful if this info is included in the README.

Add `Result<T,E>` generator, like Rust

I think that would be a great addition.

Unset() method would be natural

Would be handy to reset optional value (which present) to the state where it not present. Right now you have to create new value and that looks like incomplete/unnatural.

"generated by robots at {{ .Timestamp }}" Makes File Generation Non-Deterministic

Can we remove this comment or at least remove the timestamp from the generation tool?

Consider a project that has a lot of separate files containing types that need optional types generated. Ideally, one could run go generate on the whole directory and only files that changed would be updated, however, this comment will update every generated file with the new timestamp whether the type had any changes or not. This creates a mess that then needs cleaned up before committing to git. It's a really big annoyance for no real benefit, we don't need the timestamp comment, we have git for that.

optional/cmd/optional/main.go

Line 129 in 7069a2a

// This file was generated by robots at {{ .Timestamp }}

Optional for sql.Null* types

It would be awesome to have wrappers for sql.Null* types. It will be different from the generated primitive types though.

Example:

o := optional.NewNullInt64(sql.NullInt64{Valid: true, Int64: 55})

The question is, use it like in my example, or just implement sql.Scanner and sql.Valuer interfaces?