What makes it permissible to use `declare const foo = 3` in TypeScript?

Question

What makes it permissible to use `declare const foo = 3` in TypeScript?

As I was working on creating a TypeScript declaration file, I discovered that it is permissible to declare a constant and assign a value to it.

declare const foo = 1;        // This is considered valid
declare const bar = 'b';      // This is also acceptable
declare const baz = () => {}; // ERROR: A 'const' initializer in an ambient context must be a string or numeric literal.

declare var foo1 = 1;      // ERROR: Initializers are not allowed in ambient contexts.
declare let bar1 = 2;      // ERROR: Initializers are not allowed in ambient contexts.
declare function baz1() {} // ERROR: An implementation cannot be declared in ambient contexts.

In my opinion, it seems questionable to allow assigning a value in a declare statement.

I understand that in the const statement, the type of foo can be inferred as 1. However, wouldn't declare const foo: 1 be a more appropriate declaration?

What could be the reason behind TypeScript permitting declare const to have an assigned value?

typescript

Answer 1

Answer №1

The reason behind the current behavior may not be explicitly stated in the official documentation, but based on my interpretation, it seems like a bug in the compiler. According to the spec, the assignment should not be possible.

declare with a variable, you are essentially informing the compiler that a symbol with that name exists without providing the actual implementation. The declaration itself does not emit anything.

In most cases of using declare, a type is also specified. In situations where literal values like numbers or strings are used, the compiler can infer the type of the symbol. Otherwise, the value provided has no impact.

It would have been less confusing if assignments were disallowed. In an ambient context, you're simply giving details about symbols and types that should be accessible.

As for why certain scenarios do not work:


baz - trying to assign a non-constant value to a declared variable
foo1, bar1 - attempting to assign non-constant values to variables that are not constants
baz1 - declaring a function with an implementation (which does nothing). To declare a function, the syntax must include only the function signature, a "prototype"

declare function baz(): void; // function baz returns void

Answer 2

The reason behind the current behavior may not be explicitly stated in the official documentation, but based on my interpretation, it seems like a bug in the compiler. According to the spec, the assignment should not be possible.

declare with a variable, you are essentially informing the compiler that a symbol with that name exists without providing the actual implementation. The declaration itself does not emit anything.

In most cases of using declare, a type is also specified. In situations where literal values like numbers or strings are used, the compiler can infer the type of the symbol. Otherwise, the value provided has no impact.

It would have been less confusing if assignments were disallowed. In an ambient context, you're simply giving details about symbols and types that should be accessible.

As for why certain scenarios do not work:


baz - trying to assign a non-constant value to a declared variable
foo1, bar1 - attempting to assign non-constant values to variables that are not constants
baz1 - declaring a function with an implementation (which does nothing). To declare a function, the syntax must include only the function signature, a "prototype"

declare function baz(): void; // function baz returns void

Answer 3

Answer №2

To start, establish the accept variable value based on the information found at https://www.typescriptlang.org/docs/handbook/declaration-merging.html

Next, it's important to clarify that :1 defines the type of foo, not its value. This means you cannot simply assign 1 to foo without first defining its type as such.

I hope this explanation clears things up for you.

Answer 4

To start, establish the accept variable value based on the information found at https://www.typescriptlang.org/docs/handbook/declaration-merging.html

Next, it's important to clarify that :1 defines the type of foo, not its value. This means you cannot simply assign 1 to foo without first defining its type as such.

I hope this explanation clears things up for you.

What makes it permissible to use `declare const foo = 3` in TypeScript?

Answer №1

Answer №2

Similar questions

JavaScript for Office Spreadsheet Titles

Enhance React component props for a styled component element using TypeScript

TypeScript - Using all interface keys as a custom type

Create a mechanism in the API to ensure that only positive values greater than or equal to 0 are accepted

Guide for the synchronous loading of a React Provider component pattern

generate an object with the forEach method

How to stop a method in Angular2 when a specific response is received?

Cannot display data in template

Ways to develop a dynamic Promise-returning Function

Retrieving key values from an interface using Typescript

Using React Native with TypeScript to Select the Parent and Child Checkboxes within a FlatList

Sorting List Algorithm

Has the antd Form.create() method been substituted with something else?

Struggling to retrieve dataset from Bootstrap 5 form while using Angular

Require assistance with transforming a JSON string into an object

What is the solution for handling the error 'Mismatch between argument types and parameters' in TypeScript while using React Navigation?

Using TypeScript: creating functions without defining an interface

Struggling with "Content" not being recognized in Typescript PouchDB transpilation errors?

Using object bracket notation in TypeScript to retrieve values from props with the help of string interpolation

What is the proper classification for me to choose?