...

パッケージ constant

import "go/constant"
概要
目次

概要 ▾

constant パッケージは,型なし Go 定数とその演算を表す値を実装します。

値がエラーのため不明であるとき特別な Unknown 値が使用されるかもしれません。 特に指定しない限り,未知の値に対する演算は未知の値を生成します。

例 (ComplexNumbers)

コード:

// 複素数 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)

出力:

実数部 25.3 を float64 で正確に表せません
リテラル (25.3+55i)
go/constant (25.3+55i)
complex128 (25.299999999999997+55i)

func BitLen 1.5

func BitLen(x Value) int

BitLen は,絶対値 x をバイナリ表現で表すのに必要なビット数を返します。 x は Int または Unknown でなければなりません。 x が Unknown の場合,結果は 0 です。

func BoolVal 1.5

func BoolVal(x Value) bool

BoolVal は Go のブール値 x を返します。 これは Bool または Unknown である必要があります。 x が Unknown の場合,結果は false です。

func Bytes 1.5

func Bytes(x Value) []byte

Bytes は, x の絶対値のバイトをリトルエンディアンの 2 進表現で返します。 x は Int でなければなりません。

func Compare 1.5

func Compare(x_ Value, op token.Token, y_ Value) bool

Compare は比較 x op y の結果を返します。 比較はオペランドに対して定義する必要があります。 オペランドの 1 つが Unknown の場合,結果は false です。

コード:

vs := []constant.Value{
    constant.MakeString("Z"),
    constant.MakeString("bacon"),
    constant.MakeString("go"),
    constant.MakeString("Frame"),
    constant.MakeString("defer"),
    constant.MakeFromLiteral(`"a"`, token.STRING, 0),
}

sort.Slice(vs, func(i, j int) bool {
    // vs[i] <= vs[j] と同じです。
    return constant.Compare(vs[i], token.LEQ, vs[j])
})

for _, v := range vs {
    fmt.Println(constant.StringVal(v))
}

出力:

Frame
Z
a
bacon
defer
go

func Float32Val 1.5

func Float32Val(x Value) (float32, bool)

Float32Val は Float64Val と似ていますが, float64 ではなく float32 用です。

func Float64Val 1.5

func Float64Val(x Value) (float64, bool)

Float64Val は, x の最も近い Go float64 値と,結果が正確かどうかを返します。 x は数値または未知数である必要がありますが,複素数ではありません。 float64 として表現するには小さすぎる (0 に近い) 値の場合, Float64Val は暗黙的に 0 にアンダーフローします。 結果の符号は, 0 の場合でも常に x の符号と一致します。 x が Unknown の場合,結果は (0, false) です。

func Int64Val 1.5

func Int64Val(x Value) (int64, bool)

Int64Val は, x の Go int64 値と結果が正確かどうかを返します。 x は Int または Unknown でなければなりません。 結果が正確ではない場合,その値は未定義です。 x が Unknown の場合,結果は (0, false) です。

func Sign 1.5

func Sign(x Value) int

Sign は,x < 0, x == 0, または x > 0 のどれであるかに応じて,-1, 0, または 1 を返します。 x は数値または Unknown でなければなりません。 x が複素数 x の場合, x == 0 の場合,符号は 0 です。 それ以外の場合, != 0 です。 x が Unknown の場合,結果は 1 です。

コード:

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)
}

出力:

-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 StringVal 1.5

func StringVal(x Value) string

StringVal は x の Go 文字列値を返します。 これは String または Unknown でなければなりません。 x が Unknown の場合,結果は "" です。

func Uint64Val 1.5

func Uint64Val(x Value) (uint64, bool)

Uint64Val は x の Go uint64 値と結果が正確かどうかを返します。 x は Int または Unknown でなければなりません。 結果が正確ではない場合,その値は未定義です。 x が Unknown の場合,結果は (0, false) です。

func Val

func Val(x Value) interface{}

Val returns the underlying value for a given constant. Since it returns an interface, it is up to the caller to type assert the result to the expected type. The possible dynamic return types are:

x Kind             type of result
-----------------------------------------
Bool               bool
String             string
Int                int64 or *big.Int
Float              *big.Float or *big.Rat
everything else    nil

コード:

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))

出力:

9223372036854775807
6121026514868073/2251799813685248
true
false

type Kind 1.5

Kind は,値によって表される値の種類を指定します。

type Kind int
const (
    // 未知の値
    Unknown Kind = iota

    // 非数値
    Bool
    String

    // 数値
    Int
    Float
    Complex
)

type Value 1.6

値は Go 定数の値を表します。

type Value interface {
    // Kind は値の種類を返します。
    Kind() Kind

    // String は,引用符で囲まれた (人間が読める) 短い形式の値を返します。
    // 数値の場合,結果は近似値になります。
    // 文字列値の場合,結果は文字列が短くなることがあります。
    // 値を正確に表す文字列には ExactString を使用してください。
    String() string

    // ExactString は,正確に引用符で囲まれた (人間が読める形式の) 値を返します。
    // Value が Kind String の場合は, StringVal を使用して引用符で囲まれていないストリングを取得します。
    ExactString() string
    // contains filtered or unexported methods
}

