const (
    Good Class = "Good"
    Bad  Class = "Bad"
)

func Test_SimpleClassification(t *testing.T) {

    classifier := NewClassifier(Good, Bad)

    goodStuff := []string{"tall", "rich", "handsome"}
    badStuff := []string{"poor", "smelly", "ugly"}

    classifier.Learn(goodStuff, Good)
    classifier.Learn(badStuff, Bad)

    scores, likely, _ := classifier.LogScores([]string{"tall", "girl"})

    t.Log(scores) // [-27.12019549216256 -51.350019226428955]
    t.Log(likely) // 0

    probs, likely, _ := classifier.ProbScores([]string{"tall", "girl"})

    t.Log(probs) // [0.99999999997 2.99999999991e-11]
    t.Log(likely) // [0.99999999997 2.99999999991e-11]
}

形態素解析（けいたいそかいせき、Morphological Analysis）とは、文法的な情報の注記の無い自然言語のテキストデータ（文）から、対象言語の文法や、辞書と呼ばれる単語の品詞等の情報にもとづき、形態素（Morpheme, おおまかにいえば、言語で意味を持つ最小単位）の列に分割し、それぞれの形態素の品詞等を判別する作業である。

func Test_日本語分かち書き(t *testing.T) {

    to := tokenizer.New()
    tokens := to.Tokenize("最高の寿司体験")

    for _, token := range tokens {
        if token.Class == tokenizer.DUMMY {
            fmt.Printf("%s\n", token.Surface)
            continue
        }
        features := strings.Join(token.Features(), ",")
        fmt.Printf("%s\t%v\n", token.Surface, features)

    // BOS
    // 最高   名詞,一般,*,*,*,*,最高,サイコウ,サイコー
    // の  助詞,連体化,*,*,*,*,の,ノ,ノ
    // 寿司   名詞,一般,*,*,*,*,寿司,スシ,スシ
    // 体験   名詞,サ変接続,*,*,*,*,体験,タイケン,タイケン
    // EOS
    }
}

import "net/http"

func main() {
    http.ListenAndServe(
        ":8080",
        http.HandlerFunc(func (w http.ResponseWriter, r *http.Request) {
            // do something
        }),
    )
}

import (
    "net/http"
    "net/http/cgi"
)

func main() {
    cgi.Serve(
        http.HandlerFunc(func (w http.ResponseWriter, r *http.Request) {
            // do something
        }),
    )
}

listen:
  port: 8081
user: username
hosts:
  "localhost":
    paths:
      /:
        file.dir: ./
        file.index: ["index.cgi"]
        file.custom-handler:
          extension: .cgi
          fastcgi.spawn:
            command: "exec $H2O_ROOT/share/h2o/fastcgi-cgi"

access-log: log/access-log
error-log: log/error-log
pid-file: log/pid-file

$ h2o -c h2o.yml

$ go get -u github.com/gobuffalo/buffalo/buffalo

$ buffalo new <name>

$ buffalo dev

$ buffalo test

func main() {
    gui, err := gocui.NewGui(gocui.Output256)

    if err != nil {
        panic(err)
    }
    defer gui.Close()

    if err := gui.SetKeybinding("", gocui.KeyCtrlC, gocui.ModNone, quit); err != nil {
        panic(err)
    }

    component.NewSelect(gui, "Programming Language:", 0, 0, 21, 10).
        AddOptions("Go", "Java", "PHP", "Python", "Ruby", "C", "C++", "C#").
        Draw()

    if err := gui.MainLoop(); err != nil && err != gocui.ErrQuit {
        panic(err)
    }
}

type Select struct {
    *InputField
    options      []string // 選択するオプション一覧を保持する
    currentOpt   int // 現在選択しているオプションの配列インデックス
    isExpanded   bool // オプション一覧が開いているかどうかの判定フラグ
    ctype        ComponentType // componentのタイプ Formでcomponentの判定に使用する
    listColor    *Attributes // オプション一覧の色の定義
    listHandlers Handlers // オプション一覧を開いたときの操作の定義
}

