Lua is an extension programming language designed to support general procedural programming with data description facilities. It also offers good support for object-oriented programming, functional programming, and data-driven programming. Lua is intended to be used as a powerful, light-weight scripting language for any program that needs one. Lua is implemented as a library, written in clean C (that is, in the common subset of ANSI C and C++).
Being an extension language, Lua has no notion of a "main" program: it only works embedded in a host client, called the embedding program or simply the host. This host program can invoke functions to execute a piece of Lua code, can write and read Lua variables, and can register C functions to be called by Lua code. Through the use of C functions, Lua can be augmented to cope with a wide range of different domains, thus creating customized programming languages sharing a syntactical framework. The Lua distribution includes a sample host program called lua
, which uses the Lua library to offer a complete, stand-alone Lua interpreter.
Lua is free software, and is provided as usual with no guarantees, as stated in its license. The implementation described in this manual is available at Lua's official web site, www.lua.org
.
Like any other reference manual, this document is dry in places. For a discussion of the decisions behind the design of Lua, see the technical papers available at Lua's web site. For a detailed introduction to programming in Lua, see Roberto's book, Programming in Lua (Second Edition).
This section describes the lexis, the syntax, and the semantics of Lua. In other words, this section describes which tokens are valid, how they can be combined, and what their combinations mean.
The language constructs will be explained using the usual extended BNF notation, in which {a} means 0 or more a's, and [a] means an optional a. Non-terminals are shown like non-terminal, keywords are shown like kword, and other terminal symbols are shown like `=´. The complete syntax of Lua can be found at the end of this manual.
Names (also called identifiers) in Lua can be any string of letters, digits, and underscores, not beginning with a digit. This coincides with the definition of names in most languages. (The definition of letter depends on the current locale: any character considered alphabetic by the current locale can be used in an identifier.) Identifiers are used to name variables and table fields.
The following keywords are reserved and cannot be used as names:
and break do else elseif end false for function if in local nil not or repeat return then true until while
Lua is a case-sensitive language: and
is a reserved word, but And
and AND
are two different, valid names. As a convention, names starting with an underscore followed by uppercase letters (such as _VERSION
) are reserved for internal global variables used by Lua.
The following strings denote other tokens:
+ - * / % ^ # == ~= <= >= < > = ( ) { } [ ] ; : , . .. ...
Literal strings can be delimited by matching single or double quotes, and can contain the following C-like escape sequences: '\a
' (bell), '\b
' (backspace), '\f
' (form feed), '\n
' (newline), '\r
' (carriage return), '\t
' (horizontal tab), '\v
' (vertical tab), '\\
' (backslash), '\"
' (quotation mark [double quote]), and '\'
' (apostrophe [single quote]). Moreover, a backslash followed by a real newline results in a newline in the string. A character in a string may also be specified by its numerical value using the escape sequence
\ddd
, where ddd is a sequence of up to three decimal digits. (Note that if a numerical escape is to be followed by a digit, it must be expressed using exactly three digits.) Strings in Lua may contain any 8-bit value, including embedded zeros, which can be specified as '\0
'.
To put a double (single) quote, a newline, a backslash, a carriage return, or an embedded zero inside a literal string enclosed by double (single) quotes you must use an escape sequence. Any other character may be directly inserted into the literal. (Some control characters may cause problems for the file system, but Lua has no problem with them.)
Literal strings can also be defined using a long format enclosed by long brackets. We define an
opening long bracket of level n
as an opening square bracket followed by n equal signs followed by another opening square bracket. So, an opening long bracket of level 0 is written as [[
, an opening long bracket of level 1 is written as [=[
, and so on. A closing long bracket is defined similarly; for instance, a closing long bracket of level 4 is written as ]====]
. A long string starts with an opening long bracket of any level and ends at the first closing long bracket of the same level. Literals in this bracketed form may run for several lines, do not interpret any escape sequences, and ignore long brackets of any other level. They may contain anything except a closing bracket of the proper level.
For convenience, when the opening long bracket is immediately followed by a newline, the newline is not included in the string. As an example, in a system using ASCII (in which 'a
' is coded as 97, newline is coded as 10, and '1
' is coded as 49), the five literals below denote the same string:
a = 'alo\n123"' a = "alo\n123\"" a = '\97lo\10\04923"' a = [[alo 123"]] a = [==[ alo 123"]==]
A numerical constant may be written with an optional decimal part and an optional decimal exponent. Lua also accepts integer hexadecimal constants, by prefixing them with 0x
. Examples of valid numerical constants are
3 3.0 3.1416 314.16e-2 0.31416E1 0xff 0x56
A comment starts with a double hyphen (--
) anywhere outside a string. If the text immediately after --
is not an opening long bracket, the comment is a short comment, which runs until the end of the line. Otherwise, it is a long comment, which runs until the corresponding closing long bracket. Long comments are frequently used to disable code temporarily.
Lua is a dynamically typed language. This means that variables do not have types; only values do. There are no type definitions in the language. All values carry their own type.
All values in Lua are first-class values. This means that all values can be stored in variables, passed as arguments to other functions, and returned as results.
There are eight basic types in Lua: nil, boolean, number, string, function, userdata, thread, and table. Nil is the type of the value nil, whose main property is to be different from any other value; it usually represents the absence of a useful value. Boolean is the type of the values false and true. Both nil and false make a condition false; any other value makes it true. Number represents real (double-precision floating-point) numbers. (It is easy to build Lua interpreters that use other internal representations for numbers, such as single-precision float or long integers; see file luaconf.h
.) String represents arrays of characters. Lua is 8-bit clean: strings may contain any 8-bit character, including embedded zeros ('\0
') (see §2.1).
Lua can call (and manipulate) functions written in Lua and functions written in C (see §2.5.8).
The type userdata is provided to allow arbitrary C data to be stored in Lua variables. This type corresponds to a block of raw memory and has no pre-defined operations in Lua, except assignment and identity test. However, by using metatables, the programmer can define operations for userdata values (see §2.8). Userdata values cannot be created or modified in Lua, only through the C API. This guarantees the integrity of data owned by the host program.
The type thread represents independent threads of execution and it is used to implement coroutines (see §2.11). Do not confuse Lua threads with operating-system threads. Lua supports coroutines on all systems, even those that do not support threads.
The type table implements associative arrays, that is, arrays that can be indexed not only with numbers, but with any value (except nil). Tables can be heterogeneous; that is, they can contain values of all types (except nil). Tables are the sole data structuring mechanism in Lua; they may be used to represent ordinary arrays, symbol tables, sets, records, graphs, trees, etc. To represent records, Lua uses the field name as an index. The language supports this representation by providing a.name
as syntactic sugar for a["name"]
. There are several convenient ways to create tables in Lua (see §2.5.7).
Like indices, the value of a table field can be of any type (except nil). In particular, because functions are first-class values, table fields may contain functions. Thus tables may also carry methods (see §2.5.9).
Tables, functions, threads, and (full) userdata values are objects: variables do not actually contain these values, only references to them. Assignment, parameter passing, and function returns always manipulate references to such values; these operations do not imply any kind of copy.
The library function
type
returns a string describing the type of a given value.
Lua provides automatic conversion between string and number values at run time. Any arithmetic operation applied to a string tries to convert this string to a number, following the usual conversion rules. Conversely, whenever a number is used where a string is expected, the number is converted to a string, in a reasonable format. For complete control over how numbers are converted to strings, use the format
function from the string library (see
string.format
).
Variables are places that store values. There are three kinds of variables in Lua: global variables, local variables, and table fields.
A single name can denote a global variable or a local variable (or a function's formal parameter, which is a particular kind of local variable):
var ::= Name
Name denotes identifiers, as defined in §2.1.
Any variable is assumed to be global unless explicitly declared as a local (see §2.4.7). Local variables are lexically scoped: local variables can be freely accessed by functions defined inside their scope (see §2.6).
Before the first assignment to a variable, its value is nil.
Square brackets are used to index a table:
var ::= prefixexp `[´ exp `]´
The meaning of accesses to global variables and table fields can be changed via metatables. An access to an indexed variable t[i]
is equivalent to a call gettable_event(t,i)
. (See §2.8 for a complete description of the gettable_event
function. This function is not defined or callable in Lua. We use it here only for explanatory purposes.)
The syntax var.Name
is just syntactic sugar for var["Name"]
:
var ::= prefixexp `.´ Name
All global variables live as fields in ordinary Lua tables, called environment tables or simply environments (see §2.9). Each function has its own reference to an environment, so that all global variables in this function will refer to this environment table. When a function is created, it inherits the environment from the function that created it. To get the environment table of a Lua function, you call
getfenv
. To replace it, you call
setfenv
. (You can only manipulate the environment of C functions through the debug library; (see §5.9).)
An access to a global variable x
is equivalent to _env.x
, which in turn is equivalent to
gettable_event(_env, "x")
where _env
is the environment of the running function. (See §2.8 for a complete description of the gettable_event
function. This function is not defined or callable in Lua. Similarly, the _env
variable is not defined in Lua. We use them here only for explanatory purposes.)
Lua supports an almost conventional set of statements, similar to those in Pascal or C. This set includes assignment, control structures, function calls, and variable declarations.
The unit of execution of Lua is called a chunk. A chunk is simply a sequence of statements, which are executed sequentially. Each statement can be optionally followed by a semicolon:
chunk ::= {stat [`;´]}
There are no empty statements and thus ';;
' is not legal.
Lua handles a chunk as the body of an anonymous function with a variable number of arguments (see §2.5.9). As such, chunks can define local variables, receive arguments, and return values.
A chunk may be stored in a file or in a string inside the host program. When a chunk is executed, first it is pre-compiled into instructions for a virtual machine, and then the compiled code is executed by an interpreter for the virtual machine.
Chunks may also be pre-compiled into binary form; see program luac
for details. Programs in source and compiled forms are interchangeable; Lua automatically detects the file type and acts accordingly.
A block is a list of statements; syntactically, a block is the same as a chunk:
block ::= chunk
A block may be explicitly delimited to produce a single statement:
stat ::= do block end
Explicit blocks are useful to control the scope of variable declarations. Explicit blocks are also sometimes used to add a return or break statement in the middle of another block (see §2.4.4).
Lua allows multiple assignment. Therefore, the syntax for assignment defines a list of variables on the left side and a list of expressions on the right side. The elements in both lists are separated by commas:
stat ::= varlist `=´ explist varlist ::= var {`,´ var} explist ::= exp {`,´ exp}
Expressions are discussed in §2.5.
Before the assignment, the list of values is adjusted to the length of the list of variables. If there are more values than needed, the excess values are thrown away. If there are fewer values than needed, the list is extended with as many nil's as needed. If the list of expressions ends with a function call, then all values returned by this call enter in the list of values, before the adjustment (except when the call is enclosed in parentheses; see §2.5).
The assignment statement first evaluates all its expressions and only then are the assignments performed. Thus the code
i = 3 i, a[i] = i+1, 20
sets a[3]
to 20, without affecting a[4]
because the i
in a[i]
is evaluated (to 3) before it is assigned 4. Similarly, the line
x, y = y, x
exchanges the values of x
and y
.
The meaning of assignments to global variables and table fields can be changed via metatables. An assignment to an indexed variable t[i] = val
is equivalent to settable_event(t,i,val)
. (See §2.8 for a complete description of the settable_event
function. This function is not defined or callable in Lua. We use it here only for explanatory purposes.)
An assignment to a global variable x = val
is equivalent to the assignment _env.x = val
, which in turn is equivalent to
settable_event(_env, "x", val)
where _env
is the environment of the running function. (The _env
variable is not defined in Lua. We use it here only for explanatory purposes.)
The control structures if, while, and repeat have the usual meaning and familiar syntax:
stat ::= while exp do block end stat ::= repeat block until exp stat ::= if exp then block {elseif exp then block} [else block] end
Lua also has a for statement, in two flavors (see §2.4.5).
The condition expression of a control structure may return any value. Both false and nil are considered false. All values different from nil and false are considered true (in particular, the number 0 and the empty string are also true).
In the repeat-until loop, the inner block does not end at the until keyword, but only after the condition. So, the condition can refer to local variables declared inside the loop block.
The return statement is used to return values from a function or a chunk (which is just a function). Functions and chunks may return more than one value, so the syntax for the return statement is
stat ::= return [explist]
The break statement is used to terminate the execution of a while, repeat, or for loop, skipping to the next statement after the loop:
stat ::= break
A break ends the innermost enclosing loop.
The return and break statements can only be written as the last statement of a block. If it is really necessary to return or break in the middle of a block, then an explicit inner block can be used, as in the idioms do return end
and do break end
, because now return and break are the last statements in their (inner) blocks.
The for statement has two forms: one numeric and one generic.
The numeric for loop repeats a block of code while a control variable runs through an arithmetic progression. It has the following syntax:
stat ::= for Name `=´ exp `,´ exp [`,´ exp] do block end
The block is repeated for name starting at the value of the first exp, until it passes the second exp by steps of the third exp. More precisely, a for statement like
for v = e1, e2, e3 do block end
is equivalent to the code:
do local var, limit, step = tonumber(e1), tonumber(e2), tonumber(e3) if not (var and limit and step) then error() end while (step > 0 and var <= limit) or (step <= 0 and var >= limit) do local v = var block var = var + step end end
Note the following:
var
,
limit
, and
step
are invisible variables. The names are here for explanatory purposes only.
v
is local to the loop; you cannot use its value after the for ends or is broken. If you need this value, assign it to another variable before breaking or exiting the loop.
The generic for statement works over functions, called iterators. On each iteration, the iterator function is called to produce a new value, stopping when this new value is nil. The generic for loop has the following syntax:
stat ::= for namelist in explist do block end namelist ::= Name {`,´ Name}
A for statement like
for var_1, ···, var_n in explist do block end
is equivalent to the code:
do local f, s, var = explist while true do local var_1, ···, var_n = f(s, var) var = var_1 if var == nil then break end block end end
Note the following:
explist
is evaluated only once.  The names are here for explanatory purposes only.
var_i
are local to the loop; you cannot use their values after the for ends. If you need these values, then assign them to other variables before breaking or exiting the loop.
To allow possible side-effects, function calls can be executed as statements:
stat ::= functioncall
In this case, all returned values are thrown away. Function calls are explained in §2.5.8.
Local variables may be declared anywhere inside a block. The declaration may include an initial assignment:
stat ::= local namelist [`=´ explist]
If present, an initial assignment has the same semantics of a multiple assignment (see §2.4.3). Otherwise, all variables are initialized with nil.
A chunk is also a block (see §2.4.1), and so local variables can be declared in a chunk outside any explicit block. The scope of such local variables extends until the end of the chunk.
The visibility rules for local variables are explained in §2.6.
The basic expressions in Lua are the following:
exp ::= prefixexp exp ::= nil | false | true exp ::= Number exp ::= String exp ::= function exp ::= tableconstructor exp ::= `...´ exp ::= exp binop exp exp ::= unop exp prefixexp ::= var | functioncall | `(´ exp `)´
Numbers and literal strings are explained in §2.1; variables are explained in §2.3; function definitions are explained in §2.5.9; function calls are explained in §2.5.8; table constructors are explained in §2.5.7. Vararg expressions, denoted by three dots ('...
'), can only be used when directly inside a vararg function; they are explained in §2.5.9.
Binary operators comprise arithmetic operators (see §2.5.1), relational operators (see §2.5.2), logical operators (see §2.5.3), and the concatenation operator (see §2.5.4). Unary operators comprise the unary minus (see §2.5.1), the unary not (see §2.5.3), and the unary length operator (see §2.5.5).
Both function calls and vararg expressions may result in multiple values. If the expression is used as a statement (see §2.4.6) (only possible for function calls), then its return list is adjusted to zero elements, thus discarding all returned values. If the expression is used as the last (or the only) element of a list of expressions, then no adjustment is made (unless the call is enclosed in parentheses). In all other contexts, Lua adjusts the result list to one element, discarding all values except the first one.
Here are some examples:
f() -- adjusted to 0 results g(f(), x) -- f() is adjusted to 1 result g(x, f()) -- g gets x plus all results from f() a,b,c = f(), x -- f() is adjusted to 1 result (c gets nil) a,b = ... -- a gets the first vararg parameter, b gets -- the second (both a and b may get nil if there -- is no corresponding vararg parameter) a,b,c = x, f() -- f() is adjusted to 2 results a,b,c = f() -- f() is adjusted to 3 results return f() -- returns all results from f() return ... -- returns all received vararg parameters return x,y,f() -- returns x, y, and all results from f() {f()} -- creates a list with all results from f() {...} -- creates a list with all vararg parameters {f(), nil} -- f() is adjusted to 1 result
An expression enclosed in parentheses always results in only one value. Thus, (f(x,y,z))
is always a single value, even if f
returns several values. (The value of (f(x,y,z))
is the first value returned by f
or nil if f
does not return any values.)
Lua supports the usual arithmetic operators: the binary +
(addition), -
(subtraction), *
(multiplication), /
(division), %
(modulo), and ^
(exponentiation); and unary -
(negation). If the operands are numbers, or strings that can be converted to numbers (see §2.2.1), then all operations have the usual meaning. Exponentiation works for any exponent. For instance, x^(-0.5)
computes the inverse of the square root of x
. Modulo is defined as
a % b == a - math.floor(a/b)*b
That is, it is the remainder of a division that rounds the quotient towards minus infinity.
The relational operators in Lua are
== ~= < > <= >=
These operators always result in false or true.
Equality (==
) first compares the type of its operands. If the types are different, then the result is false. Otherwise, the values of the operands are compared. Numbers and strings are compared in the usual way. Objects (tables, userdata, threads, and functions) are compared by reference: two objects are considered equal only if they are the same object. Every time you create a new object (a table, userdata, thread, or function), this new object is different from any previously existing object.
You can change the way that Lua compares tables and userdata by using the "eq" metamethod (see §2.8).
The conversion rules of §2.2.1 do not apply to equality comparisons. Thus, "0"==0
evaluates to false, and t[0]
and t["0"]
denote different entries in a table.
The operator ~=
is exactly the negation of equality (==
).
The order operators work as follows. If both arguments are numbers, then they are compared as such. Otherwise, if both arguments are strings, then their values are compared according to the current locale. Otherwise, Lua tries to call the "lt" or the "le" metamethod (see §2.8).
The logical operators in Lua are and, or, and not. Like the control structures (see §2.4.4), all logical operators consider both false and nil as false and anything else as true.
The negation operator not always returns false or true. The conjunction operator and returns its first argument if this value is false or nil; otherwise, and returns its second argument. The disjunction operator or returns its first argument if this value is different from nil and false; otherwise, or returns its second argument. Both and and or use short-cut evaluation; that is, the second operand is evaluated only if necessary. Here are some examples:
10 or 20 --> 10 10 or error() --> 10 nil or "a" --> "a" nil and 10 --> nil false and error() --> false false and nil --> false false or nil --> nil 10 and 20 --> 20
(In this manual, --> indicates the result of the preceding expression.)
The string concatenation operator in Lua is denoted by two dots ('..
'). If both operands are strings or numbers, then they are converted to strings according to the rules mentioned in §2.2.1. Otherwise, the "concat" metamethod is called (see §2.8).
The length operator is denoted by the unary operator #
. The length of a string is its number of bytes (that is, the usual meaning of string length when each character is one byte).
The length of a table t
is defined to be any integer index n
such that t[n]
is not nil and t[n+1]
is nil; moreover, if t[1]
is nil, n
may be zero. For a regular array, with non-nil values from 1 to a given n
, its length is exactly that n
, the index of its last value. If the array has "holes" (that is, nil values between other non-nil values), then #t
may be any of the indices that directly precedes a nil value (that is, it may consider any such nil value as the end of the array).
Operator precedence in Lua follows the table below, from lower to higher priority:
or and < > <= >= ~= == .. + - * / % not # - (unary) ^
As usual, you can use parentheses to change the precedences of an expression. The concatenation ('..
') and exponentiation ('^
') operators are right associative. All other binary operators are left associative.
Table constructors are expressions that create tables. Every time a constructor is evaluated, a new table is created. Constructors can be used to create empty tables, or to create a table and initialize some of its fields. The general syntax for constructors is
tableconstructor ::= `{´ [fieldlist] `}´ fieldlist ::= field {fieldsep field} [fieldsep] field ::= `[´ exp `]´ `=´ exp | Name `=´ exp | exp fieldsep ::= `,´ | `;´
Each field of the form [exp1] = exp2
adds to the new table an entry with key exp1
and value exp2
. A field of the form name = exp
is equivalent to ["name"] = exp
. Finally, fields of the form exp
are equivalent to [i] = exp
, where i
are consecutive numerical integers, starting with 1. Fields in the other formats do not affect this counting. For example,
a = { [f(1)] = g; "x", "y"; x = 1, f(x), [30] = 23; 45 }
is equivalent to
do local t = {} t[f(1)] = g t[1] = "x" -- 1st exp t[2] = "y" -- 2nd exp t.x = 1 -- t["x"] = 1 t[3] = f(x) -- 3rd exp t[30] = 23 t[4] = 45 -- 4th exp a = t end
If the last field in the list has the form exp
and the expression is a function call or a vararg expression, then all values returned by this expression enter the list consecutively (see §2.5.8). To avoid this, enclose the function call (or the vararg expression) in parentheses (see §2.5).
The field list may have an optional trailing separator, as a convenience for machine-generated code.
A function call in Lua has the following syntax:
functioncall ::= prefixexp args
In a function call, first prefixexp and args are evaluated. If the value of prefixexp has type function, then this function is called with the given arguments. Otherwise, the prefixexp "call" metamethod is called, having as first parameter the value of prefixexp, followed by the original call arguments (see §2.8).
The form
functioncall ::= prefixexp `:´ Name args
can be used to call "methods". A call
v:name(args)
is syntactic sugar for
v.name(v,args)
, except that v
is evaluated only once.
Arguments have the following syntax:
args ::= `(´ [explist] `)´ args ::= tableconstructor args ::= String
All argument expressions are evaluated before the call. A call of the form
f{fields}
is syntactic sugar for
f({fields})
; that is, the argument list is a single new table. A call of the form
f'string'
(or
f"string"
or
f[[string]]
) is syntactic sugar for
f('string')
; that is, the argument list is a single literal string.
As an exception to the free-format syntax of Lua, you cannot put a line break before the '(
' in a function call. This restriction avoids some ambiguities in the language. If you write
a = f (g).x(a)
Lua would see that as a single statement, a = f(g).x(a)
. So, if you want two statements, you must add a semi-colon between them. If you actually want to call f
, you must remove the line break before (g)
.
A call of the form return
functioncall is called a tail call. Lua implements proper tail calls (or proper tail recursion): in a tail call, the called function reuses the stack entry of the calling function. Therefore, there is no limit on the number of nested tail calls that a program can execute. However, a tail call erases any debug information about the calling function. Note that a tail call only happens with a particular syntax, where the return has one single function call as argument; this syntax makes the calling function return exactly the returns of the called function. So, none of the following examples are tail calls:
return (f(x)) -- results adjusted to 1 return 2 * f(x) return x, f(x) -- additional results f(x); return -- results discarded return x or f(x) -- results adjusted to 1
The syntax for function definition is
function ::= function funcbody funcbody ::= `(´ [parlist] `)´ block end
The following syntactic sugar simplifies function definitions:
stat ::= function funcname funcbody stat ::= local function Name funcbody funcname ::= Name {`.´ Name} [`:´ Name]
The statement
function f () body end
translates to
f = function () body end
The statement
function t.a.b.c.f () body end
translates to
t.a.b.c.f = function () body end
The statement
local function f () body end
translates to
local f; f = function () body end
not to
local f = function () body end
(This only makes a difference when the body of the function contains references to f
.)
A function definition is an executable expression, whose value has type function. When Lua pre-compiles a chunk, all its function bodies are pre-compiled too. Then, whenever Lua executes the function definition, the function is instantiated (or closed). This function instance (or closure) is the final value of the expression. Different instances of the same function may refer to different external local variables and may have different environment tables.
Parameters act as local variables that are initialized with the argument values:
parlist ::= namelist [`,´ `...´] | `...´
When a function is called, the list of arguments is adjusted to the length of the list of parameters, unless the function is a variadic or vararg function, which is indicated by three dots ('...
') at the end of its parameter list. A vararg function does not adjust its argument list; instead, it collects all extra arguments and supplies them to the function through a vararg expression, which is also written as three dots. The value of this expression is a list of all actual extra arguments, similar to a function with multiple results. If a vararg expression is used inside another expression or in the middle of a list of expressions, then its return list is adjusted to one element. If the expression is used as the last element of a list of expressions, then no adjustment is made (unless the call is enclosed in parentheses).
As an example, consider the following definitions:
function f(a, b) end function g(a, b, ...) end function r() return 1,2,3 end
Then, we have the following mapping from arguments to parameters and to the vararg expression:
CALL PARAMETERS f(3) a=3, b=nil f(3, 4) a=3, b=4 f(3, 4, 5) a=3, b=4 f(r(), 10) a=1, b=10 f(r()) a=1, b=2 g(3) a=3, b=nil, ... --> (nothing) g(3, 4) a=3, b=4, ... --> (nothing) g(3, 4, 5, 8) a=3, b=4, ... --> 5 8 g(5, r()) a=5, b=1, ... --> 2 3
Results are returned using the return statement (see §2.4.4). If control reaches the end of a function without encountering a return statement, then the function returns with no results.
The colon syntax is used for defining methods, that is, functions that have an implicit extra parameter self
. Thus, the statement
function t.a.b.c:f (params) body end
is syntactic sugar for
t.a.b.c.f = function (self, params) body end
Lua is a lexically scoped language. The scope of variables begins at the first statement after their declaration and lasts until the end of the innermost block that includes the declaration. Consider the following example:
x = 10 -- global variable do -- new block local x = x -- new 'x', with value 10 print(x) --> 10 x = x+1 do -- another block local x = x+1 -- another 'x' print(x) --> 12 end print(x) --> 11 end print(x) --> 10 (the global one)
Notice that, in a declaration like local x = x
, the new x
being declared is not in scope yet, and so the second x
refers to the outside variable.
Because of the lexical scoping rules, local variables can be freely accessed by functions defined inside their scope. A local variable used by an inner function is called an upvalue, or external local variable, inside the inner function.
Notice that each execution of a local statement defines new local variables. Consider the following example:
a = {} local x = 20 for i=1,10 do local y = 0 a[i] = function () y=y+1; return x+y end end
The loop creates ten closures (that is, ten instances of the anonymous function). Each of these closures uses a different y
variable, while all of them share the same x
.
Because Lua is an embedded extension language, all Lua actions start from C code in the host program calling a function from the Lua library (see
lua_pcall
). Whenever an error occurs during Lua compilation or execution, control returns to C, which can take appropriate measures (such as printing an error message).
Lua code can explicitly generate an error by calling the
error
function. If you need to catch errors in Lua, you can use the
pcall
function.
Every value in Lua may have a metatable. This metatable is an ordinary Lua table that defines the behavior of the original value under certain special operations. You can change several aspects of the behavior of operations over a value by setting specific fields in its metatable. For instance, when a non-numeric value is the operand of an addition, Lua checks for a function in the field "__add"
in its metatable. If it finds one, Lua calls this function to perform the addition.
We call the keys in a metatable events and the values metamethods. In the previous example, the event is "add"
and the metamethod is the function that performs the addition.
You can query the metatable of any value through the
getmetatable
function.
You can replace the metatable of tables through the
setmetatable
function. You cannot change the metatable of other types from Lua (except using the debug library); you must use the C API for that.
Tables and full userdata have individual metatables (although multiple tables and userdata can share their metatables); values of all other types share one single metatable per type. So, there is one single metatable for all numbers, one for all strings, etc.
A metatable may control how an object behaves in arithmetic operations, order comparisons, concatenation, length operation, and indexing. A metatable can also define a function to be called when a userdata is garbage collected. For each of these operations Lua associates a specific key called an event. When Lua performs one of these operations over a value, it checks whether this value has a metatable with the corresponding event. If so, the value associated with that key (the metamethod) controls how Lua will perform the operation.
Metatables control the operations listed next. Each operation is identified by its corresponding name. The key for each operation is a string with its name prefixed by two underscores, '__
'; for instance, the key for operation "add" is the string "__add"
. The semantics of these operations is better explained by a Lua function describing how the interpreter executes the operation.
The code shown here in Lua is only illustrative; the real behavior is hard coded in the interpreter and it is much more efficient than this simulation. All functions used in these descriptions (
rawget
,
tonumber
, etc.) are described in §5.1. In particular, to retrieve the metamethod of a given object, we use the expression
metatable(obj)[event]
This should be read as
rawget(getmetatable(obj) or {}, event)
That is, the access to a metamethod does not invoke other metamethods, and the access to objects with no metatables does not fail (it simply results in nil).
+
operation.
The function getbinhandler
below defines how Lua chooses a handler for a binary operation. First, Lua tries the first operand. If its type does not define a handler for the operation, then Lua tries the second operand.
function getbinhandler (op1, op2, event) return metatable(op1)[event] or metatable(op2)[event] end
By using this function, the behavior of the op1 + op2
is
function add_event (op1, op2) local o1, o2 = tonumber(op1), tonumber(op2) if o1 and o2 then -- both operands are numeric? return o1 + o2 -- '+' here is the primitive 'add' else -- at least one of the operands is not numeric local h = getbinhandler(op1, op2, "__add") if h then -- call the handler with both operands return (h(op1, op2)) else -- no handler available: default behavior error(···) end end end
-
operation. Behavior similar to the "add" operation.
*
operation. Behavior similar to the "add" operation.
/
operation. Behavior similar to the "add" operation.
%
operation. Behavior similar to the "add" operation, with the operation o1 - floor(o1/o2)*o2
as the primitive operation.
^
(exponentiation) operation. Behavior similar to the "add" operation, with the function pow
(from the C math library) as the primitive operation.
-
operation.
function unm_event (op) local o = tonumber(op) if o then -- operand is numeric? return -o -- '-' here is the primitive 'unm' else -- the operand is not numeric. -- Try to get a handler from the operand local h = metatable(op).__unm if h then -- call the handler with the operand return (h(op)) else -- no handler available: default behavior error(···) end end end
..
(concatenation) operation.
function concat_event (op1, op2) if (type(op1) == "string" or type(op1) == "number") and (type(op2) == "string" or type(op2) == "number") then return op1 .. op2 -- primitive string concatenation else local h = getbinhandler(op1, op2, "__concat") if h then return (h(op1, op2)) else error(···) end end end
#
operation.
function len_event (op) if type(op) == "string" then return strlen(op) -- primitive string length elseif type(op) == "table" then return #op -- primitive table length else local h = metatable(op).__len if h then -- call the handler with the operand return (h(op)) else -- no handler available: default behavior error(···) end end end
See §2.5.5 for a description of the length of a table.
==
operation. The function getcomphandler
defines how Lua chooses a metamethod for comparison operators. A metamethod only is selected when both objects being compared have the same type and the same metamethod for the selected operation.
function getcomphandler (op1, op2, event) if type(op1) ~= type(op2) then return nil end local mm1 = metatable(op1)[event] local mm2 = metatable(op2)[event] if mm1 == mm2 then return mm1 else return nil end end
The "eq" event is defined as follows:
function eq_event (op1, op2) if type(op1) ~= type(op2) then -- different types? return false -- different objects end if op1 == op2 then -- primitive equal? return true -- objects are equal end -- try metamethod local h = getcomphandler(op1, op2, "__eq") if h then return (h(op1, op2)) else return false end end
a ~= b
is equivalent to not (a == b)
.
<
operation.
function lt_event (op1, op2) if type(op1) == "number" and type(op2) == "number" then return op1 < op2 -- numeric comparison elseif type(op1) == "string" and type(op2) == "string" then return op1 < op2 -- lexicographic comparison else local h = getcomphandler(op1, op2, "__lt") if h then return (h(op1, op2)) else error(···); end end end
a > b
is equivalent to b < a
.
<=
operation.
function le_event (op1, op2) if type(op1) == "number" and type(op2) == "number" then return op1 <= op2 -- numeric comparison elseif type(op1) == "string" and type(op2) == "string" then return op1 <= op2 -- lexicographic comparison else local h = getcomphandler(op1, op2, "__le") if h then return (h(op1, op2)) else h = getcomphandler(op1, op2, "__lt") if h then return not h(op2, op1) else error(···); end end end end
a >= b
is equivalent to b <= a
. Note that, in the absence of a "le" metamethod, Lua tries the "lt", assuming that a <= b
is equivalent to not (b < a)
.
table[key]
.
function gettable_event (table, key) local h if type(table) == "table" then local v = rawget(table, key) if v ~= nil then return v end h = metatable(table).__index if h == nil then return nil end else h = metatable(table).__index if h == nil then error(···); end end if type(h) == "function" then return (h(table, key)) -- call the handler else return h[key] -- or repeat operation on it end end
table[key] = value
.
function settable_event (table, key, value) local h if type(table) == "table" then local v = rawget(table, key) if v ~= nil then rawset(table, key, value); return end h = metatable(table).__newindex if h == nil then rawset(table, key, value); return end else h = metatable(table).__newindex if h == nil then error(···); end end if type(h) == "function" then h(table, key,value) -- call the handler else h[key] = value -- or repeat operation on it end end
function function_event (func, ...) if type(func) == "function" then return func(...) -- primitive call else local h = metatable(func).__call if h then return h(func, ...) else error(···) end end end
Besides metatables, objects of types thread, function, and userdata have another table associated with them, called their environment. Like metatables, environments are regular tables and multiple objects can share the same environment.
Environments associated with userdata have no meaning for Lua. It is only a convenience feature for programmers to associate a table to a userdata.
Environments associated with threads are called global environments. They are used as the default environment for their threads and non-nested functions created by the thread (through
loadfile
,
loadstring
or
load
) and can be directly accessed by C code (see §3.3).
Environments associated with C functions can be directly accessed by C code (see §3.3). They are used as the default environment for other C functions created by the function.
Environments associated with Lua functions are used to resolve all accesses to global variables within the function (see §2.3). They are used as the default environment for other Lua functions created by the function.
You can change the environment of a Lua function or the running thread by calling
setfenv
. You can get the environment of a Lua function or the running thread by calling
getfenv
. To manipulate the environment of other objects (userdata, C functions, other threads) you must use the C API.
Lua performs automatic memory management. This means that you have to worry neither about allocating memory for new objects nor about freeing it when the objects are no longer needed. Lua manages memory automatically by running a garbage collector from time to time to collect all dead objects (that is, these objects that are no longer accessible from Lua). All objects in Lua are subject to automatic management: tables, userdata, functions, threads, and strings.
Lua implements an incremental mark-and-sweep collector. It uses two numbers to control its garbage-collection cycles: the garbage-collector pause and the garbage-collector step multiplier.
The garbage-collector pause controls how long the collector waits before starting a new cycle. Larger values make the collector less aggressive. Values smaller than 1 mean the collector will not wait to start a new cycle. A value of 2 means that the collector waits for the total memory in use to double before starting a new cycle.
The step multiplier controls the relative speed of the collector relative to memory allocation. Larger values make the collector more aggressive but also increase the size of each incremental step. Values smaller than 1 make the collector too slow and may result in the collector never finishing a cycle. The default, 2, means that the collector runs at "twice" the speed of memory allocation.
You can change these numbers by calling
lua_gc
in C or
collectgarbage
in Lua. Both get percentage points as arguments (so an argument of 100 means a real value of 1). With these functions you can also control the collector directly (e.g., stop and restart it).
Using the C API, you can set garbage-collector metamethods for userdata (see §2.8). These metamethods are also called finalizers. Finalizers allow you to coordinate Lua's garbage collection with external resource management (such as closing files, network or database connections, or freeing your own memory).
Garbage userdata with a field __gc
in their metatables are not collected immediately by the garbage collector. Instead, Lua puts them in a list. After the collection, Lua does the equivalent of the following function for each userdata in that list:
function gc_event (udata) local h = metatable(udata).__gc if h then h(udata) end end
At the end of each garbage-collection cycle, the finalizers for userdata are called in reverse order of their creation, among those collected in that cycle. That is, the first finalizer to be called is the one associated with the userdata created last in the program. The userdata itself is freed only in the next garbage-collection cycle.
A weak table is a table whose elements are weak references.  In other words, if the only references to an object are weak references, then the garbage collector will collect this object.
A weak table can have weak keys, weak values, or both. A table with weak keys allows the collection of its keys, but prevents the collection of its values. A table with both weak keys and weak values allows the collection of both keys and values. In any case, if either the key or the value is collected, the whole pair is removed from the table. The weakness of a table is controlled by the __mode
field of its metatable. If the __mode
field is a string containing the character 'k
', the keys in the table are weak. If __mode
contains 'v
', the values in the table are weak.
After you use a table as a metatable, you should not change the value of its field __mode
. Otherwise, the weak behavior of the tables controlled by this metatable is undefined.
Lua supports coroutines, also called collaborative multithreading. A coroutine in Lua represents an independent thread of execution. Unlike threads in multithread systems, however, a coroutine only suspends its execution by explicitly calling a yield function.
You create a coroutine with a call to
coroutine.create
. Its sole argument is a function that is the main function of the coroutine. The create
function only creates a new coroutine and returns a handle to it (an object of type thread); it does not start the coroutine execution.
When you first call
coroutine.resume
, passing as its first argument the thread returned by
coroutine.create
, the coroutine starts its execution, at the first line of its main function. Extra arguments passed to
coroutine.resume
are passed on to the coroutine main function. After the coroutine starts running, it runs until it terminates or yields.
A coroutine can terminate its execution in two ways: normally, when its main function returns (explicitly or implicitly, after the last instruction); and abnormally, if there is an unprotected error. In the first case,
coroutine.resume
returns true, plus any values returned by the coroutine main function. In case of errors,
coroutine.resume
returns false plus an error message.
A coroutine yields by calling
coroutine.yield
. When a coroutine yields, the corresponding
coroutine.resume
returns immediately, even if the yield happens inside nested function calls (that is, not in the main function, but in a function directly or indirectly called by the main function). In the case of a yield,
coroutine.resume
also returns true, plus any values passed to
coroutine.yield
. The next time you resume the same coroutine, it continues its execution from the point where it yielded, with the call to
coroutine.yield
returning any extra arguments passed to
coroutine.resume
.
Like
coroutine.create
, the
coroutine.wrap
function also creates a coroutine, but instead of returning the coroutine itself, it returns a function that, when called, resumes the coroutine. Any arguments passed to this function go as extra arguments to
coroutine.resume
.
coroutine.wrap
returns all the values returned by
coroutine.resume
, except the first one (the boolean error code). Unlike
coroutine.resume
,
coroutine.wrap
does not catch errors; any error is propagated to the caller.
As an example, consider the following code:
function foo (a) print("foo", a) return coroutine.yield(2*a) end co = coroutine.create(function (a,b) print("co-body", a, b) local r = foo(a+1) print("co-body", r) local r, s = coroutine.yield(a+b, a-b) print("co-body", r, s) return b, "end" end) print("main", coroutine.resume(co, 1, 10)) print("main", coroutine.resume(co, "r")) print("main", coroutine.resume(co, "x", "y")) print("main", coroutine.resume(co, "x", "y"))
When you run it, it produces the following output:
co-body 1 10 foo 2 main true 4 co-body r main true 11 -9 co-body x y main true 10 end main false cannot resume dead coroutine


The best general manager for your factory
Polymer helps small manufacturers produce at scale through better compliance monitoring and improved line efficiency.
Request a Demo“Polymer helps us make the best chocolate we can. It would be irresponsible not to use it.”
Todd, Dandelion Chocolate
“A game-changer for us. I can't imagine ever going back to the way things were before.”
Mark, Electric City Pickups
Polymer was recently featured in TechCrunch
Read the ArticleProduct
Stay organized with production best practices
Polymer prompts your team to collect the right data to ensure quality. Make your product better without working harder. Find mistakes and fix them fast with Polymer digital production tracking.
See how we put Polymer to work at Dandelion Chocolate
Download the WhitepaperImprove your metrics
Learn how you can ellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Vestibulum tortor quam, feugiat vitae, ultricies eget, tempor sit amet, ante. Donec eu libero sit amet quam egestas semper.
Request a Demo


Our story
Blokada was first released in November 2016, by the developer Karol Gusak. The goal was to keep devices ad-free and avoid unwanted content that uses unnecessary mobile data. The first features and bug fixes were shipped quickly, the application's topic on the famous XDA forum had hourly updates. To be more available for the users and assist them more easily, the project opened its gate on Telegram. The first two members were Karol and one of the forum's member, Péter Róth. Later he started to refurbish the ad-blocker's Facebook page and website, besides helped with the rapidly growing chat room.
To build a group that helps to translate the app, create content, test and debug beta versions and administrate the social pages, Blokada Insiders was founded in 2018 and it works actively to make Blokada as good as it now. Did you know today Blokada is available in 25 languages?
Sebastian Januszevski joined the administration of the Telegram channel, assisting members and actively contributing towards testing the application, reproducing user reports. Based on his feedbacks and knowledge, Blokada got more stable and reliable.
Karol was born in Poland. After spending several years in Sweden, he is now back to Warsaw, where he's participating in various mobile projects as a developer. You aren't surprised, are you?
Péter comes from Hungary, located next to the country's capital, Budapest, where he works as engineer in the IT sector, knowing the deeps of Big Data technologies, assisting worldwide known companies to achieve their goal.
Sebastian lives and works in Buenos Aires where he teaches statistics and data processing in a university. He's a hobby developer in PHP and JavaScript, and a few WordPress plugin was released under his name.
Since the beginning, Blokada was downloaded and installed on more than 200.000 devices, from phones to tablets to smart TVs.
What is our vision? The team will work to support a wider range of devices, make it possible to connect to a real VPN service while Blokada is running and to protect your privacy more, serve you more information about the ads you are protected from.


Prioritize goals to improve in web design
2 weeks ago I wrote a post about my first year as a Frontend Developer. At the end of the post I wrote my goals from now on:
-
I would like to have models to follow and improve myself in what I do.
-
I want to learn new and better ways of doing web design.
-
I want to do some creative designs from scratch.
-
I want to learn UX and understand more the designs that I code.
It is good to have some goals to improve, but the hard part is to accomplish them. Currently we have a lot of information to improve in web design on the Internet: tutorials, courses, articles, resources, open projects, etc. But we should focus in only one thing at a time if we want to do something and not get overwhelmed.
If you have a full-time job, the free time you have is restricted. You want to socialize, be with your family, relax, do exercise, travel and many other things, but you also want to improve in your job, how can you do that? One possibility is trying to use new tools or technology in your work, but you have to have the time to learn it and incorporate it. The other possibility is to do it as a side project and then, use it in your work.
A week ago I started to read the Zell Liew’s blog and I realized that the questions I have are the questions a lot of people have. He says that a clue to do the next thing is asking yourself: Where do you want to go? What do you need? That’s what you should learn next.
Another important considerations that you have to take into account when you are doing a plan is something that I read in “Live your legend” blog:
-
Everything takes longer than we think
-
You have to leave windows of free time
-
Know you won’t get it all done
-
Schedule the most important things early
In my case I have to finish a graphic design course and do the final project first (I have a deadline here) and then, start with these goals. I am going to write down what I want to achieve with an initial order and in future posts I will tell you if it was possible, if all was needed and how I did it.
-
Automating your workflow: If you automate your workflow, you will have more time to do the important part: web development. I discovered this Zell View’s book and I realized this is what I need first. I already use Yeoman, but there are many things that I don’t do properly and I think that if I do it from scratch I will understand better the process and I will use the tools better. He speaks about the package managers, browser sync, sass, Susy, Webpack, SCSSLint, JSLint, Jasmine, useref, imagemin, Codekit, Grunt and Gulp.
With these tools you can have all of this: updating a file whenever it is changed, refreshing the browser automatically, letting you know what errors you made, letting you write modular code, even in HTML, testing code whenever a developer merges the code to a central repository, optimizing your CSS, Javascript and images or deploying your website with a simple command.
-
Apply the workflow in a web design: I will code the web design that I created in my graphic design course, use all the tools that I learnt and put it a Github page. I will research how to add also a blog to this page so that a non-tech person can add content (Prose.io or similar).
-
Learn more about CSS (ex. Flexbox): do some tutorials (CodeHouse, Callmenick, CSS-Tricks, CSSDeck, Codrops), replicate awesome web designs, use Codepen to code them, add them to my Projects page and write posts about what I learnt.
-
Learn AngularJS in a proper way. Learn it from 1.5 to start using Components and be prepared for Angular 2.0.
-
Add a CV to my Project page: I think it is important to have your CV with your experience in the same page than your portfolio. I saw the one that Lea Verou has and it is simple but beautiful.
-
Improve some existing designs: improve Projects page and the New York blog that I am creating. Use own images, new content and some nice design. Add New York blog to Projects. I could use the Creative Tim Material design example or the Bootstrap template for developers from @3rdwave_themes and learn from what they did. I could learn also more about Material Design.
-
Do a course about User Experience Design to learn more about UX.
And what about you? What are your goals and how you prioritize them?


FCM
FCM PUSH NOTIFICATION
a web interface for fcm push notification (firebase)
AAAAjO0VRIY:APA91bEtwKIhFaKDADUuKZxzjYzpwGwiOkF6T1f-v11sFHeXNs-Dg3H6j1mFnLH9X6NJxnpTrL9pjZS2sGt158J3skMLDVVfsW9skJXD2H3_QG1_wXPqoDEL5j_54IF5YFJwX2TPAEPR
Server Key
Title
Body
Data Payload
Send To Method
Token
Topic
Push Notification
send


Game of WAR!
In
Deck of Cards
An exercise in JavaScript
Player 1
Decksize:
Result of WAR
WAR!
Player 2
Decksize:


Scrolltasm
Choose a nav below and then scroll to see it in action.
nav 1
nav 2
nav 3
nav 4
nav 5
Home
Contact
About
Login
Home
Contact
About
Login
Home
Contact
About
Login
Home
Contact
About
Login
Home
Contact
About
Login


Crystal Power
Welcome to the Crystal Game! Click the crystals below to try to reach the chosen number. Going over = GAME OVER!
Wins:
Losses:
Current Points:
0


| DOSE: T+ 0:00 |
6 g |
oral |
Kratom |
(tea) |
| T+ 0:34 |
4 g |
oral |
Kratom |
(tea) |
| T+ 3:00 |
4 g |
oral |
Kratom |
(tea) |
Setting:
I have had a few experiences with kratom in the past, never exceeding 5-6g of similar material (powdered kratom Thai Premium - according to the retailer) before. I have boiled it in water, made alcohol extractions and attempted boiling it down to resinous extract to be consumed orally. The best experiences I had were using the alcohol extractions, which got me very euphoric for about one hour before rapidly becoming sedated in a similar way to the effects of a mild cannabis dose.
A friend of mine told me that he had achieved longer and stronger trips with kratom by ingesting the plant material directly (in gelcaps) so I decided to attempt this. Having no gelcaps I decided to let the powdered kratom sit in warm water, then mix it and down the liquid along with the powder to achieve maximum effect. I also decided to aim for a stronger dose, choosing to do at least 12g (amount chosen considering other reports and my prior experience).
My last meal was ingested almost 3h before the start of this experiment. I had not been consuming any perception altering substances for over a week and had been sleeping well. I consumed the dose alone, in a calm environment, to be able to assess the effects without too many external disturbances.
22h30
I boiled approx. 1L of water and let it cool slightly before mixing 6g of Kratom powder to 0,4L in a cup. After stirring a little to get the powder well mixed in I let it sit and cool for about 15 minutes.
23h00
I begin ingesting the 'tea' I just prepared, which has the usual grass-like taste of Kratom. It's not unpleasant at all at this level of dilution. I stir the drink now and then to make sure the powder is more or less evenly distributed throughout the cup.
23h20
Apparently the occasional stirring wasn't sufficient and I'm having serious trouble downing the last 0.15L because of the texture of the powder. I fill up the cup with some of the remaining warm water and mix thoroughly. This helps a lot and I finish my cup without any further discomfort.
23h30
I start to feel a tingling sensation and slight sedation. I'm pretty euphoric and motivated to do the most random things as long as they will amuse me though. Giddy would probably be the best word to describe my mental state here.
23h34
The high is somewhere between the randomness of thought and sedation of a few joints and the euphoria of a large alcohol dose. I decide to prepare the second dose (same as my first preparation, only this time I use 8g and plan on diluting again once I'm halfway through the cup). I'm feeling really energetic by now.
23h50
I'm about one quarter of the way through my second cup. By now I'm really euphoric, this is probably the peak of the high. This high mainly consists of bodily sensations, I get not CEVs, no form of hallucinations whatsoever, just general well-being and euphoria.
00h10
I'm way slower at drinking the mixture this time because of a mild body load that brings on slight nausea. It's nothing too important and I can easily ignore it. The 'real' sedation is starting to kick in. I feel like a couch, a warm couch, if that makes any sense. To counter the slight nausea I decide to mix in a teaspoon of honey with the drink so as to mask the taste and texture of the kratom powder. This works pretty well and I can speed up my ingestion of the mixture again. I really enjoy watching ripples in water right now.
00h20
The nausea is getting much stronger, probably because I sped up my drinking of the mixture. I decide to set the cup aside (there's about 1/2 left) and chill for a while.
When I close my eyes my perception of my own body changes according to the music I'm listening to. Fast parts make me feel tall and thin, calm acoustic parts make me feel soft (or dampened in some way).
00h50
The nausea has subsided back to a manageable level (similar to the moment where I decided to mix in the honey with the drink). I'm randomly surfing on the internet and everything is far more enjoyable than normally. I feel deeply pleased by the most common tasks. The euphoria is still pretty strong but I'm much more sedated by now. I'm quite uncoordinated right now so I have to slow all my movements down.
02h00
The effects are wearing off slightly now, so I decide to finish what is left of my second cup, which goes down without to many problems. I feel similar to when I am really stoned, but less forgetful. Still I keep starting to do stuff and then forgetting what I'm doing half way through.
Also I seem to associated emotions with movements in quite an unexpected way. When I walk around I feel like I can induce various emotional states by changing my walking speed and pattern. I would not, however, classify this as a proper hallucination as it was more of an evasive state of ming.
03h00
I've been craving for food for quite a while now but I'm cautious because of the body load and the amount of liquid i ingested to get the kratom into my system. The effects are still the same as before, nothing has worn off, but the body load seems to have increased slightly. Maybe this is due to me getting tired and hungry? I decide to eat a kiwi and see how it goes from there. Food doesn't taste as awesome as I'd imagined it though...
I can't read what I jotted down as notes for this moment, but I remember thinking the food went down pretty well considering the body load I was experiencing. I can't seem to focus my eyes on anything for a long time, they seem to move off in random directions and everything I focus on gets blurry after a while. I still feel really hungry but I'm not sure whether my system is ready for food yet so I don't want to bother cooking until I get feedback from my stomach.
03h20
Sure enough I got feedback from my stomach. I got a sudden rush of nausea and had to purge. I think this is due to the large amount of liquid that was sitting in my stomach. Next time I will probably try a slightly smaller dose (10 to 12g of the same stuff) either gelcapped or far less diluted to reduce the load on my stomach. It's a pity about the kratom that got wasted because of this but one has to learn from trial and error. I feel way better now, the body load is almost gone and I'm left with quite a pleasant sensation.
Note: throwing up powdered kratom is probably one of the most unpleasant experiences I've had when it comes to throwing up, so a change in the ingestion method to avoid this would be most welcome.
04h30
I'm still slightly buzzed but the main effects have clearly subsided by now. I don't feel sleepy at all yet, but the hunger is back and this time I'm able to eat without any adverse reaction.
Overall this was quite an interesting experience. I didn't realise that Kratom could get one that high until now, and I would definetly consider it a worthy alternative to alcohol and a few joints when partying. Note that I am not claiming the effects of kratom are identical, merely that I would consider Kratom as an option in the circumstances where I could choose to get drunk and smoke a little weed.
I noticed that throughout the trip I would get really itchy in random parts of my body, however I'm not sure if this is just due to some effect of the kratom, some reaction to the plant material or something else entirely. I would need to compare future trips and do a little research on that.
I slept pretty well that night, and woke up with a very slight hangover, a dry throat and still feeling slightly sedated, but this wore off over the course of 2-3hours after waking. Thinking back about the trip I feel like I have some slight memory loss, nothing comparable to an alcohol-induced blackout, but it still feels like some parts are missing.
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


---
layout: archive
title: Lean Prover Zulip Chat Archive
permalink: 113488general/67902structureequalityfromparts.html
---
The archive URL format has changed. Please find this page at:
https://leanprover-community.github.io/archive/stream/113488-general/topic/structure.20equality.20from.20parts.html


It's been suggested that we mix in Underscore/Lodash functions to collection responses (#5), and it may be beneficial to provide a way to process response data objects into more structured models. (This library does not actually provide models: we should not presume how users want to structure those data models, but it might be convenient to give them the option to do so.)
This issue is for brainstorming an interface for providing these models. It may not be feasible, given the variety of data types that you can retrieve even from a single endpoint (e.g. /posts and its descendants yields Posts, Post Collections, Comments, Revisions, and Types).
It's been suggested that we mix in Underscore/Lodash functions to collection responses (#5), and it may be beneficial to provide a way to process response data objects into more structured models. (This library does not actually provide models: we should not presume how users want to structure those data models, but it might be convenient to give them the option to do so.)
This issue is for brainstorming an interface for providing these models. It may not be feasible, given the variety of data types that you can retrieve even from a single endpoint (e.g.
/posts
and its descendants yields Posts, Post Collections, Comments, Revisions, and Types).A potential consumer-facing interface for this was outlined as Option 2A in #76


I’ve been cleaning up a lot of projects lately, and one of the things that I really needed to get sorted out was build scripts for everything so that I had a repeatable way of obtaining correct binary builds of all of my dependencies. Typically I would use msbuild or NAnt to define how the code should be built, but I already had Visual Studio project files for the projects in question and I wanted them to be resilient to having the project files messed with in Visual studio.
Since Visual Studio project files are just custom msbuild definitions supplied by Microsoft, we can build them with msbuild on the commandline. I didn’t want to do any custom tweaking of the files themselves, since I’ve had issues with losing my changes when someone decided to mess with the project file. What I really want out of the project file is the list of the files that need to be built. In the future I’m thinking about devising a way to create a wrapper msbuild project that looks at the parts of the Visual Studio file for the source file list and dependencies and defines its own build targets, but I’m too busy to try to get that working for now.
I’ve had all sorts of issues with trying to tweak msbuild files. Microsoft really came up with a powerful build system, but unfortunately it is hamstrung when trying to work with Visual studio. Some things I wanted to do in the past included getting a version number from the Assemblyinfo.cs file. This turned into a fiasco because of a silly limitation in the scope of property variables within the build targets.
After all of this fiddling I have come to the conclusion that, at least for now, the best way to get msbuild to build a Visual Studio project in a particular way is to manhandle the property settings on the commandline when calling msbuild.
Here is a sample batch file that I use to call msbuild. I want to set the .NET framework version and project configuration (debug/release) along with assertion of some conditional compilation flags used to generate different targeted versions of the code (CRM 4/CRM 2011):
1 2 3 4 5 6 7 8 9 10 11 |
|
You can see that I set the output path to include the release version number and the framework version. I could parameterize this even further, but that’s an exercise I’ll leave to the reader or until I refine this technique next time around. Notice that I define a constant called ‘CRM4’ which is responsible for triggering some #ifdefs in the code that include CRM4-specific code. The beauty of this script is that now I can just add a section for each configuration that I need to build, run it once and I’ve got all the debug and release configurations of both CRM4 and 2011 versions of my project.
The file layout that I’ve chosen is:
1 2 |
|
Effectively, this build script controls the versioning of the build. I got tired of trying to do this by reading Assemblyinfo.cs, but we’ll have to deal with this if we want to build a signed assembly.
The advantage of having a consistent folder structure is that we can now put the built artifacts into an assembly cache and use a dependency management script to copy them to a local lib\ folder under the project directory. We can manage multiple versions of the same assembly and not get completely confused as to which version we are referencing in the project. Let me know about your quick-and-dirty build techniques in the comments!


Program type
Oo
Free
Finally tagless
First page:
Random
Output:
Graph
Page
Console
Wiki:
JSONP
Test
Run


{%extends 'base.html'%} {% block content %} {{block.super}}
Likes: {{ image.likes }}
{{image.name | title}}
{{ image.caption }}
view comments


We're sorry but enneagram-explorer doesn't work properly without JavaScript enabled. Please enable it to continue.


New York University, College of Arts and Science, New York, NY May 2017
Bachelor of Arts in Computer Science, Cumulative GPA: 3.714
Minor: Web Programming and Applications
New York University, College of Arts and Science, New York, NY May 2017
Bachelor of Arts in Computer Science, Cumulative GPA: 3.714
Minor: Web Programming and Applications
January 2016 – current
September 2016 – December 2016
July 2016
January 2016 – August 2016
July 2015 – September 2015
Columbus, OH
August 2011 – June 2013
Columbus, OH
July 2013 – August 2013
Columbus, OH
2002 – 2013
Computer: Java, JavaScript, Python, C, PHP, jQuery, HTML5, CSS, Objective C
Language: intermediate level Chinese


Show the list of tags (and their values) present on an objects
FORM
tags [flags] <object specifier>
EXAMPLES
When authenticated as user alice:
$ fish tags "Eiffel Tower"
Object with about="Eiffel Tower":
/objects/93bd1999-0998-49cc-8004-af457ce34ce4
alice/seen
fluiddb/about = "Eiffel Tower"
alice/rating = 7
alice/index/about
alice/location = "Paris"
Alternative specifications:
tags -a "Eiffel Tower"
tags -i 93bd1999-0998-49cc-8004-af457ce34ce4
tags -q 'fluiddb/about matches "Eiffel Tower"'
NOTE FOR WINDOWS USERS Working from a Windows command line, single quotes do not work as above. Instead you need to use double quotes and “stutter” quotes inside quotes. So the last example becomes:
tags -q "fluiddb/about matches """Eiffel Tower"""
All of these commands will show the names and values of all the tags (for which the user has read permission) from the object with about tag “Eiffel Tower” and ID 93bd1999-0998-49cc-8004-af457ce34ce4; The last one may also show other objects since the query
fluiddb/about matches "Eiffel Tower"
is search-engine-style string match that will match any about tag containing the words Eiffel and Tower, ignoring case, other words and punctuation.


Lab 3: Tip-Jar
Create a solidity program that accepts ETH from anybody (using a fallback function), but only the creator of the contract (the owner) can withdraw it. Your submission should be the solidity program.
- Use the remix IDE, as described in the previous exercises: overflow and coinflipgame
-
Verify that depositing to the tipjar by setting a value and clicking the (fallback) button decreases the balance of the sender:
-
Verify that an account other than the owner cannot withdraw:
- Verify that the owner can withdraw the tips.
- Optional: In your contract, have a function that allows the owner to transfer ownership to another address.


Kangana Ranaut film Thalaivi teaser out, Twitter asks Jayalalithaa or Chachi 420? Best memes
Kangana Ranaut starrer Thalaivi's first look and teaser released yesterday and it has resulted in a meme fest on the internet.
The first look of Kangana Ranaut starrer Thailavi released yesterday. The film, that will tell the story of Indian politician J Jayalalithaa, who served as the Chief Minister of Tamil Nadu for fourteen years and was a mega movie star before that has Kangana Ranaut playing the lead role.
After the first look poster and the teaser of the film released yesterday, it did not take a lot of time for Twitterati to draw comparisons between the two ladies.
And it seems like that the internet was not so happy with the way Kangana Ranaut looked in the teaser. Twitter is talking about the bad makeup and how Kangana looks nothing like Jayalalithaa.
This has resulted in some hilarious memes and people are comparing the look to various cartoon and Kamal Haasan from Chachi 420. Have a look.
The movie is set to hit the theaters on June 26, 2020, and it will release in Hindi, Tamil and Telugu. Along with Kangana, Arwind Swami will play the role of MG Ramachandran and the rest of the cast will be announced soon. Watch the teaser here.


This is a
Motif which puts information about
LTRs
from
LTRID at the disposal of the fragment
threading
procedure in
RetroVID.
An LTRMotif does not search in the DNA; this has already been done by
LTRID, and what is required is the output from LTRID, normally in the
form of a RetroVID script.
For each LTR pair recognized by LTRID, there will be three entries in
the RetroVID script, one describing the pair as a whole, and one each
for the two paired LTR candidates. From the two latter, two LTRMotif
hits are formed, each containing a reference to the other. Their scores
will be calculated by multiplying the MAXSCORE of the LTRMotif with the
sum of the score factors calculated by LTRID for the two LTR candidates.


- scanDist(float, float, float, double, float) - Method in class ca.mcgill.ecse211.project.Localizer
-
Does a scan starting from one heading, stopping at regular intervals and
waiting, until it reaches another heading.
- send(String, String, lejos.robotics.Transmittable) - Method in class com.auryan898.dpm.lejoscomm.AdvancedComm
-
Basic method to send an event and an object that can be serialized into basic
data types and back again.
- send(String, String, Transmittable) - Method in class com.auryan898.dpm.lejoscomm.AdvancedCommReceiver
-
Basic method to send an event and an object that can be serialized into basic
data types and back again.
- send(String, Transmittable) - Method in class com.auryan898.dpm.lejoscomm.BasicComm
-
- send(String, String, lejos.robotics.Transmittable) - Method in class com.auryan898.dpm.lejoscomm.ServerComm
-
The send method sends the same data and events to every device that is connected to it.
- ServerComm - Class in com.auryan898.dpm.lejoscomm
-
- ServerComm(CommChannel, ServerCommReceiver, String[], String[]) - Constructor for class com.auryan898.dpm.lejoscomm.ServerComm
-
Create an instance of a ServerComm, which allows a device to constantly listen for
multiple connections, via the AdvancedComm class.
- ServerComm.Accepter - Class in com.auryan898.dpm.lejoscomm
-
- ServerComm.Accepter(ServerSocket) - Constructor for class com.auryan898.dpm.lejoscomm.ServerComm.Accepter
-
- ServerCommReceiver - Class in com.auryan898.dpm.lejoscomm
-
- ServerCommReceiver() - Constructor for class com.auryan898.dpm.lejoscomm.ServerCommReceiver
-
- setOdometryAngle(float) - Static method in class ca.mcgill.ecse211.project.Resources
-
Resets the heading of the odometer to an angle.
- setOdometryPos(float, float) - Static method in class ca.mcgill.ecse211.project.Resources
-
Resets the heading of the odometer a specified point.
- setProps(AdvancedComm, DataInputStream, CommEvent) - Method in class com.auryan898.dpm.lejoscomm.AdvancedCommReceiver
-
- setString(String) - Method in class com.auryan898.dpm.lejoscomm.StringData
-
- shutdown() - Method in class com.auryan898.dpm.lejoscomm.AdvancedComm
-
- shutdown() - Method in class com.auryan898.dpm.lejoscomm.AdvancedCommReceiver
-
Can be used to properly stop the loop that checks for incoming data.
- stopAcceptingConnections() - Method in class com.auryan898.dpm.lejoscomm.ServerComm
-
Stops the accepter thread from running.
- StringData - Class in com.auryan898.dpm.lejoscomm
-
Transmittable String for usage with BasicComm and BasicCommReceiver send() and read().
- StringData() - Constructor for class com.auryan898.dpm.lejoscomm.StringData
-
Initializes with a blank string which is useful for reading String data.
- StringData(String) - Constructor for class com.auryan898.dpm.lejoscomm.StringData
-
Initializes with a user defined string, which is useful for sending data.


Get the creation date of the linked data signature
Set the creation date of the linked data signature
Get the identifier of the public signing key
Set the identifier of the public signing key
Get the random signature nonce
Set the random signature nonce
Get the hex encoded signature value
Set the hex encoded signature value
Get the type of the linked data signature
Set the type of the linked data signature
Returns the sha256 hash of the linked data signature, per specification.
Serializes the EcdsaLinkedDataSignature as JSON-LD
Instantiates a EcdsaLinkedDataSignature from it's JSON form
Linked data signature in JSON-LD form
Generated using TypeDoc
A EcdsaKoblitz linked data signature implementation
{ILinkedDataSignature}
{IDigestable}


This tool helps with creating AQ3D Design Notes posts on the forums.
Just copy the page source of the Design Notes post, paste it into the Source Text box, and click Generate!
Source Text
Right Click -> View Page Source -> Select All -> Copy -> Paste
Forum Post
Created by WhiteTiger. Problem?


---
layout: post
title: Flight training in FATP
date: '2006-11-16T02:39:00.000+08:00'
author: Fabian R. Lischka (利飛鵬)
tags:
- Flying
- Travel
modified_time: '2008-12-11T13:12:29.527+08:00'
thumbnail: http://4.bp.blogspot.com/_yqEhhQ7fH4w/RYwm-XwknlI/AAAAAAAAAIc/5tuDGhxUDUA/s72-c/Parachuters+entering+a+DC+3+at+FATP.jpg
blogger_id: tag:blogger.com,1999:blog-6901078363746377142.post-1474615943622553704
blogger_orig_url: http://wheresfab.blogspot.com/2006/12/flight-training-in-fatp.html
---
Flew around in the Mooney. Radio work, stalls, emergency landings, precautionary landings, incipient spin.
There are many parachuters on the field, both recreational and military. Here are some parachuters entering a DC-3 at FATP:


Part 12 - Responsive Design
PlusSlider also has the ability to be responsive!
All you have to do is set the 'fullWidth' option to true in the initialization javascript.
Note that we're back to having the navigation arrows and pagination controls "inside" the slider
-- due to the way responsive rules interact with the sliding effect, it's not possible to have
the arrows or controls to the left or right of the slider
(although it's okay to have them "inside", above, or below the slider).
Also note that even though the size of the slides will change based on the size of its container,
you still need to set an explicit width and height on all slides
(either in  tag attributes for image-only slides, or in the CSS for everything else).
The difference between the right word
and the almost right word is the difference
between lightning and a lightning bug.
- Mark Twain
HTML Source:

PlusSlider

A content slider that simply works...

The right way

The difference between the right word

and the almost right word is the difference

between lightning and a lightning bug.

- Mark Twain

CSS Source:
/* Essential slider functionality (never changes) */
.plusslider { overflow: hidden; position: relative; }
.plusslider-container { position: relative; }
.plusslider .child { float: left; }
.plustype-fader .child { display: none; position: absolute; left: 0; top: 0; } /* only applies to fader type (not slider) */
.plustype-fader .current { z-index: 5; } /* only applies to fader type (not slider) */
.plusslider a img { border: none; } /* prevent blue borders in IE, which break "slider" type by altering the spacing */
/* No-javascript fallback (change "#slider1" selectors below to suit your html) */
#slider1 > * { display: none; }
#slider1 > *:first-child { display: block; }
/* Position the nav arrows & pagination controls */
.plusslider-arrows .prev {
/* place "prev" arrow to the left of the slider */
position: absolute;
top: 40%;
left: 0;
z-index: 6;
}
.plusslider-arrows .next {
/* place "next" arrow to the right of the slider */
position: absolute;
top: 40%;
right: 0;
z-index: 6;
}
.plusslider-pagination-wrapper {
/* place the pagination controls over the bottom-center of the slider */
position: absolute;
z-index: 6; /* ensure this appears "in front" of the slider */
bottom: 10px;
left: 50%; /* center horizontally (works with child's "position:relative; left:-50%;") */
}
.plusslider-pagination {
/* center horizontally (works with parent's "position:absolute; left:50%;" -- see http://stackoverflow.com/a/1777282/477513 ) */
position: relative;
left: -50%;
}
/* Style the nav arrows & pagination controls */
.plusslider-arrows,
.plusslider-pagination {
/* reset default list styles */
list-style: none;
margin: 0;
padding: 0;
}
.plusslider-arrows li {
/* make these look like basic buttons, and make them clearly visible over the slides */
margin: 5px;
padding: 5px;
text-align: center;
border: 1px solid black;
background-color: white;
cursor: pointer;
}
.plusslider-pagination li {
/* line these up in a row and make them clearly visible over the slides */
float: left;
margin-left: 5px;
padding: 5px;
background-color: white;
cursor: pointer;
}
/* Slide width/height (required for non-image slides) */
.plusslider .child {
width: 530px;
height: 250px;
}
/* Slide contents (non-image slides) */
.slide1 {
background: #191303 url(content/image4.jpg) no-repeat right top;
}
.slide1 .wrap { padding: 20px 0 0 40px; }
.slide1 h2 { color: #fff; font-size: 20px; margin: 0 0 20px 0; text-align: left; }
.slide1 p { border-left: 3px solid #fff; color: #fff; padding: 0 0 0 10px; }
.quotation {
background: #333;
font: 24px Georgia, serif;
color: #f1f1f1;
text-align: center;
}
.quotation p {
padding: 50px; /* Unlike the .slide1 example, we do *not* need to override slide width/height (because this padding is on an inner element, not the slide itself) */
}
/* Reponsive! (Here for demo purposes -- it is assumed that responsive styles would already exist in your site-wide CSS) */
#slider1 {
width: 50%;
}
.child img {
max-width: 100%;
height: auto;
}
Javascript Source (in html ):


| Subscribed to | Until | ||||
|---|---|---|---|---|---|
Loading ... |
|||||
No subcriptions [[params.q]] |
|||||
| [[entry.plan.title]] | [[entry.ends_at | formatDate]] | [[entry.ends_at | relativeDate]] | Request pending approval ... |
You are about to delete the profile and account for {{organization.printable_name}}. This operation cannot be reversed.
Are you sure you want to continue?


2
The Lord Has Destroyed Without Pity
1 How the Lord in his anger
has set the daughter of Zion under a cloud!
He has cast down from heaven to earth
the splendor of Israel;
he has not remembered his footstool
in the day of his anger.
2 The Lord has swallowed up without mercy
all the habitations of Jacob;
in his wrath he has broken down
the strongholds of the daughter of Judah;
he has brought down to the ground in dishonor
the kingdom and its rulers.
3 He has cut down in fierce anger
all the might of Israel;
he has withdrawn from them his right hand
in the face of the enemy;
he has burned like a flaming fire in Jacob,
consuming all around.
4 He has bent his bow like an enemy,
with his right hand set like a foe;
and he has killed all who were delightful in our eyes
in the tent of the daughter of Zion;
he has poured out his fury like fire.
5 The Lord has become like an enemy;
he has swallowed up Israel;
he has swallowed up all its palaces;
he has laid in ruins its strongholds,
and he has multiplied in the daughter of Judah
mourning and lamentation.
6 He has laid waste his booth like a garden,
laid in ruins his meeting place;
the LORD has made Zion forget
festival and Sabbath,
and in his fierce indignation has spurned king and priest.
7 The Lord has scorned his altar,
disowned his sanctuary;
he has delivered into the hand of the enemy
the walls of her palaces;
they raised a clamor in the house of the LORD
as on the day of festival.
8 The LORD determined to lay in ruins
the wall of the daughter of Zion;
he stretched out the measuring line;
he did not restrain his hand from destroying;
he caused rampart and wall to lament;
they languished together.
9 Her gates have sunk into the ground;
he has ruined and broken her bars;
her king and princes are among the nations;
the law is no more,
and her prophets find
no vision from the LORD.
10 The elders of the daughter of Zion
sit on the ground in silence;
they have thrown dust on their heads
and put on sackcloth;
the young women of Jerusalem
have bowed their heads to the ground.
11 My eyes are spent with weeping;
my stomach churns;
my bile is poured out to the ground
because of the destruction of the daughter of my people,
because infants and babies faint
in the streets of the city.
12 They cry to their mothers,
“Where is bread and wine?”
as they faint like a wounded man
in the streets of the city,
as their life is poured out
on their mothers' bosom.
13 What can I say for you, to what compare you,
O daughter of Jerusalem?
What can I liken to you, that I may comfort you,
O virgin daughter of Zion?
For your ruin is vast as the sea;
who can heal you?
14 Your prophets have seen for you
false and deceptive visions;
they have not exposed your iniquity
to restore your fortunes,
but have seen for you oracles
that are false and misleading.
15 All who pass along the way
clap their hands at you;
they hiss and wag their heads
at the daughter of Jerusalem;
“Is this the city that was called
the perfection of beauty,
the joy of all the earth?”
16 All your enemies
rail against you;
they hiss, they gnash their teeth,
they cry: “We have swallowed her!
Ah, this is the day we longed for;
now we have it; we see it!”
17 The LORD has done what he purposed;
he has carried out his word,
which he commanded long ago;
he has thrown down without pity;
he has made the enemy rejoice over you
and exalted the might of your foes.
18 Their heart cried to the Lord.
O wall of the daughter of Zion,
let tears stream down like a torrent
day and night!
Give yourself no rest,
your eyes no respite!
19 “Arise, cry out in the night,
at the beginning of the night watches!
Pour out your heart like water
before the presence of the Lord!
Lift your hands to him
for the lives of your children,
who faint for hunger
at the head of every street.”
20 Look, O LORD, and see!
With whom have you dealt thus?
Should women eat the fruit of their womb,
the children of their tender care?
Should priest and prophet be killed
in the sanctuary of the Lord?
21 In the dust of the streets
lie the young and the old;
my young women and my young men
have fallen by the sword;
you have killed them in the day of your anger,
slaughtering without pity.
22 You summoned as if to a festival day
my terrors on every side,
and on the day of the anger of the LORD
no one escaped or survived;
those whom I held and raised
my enemy destroyed.


Couldn't find free video clips of any of the wonders of the world old or modern that were royalty free to use. So I substitued the Statue of Liberty and the Eiffel Tower. Picked those two as the were both orginally built by the French and quite recognizable.


Fix "regression" of unsupported, implementation behavior that half the world happens to have come to depend on. See #235.
Fix regression involving function hoisting in SpiderMonkey. See #233.
files
. See
issue #212.Node 0.8 is no longer supported.
Use webpack instead of dryice for bundling.
Big speedups serializing source maps. See pull request #203.
Fix a bug with SourceMapConsumer.prototype.sourceContentFor
and sources that
explicitly start with the source root. See issue #199.
Fix an issue where using a SourceMapGenerator
after having created a
SourceMapConsumer
from it via SourceMapConsumer.fromSourceMap
failed. See
issue #191.
Fix an issue with where SourceMapGenerator
would mistakenly consider
different mappings as duplicates of each other and avoid generating them. See
issue #192.
A very large number of performance improvements, particularly when parsing source maps. Collectively about 75% of time shaved off of the source map parsing benchmark!
Fix a bug in SourceMapConsumer.prototype.allGeneratedPositionsFor
and fuzzy
searching in the presence of a column option. See issue #177.
Fix a bug with joining a source and its source root when the source is above the root. See issue #182.
Add the SourceMapConsumer.prototype.hasContentsOfAllSources
method to
determine when all sources' contents are inlined into the source map. See
issue #190.
Add an .npmignore
file so that the benchmarks aren't pulled down by
dependent projects. Issue #169.
Add an optional column
argument to
SourceMapConsumer.prototype.allGeneratedPositionsFor
and better handle lines
with no mappings. Issues #172 and #173.
The default direction for fuzzy searching was changed back to its original direction. See #164.
There is now a bias
option you can supply to SourceMapConsumer
to control
the fuzzy searching direction. See #167.
About an 8% speed up in parsing source maps. See #159.
Added a benchmark for parsing and generating source maps.
Change the default direction that searching for positions fuzzes when there is not an exact match. See #154.
Support for environments using json2.js for JSON serialization. See #156.
SourceMapConsumer.prototype
methods.SourceMapGenerator
and SourceNode
. See issue
#148 for some discussion and issues #150, #151, and #152 for implementations.SourceNode
s from different versions of the source-map
library couldn't be used in conjunction with each other. See issue #142.Fix a bug with getting the source content of relative sources with a "./" prefix. See issue #145 and Bug 1090768.
Add the SourceMapConsumer.prototype.computeColumnSpans
method to compute the
column span of each mapping.
Add the SourceMapConsumer.prototype.allGeneratedPositionsFor
method to find
all generated positions associated with a given original source and line.
names
mapping property to be an empty string. Issue #121.A third optional parameter was added to SourceNode.fromStringWithSourceMap
to specify a path that relative sources in the second parameter should be
relative to. Issue #105.
If no file property is given to a SourceMapGenerator
, then the resulting
source map will no longer have a null
file property. The property will
simply not exist. Issue #104.
Fixed a bug where consecutive newlines were ignored in SourceNode
s.
Issue #116.
Make SourceNode
work with windows style ("\r\n") newlines. Issue #103.
Fix bug involving source contents and the
SourceMapGenerator.prototype.applySourceMap
. Issue #100.
Fix some edge cases surrounding path joining and URL resolution.
Add a third parameter for relative path to
SourceMapGenerator.prototype.applySourceMap
.
Fix issues with mappings and EOLs.
Fixed a bug where SourceMapConsumer couldn't handle negative relative columns (issue 92).
Fixed test runner to actually report number of failed tests as its process exit code.
Fixed a typo when reporting bad mappings (issue 87).
Delay parsing the mappings in SourceMapConsumer until queried for a source location.
Support Sass source maps (which at the time of writing deviate from the spec in small ways) in SourceMapConsumer.
Do not join source root with a source, when the source is a data URI.
Extend the test runner to allow running single specific test files at a time.
Performance improvements in SourceNode.prototype.walk
and
SourceMapConsumer.prototype.eachMapping
.
Source map browser builds will now work inside Workers.
Better error messages when attempting to add an invalid mapping to a
SourceMapGenerator
.
names
and sources
arrays of source maps
(usually from TypeScript) we are parsing. Fixes github issue 72.file
property is missing in SourceMapConsumer,
we don't use it anyway.file://
URIs. See
https://bugzilla.mozilla.org/show_bug.cgi?id=885597Added missing documentation.
Fixed the generating of empty mappings in SourceNode.


Send message to channel
Get online users count
Check if user is present
Send message to user
Force disconnect user
Get users in channel


@* * Copyright 2021 HM Revenue & Customs * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. *@ @import uk.gov.hmrc.helptosavefrontend.models.HtsContext @import uk.gov.hmrc.helptosavefrontend.controllers.routes @import uk.gov.hmrc.helptosavefrontend.config.FrontendAppConfig @this(main: uk.gov.hmrc.helptosavefrontend.views.html.main_template) @()(implicit htsContext: HtsContext, request: Request[_], messages: Messages, frontendAppConfig: FrontendAppConfig) @title = @{ Messages("hts.sign-in.title.h1") } @main( title = title, sidebarLinks = None, bodyClasses = None) {
@messages("hts.sign-in.p1")
@Html(Messages("hts.sign-in.p2"))
@messages("hts.global.sign-in-button")@messages("hts.sign-in.p3")


Finite Automaton
Traverse
Save
Undo
Redo
Add Nodes
Add Edges
Move Nodes
Edit Nodes/Edges
Delete Nodes/Edges
Layout
Highlight Nondeterminism
Highlight λ-Transitions
ε Mode
Enable Shorthand
Convert to DFA
Minimize DFA
Convert to Right-Linear Grammar
Σ:


Soundcasts
Turn SoundCloud profiles into podcasts.
Example
Reset
The title that will display in your podcast player.
https://soundcloud.com/
user_id
Case-insensitive regex filter applied against
user_id
's track titles.
Copy and paste this link into your podcast player.


Panda Watcher
Menu
Visitor
Data
Video
Live
Panda Watcher is a Deep Learning, Computer Vision, Voice Recognition Based, Cognitive Hardware and Program that Logs People Visiting Your Home, Your Office, or Your Business for You
View Demo
Your Visitor
{% for name in name_List %}
{% endfor %}
I Visit U Most frequently
I VISIT U
{{ max_time }}
TIMES
IN TOTAL
Average Age:
{{ age_Ave }}
Gender Ratio:
{{ gen_Rto }}
Glasses Ratio:
{{ gls_Rto }}