Documentation
¶
Overview ¶
constant パッケージは、Go の未型指定の定数とその対応する操作を表現する値を実装します。
エラーにより値が不明な場合、特別な Unknown 値を使用できます。 不明な値に対する操作は、明示的に指定されない限り、不明な値を生成します。
Example (ComplexNumbers) ¶
package main
import (
"github.com/shogo82148/std/fmt"
"github.com/shogo82148/std/go/constant"
"github.com/shogo82148/std/go/token"
)
func main() {
// 複素数2.3 + 5iを作成します。
ar := constant.MakeFloat64(2.3)
ai := constant.MakeImag(constant.MakeInt64(5))
a := constant.BinaryOp(ar, token.ADD, ai)
// (2.3 + 5i) * 11を計算する。
b := constant.MakeUint64(11)
c := constant.BinaryOp(a, token.MUL, b)
// cをcomplex128に変換します。
Ar, exact := constant.Float64Val(constant.Real(c))
if !exact {
fmt.Printf("Could not represent real part %s exactly as float64\n", constant.Real(c))
}
Ai, exact := constant.Float64Val(constant.Imag(c))
if !exact {
fmt.Printf("Could not represent imaginary part %s as exactly as float64\n", constant.Imag(c))
}
C := complex(Ar, Ai)
fmt.Println("literal", 25.3+55i)
fmt.Println("go/constant", c)
fmt.Println("complex128", C)
}
Output: Could not represent real part 25.3 exactly as float64 literal (25.3+55i) go/constant (25.3 + 55i) complex128 (25.299999999999997+55i)
Index ¶
- func BitLen(x Value) int
- func BoolVal(x Value) bool
- func Bytes(x Value) []byte
- func Compare(x_ Value, op token.Token, y_ Value) bool
- func Float32Val(x Value) (float32, bool)
- func Float64Val(x Value) (float64, bool)
- func Int64Val(x Value) (int64, bool)
- func Sign(x Value) int
- func StringVal(x Value) string
- func Uint64Val(x Value) (uint64, bool)
- func Val(x Value) any
- type Kind
- type Value
- func BinaryOp(x_ Value, op token.Token, y_ Value) Value
- func Denom(x Value) Value
- func Imag(x Value) Value
- func Make(x any) Value
- func MakeBool(b bool) Value
- func MakeFloat64(x float64) Value
- func MakeFromBytes(bytes []byte) Value
- func MakeFromLiteral(lit string, tok token.Token, zero uint) Value
- func MakeImag(x Value) Value
- func MakeInt64(x int64) Value
- func MakeString(s string) Value
- func MakeUint64(x uint64) Value
- func MakeUnknown() Value
- func Num(x Value) Value
- func Real(x Value) Value
- func Shift(x Value, op token.Token, s uint) Value
- func ToComplex(x Value) Value
- func ToFloat(x Value) Value
- func ToInt(x Value) Value
- func UnaryOp(op token.Token, y Value, prec uint) Value
Examples ¶
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
func BitLen ¶
BitLenは、絶対値xを2進表現するために必要なビット数を返します。xは Int または Unknown である必要があります。 xが Unknown の場合、結果は0です。
func Compare ¶
Compareはx op yの比較結果を返します。 オペランドの比較は定義されている必要があります。 オペランドの一つが Unknown の場合、結果はfalseです。
Example ¶
package main
import (
"github.com/shogo82148/std/fmt"
"github.com/shogo82148/std/go/constant"
"github.com/shogo82148/std/go/token"
"github.com/shogo82148/std/slices"
)
func main() {
vs := []constant.Value{
constant.MakeString("Z"),
constant.MakeString("bacon"),
constant.MakeString("go"),
constant.MakeString("Frame"),
constant.MakeString("defer"),
constant.MakeFromLiteral(`"a"`, token.STRING, 0),
}
slices.SortFunc(vs, func(a, b constant.Value) int {
if constant.Compare(a, token.LSS, b) {
return -1
}
if constant.Compare(a, token.GTR, b) {
return +1
}
return 0
})
for _, v := range vs {
fmt.Println(constant.StringVal(v))
}
}
Output: Frame Z a bacon defer go
func Float32Val ¶
Float32Valは、float64ではなくfloat32のための Float64Val と同様です。
func Float64Val ¶
Float64Valは、xの最も近いGoのfloat64値とその結果が正確かどうかを返します。 xは数値または Unknown である必要がありますが、Complex ではありません。float64として表現するのに 小さすぎる値（0に近すぎる）の場合、Float64Val は静かに0にアンダーフローします。結果の符号は常に xの符号と一致しますが、0の場合でもです。 xが Unknown の場合、結果は（0、false）です。
func Int64Val ¶
Int64Valは、xのGo int64値と結果が正確であるかどうかを返します。 xは Int または Unknown でなければなりません。結果が正確でない場合は、値は未定義です。 xがUnknownの場合、結果は(0、false)です。
func Sign ¶
Signは、xが0より小さい場合-1、xが0と等しい場合0、xが0より大きい場合1を返します。 xは数値または Unknown である必要があります。複素数の場合、xが0と等しい場合は0であり、 それ以外の場合は0ではありません。xが Unknown の場合、結果は1です。
Example ¶
package main
import (
"github.com/shogo82148/std/fmt"
"github.com/shogo82148/std/go/constant"
"github.com/shogo82148/std/go/token"
)
func main() {
zero := constant.MakeInt64(0)
one := constant.MakeInt64(1)
negOne := constant.MakeInt64(-1)
mkComplex := func(a, b constant.Value) constant.Value {
b = constant.MakeImag(b)
return constant.BinaryOp(a, token.ADD, b)
}
vs := []constant.Value{
negOne,
mkComplex(zero, negOne),
mkComplex(one, negOne),
mkComplex(negOne, one),
mkComplex(negOne, negOne),
zero,
mkComplex(zero, zero),
one,
mkComplex(zero, one),
mkComplex(one, one),
}
for _, v := range vs {
fmt.Printf("% d %s\n", constant.Sign(v), v)
}
}
Output: -1 -1 -1 (0 + -1i) -1 (1 + -1i) -1 (-1 + 1i) -1 (-1 + -1i) 0 0 0 (0 + 0i) 1 1 1 (0 + 1i) 1 (1 + 1i)
func Uint64Val ¶
Uint64ValはxのGo uint64の値と結果が正確かどうかを返します。 xは Int または Unknown でなければなりません。結果が正確でない場合、その値は未定義です。 xがUnknownの場合、結果は(0, false)です。
func Val ¶ added in v1.13.0
Valは指定された定数の基になる値を返します。インターフェースを返すため、呼び出し元が結果を期待する型にキャストすることが求められます。可能な動的な戻り値の型は次の通りです：
xの種類 結果の型 ------------------------------------------- Bool bool String string Int int64または*big.Int Float *big.Floatまたは*big.Rat その他のすべて nil
Example ¶
package main
import (
"github.com/shogo82148/std/fmt"
"github.com/shogo82148/std/go/constant"
"github.com/shogo82148/std/math"
)
func main() {
maxint := constant.MakeInt64(math.MaxInt64)
fmt.Printf("%v\n", constant.Val(maxint))
e := constant.MakeFloat64(math.E)
fmt.Printf("%v\n", constant.Val(e))
b := constant.MakeBool(true)
fmt.Printf("%v\n", constant.Val(b))
b = constant.Make(false)
fmt.Printf("%v\n", constant.Val(b))
}
Output: 9223372036854775807 6121026514868073/2251799813685248 true false
Types ¶
type Value ¶
type Value interface {
Kind() Kind
String() string
ExactString() string
// contains filtered or unexported methods
}
ValueはGo言語の定数の値を表します。
func BinaryOp ¶
BinaryOpは、バイナリ式x op yの結果を返します。 演算は、オペランドに対して定義されている必要があります。オペランドの1つが Unknown の場合、結果は Unknown です。 BinaryOpは比較やシフトを処理しません。代わりに Compare または Shift を使用してください。
Intオペランドの整数除算を強制するには、token.QUO のかわりにop == token.QUO_ASSIGN を使用します。この場合、結果は Int が保証されます。 ゼロでの除算はランタイムパニックを引き起こします。
Example ¶
package main
import (
"github.com/shogo82148/std/fmt"
"github.com/shogo82148/std/go/constant"
"github.com/shogo82148/std/go/token"
)
func main() {
// 11 / 0.5
a := constant.MakeUint64(11)
b := constant.MakeFloat64(0.5)
c := constant.BinaryOp(a, token.QUO, b)
fmt.Println(c)
}
Output: 22
func Denom ¶
Denomはxの分母を返します。xは Int、Float、または Unknown でなければなりません。 もしxが Unknown であるか、それを分数として表現するのに大きすぎるか小さすぎる場合、結果は Unknown です。 それ以外の場合、結果は1以上の Int です。
func Make ¶ added in v1.13.0
Makeはxの値に対する Value を返します。
xの型 結果のKind ---------------------------- bool Bool string String int64 Int *big.Int Int *big.Float Float *big.Rat Float それ以外の型 Unknown
func MakeFloat64 ¶
MakeFloat64はxの Float 値を返します。 xが-0.0の場合、結果は0.0です。 xが有限ではない場合、結果はUnknownです。
func MakeFromBytes ¶
MakeFromBytesは、リトルエンディアンのバイナリ表現のバイトを与えられた場合に、 Int 値を返します。空のバイトスライス引数は0を表します。
func MakeFromLiteral ¶
MakeFromLiteralは、Goリテラル文字列に対応する整数、浮動小数点、虚数、文字、または文字列の値を返します。tokの値は、token.INT、token.FLOAT、token.IMAG、token.CHAR、または token.STRING のいずれかでなければなりません。最後の引数はゼロでなければなりません。リテラルの文字列構文が無効な場合、結果は Unknown です。
func MakeImag ¶
MakeImagはComplex値 x*iを返します； xはInt、Float、またはUnknownである必要があります。 もしxがUnknownの場合、結果もUnknownです。
func Num ¶
Numはxの分子を返します。xは Int、Float、または Unknown でなければなりません。 xが Unknown であるか、分数として表現するには大きすぎるまたは小さすぎる場合は、結果は Unknown です。 それ以外の場合、結果はxと同じ符号の Int です。
func Shift ¶
Shiftはshift式x op sの結果を返します opが token.SHL または token.SHR（<<または>>）である場合の結果です。xは Int または Unknown でなければなりません。xが Unknown の場合、結果はxです。
func ToComplex ¶ added in v1.6.0
ToComplexは、xが Complex として表現可能な場合は Complex の値に変換します。 それ以外の場合は Unknown を返します。
func ToFloat ¶ added in v1.6.0
ToFloatはxが Float として表現可能な場合、xを Float 値に変換します。 それ以外の場合は、Unknown を返します。
func UnaryOp ¶
UnaryOpは単項演算子op yの結果を返します。 演算はオペランドに対して定義されている必要があります。 prec > 0の場合、^（XOR）の結果のビット数を指定します。 yが Unknown の場合、結果は Unknown です。
Example ¶
package main
import (
"github.com/shogo82148/std/fmt"
"github.com/shogo82148/std/go/constant"
"github.com/shogo82148/std/go/token"
)
func main() {
vs := []constant.Value{
constant.MakeBool(true),
constant.MakeFloat64(2.7),
constant.MakeUint64(42),
}
for i, v := range vs {
switch v.Kind() {
case constant.Bool:
vs[i] = constant.UnaryOp(token.NOT, v, 0)
case constant.Float:
vs[i] = constant.UnaryOp(token.SUB, v, 0)
case constant.Int:
// 16ビットの精度を使用します。
// これは^uint16(v)と等価です。
vs[i] = constant.UnaryOp(token.XOR, v, 16)
}
}
for _, v := range vs {
fmt.Println(v)
}
}
Output: false -2.7 65493
Source Files