There are three parts changed:

• Add producer_consumer.md and update the README.md in root dir.

• Add producer_consumer package:

We can use assign tasks to producer after producer starts.
Producer has limit buffer for task. If the buffer is full and no
consumer to take, the producer will ignore the task.
Consumer needs to regiester if it wants to do task for producer.

All the communication is based on RPC.

• Add example for producer_consumer package.

The example will show the case that the buffer of producer is full.

Hi Tamer

It works now :) The problem was that I tried to make an remote branch to compare to master branch. But I had no permission. Then I realized that I can make a fork to compare to the master branch :)

Hope it is good enough to integrate (still in the learning curve)

Best regards

Steve aka Inux

The circuit breaker example is mostly a copy paste from sony/gobreaker/gobreaker.go without credit for the original authors. Furthermore, the example doesn't build due to missing constants: Counts and State.

Hi! I saw that a some patterns have a link to related implementation (e.g. http://tmrts.com/go-patterns/stability/circuit-breaker.html). Can I add via pull request some implementation of synchronization/semaphore?

• https://github.com/eapache/go-resiliency/blob/master/semaphore/semaphore.go
• https://github.com/dropbox/godropbox/blob/master/sync2/semaphore.go
• https://github.com/kamilsk/semaphore

https://github.com/tmrts/go-patterns/blob/master/messaging/publish_subscribe.md

 if _, ok := s.ch; !ok {
        return errors.New("Topic has been closed")
 }

assignment count mismatch: 2 = 1

Hi @tmrts, First of all I don't want this to act like 'advertisement' ( I personally don't like 'advertisements' in github), if it's acted like that then do not approve this PR.

I made a package only to help readers of this go-patterns repository to understand how they can extend Pattern: Functional Options to fit to their needs, so I added a section with relative links of this particular pattern. I could also recommend search and do the same for other patterns, it's good to add relative links in order to see how they(readers) can extend a pattern, it will help to understand better the subject, I hope.

Factory Method Pattern in Go is function which returns an interface (something what is implementing an interface)... that's all. This means you should not think about this pattern and use a pattern when you known patterns. You should make only a function like func NewXXX(arguments) <interface> {...} for your needs (or in ideal case package.New()). And every gofer are making this everyday. And it is not a pattern. This is Interface builder or Interface constructor as you like. I affirm that Go does not require knowledge of any patterns (as OOP requires), but it requires an understanding of SOLID principles and having a mind.