This section describes the conventions used here to describe type signatures.
A [T] is an array-like value (only ever used read-only in this API), i.e., one with an integer length and whose indexed properties from 0 to length - 1 are of type T.
A type T? should be read as T | undefined -- that is, an optional value that may be undefined.
This section describes the conventions used here to describe type signatures.
A [T] is an array-like value (only ever used read-only in this API), i.e., one with an integer length and whose indexed properties from 0 to length - 1 are of type T.
A type T? should be read as T | undefined -- that is, an optional value that may be undefined.
I struggle with this question from time to time.
Lots of tools compile to JS, not just compilers for other languages but also JS language extensions and instrumentation. In those cases you want to minimally perturb the semantics of JS. Direct eval is the hard part I struggle with.
Let's assume for the moment you have some global variable $RT you can access to get to the compiler's runtime. There are tricky bits to this, but let's just take it as given.
When you see an apparent direct eval in the source program, of the form eval(EXPR), you might translate to something like:
($RT.tmpEval = eval, $RT.tmpArg = EXPR, $RT.directEval((eval) => eval($RT.tmpArg)))
| function! SyntaxCheckers_chef_IsAvailable() | |
| return executable('foodcritic') | |
| endfunction | |
| function! SyntaxCheckers_chef_GetLocList() | |
| " let exe = expand(g:syntastic_ruby_exec) | |
| " if !has('win32') | |
| " let exe = 'RUBYOPT= ' . exe | |
| " endif |
(tl;dr DOM builders like [domo][domo] trump HTML templates on the client.)
Like all web developers, I've used a lot of template engines. Like most, I've also written a few of them, some of which even [fit in a tweet][140].
The first open-source code I ever wrote was also one of the the first template engines for node.js, [a port][node-tmpl] of the mother of all JavaScript template engines, [John Resig][jresig]'s [micro-templates][tmpl]. Of course, these days you can't swing a dead cat without hitting a template engine; one in eight packages on npm ([2,220][npm templates] of 16,226 as of 10/19) involve templates.
John's implementation has since evolved and [lives on in Underscore.js][underscore], which means it's the default choice for templating in Backbone.js. And for a while, it's all I would ever use when building a client-side app.
But I can't really see the value in client-side HTML templates anymore.
This article has been given a more permanent home on my blog. Also, since it was first written, the development of the Promises/A+ specification has made the original emphasis on Promises/A seem somewhat outdated.
Promises are a software abstraction that makes working with asynchronous operations much more pleasant. In the most basic definition, your code will move from continuation-passing style:
getTweetsFor("domenic", function (err, results) {
// the rest of your code goes here.| function ContactCtrl($scope, $http) { | |
| $scope.success = false; | |
| $scope.httpError = false; | |
| $scope.send = function() { | |
| var job = { job: { klass: 'msg', args: [$scope.msg]}}; | |
| $http.post('/contact',job). | |
| success(function(data){ | |
| $scope.success = true; | |
| $scope.msg = {}; |
| import SimpleHTTPServer | |
| class CORSHTTPRequestHandler(SimpleHTTPServer.SimpleHTTPRequestHandler): | |
| def send_head(self): | |
| """Common code for GET and HEAD commands. | |
| This sends the response code and MIME headers. | |
| Return value is either a file object (which has to be copied | |
| to the outputfile by the caller unless the command was HEAD, | |
| and must be closed by the caller under all circumstances), or |
