id stringlengths 8 11 | text stringlengths 32 472 | label stringclasses 5
values | label_id int64 0 4 |
|---|---|---|---|
rust_539 | Adding support for 'degenerate' anonymous objects | We want to add support for 'degenerate' anonymous objects that don't add any new methods or fields. This might seem trivial, but part of making it work is ensuring that calls to anonymous objects "fall through" appropriately, so that calls to methods that were on the ... | question | 4 |
rust_540 | Adding support for extending objects with methods that contain simple self-calls | By "simple self-calls", we mean that no method overloading is involved. I think the place this is currently failing is in typechecking, although I need to make sure. Currently xfail'd test: src/test/run-pass/anon-obj-with-self-call.rs. | question | 4 |
rust_541 | Alias analysis should take move ops into account | The rhs of a move gets clobbered/invalidated, so you shouldn't be able to move stuff that's aliased. | medium | 2 |
rust_542 | Use move semantics for function and block returns | (Where block return is the thing that happens with semicolon-less last expressions.) Both guarantee that the returned value is no longer live after the return, so there doesn't seem to be a reason to copy. | labels: I-slow | medium | 2 |
rust_543 | Adding support for extending objects with methods that override existing methods in the presence of self-calls | This is tricky because we have to make sure that the meaning of 'self' is also overridden. Currently xfail'd test: src/test/run-pass/anon-obj-overriding.rs. | question | 4 |
rust_544 | Implement dropping predicates in typestate | Typestate doesn't handle move correctly -- any predicates mentioning the thing being de-initialized should be dropped. Also, assignment to a local should invalidate any predicates on the LHS variable. Implement this, | medium | 2 |
rust_546 | Wrong types reported in some let binding type errors | Trying to compile the program fn main() { auto b = "hi"; let int i = b; } Results in the error: error: mismatched types: expected str but found str (types differ) | labels: A-type-system | medium | 2 |
rust_547 | Replace some native module syntax with attributes | Native mod declarations have some optional syntax (abi, native name) which can be turned into attributes. | labels: A-frontend, E-easy | low | 3 |
rust_548 | Write swap in assembly instead of C++ | Right now, C++ compilers like to make set_registers into a tail call, which causes problems when get_registers returns the second time. To get around this, we should write the swap context function in assembly instead of disabling compiler optimizations. | medium | 2 |
rust_550 | Type inference not working in anonymous functions | ``` auto f = fn() { auto i = 10; }; ``` Cannot determine type for `i`. | labels: A-type-system | medium | 2 |
rust_551 | Duplicate alt patterns ignored | fn main() { auto a = 5; alt (a) { case (_) { } case (_) { fail; } } } The program happily compiles and runs to completion. | medium | 2 |
rust_552 | Support static linking crates | Currently a crate is always compiled to a shared library. We should support both regular static linking and LTO. I think we should rename --shared to --lib. This is what it would look at: *) rustc --lib --shared foo.rc -o foo.so *) rustc --lib --static foo.rc -o foo.lib (really j | label... | question | 4 |
rust_553 | Add global variables to unsafe | We should support simple global variables. No before main constructors, just plain variables. | labels: C-enhancement, A-codegen | question | 4 |
rust_554 | Implement log in rust | With global variables implemented, we can probably implement log in rust itself. | labels: A-runtime, C-enhancement | low | 3 |
rust_555 | Add support for slices | LLVM uses a lot of StringRef and ArrayRef. They are really handy and efficient, being implemented with just a pointer and size. Some uses of it are safe (call a function with StringRef to a string that outlives the call), some unsafe (StringMap return a StringRef). Go makes this | labels: C-en... | question | 4 |
rust_556 | figure out what to do with iterators | We would like to keep the ability of using yield instead of creating iterator "objects". One way to implement it with llvm that we discussed is that --- iter f() { yield 1; yield 2; } ... for I in f() } if I == 1 { ret 42; } } ## ... Gets compiled to (pseudo code) {act, i32} the_ | medium | 2 |
rust_557 | GEP instead of pointer-to-int and add and back | GEP is a better way to do pointer-to-int. | labels: C-cleanup | low | 3 |
rust_558 | Tool to detect/display function dependencies in Rust crates | This would be useful for many things: - Figuring out which functions are dead and can be removed. - Visualize function dependencies (with `dot`). - Be the basis for a Rust `ccache` workalike. - On-demand, lazy unit tests. | medium | 2 |
rust_559 | Pull glue out of trans | middle::trans is huge. An easy way to make it smaller is pull out the glue-related stuff. | labels: E-easy, C-cleanup | low | 3 |
rust_560 | Split rustc into libraries | Parts of rustc will need to be used outside of the compiler and splitting it up will help improve the design. One possible division: - front - ast, parser, pretty-printer - middle - resolver, typechecker, typestate - back - trans, link, etc. creader needs to be somewhere as well. | labels: ... | question | 4 |
rust_561 | Better error when types differ only by their boxiness | Instead of having to figure out what is meant by `error: mismatched types: expected block but found @rec(rec(vec[@stmt] stmts,<tag#1:926>[@expr] expr,node_id id) node,span span) (types differ) ` rustc should just tell me that I don't need the box, maybe by using a... | low | 3 |
rust_562 | lib-sha1 segfaults only at -O0 | This seems bad. | labels: I-crash | high | 1 |
rust_563 | Reformat under the major agreed syntax changes | There's a bunch of syntax changes pending. Teach pp and parser to do it, then snapshot, reformat, and resnap. | labels: A-frontend, C-cleanup, A-pretty | low | 3 |
rust_564 | Interior vector syntax should be [T] | Instead of `T[]`, we should use `[T]`. This makes `@int[]` unambiguous: `[@int]` vs. `@[int]`. | labels: A-frontend | medium | 2 |
rust_565 | Add ternary operator | labels: A-frontend, E-easy, A-type-system | low | 3 |
rust_568 | Typechecking doesn't enforce communication immutability requirements | It looks like we'll still attempt to compile attempts to send mutable data on channels or in spawn arguments. This should be disallowed. | labels: A-type-system | medium | 2 |
rust_569 | Merge rust_kernel and rust_domain | medium | 2 |
rust_570 | Allow arbitrary constant expressions to be assigned to const items | Right now constants have to be literals and this is getting pretty painful. | labels: A-frontend, A-codegen | medium | 2 |
rust_571 | Allow vector constants | labels: C-enhancement, A-codegen | low | 3 |
rust_574 | Poor error when iterator name missing in for loop | Currently, if you write a loop like this: for (type in named_list) {} you get this message: error: expecting in, found named_list which is really obtuse. An easy heuristic to show a more informative message would be to check whether the iterator is named "in", possibl... | low | 3 |
rust_575 | Some forms of float literal don't parse | I expect the following things to parse as float literals but they don't: ``` 12E+99_f32; 12E+99f64; 10f; ``` The last form (without the decimal) isn't mentioned in the Rust documentation, but since it's explicitly marked as a float i would expect it to work. | labels: A-fronten... | low | 3 |
rust_576 | Relational binops on unit type are nonsensical | The following is currently what holds for relational binops on () ``` assert (() < ()); assert (() <= ()); assert (!(() > ())); assert (!(() >= ())); ``` Now, because we have relational binops over structural types, we have to either have relational binops over all types... | medium | 2 |
rust_577 | Crash comparing ports, channels, tasks | rustc will compile comparisons between ports and comparisons between channels but the code crashes at runtime. Also tasks. | labels: A-runtime, I-crash | high | 1 |
rust_578 | rustc happily compiles non-boolean branch expressions which assert at runtime | auto a = 0u; if (a) { fail } This should be caught at compile time. | medium | 2 |
rust_579 | Implement something like copy & move analysis | Some pass should check whether code doesn't move from locations that should never be moved from (data structure fields can be swapped, if mutable, but never moved out, I think). The same pass can probably verify that no non-copyable values (currently only ty_res) are bein... | medium | 2 |
rust_580 | rust_task::kill appears to just wake the task | In some of the aio code, I would like to kill a task from another task in native code. I have a task which does the following: `while (true) { log "about to sleep"; p |> evt; }` however nothing is ever sent to `p`. What I expect to see is one log message however I see a s... | medium | 2 |
rust_581 | Current LLVM trunk incompatible with librustrt. | On 32-bit Linux and LLVM trunk revision 133904 (tip at the time of filing), rustc fails to build (in particular, librustrt fails to link) `rustllvm/MachOObjectFile.o`. This appears to be due to a change in the interface of LLVM's `ObjectFile` probably introduced by revi... | medium | 2 |
rust_582 | switch from rand to isaac | There's a cprng that auto-initializes from system entropy in rt. Use that in the scheduler (and anywhere else in rt or std) instead of rand(), please. | labels: A-runtime | medium | 2 |
rust_583 | perf bot | We need a part of the website / tinderbox setup that measures "performance" in a general sense, so we can see regressions and have a target to try to press downwards. Recommend measuring with linux 'perf' tool on the rustc and libstd builds as well as the contents of the 'bench' | high | 1 |
rust_584 | Start running runtime test suite again | We have a set of runtime tests written in C++ that are not currently being run. We should be running these. | labels: A-runtime, A-testsuite | medium | 2 |
rust_585 | Replace common::new_seq_hash with std::smallintmap | These do the same thing | labels: E-easy, C-cleanup | low | 3 |
rust_586 | Postconditions on function return types | I want to be able to write a function with a constraint on its return type. For example: ``` fn add(int x, int y) -> int : * >= x, * >= y { x + y } ``` Here, the \* refers to the return value. I can't just do this with constraint types, because in this case, add would have to r... | low | 3 |
rust_588 | port constructors with types don't parse correctly. | The following snippet doesn't parse and it should. ``` auto p1; p1 = port[int](); ``` | medium | 2 |
rust_591 | Require that the RHS of a move be a local variable | This is a bit trickier than just making sure that it is a path of length 1, since it could also be an object field or (soon) an upvar. | labels: A-type-system | medium | 2 |
rust_593 | Deadlock in upcall_vec_append/upcall_malloc | `upcall_vec_append` can call copy glue, which can call `upcall_malloc`. `upcall_malloc` tries to grab the scheduler lock too and deadlocks. | labels: A-runtime | medium | 2 |
rust_594 | Add warning when return is used | I frequently type return instead of ret, and always end up puzzling over the resulting error for longer than should be necessary. An explicit warning would be nice. | labels: A-frontend, E-easy | low | 3 |
rust_595 | Add 1:1 Scheduling Mode | Add a way to make each task run in its own thread. | labels: A-runtime | medium | 2 |
rust_596 | Worker threads shouldn't busy wait | If there are no tasks available to run, the worker thread should go to sleep and wait for `rust_kernel` to wake them. | labels: A-runtime | medium | 2 |
rust_597 | "Instruction does not dominate all uses" when translating fixed point combinator | Trying to translate the function <pre> fn fix[A,B](fn (fn (&A) -> B, &A) -> B f, &A x) -> B { ret f(bind fix(f, _), x); } </pre> produces the LLVM messages: <pre> Instruction does not dominate all uses! %19 = load %tydesc** %18 store %ty... | medium | 2 |
rust_598 | Add support for pinning tasks to a certain worker thread | Add a `pinned_on` field to `rust_task`. Add runtime support for setting and unsetting this. Make the scheduler respect it. | question | 4 |
rust_599 | Add task wakeup callback | Add a callback that fires when a task blocking on a port becomes ready to run again. To do this right, it should require moving the `message_queue` into `rust_task` and doing something with that. | medium | 2 |
rust_600 | Eliminate copies when initializing a local from a temporary | I don't think we need to copy the data when initializing a local from a temporary; we can just say the local _is_ the temporary. This is analogous to constructor elision in clang: see http://clang.llvm.org/doxygen/CGExprCXX_8cpp_source.html#l00354 | labels: ... | medium | 2 |
rust_601 | Can't define types as resources | The following doesn't work: ``` type rtype = resource(int i); ``` Then I would expect to be able to: ``` resource r1(int i) {}; resource r2(int i) {}; let rtype i1 <- r1(0); let rtype i2 <- r2(0); ``` Currently I don't see any way to make polymorphic resources. | medium | 2 |
rust_602 | typecheck segfault on failure to unify | The type error makes this segfault: ``` use std; import std::option::*; fn main() { let t[int] x = none; x = 5; } ``` Looks like stack overflow. The interesting part of the backtrace: #1019 0x080df952 in middle::ty::fold_ty () #1020 0x080f985f in middle::ty::unify::fixup_vars::s... | high | 1 |
rust_603 | Remove rc_base | Make the ref count fields and methods interior to each ref counted object. The current `rc_base` class causes problems with MSVC, since it makes the vtable layout different from GCC's. | medium | 2 |
rust_604 | Remove much of the crate file evaluation infrastructure | Having a mini scripting language inside the parser is rather undesirable, and some of it's use case will be replaced with the new conditional compilation attributes. Try to remove much of the front::eval code for parsing crate files. Graydon suggests that leavin... | low | 3 |
rust_607 | Allow crate link attributes to contain nested meta items | It's currently impossible to define a link attribute that has nested meta items, `#[link(foo(bar))];`, even though this is a valid way to write an attribute. There are unfinished branches in two methods, link::build_link_meta (that prevents translation), and at... | medium | 2 |
rust_608 | Restore or remove the --depend flag | rustc claims to support a --depend flag that lists the .rs files in a crate. There is support in front::eval for this, but it is not wired up to the driver. Either finish the implementation or remove its vestiges. | labels: A-frontend, E-easy, C-cleanup, A-driver | question | 4 |
rust_609 | Attributes for native items | Attributes can be applied to native modules but not the items in those modules. For completeness, this seems like it should be allowed. | labels: A-frontend, E-easy | low | 3 |
rust_610 | Conditional compilation for native items | Pending completion of #609, native items should support conditional compilation with the #[cfg(...)] attribute. | labels: A-frontend, E-easy | question | 4 |
rust_611 | Support all literal types in ast::meta_item | Right now they only hold strings, and thus attributes only support strings. | labels: A-frontend, A-linkage | question | 4 |
rust_612 | Create a mechanism to merge config files into the crate compilation environment | We need some mechanism to provide configuration information to the compiler via a file that, e.g. is produced by the build system. The intent is - at least partially - to remove the need for the long, arcane command lines that plague C co... | question | 4 |
rust_614 | Add warnings and errors when the crate 'link' attribute looks malformed | The link attribute has special meaning on crates, and certain rules should be enforced like: - Warn if there is no 'name' or 'vers' item for shared libraries - Error if there are two items with the same identifier Some of this used to exist until... | low | 3 |
rust_618 | fail #fmt("%s", str_var) causes an LLVM assertion | Specifically, when trying to build a GEP we end up triggering the !*terminated assertion in llvm.rs, since terminated is presumably set when we mark the post-failure block as being unreachable. | medium | 2 |
rust_619 | Passing a type parameter to a tag constructor that doesn't expect one isn't checked | Instead, you get an index out of bounds error in typeck. This should probably be checked and properly reported. (I didn't check with non-tag-constructor functions, the same problem probably exists there) | medium | 2 |
rust_620 | Remove rust_scheduler parameter from rust_vec contructor | This is not used, so there's no point having it there. | labels: A-runtime, E-easy, C-cleanup | low | 3 |
rust_621 | "cannot determine a type for this expression" should be non-fatal | Generally, when we can't determine a type for an expression due to `structure_of` failing, we're kinda stuck when it comes to typechecking that function, but we can back out and typecheck the other functions. | labels: A-type-system | medium | 2 |
rust_622 | Nil literal doesn't parse in some situations | `()` doesn't parse as a nil literal in some situations that I would expect it to, in particular as meta_item values and in patterns ``` #[x = ()] fn main() { auto x = (); alt (x) { case (()) { } } } ``` | labels: A-frontend, E-easy | low | 3 |
rust_623 | Encode/decode meta_name_values with non-string values | ast::meta_item supports any literal as a value but the crate metadata encoder and decoder only knows how to deal with string values. This currently just means that crate attributes with non-string literal values, e.g. `#[revision = 100u]`, will be silently lost. |... | question | 4 |
rust_624 | "error: cyclic import" | This gives an error and maybe it shouldn't: import rustc::driver::rustc; ../src/fuzzer/fuzzer.rs:10:12:14:4: error: cyclic import ../src/fuzzer/fuzzer.rs:9:12:10:6: error: unresolved modulename: syntax Workaround: import driver = rustc::driver::rustc; | medium | 2 |
rust_625 | The "log" does not output anything to the console, but the "log_err" outputs. | OS: Linux/Ubuntu. The `log` does not output anything to the console, but the `log_err` outputs. Following [the documentation](https://github.com/graydon/rust/wiki/Logging-vision), I set the RUST_LOG environment variable as: ``` $ export RUS... | medium | 2 |
rust_626 | Better error when main is not defined | When a main function is not defined we end up failing at link time with an error from ld. We could be failing much earlier with a simpler error message. | labels: A-frontend, E-easy | low | 3 |
rust_627 | Windows does not respect RUST_SEED environment variable | labels: A-runtime, O-windows | medium | 2 |
rust_628 | Incorrect span for mismatched type error during FRU | In the following example, foo is bool when it's expected to be int. ``` auto a = rec(foo = 0); auto b = rec(foo = true with a); ``` The mismatched type error spans the entire rec being assigned to variable b, instead of just the incorrect expression, 'true'. For err... | low | 3 |
rust_631 | Compound assignment between boxed types results in LLVM assertion failure | The following code ``` auto x = @10; x += @20; ``` fails with "rustc: Instructions.cpp:1567: void llvm::BinaryOperator::init(llvm::Instruction::BinaryOps): Assertion `getType()->isIntOrIntVectorTy() && "Tried to create an integer operation on a... | low | 3 |
rust_632 | Transitive dependencies between crates don't work in the metadata reader | Reduced test case (thanks, jruderman): ``` use rustc; import driver = rustc::driver:rustc; fn main() { driver::parse_input; } ``` | medium | 2 |
rust_633 | type-parameterized functions not specialized when passed as argument | Ran into this while trying to make an ivec_equal function. Here's a testcase without any vectors. ``` fn builtin_equal_int(&int a, &int b) -> bool { ret a == b; } fn builtin_equal[T](&T a, &T b) -> bool { ret a == b; } fn apply_equal[T](fn (&T, &T) ... | high | 1 |
rust_635 | Add a configure flag to force using gcc instead of clang | I had to comment out this line in configure to make rust compile with gcc instead of the wrong-version-of-clang I happen to have lying around. ``` probe CFG_CLANG clang++ ``` Seems like there should be a configure flag for this. Or it could just automatically f... | medium | 2 |
rust_637 | Add environment variable to set stack size | Some programs need a big stack, others need lots of small stacks. Since we don't have stack growth working yet, we should have an environment variable to switch stack sizes without having to recompile the runtime. | labels: E-easy | low | 3 |
rust_638 | "Calling a function with a bad signature!" when I forget to specify iter's out type | Assertion failed: ((i >= FTy->getNumParams() || FTy->getParamType(i) == Params[i]->getType()) && "Calling a function with a bad signature!"), function init, file /Users/graydon/src/llvm/lib/VMCore/Instructions.cpp, line 191. ``` iter ... | medium | 2 |
rust_639 | trans_put - 'non-exhaustive match failure' | rt: 9736:main:main: upcall fail 'non-exhaustive match failure', ../src/comp/middle/trans.rs:6572 ``` iter under(uint hi) -> uint { let uint y = 0u; while (y < hi) { put y; y += 1u; } } iter several_zeroes() { for each (uint i in under(3u)) { put 0u; } } ``` | medium | 2 |
rust_640 | Type-parameterized 'vec_omit' produces incorrect result | The function ``` fn vec_omit_T[T] (&T [] v, uint i) -> T[] { slice(v, 0u, i) + slice(v, i+1u, len(v)) } ``` produces an array with bogus values in it. In contrast, an int-specialized function produces correct results. ``` use std; import std::ivec; import std::i... | medium | 2 |
rust_641 | Import pattern alternatives | The pipe character between case patterns will mean 'match either of these', as a way associate put multiple patterns with a single body. The types and bound variables of the combined patterns should agree. | medium | 2 |
rust_642 | Binding bare function arguments with type parameters fails in llvm | Trying to bind a bare function argument with type parameters will trip an LLVM assert. The extent to which is this is a bug depends on what our final decision about bare fns winds up being. | medium | 2 |
rust_643 | Improve error message for unexpected EOF | ``` fn x() { } fn y() { fn z() { } ``` Result: ``` a.rs:3:9:3:10: error: unexpected token: <eof> ``` Expected: something like of "missing } after function body which begins on line 2". | labels: A-frontend, E-easy | low | 3 |
rust_644 | record update should auto-dereference | ``` fn main() { auto a = @rec(x=1, y=2); auto b = @rec(x=3 with a); assert b.x == 3; assert b.y == 2; } ``` Result: ``` /Users/jruderman/Desktop/b.rs:3:14:3:29: error: record update non-record base ``` It wants me to change `a` to `*a`. I think it should auto-dereference, since t... | low | 3 |
rust_646 | Race condition in port shutdown | Now that ports have a lock, there is a race condition in the shutdown process. One task may call the port destructor while another task is still holding the lock. | labels: A-runtime | medium | 2 |
rust_647 | Only autoderef through one box | Right now we can autoderef through multiple boxes (and we can do things like "(@@@@7) + (@@2)". This seems a little silly. I think we might want to restrict it to just go through one box? What do people think of this? (Relatedly, I think could use a "bikeshed" label and a "langua | labe... | low | 3 |
rust_648 | bounds check failure in trans | The following code causes a bounds check failure in trans. I'm not sure what it should do instead. ``` fn foo[T] (&T x) { fn bar(fn (&T) -> T f) { }; } ``` | medium | 2 |
rust_649 | Variable shadowing behaves weirdly | <pre> fn wrong(int a) -> int { let int b = a; let str a = "something"; ret b; } fn main() {} </pre> fails in typechecking with the message <pre> shadowing-bug.rs:2:16:2:18: error: mismatched types: expected int but found str (types differ) </pre> I think this is because we treat | ... | medium | 2 |
rust_650 | Spans for view items are fairly inaccurate | In this test case: ``` // xfail-stage0 // error-pattern:'swap' is glob-imported from multiple different modules // issue #482 use std; // expecting swap to be defined in vec import std::vec::*; import alternate_supplier::*; mod alternate_supplier { fn swap() {} } fn main() {... | low | 3 |
rust_651 | syntax::fold::make_fold leaks | ``` use rustc; import rustc::syntax::fold; fn main() { auto afp = fold::default_ast_fold(); auto af = fold::make_fold(*afp); } ``` rt: fatal, 'leaked memory in rust main loop (23 objects)' failed, ../src/rt/memory_region.cpp:156 23 objects | medium | 2 |
rust_652 | pprust::print_if does not anticipate evil | If my fuzzer replaces the 'els' node with something other than an expr_if or expr_block, I get: upcall fail 'non-exhaustive match failure', ../src/comp/syntax/print/pprust.rs:636 | medium | 2 |
rust_653 | constrained-type.rs fails to parse again | Comment in the test indicates that it's supposed to parse but not run. It doesn't parse. (Again. It was fixed once in #141.) /Users/jruderman/code/rust/src/test/run-pass/constrained-type.rs:18:57:18:58: error: expecting ,, found . | medium | 2 |
rust_654 | 'Assertion i == total failed' in str::char_len | rt: 9736:main:main: upcall fail 'Assertion i == total failed', ../src/lib/str.rs:279 ``` use std; use rustc; import std::fs; import std::io; import std::vec; import rustc::back::link; import rustc::syntax::ast; import rustc::syntax::print::pprust; import driver = rustc::... | medium | 2 |
rust_656 | Ambiguity in proposed pattern syntax | Colons will allow specifying the types of pattern elements (`let x: int = 6`), but are also used as separators between field names and sub-patterns in record patterns (`{x: ?binding}`). Since we allow the sub-pattern to be omitted (`{x}` is interpreted as `{x: ?x}`) this introduc | medium | 2 |
rust_657 | Warning for vecname(0) could be more helpful | I find it easy to leave out the indexing operator. It would be nice if we could use a heuristic to detect this and display a better warning than the current "mismatched types: expected function or native function but found vec[uint]". | low | 3 |
rust_658 | Export consts across crates | rustc still does not have the ability to read constants from external crates. Trying results in the following error: "upcall fail 'Assertion ccx.consts.contains_key(did._1) failed', /media/src/rust-tinderbox/srcdir-snap-stage3-x86_64-unknown-linux-gnu/src/comp/middle/trans.rs:508 | medium | 2 |
rust_661 | Matching a struct pattern should autoderef | Either that, or we need a syntax for dereferencing in a pattern. | medium | 2 |
rust_662 | Cannot infer a type for this case | The typechecker does not infer a type for the following parameter. It should determine that `ctrl` has type `port[command[K,V]]`. ``` fn cache_server[K, V] (chan[chan[command[K,V]]] c) { auto ctrl = port(); c <| chan(ctrl); } ``` | labels: A-type-system | medium | 2 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.