TODO

Requests:

 - String interpolation "asadasdsa {} {1}" % (asdasd)
 - Expression in string "asdas {1 + 2}"
 - Multi-line strings
 - tuples vs lists: (asda,vasdas,vadasd)
 - Modules in multiple files
 - Support module.submodule
 - Importing modules (automatic resolution)
 - 'elif' in conditionals
 - Streamlined mappings: _ :: connector Project fold :: {_| (group[_ discipline [-1]] ?= []) push (_)}

 - Filter VALUE :<: PREDICATE
 - Map    VALUE :=: EXTRACTOR
 - Reduce VALUE :|: EXTRACTOR

- Time units 10s 10ms 10m 10h, etc

 - Infix functions @infix @function fold XXXX fold XXXX -> fold (XXX,XXX)
 - list comprehensions: [x * 2 for x in COLLECTION if CONDITION]
 - generators

Language Features:

  - Support overloading based on type
  - Add standard library
  - '@special' support for specila operations
  - Multile-line strings/embedding of raw content
  - Passing named arguments
  - Casting
    >	((List)asas) length()

  - More operations for if:
    >	if self._views.main is undefined:
    >		return
    >	end
    >	==, !=, <=, >=, <, >, "and", "or", "is", "not"
							
	with  (value | assignation | declaration)
		DotValue *
	end

String interpolation

	"{0:d} {1:d}" (uses the local scope)

	"{0:d} {1:d}" % {dict}

Hex/Bit notation:

	0xFF
	0b011010101

Bit-logic operator
	
	&&
	||
	!

Infix operator:

	e ~map extractor 

	would be rewritten as

	map (e, extractor)

Automatic variables

	_  == arguments[0]
	_0 == arguments[0]
	_1 == arguments[1]
	_2 == arguments[2]

Like operation
	
	v like (_, _, _)

	like takes a structural expression that will tell if the left-hand value
	is "like" the right hand value

Select/match:

	match value as f
		case 1.0
			code
		case f like (_, _, _)
			code
		else
			code
	
Use map/filter/... operators:

		# TODO: Could be re-expressed with lambdas with implicit parameters and operators
		# ::=  map
		# ::<  filter
		# ::|  reduce
		# in   find
		# len(selection) != len(previous_selection) or len(selection ::= _ in previous_selection ::< {_ == -1})required 

Assert/pre/post/error

	@pre  expresssion error message
	@post expression  error message
	assert expression error message

Dictionary setdefault/assign if not null

	a[1] ?= 1.0
	
	equals to

	if not isDefined(a[1]) -> a[1] = 1.0


Support continue/break

	for a,b in 0..10
		if a == 5
			continue
		elif a > 7
			break
		end
	end

Support generators (that might not be easy)

	var f = {
		for a in 0..100
			yield a
		end
	}



Add special variables

	__scope_name__ (ex: widgets.Widget.ensure)
	__scope__ 

	__module__
	__module_name__

	__class__
	__class_name__

	__method__
	__method_name__

	__function__
	__function_name__

	__class__
	__class_name__

	__line__
	__file__


	and so in code


	error ("{__scope_name__:__line}: Error message")

Support @singleton

Add chaining:

	value:
		a ()
		b ()
	
	is equal to

	value a ()
	value b ()

	and you can also affect that

	var r = value:
		a ()
		b ()

	and chain it

	var r = value:
		a ()
		b () :
			c ()
	
	which equals to

	var _ = value () a () b ()
	var r = _ c ()

Add default/named arguments:
	
	@function i a=0, b=1, c=2
	@end

	@function i a, b, rest...
	@end

	@function i a, b, rest..., options=...
	@end


	@function i a, b, rest..., options=...
	@end

Implicit return

	{_| _ + 1}
Macros:

>	@macro name( a, b, c )
>		$a = pouet
>		$b = pouet
>		$c = pouet
>	@end
>	
>	@function f
>		@name(a,b,c)
>	@end
>	
>	will produce the code $a, $b, $c
>	
>	@function f
>		a = pouet
>		b = pouet
>		c = pouet
>	@end