View source for Guide:Assignment

= Assignment =

Superficially, Ioke's assignment model is quite simple. But there exists some subtleties too. One of the main reasons for this is that assigning a cell that doesn't exist will create that cell. Where it gets created is different based on what kind of context the assignment happens in. The main difference here is between a method activation context, or a lexical block context.

Ioke also supports assignment of places, which makes assigning much more flexible. A third feature of Ioke assignment is that it will check for the existence of an assignment method before assigning a specific name. This chapter will make all these things clear, and show some examples.

Let's start with a small example of simple assignment:

<pre>foo = Origin mimic
foo x = 42
foo y = 13
foo x += 2</pre>
The first line creates a new Origin mimic, and then assigns that to the name foo. Since this code executes at the top level, &quot;foo&quot; will be a new cell created in Ground. The second line creates a new cell called &quot;x&quot; inside the &quot;foo&quot; object. It gets assigned the value 42. The third line creates a &quot;y&quot; cell, and the fourth line sends the += message, which will first call +, and then assign using =. So at the end of this program, &quot;foo&quot; will contain two cells: &quot;x&quot; with value 44, and &quot;y&quot; with value 13. As mentioned above, cells get created the first time they are assigned to. If you need to create a cell in a specific object, just namespace it. For example, if you want to make sure that you create a cell in Ground, just do &quot;Ground foo = 42&quot;.