// NewSelect new select
func NewSelect(gui *gocui.Gui, label string, x, y, labelWidth, fieldWidth int) *Select {

    s := &Select{
        InputField:   NewInputField(gui, label, x, y, labelWidth, fieldWidth), // InputFieldのインスタンスを生成
        listHandlers: make(Handlers),
        ctype:        TypeSelect,
    }

    // Enterでオプション一覧を開くように、InputFieldのAddHandlerを使用して定義
    s.AddHandler(gocui.KeyEnter, s.expandOpt) 

    // オプション一覧の色を定義
    s.AddAttribute(gocui.ColorBlack, gocui.ColorWhite, gocui.ColorBlack, gocui.ColorGreen).
        // AddListHandlerを利用してオプション一覧を開いたとき、jk↑↓で移動、Enterで選択できるように定義
        AddListHandler('j', s.nextOpt).
        AddListHandler('k', s.preOpt).
        AddListHandler(gocui.KeyArrowDown, s.nextOpt).
        AddListHandler(gocui.KeyArrowUp, s.preOpt).
        AddListHandler(gocui.KeyEnter, s.selectOpt).
        // `InputField`を埋め込んでいるので、入力できないようにする必要がある
        SetEditable(false)

    return s
}

func (s *Select) expandOpt(g *gocui.Gui, vi *gocui.View) error {
    if s.hasOpts() {
        s.isExpanded = true
        g.Cursor = false

        x := s.field.X
        w := s.field.W

        y := s.field.Y
        h := y + 2

        for _, opt := range s.options {
            // オプション一覧は下方向に展開していくので、yとh座標をインクリメントする
            y++
            h++

            // オプションごとviewを定義していく
            if v, err := g.SetView(opt, x, y, w, h); err != nil {
                if err != gocui.ErrUnknownView {
                    panic(err)
                }

                v.Frame = false
                v.SelFgColor = s.listColor.textColor
                v.SelBgColor = s.listColor.textBgColor
                v.FgColor = s.listColor.hilightColor
                v.BgColor = s.listColor.hilightBgColor

                // 設定したキーバインドをオプションごとに追加する
                for key, handler := range s.listHandlers {
                    if err := g.SetKeybinding(v.Name(), key, gocui.ModNone, handler); err != nil {
                        panic(err)
                    }
                }

                fmt.Fprint(v, opt)
            }

        }

        // 一覧を開いたときに選択したのオプションにフォーカスを当てる
        v, _ := g.SetCurrentView(s.options[s.currentOpt])
        v.Highlight = true
    }

    return nil
}

func (s *Select) selectOpt(g *gocui.Gui, v *gocui.View) error {
    // オプション一覧が開いていれば閉じる、開いていなければ展開する
    if !s.isExpanded {
        s.expandOpt(g, v)
    } else {
        s.closeOpt(g, v)
    }

    return nil
}

func (s *Select) nextOpt(g *gocui.Gui, v *gocui.View) error {
    maxOpt := len(s.options)
    if maxOpt == 0 {
        return nil
    }

    // 前のオプションのフォーカスを外す
    v.Highlight = false

    next := s.currentOpt + 1
    if next >= maxOpt {
        next = s.currentOpt
    }

    // 次のオプションにフォーカスを当てる
    s.currentOpt = next
    v, _ = g.SetCurrentView(s.options[next])

    v.Highlight = true

    return nil
}

func (s *Select) closeOpt(g *gocui.Gui, v *gocui.View) error {
    s.isExpanded = false
    g.Cursor = true

    // オプションリストのviewとキーバインドを削除する
    for _, opt := range s.options {
        g.DeleteView(opt)
        g.DeleteKeybindings(opt)
    }

    v, _ = g.SetCurrentView(s.GetLabel())

    v.Clear()

    // 選択したオプションを反映する
    fmt.Fprint(v, s.GetSelected())

    return nil
}

    for _, cp := range f.components {
        p := cp.GetPosition()
        if p.W > f.W {
            f.W = p.W
        }
        if p.H > f.H {
            f.H = p.H
        }
        cp.AddHandlerOnly(gocui.KeyTab, f.NextItem)
        cp.AddHandlerOnly(gocui.KeyArrowDown, f.NextItem)
        cp.AddHandlerOnly(gocui.KeyArrowUp, f.PreItem)
        cp.Draw()
    }

package main

import (
    "fmt"
)

func main() {
    fmt.Printf("%v\n", true)
    fmt.Printf("%v\n", 42)
    fmt.Printf("%v\n", uint(42))
    fmt.Printf("%v\n", 12.345)
    fmt.Printf("%v\n", 1-2i)
    fmt.Printf("%v\n", "寿司🍣Beer🍺")
    fmt.Printf("%v\n", make(chan bool))
    fmt.Printf("%v\n", new(int))
}

