Giter Club home page Giter Club logo

cargo-expand's Introduction

cargo-expand

github crates.io build status

Once installed, the following command prints out the result of macro expansion and #[derive] expansion applied to the current crate.

$ cargo expand

This is a wrapper around the more verbose compiler command:

$ cargo rustc --profile=check -- -Zunpretty=expanded

Installation

Install with cargo install cargo-expand.

This command optionally uses rustfmt to format the expanded output. The resulting code is typically much more readable than what you get from the compiler. If rustfmt is not available, the expanded code is not formatted. Install rustfmt with rustup component add rustfmt.

Cargo expand relies on unstable compiler flags so it requires a nightly toolchain to be installed, though does not require nightly to be the default toolchain or the one with which cargo expand itself is executed. If the default toolchain is one other than nightly, running cargo expand will find and use nightly anyway.

Example

$ cat src/main.rs

#[derive(Debug)]
struct S;

fn main() {
    println!("{:?}", S);
}

$ cargo expand

#![feature(prelude_import)]
#[prelude_import]
use std::prelude::v1::*;
#[macro_use]
extern crate std;
struct S;
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for S {
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        match *self {
            S => {
                let mut debug_trait_builder = f.debug_tuple("S");
                debug_trait_builder.finish()
            }
        }
    }
}
fn main() {
    {
        ::std::io::_print(::core::fmt::Arguments::new_v1(
            &["", "\n"],
            &match (&S,) {
                (arg0,) => [::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Debug::fmt)],
            },
        ));
    };
}

Options

See cargo expand --help for a complete list of options, most of which are consistent with other Cargo subcommands. Here are a few that are common in the context of cargo expand.

To expand a particular test target:

$ cargo expand --test test_something

To expand without rustfmt:

$ cargo expand --ugly

To expand a specific module or type or function only:

$ cargo expand path::to::module

cargo expand punctuated::printing cargo expand token::FatArrow

Configuration

The cargo expand command reads the [expand] section of $CARGO_HOME/config.toml if there is one (usually ~/.cargo/config.toml).

Set the default syntax highlighting theme with the theme setting:

[expand]
theme = "TwoDark"

Run cargo expand --themes to print a list of available themes. Use theme = "none" to disable coloring.

Change the default coloring disposition (normally auto) with the color setting:

[expand]
color = "always"

Enable paging of the output with the pager setting:

[expand]
pager = true

Disclaimer

Be aware that macro expansion to text is a lossy process. This is a debugging aid only. There should be no expectation that the expanded code can be compiled successfully, nor that if it compiles then it behaves the same as the original code.

For instance the following function returns 3 when compiled ordinarily by Rust but the expanded code compiles and returns 4.

fn f() -> i32 {
    let x = 1;

    macro_rules! first_x {
        () => { x }
    }

    let x = 2;

    x + first_x!()
}

Refer to The Book for more on the considerations around macro hygiene.


License

Licensed under either of Apache License, Version 2.0 or MIT license at your option.
Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in this crate by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.

cargo-expand's People

Contributors

ahl avatar alarsyo avatar dependabot[bot] avatar dtolnay avatar ehuss avatar enselic avatar gsquire avatar iptq avatar mlegner avatar noc7c9 avatar tottoto avatar viruscamp avatar

Stargazers

 avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar

Watchers

 avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar

cargo-expand's Issues

Look for a nightly compiler

$ rustup run stable cargo expand >/dev/null

  warning: the option `Z` is unstable and should only be used on the nightly
    compiler, but it is currently accepted for backwards compatibility; this
    will soon change, see issue #31847 for more details
  warning: the option `pretty` is unstable and should only be used on the nightly
    compiler, but it is currently accepted for backwards compatibility; this
    will soon change, see issue #31847 for more details

Let's run rustc --version and rustup run nightly rustc --version and choose the one that provides a nightly compiler.

If neither is nightly, keep the current behavior with warnings.

No error when rustfmt fails

...at least, I think that's the problem.

When running cargo expand on a fairly complex codebase with lots of derives, it does... nothing. That is, it compiles the crate, reports "Finished", then exits (and returns no error).

Manually dumping the expanded code and prettifying, like so:

