azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fixed up readme to link to the example template implementations

Browse Source
This commit is contained in:
James Strachan
2012-03-13 12:22:56 +00:00
parent 8d47332cd9
commit e007ce8c62
1 changed files with 7 additions and 2 deletions
Download Patch File Download Diff File Expand all files Collapse all files
libraries/stdlib/src/kotlin/template/ReadMe.md
+7 -2
View File
@@ -21,13 +21,15 @@ suitability, code size, complexity and efficiency.
Here we convert a string template into a function on some kind of builder object where we invoke the text() method for static text and expression() for dynamic expressions Here we convert a string template into a function on some kind of builder object where we invoke the text() method for static text and expression() for dynamic expressions
* [example](https://github.com/JetBrains/kotlin/blob/master/libraries/testlib/test/template/experiment1/HtmlTemplateTest.kt#L17)
Pro: Pro:
* simple and efficient code is generated - no arrays * simple and efficient code is generated - no arrays
* no arrays are created for static and expression arguments * no arrays are created for static and expression arguments
* static dispatch of encoding functions; no runtime instanceof checks on each argument * static dispatch of encoding functions; no runtime instanceof checks on each argument
* Cons: Cons:
* function may create an inner object/class (though the compiler may get smart enough to inline some of those - or maybe generate a custom function for the whole thing with parameters?) * function may create an inner object/class (though the compiler may get smart enough to inline some of those - or maybe generate a custom function for the whole thing with parameters?)
* we can only use this strategy if the template expression is passed to a function and we can detect the function parameter takes a fn: (T) -> Unit; and T has suitable text() and expression() methods. * we can only use this strategy if the template expression is passed to a function and we can detect the function parameter takes a fn: (T) -> Unit; and T has suitable text() and expression() methods.
@@ -37,6 +39,8 @@ Pro:
Here we create a single StringTemplate object containing the constant text array and the values array. Then we use functions or extension functions as ways to do other things. Here we create a single StringTemplate object containing the constant text array and the values array. Then we use functions or extension functions as ways to do other things.
* [example](https://github.com/JetBrains/kotlin/blob/master/libraries/testlib/test/template/experiment2/HtmlTemplateTest.kt#L13)
Pros: Pros:
* really simple * really simple
@@ -44,9 +48,10 @@ Pros:
Cons: Cons:
* requires runtime instanceof checks on each expression value * requires runtime [instanceof checks](https://github.com/JetBrains/kotlin/blob/master/libraries/stdlib/src/kotlin/template/experiment2/Templates.kt#L66) on each expression value
* fair bit of object construction per call (2 arrays, a template object, then the string builder and lots of index lookup of arrays * fair bit of object construction per call (2 arrays, a template object, then the string builder and lots of index lookup of arrays
#### experiment 3 #### experiment 3
The idea is we create a FooTemplate object with the static constant strings inside; so we can easily cache the immutable stuff on startup. Then we basically use pseudo code like The idea is we create a FooTemplate object with the static constant strings inside; so we can easily cache the immutable stuff on startup. Then we basically use pseudo code like