true
42
42
12.345
(1-2i)
寿司🍣Beer🍺
0x434080
0x416028

package main

import (
    "fmt"
    "net/http"
)

func main() {
    fmt.Printf("%v\n", http.Client{})
    fmt.Printf("%v\n", &http.Client{})
    fmt.Printf("%v\n", [...]int{1, 2, 3})
    fmt.Printf("%v\n", &[...]int{1, 2, 3})
    fmt.Printf("%v\n", []int{1, 2, 3})
    fmt.Printf("%v\n", &[]int{1, 2, 3})
    fmt.Printf("%v\n", map[string]int{"寿司": 1000, "ビール": 500})
    fmt.Printf("%v\n", &map[string]int{"寿司": 1000, "ビール": 500})
}

{<nil> <nil> <nil> 0s}
&{<nil> <nil> <nil> 0s}
[1 2 3]
&[1 2 3]
[1 2 3]
&[1 2 3]
map[寿司:1000 ビール:500]
&map[寿司:1000 ビール:500]

package main

import (
    "fmt"
    "net/http"
)

func main() {
    fmt.Printf("%v\n", http.Client{})
    fmt.Printf("%+v\n", http.Client{})
}

{<nil> <nil> <nil> 0s}
{Transport:<nil> CheckRedirect:<nil> Jar:<nil> Timeout:0s}

package main

import (
    "fmt"
    "net/http"
)

func main() {
    fmt.Printf("%#v\n", true)
    fmt.Printf("%#v\n", 42)
    fmt.Printf("%#v\n", uint(42))
    fmt.Printf("%#v\n", 12.345)
    fmt.Printf("%#v\n", 1-2i)
    fmt.Printf("%#v\n", "寿司🍣Beer🍺")
    fmt.Printf("%#v\n", make(chan bool))
    fmt.Printf("%#v\n", new(int))
    fmt.Printf("\n")
    fmt.Printf("%#v\n", http.Client{})
    fmt.Printf("%#v\n", &http.Client{})
    fmt.Printf("%#v\n", [...]int{1, 2, 3})
    fmt.Printf("%#v\n", &[...]int{1, 2, 3})
    fmt.Printf("%#v\n", []int{1, 2, 3})
    fmt.Printf("%#v\n", &[]int{1, 2, 3})
    fmt.Printf("%#v\n", map[string]int{"寿司": 1000, "ビール": 500})
    fmt.Printf("%#v\n", &map[string]int{"寿司": 1000, "ビール": 500})
}

true
42
0x2a
12.345
(1-2i)
"寿司🍣Beer🍺"
(chan bool)(0x834100)
(*int)(0x816260)

http.Client{Transport:http.RoundTripper(nil), CheckRedirect:(func(*http.Request, []*http.Request) error)(nil), Jar:http.CookieJar(nil), Timeout:0}
&http.Client{Transport:http.RoundTripper(nil), CheckRedirect:(func(*http.Request, []*http.Request) error)(nil), Jar:http.CookieJar(nil), Timeout:0}
[3]int{1, 2, 3}
&[3]int{1, 2, 3}
[]int{1, 2, 3}
&[]int{1, 2, 3}
map[string]int{"寿司":1000, "ビール":500}
&map[string]int{"寿司":1000, "ビール":500}

package main

import (
    "fmt"
    "net/http"
)

func main() {
    fmt.Printf("%T\n", true)
    fmt.Printf("%T\n", 42)
    fmt.Printf("%T\n", uint(42))
    fmt.Printf("%T\n", 12.345)
    fmt.Printf("%T\n", 1-2i)
    fmt.Printf("%T\n", "寿司🍣Beer🍺")
    fmt.Printf("%T\n", make(chan bool))
    fmt.Printf("%T\n", new(int))
    fmt.Printf("\n")
    fmt.Printf("%T\n", http.Client{})
    fmt.Printf("%T\n", &http.Client{})
    fmt.Printf("%T\n", [...]int{1, 2, 3})
    fmt.Printf("%T\n", &[...]int{1, 2, 3})
    fmt.Printf("%T\n", []int{1, 2, 3})
    fmt.Printf("%T\n", &[]int{1, 2, 3})
    fmt.Printf("%T\n", map[string]int{"寿司": 1000, "ビール": 500})
    fmt.Printf("%T\n", &map[string]int{"寿司": 1000, "ビール": 500})
}