cargo rustc -- --pretty=expanded -Z unstable-options > expanded.rs
rustfmt expanded.rs

I find that due to some mismatch between syn and libsyntax or something, rustfmt is failing (on valid code) with some parse error, but the error is being swallowed by cargo-expand.

Similarly if I try to run with some dummy test, I get some evidence that cargo-expand is trying to cat a non-existent directory.

cargo expand --test whatever  
error: no test target named `whatever`
cat: /tmp/cargo-expand.1MhZhIEnZTqi/expanded: No such file or directory

It would be nice if cargo-expand recognized and handled these failures gracefully.

Versions:
cargo-expand v0.3.12
cargo 0.26.0-nightly (6a8eb71f6 2018-01-13)
rustc 1.25.0-nightly (4e3901d35 2018-01-23)
rustfmt-nightly v0.3.6

Support non-nightly rustfmt

When someone runs cargo +stable expand, it calls cargo +nightly expand which calls rustfmt. Apparently that only finds rustfmt if the system has a nightly rustfmt. If they have nightly cargo-expand but stable rustfmt, then rustfmt does not get found.

Let's update the logic for invoking rustfmt so that it any rustfmt will work.

cargo expand fails with wasm-bindgen

Would it be possible to present a better error message to user when trying to export wasm-bindgen project?

cargo expand --target wasm32-unknown-unknown
   Compiling proc-macro2 v0.4.30
   Compiling unicode-xid v0.1.0
   Compiling syn v0.15.39
   Compiling wasm-bindgen-shared v0.2.47
   Compiling cfg-if v0.1.9
   Compiling lazy_static v1.3.0
   Compiling bumpalo v2.4.3
   Compiling wasm-bindgen v0.2.47
   Compiling log v0.4.6
   Compiling quote v0.6.12
   Compiling wasm-bindgen-backend v0.2.47
   Compiling wasm-bindgen-macro-support v0.2.47
   Compiling wasm-bindgen-macro v0.2.47
error[E0463]: can’t find crate for `core`
error: aborting due to previous error
For more information about this error, try `rustc --explain E0463`.
error: Could not compile `wasm-bindgen`.
To learn more, run the command again with --verbose.

This was solved by installing the Nightly toolchain:

rustup target add wasm32-unknown-unknown --toolchain nightly

Would it be possible to give a warning, or better error message in this case?

error: Option 'color' given more than once

$ cargo expand --lib rst::document_tree::extra_attributes
    Checking rst v0.2.0 (/home/phil/Dev/Rust/rust-rst)
error: Option 'color' given more than once
error: Could not compile `rst`.
To learn more, run the command again with --verbose.

and indeed, when specifying --verbose I see:

 process didn't exit successfully:
`rustc --edition=2018 --crate-name rst src/lib.rs --color never \
  --crate-type lib --emit=dep-info,metadata -C debuginfo=2 \
  'rst::document_tree::extra_attributes' --color=always -- \
  -o /tmp/cargo-expandbDlv5A/expanded \
  [...]

0.4.10 update

This version exists on crates.io but doesn't seem to have been pushed to github.

Can't find crate for std when compiling i686-unknown-linux-gnu on x86_64 system

i created empty bin project and cargo expand fails on empty project targeting i686-unknown-linux-gnu:

$ cargo expand --target i686-unknown-linux-gnu
    Checking cargo_expand_check v0.1.0 (/home/user/cargo_expand_check)
error[E0463]: can't find crate for `std`
  |
  = note: the `i686-unknown-linux-gnu` target may not be installed
error: aborting due to previous error
For more information about this error, try `rustc --explain E0463`.
error: Could not compile `cargo_expand_check`.
To learn more, run the command again with --verbose.

With verbosity:

$ cargo expand --target i686-unknown-linux-gnu --verbose
     Running `cargo rustc --profile=check --target i686-unknown-linux-gnu --verbose --color always -- -o /tmp/cargo-expandXtN9o0/expanded -Zunstable-options --pretty=expanded`
    Checking cargo_expand_check v0.1.0 (/home/user/cargo_expand_check)
     Running `rustc --edition=2018 --crate-name cargo_expand_check src/main.rs --color always --crate-type bin --emit=dep-info,metadata -C debuginfo=2 -o /tmp/cargo-expandXtN9o0/expanded -Zunstable-options --pretty=expanded -C metadata=4f1aa5936284202a -C extra-filename=-4f1aa5936284202a --out-dir /home/user/cargo_expand_check/target/i686-unknown-linux-gnu/debug/deps --target i686-unknown-linux-gnu -C incremental=/home/user/cargo_expand_check/target/i686-unknown-linux-gnu/debug/incremental -L dependency=/home/user/cargo_expand_check/target/i686-unknown-linux-gnu/debug/deps -L dependency=/home/user/cargo_expand_check/target/debug/deps`
error[E0463]: can't find crate for `std`
  |
  = note: the `i686-unknown-linux-gnu` target may not be installed
error: aborting due to previous error
For more information about this error, try `rustc --explain E0463`.
error: Could not compile `cargo_expand_check`.
Caused by:
  process didn't exit successfully: `rustc --edition=2018 --crate-name cargo_expand_check src/main.rs --color always --crate-type bin --emit=dep-info,metadata -C debuginfo=2 -o /tmp/cargo-expandXtN9o0/expanded -Zunstable-options --pretty=expanded -C metadata=4f1aa5936284202a -C extra-filename=-4f1aa5936284202a --out-dir /home/user/cargo_expand_check/target/i686-unknown-linux-gnu/debug/deps --target i686-unknown-linux-gnu -C incremental=/home/user/cargo_expand_check/target/i686-unknown-linux-gnu/debug/incremental -L dependency=/home/user/cargo_expand_check/target/i686-unknown-linux-gnu/debug/deps -L dependency=/home/user/cargo_expand_check/target/debug/deps` (exit code: 1)

Work for native arch:

$ cargo expand --target x86_64-unknown-linux-gnu
    Checking cargo_expand_check v0.1.0 (/home/sorenel/projects/cargo_expand_check)
    Finished dev [unoptimized + debuginfo] target(s) in 0.10s

#![feature(prelude_import)]
#![no_std]
#[prelude_import]
use ::std::prelude::v1::*;
#[macro_use]
extern crate std as std;
fn main() {
    {
        ::std::io::_print(::std::fmt::Arguments::new_v1(
            &["Hello, world!\n"],
            &match () {
                () => [],
            },
        ));
    };
}

I know, issues are not tech support and I would consider my (rustup?) setup is wrong, but all of cargo commands work:

$ cargo check --target i686-unknown-linux-gnu
    Checking cargo_expand_check v0.1.0 (/home/user/cargo_expand_check)
    Finished dev [unoptimized + debuginfo] target(s) in 0.36s
$ cargo build --target i686-unknown-linux-gnu
   Compiling cargo_expand_check v0.1.0 (/home/user/cargo_expand_check)
    Finished dev [unoptimized + debuginfo] target(s) in 0.47s
$ cargo run --target i686-unknown-linux-gnu
    Finished dev [unoptimized + debuginfo] target(s) in 0.01s
     Running `target/i686-unknown-linux-gnu/debug/cargo_expand_check`
Hello, world!

So issue is probably related to cargo expand.

Additional info:

$ rustc --version
rustc 1.34.1 (fc50f328b 2019-04-24)

$ cargo version
cargo 1.34.0 (6789d8a0a 2019-04-01)

$ cargo expand --version
cargo-expand 0.4.11

$ rustup --version
rustup 1.18.1 (2019-04-26)

$ rustup target list | grep i686-unknown-linux-gnu
i686-unknown-linux-gnu (installed)

$ rustup component list | grep i686-unknown-linux-gnu
rust-std-i686-unknown-linux-gnu (installed)

Cargo.toml:

[package]
name = "cargo_expand_check"
version = "0.1.0"
authors = ["Fedcomp"]
edition = "2018"

[dependencies]

src/main.rs:

fn main() {
    println!("Hello, world!");
}

Cargo.lock:

# This file is automatically @generated by Cargo.
# It is not intended for manual editing.
[[package]]
name = "cargo_expand_check"
version = "0.1.0"

What can i do to make it work with i686 arch?

UnicodeDecodeError

cmd: cargo expand --color never
version: v0.3.10

Error:

** Error while highlighting:
UnicodeDecodeError: 'ascii' codec can't decode byte 0xe2 in position 1832403: ordinal not in range(128)
   (file "/usr/local/lib/python2.7/site-packages/Pygments-1.6-py2.7.egg/pygments/lexer.py", line 168, in get_tokens)

I don't understand why pygments is invoked at all when using --color never. I can also reproduce without the option.

Flag to preserve macro_rules in the output

Currently macro_rules definitions are not visible in the expanded code. Sometimes it can be useful to see them, such as when you have a procedural macro whose job is to emit a macro_rules macro.

Show progress bar

Currently the Cargo subprocess spawned by cargo-expand does not display Cargo's usual progress bar. I believe this is because we pipe the child's stderr to perform filtering here:

let mut child = cmd.stderr(Stdio::piped()).spawn()?;

and that means Cargo does not get a winsize from this ioctl:

https://github.com/rust-lang/cargo/blob/6be12653dcefb46ee7b605f063ee75b5e6cba513/src/cargo/core/shell.rs#L377

I tried a naive fix in #61 but it didn't work, the second ioctl fails with:

Inappropriate ioctl for device (os error 25)

Will need to figure out what's the correct way to provide a winsize to the child process.

"cargo expand --lib --tests" ignore dev dependencies

cargo expand --lib --tests can't resolve extern crates that are dev-dependencies. dev-dependencies do correctly get resolved when doing cargo expand --test XXX, though. It's as if cargo-expand ignores them whenever you use --lib. Steps to reproduce:

Cargo.toml:

[package]
name = "cargo_expand_dev_dependencies"
version = "0.1.0"
edition = "2018"

[dev-dependencies]
lazy_static = "1.0"

src/lib.rs

#[cfg(test)]
lazy_static::lazy_static! {
    static ref FOO: u32 = 5u32;
}

Output:

> cargo expand --lib --tests
    Checking cargo_expand_dev_dependencies v0.1.0 (/tmp/cargo_expand_dev_dependencies)
error[E0433]: failed to resolve: use of undeclared type or module `lazy_static`
 --> src/lib.rs:2:1
  |
2 | lazy_static::lazy_static! {
  | ^^^^^^^^^^^ use of undeclared type or module `lazy_static`
error: aborting due to previous error
For more information about this error, try `rustc --explain E0433`.
error: Could not compile `cargo_expand_dev_dependencies`.
To learn more, run the command again with --verbose.

#![feature(prelude_import)]
#![no_std]
#[prelude_import]
use std::prelude::v1::*;
#[macro_use]
extern crate std as std;
#[main]
pub fn main() -> () {
    extern crate test as test;
    test::test_main_static(&[])
}

Expand only one file

Currently, it displays the expansion of the entire crate. For big crates, that's not very practical. Often, you want to see the expansion of only one file.

Windows version requires msvc

When executing on Windows 10 command cargo expand
It outputs to console

error: toolchain 'nightly-x86_64-pc-windows-msvc' is not installed

Expected: use nightly-gnu

Installed toolchains:

>rustup toolchain list
stable-x86_64-pc-windows-gnu (default)
stable-x86_64-pc-windows-msvc
nightly-2016-08-01-x86_64-pc-windows-msvc
nightly-x86_64-pc-windows-gnu

Consider setting time limit on rustfmt

Rustfmt can hit cases where code takes exponentially long to format, particularly in macro-generated code. rust-lang/rustfmt#3465

We may want to consider limiting rustfmt execution time to some small number of seconds, after which we kill the rustfmt process and fall back to unformatted code.

Use `which` crate for locating tools

I contributed a bunch of code to the which crate a while back to use in sccache. I was looking at the code here and it seems like you could probably use that to replace some of the custom which impl you have.

Print status to stderr while formatting and colorizing

When expanding a crate with hundreds of thousands of lines post expansion, the progress can seem to pause for many seconds after printing:

Finished dev [unoptimized + debuginfo] target(s) in 10.64s

and before the expanded output appears. It is reasonable for users to expect that no further work needs to take place after something is "Finished". Let's print messages in the same style as Cargo to show that formatting and colorizing are taking place.

Smarter detection of rustfmt

Now with rustfmt-nightly being tied to a particular nightly compiler, cargo expand fails in a bad way if your rustfmt-nightly was installed by an older nightly than the one running cargo-expand.

rustfmt: error while loading shared libraries: libsyntax-d10704bc7cca04cb.so: cannot open shared object file: No such file or directory

Let's detect this situation and avoid executing rustfmt.

Investigate whether `cargo check` can perform expansion

Currently cargo expand is implemented in terms of cargo rustc which appears to compile the crate, similar to cargo build. Investigate whether there is a way for cargo rustc to behave like cargo check instead. Check is generally going to complete faster than build.

Expand in the face of compile errors

I know this is probably very impossible unless rustc adds support for it, but:

I think it would be useful to be able to expand code even when it doesn't compile, especially when debugging procedural macros.

(For now, the easiest way I've found is just to wrap your entire output into compile_error to see it.)

Can’t specify --lib and a module name at once

Bypassing #53 with --color=never, I execute

$ cargo expand --color=never rst::document_tree::extra_attributes
error: extra arguments to `rustc` can only be passed to one target, consider filtering
the package by passing, e.g., `--lib` or `--bin NAME` to specify a single target

ok, fair enough, let’s add --lib

$ cargo expand --color=never --lib rst::document_tree::extra_attributes
    Checking rst v0.2.0 (/home/phil/Dev/Rust/rust-rst)
error: multiple input filenames provided (first two filenames are `src/lib.rs` and `rst::document_tree::extra_attributes`)
error: Could not compile `rst`.
To learn more, run the command again with --verbose.

cargo expand --tests fails on coresimd

To reproduce:

git clone [email protected]:rust-lang-nursery/stdsimd.git
cd stdsimd/crates/coresimd
cargo expand --tests

produces:

error: extra arguments to `rustc` can only be passed to one target, consider filtering
the package by passing e.g. `--lib` or `--bin NAME` to specify a single target
cat: /var/folders/mm/y444qqwd0kn52fycyz6nsph40000gn/T/cargo-expand.wi2xxYzTETto/expanded: No such file or directory

Warning about multiple output types

Using the newest nightly:

warning: due to multiple output types requested, the explicitly specified output file name will be adapted for each output type

Expand test modules

I am trying to expand some macros inside #[cfg(test)] mod tests { .... } modules and failing.

I have tried: cargo expand --tests, cargo expand --test path/to/file.rs, cargo expand --test file, cargo expand test` (like cargo test but with expand), without any luck.

