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
}