feat: arrays and type system consolidation

[aljazerzen]

This PR contains many small changes mostly in the frontend of the compiler:

• parsing arrays
• use arrays in the type system
• refactor: Ty::Function -> TypeExpr::Function
• refactor Ty -> TyKind
• refactor minor AST
• refactor TyKind::Infer -> None
• ty name
• refactor TyKind::Table -> Expr.lineage
• refactor TyExpr -> TyKind
• refactor ExprKind::Type -> ExprKind::Set
• refactor std.table -> std.relation
• make relation literal an array of lists
• revert ExprKind::Set -> ExprKind::Type
• array constants to relation literals

I've added a non-breaking syntax for arrays:

let a ={1,2,3}

They cannot be directly translated into SQL, but are used in the type system a lot (they are used to implement relations).

I've refactored the data structure that tracks how a relation is manipulated and renamed it from "Frame" into "Lineage".

And I've made sure that relations are actually just arrays of tuples:

let row1 =[a =5, b = false]let row2 =[a =6, b = true]let my_relation ={row1, row2}my_relation | filter b == true

... which make great one-liners for constructing relations on-the-fly:

{[a =5, b = false],[a =6, b = true]}filter b == true

Ref #2124#1965

Closes#1787

Closes#286

[aljazerzen]

Note: to actually translate arrays into SQL, we'd want to have wildly different implementations of common array-handling-operations for different dialects. I don't think we have proper infrastructure to do this now, we want wait for compiler to understand representations.

[max-sixty]

Awesome velocity of changes!

My concern with the {} syntax for arrays is how we would represent a struct / record type?

I do think this is a sticking point; there some chance we end up in a totally different place to other languages because of initial decisions.

(I'm responding quickly because of the pace here, but I'll look later for previous comments on this; I remember there being no easy answer)

[max-sixty]

{[a =5, b = false],[a =6, b = true]}filter b == true

This is really awesome, great work. Better than the from_text imo!

[aljazerzen]

My concern with the {} syntax for arrays is how we would represent a struct / record type?

We already use [] for a struct / record type - which we currently name list :D

[max-sixty]

Docs at #2605

[aljazerzen]

This PR contains many small changes mostly in the frontend of the compiler:

• parsing arrays
• use arrays in the type system
• refactor: Ty::Function -> TypeExpr::Function
• refactor Ty -> TyKind
• refactor minor AST
• refactor TyKind::Infer -> None
• ty name
• refactor TyKind::Table -> Expr.lineage
• refactor TyExpr -> TyKind
• refactor ExprKind::Type -> ExprKind::Set
• refactor std.table -> std.relation
• make relation literal an array of lists
• revert ExprKind::Set -> ExprKind::Type
• array constants to relation literals

I've added a non-breaking syntax for arrays:

let a ={1,2,3}

They cannot be directly translated into SQL, but are used in the type system a lot (they are used to implement relations).

I've refactored the data structure that tracks how a relation is manipulated and renamed it from "Frame" into "Lineage".

And I've made sure that relations are actually just arrays of tuples:

let row1 =[a =5, b = false]let row2 =[a =6, b = true]let my_relation ={row1, row2}my_relation | filter b == true

... which make great one-liners for constructing relations on-the-fly:

{[a =5, b = false],[a =6, b = true]}filter b == true

Ref #2124#1965

Closes#1787

Closes#286

[aljazerzen]

Note: to actually translate arrays into SQL, we'd want to have wildly different implementations of common array-handling-operations for different dialects. I don't think we have proper infrastructure to do this now, we want wait for compiler to understand representations.

[max-sixty]

Awesome velocity of changes!

My concern with the {} syntax for arrays is how we would represent a struct / record type?

I do think this is a sticking point; there some chance we end up in a totally different place to other languages because of initial decisions.

(I'm responding quickly because of the pace here, but I'll look later for previous comments on this; I remember there being no easy answer)

[max-sixty]

{[a =5, b = false],[a =6, b = true]}filter b == true

This is really awesome, great work. Better than the from_text imo!

[aljazerzen]

My concern with the {} syntax for arrays is how we would represent a struct / record type?

We already use [] for a struct / record type - which we currently name list :D

[max-sixty]

