maybe

Documentation

Overview

Package maybe provides a container type and utilities for optional values.

Index

• func Apply[A, B any](dflt B, f func(a A) B, v Maybe[A]) B
• func CatMaybes[A any](vs []Maybe[A]) []A
• func Conform[A any, CA Class[A, A, A]](c CA) func(t *testing.T, x A)
• func FromJust[A any](v Maybe[A]) A
• func FromMaybe[A any](dflt A, v Maybe[A]) A
• func IsJust[A any](v Maybe[A]) bool
• func IsNothing[A any](v Maybe[A]) bool
• func MapMaybes[A, B any](f func(A) Maybe[B], vs []A) (rs []B)
• func MaybeToList[A any](v Maybe[A]) []A
• type Class
• type Just
  • func (j Just[T]) DEmpty() bool
  • func (j Just[T]) DRest() data.Data[T]
  • func (j Just[T]) DValue() T
• type Maybe
  • func ListToMaybe[A any](vs []A) Maybe[A]
• type Nothing
  • func (n Nothing[T]) DEmpty() bool
  • func (n Nothing[T]) DRest() data.Data[T]
  • func (n Nothing[T]) DValue() T
• type Type
  • func NewType[A, B, C any]() Type[A, B, C]
  • func (t Type[A, B, C]) Apply(f Maybe[func(A) B], m Maybe[A]) Maybe[B]
  • func (t Type[A, B, C]) ApplyL(x Maybe[A], y Maybe[B]) Maybe[A]
  • func (t Type[A, B, C]) ApplyR(x Maybe[A], y Maybe[B]) Maybe[B]
  • func (t Type[A, B, C]) Bind(x Maybe[A], k func(A) Maybe[B]) Maybe[B]
  • func (t Type[A, B, C]) FMap(f func(A) B, v Maybe[A]) Maybe[B]
  • func (t Type[A, B, C]) FReplace(a A, v Maybe[B]) Maybe[A]
  • func (t Type[A, B, C]) LiftA2(f func(A, B) C, x Maybe[A], y Maybe[B]) Maybe[C]
  • func (t Type[A, B, C]) NewJust(x A) Just[A]
  • func (t Type[A, B, C]) NewNothing() Nothing[A]
  • func (t Type[A, B, C]) Pure(x A) Maybe[A]
  • func (t Type[A, B, C]) Return(x A) Maybe[A]
  • func (t Type[A, B, C]) Then(x Maybe[A], y Maybe[B]) Maybe[B]

Examples

• CatMaybes
• MapMaybes
• Maybe
• Type.FMap
• Type.FReplace

Functions

func Apply

func Apply[A, B any](dflt B, f func(a A) B, v Maybe[A]) B

Apply returns the default value `dflt` if `v` is Nothing. Otherwise it returns the result of calling `f` on `v`.

func CatMaybes

func CatMaybes[A any](vs []Maybe[A]) []A

Example

package main

import (
	"fmt"

	"github.com/calebcase/base/data/maybe"
)

func main() {
	values := []maybe.Maybe[int]{
		maybe.Just[int]{1},
		maybe.Nothing[int]{},
		maybe.Just[int]{3},
	}

	fmt.Println(maybe.CatMaybes(values))

}

Output:

[1 3]

func Conform

func Conform[
	A any,

	CA Class[A, A, A],
](c CA) func(t *testing.T, x A)

Conform returns a function testing if the implementation abides by its laws.

func FromJust

func FromJust[A any](v Maybe[A]) A

func FromMaybe

func FromMaybe[A any](dflt A, v Maybe[A]) A

func IsJust

func IsJust[A any](v Maybe[A]) bool

func IsNothing

func IsNothing[A any](v Maybe[A]) bool

func MapMaybes

func MapMaybes[A, B any](f func(A) Maybe[B], vs []A) (rs []B)

Example

package main

import (
	"fmt"
	"strconv"

	"github.com/calebcase/base/data/maybe"
)

func main() {
	values := []string{
		"1",
		"foo",
		"3",
	}

	maybeInt := func(s string) maybe.Maybe[int] {
		i, err := strconv.Atoi(s)
		if err != nil {
			return maybe.Nothing[int]{}
		}

		return maybe.Just[int]{i}
	}

	fmt.Println(maybe.MapMaybes(maybeInt, values))

}

Output:

[1 3]

func MaybeToList

func MaybeToList[A any](v Maybe[A]) []A

Types

type Class

type Class[A, B, C any] interface {
	monad.Class[A, B, C, Maybe[func(A) B], Maybe[A], Maybe[B], Maybe[C]]

	NewJust(A) Just[A]
	NewNothing() Nothing[A]
}

type Just

type Just[T any] struct {
	Value T
}

Just contains a value.

func (Just[T]) DEmpty

func (j Just[T]) DEmpty() bool

func (Just[T]) DRest

func (j Just[T]) DRest() data.Data[T]

func (Just[T]) DValue

func (j Just[T]) DValue() T

type Maybe

type Maybe[T any] interface {
	data.Data[T]
	// contains filtered or unexported methods
}

Maybe is the sum type for maybe.

Example

package main

import (
	"fmt"

	"github.com/calebcase/base/data/maybe"
)

