Redux in Go

就在昨天我完成了Go版本redux的主要功能
發文要附圖(誤)，是連結: redux
首先redux是什麼呢？redux的起源與react有關，facebook推出一種叫flux的資料流架構，而如今redux憑借著簡單優雅的架構成為了主流的實作，它受到elm這隻程式語言的啟發而對flux做出修正
那麼flux是什麼呢？或者說，它的重點是什麼？flux試圖解決JavaScript程式長久以來面臨的問題：究竟是誰改變了狀態？
事實上這不只是JavaScript會面臨的問題，是所有具有多個改變狀態的原因的程式需要面對的問題
追蹤狀態的改變是如此的複雜，flux點出的關鍵在於我們不知道狀態存放的地點以及誰可以接觸到它，既然了解了問題點所在，我們就能問題提出解法
好吧！到了這裡，相信大家都已經了解flux存在的意義，那麼它面臨了什麼樣的新問題呢？
問題在於實作，flux由action dispatcher store view組成(但是view通常並非其實作所關注的，而是一種抽象的概念，指涉使用它的展示層)
store儲存資料，dispatcher分發事件，view觀察store中的資料對自己做出更新
使用者觸發action，dispatch就會觸發已註冊的那些callback，最終達到update store的效果
實際操作起來的問題是dispatcher會變得非常多，每次應用就會出現類似的程式
而這顯然與程式工程師們習慣不符，我們就是『懶』
那麼如何解決這樣的問題呢？redux參考函數式語言的一些概念，提出了
reducer(previousState, action) => newState
這樣的等式，更有趣的是你不能提供一個store初始狀態給redux，而是要給予一個個reducer組成store，每個reducer各自擁有initial state，store的初始狀態變由此決定
除此之外，redux也沒有dispatcher，它只有dispatch函數，所以我們不用管理事件會分發給誰，因為所有reducer都會收到
接著是subscribe函數，這個函數讓呼叫方的函數可以在dispatch時自動被執行，唯一的限制是裡面不能再度呼叫dispatch，這會無限遞迴
好了，最後我們進入正題，這個Go版的redux究竟是怎麼實作的呢？
首先是NewStore函數，它是我們這個版本的createStore，命名是依照Go的慣例
其回傳一個Store指標(我們當然不想要複製整個Store，其成本難以想像，JS的物件則是本來就不會複製(預設))
接受reducer型別作為參數

type reducer func(interface{}, Action) interface{}

reducer定義非常簡單，就是我們前面看到的reducer(previousState, action) => newState的樣子
Store定義如下

type Store struct {
        GetState map[string]interface{}
        reducers []reducer
        subscribes []func()
        atSubscribe bool
        mu sync.Mutex
}

reducers, subscribes無須解釋，GetState即是我們所有state存放的位置，這樣取名是為了呼叫時的清晰度
(其實想改掉了，這樣會被客戶端修改，其實失去了保證性)
mu在共時程式之中保證Dispatch會安全完成
atSubscribe則是保證Subscribe中不得呼叫Dispatch

func NewStore(r reducer, reducers ...reducer) *Store {
        s := &Store{
                GetState:    make(map[string]interface{}),
                atSubscribe: false,
        }
        s.newReducer(r)
        for _, r := range reducers {
                s.newReducer(r)
        }
        return s
}

將參數分成兩部份是因為這樣就不需要自己檢查參數(...散列可以為空之特性)，而是由編譯器做出保證
除去上述的特殊設計，非常容易看出程式的邏輯，我們把一個個reducer綁上我們可愛的store
到這裡我們先看看實際案例

import "github.com/dannypsnl/redux"

func counter(state interface{}, action redux.Action) interface{} {
        // Initial State
        if state == nil {
                return 0
        }
        switch action.Type {
        case "INC":
                return state.(int)+1
        case "DEC":
                return state.(int)-1
        default:
                return state
        }
}

func main() {
        store := redux.NewStore(counter)
        store.Subscribe(func() {
                fmt.Printf("Now state is %v\n", store.GetState["counter"])
        })
        store.Dispatch(redux.SendAction("INC"))
}

我們居然可以GetState["counter"]！？
這就是用在newReducer中的魔法了

func (s *Store) newReducer(r reducer) {
        s.GetState[getReducerName(r)] = r(nil, Action{})
        s.reducers = append(s.reducers, r)
}

應該很容易能看出，我們找出reducer的參考名稱，並用此名稱作為鍵值，用nil調用reducer(Action在這裡不重要，想一下Go版reducer的定義中必須在nil時回傳initial state)
然後將reducer放入我們的大殺器reducers中(!?)
getReducerName實作如下

func getReducerName(r reducer) string {
        fullName := runtime.FuncForPC(reflect.ValueOf(r).Pointer()).Name()
        return fullName[strings.LastIndexByte(fullName, '.')+1:]
}

我們先用runtime API取得指標指向的函數，再存取其名稱，這時我們會得到完整的名稱(套件.參考名稱)
所以去除套件部份之後就是我們想要的部份了
做成helper函數的原因是之後更新state時也需要這個函數，DRY，很好

接著我們看Dispatch的實作

func (s *Store) Dispatch(act *Action) {
    s.mu.Lock()
    if s.atSubscribe {
        panic(`you're trying to invoke Dispatch inside the subscribed function`)
    }
    for _, r := range s.reducers {
        funcName := getReducerName(r)
        s.GetState[funcName] = r(s.GetState[funcName], *act)
    }
    // we call subscribed function after state updated.
    s.atSubscribe = true
    for _, subscribtor := range s.subscribes {
        subscribtor()
    }
    s.atSubscribe = false
    s.mu.Unlock()
}

可以看到if atSubscribe程式就會崩潰，這樣能夠阻止想做蠢事的正常呼叫(但是你阻止不了硬要用recover卻不處理這個問題的人)(目前這部份有bug，事實上我們會先遇上deadlock而不是panic，雖然結果正確但是失去錯誤訊息的提示)
我們對操作上鎖
所以程式能夠安全的在共時程式中執行，而狀態更新上鎖也算是正常的設計
然後我們執行那些subscribe進來的函數，注意註冊的函數不能有參數，因為我也不知道要傳什麼參數給你，那很不合理對吧
而最後Subscribe的實作索然無味，就只是將我們可愛的函式們放入註冊函數集合中

func (s *Store) Subscribe(subscribetor func()) {
    s.subscribes = append(s.subscribes, subscribetor)
}

最後總結是為了Go的一些特性我們得要做出取捨，例如原版中，只有一個reducer的情況只需要使用getState就能得到狀態，但是我統一使用函數名稱做存取，因為Go不允許多載函數，而動態參數列亦不太適合(我們得在參數數量超過1時panic，0時檢查reducer的數量，都很麻煩)

另外state型別為interface{}的部份，這並不會造成任何問題，因為state只在reducer中被使用，因此強制轉型並不會造成問題

謝謝觀看，歡迎提出改進意見