Docs at #2605

[aljazerzen]

This PR contains many small changes mostly in the frontend of the compiler:

• parsing arrays
• use arrays in the type system
• refactor: Ty::Function -> TypeExpr::Function
• refactor Ty -> TyKind
• refactor minor AST
• refactor TyKind::Infer -> None
• ty name
• refactor TyKind::Table -> Expr.lineage
• refactor TyExpr -> TyKind
• refactor ExprKind::Type -> ExprKind::Set
• refactor std.table -> std.relation
• make relation literal an array of lists
• revert ExprKind::Set -> ExprKind::Type
• array constants to relation literals

I've added a non-breaking syntax for arrays:

let a ={1,2,3}

They cannot be directly translated into SQL, but are used in the type system a lot (they are used to implement relations).

I've refactored the data structure that tracks how a relation is manipulated and renamed it from "Frame" into "Lineage".

And I've made sure that relations are actually just arrays of tuples:

let row1 =[a =5, b = false]let row2 =[a =6, b = true]let my_relation ={row1, row2}my_relation | filter b == true

... which make great one-liners for constructing relations on-the-fly:

{[a =5, b = false],[a =6, b = true]}filter b == true

Ref #2124#1965

Closes#1787

Closes#286

[aljazerzen]

Note: to actually translate arrays into SQL, we'd want to have wildly different implementations of common array-handling-operations for different dialects. I don't think we have proper infrastructure to do this now, we want wait for compiler to understand representations.

[max-sixty]

Awesome velocity of changes!

My concern with the {} syntax for arrays is how we would represent a struct / record type?

I do think this is a sticking point; there some chance we end up in a totally different place to other languages because of initial decisions.

(I'm responding quickly because of the pace here, but I'll look later for previous comments on this; I remember there being no easy answer)

[max-sixty]

{[a =5, b = false],[a =6, b = true]}filter b == true

This is really awesome, great work. Better than the from_text imo!

[aljazerzen]

My concern with the {} syntax for arrays is how we would represent a struct / record type?

We already use [] for a struct / record type - which we currently name list :D

[max-sixty]

Docs at #2605

[aljazerzen]

This PR contains many small changes mostly in the frontend of the compiler:

• parsing arrays
• use arrays in the type system
• refactor: Ty::Function -> TypeExpr::Function
• refactor Ty -> TyKind
• refactor minor AST
• refactor TyKind::Infer -> None
• ty name
• refactor TyKind::Table -> Expr.lineage
• refactor TyExpr -> TyKind
• refactor ExprKind::Type -> ExprKind::Set
• refactor std.table -> std.relation
• make relation literal an array of lists
• revert ExprKind::Set -> ExprKind::Type
• array constants to relation literals

I've added a non-breaking syntax for arrays:

let a ={1,2,3}

They cannot be directly translated into SQL, but are used in the type system a lot (they are used to implement relations).

I've refactored the data structure that tracks how a relation is manipulated and renamed it from "Frame" into "Lineage".

And I've made sure that relations are actually just arrays of tuples:

let row1 =[a =5, b = false]let row2 =[a =6, b = true]let my_relation ={row1, row2}my_relation | filter b == true

... which make great one-liners for constructing relations on-the-fly:

{[a =5, b = false],[a =6, b = true]}filter b == true

Ref #2124#1965

Closes#1787

Closes#286

[aljazerzen]

Note: to actually translate arrays into SQL, we'd want to have wildly different implementations of common array-handling-operations for different dialects. I don't think we have proper infrastructure to do this now, we want wait for compiler to understand representations.

[max-sixty]

Awesome velocity of changes!

My concern with the {} syntax for arrays is how we would represent a struct / record type?

I do think this is a sticking point; there some chance we end up in a totally different place to other languages because of initial decisions.

(I'm responding quickly because of the pace here, but I'll look later for previous comments on this; I remember there being no easy answer)

[max-sixty]

{[a =5, b = false],[a =6, b = true]}filter b == true

This is really awesome, great work. Better than the from_text imo!

[aljazerzen]

My concern with the {} syntax for arrays is how we would represent a struct / record type?

We already use [] for a struct / record type - which we currently name list :D

[max-sixty]