bool
int
uint
float64
complex128
string
chan bool
*int

http.Client
*http.Client
[3]int
*[3]int
[]int
*[]int
map[string]int
*map[string]int

package main

import (
    "fmt"
)

func main() {
    fmt.Printf("%t\n", true)
    fmt.Printf("%t\n", false)
}

true
false

package main

import (
    "fmt"
)

func main() {
    answer := 42
    fmt.Printf("%b\n", answer)
    fmt.Printf("%c\n", answer)
    fmt.Printf("%d\n", answer)
    fmt.Printf("%o\n", answer)
    fmt.Printf("%q\n", answer)
    fmt.Printf("%x\n", answer)
    fmt.Printf("%X\n", answer)
    fmt.Printf("%U\n", answer)
}

101010
*
42
52
'*'
2a
2A
U+002A

package main

import (
    "fmt"
)

func main() {
    f := 12.345
    fmt.Printf("%b\n", f)
    fmt.Printf("%e\n", f)
    fmt.Printf("%E\n", f)
    fmt.Printf("%f\n", f)
    fmt.Printf("%F\n", f)
    fmt.Printf("%g\n", f)
    fmt.Printf("%G\n", f)
    fmt.Printf("%g\n", 12345678.9)
    fmt.Printf("%G\n", 12345678.9)
}

6949617174986097p-49
1.234500e+01
1.234500E+01
12.345000
12.345000
12.345
12.345
1.23456789e+07
1.23456789E+07

package main

import (
    "fmt"
)

func main() {
    s := "寿司🍣Beer🍺"
    fmt.Printf("%s\n", s)
    fmt.Printf("%q\n", s)
    fmt.Printf("%x\n", s)
    fmt.Printf("%X\n", s)
}

寿司🍣Beer🍺
"寿司🍣Beer🍺"
e5afbfe58fb8f09f8da342656572f09f8dba
E5AFBFE58FB8F09F8DA342656572F09F8DBA

package main

import (
    "fmt"
)

func main() {
    f := 12.345
    fmt.Printf("%f\n", f)
    fmt.Printf("%12f\n", f)
    fmt.Printf("%12.2f\n", f)
    fmt.Printf("%.2f\n", f)
    fmt.Printf("%12.f\n", f)
    fmt.Printf("%e\n", f)
    fmt.Printf("%#g\n", f)
    fmt.Printf("%g\n", f)

    fmt.Printf("%f", 1-2i)
}

12.345000
   12.345000
       12.35
12.35
          12
1.234500e+01
12.3450
12.345
(1.000000-2.000000i)

package main

import (
    "fmt"
)

func main() {
    fmt.Printf("%d\n", 42)
    fmt.Printf("%+d\n", 42)
    fmt.Printf("%q\n", 945)
    fmt.Printf("%+q\n", 945)
    fmt.Printf("%q\n", "寿司🍣Beer🍺")
    fmt.Printf("%+q\n", "寿司🍣Beer🍺")
}

42
+42
'α'
'\u03b1'
"寿司🍣Beer🍺"
"\u5bff\u53f8\U0001f363Beer\U0001f37a"

package main

import (
    "fmt"
)

func main() {
    fmt.Printf("%5d\n", 42)
    fmt.Printf("%-5d\n", 42)
    fmt.Printf("%10s\n", "寿司🍣Beer🍺")
    fmt.Printf("%-10s\n", "寿司🍣Beer🍺")
}

   42
42   
  寿司🍣Beer🍺
寿司🍣Beer🍺

package main

import (
    "fmt"
)

func main() {
    answer := 42
    fmt.Printf("%o\n", answer)
    fmt.Printf("%#o\n", answer)
    fmt.Printf("%x\n", answer)
    fmt.Printf("%#x\n", answer)
    fmt.Printf("%X\n", answer)
    fmt.Printf("%#X\n", answer)
    fmt.Printf("%p\n", &answer)
    fmt.Printf("%#p\n", &answer)
    fmt.Printf("%q\n", "go")
    fmt.Printf("%#q\n", "go")
    fmt.Printf("%q\n", "`go`")
    fmt.Printf("%#q\n", "`go`")
    fmt.Printf("%.f\n", 12.345)
    fmt.Printf("%#.f\n", 12.345)
    fmt.Printf("%g\n", 12.345)
    fmt.Printf("%#g\n", 12.345)
    fmt.Printf("%U\n", answer)
    fmt.Printf("%#U\n", answer)
}