I've also tried by copying the relevant code into tests/file.rs and trying to cargo expand --test tests/file.rs instead.

Expand errors on valid input

On cargo-expand 0.3.9 and rustc 1.19.0-nightly (5b13bff52 2017-05-23), the following code will compile and run, but won't expand:

pub struct Foo {
    bar: String,
}

impl Foo {
    fn new(bar: String) -> Self {
        Self { bar, }
    }
}

#[test]
fn hello() {
    assert_eq!("Hello", &Foo::new("Hello".to_string()).bar);
}

The error message is

error: expected `:`, found `,`
  --> stdin:12:43
   |
12 |     fn new(bar: String) -> Self { Self{bar,} }
   |

Proposal: Expand whole project source to the ad hoc project

Expand (with preserved comments (?)) whole project source files, and copy, other project related files, to the other project,
So obtained project copy, will contain "pure" source and can be run and debugged as is, without any expansion.

Can be added option - how deep to expand macros. Only located in user code... located in user code and used crates...

Continuous output

Instead of printing all the output at the end, you could print it as soon as you receive it. With the current setup, we don't see dependencies compiling progress.

--help flag

Currently a --help flag gets passed through to Cargo and then Rustfmt chokes on the output.

$ cargo expand --help
error: unknown start of token: `
  --> stdin:40:1
   |
40 | `build.rustflags` configuration option.
   | ^
thread 'main' panicked at 'Box<Any>', .cargo/registry/src/github.com-1ecc6299db9ec823/syntex_syntax-0.44.1/src/parse/lexer/mod.rs:48
note: Run with `RUST_BACKTRACE=1` for a backtrace.

Using println breaks when cargo-expand uses rustfmt

For finding out where I was generating wrongly formatted quotes I used println('{:?}', tokens) to find out what tokens were being generated. Leaving those prints in causes cargo expand to hiccup when rustfmt is in the path, because they are seen as the first part of the code and it's not valid Rust.

error: expected item, found `Tokens`
 --> stdin:1:1
  |
1 | Tokens("MyInt ( self . 0 . add ( rhs . 0 ) )")
  | ^^^^^^

This can be worked around by using RUSTFMT= cargo expand, to disable rustfmt.

Expanding tests

Related to #20, but I can't seem to use the solution given there:

$ cargo expand -- --test
error: Invalid value for '<ITEM>': `--test` is not an identifier
$ cargo expand --version
cargo-expand 0.4.4

How should I pass arguments to rustc with the addition of the cargo-expand arguments to expand specific items?

Add feature to inject trace_macros

If the user has a crate like:

fn main() {
    println!("{:?}", S);
}

We can inject the following code before compiling, I guess similarly to how cargo clippy works (but I haven't looked at how that is).

#![feature(trace_macros)]
trace_macros!(true);

The output looks like:

note: trace_macro
 --> src/main.rs:8:5
  |
8 |     println!("{:?}", S);
  |     ^^^^^^^^^^^^^^^^^^^^
  |
  = note: expanding `println! { "{:?}" , S }`
  = note: to `print ! ( concat ! ( "{:?}" , "\n" ) , S )`
  = note: expanding `print! { concat ! ( "{:?}" , "\n" ) , S }`
  = note: to `$crate :: io :: _print ( format_args ! ( concat ! ( "{:?}" , "\n" ) , S ) )`

It shows the intermediate expansion steps, not just the final expanded result.

cannot expand single item

I have an issue expanding a single item. I get the error "cannot expand single item (single::item) without rustfmt" it does give the hint to install rustfmt using "rustup component add rustfmt --toolchain nightly"

however when i run that it says rustfmt is up to date. Even installing to stable is up to date. to the best I can tell rustfmt is installed fine for all toolchains.

not sure if there is a bug or I am simply doing something wrong.

Implement the `-p` argument

Currently cargo expand -p some-workspace-crate fails with the following

Found argument '-p' which wasn't expected, or isn't valid in this context

It would be nice to expand macros in other workspace crates.

error: multiple input filenames provided

cargo expand with a stable or beta toolchain doesn't work at all, even on a newly created, empty crate. For example:

somers@rustup /tmp> cargo new dummy
     Created binary (application) `dummy` project
somers@rustup /tmp> cd dummy
somers@rustup /t/dummy> cargo expand
    Checking dummy v0.1.0 (file:///tmp/dummy)
error: multiple input filenames provided
error: Could not compile `dummy`.
To learn more, run the command again with --verbose.

No variation of cargo expand --verbose produces any different output. Using cargo +nightly expand works, but according to the README that shouldn't be necessary. The README says that cargo expand can be invoked with any Rust toolchain, as long as nightly is also installed.

Recommend Projects

  • React photo React

    A declarative, efficient, and flexible JavaScript library for building user interfaces.

  • Vue.js photo Vue.js

    🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.

  • Typescript photo Typescript

    TypeScript is a superset of JavaScript that compiles to clean JavaScript output.

  • TensorFlow photo TensorFlow

    An Open Source Machine Learning Framework for Everyone

  • Django photo Django

    The Web framework for perfectionists with deadlines.

  • D3 photo D3

    Bring data to life with SVG, Canvas and HTML. 📊📈🎉

Recommend Topics

  • javascript

    JavaScript (JS) is a lightweight interpreted programming language with first-class functions.

  • web

    Some thing interesting about web. New door for the world.

  • server

    A server is a program made to process requests and deliver data to clients.

  • Machine learning

    Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.

  • Game

    Some thing interesting about game, make everyone happy.

Recommend Org

  • Facebook photo Facebook

    We are working to build community through open source technology. NB: members must have two-factor auth.

  • Microsoft photo Microsoft

    Open source projects and samples from Microsoft.

  • Google photo Google

    Google ❤️ Open Source for everyone.

  • D3 photo D3

    Data-Driven Documents codes.