to

README

Library of Converters in Go 1.18+

• Stringer Interface
• Any->String
• String->Lines
• Func->FuncName

Documentation

Overview

Package to contains a number of converters that take any number of types and return something transformed from them. It also contains a more granular approach to fmt.Stringer.

Index

• func FuncName(i any) string
• func Human(a any) string
• func Lines(in any) []string
• func String(in any) string
• type HumanFriend
• type Stringer

Examples

• FuncName
• Human
• Lines
• String

Functions

func FuncName

func FuncName(i any) string

FuncName makes a best effort attempt to return the string name of the passed function. Anonymous functions are named "funcN" where N is the order of appearance within the current scope. Note that this function will panic if not passed a function.

Example

package main

import (
	"github.com/rwxrob/fn"
	"github.com/rwxrob/fn/each"
	"github.com/rwxrob/to"
)

func Foo() {}

func main() {

	f1 := func() {}
	f2 := func() {}

	// Foo is defined outside of the ExampleFuncName

	each.Println(fn.Map([]any{f1, f2, Foo, to.Lines}, to.FuncName))

}

Output:
func1
func2
Foo
Lines

func Human

func Human(a any) string

Human returns a human-friendly string version of the item, specifically:

• single-quoted runes
• double-quoted strings
• numbers as numbers
• function names are looked up
• slices joined with "," and wrapped in []

Anything else is rendered as its fmt.Sprintf("%v",it) form.

Example

package main

import (
	"fmt"

	"github.com/rwxrob/to"
)

type FooStruct struct{}

func (f FooStruct) String() string { return "FOO" }

type HumanFoo struct{}

func (f HumanFoo) Human() string { return "a friendly foo" }

func FooFunc(a any) {}

func main() {
	fmt.Println(to.Human('r'))                    // not number
	fmt.Println(to.Human("string💢good"))          // unescaped
	fmt.Println(to.Human(new(FooStruct)))         // has String()
	fmt.Println(to.Human(new(HumanFoo)))          // has Human()
	fmt.Println(to.Human([]rune{'r', 's', 'm'}))  // commas
	fmt.Println(to.Human([]string{"foo", "bar"})) // also commas
	fmt.Println(to.Human(func() {}))              // func1
	fmt.Println(to.Human(FooFunc))                // FooFunc
}

Output:
'r'
"string💢good"
FOO
a friendly foo
['r','s','m']
["foo","bar"]
func1
FooFunc

func Lines

func Lines(in any) []string

Lines transforms the input into a string and then divides that string up into lines (\r?\n) suitable for functional map operations.

Example

package main

import (
	"github.com/rwxrob/fn/each"
	"github.com/rwxrob/to"
)

func main() {
	buf := `
some

thing 
here

mkay
`
	each.Print(to.Lines(buf))
}

Output:
something heremkay

func String

func String(in any) string

String converts whatever is passed to its fmt.Sprintf("%v") string version (but avoids calling it if possible). Be sure you use things with consistent string representations.

Example

package main

import (
	"fmt"

	"github.com/rwxrob/to"
)

type stringer struct{}

func (s stringer) String() string { return "stringer" }

func main() {
	stuff := []any{
		"some", []byte{'t', 'h', 'i', 'n', 'g'},
		1, 2.234, stringer{},
	}
	for _, s := range stuff {
		fmt.Printf("%q ", to.String(s))
	}
}

Output:
"some" "thing" "1" "2.234" "stringer"

Types

type HumanFriend

type HumanFriend interface {
	Human() string
}

HumanFriend implementations have a human readable form that is even friendlier than fmt.Stringer.

type Stringer

type Stringer interface {
	String() string
	StringLong() string
}

Stringer interfaces fulfills fmt.Stringer with the additional promise that the output of String method will always be both consistently parsable (say as JSON) and will never span more than a single line. Stringer also requires the StringLong method promising to produce parsable strings that span multiple lines to remain easy to read.