Skip to content
体验新版
项目
组织
正在加载...
登录
切换导航
打开侧边栏
梦境迷离
Cs Summary Reflection
提交
de952b23
C
Cs Summary Reflection
项目概览
梦境迷离
/
Cs Summary Reflection
12 个月 前同步成功
通知
4
Star
1
Fork
0
代码
文件
提交
分支
Tags
贡献者
分支图
Diff
Issue
0
列表
看板
标记
里程碑
合并请求
0
DevOps
流水线
流水线任务
计划
Wiki
0
Wiki
分析
仓库
DevOps
项目成员
Pages
C
Cs Summary Reflection
项目概览
项目概览
详情
发布
仓库
仓库
文件
提交
分支
标签
贡献者
分支图
比较
Issue
0
Issue
0
列表
看板
标记
里程碑
合并请求
0
合并请求
0
Pages
DevOps
DevOps
流水线
流水线任务
计划
分析
分析
仓库分析
DevOps
Wiki
0
Wiki
成员
成员
收起侧边栏
关闭侧边栏
动态
分支图
创建新Issue
流水线任务
提交
Issue看板
体验新版 GitCode,发现更多精彩内容 >>
提交
de952b23
编写于
3月 07, 2020
作者:
梦境迷离
浏览文件
操作
浏览文件
下载
电子邮件补丁
差异文件
add rust function closures
上级
c2bf124e
变更
3
隐藏空白更改
内联
并排
Showing
3 changed file
with
348 addition
and
0 deletion
+348
-0
rust-examples/src/closures.rs
rust-examples/src/closures.rs
+232
-0
rust-examples/src/functions.rs
rust-examples/src/functions.rs
+110
-0
rust-examples/src/main.rs
rust-examples/src/main.rs
+6
-0
未找到文件。
rust-examples/src/closures.rs
0 → 100644
浏览文件 @
de952b23
///闭包
//by reference: &T 默认
//by mutable reference: &mut T
//by value: T
pub
fn
closures
()
{
//闭包是lambda,一个表达式可以省略大括号
fn
function
(
i
:
i32
)
->
i32
{
i
+
1
}
let
closure_annotated
=
|
i
:
i32
|
->
i32
{
i
+
1
};
let
closure_inferred
=
|
i
|
i
+
1
;
let
i
=
1
;
println!
(
"function: {}"
,
function
(
i
));
println!
(
"closure_annotated: {}"
,
closure_annotated
(
i
));
println!
(
"closure_inferred: {}"
,
closure_inferred
(
i
));
let
one
=
||
1
;
println!
(
"closure returning one: {}"
,
one
());
capturing
();
let
haystack
=
vec!
[
1
,
2
,
3
];
let
contains
=
move
|
needle
|
haystack
.contains
(
needle
);
println!
(
"{}"
,
contains
(
&
1
));
println!
(
"{}"
,
contains
(
&
4
));
//println!("There're {} elements in vec", haystack.len());
input_parameters
();
type_anonymity
();
input_functions
();
output_parameters
();
closures_std
();
higher_order_functions
();
diverging_functions
();
}
fn
capturing
()
{
use
std
::
mem
;
let
color
=
"green"
;
let
print
=
||
println!
(
"`color`: {}"
,
color
);
print
();
let
_
reborrow
=
&
color
;
//闭包使用的color能被继续借用
print
();
//直到最后一次使用print
let
_
color_moved
=
color
;
//最后使用`print`后允许移动或重新借用
let
mut
count
=
0
;
let
mut
inc
=
||
{
count
+=
1
;
println!
(
"`count`: {}"
,
count
);
};
inc
();
//let _reborrow = &count;//已经被作为可变的借用出去,不可再借用给不可变的
inc
();
let
_
count_reborrowed
=
&
mut
count
;
//非copy的,被移动进闭包
let
movable
=
Box
::
new
(
3
);
let
consume
=
||
{
println!
(
"`movable`: {:?}"
,
movable
);
mem
::
drop
(
movable
);
};
consume
();
//仅能被使用一次。
}
fn
input_parameters
()
{
//以闭包作为参数并调用它的函数。
fn
apply
<
F
>
(
f
:
F
)
where
// The closure takes no input and returns nothing.
F
:
FnOnce
()
{
//按值捕获
// ^ TODO: Try changing this to `Fn` or `FnMut`.
f
();
}
// A function which takes a closure and returns an `i32`.
fn
apply_to_3
<
F
>
(
f
:
F
)
->
i32
where
F
:
Fn
(
i32
)
->
i32
{
f
(
3
)
}
use
std
::
mem
;
let
greeting
=
"hello"
;
//从借来的引用创建自己拥有的数据
let
mut
farewell
=
"goodbye"
.to_owned
();
let
diary
=
||
{
println!
(
"I said {}."
,
greeting
);
//捕获引用
farewell
.push_str
(
"!!!"
);
//捕获可变引用
println!
(
"Then I screamed {}."
,
farewell
);
println!
(
"Now I can sleep. zzzzz"
);
mem
::
drop
(
farewell
);
//捕获值
};
apply
(
diary
);
let
double
=
|
x
|
2
*
x
;
println!
(
"3 doubled: {}"
,
apply_to_3
(
double
));
}
fn
type_anonymity
()
{
// `F`必须是泛型的
fn
apply
<
F
>
(
f
:
F
)
where
F
:
FnOnce
()
{
f
();
}
}
fn
input_functions
()
{
//无返回值的
fn
call_me
<
F
:
Fn
()
>
(
f
:
F
)
{
f
();
}
fn
function
()
{
println!
(
"I'm a function!"
);
}
//满足Fn的闭包
let
closure
=
||
println!
(
"I'm a closure!"
);
call_me
(
closure
);
call_me
(
function
);
}
fn
output_parameters
()
{
fn
create_fn
()
->
impl
Fn
()
{
//必须使用move关键字,强制按值捕获避免函数退出时通过引用捕获的被丢弃而留下无效引用
let
text
=
"Fn"
.to_owned
();
move
||
println!
(
"This is a: {}"
,
text
)
}
fn
create_fnmut
()
->
impl
FnMut
()
{
let
text
=
"FnMut"
.to_owned
();
move
||
println!
(
"This is a: {}"
,
text
)
}
fn
create_fnonce
()
->
impl
FnOnce
()
{
let
text
=
"FnOnce"
.to_owned
();
move
||
println!
(
"This is a: {}"
,
text
)
}
let
fn_plain
=
create_fn
();
let
mut
fn_mut
=
create_fnmut
();
let
fn_once
=
create_fnonce
();
fn_plain
();
fn_mut
();
fn_once
();
}
///https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.find
fn
closures_std
()
{
//any
let
vec1
=
vec!
[
1
,
2
,
3
];
let
vec2
=
vec!
[
4
,
5
,
6
];
println!
(
"2 in vec1: {}"
,
vec1
.iter
()
.any
(|
&
x
|
x
==
2
));
//不消耗集合,使用引用捕获
println!
(
"2 in vec2: {}"
,
vec2
.into_iter
()
.any
(|
x
|
x
==
2
));
//消耗集合,使用值捕获
let
array1
=
[
1
,
2
,
3
];
let
array2
=
[
4
,
5
,
6
];
println!
(
"2 in array1: {}"
,
array1
.iter
()
.any
(|
&
x
|
x
==
2
));
println!
(
"2 in array2: {}"
,
array2
.into_iter
()
.any
(|
&
x
|
x
==
2
));
//find
let
vec1
=
vec!
[
1
,
2
,
3
];
let
vec2
=
vec!
[
4
,
5
,
6
];
let
mut
iter
=
vec1
.iter
();
//&i32
let
mut
into_iter
=
vec2
.into_iter
();
//i32
println!
(
"Find 2 in vec1: {:?}"
,
iter
.find
(|
&&
x
|
x
==
2
));
//`&&i32` to `i32`
println!
(
"Find 2 in vec2: {:?}"
,
into_iter
.find
(|
&
x
|
x
==
2
));
//`&i32` to `i32`
let
array1
=
[
1
,
2
,
3
];
let
array2
=
[
4
,
5
,
6
];
println!
(
"Find 2 in array1: {:?}"
,
array1
.iter
()
.find
(|
&&
x
|
x
==
2
));
println!
(
"Find 2 in array2: {:?}"
,
array2
.into_iter
()
.find
(|
&&
x
|
x
==
2
));
//position index
let
vec
=
vec!
[
1
,
9
,
3
,
3
,
13
,
2
];
let
index_of_first_even_number
=
vec
.iter
()
.position
(|
x
|
x
%
2
==
0
);
assert_eq!
(
index_of_first_even_number
,
Some
(
5
));
let
index_of_first_negative_number
=
vec
.iter
()
.position
(|
x
|
x
<
&
0
);
assert_eq!
(
index_of_first_negative_number
,
None
);
//into_iter这个只能放最后,会消耗集合,会从左到右移动每个元素,之后集合不可用
let
index_of_first_even_number
=
vec
.into_iter
()
.position
(|
x
|
x
%
2
==
0
);
assert_eq!
(
index_of_first_even_number
,
Some
(
5
));
}
fn
higher_order_functions
()
{
fn
is_odd
(
n
:
u32
)
->
bool
{
n
%
2
==
1
}
println!
(
"Find the sum of all the squared odd numbers under 1000"
);
let
upper
=
1000
;
let
mut
acc
=
0
;
for
n
in
0
..
{
//无穷大
let
n_squared
=
n
*
n
;
if
n_squared
>=
upper
{
break
;
}
else
if
is_odd
(
n_squared
)
{
acc
+=
n_squared
;
}
}
println!
(
"imperative style: {}"
,
acc
);
//函数式风格
let
sum_of_squared_odd_numbers
:
u32
=
(
0
..
)
.map
(|
n
|
n
*
n
)
.take_while
(|
&
n_squared
|
n_squared
<
upper
)
.filter
(|
&
n_squared
|
is_odd
(
n_squared
))
// That are odd
.fold
(
0
,
|
acc
,
n_squared
|
acc
+
n_squared
);
// Sum them
println!
(
"functional style: {}"
,
sum_of_squared_odd_numbers
);
}
fn
diverging_functions
()
{
fn
foo
()
->
!
{
panic!
(
"This call never returns."
);
}
//尽管返回值中没有信息,但该函数照常返回。
fn
some_fn
()
{
()
}
let
a
:
()
=
some_fn
();
println!
(
"This function returns and you can see this line."
);
//该函数永远不会将控制流返回给调用者。直接抛出恐慌
//let x= panic!("This call never returns.");
println!
(
"You will never see this line!"
);
fn
sum_odd_numbers
(
up_to
:
u32
)
->
u32
{
let
mut
acc
=
0
;
for
i
in
0
..
up_to
{
let
addition
:
u32
=
match
i
%
2
==
1
{
true
=>
i
,
false
=>
continue
,
//不返还,不违反match
};
acc
+=
addition
;
}
acc
}
println!
(
"Sum of odd numbers up to 9 (excluding): {}"
,
sum_odd_numbers
(
9
));
//println!("{}", foo()) //error This call never returns.
}
\ No newline at end of file
rust-examples/src/functions.rs
0 → 100644
浏览文件 @
de952b23
///函数
pub
fn
functions
()
{
fizzbuzz
(
1
);
fizzbuzz_to
(
1
);
methods
();
}
fn
is_divisible_by
(
lhs
:
u32
,
rhs
:
u32
)
->
bool
{
//提前返回
if
rhs
==
0
{
return
false
;
}
//最后的return 不是必须的
lhs
%
rhs
==
0
}
//没有返回值: ()
fn
fizzbuzz
(
n
:
u32
)
->
()
{
if
is_divisible_by
(
n
,
15
)
{
println!
(
"fizzbuzz"
);
}
else
if
is_divisible_by
(
n
,
3
)
{
println!
(
"fizz"
);
}
else
if
is_divisible_by
(
n
,
5
)
{
println!
(
"buzz"
);
}
else
{
println!
(
"{}"
,
n
);
}
}
//反回: () 可以省略
fn
fizzbuzz_to
(
n
:
u32
)
{
for
n
in
1
..
n
+
1
{
fizzbuzz
(
n
);
}
}
//方法是附加给对象的函数,这些方法可以通过self关键字访问对象及其其他方法的数据
fn
methods
()
{
struct
Point
{
x
:
f64
,
y
:
f64
,
}
impl
Point
{
//对象的静态方法
fn
origin
()
->
Point
{
Point
{
x
:
0.0
,
y
:
0.0
}
}
fn
new
(
x
:
f64
,
y
:
f64
)
->
Point
{
Point
{
x
,
y
}
}
}
struct
Rectangle
{
p1
:
Point
,
p2
:
Point
,
}
impl
Rectangle
{
fn
area
(
&
self
)
->
f64
{
let
Point
{
x
:
x1
,
y
:
y1
}
=
self
.p1
;
let
Point
{
x
:
x2
,
y
:
y2
}
=
self
.p2
;
((
x1
-
x2
)
*
(
y1
-
y2
))
.abs
()
}
//对象的方法
fn
perimeter
(
&
self
)
->
f64
{
let
Point
{
x
:
x1
,
y
:
y1
}
=
self
.p1
;
let
Point
{
x
:
x2
,
y
:
y2
}
=
self
.p2
;
2.0
*
((
x1
-
x2
)
.abs
()
+
(
y1
-
y2
)
.abs
())
}
fn
translate
(
&
mut
self
,
x
:
f64
,
y
:
f64
)
{
self
.p1.x
+=
x
;
self
.p2.x
+=
x
;
self
.p1.y
+=
y
;
self
.p2.y
+=
y
;
}
}
struct
Pair
(
Box
<
i32
>
,
Box
<
i32
>
);
impl
Pair
{
fn
destroy
(
self
)
{
let
Pair
(
first
,
second
)
=
self
;
println!
(
"Destroying Pair({}, {})"
,
first
,
second
);
}
}
let
rectangle
=
Rectangle
{
//静态方法使用双冒号
p1
:
Point
::
origin
(),
p2
:
Point
::
new
(
3.0
,
4.0
),
};
println!
(
"Rectangle perimeter: {}"
,
rectangle
.perimeter
());
println!
(
"Rectangle area: {}"
,
rectangle
.area
());
let
mut
square
=
Rectangle
{
p1
:
Point
::
origin
(),
p2
:
Point
::
new
(
1.0
,
1.0
),
};
square
.translate
(
1.0
,
1.0
);
let
pair
=
Pair
(
Box
::
new
(
1
),
Box
::
new
(
2
));
pair
.destroy
();
}
rust-examples/src/main.rs
浏览文件 @
de952b23
use
std
::
fmt
;
use
std
::
fmt
::{
Display
,
Error
,
Formatter
};
use
crate
::
closures
::
*
;
use
crate
::
conversion
::
*
;
use
crate
::
custom_types
::
*
;
use
crate
::
flow_control
::
*
;
use
crate
::
formatted_print
::
*
;
use
crate
::
functions
::
*
;
use
crate
::
primitives
::
*
;
use
crate
::
types
::
*
;
use
crate
::
variable_bindings
::
*
;
pub
mod
formatted_print
;
pub
mod
functions
;
pub
mod
flow_control
;
pub
mod
closures
;
pub
mod
conversion
;
pub
mod
types
;
pub
mod
primitives
;
...
...
@@ -25,4 +29,6 @@ fn main() {
types
();
conversion
();
flow_control
();
functions
();
closures
();
}
编辑
预览
Markdown
is supported
0%
请重试
或
添加新附件
.
添加附件
取消
You are about to add
0
people
to the discussion. Proceed with caution.
先完成此消息的编辑!
取消
想要评论请
注册
或
登录