Inside of a method, the situation is exactly the same. If you assign something, it will be assigned in the current context, which is the local activation context (meaning it's the place where local variables are available). There are two situations where this doesn't hold true. The first one is within the special method &quot;do&quot;. This method will take any code as argument and execute that with the receiver of the &quot;do&quot; message as the ground/context of the code inside it. That means &quot;do&quot; is a good way to create new cells inside an object.

This is a bit academic, so lets take a look at an example:

<pre>Foo = Origin mimic
Foo x = method(
  ;; this creates a local variable in the method activation
  foo = 42
)

Foo = Origin mimic
Foo do(
  ;; this creates the cell foo inside of Foo
  foo = 42
)</pre>
Here you can see a method defined called x. This method will just create a new local cell, which means calling the method will not make any difference on its receiver at all. The call to &quot;do&quot; in contrast will immediately execute the code inside it, and this code will create the cell &quot;foo&quot; inside of &quot;Foo&quot;.

The second exception to the general rule is when executing inside of a lexical context. A lexical context is basically established inside of a block, but can also be created transparently when sending code to a method. A lexical block will try to not create new cells. When you assign a cell without a specific place to assign it, a lexical block will first see if there is any cell with that name further out, and if so it will make the assignment there instead. Only when no such cell exists, a new cell will be created in the lexical context. This code shows this in action:

<pre>x = 42
fn(x = 43. y = 42) call
x ;; =&gt; 43
y ;; =&gt; Condition Error NoSuchCell</pre>
The &quot;fn&quot; message creates a new lexical block. The chapter on [http://{{SERVERNAME}}/#code code] will talk more about this. But as you can see, this block assigns 43 to the cell &quot;x&quot;, and 42 to the cell &quot;y&quot;. But since the cell &quot;y&quot; doesn't exist, it will only be created inside the lexical context, while &quot;x&quot; exists outside, and will be assigned a new value instead. The basic idea is that code like this should behave like you expect it to behave.

The canonical form of assignment is a bit different from the way you usually write code in Ioke. The section on the syntax of assignments talked a bit about this. Specifically, something like &quot;foo = 42&quot; will get translated into &quot;=(foo, 42)&quot;. That also means that assignment is just a regular method call, and can be overridden or removed just like any other method. That is exactly how both lexical context, and local method context make it possible to have different logic here. This is true for all assignment operators.

All assignment operators take as their first argument the place to assign to. This place will be unevaluated. Only the second argument to an assignment will be evaluated. In most cases, a place is the same thing as a cell name, but it doesn't have to be. Let's look at the case of assigning a cell with a strange name. Say we want to assign the cell with the no name. We can do it like this:

<pre>cell(&quot;&quot;) = 42</pre>
What happens here is a bit subtle. Since the left hand side of the assignment takes arguments, the &quot;=&quot; method figures out that the assignment is not to a simple cell name, but to a place. The parsing step will change &quot;cell(&quot;&quot;) = 42&quot; into &quot;=(cell(&quot;&quot;), 42)&quot;. Notice here that the argument comes along into the specification of the place. When this happens, the assignment operator will not try to create or assign a cell - instead it will in this case call the method cell=. So &quot;cell(&quot;&quot;) = 42&quot; will ultimately end up being the same as &quot;cell=(&quot;&quot;, 42)&quot;. This way of transforming the name will work the same for all cases, so you can have as many arguments as you want to the place on the left hand side. The equals sign will be added to the method name, and a message will be sent to that instead.

This makes assignment of places highly flexible, and the only thing you need to do is implement methods with the right names. This feature is used extensively in Lists and Dicts to make it easy to assign to specific indexes. So, say we have a list called x. Then this code: &quot;x[13] = 42&quot; will be transformed into &quot;x =([](13), 42)&quot; which will in turn be transformed into &quot;x []=(13, 42)&quot;. Ioke lists also has an at= method, so you can do &quot;x at(13) = 42&quot; which will call at=, of course.

The second transformation that might happen is that if you try to assign a cell that has an assigner, you will call that assigner instead of actually assigning a cell. So, for example, if you do &quot;foo documentation = 42&quot;, this will not actually create or assign the cell &quot;documentation&quot;. Instead it will find that Base has a cell called &quot;documentation=&quot;, and instead send that message. So the prior code would actually be equivalent to &quot;foo documentation=(42)&quot;.

All of these assignment processes together make it really easy to take control over assignment, while still making it very obvious and natural in most cases.

== Let ==

Sometimes you really need to change the value of something temporarily, but then make sure that the value gets set back to the original value afterwards. Other situations often arise when you want to have a new name bound to something, but maybe not for a complete method. This might be really useful to create closures, and also to create localized helper methods. For example, the Ioke implementations for Enumerable use a helper syntax macro. This macro is bound temporarily, using a let form. This ensures that the syntax doesn't stay around and pollute the namespace.

A let in Ioke can do two different things, that on the surface look mostly the same but are really very different operations. The first one is to introduce new lexical bindings, and the second is to do a dynamic rebind of a specific place. The easiest way of thinking about it is that the lexical binding introduces a local change or addition to the available names you're currently using, while a dynamic rebinding will change the global state temporarily, and then set it back.

This sounds really academic, so let us go for some examples. We begin with lexical bindings.

<pre>;; put everything in a method to show explicit scope
foo = method(x, y,
  x println ; =&gt; argument value of x
  let(x, 14,
    x println ; =&gt; 14
  )
  x println ; =&gt; argument value of x

  y println ; =&gt; argument value of y
  y = 13
  y println ; =&gt; 13
  let(y, 14,
    y println ; =&gt; 14
  )
  y println ; =&gt; 13

  z println ; will signal condition
  let(z, 42,
    z println ; =&gt; 42
  )
  z println ; will signal condition
)</pre>
Here a new method is created that has two arguments, x and y. The first let-expression will create a new scope where a binding from x to 14 is established. This binding is valid until the end of the let-form (but it can be changed, doing an assignment will set the value to something else, but only until the end of the let form). The same thing is true with y. We can change the value of y outside of the let form. That changes the actual argument variable. But a let form that binds y will only have it active for a limited time. Finally, a let form can also create totally new variables, as when creating z.

I didn't show any example of it, but the first part of a let-name can be any kind of place, not just a simple name. Anything you can use with =, can be used as a name for let. So you could do something like let(cell(&quot;&quot;), 42, nil) if you wanted to.

OK, so that's lexical binding. What about dynamic rebinding? The main difference in a dynamic binding is that the scope you work in is something that is referencable from other scopes. In most cases this will be global places, but not necessarily. You can also rebind cells inside of other objects with the dynamic binding feature.

<pre>bar = method(
  let(Origin foo, method(&quot;haha&quot; println),
    &quot;x&quot; foo
    Origin foo
    [1,2,3] foo
  )

  let(Text something, 42,
    &quot;abc&quot; something println ; =&gt; 42
  )
  &quot;abc&quot; something println ; will signal condition

  let(Text inspect, &quot;HAHA&quot;,
    &quot;foo bar qux&quot; inspect println ; =&gt; &quot;HAHA&quot;
  )
  &quot;foo bar qux&quot; inspect println ; =&gt; #[&quot;foo bar qux&quot;]

  let(Text asRational, method(42),
    (3 + &quot;haha&quot;) println ; =&gt; 45
  )
)</pre>
This example actually changes things quote a lot. The first and second examples introduce new cells into existing places, uses them and then doesn't do anything. The third example actually overrides an existing cell in Text - inspect - and then uses it inside of the let code. Finally, after the let block is over, we see that the original method is back. The fourth example shows that our changes with let actually are global. There is no asRational on Text, but we add it temporarily and can then use it in arithmetic with numbers. This is once again a temporary change that will disappear afterwards.

Ioke's let-form is incredibly powerful, and it allows very nice temporal and localized changes. Of course, it's a power that can be abused, but it gives lots of interesting possibilities for expression.