After getting Io installed, I am feeling a little smug with myself. I don't know if its just because the language is so different, or because I’ve had a beer or what but the Io introductory material seems more complex than that for Ruby. However, looking back at what was covered I suspect that there was actually less material. Io is an extremely minimalist language with a tiny and beautifully consistent syntax. In day one we look at the basics of the syntax -- messages, inheritence, prototypes, slots, methods and the basic collections, lists and maps (read arrays and hashes, roughly). We also get a quick interview with Steve Dekorte, the language's creator.
Evaluate 1+1 and 1+"one". Is Io strongly typed or weakly typed. Suport your answer with code.
Exception: argument 0 to method '+' must be a Number, not a 'Sequence'
message '+' in 'Command Line' on line 1
Well that looks strongly typed to me! We don't implicitly cast to an integer value. I suppose that something like this may be used instead, depending on what you were trying to achieve.
Io> 1+"one" itemSize
Is 0 true or false? What about the empty string? Is nil true or false? Support your answer with code.
Zero is true.
Io> 0 and true
Io> 0 and false
Io> 0 and 0
"" is true
Io> "" and true
Io> "" and ""
Io> "" and false
nil evaluates to false. Not to neither as I’d previously thought. Props to oldak for putting me straight in the comments.
Io> nil and true
Io> nil and nil
Io> nil and false
Io> nil or not nil
How can you tell what slots a prototype supports?
It seems to me like you would use slotNames.
Io> Object slotNames
==> list(newSlot, ownsSlots, isError, foreachSlot, currentCoro, <, removeAllSlots, list, for, doString, uniqueHexId, clone, become, write, evalArgAndReturnNil, serializedSlots, isNil, method, block, pause, isActivatable, deprecatedWarning, isLaunchScript, coroWith, evalArg, uniqueId, ?, actorProcessQueue, do, in, setProto, super, writeln, setSlot, !=, inlineMethod, doRelativeFile, removeAllProtos, coroDo, asyncSend, continue, stopStatus, ancestorWithSlot, print, protos, evalArgAndReturnSelf, actorRun, not, type, and, return, break, slotSummary, >, message, ==, serialized, slotNames, ifNonNilEval, asSimpleString, hasLocalSlot, while, updateSlot, switch, perform, returnIfError, asString, hasSlot, try, returnIfNonNil, hasProto, prependProto, getSlot, wait, justSerialized, hasDirtySlot, thisContext, removeProto, appendProto, println, lazySlot, loop, slotDescriptionMap, launchFile, .., relativeDoFile, serializedSlotsWithNames, compare, , yield, setSlotWithType, init, resend, isTrue, lexicalDo, or, doFile, argIsActivationRecord, raiseIfError, ancestors, isIdenticalTo, ifNil, ifNilEval, performWithArgList, cloneWithoutInit, contextWithSlot, thisLocalContext, >=, if, isKindOf, memorySize, <=, ifNonNil, coroFor, thisMessage, apropos, @, getLocalSlot, ifError, markClean, coroDoLater, slotValues, -, doMessage, proto, setIsActivatable, futureSend, removeSlot, shallowCopy, handleActorException, @@, setProtos, argIsCall)
What is the difference between =, :=, ::= and when should each one be used? When would you use each one?
According to the Io guide's assignment syntax section,
::= Creates slot, creates setter, assigns value
:= Creates slot, assigns value
= Assigns value to slot if it exists, otherwise raises exception
I suppose you'd use ::= if you were creating and setting a slot at the same time and you wanted a setter available for the slot (i.e. same as the newSlot method). := Would be used when you wanted to create a new slot and set it, like the setSlot method. And = would be used to udate an existing slot, like the updateSlot method.
Run an io program from a file.
I nicked the code for this from Io programming begginers guide.
$ cat greet.io
greet := method(
writeln ("What is your name?");
you := File standardInput readLine ("> ");
writeln ("Hello ", you)
What is your name?
Execute the code in a slot given its name.
I wasn't entirely sure what I was doing here. I think it was basically call a method from a named slot. Here was my attempt, anyhow.
$ cat runner.io
runner := Object clone
runner run := method ("Running like a fool!" println)
runner getSlot("run") call // I /think/ that's what Tate meant.
Running like a fool!
Final thoughts on Day One
Io is definitely totally different from the C-like languages — C, C++, Java — and the 'P' scripting languages which have eveolved from them. So I found the learning curve a bit steep, even on day one learning the very basics. However, Io is very cute and I suspect will be relatively straightforward to pick up. At least compared to perl or something!