From c743c9389f84450d310cbdefe0d16a02c2080d28 Mon Sep 17 00:00:00 2001 From: sgf Date: Wed, 22 Jun 2022 00:23:17 +0300 Subject: [PATCH] Save some earlier experiments. --- firstapp/Goroutine-1.go | 81 +++++++++++++++++++++++++++++++++++ firstapp/Goroutine.go | 55 ++++++++++++++++++++++++ firstapp/Interface1.go | 34 +++++++++++++++ firstapp/Interface2.go | 49 +++++++++++++++++++++ firstapp/Interfaces.go | 68 +++++++++++++++++++++++++++++ firstapp/Main.go | 94 +++++++++++++++++++++++++++++++++++++++++ 6 files changed, 381 insertions(+) create mode 100644 firstapp/Goroutine-1.go create mode 100644 firstapp/Goroutine.go create mode 100644 firstapp/Interface1.go create mode 100644 firstapp/Interface2.go create mode 100644 firstapp/Interfaces.go create mode 100644 firstapp/Main.go diff --git a/firstapp/Goroutine-1.go b/firstapp/Goroutine-1.go new file mode 100644 index 0000000..e519727 --- /dev/null +++ b/firstapp/Goroutine-1.go @@ -0,0 +1,81 @@ + +package main + +import "fmt" +import "sync" +import "time" + +// What is Go closure? +/*func main() { + go sayHello() + time.Sleep(100 * time.Millisecond) +}*/ + +var wg = sync.WaitGroup{} +var counter = 0 +var counter2 = 0 +var m = sync.RWMutex{} + +func main() { + + /* + for i := 0; i < 5; i++ { + wg.Add(2) + go sayHello(i) + go increment(i) + } + wg.Wait() + */ + + for i := 0; i < 5; i++ { + wg.Add(2) + go sayHelloM(i) + go incrementM(i) + } + wg.Wait() + +} + +func sayHello(i int) { + //m.RLock() + fmt.Printf("Hello (%v) #%v #%v\n", i, counter, counter2) + //m.RUnlock() + wg.Done() +} + +func increment(i int) { + //m.Lock() + fmt.Printf("Counter (%v) start\n", i) + counter2++ + + time.Sleep(100 * time.Millisecond) + counter++ + fmt.Printf("Counter (%v) #%v #%v\n", i, counter, counter2) + //m.Unlock() + wg.Done() +} + +func sayHelloM(i int) { + c2 := counter2 + if i < 3 { + time.Sleep(100 * time.Millisecond) + } + fmt.Printf("Hello (%v) #%v\n", i, c2) + + m.RLock() + fmt.Printf("Hello (%v) #%v\n", i, counter) + m.RUnlock() + wg.Done() +} + +func incrementM(i int) { + fmt.Printf("Counter (%v) start\n", i) + counter2++ + + m.Lock() + counter++ + fmt.Printf("Counter (%v) #%v #%v\n", i, counter, counter2) + m.Unlock() + wg.Done() +} + diff --git a/firstapp/Goroutine.go b/firstapp/Goroutine.go new file mode 100644 index 0000000..a95c51f --- /dev/null +++ b/firstapp/Goroutine.go @@ -0,0 +1,55 @@ + +package main + +import "fmt" +import "sync" +import "time" + +// What is Go closure? +/*func main() { + go sayHello() + time.Sleep(100 * time.Millisecond) +}*/ + +var wg = sync.WaitGroup{} +var counter = 0 +var counter2 = 0 +var m = sync.RWMutex{} + +func main() { + + for i := 0; i < 5; i++ { + wg.Add(2) + go sayHello(i) + go increment(i) + } + wg.Wait() +} + +func sayHello(i int) { + c2 := counter2 + if i < 3 { + time.Sleep(100 * time.Millisecond) + } + fmt.Printf("Hello (%v) #%v\n", i, c2) + + m.RLock() + fmt.Printf("Hello (%v) #%v\n", i, counter) + m.RUnlock() + wg.Done() +} + +func increment(i int) { + counter2++ + fmt.Printf("Counter (%v) start #%v\n", i, counter2) + if i < 3 { + time.Sleep(10 * time.Millisecond) + } + + m.Lock() + counter++ + fmt.Printf("Counter (%v) #%v\n", i, counter) + m.Unlock() + wg.Done() +} + diff --git a/firstapp/Interface1.go b/firstapp/Interface1.go new file mode 100644 index 0000000..a0125b3 --- /dev/null +++ b/firstapp/Interface1.go @@ -0,0 +1,34 @@ + +package main + +import ( + "fmt" +) + +func main() { + var w Writer = FileWriter{} + f(w) +} + +func f (w Writer) { + w.Write([]byte("Hello go!")) +} + +type Writer interface { + Write([]byte) (int, error) +} + +type ConsoleWriter struct {} + +func (cw ConsoleWriter) Write(data []byte) (int, error) { + n, err := fmt.Println(string(data)) + return n, err +} + +type FileWriter struct {} + +func (fw FileWriter) Write(data []byte) (int, error) { + n, err := fmt.Println("write to file: ", string(data)) + return n, err +} + diff --git a/firstapp/Interface2.go b/firstapp/Interface2.go new file mode 100644 index 0000000..1f669d9 --- /dev/null +++ b/firstapp/Interface2.go @@ -0,0 +1,49 @@ + +package main + +import ( + "fmt" +) + +func main() { + myInt := IntCounter(0) + var inc Incrementer = &myInt + f(inc) +} + +func f(inc Incrementer) { + for i := 0; i < 10; { + i = inc.Increment() + fmt.Println(i) + } +} + +type Incrementer interface { + Increment() int +} + +type IntCounter int + +func (ic *IntCounter) Increment() int { + *ic++ + return int(*ic) +} + +func f2(inc Incrementer2) { + for i := 0; i < 10; { + inc = inc.Increment2() + fmt.Println(inc) + } +} + +type Incrementer2 interface { + Increment2() Incrementer2 +} + +type IntCounter2 int + +func (ic IntCounter2) Increment2() Incrementer2 { + ic++ + return ic +} + diff --git a/firstapp/Interfaces.go b/firstapp/Interfaces.go new file mode 100644 index 0000000..fd9f0fc --- /dev/null +++ b/firstapp/Interfaces.go @@ -0,0 +1,68 @@ +package main + +import ( + "fmt" +) + +type myStruct struct { + foo int +} + +func main() { + /* + statePop := map[string]int{ + "Cal": 392, + "Tex": 278, + "Flo": 206, + "New": 197, + "Pen": 128, + "Ill": 128, + "Ohi": 116, + } + */ + + var w Writer = ConsoleWriter{i: 3} + //var w ConsoleWriter = ConsoleWriter{i: 3} + // Write(w :: ConsoleWriter, ...) + w.Write([]byte("Hello go!")) + fmt.Printf("%v %T\n", w, w) + + myInt := IntCounter(0) + // data Incrementer = forall a. Incrementer a => Incrementer a + // inc :: Incrementer + // inc = Incrementer myInt + var inc Incrementer = &myInt + for myInt < 10 { + fmt.Println(inc.Increment()) + } +} + +// class Writer a +// Write(..) +type Writer interface { + Write([]byte) (int, error) +} + +// instance Writer ConsoleWriter +type ConsoleWriter struct { + i int +} + +// Write = ... +func (cw ConsoleWriter) Write(data []byte) (int, error) { + n, err := fmt.Println(string(data)) + cw.i = 7 + return n, err +} + +type Incrementer interface { + Increment() int +} + +// newtype IntCounter = IntCounter Int +type IntCounter int + +func (ic *IntCounter) Increment() int { + *ic++ + return int(*ic) +} diff --git a/firstapp/Main.go b/firstapp/Main.go new file mode 100644 index 0000000..fc64a75 --- /dev/null +++ b/firstapp/Main.go @@ -0,0 +1,94 @@ +package main + +import ( + "fmt" +) + +type myStruct struct { + foo int +} + +func main() { + /* + statePop := map[string]int{ + "Cal": 392, + "Tex": 278, + "Flo": 206, + "New": 197, + "Pen": 128, + "Ill": 128, + "Ohi": 116, + } + */ + + var wc WriterCloser = ConsoleWriter{i: 3} + //var w ConsoleWriter = ConsoleWriter{i: 3} + // Write(w :: ConsoleWriter, ...) + w.Write([]byte("Hello go!")) + fmt.Printf("%v %T\n", w, w) + + myInt := IntCounter(0) + // data Incrementer = forall a. Incrementer a => Incrementer a + // inc :: Incrementer + // inc = Incrementer myInt + var inc Incrementer = &myInt + for myInt < 10 { + fmt.Println(inc.Increment()) + } +} + +// class Writer a +// Write(..) +type Writer interface { + Write([]byte) (int, error) +} + +type Closer interface { + Close() error +} + +type WriterCloser interface { + Writer + Closer +} + +type BufferedWriterCloser struct { + buffer *bytes.Buffer +} + +func (bwc *BufferedWriterCloser) Write(data []byte) (int, error) { + n, err := bwc.buffer.Write(data) + if err != nil { + return 0, err + } + v := make([]byte, 8) + for bwc.buffer.Len() > 8 { + _, err := bwc.buffer.Read(v) + if err != nil { + return 0, err + } + _, err = fmt.Println(string(v)) + if err != nil { + return 0, err + } + } + return n, nil +} + +func (bwc *BufferedWriterCloser) Close() error { + for bwc.buffer.Len() > 0 { + data := bwc.buffer.Next(8) + _, err := fmt.Println(string(data)) + if err != nil { + return err + } + } + return nil +} + +func NewBufferedWriterCloser() *BufferedWriterCloser { + return &BufferedWriterCloser{ + buffer: bytes.NewBuffer([]bytes{}), + } +} + -- 2.20.1