type StructA struct {
	Name string
}

// 初期化時に行いたい処理
func (self *StructA) SomeInitialize() {
	// Some initialize
}

// コンストラクタ関数を定義
func NewStructA(name string) *StructA {
	structA := &StructA{Name: name}
	structA.SomeInitialize()
	return structA
}

func main() {
	_ = NewStructA("name")
}

package singleton

// 構造体の名前を小文字にすることでパッケージ外へのエクスポートを行わない
type singleton struct {
}

// インスタンスを保持する変数も小文字にすることでエクスポートを行わない
var instance *singleton

// インスタンス取得用の関数のみエクスポートしておき、ここでインスタンスが
// 一意であることを保証する
func GetInstance() *singleton {
	if instance == nil {
	     instance = &singleton{}
	}
	return instance
}

singleton := singleton.GetInstance()

// インターフェースの定義
type SomeBehivor interface {
	DoSomething(arg string) string
}

// 構造体の定義
type StructA struct {
}

// インターフェースの実装
func (self *StructA) DoSomething(arg string) string {
	return arg
}

// ポリモフィズム
func main() {
	// インターフェース型の変数に格納できる
	var behivor SomeBehivor
	behivor = &StructA{}
	behivor.DoSomething("A")
}

// インターフェースの定義
type SomeBehivor interface {
	DoSomething() string
}

// 共通構造体の定義
type DefaultStruct struct {
	// 共通メンバ
	Name string
}

// 共通構造体にインターフェースを実装
func (self *DefaultStruct) DoSomething() string {
	return self.Name
}

// 共通構造体を埋め込む
type StructA struct {
	*DefaultStruct
}

func main() {
	// インターフェース型の変数に格納できる
	behivor := &StructA{&DefaultStruct{"A"}}

	// 共通実装とメンバを使うことができる
	behivor.DoSomething()
}

// コンストラクタ関数
func NewStructA(name string) *StructA {
	return &StructA{&DefaultStruct{"A"}}
}
// 利用側は埋込構造体の存在を意識しない
behivor := NewStructA("A")

type Behivor interface {
	DoSomethingByOther()
}

type Abstract struct {
}

// 内部で、もとの構造体の実装を利用するメソッド
func (self *Abstract) DoSomething(behivor Behivor) {
	behivor.DoSomethingByOther()

	// 仮にここで AbstractにBehivorを埋め込むなど、メソッドがある状態でコンパイルを通るようにして、
	// self.DoSomethingByOther()としてもpanic: runtime error: invalid memory address or nil pointer dereferenceが
	// 発生し、Dispatch backされないことがわかる
}

// 上で定義した構造体を埋め込む
type Concrete struct {
	*Abstract
}

// インターフェースを実装
func (self *Concrete) DoSomethingByOther() {
	// Do something
}

func main() {
	concrete := &Concrete{}
	// レシーバとなる自分自身を渡す
	concrete.DoSomething(concrete)
}

type Strategy interface {
	DoSomething()
}

type ConcreteStrategy struct {
}

func (self *ConcreteStrategy) DoSomething() {
	// Do something
}

type StructA struct {
	// 移譲先をメンバに保持
	strategy Strategy
}

func (self *StructA) Operation() {
	// 埋め込んだ構造体に処理を移譲
	self.strategy.DoSomething()
}

// 関数型を定義
type DoSomething func()


type StructA struct {
}

// 関数型を引数で受け取るメソッドを定義
func (self *StructA) Operation(strategy DoSomething) {
	// 受け取った関数型に処理を移譲
	strategy()
}

func main() {
	structA := &StructA{}

	// 関数リテラルで引数として渡す
	structA.Operation(func(){
	     // Do something
	})
}