go/test/named.go

// $G $D/$F.go && $L $F.$A && ./$A.out

// Copyright 2009 The Go Authors.  All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Test that basic operations on named types are valid
// and preserve the type.

package main

type Array [10]byte
type Bool bool
type Chan chan int
type Float float
type Int int
type Map map[int]byte
type Slice []byte
type String string

// Calling these functions checks at compile time that the argument
// can be converted implicitly to (used as) the given type.
func asArray(Array) {}
func asBool(Bool) {}
func asChan(Chan) {}
func asFloat(Float) {}
func asInt(Int) {}
func asMap(Map) {}
func asSlice(Slice) {}
func asString(String) {}

func (Map) M() {}


// These functions check at run time that the default type
// (in the absence of any implicit conversion hints)
// is the given type.
func isArray(x interface{}) { _ = x.(Array) }
func isBool(x interface{}) { _ = x.(Bool) }
func isChan(x interface{}) { _ = x.(Chan) }
func isFloat(x interface{}) { _ = x.(Float) }
func isInt(x interface{}) { _ = x.(Int) }
func isMap(x interface{}) { _ = x.(Map) }
func isSlice(x interface{}) { _ = x.(Slice) }
func isString(x interface{}) { _ = x.(String) }

func main() {
	var (
		a Array;
		b Bool = true;
		c Chan = make(Chan);
		f Float = 1;
		i Int = 1;
		m Map = make(Map);
		slice Slice = make(Slice, 10);
		str String = "hello";
	)

	asArray(a);
	isArray(a);
	asArray(*&a);
	isArray(*&a);
	asArray(Array{});
	isArray(Array{});

	asBool(b);
	isBool(b);
	asBool(!b);
	isBool(!b);
	asBool(true);
	asBool(*&b);
	isBool(*&b);
	asBool(Bool(true));
	isBool(Bool(true));

	asChan(c);
	isChan(c);
	asChan(make(Chan));
	isChan(make(Chan));
	asChan(*&c);
	isChan(*&c);
	asChan(Chan(nil));
	isChan(Chan(nil));

	asFloat(f);
	isFloat(f);
	asFloat(-f);
	isFloat(-f);
	asFloat(+f);
	isFloat(+f);
	asFloat(f+1);
	isFloat(f+1);
	asFloat(1+f);
	isFloat(1+f);
	asFloat(f+f);
	isFloat(f+f);
	f++;
	f+=2;
	asFloat(f-1);
	isFloat(f-1);
	asFloat(1-f);
	isFloat(1-f);
	asFloat(f-f);
	isFloat(f-f);
	f--;
	f-=2;
	asFloat(f*2.5);
	isFloat(f*2.5);
	asFloat(2.5*f);
	isFloat(2.5*f);
	asFloat(f*f);
	isFloat(f*f);
	f*=4;
	asFloat(f/2.5);
	isFloat(f/2.5);
	asFloat(2.5/f);
	isFloat(2.5/f);
	asFloat(f/f);
	isFloat(f/f);
	f/=4;
	asFloat(f);
	isFloat(f);
	f = 5;
	asFloat(*&f);
	isFloat(*&f);
	asFloat(234);
	asFloat(Float(234));
	isFloat(Float(234));
	asFloat(1.2);
	asFloat(Float(i));
	isFloat(Float(i));

	asInt(i);
	isInt(i);
	asInt(-i);
	isInt(-i);
	asInt(^i);
	isInt(^i);
	asInt(+i);
	isInt(+i);
	asInt(i+1);
	isInt(i+1);
	asInt(1+i);
	isInt(1+i);
	asInt(i+i);
	isInt(i+i);
	i++;
	i+=1;
	asInt(i-1);
	isInt(i-1);
	asInt(1-i);
	isInt(1-i);
	asInt(i-i);
	isInt(i-i);
	i--;
	i-=1;
	asInt(i*2);
	isInt(i*2);
	asInt(2*i);
	isInt(2*i);
	asInt(i*i);
	isInt(i*i);
	i*=2;
	asInt(i/5);
	isInt(i/5);
	asInt(5/i);
	isInt(5/i);
	asInt(i/i);
	isInt(i/i);
	i/=2;
	asInt(i%5);
	isInt(i%5);
	asInt(5%i);
	isInt(5%i);
	asInt(i%i);
	isInt(i%i);
	i%=2;
	asInt(i&5);
	isInt(i&5);
	asInt(5&i);
	isInt(5&i);
	asInt(i&i);
	isInt(i&i);
	i&=2;
	asInt(i&^5);
	isInt(i&^5);
	asInt(5&^i);
	isInt(5&^i);
	asInt(i&^i);
	isInt(i&^i);
	i&^=2;
	asInt(i|5);
	isInt(i|5);
	asInt(5|i);
	isInt(5|i);
	asInt(i|i);
	isInt(i|i);
	i|=2;
	asInt(i^5);
	isInt(i^5);
	asInt(5^i);
	isInt(5^i);
	asInt(i^i);
	isInt(i^i);
	i^=2;
	asInt(i<<4);
	isInt(i<<4);
	i<<=2;
	asInt(i>>4);
	isInt(i>>4);
	i>>=2;
	asInt(i);
	isInt(i);
	asInt(0);
	asInt(Int(0));
	isInt(Int(0));
	i = 10;
	asInt(*&i);
	isInt(*&i);
	asInt(23);
	asInt(Int(f));
	isInt(Int(f));

	asMap(m);
	isMap(m);
	asMap(nil);
	m = nil;
	asMap(make(Map));
	isMap(make(Map));
	asMap(*&m);
	isMap(*&m);
	asMap(Map(nil));
	isMap(Map(nil));
	asMap(Map{});
	isMap(Map{});

	asSlice(slice);
	isSlice(slice);
	asSlice(make(Slice, 5));
	isSlice(make(Slice, 5));
	asSlice([]byte{1,2,3});
	asSlice([]byte{1,2,3}[0:2]);
	asSlice(slice[0:4]);
	isSlice(slice[0:4]);
	asSlice(slice[3:8]);
	isSlice(slice[3:8]);
	asSlice(nil);
	asSlice(Slice(nil));
	isSlice(Slice(nil));
	slice = nil;
	asSlice(Slice{1,2,3});
	isSlice(Slice{1,2,3});
	asSlice(Slice{});
	isSlice(Slice{});
	asSlice(*&slice);
	isSlice(*&slice);

	asString(str);
	isString(str);
	asString(str+"a");
	isString(str+"a");
	asString("a"+str);
	isString("a"+str);
	asString(str+str);
	isString(str+str);
	str += "a";
	str += str;
	asString(String('a'));
	isString(String('a'));
	asString(String(slice));
	isString(String(slice));
	asString(String([]byte(nil)));
	isString(String([]byte(nil)));
	asString("hello");
	asString(String("hello"));
	isString(String("hello"));
	str = "hello";
	isString(str);
	asString(*&str);
	isString(*&str);
}