Fable.Core

Numbers that are not represented with JS native number type

Each Position object consists of a line number (1-indexed) and a column number (0-indexed):

An export batch declaration, e.g., export * from "mod";.

An export default declaration, e.g., export default function () {}; or export default 1;.

An export named declaration, e.g., export {foo, bar};, export {foo} from "mod"; or export var foo = 1;. Note: Having declaration populated with non-empty specifiers or non-null source results in an invalid state.

An exported variable binding, e.g., {foo} in export {foo} or {bar as foo} in export {bar as foo}. The exported field refers to the name exported in the module. The local field refers to the binding into the local module scope. If it is a basic named export, such as in export {foo}, both exported and local are equivalent Identifier nodes; in this case an Identifier node representing foo. If it is an aliased export, such as in export {bar as foo}, the exported field is an Identifier node representing foo, and the local field is an Identifier node representing bar.

e.g., import foo from "mod";.

A namespace import specifier, e.g., * as foo in import * as foo from "mod".

A default import specifier, e.g., foo in import foo from "mod".

An imported variable binding, e.g., {foo} in import {foo} from "mod" or {foo as bar} in import {foo as bar} from "mod". The imported field refers to the name of the export imported from the module. The local field refers to the binding imported into the local module scope. If it is a basic named import, such as in import {foo} from "mod", both imported and local are equivalent Identifier nodes; in this case an Identifier node representing foo. If it is an aliased import, such as in import {foo as bar} from "mod", the imported field is an Identifier node representing foo, and the local field is an Identifier node representing bar.

A specifier in an import or export declaration.

Anonymous class: e.g., var myClass = class { }

ES Class Fields & Static Properties https://github.com/jeffmo/es-class-fields-and-static-properties e.g, class MyClass { static myStaticProp = 5; myProp /* = 10 */; }

A comma-separated sequence of expressions.

A function or method call expression.

A conditional expression, i.e., a ternary ?/: expression.

If computed is true, the node corresponds to a computed (a[b]) member expression and property is an Expression. If computed is false, the node corresponds to a static (a.b) member expression and property is an Identifier.

e.g., var z = { x: 1, ...y } // Copy all properties from y

Delegates to another generator? (yield*)

e.g., x = do { var t = f(); t * t + 1 }; http://wiki.ecmascript.org/doku.php?id=strawman:do_expressions Doesn't seem to work well with block-scoped variables (let, const)

A fat arrow function expression, e.g., let foo = (bar) => { /* body */ }.

A super pseudo-expression.

A function declaration. Note that id cannot be null.

When passing a VariableDeclaration, the bound value must go through the `right` parameter instead of `init` property in VariableDeclarator

If handler is null then finalizer must be a BlockStatement.

A catch clause following a try block.

A case (if test is an Expression) or default (if test === null) clause in the body of a switch statement.

Contineu can optionally take a label of a loop to continuue

Break can optionally take a label of a loop to break

Statement (typically loop) prefixed with a label (for continuue and break)

An empty statement, i.e., a solitary semicolon.

A block statement, i.e., a sequence of statements surrounded by braces.

An expression statement, i.e., a statement consisting of a single expression.

A complete program source tree. Parsers must specify sourceType as "module" if the source has been parsed as an ES6 module. Otherwise, sourceType must be "script".

e.g. "use strict";

Note that an identifier may be an expression or a destructuring pattern.

Not in Babel specs, disguised as StringLiteral

Placeholder, doesn't belong to Babel specs

A module import or export declaration.

Note that declarations are considered statements; this is because declarations can appear in any statement context.

Since the left-hand side of an assignment may be any expression in general, an expression can also be a pattern.

The type field is a string representing the AST variant type. Each subtype of Node is documented below with the specific string of its type field. You can use this field to determine which interface a node implements. The loc field represents the source location information of the node. If the node contains no information about the source location, the field is null; otherwise it is an object consisting of a start position (the position of the first character of the parsed source region) and an end position (the position of the first character after the parsed source region):

If the method accepts a lambda as first argument, indicates its arity

Sometimes Fable.Type may differ from original F# name (e.g. System.Object -> Fable.Any). This field keeps the original name.

Module members are also declared as variables, so they need a private name that doesn't conflict with enclosing scope (see #130)

Finds decorator by full name

Finds decorator by name

isArrow: Arrow functions capture the enclosing `this` in JS

Helper when we need to compare the types of the arguments applied to a method (concrete) with the declared argument types for that method (may be generic) (e.g. when resolving a TraitCall)

Checks if an F# let binding is being applied and applies arguments as for a curried function

Ignores relative imports (e.g. `[<Import("foo","./lib.js")>]`)

DO NOT USE: Internal type for Fable dynamic operations

Function calls will be replaced by inlined JS code. More info: http://fable.io/docs/interacting.html#Import-attribute

Used for erased union types and to ignore modules in JS compilation. More info: http://fable.io/docs/interacting.html#Erase-attribute

The module, type, function... is globally accessible in JS. More info: http://fable.io/docs/interacting.html#Import-attribute

