idea:

(monads)

mechanism for a component to simply pass an item through.
transparent container
generic escape

box	can hold a thing
wrap	takes a thing a puts it in a box
func	takes in and puts out
boxer	takes in and puts out into a box  (i.e. may produce abnormal valued results such as empty, element of {x, y},...)
apply	takes a box and boxer, and produces another box
empty	a common type of box, with nothing in

box
a box can be empty  (if allowed)
safe is a box
present is a box
lock(x) is a safe containing x
lock() is a safe containing nothing
wrap(x) is a present containing x
wrap() is a present containing nothing
get(b) gets x from a box  (if allowed)







'box' or 'handle' ?

graph monad:

we put zero or more things in a box
we can connect them up in relationships or whatever, i.e. we put a graph in the box, can put extra stuff in the box

the especial 'things' that we put in the box can be specifically retrieved from
the box, aside from any other junk or relationships in it

we can ask the box to put all its 'things' through a function

i.e. we may be able to test if a thing is in it, or index the things in it
(enumerate is index by integer, can also index by real number or point, etc),
or put a vague thing in and retrieve a more specific thing out

A function can be applied to all the things in the box, producing another box
with same extras / relationships but mapped things.

With this, we can write functions that act on collections but don't care whether they are set, lists, trees, bags or what


We have boxes:   [x]    [x y]    [x->y<-z]    etc
and stuff, which is like the contents of a box, or a sort of imaginary box with no walls

relations vs transformers:
  a relation says something about how several things are connected
  a process takes some things and does something to them or produces something from them


0ary 1ary relations...?



simply, a function may be seen to act on atoms as  ( + 1 2 ) -> 3
such atom may be structured in transparent structures, e.g. a list (4 5), then
the function may say that the structures must match and atoms are mapped:
(+ [4 5] [1 1]) -> [5 6]
(+ [1 [2 3] foo] [4 [5 6] bar] ->
(+ sin cos) -> (x){sin x + cos x}



any function may preserve existing relationships in its inputs in so much
as those inputs correspond to its outputs



--------------------

Box(X)
wrap(x)

bind
bind

empty  (creates an empty box that holds no X)

unwrap (takes an X out of a box that is not empty)