www.digitalmars.com         C & C++   DMDScript  

digitalmars.D - From two small Rust tutorials

reply "bearophile" <bearophileHUGS lycos.com> writes:
Recently I've found two very small introductions to the Rust 
language. Below I list some of the things I've found in them.

The first tutorial is:
http://matej-lach.me/rust-basics/

------------------

The Rust tuple syntax similar to Kenji's:

let (i, result) = (0i, 0i);
let (x, y, z) = (15i, "string", 29.99f64);
let (mut s, a, mut m) = ("can change", "cannot", "can");

------------------

Nice uniform names for the integral values (but uint and int are 
variable length, I don't know if this is a good idea, I don't 
like this much):


Rust has the following primitive numeric types: u8, i8, u16, 
i16, u32, i32, u64 and i64 - it also has the aliases int and 
uint for i64 or i32 and u64 or u32 respectively, (depending on 
whether the OS is 64 or 32-bit).<


------------------

The switch syntax supports floating point intervals too:

match x {
     1.0..1.99 => println!("x is between one and two"),
     2.0..2.99 => println!("x is between two and three"),
     3.0..3.99 => println!("x is between three and four"),
     4.0..4.99 => println!("x is between four and five"),
     5.0..5.99 => println!("x is between five and six"),
     _ => println!("x is bigger than five") // catches all other 
possible values of `x`
}


That feature can be added to D too, if it's desired:

void main() {
     double x;
     case (x) {
         case 1.0: .. case 1.99: return writeln("x is between one 
and two");
         case 2.0: .. case 2.99: return writeln("x is between two 
and three");
         case 3.0: .. case 3.99: return writeln("x is between 
three and four");
         case 4.0: .. case 4.99: return writeln("x is between four 
and five");
         case 5.0: .. case 5.99: return writeln("x is between five 
and six");
         default:                return writeln("x is bigger than 
five");
}


But what about x = 1.999? That Rust code looks buggy.

This hypotetical D code looks more correct, so it's tricky (I 
used T because the nextDown of a float is different from the 
nextDown of a double/real):

void main() {
     import std.math: nextDown;
     double x;
     alias T = typeof(x);
     case (x) {
         case 1.0: .. case nextDown(T(2)):
             return writeln("x is between one and two");
         case 2.0: .. case nextDown(T(3)):
             return writeln("x is between two and three");
         case 3.0: .. case nextDown(T(4)):
             return writeln("x is between three and four");
         case 4.0: .. case nextDown(T(5)):
             return writeln("x is between four and five");
         case 5.0: .. case nextDown(T(6)):
             return writeln("x is between five and six");
         default:
             return writeln("x is bigger than five");
}

------------------

The second tutorial:
http://pudgepacket.github.io/rust/2014/08/11/taste-of-rust-pt-2/


A little function that converts a string (line) to a vector of 
doubles:

fn extract_line_data<T: std::from_str::FromStr>(line: &str) -> 
Vec<T> {
     line.trim().split(' ').filter_map(|s| 
from_str::<T>(s)).collect()
}


The same function written in a more didactic style:

fn extract_line_data<T: std::from_str::FromStr>(line: &str) -> 
Vec<T> {
     // line = "f 1 2 3 4\n"

     // Remove line endings
     let trimmed = line.trim();
     // trimmed = "f 1 2 3 4"

     // Split on space
     let split = trimmed.split(' ');
     // split = ["f", "1", "2", "3", "4"]

     // Map from_str over the split array
     //   collect all the successfuly converted values into a 
vector
     let converted = split.filter_map(|s| 
from_str::<T>(s)).collect();
     // converted = [1, 2, 3, 4]

     return converted
}


The from_str is related to std.conv.to (but I think it overloads 
the return type, as in the Haskell function, that is not possible 
in D).

When you try to convert the "f" string using from_str it doesn't 
raise an exception like std.conv.to because from_str returns an 
Option<T>, similar to Phobos Nullable!T.

So they have used filter_map to filter away the Null conversions. 
So it's similar to this D code:


T[] extractLineData(T)(in string line) {
     return line
            .split
            .map!(s => s.maybeTo!T)
            .filter!(m => !m.isNull)
            .map!(m => m.get)
            .array;
}


Where maybeTo is similar to std.conv.to but returns a Nullable!T 
(https://d.puremagic.com/issues/show_bug.cgi?id=6840 ).

Probably it's a good idea to add to Phobos some more functions 
(like filterMap) that manage ranges of Nullables in a smarter way 
(this is also quite commonly done in Scala language).

Bye,
bearophile
Aug 16 2014
parent reply "b" <yes no.com> writes:
rust makes me sad. So good. Unique types. Type classes. Nice. 
Wait.

no.. overloading...

why.........
Aug 16 2014
parent reply Ziad Hatahet via Digitalmars-d <digitalmars-d puremagic.com> writes:
On Sat, Aug 16, 2014 at 8:01 AM, b via Digitalmars-d <
digitalmars-d puremagic.com> wrote:


 no.. overloading...

 why.........


Some form of overloading is possible using traits and generics.

--
Ziad
Aug 17 2014
parent "Paulo Pinto" <pjmlp progtools.org> writes:
On Monday, 18 August 2014 at 04:32:42 UTC, Ziad Hatahet via 
Digitalmars-d wrote:

 On Sat, Aug 16, 2014 at 8:01 AM, b via Digitalmars-d <
 digitalmars-d puremagic.com> wrote:


 no.. overloading...

 why.........


 Some form of overloading is possible using traits and generics.

 --
 Ziad


And currying
Aug 17 2014