References to the module, type, function... will be replaced by import statements. Use `[<Import("default", "my-package")>] to import the default member. Use `[<Import("*", "my-package")>] to import the whole package. More info: http://fable.io/docs/interacting.html#Import-attribute

Compile union case lists as JS object literals. More info: http://fable.io/docs/interacting.html#KeyValueList-attribute

[EXPERIMENTAL] Record updates will be compiled as mutations: { x with a = 5 } Fable will fail if the original value is used after being updated or passed to a function. More info: http://fable.io/docs/interacting.html#MutatingUpdate-attribute

When this is attached to a method, Fable will add the generic info as an extra argument to every call, making it possible to access a type 'T with `typeof<'T>` within the method body

Compile a record as a JS object literals. More info: http://fable.io/docs/interacting.html

Compile union types as string literals. More info: http://fable.io/docs/interacting.html#StringEnum-attribute

Erased union type to represent one of two possible values. More info: http://fable.io/docs/interacting.html#Erase-attribute

Erased union type to represent one of three possible values. More info: http://fable.io/docs/interacting.html#Erase-attribute

Erased union type to represent one of four possible values. More info: http://fable.io/docs/interacting.html#Erase-attribute

Erased union type to represent one of five possible values. More info: http://fable.io/docs/interacting.html#Erase-attribute

Erased union type to represent one of six possible values. More info: http://fable.io/docs/interacting.html#Erase-attribute

Used to indicate that a member is only implemented in native Javascript

Same as `System.Func<'Arg1,'Arg2,'Arg3,'Arg4,'Arg5,'Arg6,'Out>`

Same as `System.Func<'Arg1,'Arg2,'Arg3,'Arg4,'Arg5,'Out>`

Same as `System.Func<'Arg1,'Arg2,'Arg3,'Arg4,'Out>`

Same as `System.Func<'Arg1,'Arg2,'Arg3,'Out>`

Same as `System.Func<'Arg1,'Arg2,'Out>`

Same as `System.Func<'Arg1,'Out>`

Same as `System.Func<unit,'Out>`

Use it to cast dynamic functions coming from JS. If you know the argument and return types, use `System.Func<>` instead. If you need a constructor (must be applied with `new` keyword), use `JsConstructor`. ## Sample let f: JsFunc = import "myFunction" "./myLib" f.Invoke(5, "bar")

Use it when importing a constructor from a JS library.

Compiles to JS `this` keyword. Can only be used within a delegate. ## Sample let fn = JsFunc2(fun x y -> jsThis?add(x, y))

Converts a plain JS object (POJO) to an instance of the specified type. This is only intended if you're using a custom serialization method (that must produce same objects as `toJson`) instead of `ofJson`.

Instantiate F# objects from JSON containing $type info

Serialize F# objects to JSON adding $type info

Instantiate F# objects from JSON

Serialize F# objects to JSON

Convert F# unions, records and classes into plain JS objects DEPRECATED: Use a Pojo record or union

F#: let myLib = importAll<obj> "myLib" JS: import * as myLib from "myLib"

F#: let defaultMember = importDefault<unit->obj> "myModule" JS: import defaultMember from "myModule"

F#: let myMember = importMember<string> "myModule" JS: import { myMember } from "myModule" Note the import must be immediately assigned to a value in a let binding

Works like `ImportAttribute` (same semantics as ES6 imports). You can use "*" or "default" selectors.

Create an empty JS object: {}

Create a literal JS object from a collection of key-value tuples. E.g. `createObj [ "a" ==> 5 ]` in JS becomes `{ a: 5 }`

Destructure and apply a tuple to an arbitrary value with `new` keyword. E.g. `createNew myCons (arg1, arg2)` in JS becomes `new myCons(arg1, arg2)`

Upcast the right operand to obj and create a key-value tuple. Mostly convenient when used with `createObj`. E.g. `createObj [ "a" ==> 5 ]` in JS becomes `{ a: 5 }`

Destructure and apply a tuple to an arbitrary value. E.g. `myFn $ (arg1, arg2)` in JS becomes `myFn(arg1, arg2)`

Dynamically assign a value to a property of an arbitrary object. `myObj?propA <- 5` in JS becomes `myObj.propA = 5` `myObj?(propA) <- 5` in JS becomes `myObj[propA] = 5`

Dynamically access a property of an arbitrary object. `myObj?propA` in JS becomes `myObj.propA` `myObj?(propA)` in JS becomes `myObj[propA]`

Has same effect as `unbox` (dynamic casting erased in compiled JS code). The casted type can be defined on the call site: `!!myObj?bar(5): float`

Matches placeholders for generics in an Emit macro like `React.createElement($'T, $0, $1)`

Methods automatically assigned by the F# compiler for unions and records. Ignored by Fable.

Interfaces automatically assigned by the F# compiler to unions and records. Ignored by Fable.

Calls to methods of these interfaces will be replaced

This is null to keep compatibility with Require.js (which expects paths not to have extensions), in the future this will probably be changed to ".js"

Creates a relative path from one file or folder to another.