optional

Documentation

Index

• Variables
• func IsNil(value types.T) bool
• type Optional
  • func Empty() Optional
  • func Of(value types.T) Optional
  • func OfNullable(value types.T) Optional

Examples

• Empty
• Of
• OfNullable

Variables

var (
	// ErrAbsent used to panic when call Optional.Get on empty Optional
	ErrAbsent = errors.New("absent value")
	// ErrNil used to panic when input a nil value to the Of method
	ErrNil = errors.New("nil value")
)

Functions

func IsNil

func IsNil(value types.T) bool

IsNil used to determine a value whether is nil or not

Types

type Optional

type Optional interface {
	Get() types.T                                  // Get the value or panic when no value
	IsPresent() bool                               // IsPresent return true is value exist
	IfPresent(types.Consumer)                      // IfPresent will invoke the Consumer if value exist
	Filter(types.Predicate) Optional               // Filter: if has value, and the value matches the given Predicate return a Present Optional, or else return Empty
	Map(types.Function) Optional                   // Map: if has value, apply the given Function to it, or else return Empty
	FlatMap(func(t types.T) Optional) Optional     // Flatmap: if has value, apply the given flatten-Function and return the result, or else return Empty
	OrElse(types.T) types.T                        // OrElse: if absent, return the given value. if value present, return it
	OrElseGet(types.Supplier) types.T              // OrElseGet: if absent, call Supplier and return it's result. if value present return it
	OrPanic(panicArg interface{}) types.T          // OrPanic:if absent, panic with `panicArg`, if value present, return it
	OrPanicGet(getPanicArg types.Supplier) types.T // OrPanicGet: if absent, panic with the given supplier's result. if value present, return it
}

Optional is a container which may or may not contain a non-nil value. If value is not nil, IsPresent will return true, and Get will return the value.

func Empty

func Empty() Optional

Empty return a absent optional

Example

package main

import (
	"errors"
	"fmt"

	"github.com/youthlin/stream/optional"
	"github.com/youthlin/stream/types"
)

func main() {
	fmt.Println(optional.Empty().IsPresent()) // false
	optional.Empty().IfPresent(func(t types.T) {
		fmt.Println("This will not print")
	})
	fmt.Printf("%#v\n", optional.Empty().Filter(func(t types.T) bool {
		fmt.Println("Filter: Not Reach")
		return true
	}).Map(func(t types.T) types.R {
		fmt.Println("Map: Not Reach")
		return t
	}).FlatMap(func(t types.T) optional.Optional {
		fmt.Println("FlatMap: Not Reach")
		return optional.Empty()
	}).OrElse(1)) // 1
	fmt.Println(optional.Empty().OrElseGet(func() types.T {
		return "else"
	}))
	defer func() {
		if err := recover(); err != nil {
			fmt.Println(err)
		}
		defer func() {
			if err := recover(); err != nil {
				fmt.Println(err)
				defer func() {
					if err := recover(); err != nil {
						fmt.Printf("OrPanicGet:%+v\n", err)
					}
				}()
				optional.Empty().OrPanicGet(func() types.T {
					return errors.New("err_msg")
				})
			}
		}()
		optional.Empty().OrPanic("error_msg")
	}()
	optional.Empty().Get()
}

Output:
false
1
else
absent value
error_msg
OrPanicGet:err_msg

func Of

func Of(value types.T) Optional

Of returns a present optional, the input value must not be nil, or it will panic

Example

package main

import (
	"fmt"

	"github.com/youthlin/stream/optional"
	"github.com/youthlin/stream/types"
)

func main() {
	defer func() {
		if err := recover(); err != nil {
			fmt.Println(err)
		}
		fmt.Println(optional.Of(1).IsPresent()) // true
		fmt.Println(optional.Of(1).Filter(func(t types.T) bool {
			return t.(int) > 1
		}).IsPresent()) // false
		fmt.Println(optional.Of(1).Filter(func(t types.T) bool {
			return t.(int) == 1
		}).IsPresent()) // true
		fmt.Println(optional.Of(1).Map(func(t types.T) types.R {
			return fmt.Sprintf("<%d>", t)
		}).Get())
		optional.Of(1).FlatMap(optional.Of).IfPresent(func(t types.T) {
			fmt.Printf("FlatMap: %d\n", t)
		})
		fmt.Printf("OrElse: %d\n", optional.Of(1).OrElse(0))
		fmt.Printf("OrElseGet: %d\n", optional.Of(1).OrElseGet(func() types.T {
			return 0
		}))
		fmt.Printf("OrPanic: %d\n", optional.Of(1).OrPanic("boom"))

		defer func() {
			if err := recover(); err != nil {
				fmt.Println(err)
			}
		}()
		var s *string = nil
		optional.Of(s).IfPresent(func(t types.T) {
			fmt.Printf("%v\n", t)
		})
	}()
	of := optional.Of(nil)
	fmt.Println(of)
}

Output:
nil value
true
false
true
<1>
FlatMap: 1
OrElse: 1
OrElseGet: 1
OrPanic: 1
nil value

func OfNullable

func OfNullable(value types.T) Optional

OfNullable return a absent or present optional depends on the input value is nil or false

Example

package main

import (
	"fmt"

	"github.com/youthlin/stream/optional"
)

func main() {
	fmt.Printf("nil IsPresent: %t\n", optional.OfNullable(nil).IsPresent())
	fmt.Printf("nil(*string) IsPresent: %t\n", optional.OfNullable((*string)(nil)).IsPresent())
	fmt.Printf("IsPresent: %t\n", optional.OfNullable(1).IsPresent())
}

Output:
nil IsPresent: false
nil(*string) IsPresent: false
IsPresent: true