strings

Documentation

Overview

Package strings provides strings module implementing simple functions to manipulate UTF-8 encoded strings for uGO script language. It wraps Go's strings package functionalities.

Index

• Variables

Variables

var Module = map[string]ugo.Object{

	"Contains": &ugo.Function{
		Name:    "Contains",
		Value:   stdlib.FuncPssRO(containsFunc),
		ValueEx: stdlib.FuncPssROEx(containsFunc),
	},

	"ContainsAny": &ugo.Function{
		Name:    "ContainsAny",
		Value:   stdlib.FuncPssRO(containsAnyFunc),
		ValueEx: stdlib.FuncPssROEx(containsAnyFunc),
	},

	"ContainsChar": &ugo.Function{
		Name:    "ContainsChar",
		Value:   stdlib.FuncPsrRO(containsCharFunc),
		ValueEx: stdlib.FuncPsrROEx(containsCharFunc),
	},

	"Count": &ugo.Function{
		Name:    "Count",
		Value:   stdlib.FuncPssRO(countFunc),
		ValueEx: stdlib.FuncPssROEx(countFunc),
	},

	"EqualFold": &ugo.Function{
		Name:    "EqualFold",
		Value:   stdlib.FuncPssRO(equalFoldFunc),
		ValueEx: stdlib.FuncPssROEx(equalFoldFunc),
	},

	"Fields": &ugo.Function{
		Name:    "Fields",
		Value:   stdlib.FuncPsRO(fieldsFunc),
		ValueEx: stdlib.FuncPsROEx(fieldsFunc),
	},

	"FieldsFunc": &ugo.Function{
		Name: "FieldsFunc",
		Value: func(args ...ugo.Object) (ugo.Object, error) {
			return fieldsFuncInv(ugo.NewCall(nil, args))
		},
		ValueEx: fieldsFuncInv,
	},

	"HasPrefix": &ugo.Function{
		Name:    "HasPrefix",
		Value:   stdlib.FuncPssRO(hasPrefixFunc),
		ValueEx: stdlib.FuncPssROEx(hasPrefixFunc),
	},

	"HasSuffix": &ugo.Function{
		Name:    "HasSuffix",
		Value:   stdlib.FuncPssRO(hasSuffixFunc),
		ValueEx: stdlib.FuncPssROEx(hasSuffixFunc),
	},

	"Index": &ugo.Function{
		Name:    "Index",
		Value:   stdlib.FuncPssRO(indexFunc),
		ValueEx: stdlib.FuncPssROEx(indexFunc),
	},

	"IndexAny": &ugo.Function{
		Name:    "IndexAny",
		Value:   stdlib.FuncPssRO(indexAnyFunc),
		ValueEx: stdlib.FuncPssROEx(indexAnyFunc),
	},

	"IndexByte": &ugo.Function{
		Name:    "IndexByte",
		Value:   stdlib.FuncPsrRO(indexByteFunc),
		ValueEx: stdlib.FuncPsrROEx(indexByteFunc),
	},

	"IndexChar": &ugo.Function{
		Name:    "IndexChar",
		Value:   stdlib.FuncPsrRO(indexCharFunc),
		ValueEx: stdlib.FuncPsrROEx(indexCharFunc),
	},

	"IndexFunc": &ugo.Function{
		Name: "IndexFunc",
		Value: func(args ...ugo.Object) (ugo.Object, error) {
			return newIndexFuncInv(strings.IndexFunc)(ugo.NewCall(nil, args))
		},
		ValueEx: newIndexFuncInv(strings.IndexFunc),
	},

	"Join": &ugo.Function{
		Name:    "Join",
		Value:   stdlib.FuncPAsRO(joinFunc),
		ValueEx: stdlib.FuncPAsROEx(joinFunc),
	},

	"LastIndex": &ugo.Function{
		Name:    "LastIndex",
		Value:   stdlib.FuncPssRO(lastIndexFunc),
		ValueEx: stdlib.FuncPssROEx(lastIndexFunc),
	},

	"LastIndexAny": &ugo.Function{
		Name:    "LastIndexAny",
		Value:   stdlib.FuncPssRO(lastIndexAnyFunc),
		ValueEx: stdlib.FuncPssROEx(lastIndexAnyFunc),
	},

	"LastIndexByte": &ugo.Function{
		Name:    "LastIndexByte",
		Value:   stdlib.FuncPsrRO(lastIndexByteFunc),
		ValueEx: stdlib.FuncPsrROEx(lastIndexByteFunc),
	},

	"LastIndexFunc": &ugo.Function{
		Name: "LastIndexFunc",
		Value: func(args ...ugo.Object) (ugo.Object, error) {
			return newIndexFuncInv(strings.LastIndexFunc)(ugo.NewCall(nil, args))
		},
		ValueEx: newIndexFuncInv(strings.LastIndexFunc),
	},

	"Map": &ugo.Function{
		Name: "Map",
		Value: func(args ...ugo.Object) (ugo.Object, error) {
			return mapFuncInv(ugo.NewCall(nil, args))
		},
		ValueEx: mapFuncInv,
	},

	"PadLeft": &ugo.Function{
		Name: "PadLeft",
		Value: func(args ...ugo.Object) (ugo.Object, error) {
			return pad(ugo.NewCall(nil, args), true)
		},
		ValueEx: func(c ugo.Call) (ugo.Object, error) {
			return pad(c, true)
		},
	},

	"PadRight": &ugo.Function{
		Name: "PadRight",
		Value: func(args ...ugo.Object) (ugo.Object, error) {
			return pad(ugo.NewCall(nil, args), false)
		},
		ValueEx: func(c ugo.Call) (ugo.Object, error) {
			return pad(c, false)
		},
	},

	"Repeat": &ugo.Function{
		Name:    "Repeat",
		Value:   stdlib.FuncPsiRO(repeatFunc),
		ValueEx: stdlib.FuncPsiROEx(repeatFunc),
	},

	"Replace": &ugo.Function{
		Name: "Replace",
		Value: func(args ...ugo.Object) (ugo.Object, error) {
			return replaceFunc(ugo.NewCall(nil, args))
		},
		ValueEx: replaceFunc,
	},

	"Split": &ugo.Function{
		Name: "Split",
		Value: func(args ...ugo.Object) (ugo.Object, error) {
			return newSplitFunc(strings.SplitN)(ugo.NewCall(nil, args))
		},
		ValueEx: newSplitFunc(strings.SplitN),
	},

	"SplitAfter": &ugo.Function{
		Name: "SplitAfter",
		Value: func(args ...ugo.Object) (ugo.Object, error) {
			return newSplitFunc(strings.SplitAfterN)(ugo.NewCall(nil, args))
		},
		ValueEx: newSplitFunc(strings.SplitAfterN),
	},

	"Title": &ugo.Function{
		Name:    "Title",
		Value:   stdlib.FuncPsRO(titleFunc),
		ValueEx: stdlib.FuncPsROEx(titleFunc),
	},

	"ToLower": &ugo.Function{
		Name:    "ToLower",
		Value:   stdlib.FuncPsRO(toLowerFunc),
		ValueEx: stdlib.FuncPsROEx(toLowerFunc),
	},

	"ToTitle": &ugo.Function{
		Name:    "ToTitle",
		Value:   stdlib.FuncPsRO(toTitleFunc),
		ValueEx: stdlib.FuncPsROEx(toTitleFunc),
	},

	"ToUpper": &ugo.Function{
		Name:    "ToUpper",
		Value:   stdlib.FuncPsRO(toUpperFunc),
		ValueEx: stdlib.FuncPsROEx(toUpperFunc),
	},

	"ToValidUTF8": &ugo.Function{
		Name: "ToValidUTF8",
		Value: func(args ...ugo.Object) (ugo.Object, error) {
			return toValidUTF8Func(ugo.NewCall(nil, args))
		},
		ValueEx: toValidUTF8Func,
	},

	"Trim": &ugo.Function{
		Name:    "Trim",
		Value:   stdlib.FuncPssRO(trimFunc),
		ValueEx: stdlib.FuncPssROEx(trimFunc),
	},

	"TrimFunc": &ugo.Function{
		Name: "TrimFunc",
		Value: func(args ...ugo.Object) (ugo.Object, error) {
			return newTrimFuncInv(strings.TrimFunc)(ugo.NewCall(nil, args))
		},
		ValueEx: newTrimFuncInv(strings.TrimFunc),
	},

	"TrimLeft": &ugo.Function{
		Name:    "TrimLeft",
		Value:   stdlib.FuncPssRO(trimLeftFunc),
		ValueEx: stdlib.FuncPssROEx(trimLeftFunc),
	},

	"TrimLeftFunc": &ugo.Function{
		Name: "TrimLeftFunc",
		Value: func(args ...ugo.Object) (ugo.Object, error) {
			return newTrimFuncInv(strings.TrimLeftFunc)(ugo.NewCall(nil, args))
		},
		ValueEx: newTrimFuncInv(strings.TrimLeftFunc),
	},

	"TrimPrefix": &ugo.Function{
		Name:    "TrimPrefix",
		Value:   stdlib.FuncPssRO(trimPrefixFunc),
		ValueEx: stdlib.FuncPssROEx(trimPrefixFunc),
	},

	"TrimRight": &ugo.Function{
		Name:    "TrimRight",
		Value:   stdlib.FuncPssRO(trimRightFunc),
		ValueEx: stdlib.FuncPssROEx(trimRightFunc),
	},

	"TrimRightFunc": &ugo.Function{
		Name: "TrimRightFunc",
		Value: func(args ...ugo.Object) (ugo.Object, error) {
			return newTrimFuncInv(strings.TrimRightFunc)(ugo.NewCall(nil, args))
		},
		ValueEx: newTrimFuncInv(strings.TrimRightFunc),
	},

	"TrimSpace": &ugo.Function{
		Name:    "TrimSpace",
		Value:   stdlib.FuncPsRO(trimSpaceFunc),
		ValueEx: stdlib.FuncPsROEx(trimSpaceFunc),
	},

	"TrimSuffix": &ugo.Function{
		Name:    "TrimSuffix",
		Value:   stdlib.FuncPssRO(trimSuffixFunc),
		ValueEx: stdlib.FuncPssROEx(trimSuffixFunc),
	},
}

Module represents time module.