rxjs – Unrecognised javascript syntax

I have come across a particular javascript code while looking into RxJs documentation.

import { of } from 'rxjs';
import { map } from 'rxjs/operators';

map(x => x * x)(of(1, 2, 3)).subscribe((v) => console.log(`value: ${v}`));

I understand what it does but I have not come across this syntax before as far as I remember. Which syntax is this?

air travel – What is the official Flight ID syntax for a IATA-formatted flight code? With space or without?

Is there any official source that tells if “with” or “without space” should be used one instead of the other, or if they both are officially accepted, when should one be used and when the other?

It’s a good question, because I have the same question. The short answer, is IATA seems to be inconsistent on the issue. It doesn’t give a lot of examples, but in some cases it’s no space, some cases it is a space. I spent some time leafing through the IATA Passenger Service Conferences Manual and the IATA Ticketing Handbook, as a person does on a Friday night, and I did not find a definitive preference or declaration.

These documents are in copyright and regrettably I cannot provide references.

IATA tends to treat the carrier, or airline designator, as a separate field to the flight number. Thus on forms and in tables, they are shown separately. In running text, IATA usually writes a flight designator with a non-breaking space between the airline designator and the flight number.

The exceptions I find are examples of monospaced printed information or display screens where sometimes (but not universally) the airline designator and flight number appear unseparated.

I tried to find out if there was an official practice. The best I could find was Resolution 761, “Flight Numbers”, which looked promising …


  1. A flight number shall contain up to four (4) digits (to be prefixed by a two-character or three-letter airline designator) …

Regrettably, no word on spacing.

  1. For Schedule Exchange purposes only, the format of flight numbers may be as prescribed by the Standard Schedules Information Manual (SSIM) (see Recommended Practice 1761b) …

It turns out that IATA Recommended Practice 1761b, first adopted July 1972, simply recommends that member airlines use the IATA Standard Schedules Information Manual when exchanging airline schedule information with each other. The SSIM is also silent on the issue, but its examples always have the flight designator without space. That said, the document intends to describe electronic distribution, and if you know the format in advance, the space is just an extra byte which is just cost.

If we focus on 2-letter IATA flight codes (discard 3-letter ICAO for this question)

IATA resolved (Resolution 001pg) at the 1994 passenger services conference that three-letter airline designators should be allowed (that’s specifically three letters, not two characters like for the existing airline designators). I don’t believe that provision was ever activated, but no doubt a lot of IT consultants made a lot of money preparing for it.

This is important to your question, because in most places where a fixed width airline designator or carrier code is required, IATA sets the field at three characters wide. For two-character airline designators, the third character is a space. Therefore a lot of the time you see two characters in a monospaced output, it could be that the third character is a blank, and not a separator.

I’m doing documentation for travelers and frequently I wonder if I should write “XX nnnn” or “XXnnnn”

The flight designator can also have a letter suffix. This is sometimes used if the same flight number has to be reused on the same day for the same route (which is not allowed), for instance if AB 123 is grounded at an out station and delayed by 14 hours, there could be two AB 123s the next day. One of the flights is usually re-designated AB 123Z, depending on the airline’s practice.

air travel – What us the official Flight ID syntax for a IATA-formatted flight code? With space or without?

If we focus on 2-letter IATA flight codes (discard 3-letter ICAO for this question) we see them half of the times written with space and the other half without space.

I’m doing documentation for travelers and frequently I wonder if I should write “XX nnnn” or “XXnnnn” and why. The company wants to set an “internal standard” but based on something more formal, not just “We like this one”.

Examples with space

It is common to see flight numbers with a space between the airline code and the number itself, like in this Etihad website where it says EY 402 and EY 7750:


or this flight search in FlightStats where you can read WN 417:


Example without space

But it’s also common to see the flight number consisting of non-spaced concatenation, like in this eDreams result, where we can see TK1852 and TK164.


Or in this FlightAware seearch result where we can see both ICAO and IATA codes, the latter being QR8324



Is there any official source that tells if “with” or “without space” should be used one instead of the other, or if they both are officially accepted, when should one be used and when the other?

PD: I have carefully thought if this question should go to https://travel.stackexchange.com or to https://aviation.stackexchange.com but I feel this travel site next to the “travelers side” and the question relates to create documentation, while the other site seems nearer to the cabin crew and technical flight things like aerodynamics, flight-control, propellers and so.

sql – HSQL 2.3.6 outer join syntax

I use HSQL 2.3.6 and I want to make a join with the following syntax :


But in the documentation (most recent of my version of HSQL) http://hsqldb.org/doc/2.0/guide/dataaccess-chapt.html#dac_joined_table the syntax it’s :

<joined table> ::= <cross join> | <qualified join> | <natural join>

<qualified join> ::= <table reference> | ( <join type> ) JOIN <table reference> <join specification>

<join specification> ::= <join condition> | <named columns join>

<join condition> ::= ON <search condition>

<join type> ::= INNER | <outer join type> ( OUTER )

<outer join type> ::= LEFT | RIGHT | FULL

<join column list> ::= <column name list>

With my syntax I have SQLSyntaxErrorException, and I think it’s because my syntax is not compatible.

