nineties / amber Goto Github PK

Change the internal representation of [a,b,c,...] from a list to an array.

Enable use of OR-pattern.

f(Foo{x, } or Bar{, x}): x

f(\Foo{1, 2}) # => 1
f(\Bar{1, 2}) # => 2

found in commit: c14f05c

When the value of code_base is even amber fails to start up.

What is the best data type for the syntax [a,b,c,...]?
[a,b,c,...] is the most simple expression to represent a sequence. This means that the internal
representation for the sequence must be efficient for most common usages of sequences.

I am considering an improvement on the internal representation of arrays.

1. For the first time we create an array, allocate one continuous memory space for it.

   | header  | obj0 | obj1 | ... | obj n-1 |
   

2. When it is extended and its length becomes bigger than some threshold, allocate another chunk, change the array to dynamically allocated array and truncate area which is no longer required.

   |header|length|capa|pointer|    <-- truncate
                           |
                           +-->| obj0 | obj1 | ... | obj n-1 |
   

The truncation causes fragmentation of heap area, but Amber VM's Copying-GC will resolve it.

Implement predicate named "defined":

defined(f, a_1, ..., a_n) = true (iff `f' is defined for arguments a_1, ..., a_n)

Distinguish f(a,b,c), f[a,b,c] and f{a,b,c} from f (a,b,c), f[a,b,c] and f {a,b,c}.
We need nospace option for defining syntaxes. See also #29.

When a function f returns multiple values as a tuple, we can use pattern matching assignment to pick them up like

(a, b) = f(...)

I think it would be nicer if we can write it like:

a, b = f(...)

There are three possibilities.

1. Do not provide this syntax as a standard.
2. Add parentheses-less tuple syntax.
3. Add special syntax for multiple assignment.

Survey use case of parentheses-less tuple syntax in other languages like Python.
When there are no significant use of it besides multiple assignment, I think it is better
to choice 2.

See also #29.

Enable to assign a value to an interior parameter like:

f(Foo{x, Bar{y}}): {
x = 1
y = 2
}

Note: This assignment must not change given parameter.

e: \Foo{0, Bar{0}}
f(e)
puts(e) # => Foo{0, Bar{0}} (not Foo{1, Bar{2}})

Because Amber's arrays are heterogeneous, arrays can be used in place of tuples.

Currently a symbol "false" is treated as falsehood and every other value is treated as truth.

There should be other falsehoods?

• an integer 0
• empty list []
• a symbol "nil"
• empty string ""
  etc.

Support one-line declaration of modules.

module A { ... }

branch: refactoring (032657d)

1. push arguments
2. pattern matching
3. repush arguments <- eliminate it.
4. call built-in function

95% of calls of make_assembler() are in build_closure().
Since build_closure() always creates fixed-length (13bytes) bytecode, it is not necessary to use assembler.

a - b is parsed as a(-b).

• blocks
  { }, do end, indentation-based or something else.
• application of functions
  f(a,b,c) v.s. f a b c
• nodes
  Head{a, b, c} or Head a b c

The second argument of Send expression is not a variable but a name of method.
The function free_variables trates it as a variable (at 705213b).

I decided to use [a,b,c,..] for arrays (#34). Then, how about lists?

I use a list for a default data type for sequences in the internal implementation of Amber. But lists are not memory efficient (three words are required per one element).

Should Amber support the syntax of parentheses-less function call like Ruby?
I think it would be better to support to make new DSLs easier.

Now, I have one thing to think about tuples and lists.
When someone want to print out a tuple (a,b,c), he may write it as print (a, b, c).
But this is confusable with print(a, b, c), a function call with three arguments a, b and c. Lists has the same problem.
In case of Ruby, there are no tuples and for arrays f[a,b,c] and f [a,b,c] have different meaning.

Are there any other problems with this syntax?