func BinaryOp 1.5

func BinaryOp(x_ Value, op token.Token, y_ Value) Value

BinaryOp は,バイナリ式 x op y の結果を返します。 操作はオペランドに対して定義する必要があります。 オペランドの 1 つが Unknown の場合,結果は Unknown です。 BinaryOp は比較やシフトを処理しません。 代わりに Compare または Shift を使用してください。

Int オペランドの整数除算を強制するには, token.QUO の代わりに op == token.QUO_ASSIGN を使用してください。 この場合,結果は Int であることが保証されています。 ゼロによる除算は実行時パニックを引き起こします。

コード:

// 11 / 0.5
a := constant.MakeUint64(11)
b := constant.MakeFloat64(0.5)
c := constant.BinaryOp(a, token.QUO, b)
fmt.Println(c)

出力:

22

func Denom 1.5

func Denom(x Value) Value

Denom は x の分母を返します。 x は, Int, Float ,または Unknown でなければなりません。 x が Unknown の場合,または分数として表現するには大きすぎるか小さすぎる場合,結果は Unknown です。 それ以外の場合,結果は Int >= 1 です。

func Imag 1.5

func Imag(x Value) Value

Imag は x の虚数部を返します。 これは数値または未知の値でなければなりません。 x が Unknown の場合,結果は Unknown です。

func Make

func Make(x interface{}) Value

Make returns the Value for x.

type of x        result Kind
----------------------------
bool             Bool
string           String
int64            Int
*big.Int         Int
*big.Float       Float
*big.Rat         Float
anything else    Unknown

func MakeBool 1.5

func MakeBool(b bool) Value

MakeBool は b の Bool 値を返します。

func MakeFloat64 1.5

func MakeFloat64(x float64) Value

MakeFloat64 は x の Float 値を返します。 x が有限でない場合,結果は Unknown です。

func MakeFromBytes 1.5

func MakeFromBytes(bytes []byte) Value

MakeFromBytes は,リトルエンディアンの 2 進表現のバイト数を指定して Int 値を返します。 空のバイトスライス引数は 0 を表します。

func MakeFromLiteral 1.5

func MakeFromLiteral(lit string, tok token.Token, zero uint) Value

MakeFromLiteral は, Go リテラル文字列に対応する整数,浮動小数点,虚数,文字,または文字列値を返します。 tok 値は, token.INT , token.FLOAT , token.IMAG , token.CHAR ,または token.STRING のいずれかでなければなりません。 最後の引数はゼロでなければなりません。 リテラル文字列の構文が無効な場合,結果は Unknown になります。

func MakeImag 1.5

func MakeImag(x Value) Value

MakeImag は複素数値 x*i を返します。 x は, Int, Float ,または Unknown でなければなりません。 x が Unknown の場合,結果は Unknown です。

func MakeInt64 1.5

func MakeInt64(x int64) Value

MakeInt64 は x の Int 値を返します。

func MakeString 1.5

func MakeString(s string) Value

MakeString は s の文字列値を返します。

func MakeUint64 1.5

func MakeUint64(x uint64) Value

MakeUint64 は x の Int 値を返します。

func MakeUnknown 1.5

func MakeUnknown() Value

MakeUnknown は Unknown 値を返します。

func Num 1.5

func Num(x Value) Value

Num は x の分子を返します。 x は, Int, Float ,または Unknown でなければなりません。 x が Unknown の場合,または分数として表現するには大きすぎるか小さすぎる場合,結果は Unknown です。 それ以外の場合,結果は x と同じ符号を持つ Int です。

func Real 1.5

func Real(x Value) Value

Real は x の実部を返します。 これは数値または未知の値である必要があります。 x が Unknown の場合,結果は Unknown です。

func Shift 1.5

func Shift(x Value, op token.Token, s uint) Value

Shift は, op == token.SHL または token.SHR (<< または >>) を使用して,シフト式 x op s の結果を返します。 x は Int または Unknown でなければなりません。 x が Unknown の場合,結果は x です。

func ToComplex 1.6

func ToComplex(x Value) Value

ToComplex は,x が Complex として表現可能な場合, x を Complex 値に変換します。 そうでなければ Unknown を返します。

func ToFloat 1.6

func ToFloat(x Value) Value

x が Float として表現できる場合, ToFloat は x を Float 値に変換します。 そうでなければ Unknown を返します。

func ToInt 1.6

func ToInt(x Value) Value

x が Int として表現できる場合, ToInt は x を Int 値に変換します。 そうでなければ Unknown を返します。

func UnaryOp 1.5

func UnaryOp(op token.Token, y Value, prec uint) Value

UnaryOp は,単項式 op y の結果を返します。 オペランドに対して操作を定義する必要があります。 prec > 0 の場合, ^ (xor) 結果サイズをビット単位で指定します。 y が Unknown の場合,結果は Unknown です。

コード:

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)
}

出力:

false
-2.7
65493