But not having the documentation for my HSQL’s version, I’m not sure. You confirmed ?

Thank you in advance

syntax – differences between element wise summation and element wise products

I am really new to Julia, and so I am going to ask a very very elementary question. I understand the logic of the dot (.) to make element-wise operation however, I am perplexed by this very simple piece of code

array_try_op = (1, 2, 3, 4)
array_sum2 = array_try_op .+ 2
array_sum2_wrong = array_try_op + 2
array_prod2 = array_try_op .* 2
array_prod2_wrong = array_try_op * 2

Indeed, when I try to perform array_sum2_wrong = array_try_op + 2 I correctly get an error message, but on the contrary array_prod2_wrong = array_try_op * 2 does not return any error message, and actually returns the same result of array_prod2 = array_try_op .* 2

Why this is the case?

Thank you all!

c# – System.Data.SqlClient.SqlException: Incorrect syntax near ‘;’

I cannot for the life of me figure out why I’m getting a:
System.Data.SqlClient.SqlException: Incorrect syntax near ‘;’ error on ExecuteReader comamnd.
This is the command.CommandText statement:

comm.CommandText = "SELECT AcctNumb,TranCode,Code from dbo.tablbfee where Code = @cd";

@cd is defined as:

 var feeb1 = prmt.Controls.Find("Bt3", true)(0);                        
 comm.Parameters.AddWithValue("@cd", feeb1.Text);

I use this exact same code when I find Bt2 and it works fine.
Any ideas?

databases – phpmyadmin error #1064 – error in SQL syntax

I am making a product database, and I am having problems saving the table. Also I am wondering why it is saying MariaDB, on my XAMPP I don’t even have the option for MariaDB. How can I get rid of this error?

This is the error I am getting

composer: Composerise Drupal command syntax and start location

I have 2 sites, a development site and a production site. They need to be converted from the drupal / drupal composer sites to the newer format that allows continuous support for the composer.
The syntax is not clear to me as detailed below. From https://github.com/grasmash/composerize-drupal

The & # 39;composer's rootIt's supposed to be where .git is. Composer is in / home dir, its is a Git directory a .composer (dir) .gitconfig (file) (I always ran the composer from the terminal / opt / lampp / htdocs / d8 / web directory)

So is composer-root =. / Home?

The Drupal development site is located at / opt / lampp / htdocs / d8 / web, where the index.php, composer.json, composer.lock, update.php files are located in the web directory. This is where I ran composer previously.

So is it –drupal-root =. / Opt / lampp / htdocs / d8 / web?

And I run the command from / opt / lampp / htdocs / d8 / web like I did before?

If correct: composer composerize-drupal –composer-root =. / Home –drupal-root =. / Opt / lampp / htdocs / d8 / web –no-update

Thank you very much for the suggestions!

Regarding Python syntax error

t = pandas.series ((1 2 3))
Why is there a syntax error in this?
I tried
t = np.array ((1 2 3)) and results in an array.
I can't create an array in Python. Please give me the solution.

parsers: abstract syntax tree: expression-> operation-> lhs | rhs vs expression-> lhs | operation | rhs: what should i consider in the decision?

I am trying to build a class hierarchy for the First Order Logic abstract syntax tree as specified in the grammar https://github.com/antlr/grammars-v4/blob/master/fol/fol.g4 (generator ANTLR parser).

I have 2 options for the class hierarchy:

Variant expression->lhs|operation|rhs It has constructors (whose arguments are assigned to the attributes of the instance; I'm not specifying it anymore, it's obvious):

FOLFormula(FOLFormula lhs, FOLOperation operation, FOLFormula rhs); //FOLFormula has several other constructors
FOLOperationt(); //instances can be: or, and, implication, biconditional

Variant expression->operation->lhs|rhs has constructors:

FOLFormula(FOLOperation operation); //FOLFormula has several other consturctors
FOLOperation(FOLFormula lhs, FOLFormula rhs);

Am I resonating in my decision which hierarchy to choose? From the web examples, which implement calculators, I can see that most prefer expression->lhs|operation|rhs, but I'm concerned about this choice, because it strictly says that the operation is a binary operation, but we know that that binary operation is just a special type of n-ary function for boolean arguments and boolean return type. I have found 2 other arguments why expression->lhs|operation|rhs is preferable (and not the expression->operation->lhs|rhs):

  1. However, all FOL syntax specifications write A&B and so on and no one specifies & and & (A, B), I'm not sure why. Perhaps it is just a readability convention and not the implementation hint;
  2. The mentioned grammar https://github.com/antlr/grammars-v4/blob/master/fol/fol.g4 clearly writes the rule in the format expression->lhs|operation|rhs and the parser … The condition class for this grammar rule is generated in such a way that it contains (as direct children) both the operation and its arguments (lhs, rhs) and not the 2-level hierarchy. So, I am going to use the visitor pattern for AST generation from parsing, then I should take into account the generated class structure for concrete parsing tree and follow this structure in my AST generation, it may be easier .

Are there other arguments for and against each of the options? Perhaps I am just thinking too much about the decision for which the academic community has already established a decision and best practices?