Docs at #2605

[aljazerzen]

This PR contains many small changes mostly in the frontend of the compiler:

• parsing arrays
• use arrays in the type system
• refactor: Ty::Function -> TypeExpr::Function
• refactor Ty -> TyKind
• refactor minor AST
• refactor TyKind::Infer -> None
• ty name
• refactor TyKind::Table -> Expr.lineage
• refactor TyExpr -> TyKind
• refactor ExprKind::Type -> ExprKind::Set
• refactor std.table -> std.relation
• make relation literal an array of lists
• revert ExprKind::Set -> ExprKind::Type
• array constants to relation literals

I've added a non-breaking syntax for arrays:

let a ={1,2,3}

They cannot be directly translated into SQL, but are used in the type system a lot (they are used to implement relations).

I've refactored the data structure that tracks how a relation is manipulated and renamed it from "Frame" into "Lineage".

And I've made sure that relations are actually just arrays of tuples:

let row1 =[a =5, b = false]let row2 =[a =6, b = true]let my_relation ={row1, row2}my_relation | filter b == true

... which make great one-liners for constructing relations on-the-fly:

{[a =5, b = false],[a =6, b = true]}filter b == true

Ref #2124#1965

Closes#1787

Closes#286

[aljazerzen]

Note: to actually translate arrays into SQL, we'd want to have wildly different implementations of common array-handling-operations for different dialects. I don't think we have proper infrastructure to do this now, we want wait for compiler to understand representations.

[max-sixty]

Awesome velocity of changes!

My concern with the {} syntax for arrays is how we would represent a struct / record type?

I do think this is a sticking point; there some chance we end up in a totally different place to other languages because of initial decisions.

(I'm responding quickly because of the pace here, but I'll look later for previous comments on this; I remember there being no easy answer)

[max-sixty]

{[a =5, b = false],[a =6, b = true]}filter b == true

This is really awesome, great work. Better than the from_text imo!

[aljazerzen]

My concern with the {} syntax for arrays is how we would represent a struct / record type?

We already use [] for a struct / record type - which we currently name list :D

[max-sixty]

Docs at #2605

[aljazerzen]

This PR contains many small changes mostly in the frontend of the compiler:

• parsing arrays
• use arrays in the type system
• refactor: Ty::Function -> TypeExpr::Function
• refactor Ty -> TyKind
• refactor minor AST
• refactor TyKind::Infer -> None
• ty name
• refactor TyKind::Table -> Expr.lineage
• refactor TyExpr -> TyKind
• refactor ExprKind::Type -> ExprKind::Set
• refactor std.table -> std.relation
• make relation literal an array of lists
• revert ExprKind::Set -> ExprKind::Type
• array constants to relation literals

I've added a non-breaking syntax for arrays:

let a ={1,2,3}

They cannot be directly translated into SQL, but are used in the type system a lot (they are used to implement relations).

I've refactored the data structure that tracks how a relation is manipulated and renamed it from "Frame" into "Lineage".

And I've made sure that relations are actually just arrays of tuples:

let row1 =[a =5, b = false]let row2 =[a =6, b = true]let my_relation ={row1, row2}my_relation | filter b == true

... which make great one-liners for constructing relations on-the-fly:

{[a =5, b = false],[a =6, b = true]}filter b == true

Ref #2124#1965

Closes#1787

Closes#286

[aljazerzen]

Note: to actually translate arrays into SQL, we'd want to have wildly different implementations of common array-handling-operations for different dialects. I don't think we have proper infrastructure to do this now, we want wait for compiler to understand representations.

[max-sixty]

Awesome velocity of changes!

My concern with the {} syntax for arrays is how we would represent a struct / record type?

I do think this is a sticking point; there some chance we end up in a totally different place to other languages because of initial decisions.

(I'm responding quickly because of the pace here, but I'll look later for previous comments on this; I remember there being no easy answer)

[max-sixty]

{[a =5, b = false],[a =6, b = true]}filter b == true

This is really awesome, great work. Better than the from_text imo!

[aljazerzen]

My concern with the {} syntax for arrays is how we would represent a struct / record type?

We already use [] for a struct / record type - which we currently name list :D

[max-sixty]

