nrc / darkly

🦍🦍🦍🦍🦍🦍🦍🦍🦍🦍

• Mastodon: @nrc
• Twitter: @nick_r_cameron
• Blog: ncameron.org/blog
• Website: ncameron.org
• Pronouns: he/him

🦀🦀🦀🦀🦀🦀🦀🦀🦀🦀

darkly's Issues

statement form/argument form of scanlns

Perhaps with an implicit loop?

scanlns!("{} {}", x: u32, y:String, {
    ...
});

Or perhaps it should still have expression form, but lets you specify types as arguments, e.g., scanlns!("{}, {}", u32, String) which gives Iterator<Item=(u32, String)>

token/quoting macro bug

There is a bug in rustc that I'm currently hitting and which is preventing any progress on the macro front.

expression form: if there is only one item, don't tuple-wrap it.

Compare to mmun's spec

https://gist.github.com/mmun/bffc62a5eb6ad648b7f7b2825364962c (cc @mmun)

• - Add scan! for scan-not-a-whole-line case.
• - Robust parsing: scan! should keep trying to match the input until it finds something that matches or we run out of bytes. This matches cin and scanf semantics.
• - Expression form of scan!(...) to avoid boilerplatey bindings in some cases, e.g.

// this snippet also uses default format string inference on the next line
for i in 0..scan!("{}") {
  for j in 0..scan!("{}") {
    // ...
  }
}

• - Let scan!() infer a default format string:
  • let x: i32 = scan!(); // "{}"
  • let x: (i32,) = scan!(); // "{}"
  • let x: (i32, i32) = scan!(); // "{}{}"

Use macros 2.0 framework

Currently using the old proc macro stuff

When should the scanlns iterator terminate (c.f., panic)

It currently returns None on an error, but maybe it should return None on a blank line and panic on an error.

lattice specialisation

We need specialisation with the 'lattice rule' to offer a nice inference-based API which can use the same functions for scanning T as Result<T>.

assign into references

e.g., scanln!("{}", *x) would infer the type of x, read that type, then save it into x

tracking: scanning API

library functionallty.

documentation

Tailor whitespace sensitivity

I.e., so that scanned data has trim applied automatically (or trim_left/trim_right).

tracking: scanln macro

a useful and working scanln! macro

Work on stable Rust

We can use the proc macro hack to get around the proc_macro_hygiene feature, and might be able to find ways around other features.