Fetching contributors…
Cannot retrieve contributors at this time
219 lines (176 sloc) 7.09 KB
+ Alias of v0.2.23
+ v0.2.23 had enough changes to warrant a big version number bump
+ Wooe, so many improvements I can't even list them all.
+ Awesome dev environment! Automatically sync UI with file on every save.
+ Allow for keywords to be XML attribute names
+ Add --normalize.css=false and minify=true commandline options
+ text module with text.trim
+ Implement != and ! comparative operators
+ Rename filter module to list, and make it list.filter
+ Hash-expand xml attributes a la <div #{ class:'clickable', onclick:handler() { ... }} />
+ New tap modules
+ Back to using npm node modules instead of git...
+ Add support for automatic less preprocessing of <link ref="stylesheet/less" ... /> elements
+ Add support for stylus
+ Automatically detect that less or stylus is required, and install them dynamically at runtime if needed
+ Handler event arguments are now cancelable
+ Allow for commas between XML attributes, e.g. <div foo="bar", cat="qwe"/>
+ Remove need for `let` in front of declarations. Now it's just `foo = "bar"`
+ Disabled minification for now
+ Add -v/--version flags
+ Allow for `foo is "image"` as a shorthand for `foo is = "image"`
+ Inline all stylesheets with static hrefs as a <style> tag in the header
+ Minify the CSS of inlined style tags using clean-css
+ Variable declarations require a value (let foo is no longer valid, must to let foo = null)
+ implement json module
+ add an instagram example app
+ add access to npm node_modules with the require() statement in inline javascript code
+ implement xhr module
+ Fix broken v0.2.15 build
+ Use `let` instead of `var` for variable declarations
+ allow for comma-seperated declarations (e.g. let foo = 1, bar = 2)
+ new mutation statement syntax - instead of, you say set: 2
+ inline statically referenced stylesheets
+ remove parentheseses around the conditinoal of if, for and switch statements.
+ test new packaging system
+ handler and function code now runs procedurally. Only template code is reactive and functional. However, functions are still truly functional (no side effects).
+ control flow statements parse and compile correctly in templates, handler and functions.
+ todomvc example app fully functional:
+ lots and lots of other improvements :)
+ Unit tests for parser, resolver, compiler and runtime library
+ Proper JS bridge: <script jsVar=funVar> ... jsVar.set(...) </script>
+ Mouse module
+ Styles with dynamic values: <div id="output1" style={ background:'red', width:100, height:100, position:"absolute", top:Mouse.y, left:Mouse.x }/>
+ Object literal emission
+ Variables are now dynamically typed, and expression type-evaluated at runtime
+ npm install works again
+ Fix parsing of empty XML tags
+ Add parser and resolver test cases for XML
+ examples/ works again :)
+ operator presedence in parser
+ parser unit tests for if statements, composite expressions, and operator presedence
+ use latest fin
+ use latest std
+ first resolver tests
+ first compiler tests
+ moved all js files into /lib
+ Parser improvements
+ Local expressions are now Local item properties, e.g. let name = "marcus" name.set("marcus westin")
+ Unit testing using nodeunit - a bunch of test cases added for the parser!
+ File cleanup
+ Upgrade to fin v0.2.11
+ Fix if/else statement parsing
+ Publish fun with npm
+ Significantly improved parsing
+ Use latest fin
+ First versioned version of fun. Lots of stuff works, lots of stuff is hacky, lots of stuff to be done.
TODOs and Roadmap
Get involved - complete a task :)
All expressions should have type:EXPRESSION | INVOCATION | COMPOSITE - each expression should also have a valueType. An alias has the type of what its aliasing. An invocable's signature's argument has the type of what is passed in. A composite has the type of its left operand(?).
Fix prefixes.
work, but
for (number in [1,2,3]) { displayNumber(-number) }
does not, nor does
- Add valueType to each AST with a value
- Make derive global.messages and message.text from the declared classes rather than syntactically
- Add enum type?
enum State {
1 happiness
2 sadness
3 giddiness
let aState = new State(1)
switch(aState) {
case State.happiness:
case State.sadness:
<button>"switch state"</button onclick=handler() { aState.set(State.sadness) }>
- "Write apps"
1) write an app
2) write another one
3) tell the world about them
- "Template arguments"
1) Pass in arguments to template invocations
X let aTemplate = template(item) { "Hello " }
X let anotherTemplate = template(name) { "Hello " name }
- "Handler arguments"
1) Pass in arguments to handler invocations
let removeFriend = handler(user, friend) {
for (friend in user.friends) {
<button>"remove"</button onclick=removeFriend(user, friend)>
- ""
X 1) just put something up there
2) run server in browser for demos
3) in-browser editor for demos
4) list engines
5) technical docs
6) add just-compile option to fun, so that you can get a static version of webpages that don't use the Global keyword
- "Custom events"
1) allow for custom events other than XML elements' "on*" events, e.g.
App.onLoad = handler() { ... }
// or
App.onLoad(handler() { ... })
// or
App.onLoad.add(handler() { ... })
2) Implement some, e.g
Global.onConnect = handler() { ... }
Global.onDisconnect = handler() { ... }
- Allow for unary operators !, -, + at the beginning of conditional composite statements
- "Type checking"
X 1) Tags with data should have the dataType attribute <input data=Local.x dataType="number" />
2) Tags should have custom implementations, that declare what types of data they accept
3) The data should infer its type of the dataType attribute, and should default to "text"
4) Template and handler arguments need to have a type associated with them
5) MIGRATE all type checking from the parser to the resolver. Right now the parser is selective about what type of
value can be where. The resolver should do all of that checking.
- "List/Range literals (and list comprehensions?)"
See examples/
1) Implement list literals (e.g. for (number in [1,2,3]) { ... })
2) Implement ranges (e.g. for (number in [1..10]) { ... })
3) Investigate list comprehension - are they useful for fun?
- "Fun Engines"
1) separate out the persistence and the storage engines from each other
2) a mysqpl persistence engine
3) a 0mq pubsub engine
4) a couchdb persistence engine
5) a couchdb pubsub engine (changes api)
- "Type-safe item creation"
1) Whenever an item gets created, ensure that all item properties that are used elsewhere
are properly initialized, and that no properties that are not used are initialized
- "Relative file imports"
file imports are relative to the process directory but should be relative to the file's directory