Language Integrated Query in Rust (created by declarative macros).
- Inspired by LINQ in .NET.
- What's LINQ
This project is under development! API might be changed.
This is an example:
use linq::linq;
use linq::Queryable;
fn try_linq_methods() {
let x = 1..100;
let mut y: Vec<i32> = x.clone().filter(|p| p <= &5).collect();
y.sort_by_key(|t| -t);
let y: Vec<i32> = y.into_iter().map(|t| t * 2).collect();
let e: Vec<i32> = x
.clone()
.where_by(|p| p <= &5)
.order_by(|p| -p)
.select(|p| p * 2)
.collect();
assert_eq!(e, y);
}
fn try_linq_expr() {
let x = 1..100;
let mut y: Vec<i32> = x.clone().filter(|p| p <= &5).collect();
y.sort_by_key(|t| -t);
let y: Vec<i32> = y.into_iter().map(|t| t * 2).collect();
let e: Vec<i32> =
linq!(from p in x.clone(), where p <= &5, orderby -p, select p * 2).collect();
assert_eq!(e, y);
}
If you are familier with LINQ in C#, you will find this is easy to use.
The two imports is necessary:
use linq::linq; // for `linq!` macro
use linq::iter::Enumerable; // for LINQ methods and `linq!` macro
The trait linq::Queryable
supports LINQ methods on Iterator
. You can find the correspondences below.
- Normal items mean they are builtin methods of
Iterator
in std. - Bold items mean they are implemented in this project. You can find them in module
linq::iter
(but they are private so that you can't import them). - Italic items mean they are not in roadmap. Happy for your suggestions.
- where => where_by => filter
- select => map
- select_many => select_many_single, select_many
- skip
- skip_while
- take
- take_while
- join
- group_join
- concate => chain
- order_by
- order_by_descending
- then_by
- then_by_descending
- reverse => rev
- group_by
- distinct
- union
- intersect
- except
- first => next
- single
- element_at => nth
- all
- any
- contains
- count
- sum
- product
- min
- max
- average
- aggregate => fold
The query expression begins with from
clause and ends with select
clause. Use ,
to seperate every clause.
linq!(from x in coll, select x)
Now we supports these keywords:
- from
- from (
select_many_single
) - zfrom (
select_many
)
- from (
- in
- select
- where
- orderby
- descending
- group_by
- more...
from <id> in <iter expr>,
Also you can enumerate elements of each set in the collection (Attention: for this type, you can't access the value that is in the first from
clause in select
clause):
let x = 1..5;
let y = vec![0, 0, 1, 0, 1, 2, 0, 1, 2, 3];
let e: Vec<i32> = linq!(from p in x.clone(), from t in 0..p, select t).collect();
assert_eq!(e, y);
If you want to zip or enumerate value-pairs of two sets, use zfrom
for the second from
:
let x = 1..5;
let y = vec![
(1, 0),
(2, 0),
(2, 1),
(3, 0),
(3, 1),
(3, 2),
(4, 0),
(4, 1),
(4, 2),
(4, 3),
];
let e: Vec<_> = linq!(from p in x.clone(), zfrom t in 0..p, select (p,t)).collect();
assert_eq!(e, y);
The expression in zfrom
recieve the cloned value in the first from
,
and the elements in two sets will be cloned for select
clause.
while <expr>,
You can use where
clause in single-from query, and the expression will recieve a variable named the id
in from
clause. The expression need to return a boolean value.
orderby <expr>,
orderby <expr>, descending,
You can use orderby
clause in single-from query. This query will collect the iterator, and sort them by the expression, then return the new iterator.
We need more unit-test samples. If you have any ideas, open issues to tell us.
Since the expression procedural macros is not stable, I only create macros by declarative macros.
$ cargo test