52
052
2a
0x2a
2A
0X2A
0x416020
416020
"go"
`go`
"`go`"
"`go`"
12
12.
12.345
12.3450
U+002A
U+002A '*'

package main

import (
    "fmt"
)

func main() {
    fmt.Printf("%d\n", 42)
    fmt.Printf("% d\n", 42)
    fmt.Printf("%x\n", "寿司🍣Beer🍺")
    fmt.Printf("% x\n", "寿司🍣Beer🍺")
    fmt.Printf("%X\n", "寿司🍣Beer🍺")
    fmt.Printf("% X\n", "寿司🍣Beer🍺")
}

42
 42
e5afbfe58fb8f09f8da342656572f09f8dba
e5 af bf e5 8f b8 f0 9f 8d a3 42 65 65 72 f0 9f 8d ba
E5AFBFE58FB8F09F8DA342656572F09F8DBA
E5 AF BF E5 8F B8 F0 9F 8D A3 42 65 65 72 F0 9F 8D BA

package main

import (
    "fmt"
)

func main() {
    fmt.Printf("%10s\n", "寿司🍣Beer🍺")
    fmt.Printf("%010s\n", "寿司🍣Beer🍺")
    fmt.Printf("%10.3f\n", -12.345)
    fmt.Printf("%010.3f\n", -12.345)
}

  寿司🍣Beer🍺
00寿司🍣Beer🍺
   -12.345
-00012.345

package main

import (
    "fmt"
)

func main() {
    fmt.Printf("%[2]s %[1]s\n", "寿司🍣", "Beer🍺")
    fmt.Printf("%[3]*.[2]*[1]f\n", 12.345, 2, 8)
    fmt.Printf("%*.*f\n", 8, 2, 12.345)
    fmt.Printf("%s %s %[1]q %q", "寿司🍣", "Beer🍺")
}

Beer🍺 寿司🍣
   12.35
   12.35
寿司🍣 Beer🍺 "寿司🍣" "Beer🍺"

type Type int

const (
    a Type = iota
    b
    c
)

type S struct {
    T Type
}

func main() {
    s := S{}
    switch s.T {
    case a:
        fmt.Println("a") // <- 実際にはここを通る
    case b:
        fmt.Println("b")
    case c:
        fmt.Println("b")
    default:
        fmt.Println("default") // <- s.T に何も設定していなかったらここを通ってほしい
    }
}

const (
    a Type = iota + 1 // <- 1から始める
    b
    c
)

func main() {
    s := S{}
    switch s.T {
    case a:
        fmt.Println("a")
    case b:
        fmt.Println("b")
    case c:
        fmt.Println("b")
    default:
        fmt.Println("default") // <- s.T に何も設定していないのでここを通る！
    }
}

select * from foo where id = :id and bar = :bar

select * from foo where id = /*id*/5 /* IF enabled */and bar = /*bar*/'foo' /*END*/

select * from foo where id = 5 and bar = 'foo'

select * from foo where id = /*id*/5 /* IF enabled */and bar = /*bar*/'foo' /*END*/

select * from foo where id = :id

env := make(map[string]interface{})
env["enabled"] = true

sql2way := `
select
  *
from
  foo
where
  id = /*id*/5
/* IF enabled */
  and bar = /*bar*/3
/*END*/
`

sql, err := Eval(sql2way, env, ways2go.Question)

select
  *
from
  foo
where
  id = ?
  and bar = ?

func main() {
    http.HandleFunc("/", handler.Handle)
    http.ListenAndServe(":8080", nil)
}

