func (x Process) Materialize() be.Reflex { p := &process{ spawn: make(chan interface{}), } reflex, _ := plumb.NewEyeCognizer(p.cognize, "Command", "Spawn", "Exit", "IO") return reflex }
func (Strobe) Materialize() be.Reflex { x := &strobe{ when: make(chan interface{}, 1), // whens and charges cannot be out of order by more than one slot charge: make(chan interface{}, 1), } reflex, _ := plumb.NewEyeCognizer(x.Cognize, "Charge", "When", "Strobe") return reflex }
func MaterializeWriteTo(w io.Writer) be.Reflex { x := &writerTo{ WriteCloser: kitio.SovereignWriter(w), } reflex, eye := plumb.NewEyeCognizer(x.cognize, "_") go eye.Show("_", x.WriteCloser) return reflex }
func MaterializeReadFrom(w io.Reader) be.Reflex { x := &readFrom{ ReadCloser: kitio.SovereignReader(w), } reflex, eye := plumb.NewEyeCognizer(x.cognize, "_") go eye.Show("_", x.ReadCloser) return reflex }
func (Exit) Materialize() be.Reflex { reflex, _ := plumb.NewEyeCognizer( func(eye *plumb.Eye, valve string, value interface{}) { os.Exit(value.(int)) }, "_", ) return reflex }
func (Fatal) Materialize() be.Reflex { reflex, _ := plumb.NewEyeCognizer( func(eye *plumb.Eye, valve string, value interface{}) { log.Fatalln(value) }, "_", ) return reflex }
func (Memory) Materialize() be.Reflex { h := &memory{ focus: make(chan []interface{}), learn: make(chan *eu.Circuit), recall: make(chan []interface{}), } reflex, eye := plumb.NewEyeCognizer(h.Cognize, "Focus", "Learn", "Recall", "Use") go h.loop(eye) return reflex }
func (See) Materialize() be.Reflex { reflex, _ := plumb.NewEyeCognizer( func(eye *plumb.Eye, dvalve string, dvalue interface{}) { if dvalve != "Source" { return } eye.Show("Seen", es.SeeCircuit(es.NewSrcString(plumb.AsString(dvalue)))) }, "Source", "Seen", ) return reflex }
func (Lookup) Materialize() be.Reflex { reflex, _ := plumb.NewEyeCognizer( func(eye *plumb.Eye, dvalve string, dvalue interface{}) { if dvalve != "Address" { return } _, r := faculty.Root.LookupAddress(dvalue.(string)) eye.Show("Circuit", r.(Circuit)) }, "Address", "Circuit", ) return reflex }
func (LookPath) Materialize() be.Reflex { reflex, _ := plumb.NewEyeCognizer( func(eye *plumb.Eye, valve string, value interface{}) { if valve != "Name" { return } p, err := exec.LookPath(value.(string)) if err != nil { log.Fatalf("no file path to %s", value.(string)) } eye.Show("_", p) }, "Name", "_", ) return reflex }
func (Arg) Materialize() be.Reflex { reflex, _ := plumb.NewEyeCognizer( func(eye *plumb.Eye, valve string, value interface{}) { if valve != "Name" { return } n, ok := value.(string) if !ok { panic("non-string name perceived by os.arg") } eye.Show("Value", args[n]) }, "Name", "Value", ) return reflex }
func (Understand) Materialize() be.Reflex { reflex, _ := plumb.NewEyeCognizer( func(eye *plumb.Eye, dvalve string, dvalue interface{}) { if dvalve != "Seen" { return } switch t := dvalue.(type) { case *es.Circuit: eye.Show("Understood", eu.Understand(t)) } panic("nil or unknown seen") }, "Seen", "Understood", ) return reflex }
func (MergeBlend) Materialize() be.Reflex { reflex, _ := plumb.NewEyeCognizer( func(eye *plumb.Eye, valve string, value interface{}) { if valve != "XYZ" { return } xyz := value.(Circuit) var w bytes.Buffer w.WriteString(flatten(xyz.StringAt("X"))) w.WriteString(flatten(xyz.StringAt("Y"))) w.WriteString(flatten(xyz.StringAt("Z"))) eye.Show("_", w.String()) }, "XYZ", "_", ) return reflex }
func (Env) Materialize() be.Reflex { reflex, _ := plumb.NewEyeCognizer( func(eye *plumb.Eye, valve string, value interface{}) { if valve != "Name" { return } n, ok := value.(string) if !ok { panic("non-string name perceived by os.env") } ev := os.Getenv(n) log.Printf("Environment %s=%s", n, ev) eye.Show("Value", ev) }, "Name", "Value", ) return reflex }
func (FormBlend) Materialize() be.Reflex { reflex, _ := plumb.NewEyeCognizer( func(eye *plumb.Eye, valve string, value interface{}) { if valve != "FormData" { return } fd := value.(Circuit) t, err := template.New("").Parse(fd.StringAt("Form")) if err != nil { panic(err) } var w bytes.Buffer if err = t.Execute(&w, fd.At("Data")); err != nil { panic(err) } eye.Show("_", w.String()) }, "FormData", "_", ) return reflex }
func (d Dir) Materialize() be.Reflex { x := dir(d.dir) reflex, _ := plumb.NewEyeCognizer(x.Cognize, "Path", "_") return reflex }
func (Client) Materialize() be.Reflex { var c1, a1 sync.Once api, consumer, access := make(chan *anaconda.TwitterApi), make(chan Image, 1), make(chan Image, 1) go func() { // start connecting monad var c, a Image for i := 0; i < 2; i++ { select { case c = <-consumer: consumer = nil case a = <-access: access = nil } } anaconda.SetConsumerKey(c.String("Key")) // dial API server anaconda.SetConsumerSecret(c.String("Secret")) y := anaconda.NewTwitterApi(a.String("Token"), a.String("Secret")) for { api <- y // give out api server to all endpoint goroutines } }() // API query := make(chan Image, 5) reflex, eye := plumb.NewEyeCognizer( func(eye *plumb.Eye, valve string, value interface{}) { switch valve { case "Consumer": c1.Do(func() { consumer <- value.(Image) }) case "Access": a1.Do(func() { access <- value.(Image) }) case "UserTimelineQuery", "HomeTimelineQuery", "RetweetsQuery", "RetweetsOfMeQuery": valve = valve[:len(valve)-len("Query")] query <- Make().Grow(valve, value) default: log.Printf("Unknown Twitter query: %s", valve) } }, "Consumer", "Access", // set to start connection "UserTimelineQuery", "UserTimelineResult", // UserTimeline "HomeTimelineQuery", "HomeTimelineResult", // HomeTimeline "RetweetsQuery", "RetweetsResult", // Retweets "RetweetsOfMeQuery", "RetweetsOfMeResult", // RetweetsOfMe ) for i := 0; i < 3; i++ { go func() { // API response loop y := <-api for { g := <-query q := g.Letters()[0] x := g[q].(Image) uv := urlize(x) log.Printf("Twitter %s query %v", q, ImagineWithMaps(uv).(Image).PrintLine()) var tweets []anaconda.Tweet var err error switch q { case "UserTimeline": tweets, err = y.GetUserTimeline(uv) case "HomeTimeline": tweets, err = y.GetHomeTimeline(uv) case "Retweets": tweets, err = y.GetRetweets(int64(x.Int("Id")), uv) case "RetweetsOfMe": tweets, err = y.GetRetweetsOfMe(uv) } if err != nil { log.Fatalf("Problem %s query on Twitter (%v)", q, err) } eye.Show( q, Pretty( Image{ "Name": x.Interface("Name"), "Sentence": Imagine(tweets), }, ), ) } }() } return reflex }
func (Remember) Materialize() be.Reflex { reflex, _ := plumb.NewEyeCognizer((&remember{}).Cognize, "From", "What", "When", "_") return reflex }
func (Choose) Materialize() be.Reflex { reflex, _ := plumb.NewEyeCognizer((&choose{}).Cognize, "When", "From", "_") return reflex }
func (ExploreOnStrobe) Materialize() be.Reflex { reflex, _ := plumb.NewEyeCognizer(CognizeExploreOnStrobe, "Strobe", "Sequence") return reflex }
func (Focus) Materialize() be.Reflex { reflex, _ := plumb.NewEyeCognizer((&focus{}).Cognize, "From", "On", "When", "_") return reflex }
func (Sum) Materialize() be.Reflex { x := &sum{lit: New()} reflex, _ := plumb.NewEyeCognizer(x.Cognize, "X", "Y", "Sum") return reflex }
func (Join) Materialize() be.Reflex { reflex, _ := plumb.NewEyeCognizer((&join{}).Cognize, "_", "Head", "Tail") return reflex }
func (Associate) Materialize() be.Reflex { reflex, _ := plumb.NewEyeCognizer((&association{}).Cognize, "Name", "With", "When", "_") return reflex }