func main() {
	// Odd returns true if the integer is odd.
	odd := func(v int) bool {
		return v%2 != 0
	}

	// NOTE: The additional type hinting `maybe.Apply[int](...)` is
	// currently necessary because of a limitation in Go's type
	// inferencing. The hinting may eventually be unnecessary when/if the
	// type inferencing improves for generics. Alternately the types can be
	// explicitly set on the Maybe function instead.
	fmt.Println(maybe.Apply(false, odd, maybe.Maybe[int](maybe.Just[int]{3})))
	fmt.Println(maybe.Apply[int](false, odd, maybe.Just[int]{3}))

	fmt.Println(maybe.Apply(false, odd, maybe.Maybe[int](maybe.Nothing[int]{})))
	fmt.Println(maybe.Apply[int](false, odd, maybe.Nothing[int]{}))

	// These all produce the desired compile time error (because the types
	// are mismatched):
	//
	//fmt.Println(maybe.Apply(false, odd, maybe.Maybe[float32](maybe.Nothing[int]{})))
	//fmt.Println(maybe.Apply(false, odd, maybe.Maybe[float32](maybe.Nothing[float32]{})))
	//fmt.Println(maybe.Apply(false, odd, maybe.Maybe[int](maybe.Just[float32]{3})))
	//fmt.Println(maybe.Apply[int, bool](false, odd, maybe.Just[float32]{3}))

	// str returns the string even or odd for the value.
	str := func(v int) string {
		if v%2 == 0 {
			return "even"
		}

		return "odd"
	}

	fmt.Println(maybe.Apply("unknown", str, maybe.Maybe[int](maybe.Just[int]{3})))
	fmt.Println(maybe.Apply("unknown", str, maybe.Maybe[int](maybe.Just[int]{4})))
	fmt.Println(maybe.Apply("unknown", str, maybe.Maybe[int](maybe.Nothing[int]{})))

}

Output:

true
true
false
false
odd
even
unknown

func ListToMaybe

func ListToMaybe[A any](vs []A) Maybe[A]

type Nothing

type Nothing[T any] struct{}

Nothing indicates no value is present.

func (Nothing[T]) DEmpty

func (n Nothing[T]) DEmpty() bool

func (Nothing[T]) DRest

func (n Nothing[T]) DRest() data.Data[T]

func (Nothing[T]) DValue

func (n Nothing[T]) DValue() T

type Type

type Type[A, B, C any] struct{}

func NewType

func NewType[A, B, C any]() Type[A, B, C]

func (Type[A, B, C]) Apply

func (t Type[A, B, C]) Apply(f Maybe[func(A) B], m Maybe[A]) Maybe[B]

func (Type[A, B, C]) ApplyL

func (t Type[A, B, C]) ApplyL(x Maybe[A], y Maybe[B]) Maybe[A]

func (Type[A, B, C]) ApplyR

func (t Type[A, B, C]) ApplyR(x Maybe[A], y Maybe[B]) Maybe[B]

func (Type[A, B, C]) Bind

func (t Type[A, B, C]) Bind(x Maybe[A], k func(A) Maybe[B]) Maybe[B]

func (Type[A, B, C]) FMap

func (t Type[A, B, C]) FMap(f func(A) B, v Maybe[A]) Maybe[B]

Example

package main

import (
	"fmt"

	"github.com/calebcase/base/data/maybe"
)

func main() {
	flip := func(a bool) bool {
		return !a
	}

	flop := maybe.NewType[bool, bool, bool]().FMap(flip, maybe.Just[bool]{true})
	fmt.Println(flop)

	stringify := func(a bool) string {
		return fmt.Sprint(a)
	}

	str := maybe.NewType[bool, string, bool]().FMap(stringify, maybe.Just[bool]{true})
	fmt.Println(str)

	fmt.Println(maybe.NewType[bool, string, bool]().FMap(stringify, maybe.Nothing[bool]{}))

}

Output:

{false}
{true}
{}

func (Type[A, B, C]) FReplace

func (t Type[A, B, C]) FReplace(a A, v Maybe[B]) Maybe[A]

Example

package main

import (
	"fmt"

	"github.com/calebcase/base/data/maybe"
)

func main() {
	fmt.Println(maybe.NewType[bool, bool, bool]().FReplace(false, maybe.Just[bool]{true}))
	fmt.Println(maybe.NewType[string, bool, bool]().FReplace("done", maybe.Just[bool]{true}))
	fmt.Println(maybe.NewType[string, bool, bool]().FReplace("done", maybe.Nothing[bool]{}))

}

Output:

{false}
{done}
{}

func (Type[A, B, C]) LiftA2

func (t Type[A, B, C]) LiftA2(f func(A, B) C, x Maybe[A], y Maybe[B]) Maybe[C]

func (Type[A, B, C]) NewJust

func (t Type[A, B, C]) NewJust(x A) Just[A]

func (Type[A, B, C]) NewNothing

func (t Type[A, B, C]) NewNothing() Nothing[A]

func (Type[A, B, C]) Pure

func (t Type[A, B, C]) Pure(x A) Maybe[A]

func (Type[A, B, C]) Return

func (t Type[A, B, C]) Return(x A) Maybe[A]

func (Type[A, B, C]) Then

func (t Type[A, B, C]) Then(x Maybe[A], y Maybe[B]) Maybe[B]