func Handle(w http.ResponseWriter, r *http.Request) {
    if r.Method != http.MethodPost {
        w.WriteHeader(http.StatusBadRequest)
        return
    }
    defer r.Body.Close()

    byteBody, err := ioutil.ReadAll(r.Body)
    if err != nil {
        w.WriteHeader(http.StatusBadRequest)
        return
    }

    var jsonMap map[string]interface{}
    if err := json.Unmarshal(byteBody, &jsonMap); err != nil {
        fmt.Println(err)
        w.WriteHeader(http.StatusBadRequest)
        return
    }
    fmt.Println(jsonMap)

    token := jsonMap["token"].(string)
    if token != os.Getenv("SLACK_TOKEN") {
        w.WriteHeader(http.StatusBadRequest)
        return
    }

    eventType := jsonMap["type"].(string)
    switch eventType {
    case "url_verification":
        challenge := jsonMap["challenge"].(string)
        w.WriteHeader(200)
        w.Write([]byte(challenge))
        return
    case "event_callback":
        event := jsonMap["event"].(map[string]interface{})
        eventTypeString := event["type"].(string)
        if eventTypeString == "app_mention" {
            eventText := event["text"].(string)
            stringReader := strings.NewReader(eventText)
            scanner := bufio.NewScanner(stringReader)
            scanner.Scan()
            scanner.Scan()
            text := scanner.Text()
            splitSlice := strings.Split(text, ":")
            if len(splitSlice) < 1 {
                w.WriteHeader(http.StatusBadRequest)
                return
            }
            switch splitSlice[0] {
            case "search":
                w.WriteHeader(200)
                if err != nil {
                    fmt.Fprint(os.Stderr, err)
                    return
                }
                service, err := service.NewService()
                if err != nil {
                    fmt.Fprint(os.Stderr, err)
                    return
                }
                channelName := event["channel"].(string)
                go service.SendAnswer(splitSlice[1], channelName)
                return
            }
        }
    default:
        w.WriteHeader(http.StatusBadRequest)
        return
    }
}

@bookshlf
saerch:HTTP

type Finder interface {
    Find(searchWord string) ([]domain.Book, error)
    Close()
}

type CSV struct {
    reader io.ReadCloser
}

func (c *CSV) Find(searchWord string) ([]domain.Book, error) {
    bookSlice := make([]domain.Book, 0, 10)
    csvReader := csv.NewReader(c.reader)
    record, err := csvReader.ReadAll()
    if err != nil {
        fmt.Println(err)
        return nil, err
    }
    for _, row := range record {
        if strings.Contains(row[2], searchWord) && row[2] != "" && searchWord != "" {
            newBook := domain.Book{ISBN: row[0], Title: row[2], Author: row[3], Publisher: row[4]}
            bookSlice = append(bookSlice, newBook)
        }
    }
    return bookSlice, nil
}

//Close関数は省略

ISBN,found,title,author,publisher,volume,series,cover

type Book struct {
    ISBN      string
    Title     string
    Author    string
    Publisher string
}

type BookService struct {
    finder finder.Finder
}

func (b *BookService) SendAnswer(query string, channelName string) {
    bookSlice, err := b.finder.Find(query)
    if err != nil {
        fmt.Println(err)
    }

    var sendMessage strings.Builder
    length := strconv.Itoa(len(bookSlice))
    fmt.Println(length)
    if len(bookSlice) > 0 {
        sendMessage.WriteString("本あったよ:sunglasses:\n")
        sendMessage.WriteString("検索結果/" + length + "件\n")
    } else {
        sendMessage.WriteString("残念だ...\n")
    }

    for _, book := range bookSlice {
        sendMessage.WriteString("```")
        sendMessage.WriteString(book.ToString())
        sendMessage.WriteString("```")
        sendMessage.WriteString("\n")
    }
    message.SendMessage(channelName, sendMessage.String())
    b.finder.Close()
}

func SendMessage(channelName string, message string) {
    values := url.Values{}
    token := os.Getenv("SLACK_OAUTH_TOKEN")
    values.Add("token", token)
    values.Add("channel", channelName)
    values.Add("text", message)
    values.Add("mrkdwn", "true")
    resp, err := http.PostForm("https://slack.com/api/chat.postMessage", values)
    if err != nil {
        fmt.Println(err)
    }
    defer resp.Body.Close()

    byteString, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(byteString))
}

cobra.OnInitialize(func() {
    zap.ReplaceGlobals(verboseLogger)
})

cfg := zap.NewDevelopmentConfig()
cfg.EncoderConfig.EncodeLevel = zapcore.CapitalColorLevelEncoder
cfg.Level = zap.NewAtomicLevelAt(zapcore.InfoLevel)
cfg.EncoderConfig.EncodeTime = func(t time.Time, enc zapcore.PrimitiveArrayEncoder) {
    enc.AppendString(t.Local().Format("2006-01-02 15:04:05 MST"))
}

