OVERVIEW
Imp is a little scripting language I'm building for fun. It
is dynamic, duck-typed, and focused on prototypal programming.
> (import 'core/io')
> (io:writeLine 'Hello, world!')
TUTORIAL
Above, we import the standard 'io' module and call its
'writeLine' function on a string. Resulting is an instance of
software's greatest cliché.
The following produces identical output:
> (def sayHello {io:writeLine 'Hello, World!'})
> (sayHello)
As would:
> (def sayHello {(io:writeLine 'Hello, World!')})
> (sayHello)
This is because, in imp, curly braces define code blocks, and
because the first code block contains only one statement,
parenthesis are implied.
Object Literals
Arbitrary objects are constructed by surrounding key-value
pairs with hard brackets:
> (def someObject [
field1 'I am a field.'
field2 'No you are not!'
field3 'Shut it, you two.'
])
Note that nesting is allowed:
> (def anotherObject [
nestedObject [
field 'I am a field'
]
])
The Object System
Imp is dynamic and duck-typed. There are no compile-time
distinctions between objects, which contain arbitrary
string keys that map to nested objects (except in the case
of built-in data).
Object fields are accessible via the colon operator and are
most conveniently managed with the built-in 'def', 'set',
and 'rem' functions. 'rem' is rarely necessary, though.
> (def a 2)
> (set a 3)
> (rem a)
> (def myObject:mySlot 'hello')
> (rem myObject)
Exceptions are thrown when code attempts to access fields
and methods that do not exist. For example:
> (def myObject []) # Create new object.
> (myObject:nonExistentMethod) # Error!
Methods are defined and called as follows:
> (def myObject [greeting 'Hi,'])
> (def myObject:greet {
(io:writeLine self:greeting (@:get 0) '!')
})
> (myObject:greet)
The 'self' variable is injected into scope. Likewise is the
'@' arguments variable, an array of arbitrary length.
The symbols '#' and '~' stand for "base object" and
"clone", respectively. The former contains all sorts of
functions built in to the Imp interpreter. And the latter
is a primitive operation in prototype-oriented programming.
You will see it often.
A select few symbols are used to represent common operations.
Besides '#' and '~', there is '$', for example, which can be
read as "value" or "copy", and because all Imp objects are
reference types, (obj:$) is often necessary.
INSTALLATION
> git clone git@github.com:dasmithii/imp.git
> cd imp
> make release
> make install
`imp` will now be available on your command line.
Etymology
The word "imp" is defined as "a mischievous child" and
doubles as the acronym: I Make Programs. It is also a
substring of "simple". That's the best I could do.