CEL
Functions
Standard functions included in the Twisp CEL runtime.
CEL provides function invocation within expressions to perform operations and computations. Twisp includes a number of predefined extensions to the CEL runtime environment for computation within ledger transactions.
Packages
The included package functions are:
- Strongly-typed: The function signatures of a package require that the arguments provided have the expected types.
- Side-effect-free: Package functions only calculate an output based on the inputs given.
The Twisp CEL runtime has been extended with the following packages and their respective function signatures.
cal
func cal.Quarter(ts &{types Timestamp}, fiscalStartMonth int) int
Quarter returns the quarter based on the fiscalStartMonth:
fiscalStartMonth: 1 (time.January) standard fiscalStartMonth: 10 (time.October) US Government
func cal.WeekOfYear(ts &{types Timestamp}, dow int, doy int) YearWeek
WeekOfYear returns the week of year given:
- dow day of week that starts the week (Sunday:0 - Saturday: 6)
- doy first January day that must appear in week 1.
Common Settings: USA: dow 0 doy 1 (First January 1st in year) ISO: dow 1 doy 4 (First Thursday of year equivalent to first Jan 4 in year)
func cal.ISOWeekOfYear(ts &{types Timestamp}) YearWeek
ISOWeekOfYear returns the ISO year and week of the timestamp. See https://en.wikipedia.org/wiki/ISO_8601#Week_dates
decimal
func decimal.Abs(x decimal) decimal, error
Abs calculates |x| (the absolute value of x).
func decimal.Add(x decimal, y decimal) decimal, error
Add calculates the sum of x+y.
func decimal.Cbrt(x decimal) decimal, error
Cbrt calculates the cube root of x.
func decimal.Ceil(x decimal) decimal, error
Ceil calculates smallest integer >= x.
func decimal.Cmp(x decimal, y decimal) decimal, error
Cmp compares x and y and calculates:
-1 if x < y
0 if x == y
+1 if x > y
This comparison respects the normal rules of special values (like NaN), and does not compare them.
func decimal.Exp(x decimal, precision uint32) decimal, error
Exp calculates e**x.
func decimal.Ln(x decimal) decimal, error
Ln calculates the natural log of x.
func decimal.Log10(x decimal) decimal, error
Log10 calculates the base 10 log of x.
func decimal.Mul(x decimal, y decimal) decimal, error
Mul calculates the product x*y.
func decimal.Neg(x decimal) decimal, error
Neg calculates -x.
func decimal.Pow(x decimal, y decimal) decimal, error
Pow calculates x**y.
func decimal.Quantize(x decimal, exp int, precision uint32) decimal, error
Quantize calculates and rounds x as necessary so it is represented with exponent exp.
func decimal.Quo(x decimal, y decimal, precision uint32) decimal, error
Quo calculates the quotient x/y for y != 0.
func decimal.QuoInteger(x decimal, y decimal, precision uint32) decimal, error
QuoInteger calculates the integer part of the quotient x/y
func decimal.Reduce(x decimal) decimal, error
Reduce calculates x with all trailing zeros removed.
func decimal.Rem(x decimal, y decimal, precision uint32) decimal, error
Rem calculates the remainder part of the quotient x/y.
func decimal.Sqrt(x decimal) decimal, error
Sqrt calculates the square root of x. Sqrt uses the Babylonian method for computing the square root, which uses O(log p) steps for p digits of precision.
func decimal.Sub(x decimal, y decimal) decimal, error
Sub calculates the difference x-y.
func decimal.Round(x decimal, mode string, digits int) decimal, error
Round rounds x to the number of digits with the specified rounding mode. Supported rounding modes:
down
Rounds toward 0; truncate.
half_up
Rounds up if the digits are >= 0.5.
half_even
Rounds up if the digits are > 0.5. If the digits are equal to 0.5, it rounds up if the previous digit is odd, always producing an even digit.
ceiling
Rounds towards +Inf: rounds up if digits are > 0 and the number is positive.
floor
Rounds towards -Inf: rounds up if digits are > 0 and the number is negative.
half_down
Rounds up if the digits are > 0.5.
up
Rounds away from 0.
05up
Rounds zero or five away from 0; same as round-up, except that rounding up only occurs if the digit to be rounded up is 0 or 5.
finance
func finance.DaysDifference(date1 int64, date2 int64, basis int) int
DaysDifference returns the difference of days between two dates based on a daycount basis. Date1 and date2 are UNIX timestamps (seconds). "basis" must be one of: 0 = US(NASD) 30/360, 1 = Actual/actual, 2 = Actual/360, 3 = Actual/365, 4 = European 30/360.
func finance.DaysPerYear(year int, basis int) int
DaysPerYear returns the number of days in the year based on a daycount basis. "basis" must be one of: 0 = US(NASD) 30/360, 1 = Actual/actual, 2 = Actual/360, 3 = Actual/365, 4 = European 30/360.
func finance.DepreciationFixedDeclining(cost float64, salvage float64, life int, period int, month int) float64, error
DepreciationFixedDeclining returns the depreciation of an asset using the fixed-declining balance method. Excel equivalent: DB. "basis" must be one of: 0 = US(NASD) 30/360, 1 = Actual/actual, 2 = Actual/360, 3 = Actual/365, 4 = European 30/360.
func finance.DepreciationSYD(cost float64, salvage float64, life int, per int) float64
DepreciationSYD returns the depreciation for an asset in a given period using the sum-of-years' digits method. Excel equivalent: SYD.
func finance.DepreciationStraightLine(cost float64, salvage float64, life int) float64, error
DepreciationStraightLine returns the straight-line depreciation of an asset for each period. Excel equivalent: SLN.
func finance.DiscountRate(settlement int64, maturity int64, price float64, redemption float64, basis int) float64
DiscountRate returns the discount rate for a bond "settlement" is the unix timestamp (seconds) for the settlement date. "maturity" is the unix timestamp (seconds) for the maturity date. "price" is the bond's price per $100 face value. "redemption" is the bond's redemption value per $100 face value. Excel equivalent: DISC. "basis" must be one of: 0 = US(NASD) 30/360, 1 = Actual/actual, 2 = Actual/360, 3 = Actual/365, 4 = European 30/360.
func finance.EffectiveRate(nominal float64, numPeriods int) float64, error
EffectiveRate returns the effective interest rate given the nominal rate and the number of compounding payments per year. Excel equivalent: EFFECT.
func finance.FutureValue(rate float64, numPeriods int, pmt float64, pv float64, paymentType int)fv float64, err error
FutureValue returns the Future Value of a cash flow with constant payments and interest rate (annuities). Excel equivalent: FV. "paymentType" must be one of: 0 = PayEnd, 1 = PayBegin.
func finance.InterestPayment(rate float64, period int, numPeriods int, pv float64, fv float64, paymentType int) float64, error
InterestPayment returns the interest payment for a given period for a cash flow with constant periodic payments (annuities). Excel equivalent: IMPT. "paymentType" must be one of: 0 = PayEnd, 1 = PayBegin.
func finance.NominalRate(effectiveRate float64, numPeriods int) float64, error
NominalRate returns the nominal interest rate given the effective rate and the number of compounding payments per year. Excel equivalent: NOMINAL.
func finance.Payment(rate float64, numPeriods int, pv float64, fv float64, paymentType int)pmt float64, err error
Payment returns the constant payment (annuity) for a cash flow with a constant interest rate. Excel equivalent: PMT. "paymentType" must be one of: 0 = PayEnd, 1 = PayBegin.
func finance.Periods(rate float64, pmt float64, pv float64, fv float64, paymentType int)numPeriods float64, err error
Periods returns the number of periods for a cash flow with constant periodic payments (annuities), and interest rate. Excel equivalent: NPER. "paymentType" must be one of: 0 = PayEnd, 1 = PayBegin.
func finance.PresentValue(rate float64, numPeriods int, pmt float64, fv float64, paymentType int)pv float64, err error
PresentValue returns the Present Value of a cash flow with constant payments and interest rate (annuities). Excel equivalent: PV. "paymentType" must be one of: 0 = PayEnd, 1 = PayBegin.
func finance.PriceDiscount(settlement int64, maturity int64, discount float64, redemption float64, basis int) float64
PriceDiscount returns the price per $100 face value of a discounted bond. "settlement" is the unix timestamp (seconds) for the settlement date. "maturity" is the unix timestamp (seconds) for the maturity date. "discount" is the bond's discount rate. "redemption" is the bond's redemption value per $100 face value. Excel equivalent: PRICEDISC. "basis" must be one of: 0 = US(NASD) 30/360, 1 = Actual/actual, 2 = Actual/360, 3 = Actual/365, 4 = European 30/360.
func finance.PrincipalPayment(rate float64, period int, numPeriods int, pv float64, fv float64, paymentType int) float64, error
PrincipalPayment returns the principal payment for a given period for a cash flow with constant periodic payments (annuities). Excel equivalent: PPMT. "paymentType" must be one of: 0 = PayEnd, 1 = PayBegin.
func finance.Rate(numPeriods int, pmt float64, pv float64, fv float64, paymentType int, guess float64) float64, error
Rate returns the periodic interest rate for a cash flow with constant periodic payments (annuities). Guess is a guess for the rate, used as a starting point for the iterative algorithm. Excel equivalent: RATE. "paymentType" must be one of: 0 = PayEnd, 1 = PayBegin.
func finance.TBillEquivalentYield(settlement int64, maturity int64, discount float64) float64, error
TBillEquivalentYield returns the bond-equivalent yield for a Treasury bill. "settlement" is the unix timestamp (seconds) for the settlement date. "maturity" is the unix timestamp (seconds) for the maturity date. "discount" is the T-Bill discount rate. Excel equivalent: TBILLEQ.
func finance.TBillPrice(settlement int64, maturity int64, discount float64) float64, error
TBillPrice returns the price per $100 face value for a Treasury bill. "settlement" is the unix timestamp (seconds) for the settlement date. "maturity" is the unix timestamp (seconds) for the maturity date. "discount" is the T-Bill discount rate. Excel equivalent: TBILLPRICE.
func finance.TBillYield(settlement int64, maturity int64, price float64) float64, error
TBillYield returns the yield for a treasury bill. "settlement" is the unix timestamp (seconds) for the settlement date. "maturity" is the unix timestamp (seconds) for the maturity date. "price" is the TBill price per $100 face value. Excel equivalent: TBILLYIELD.
hex
func hex.EncodeToString(src []byte) string
EncodeToString returns the hexadecimal encoding of src.
func hex.DecodeString(s string) []byte, error
DecodeString returns the bytes represented by the hexadecimal string s.
DecodeString expects that src contains only hexadecimal characters and that src has even length. If the input is malformed, DecodeString returns the bytes decoded before the error.
html
func html.EscapeString(s string) string
EscapeString escapes special characters like "<" to become "<". It escapes only five such characters: <, >, &, ' and ". UnescapeString(EscapeString(s)) == s always holds, but the converse isn't always true.
func html.UnescapeString(s string) string
UnescapeString unescapes entities like "<" to become "<". It unescapes a larger range of entities than EscapeString escapes. For example, "á" unescapes to "á", as does "á" and "á". UnescapeString(EscapeString(s)) == s always holds, but the converse isn't always true.
json
func json.Marshal(v any) []byte, error
Marshal returns the JSON encoding of v.
Marshal traverses the value v recursively. If an encountered value implements [Marshaler] and is not a nil pointer, Marshal calls [Marshaler.MarshalJSON] to produce JSON. If no [Marshaler.MarshalJSON] method is present but the value implements [encoding.TextMarshaler] instead, Marshal calls [encoding.TextMarshaler.MarshalText] and encodes the result as a JSON string. The nil pointer exception is not strictly necessary but mimics a similar, necessary exception in the behavior of [Unmarshaler.UnmarshalJSON].
Otherwise, Marshal uses the following type-dependent default encodings:
Boolean values encode as JSON booleans.
Floating point, integer, and [Number] values encode as JSON numbers. NaN and +/-Inf values will return an [UnsupportedValueError].
String values encode as JSON strings coerced to valid UTF-8, replacing invalid bytes with the Unicode replacement rune. So that the JSON will be safe to embed inside HTML tags, the string is encoded using [HTMLEscape], which replaces "<", ">", "&", U+2028, and U+2029 are escaped to "\u003c","\u003e", "\u0026", "\u2028", and "\u2029". This replacement can be disabled when using an [Encoder], by calling Encoder.SetEscapeHTML(false).
Array and slice values encode as JSON arrays, except that []byte encodes as a base64-encoded string, and a nil slice encodes as the null JSON value.
Struct values encode as JSON objects. Each exported struct field becomes a member of the object, using the field name as the object key, unless the field is omitted for one of the reasons given below.
The encoding of each struct field can be customized by the format string stored under the "json" key in the struct field's tag. The format string gives the name of the field, possibly followed by a comma-separated list of options. The name may be empty in order to specify options without overriding the default field name.
The "omitempty" option specifies that the field should be omitted from the encoding if the field has an empty value, defined as false, 0, a nil pointer, a nil interface value, and any empty array, slice, map, or string.
As a special case, if the field tag is "-", the field is always omitted. Note that a field with name "-" can still be generated using the tag "-,".
Examples of struct field tags and their meanings:
// Field appears in JSON as key "myName".
Field int `json:"myName"`
// Field appears in JSON as key "myName" and
// the field is omitted from the object if its value is empty,
// as defined above.
Field int `json:"myName,omitempty"`
// Field appears in JSON as key "Field" (the default), but
// the field is skipped if empty.
// Note the leading comma.
Field int `json:",omitempty"`
// Field is ignored by this package.
Field int `json:"-"`
// Field appears in JSON as key "-".
Field int `json:"-,"`
The "string" option signals that a field is stored as JSON inside a JSON-encoded string. It applies only to fields of string, floating point, integer, or boolean types. This extra level of encoding is sometimes used when communicating with JavaScript programs:
Int64String int64 `json:",string"`
The key name will be used if it's a non-empty string consisting of only Unicode letters, digits, and ASCII punctuation except quotation marks, backslash, and comma.
Embedded struct fields are usually marshaled as if their inner exported fields were fields in the outer struct, subject to the usual Go visibility rules amended as described in the next paragraph. An anonymous struct field with a name given in its JSON tag is treated as having that name, rather than being anonymous. An anonymous struct field of interface type is treated the same as having that type as its name, rather than being anonymous.
The Go visibility rules for struct fields are amended for JSON when deciding which field to marshal or unmarshal. If there are multiple fields at the same level, and that level is the least nested (and would therefore be the nesting level selected by the usual Go rules), the following extra rules apply:
Of those fields, if any are JSON-tagged, only tagged fields are considered, even if there are multiple untagged fields that would otherwise conflict.
If there is exactly one field (tagged or not according to the first rule), that is selected.
Otherwise there are multiple fields, and all are ignored; no error occurs.
Handling of anonymous struct fields is new in Go 1.1. Prior to Go 1.1, anonymous struct fields were ignored. To force ignoring of an anonymous struct field in both current and earlier versions, give the field a JSON tag of "-".
Map values encode as JSON objects. The map's key type must either be a string, an integer type, or implement [encoding.TextMarshaler]. The map keys are sorted and used as JSON object keys by applying the following rules, subject to the UTF-8 coercion described for string values above:
- keys of any string type are used directly
- keys that implement [encoding.TextMarshaler] are marshaled
- integer keys are converted to strings
Pointer values encode as the value pointed to. A nil pointer encodes as the null JSON value.
Interface values encode as the value contained in the interface. A nil interface value encodes as the null JSON value.
Channel, complex, and function values cannot be encoded in JSON. Attempting to encode such a value causes Marshal to return an [UnsupportedTypeError].
JSON cannot represent cyclic data structures and Marshal does not handle them. Passing cyclic structures to Marshal will result in an error.
math
func math.Abs(x float64) float64
Abs returns the absolute value of x.
Special cases are:
Abs(±Inf) = +Inf
Abs(NaN) = NaN
func math.Cbrt(x float64) float64
Cbrt returns the cube root of x.
Special cases are:
Cbrt(±0) = ±0
Cbrt(±Inf) = ±Inf
Cbrt(NaN) = NaN
func math.Copysign(f float64, sign float64) float64
Copysign returns a value with the magnitude of f and the sign of sign.
func math.Dim(x float64, y float64) float64
Dim returns the maximum of x-y or 0.
Special cases are:
Dim(+Inf, +Inf) = NaN
Dim(-Inf, -Inf) = NaN
Dim(x, NaN) = Dim(NaN, x) = NaN
func math.Max(x float64, y float64) float64
Max returns the larger of x or y.
Special cases are:
Max(x, +Inf) = Max(+Inf, x) = +Inf
Max(x, NaN) = Max(NaN, x) = NaN
Max(+0, ±0) = Max(±0, +0) = +0
Max(-0, -0) = -0
Note that this differs from the built-in function max when called with NaN and +Inf.
func math.Min(x float64, y float64) float64
Min returns the smaller of x or y.
Special cases are:
Min(x, -Inf) = Min(-Inf, x) = -Inf
Min(x, NaN) = Min(NaN, x) = NaN
Min(-0, ±0) = Min(±0, -0) = -0
Note that this differs from the built-in function min when called with NaN and -Inf.
func math.Exp(x float64) float64
Exp returns e**x, the base-e exponential of x.
Special cases are:
Exp(+Inf) = +Inf
Exp(NaN) = NaN
Very large values overflow to 0 or +Inf. Very small values underflow to 1.
func math.Exp2(x float64) float64
Exp2 returns 2**x, the base-2 exponential of x.
Special cases are the same as [Exp].
func math.Expm1(x float64) float64
Expm1 returns e**x - 1, the base-e exponential of x minus 1. It is more accurate than Exp(x) - 1 when x is near zero.
Special cases are:
Expm1(+Inf) = +Inf
Expm1(-Inf) = -1
Expm1(NaN) = NaN
Very large values overflow to -1 or +Inf.
func math.Floor(x float64) float64
Floor returns the greatest integer value less than or equal to x.
Special cases are:
Floor(±0) = ±0
Floor(±Inf) = ±Inf
Floor(NaN) = NaN
func math.Ceil(x float64) float64
Ceil returns the least integer value greater than or equal to x.
Special cases are:
Ceil(±0) = ±0
Ceil(±Inf) = ±Inf
Ceil(NaN) = NaN
func math.Trunc(x float64) float64
Trunc returns the integer value of x.
Special cases are:
Trunc(±0) = ±0
Trunc(±Inf) = ±Inf
Trunc(NaN) = NaN
func math.Round(x float64) float64
Round returns the nearest integer, rounding half away from zero.
Special cases are:
Round(±0) = ±0
Round(±Inf) = ±Inf
Round(NaN) = NaN
func math.RoundToEven(x float64) float64
RoundToEven returns the nearest integer, rounding ties to even.
Special cases are:
RoundToEven(±0) = ±0
RoundToEven(±Inf) = ±Inf
RoundToEven(NaN) = NaN
func math.FMA(x float64, y float64, z float64) float64
FMA returns x * y + z, computed with only one rounding. (That is, FMA returns the fused multiply-add of x, y, and z.)
func math.Hypot(p float64, q float64) float64
Hypot returns [Sqrt](pp + qq), taking care to avoid unnecessary overflow and underflow.
Special cases are:
Hypot(±Inf, q) = +Inf
Hypot(p, ±Inf) = +Inf
Hypot(NaN, q) = NaN
Hypot(p, NaN) = NaN
func math.Log(x float64) float64
Log returns the natural logarithm of x.
Special cases are:
Log(+Inf) = +Inf
Log(0) = -Inf
Log(x < 0) = NaN
Log(NaN) = NaN
func math.Log10(x float64) float64
Log10 returns the decimal logarithm of x. The special cases are the same as for [Log].
func math.Log2(x float64) float64
Log2 returns the binary logarithm of x. The special cases are the same as for [Log].
func math.Log1p(x float64) float64
Log1p returns the natural logarithm of 1 plus its argument x. It is more accurate than [Log](1 + x) when x is near zero.
Special cases are:
Log1p(+Inf) = +Inf
Log1p(±0) = ±0
Log1p(-1) = -Inf
Log1p(x < -1) = NaN
Log1p(NaN) = NaN
func math.Mod(x float64, y float64) float64
Mod returns the floating-point remainder of x/y. The magnitude of the result is less than y and its sign agrees with that of x.
Special cases are:
Mod(±Inf, y) = NaN
Mod(NaN, y) = NaN
Mod(x, 0) = NaN
Mod(x, ±Inf) = x
Mod(x, NaN) = NaN
func math.Pow(x float64, y float64) float64
Pow returns x**y, the base-x exponential of y.
Special cases are (in order):
Pow(x, ±0) = 1 for any x
Pow(1, y) = 1 for any y
Pow(x, 1) = x for any x
Pow(NaN, y) = NaN
Pow(x, NaN) = NaN
Pow(±0, y) = ±Inf for y an odd integer < 0
Pow(±0, -Inf) = +Inf
Pow(±0, +Inf) = +0
Pow(±0, y) = +Inf for finite y < 0 and not an odd integer
Pow(±0, y) = ±0 for y an odd integer > 0
Pow(±0, y) = +0 for finite y > 0 and not an odd integer
Pow(-1, ±Inf) = 1
Pow(x, +Inf) = +Inf for |x| > 1
Pow(x, -Inf) = +0 for |x| > 1
Pow(x, +Inf) = +0 for |x| < 1
Pow(x, -Inf) = +Inf for |x| < 1
Pow(+Inf, y) = +Inf for y > 0
Pow(+Inf, y) = +0 for y < 0
Pow(-Inf, y) = Pow(-0, -y)
Pow(x, y) = NaN for finite x < 0 and finite non-integer y
func math.Pow10(n int) float64
Pow10 returns 10**n, the base-10 exponential of n.
Special cases are:
Pow10(n) = 0 for n < -323
Pow10(n) = +Inf for n > 308
func math.Remainder(x float64, y float64) float64
Remainder returns the IEEE 754 floating-point remainder of x/y.
Special cases are:
Remainder(±Inf, y) = NaN
Remainder(NaN, y) = NaN
Remainder(x, 0) = NaN
Remainder(x, ±Inf) = x
Remainder(x, NaN) = NaN
func math.Signbit(x float64) bool
Signbit reports whether x is negative or negative zero.
func math.Sqrt(x float64) float64
Sqrt returns the square root of x.
Special cases are:
Sqrt(+Inf) = +Inf
Sqrt(±0) = ±0
Sqrt(x < 0) = NaN
Sqrt(NaN) = NaN
md5
func md5.Sum(data []byte) []byte
Sum returns the MD5 checksum of the data.
money
func money.Add(a money, b money) money, error
Add two Money types and return the result
func money.Sub(a money, b money) money, error
Compute the difference between two Money types
func money.Mul(a money, b string) money, error
Multiply a Money type by a string-represented number
func money.Div(a money, b string) money, error
Divide a Money type by a string-represented number
path
func path.Clean(path string) string
Clean returns the shortest path name equivalent to path by purely lexical processing. It applies the following rules iteratively until no further processing can be done:
- Replace multiple slashes with a single slash.
- Eliminate each . path name element (the current directory).
- Eliminate each inner .. path name element (the parent directory) along with the non-.. element that precedes it.
- Eliminate .. elements that begin a rooted path: that is, replace "/.." by "/" at the beginning of a path.
The returned path ends in a slash only if it is the root "/".
If the result of this process is an empty string, Clean returns the string ".".
See also Rob Pike, “Lexical File Names in Plan 9 or Getting Dot-Dot Right,” https://9p.io/sys/doc/lexnames.html
func path.Ext(path string) string
Ext returns the file name extension used by path. The extension is the suffix beginning at the final dot in the final slash-separated element of path; it is empty if there is no dot.
func path.Base(path string) string
Base returns the last element of path. Trailing slashes are removed before extracting the last element. If the path is empty, Base returns ".". If the path consists entirely of slashes, Base returns "/".
func path.IsAbs(path string) bool
IsAbs reports whether the path is absolute.
func path.Dir(path string) string
Dir returns all but the last element of path, typically the path's directory. After dropping the final element using [Split], the path is Cleaned and trailing slashes are removed. If the path is empty, Dir returns ".". If the path consists entirely of slashes followed by non-slash bytes, Dir returns a single slash. In any other case, the returned path does not end in a slash.
rand
func rand.Int63() int64
Int63 returns a non-negative pseudo-random 63-bit integer as an int64 from the default [Source].
func rand.Uint32() uint32
Uint32 returns a pseudo-random 32-bit value as a uint32 from the default [Source].
func rand.Uint64() uint64
Uint64 returns a pseudo-random 64-bit value as a uint64 from the default [Source].
func rand.Int31() int32
Int31 returns a non-negative pseudo-random 31-bit integer as an int32 from the default [Source].
func rand.Int() int
Int returns a non-negative pseudo-random int from the default [Source].
func rand.Int63n(n int64) int64
Int63n returns, as an int64, a non-negative pseudo-random number in the half-open interval [0,n) from the default [Source]. It panics if n <= 0.
func rand.Int31n(n int32) int32
Int31n returns, as an int32, a non-negative pseudo-random number in the half-open interval [0,n) from the default [Source]. It panics if n <= 0.
func rand.Intn(n int) int
Intn returns, as an int, a non-negative pseudo-random number in the half-open interval [0,n) from the default [Source]. It panics if n <= 0.
func rand.Float64() float64
Float64 returns, as a float64, a pseudo-random number in the half-open interval [0.0,1.0) from the default [Source].
func rand.Float32() float32
Float32 returns, as a float32, a pseudo-random number in the half-open interval [0.0,1.0) from the default [Source].
func rand.NormFloat64() float64
NormFloat64 returns a normally distributed float64 in the range [-[math.MaxFloat64], +[math.MaxFloat64]] with standard normal distribution (mean = 0, stddev = 1) from the default [Source]. To produce a different normal distribution, callers can adjust the output using:
sample = NormFloat64() * desiredStdDev + desiredMean
func rand.ExpFloat64() float64
ExpFloat64 returns an exponentially distributed float64 in the range (0, +[math.MaxFloat64]] with an exponential distribution whose rate parameter (lambda) is 1 and whose mean is 1/lambda (1) from the default [Source]. To produce a distribution with a different rate parameter, callers can adjust the output using:
sample = ExpFloat64() / desiredRateParameter
sha1
func sha1.Sum(data []byte) []byte
Sum returns the SHA-1 checksum of the data.
sha256
func sha256.Sum256(data []byte) []byte
Sum256 returns the SHA256 checksum of the data.
sha512
func sha512.Sum512(data []byte) []byte
Sum512 returns the SHA512 checksum of the data.
strings
func strings.Compare(a string, b string) int
Compare returns an integer comparing two strings lexicographically. The result will be 0 if a == b, -1 if a < b, and +1 if a > b.
Use Compare when you need to perform a three-way comparison (with [slices.SortFunc], for example). It is usually clearer and always faster to use the built-in string comparison operators ==, <, >, and so on.
func strings.Count(s string, substr string) int
Count counts the number of non-overlapping instances of substr in s. If substr is an empty string, Count returns 1 + the number of Unicode code points in s.
func strings.Contains(s string, substr string) bool
Contains reports whether substr is within s.
func strings.ContainsAny(s string, chars string) bool
ContainsAny reports whether any Unicode code points in chars are within s.
func strings.LastIndex(s string, substr string) int
LastIndex returns the index of the last instance of substr in s, or -1 if substr is not present in s.
func strings.IndexAny(s string, chars string) int
IndexAny returns the index of the first instance of any Unicode code point from chars in s, or -1 if no Unicode code point from chars is present in s.
func strings.LastIndexAny(s string, chars string) int
LastIndexAny returns the index of the last instance of any Unicode code point from chars in s, or -1 if no Unicode code point from chars is present in s.
func strings.HasPrefix(s string, prefix string) bool
HasPrefix reports whether the string s begins with prefix.
func strings.HasSuffix(s string, suffix string) bool
HasSuffix reports whether the string s ends with suffix.
func strings.Repeat(s string, count int) string
Repeat returns a new string consisting of count copies of the string s.
It panics if count is negative or if the result of (len(s) * count) overflows.
func strings.ToUpper(s string) string
ToUpper returns s with all Unicode letters mapped to their upper case.
func strings.ToLower(s string) string
ToLower returns s with all Unicode letters mapped to their lower case.
func strings.ToTitle(s string) string
ToTitle returns a copy of the string s with all Unicode letters mapped to their Unicode title case.
func strings.ToValidUTF8(s string, replacement string) string
ToValidUTF8 returns a copy of the string s with each run of invalid UTF-8 byte sequences replaced by the replacement string, which may be empty.
func strings.Title(s string) string
Title returns a copy of the string s with all Unicode letters that begin words mapped to their Unicode title case.
Deprecated: The rule Title uses for word boundaries does not handle Unicode punctuation properly. Use golang.org/x/text/cases instead.
func strings.Trim(s string, cutset string) string
Trim returns a slice of the string s with all leading and trailing Unicode code points contained in cutset removed.
func strings.TrimLeft(s string, cutset string) string
TrimLeft returns a slice of the string s with all leading Unicode code points contained in cutset removed.
To remove a prefix, use [TrimPrefix] instead.
func strings.TrimRight(s string, cutset string) string
TrimRight returns a slice of the string s, with all trailing Unicode code points contained in cutset removed.
To remove a suffix, use [TrimSuffix] instead.
func strings.TrimSpace(s string) string
TrimSpace returns a slice of the string s, with all leading and trailing white space removed, as defined by Unicode.
func strings.TrimPrefix(s string, prefix string) string
TrimPrefix returns s without the provided leading prefix string. If s doesn't start with prefix, s is returned unchanged.
func strings.TrimSuffix(s string, suffix string) string
TrimSuffix returns s without the provided trailing suffix string. If s doesn't end with suffix, s is returned unchanged.
func strings.Replace(s string, old string, new string, n int) string
Replace returns a copy of the string s with the first n non-overlapping instances of old replaced by new. If old is empty, it matches at the beginning of the string and after each UTF-8 sequence, yielding up to k+1 replacements for a k-rune string. If n < 0, there is no limit on the number of replacements.
func strings.ReplaceAll(s string, old string, new string) string
ReplaceAll returns a copy of the string s with all non-overlapping instances of old replaced by new. If old is empty, it matches at the beginning of the string and after each UTF-8 sequence, yielding up to k+1 replacements for a k-rune string.
func strings.EqualFold(s string, t string) bool
EqualFold reports whether s and t, interpreted as UTF-8 strings, are equal under simple Unicode case-folding, which is a more general form of case-insensitivity.
func strings.Index(s string, substr string) int
Index returns the index of the first instance of substr in s, or -1 if substr is not present in s.
url
func url.QueryEscape(s string) string
QueryEscape escapes the string so it can be safely placed inside a [URL] query.
func url.PathEscape(s string) string
PathEscape escapes the string so it can be safely placed inside a [URL] path segment, replacing special characters (including /) with %XX sequences as needed.
uuid
func uuid.New() uuid
New creates a new random UUID.
func uuid.NewMD5(space uuid, data []byte) uuid
NewMD5 returns a new MD5 (Version 3) UUID based on the supplied name space and data.
func uuid.NewSHA1(space uuid, data []byte) uuid
NewSHA1 returns a new SHA1 (Version 5) UUID based on the supplied name space and data.