cfg := zap.NewProductionConfig()
cfg.Level = zap.NewAtomicLevelAt(zapcore.DebugLevel)
cfg.DisableStacktrace = true

// https://github.com/srvc/ery/blob/v0.0.1/pkg/app/proxy/manager.go#L20-L25
return &serverManager{
    mappingRepo:     mappingRepo,
    factory:         factory,
    cancellerByPort: new(sync.Map),
    log:             zap.L().Named("proxy"),
}

func AddLoggingFlags(cmd *cobra.Command) {
    var (
        debugEnabled, verboseEnabled bool
    )

    cmd.PersistentFlags().BoolVar(
        &debugEnabled,
        "debug",
        false,
        "Debug level output",
    )
    cmd.PersistentFlags().BoolVarP(
        &verboseEnabled,
        "verbose",
        "v",
        false,
        "Verbose level output",
    )

    cobra.OnInitialize(func() {
        switch {
        case debugEnabled:
            enableDebugLogger()
        case verboseEnabled:
            enableVerboseLogger()
        }
    })
}

type IO interface {
    In() io.Reader
    Out() io.Writer
    Err() io.Writer
}

func Stdio() IO {
    io := &IOContainer{
        InR:  os.Stdin,
        OutW: os.Stdout,
        ErrW: os.Stderr,
    }
    if runtime.GOOS == "windows" {
        io.OutW = colorable.NewColorableStdout()
        io.ErrW = colorable.NewColorableStderr()
    }
    return io
}

SRC_FILES := $(shell go list -f '{{range .GoFiles}}{{printf "%s/%s\n" $$.Dir .}}{{end}}' ./...)
BIN_DIR := ./bin
OUT_DIR := ./dist
GENERATED_BINS :=
PACKAGES :=

XC_ARCH := 386 amd64
XC_OS := darwin linux windows

define cmd-tmpl

$(eval NAME := $(notdir $(1)))
$(eval OUT := $(addprefix $(BIN_DIR)/,$(NAME)))

$(OUT): $(SRC_FILES)
    go build $(GO_BUILD_FLAGS) $(LDFLAGS) -o $(OUT) $(1)

.PHONY: $(NAME)
$(NAME): $(OUT)

.PHONY: $(NAME)-package
$(NAME)-package: $(NAME)
    gox \
        $(LDFLAGS) \
        -os="$(XC_OS)" \
        -arch="$(XC_ARCH)" \
        -output="$(OUT_DIR)/$(NAME)_{{.OS}}_{{.Arch}}" \
        $(1)

$(eval GENERATED_BINS += $(OUT))
$(eval PACKAGES += $(NAME)-package)

endef