Docs at #2605

[aljazerzen]

This PR contains many small changes mostly in the frontend of the compiler:

• parsing arrays
• use arrays in the type system
• refactor: Ty::Function -> TypeExpr::Function
• refactor Ty -> TyKind
• refactor minor AST
• refactor TyKind::Infer -> None
• ty name
• refactor TyKind::Table -> Expr.lineage
• refactor TyExpr -> TyKind
• refactor ExprKind::Type -> ExprKind::Set
• refactor std.table -> std.relation
• make relation literal an array of lists
• revert ExprKind::Set -> ExprKind::Type
• array constants to relation literals

I've added a non-breaking syntax for arrays:

let a ={1,2,3}

They cannot be directly translated into SQL, but are used in the type system a lot (they are used to implement relations).

I've refactored the data structure that tracks how a relation is manipulated and renamed it from "Frame" into "Lineage".

And I've made sure that relations are actually just arrays of tuples:

let row1 =[a =5, b = false]let row2 =[a =6, b = true]let my_relation ={row1, row2}my_relation | filter b == true

... which make great one-liners for constructing relations on-the-fly:

{[a =5, b = false],[a =6, b = true]}filter b == true

Ref #2124#1965

Closes#1787

Closes#286

[aljazerzen]

Note: to actually translate arrays into SQL, we'd want to have wildly different implementations of common array-handling-operations for different dialects. I don't think we have proper infrastructure to do this now, we want wait for compiler to understand representations.

[max-sixty]

Awesome velocity of changes!

My concern with the {} syntax for arrays is how we would represent a struct / record type?

I do think this is a sticking point; there some chance we end up in a totally different place to other languages because of initial decisions.

(I'm responding quickly because of the pace here, but I'll look later for previous comments on this; I remember there being no easy answer)

[max-sixty]

{[a =5, b = false],[a =6, b = true]}filter b == true

This is really awesome, great work. Better than the from_text imo!

[aljazerzen]

My concern with the {} syntax for arrays is how we would represent a struct / record type?

We already use [] for a struct / record type - which we currently name list :D

[max-sixty]

Docs at #2605

[aljazerzen]

This PR contains many small changes mostly in the frontend of the compiler:

• parsing arrays
• use arrays in the type system
• refactor: Ty::Function -> TypeExpr::Function
• refactor Ty -> TyKind
• refactor minor AST
• refactor TyKind::Infer -> None
• ty name
• refactor TyKind::Table -> Expr.lineage
• refactor TyExpr -> TyKind
• refactor ExprKind::Type -> ExprKind::Set
• refactor std.table -> std.relation
• make relation literal an array of lists
• revert ExprKind::Set -> ExprKind::Type
• array constants to relation literals

I've added a non-breaking syntax for arrays:

let a ={1,2,3}

They cannot be directly translated into SQL, but are used in the type system a lot (they are used to implement relations).

I've refactored the data structure that tracks how a relation is manipulated and renamed it from "Frame" into "Lineage".

And I've made sure that relations are actually just arrays of tuples:

let row1 =[a =5, b = false]let row2 =[a =6, b = true]let my_relation ={row1, row2}my_relation | filter b == true

... which make great one-liners for constructing relations on-the-fly:

{[a =5, b = false],[a =6, b = true]}filter b == true

Ref #2124#1965

Closes#1787

Closes#286

[aljazerzen]

Note: to actually translate arrays into SQL, we'd want to have wildly different implementations of common array-handling-operations for different dialects. I don't think we have proper infrastructure to do this now, we want wait for compiler to understand representations.

[max-sixty]

Awesome velocity of changes!

My concern with the {} syntax for arrays is how we would represent a struct / record type?

I do think this is a sticking point; there some chance we end up in a totally different place to other languages because of initial decisions.

(I'm responding quickly because of the pace here, but I'll look later for previous comments on this; I remember there being no easy answer)

[max-sixty]

{[a =5, b = false],[a =6, b = true]}filter b == true

This is really awesome, great work. Better than the from_text imo!

[aljazerzen]

My concern with the {} syntax for arrays is how we would represent a struct / record type?

We already use [] for a struct / record type - which we currently name list :D

[max-sixty]

Docs at #2605