$(foreach src,$(wildcard ./cmd/*),$(eval $(call cmd-tmpl,$(src))))

.DEFAULT_GOAL := all

.PHONY: all
all: $(GENERATED_BINS)

.PHONY: packages
packages: $(PACKAGES)

REVISION ?= $(shell git describe --always)
BUILD_DATE ?= $(shell date +'%Y-%m-%dT%H:%M:%SZ')
LDFLAGS := -ldflags "-X main.revision=$(REVISION) -X main.buildDate=$(BUILD_DATE)"

# .travis.yml
# 自分は Travis CI を使うことが多いけど，いまどきの CI as service なら何でもいいと思う

language: go

go: '1.11'

env:
  global:
  - FILE_TO_DEPLOY="dist/*"

  # GITHUB_TOKEN
  - secure: "..."

jobs:
  include:
  # snip.

  - stage: deploy
    install: make setup
    script: make packages -j4
    deploy:
    - provider: releases
      skip_cleanup: true
      api_key: $GITHUB_TOKEN
      file_glob: true
      file: $FILE_TO_DEPLOY
      on:
        tags: true
    if: type != 'pull_request'

.PHONY: lint
lint:
ifdef CI
    gex reviewdog -reporter=github-pr-review
else
    gex reviewdog -diff="git diff master"
endif

# snip.

env:
  global:
  # snip.

  - REVIEWDOG_GITHUB_API_TOKEN=$GITHUB_TOKEN

jobs:
  include:
  - name: lint
    install: make setup
    script: make lint
    if: type = 'pull_request'

  # snip.

.PHONY: setup
setup:
ifdef CI
    curl https://raw.githubusercontent.com/golang/dep/master/install.sh | sh
endif
    dep ensure -v -vendor-only
    @go get github.com/izumin5210/gex/cmd/gex
    gex --build --verbose

$ clig init your-app-name

$ cd your-app-name
$ tree -I 'bin|vendor'
.
├── Gopkg.lock
├── Gopkg.toml
├── Makefile
├── cmd
│   └── awesomecli
│       └── main.go
├── pkg
│   └── awesomecli
│       ├── cmd
│       │   └── cmd.go
│       ├── config.go
│       └── context.go
└── tools.go

$ tree example/
example/
├── main.go
├── util
│   └── util.go
└── util.go

package main

import (
        "fmt"

        "github.com/takashabe/gma/example/util"
)

func main() {
        fmt.Println(util.Foo())
        Foo()
}

package main

func Foo() {}

package util

import "fmt"

func Foo() string {
        return fmt.Sprintf("util")
}

$ gma -main example/main.go -depends example/util.go -depends example/util/util.go
package main

import (
        "fmt"
)

func main() {
        fmt.Println(_util_Foo())
        Foo()
}
func Foo() {
}
func _util_Foo() string {
        return fmt.Sprintf("util")
}

func mergeFiles(files []*ast.File) (*ast.File, error) {
...
  decls := []ast.Decl{}
  for _, file := range files {
    for _, d := range file.Decls {
    g, ok := d.(*ast.GenDecl)
    if ok && g.Tok == token.IMPORT {
      continue
    }
    decls = append(decls, d)
    }
  }

  file := &ast.File{
    Package: files[0].Package,
    Name:    files[0].Name,
    Decls:   decls,
  }
...

func(c *astutil.Cursor) bool {
  n := c.Node()

  callExpr, ok := n.(*ast.CallExpr)
  if !ok {
    return true
  }
  selector, ok := callExpr.Fun.(*ast.SelectorExpr)
  if !ok {
    return true
  }
  x, ok := selector.X.(*ast.Ident)
  if !ok {
    return true
  }
...

  cn := &ast.CallExpr{
    Fun:  repNode.Name,
    Args: callExpr.Args,
  }
  c.Replace(cn)
  return true
}

import . "github.com/ahmetb/go-linq"

type Car struct {
    year int
    owner, model string
}

...


var owners []string

From(cars).Where(func(c interface{}) bool {
    return c.(Car).year >= 2015
}).Select(func(c interface{}) interface{} {
    return c.(Car).owner
}).ToSlice(&owners)

package main

import (
    "fmt"
    "github.com/wesovilabs/koazee"
)

var numbers = []int{1, 5, 4, 3, 2, 7, 1, 8, 2, 3}

func main() {
    fmt.Printf("input: %v\n", numbers)
    stream := koazee.StreamOf(numbers)
    fmt.Print("stream.Reduce(sum): ")
    fmt.Println(stream.Reduce(func(acc, val int) int {
        return acc + val
    }).Int())
}

/**
go run main.go

input: [1 5 4 3 2 7 1 8 2 3]
stream.Reduce(sum): 36
*/

func (op *Filter) validate() (*filterInfo, *errors.Error) {
   item := &filterInfo{}
   fnType := reflect.TypeOf(op.Func)
   if val := cache.get(op.ItemsType, fnType); val != nil {
      return val, nil
   //...... Validations for input
   item.fnInputType = fnIn.Type()
   cache.add(op.ItemsType, fnType, item)
   return item, nil
}

func reverseInt16Ptr(itemsValue reflect.Value) interface{}{
   input := itemsValue.Interface().([]*int16)
   len := len(input)
   output := make([]*int16, len)
   for index := 0; index < (len/2)+1; index++ {
      output[index], output[len-1-index] = input[len-1-index], input[index]
   }
   return output
}

Distro: Ubuntu 18.04.1
Kernel: 4.15.0-42-generic
CPU:    Intel(R) Core(TM) i5-7600 CPU @ 3.50GHz
Mem:    16GB
Go:     go version go1.11.3 linux/amd64

func BenchmarkF0(b *testing.B) {
    for i := 0; i < b.N; i++ {
        _ = f0()
    }
}

func BenchmarkF1(b *testing.B) {
    for i := 0; i < b.N; i++ {
        _ = f1()
    }
}