Document not found (404)
+This URL is invalid, sorry. Please use the navigation bar or search to continue.
+ + +"),i.setHtml(f),i.show(),t._signal("showGutterTooltip",i),t.on("mousewheel",c);if(e.$tooltipFollowsMouse)h(u);else{var p=u.domEvent.target,d=p.getBoundingClientRect(),v=i.getElement().style;v.left=d.right+"px",v.top=d.bottom+"px"}}function c(){o&&(o=clearTimeout(o)),f&&(i.hide(),f=null,t._signal("hideGutterTooltip",i),t.removeEventListener("mousewheel",c))}function h(e){i.setPosition(e.x,e.y)}var t=e.editor,n=t.renderer.$gutterLayer,i=new a(t.container);e.editor.setDefaultHandler("guttermousedown",function(r){if(!t.isFocused()||r.getButton()!=0)return;var i=n.getRegion(r);if(i=="foldWidgets")return;var s=r.getDocumentPosition().row,o=t.session.selection;if(r.getShiftKey())o.selectTo(s,0);else{if(r.domEvent.detail==2)return t.selectAll(),r.preventDefault();e.$clickSelection=t.selection.getLineRange(s)}return e.setState("selectByLines"),e.captureMouse(r),r.preventDefault()});var o,u,f;e.editor.setDefaultHandler("guttermousemove",function(t){var n=t.domEvent.target||t.domEvent.srcElement;if(r.hasCssClass(n,"ace_fold-widget"))return c();f&&e.$tooltipFollowsMouse&&h(t),u=t;if(o)return;o=setTimeout(function(){o=null,u&&!e.isMousePressed?l():c()},50)}),s.addListener(t.renderer.$gutter,"mouseout",function(e){u=null;if(!f||o)return;o=setTimeout(function(){o=null,c()},50)}),t.on("changeSession",c)}function a(e){o.call(this,e)}var r=e("../lib/dom"),i=e("../lib/oop"),s=e("../lib/event"),o=e("../tooltip").Tooltip;i.inherits(a,o),function(){this.setPosition=function(e,t){var n=window.innerWidth||document.documentElement.clientWidth,r=window.innerHeight||document.documentElement.clientHeight,i=this.getWidth(),s=this.getHeight();e+=15,t+=15,e+i>n&&(e-=e+i-n),t+s>r&&(t-=20+s),o.prototype.setPosition.call(this,e,t)}}.call(a.prototype),t.GutterHandler=u}),ace.define("ace/mouse/mouse_event",["require","exports","module","ace/lib/event","ace/lib/useragent"],function(e,t,n){"use strict";var r=e("../lib/event"),i=e("../lib/useragent"),s=t.MouseEvent=function(e,t){this.domEvent=e,this.editor=t,this.x=this.clientX=e.clientX,this.y=this.clientY=e.clientY,this.$pos=null,this.$inSelection=null,this.propagationStopped=!1,this.defaultPrevented=!1};(function(){this.stopPropagation=function(){r.stopPropagation(this.domEvent),this.propagationStopped=!0},this.preventDefault=function(){r.preventDefault(this.domEvent),this.defaultPrevented=!0},this.stop=function(){this.stopPropagation(),this.preventDefault()},this.getDocumentPosition=function(){return this.$pos?this.$pos:(this.$pos=this.editor.renderer.screenToTextCoordinates(this.clientX,this.clientY),this.$pos)},this.inSelection=function(){if(this.$inSelection!==null)return this.$inSelection;var e=this.editor,t=e.getSelectionRange();if(t.isEmpty())this.$inSelection=!1;else{var n=this.getDocumentPosition();this.$inSelection=t.contains(n.row,n.column)}return this.$inSelection},this.getButton=function(){return r.getButton(this.domEvent)},this.getShiftKey=function(){return this.domEvent.shiftKey},this.getAccelKey=i.isMac?function(){return this.domEvent.metaKey}:function(){return this.domEvent.ctrlKey}}).call(s.prototype)}),ace.define("ace/mouse/dragdrop_handler",["require","exports","module","ace/lib/dom","ace/lib/event","ace/lib/useragent"],function(e,t,n){"use strict";function f(e){function T(e,n){var r=Date.now(),i=!n||e.row!=n.row,s=!n||e.column!=n.column;if(!S||i||s)t.moveCursorToPosition(e),S=r,x={x:p,y:d};else{var o=l(x.x,x.y,p,d);o>a?S=null:r-S>=u&&(t.renderer.scrollCursorIntoView(),S=null)}}function N(e,n){var r=Date.now(),i=t.renderer.layerConfig.lineHeight,s=t.renderer.layerConfig.characterWidth,u=t.renderer.scroller.getBoundingClientRect(),a={x:{left:p-u.left,right:u.right-p},y:{top:d-u.top,bottom:u.bottom-d}},f=Math.min(a.x.left,a.x.right),l=Math.min(a.y.top,a.y.bottom),c={row:e.row,column:e.column};f/s<=2&&(c.column+=a.x.left
"),p.appendChild(i.createElement("div"));var m=function(e,t,n){if(t===0&&(n==="esc"||n==="return"))return h.destroy(),{command:"null"}};h.destroy=function(){if(e.$mouseHandler.isMousePressed)return;e.keyBinding.removeKeyboardHandler(m),n.widgetManager.removeLineWidget(h),e.off("changeSelection",h.destroy),e.off("changeSession",h.destroy),e.off("mouseup",h.destroy),e.off("change",h.destroy)},e.keyBinding.addKeyboardHandler(m),e.on("changeSelection",h.destroy),e.on("changeSession",h.destroy),e.on("mouseup",h.destroy),e.on("change",h.destroy),e.session.widgetManager.addLineWidget(h),h.el.onmousedown=e.focus.bind(e),e.renderer.scrollCursorIntoView(null,.5,{bottom:h.el.offsetHeight})},i.importCssString(" .error_widget_wrapper { background: inherit; color: inherit; border:none } .error_widget { border-top: solid 2px; border-bottom: solid 2px; margin: 5px 0; padding: 10px 40px; white-space: pre-wrap; } .error_widget.ace_error, .error_widget_arrow.ace_error{ border-color: #ff5a5a } .error_widget.ace_warning, .error_widget_arrow.ace_warning{ border-color: #F1D817 } .error_widget.ace_info, .error_widget_arrow.ace_info{ border-color: #5a5a5a } .error_widget.ace_ok, .error_widget_arrow.ace_ok{ border-color: #5aaa5a } .error_widget_arrow { position: absolute; border: solid 5px; border-top-color: transparent!important; border-right-color: transparent!important; border-left-color: transparent!important; top: -5px; }","")}),ace.define("ace/ace",["require","exports","module","ace/lib/fixoldbrowsers","ace/lib/dom","ace/lib/event","ace/range","ace/editor","ace/edit_session","ace/undomanager","ace/virtual_renderer","ace/worker/worker_client","ace/keyboard/hash_handler","ace/placeholder","ace/multi_select","ace/mode/folding/fold_mode","ace/theme/textmate","ace/ext/error_marker","ace/config"],function(e,t,n){"use strict";e("./lib/fixoldbrowsers");var r=e("./lib/dom"),i=e("./lib/event"),s=e("./range").Range,o=e("./editor").Editor,u=e("./edit_session").EditSession,a=e("./undomanager").UndoManager,f=e("./virtual_renderer").VirtualRenderer;e("./worker/worker_client"),e("./keyboard/hash_handler"),e("./placeholder"),e("./multi_select"),e("./mode/folding/fold_mode"),e("./theme/textmate"),e("./ext/error_marker"),t.config=e("./config"),t.require=e,typeof define=="function"&&(t.define=define),t.edit=function(e,n){if(typeof e=="string"){var s=e;e=document.getElementById(s);if(!e)throw new Error("ace.edit can't find div #"+s)}if(e&&e.env&&e.env.editor instanceof o)return e.env.editor;var u="";if(e&&/input|textarea/i.test(e.tagName)){var a=e;u=a.value,e=r.createElement("pre"),a.parentNode.replaceChild(e,a)}else e&&(u=e.textContent,e.innerHTML="");var l=t.createEditSession(u),c=new o(new f(e),l,n),h={document:l,editor:c,onResize:c.resize.bind(c,null)};return a&&(h.textarea=a),i.addListener(window,"resize",h.onResize),c.on("destroy",function(){i.removeListener(window,"resize",h.onResize),h.editor.container.env=null}),c.container.env=c.env=h,c},t.createEditSession=function(e,t){var n=new u(e,t);return n.setUndoManager(new a),n},t.Range=s,t.Editor=o,t.EditSession=u,t.UndoManager=a,t.VirtualRenderer=f,t.version="1.4.4"}); (function() { + ace.require(["ace/ace"], function(a) { + if (a) { + a.config.init(true); + a.define = ace.define; + } + if (!window.ace) + window.ace = a; + for (var key in a) if (a.hasOwnProperty(key)) + window.ace[key] = a[key]; + window.ace["default"] = window.ace; + if (typeof module == "object" && typeof exports == "object" && module) { + module.exports = window.ace; + } + }); + })(); diff --git a/assets/custom3.js b/assets/custom3.js new file mode 100644 index 000000000..3f70daa4e --- /dev/null +++ b/assets/custom3.js @@ -0,0 +1,156 @@ +var initAll = function () { + var path = window.location.pathname; + if (path.endsWith("/print.html")) { + return; + } + + var images = document.querySelectorAll("main img") + Array.prototype.forEach.call(images, function (img) { + img.addEventListener("click", function () { + BigPicture({ + el: img, + }); + }); + }); + + // Un-active everything when you click it + Array.prototype.forEach.call(document.getElementsByClassName("pagetoc")[0].children, function (el) { + el.addEventHandler("click", function () { + Array.prototype.forEach.call(document.getElementsByClassName("pagetoc")[0].children, function (el) { + el.classList.remove("active"); + }); + el.classList.add("active"); + }); + }); + + var updateFunction = function () { + var id = null; + var elements = document.getElementsByClassName("header"); + Array.prototype.forEach.call(elements, function (el) { + if (window.pageYOffset >= el.offsetTop) { + id = el; + } + }); + + Array.prototype.forEach.call(document.getElementsByClassName("pagetoc")[0].children, function (el) { + el.classList.remove("active"); + }); + + Array.prototype.forEach.call(document.getElementsByClassName("pagetoc")[0].children, function (el) { + if (id == null) { + return; + } + if (id.href.localeCompare(el.href) == 0) { + el.classList.add("active"); + } + }); + }; + + var pagetoc = document.getElementsByClassName("pagetoc")[0]; + var elements = document.getElementsByClassName("header"); + Array.prototype.forEach.call(elements, function (el) { + var link = document.createElement("a"); + + // Indent shows hierarchy + var indent = ""; + switch (el.parentElement.tagName) { + case "H1": + return; + case "H3": + indent = "20px"; + break; + case "H4": + indent = "40px"; + break; + default: + break; + } + + link.appendChild(document.createTextNode(el.text)); + link.style.paddingLeft = indent; + link.href = el.href; + pagetoc.appendChild(link); + }); + updateFunction.call(); + + // Handle active elements on scroll + window.addEventListener("scroll", updateFunction); + + document.getElementById("theme-list").addEventListener("click", function (e) { + var iframe = document.querySelector('.giscus-frame'); + if (!iframe) return; + var theme; + if (e.target.className === "theme") { + theme = e.target.id; + } else { + return; + } + + // 若当前 mdbook 主题不是 Light 或 Rust ，则将 giscuz 主题设置为 transparent_dark + var giscusTheme = "light" + if (theme != "light" && theme != "rust") { + giscusTheme = "transparent_dark"; + } + + var msg = { + setConfig: { + theme: giscusTheme + } + }; + iframe.contentWindow.postMessage({ giscus: msg }, 'https://giscus.app'); + }); + + pagePath = pagePath.replace("index.md", ""); + pagePath = pagePath.replace(".md", ""); + if (pagePath.length > 0) { + if (pagePath.charAt(pagePath.length-1) == "/"){ + pagePath = pagePath.substring(0, pagePath.length-1) + } + }else { + pagePath = "index" + } + + // add visitors count + var ele = document.createElement("div"); + ele.setAttribute("align","center"); + var count = document.createElement("img") + // count.setAttribute("src", "https://visitor-badge.glitch.me/badge?page_id=practice/en/" + path); + count.setAttribute("src", "https://api.visitorbadge.io/api/visitors?labelColor=%23595959&countColor=%230d81c3&style=flat-square&path=practice/en/" + path); + ele.appendChild(count); + var divider =document.createElement("hr") + + document.getElementById("giscus-container").appendChild(ele); + document.getElementById("giscus-container").appendChild(divider); + + // 选取浏览器默认使用的语言 + const lang = navigator.language || navigator.userLanguage + + // 若当前 mdbook 主题为 Light 或 Rust ，则将 giscuz 主题设置为 light + var theme = "transparent_dark"; + const themeClass = document.getElementsByTagName("html")[0].className; + if (themeClass.indexOf("light") != -1 || themeClass.indexOf("rust") != -1) { + theme = "light" + } + + var script = document.createElement("script") + script.type = "text/javascript"; + script.src = "https://giscus.app/client.js"; + script.async = true; + script.crossOrigin = "anonymous"; + script.setAttribute("data-repo", "sunface/rust-by-practice"); + script.setAttribute("data-repo-id", "MDEwOlJlcG9zaXRvcnkxMjk5OTAzOTY="); + script.setAttribute("data-category", "Book Comments"); + script.setAttribute("data-category-id", "DIC_kwDOB79-_M4COQmx"); + script.setAttribute("data-mapping", "specific"); + script.setAttribute("data-term", pagePath); + script.setAttribute("data-reactions-enabled", "1"); + script.setAttribute("data-emit-metadata", "0"); + script.setAttribute("data-input-position", "top"); + script.setAttribute("data-theme", theme); + script.setAttribute("data-lang", lang == 'en-US' ? 'en' : lang); + // 预先加载评论会更好，这样用户读到那边时，评论就加载好了 + // script.setAttribute("data-loading", "lazy"); + document.getElementById("giscus-container").appendChild(script); +}; + +window.addEventListener('load', initAll); \ No newline at end of file diff --git a/assets/lang.js b/assets/lang.js new file mode 100644 index 000000000..061d37586 --- /dev/null +++ b/assets/lang.js @@ -0,0 +1,26 @@ +(function () { + var path = window.location.pathname; + var link = "https://practice.rs" + path; + var word = "English"; + var lang = "zh-CN"; + var changeLang = "切换到英语"; + + if (window.location.href.indexOf("zh.") == -1) { + link = "https://zh.practice.rs" + path; + word = "简体中文"; + lang = "en"; + changeLang = "Switch to Chinese" + } + + var lang_node = ''; + if (link != '') { + lang_node = ' ' + word + ''; + } + + console.log(lang_node) + var insertNode = document.getElementsByClassName('right-buttons'); + if (insertNode.length > 0) { + var html = insertNode[0].innerHTML; + insertNode[0].innerHTML = html + lang_node; + } + })() \ No newline at end of file diff --git a/async/async-await.html b/async/async-await.html new file mode 100644 index 000000000..a1d43b4b4 --- /dev/null +++ b/async/async-await.html @@ -0,0 +1,216 @@ + + + + + +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/async/future.html b/async/future.html
new file mode 100644
index 000000000..660976de7
--- /dev/null
+++ b/async/future.html
@@ -0,0 +1,216 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ async and await!
+ + +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/async/intro.html b/async/intro.html
new file mode 100644
index 000000000..c4acb4911
--- /dev/null
+++ b/async/intro.html
@@ -0,0 +1,216 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Future
+ + +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/async/pin-unpin.html b/async/pin-unpin.html
new file mode 100644
index 000000000..f29fb048a
--- /dev/null
+++ b/async/pin-unpin.html
@@ -0,0 +1,216 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Async/Await
+ + +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/async/stream.html b/async/stream.html
new file mode 100644
index 000000000..460804bf2
--- /dev/null
+++ b/async/stream.html
@@ -0,0 +1,216 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Pin and Unpin
+ + +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/ayu-highlight.css b/ayu-highlight.css
new file mode 100644
index 000000000..32c943222
--- /dev/null
+++ b/ayu-highlight.css
@@ -0,0 +1,78 @@
+/*
+Based off of the Ayu theme
+Original by Dempfi (https://github.com/dempfi/ayu)
+*/
+
+.hljs {
+ display: block;
+ overflow-x: auto;
+ background: #191f26;
+ color: #e6e1cf;
+}
+
+.hljs-comment,
+.hljs-quote {
+ color: #5c6773;
+ font-style: italic;
+}
+
+.hljs-variable,
+.hljs-template-variable,
+.hljs-attribute,
+.hljs-attr,
+.hljs-regexp,
+.hljs-link,
+.hljs-selector-id,
+.hljs-selector-class {
+ color: #ff7733;
+}
+
+.hljs-number,
+.hljs-meta,
+.hljs-builtin-name,
+.hljs-literal,
+.hljs-type,
+.hljs-params {
+ color: #ffee99;
+}
+
+.hljs-string,
+.hljs-bullet {
+ color: #b8cc52;
+}
+
+.hljs-title,
+.hljs-built_in,
+.hljs-section {
+ color: #ffb454;
+}
+
+.hljs-keyword,
+.hljs-selector-tag,
+.hljs-symbol {
+ color: #ff7733;
+}
+
+.hljs-name {
+ color: #36a3d9;
+}
+
+.hljs-tag {
+ color: #00568d;
+}
+
+.hljs-emphasis {
+ font-style: italic;
+}
+
+.hljs-strong {
+ font-weight: bold;
+}
+
+.hljs-addition {
+ color: #91b362;
+}
+
+.hljs-deletion {
+ color: #d96c75;
+}
diff --git a/basic-types/char-bool-unit.html b/basic-types/char-bool-unit.html
new file mode 100644
index 000000000..3763753b1
--- /dev/null
+++ b/basic-types/char-bool-unit.html
@@ -0,0 +1,309 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Stream
+ + +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/basic-types/functions.html b/basic-types/functions.html
new file mode 100644
index 000000000..15d119536
--- /dev/null
+++ b/basic-types/functions.html
@@ -0,0 +1,309 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Char, Bool and Unit
+Char
+-
+
- 🌟 +
++// Make it work +use std::mem::size_of_val; +fn main() { + let c1 = 'a'; + assert_eq!(size_of_val(&c1),1); + + let c2 = '中'; + assert_eq!(size_of_val(&c2),3); + + println!("Success!"); +}
-
+
- 🌟 +
++// Make it work +fn main() { + let c1 = "中"; + print_char(c1); +} + +fn print_char(c : char) { + println!("{}", c); +}
Bool
+-
+
- 🌟 +
++// Make println! work +fn main() { + let _f: bool = false; + + let t = true; + if !t { + println!("Success!"); + } +}
-
+
- 🌟 +
++// Make it work +fn main() { + let f = true; + let t = true && false; + assert_eq!(t, f); + + println!("Success!"); +}
Unit type
+-
+
- 🌟🌟 +
++// Make it work, don't modify `implicitly_ret_unit` ! +fn main() { + let _v: () = (); + + let v = (2, 3); + assert_eq!(v, implicitly_ret_unit()); + + println!("Success!"); +} + +fn implicitly_ret_unit() { + println!("I will return a ()"); +} + +// Don't use this one +fn explicitly_ret_unit() -> () { + println!("I will return a ()"); +}
-
+
- 🌟🌟 What's the size of the unit type? +
++// Modify `4` in assert to make it work +use std::mem::size_of_val; +fn main() { + let unit: () = (); + assert!(size_of_val(&unit) == 4); + + println!("Success!"); +}
++ + +You can find the solutions here(under the solutions path), but only use it when you need it
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/basic-types/intro.html b/basic-types/intro.html
new file mode 100644
index 000000000..ceb9e0cd7
--- /dev/null
+++ b/basic-types/intro.html
@@ -0,0 +1,221 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Functions
+-
+
- 🌟🌟🌟 +
++fn main() { + // Don't modify the following two lines! + let (x, y) = (1, 2); + let s = sum(x, y); + + assert_eq!(s, 3); + + println!("Success!"); +} + +fn sum(x, y: i32) { + x + y; +}
-
+
- 🌟 +
+fn main() { + print(); +} + +// Replace i32 with another type +fn print() -> i32 { + println!("Success!"); +}
-
+
- 🌟🌟🌟 +
+// Solve it in two ways +// DON'T let `println!` work +fn main() { + never_return(); + + println!("Failed!"); +} + +fn never_return() -> ! { + // Implement this function, don't modify the fn signatures + +}
Diverging functions
+Diverging functions never return to the caller, so they may be used in places where a value of any type is expected.
+-
+
- 🌟🌟 +
++fn main() { + println!("Success!"); +} + +fn get_option(tp: u8) -> Option<i32> { + match tp { + 1 => { + // TODO + } + _ => { + // TODO + } + }; + + // Rather than returning a None, we use a diverging function instead + never_return_fn() +} + +// IMPLEMENT this function in THREE ways +fn never_return_fn() -> ! { + +}
-
+
- 🌟🌟 +
++fn main() { + // FILL in the blank + let b = __; + + let _v = match b { + true => 1, + // Diverging functions can also be used in match expression to replace a value of any value + false => { + println!("Success!"); + panic!("we have no value for `false`, but we can panic"); + } + }; + + println!("Exercise Failed if printing out this line!"); +}
++ + +You can find the solutions here(under the solutions path), but only use it when you need it
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/basic-types/numbers.html b/basic-types/numbers.html
new file mode 100644
index 000000000..da0d2fce0
--- /dev/null
+++ b/basic-types/numbers.html
@@ -0,0 +1,385 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Basic Types
+Learning resources:
+-
+
- English: Rust Book 3.2 and 3.3 +
- 简体中文: Rust语言圣经 - 基本类型 +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/basic-types/statements-expressions.html b/basic-types/statements-expressions.html
new file mode 100644
index 000000000..3c89c450f
--- /dev/null
+++ b/basic-types/statements-expressions.html
@@ -0,0 +1,280 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Numbers
+Integer
+-
+
- 🌟 +
++Tips: If we don't explicitly assign a type to a variable, then the compiler will infer one for us.
+
++// Remove something to make it work +fn main() { + let x: i32 = 5; + let mut y: u32 = 5; + + y = x; + + let z = 10; // Type of z ? + + println!("Success!"); +}
-
+
- 🌟 +
++// Fill the blank +fn main() { + let v: u16 = 38_u8 as __; + + println!("Success!"); +}
-
+
- 🌟🌟🌟 +
++Tips: If we don't explicitly assign a type to a variable, then the compiler will infer one for us.
+
++// Modify `assert_eq!` to make it work +fn main() { + let x = 5; + assert_eq!("u32".to_string(), type_of(&x)); + + println!("Success!"); +} + +// Get the type of given variable, return a string representation of the type , e.g "i8", "u8", "i32", "u32" +fn type_of<T>(_: &T) -> String { + format!("{}", std::any::type_name::<T>()) +}
-
+
- 🌟🌟 +
++// Fill the blanks to make it work +fn main() { + assert_eq!(i8::MAX, __); + assert_eq!(u8::MAX, __); + + println!("Success!"); +}
-
+
- 🌟🌟 +
++// Fix errors and panics to make it work +fn main() { + let v1 = 251_u8 + 8; + let v2 = i8::checked_add(251, 8).unwrap(); + println!("{},{}",v1,v2); +}
-
+
- 🌟🌟 +
++// Modify `assert!` to make it work +fn main() { + let v = 1_024 + 0xff + 0o77 + 0b1111_1111; + assert!(v == 1579); + + println!("Success!"); +}
Floating-Point
+-
+
- 🌟 +
++// Fill the blank to make it work +fn main() { + let x = 1_000.000_1; // ? + let y: f32 = 0.12; // f32 + let z = 0.01_f64; // f64 + + assert_eq!(type_of(&x), "__".to_string()); + println!("Success!"); +} + +fn type_of<T>(_: &T) -> String { + format!("{}", std::any::type_name::<T>()) +}
-
+
- 🌟🌟 Make it work in two distinct ways +
++fn main() { + assert!(0.1+0.2==0.3); + + println!("Success!"); +}
Range
+-
+
- 🌟🌟 Two goals: 1. Modify
assert!to make it work 2. Makeprintln!output: 97 - 122
+
+fn main() { + let mut sum = 0; + for i in -3..2 { + sum += i + } + + assert!(sum == -3); + + for c in 'a'..='z' { + println!("{}",c); + } +}
-
+
- 🌟🌟 +
++// Fill the blanks +use std::ops::{Range, RangeInclusive}; +fn main() { + assert_eq!((1..__), Range{ start: 1, end: 5 }); + assert_eq!((1..__), RangeInclusive::new(1, 5)); + + println!("Success!"); +}
Computations
+-
+
- 🌟 +
++// Fill the blanks and fix the errors +fn main() { + // Integer addition + assert!(1u32 + 2 == __); + + // Integer subtraction + assert!(1i32 - 2 == __); + assert!(1u8 - 2 == -1); + + assert!(3 * 50 == __); + + assert!(9.6 / 3.2 == 3.0); // error ! make it work + + assert!(24 % 5 == __); + // Short-circuiting boolean logic + assert!(true && false == __); + assert!(true || false == __); + assert!(!true == __); + + // Bitwise operations + println!("0011 AND 0101 is {:04b}", 0b0011u32 & 0b0101); + println!("0011 OR 0101 is {:04b}", 0b0011u32 | 0b0101); + println!("0011 XOR 0101 is {:04b}", 0b0011u32 ^ 0b0101); + println!("1 << 5 is {}", 1u32 << 5); + println!("0x80 >> 2 is 0x{:x}", 0x80u32 >> 2); +}
++ + +You can find the solutions here(under the solutions path), but only use it when you need it
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/book.js b/book.js
new file mode 100644
index 000000000..aa12e7ecc
--- /dev/null
+++ b/book.js
@@ -0,0 +1,697 @@
+"use strict";
+
+// Fix back button cache problem
+window.onunload = function () { };
+
+// Global variable, shared between modules
+function playground_text(playground, hidden = true) {
+ let code_block = playground.querySelector("code");
+
+ if (window.ace && code_block.classList.contains("editable")) {
+ let editor = window.ace.edit(code_block);
+ return editor.getValue();
+ } else if (hidden) {
+ return code_block.textContent;
+ } else {
+ return code_block.innerText;
+ }
+}
+
+(function codeSnippets() {
+ function fetch_with_timeout(url, options, timeout = 6000) {
+ return Promise.race([
+ fetch(url, options),
+ new Promise((_, reject) => setTimeout(() => reject(new Error('timeout')), timeout))
+ ]);
+ }
+
+ var playgrounds = Array.from(document.querySelectorAll(".playground"));
+ if (playgrounds.length > 0) {
+ fetch_with_timeout("https://play.rust-lang.org/meta/crates", {
+ headers: {
+ 'Content-Type': "application/json",
+ },
+ method: 'POST',
+ mode: 'cors',
+ })
+ .then(response => response.json())
+ .then(response => {
+ // get list of crates available in the rust playground
+ let playground_crates = response.crates.map(item => item["id"]);
+ playgrounds.forEach(block => handle_crate_list_update(block, playground_crates));
+ });
+ }
+
+ function handle_crate_list_update(playground_block, playground_crates) {
+ // update the play buttons after receiving the response
+ update_play_button(playground_block, playground_crates);
+
+ // and install on change listener to dynamically update ACE editors
+ if (window.ace) {
+ let code_block = playground_block.querySelector("code");
+ if (code_block.classList.contains("editable")) {
+ let editor = window.ace.edit(code_block);
+ editor.addEventListener("change", function (e) {
+ update_play_button(playground_block, playground_crates);
+ });
+ // add Ctrl-Enter command to execute rust code
+ editor.commands.addCommand({
+ name: "run",
+ bindKey: {
+ win: "Ctrl-Enter",
+ mac: "Ctrl-Enter"
+ },
+ exec: _editor => run_rust_code(playground_block)
+ });
+ }
+ }
+ }
+
+ // updates the visibility of play button based on `no_run` class and
+ // used crates vs ones available on https://play.rust-lang.org
+ function update_play_button(pre_block, playground_crates) {
+ var play_button = pre_block.querySelector(".play-button");
+
+ // skip if code is `no_run`
+ if (pre_block.querySelector('code').classList.contains("no_run")) {
+ play_button.classList.add("hidden");
+ return;
+ }
+
+ // get list of `extern crate`'s from snippet
+ var txt = playground_text(pre_block);
+ var re = /extern\s+crate\s+([a-zA-Z_0-9]+)\s*;/g;
+ var snippet_crates = [];
+ var item;
+ while (item = re.exec(txt)) {
+ snippet_crates.push(item[1]);
+ }
+
+ // check if all used crates are available on play.rust-lang.org
+ var all_available = snippet_crates.every(function (elem) {
+ return playground_crates.indexOf(elem) > -1;
+ });
+
+ if (all_available) {
+ play_button.classList.remove("hidden");
+ } else {
+ play_button.classList.add("hidden");
+ }
+ }
+
+ function run_rust_code(code_block) {
+ var result_block = code_block.querySelector(".result");
+ if (!result_block) {
+ result_block = document.createElement('code');
+ result_block.className = 'result hljs language-bash';
+
+ code_block.append(result_block);
+ }
+
+ let text = playground_text(code_block);
+ let classes = code_block.querySelector('code').classList;
+ let edition = "2015";
+ if(classes.contains("edition2018")) {
+ edition = "2018";
+ } else if(classes.contains("edition2021")) {
+ edition = "2021";
+ }
+ var params = {
+ version: "stable",
+ optimize: "0",
+ code: text,
+ edition: edition
+ };
+
+ if (text.indexOf("#![feature") !== -1) {
+ params.version = "nightly";
+ }
+
+ result_block.innerText = "Running...";
+
+ fetch_with_timeout("https://play.rust-lang.org/evaluate.json", {
+ headers: {
+ 'Content-Type': "application/json",
+ },
+ method: 'POST',
+ mode: 'cors',
+ body: JSON.stringify(params)
+ })
+ .then(response => response.json())
+ .then(response => {
+ if (response.result.trim() === '') {
+ result_block.innerText = "No output";
+ result_block.classList.add("result-no-output");
+ } else {
+ result_block.innerText = response.result;
+ result_block.classList.remove("result-no-output");
+ }
+ })
+ .catch(error => result_block.innerText = "Playground Communication: " + error.message);
+ }
+
+ // Syntax highlighting Configuration
+ hljs.configure({
+ tabReplace: ' ', // 4 spaces
+ languages: [], // Languages used for auto-detection
+ });
+
+ let code_nodes = Array
+ .from(document.querySelectorAll('code'))
+ // Don't highlight `inline code` blocks in headers.
+ .filter(function (node) {return !node.parentElement.classList.contains("header"); });
+
+ if (window.ace) {
+ // language-rust class needs to be removed for editable
+ // blocks or highlightjs will capture events
+ code_nodes
+ .filter(function (node) {return node.classList.contains("editable"); })
+ .forEach(function (block) { block.classList.remove('language-rust'); });
+
+ code_nodes
+ .filter(function (node) {return !node.classList.contains("editable"); })
+ .forEach(function (block) { hljs.highlightBlock(block); });
+ } else {
+ code_nodes.forEach(function (block) { hljs.highlightBlock(block); });
+ }
+
+ // Adding the hljs class gives code blocks the color css
+ // even if highlighting doesn't apply
+ code_nodes.forEach(function (block) { block.classList.add('hljs'); });
+
+ Array.from(document.querySelectorAll("code.hljs")).forEach(function (block) {
+
+ var lines = Array.from(block.querySelectorAll('.boring'));
+ // If no lines were hidden, return
+ if (!lines.length) { return; }
+ block.classList.add("hide-boring");
+
+ var buttons = document.createElement('div');
+ buttons.className = 'buttons';
+ buttons.innerHTML = "";
+
+ // add expand button
+ var pre_block = block.parentNode;
+ pre_block.insertBefore(buttons, pre_block.firstChild);
+
+ pre_block.querySelector('.buttons').addEventListener('click', function (e) {
+ if (e.target.classList.contains('fa-eye')) {
+ e.target.classList.remove('fa-eye');
+ e.target.classList.add('fa-eye-slash');
+ e.target.title = 'Hide lines';
+ e.target.setAttribute('aria-label', e.target.title);
+
+ block.classList.remove('hide-boring');
+ } else if (e.target.classList.contains('fa-eye-slash')) {
+ e.target.classList.remove('fa-eye-slash');
+ e.target.classList.add('fa-eye');
+ e.target.title = 'Show hidden lines';
+ e.target.setAttribute('aria-label', e.target.title);
+
+ block.classList.add('hide-boring');
+ }
+ });
+ });
+
+ if (window.playground_copyable) {
+ Array.from(document.querySelectorAll('pre code')).forEach(function (block) {
+ var pre_block = block.parentNode;
+ if (!pre_block.classList.contains('playground')) {
+ var buttons = pre_block.querySelector(".buttons");
+ if (!buttons) {
+ buttons = document.createElement('div');
+ buttons.className = 'buttons';
+ pre_block.insertBefore(buttons, pre_block.firstChild);
+ }
+
+ var clipButton = document.createElement('button');
+ clipButton.className = 'fa fa-copy clip-button';
+ clipButton.title = 'Copy to clipboard';
+ clipButton.setAttribute('aria-label', clipButton.title);
+ clipButton.innerHTML = '';
+
+ buttons.insertBefore(clipButton, buttons.firstChild);
+ }
+ });
+ }
+
+ // Process playground code blocks
+ Array.from(document.querySelectorAll(".playground")).forEach(function (pre_block) {
+ // Add play button
+ var buttons = pre_block.querySelector(".buttons");
+ if (!buttons) {
+ buttons = document.createElement('div');
+ buttons.className = 'buttons';
+ pre_block.insertBefore(buttons, pre_block.firstChild);
+ }
+
+ var runCodeButton = document.createElement('button');
+ runCodeButton.className = 'fa fa-play play-button';
+ runCodeButton.hidden = true;
+ runCodeButton.title = 'Run this code';
+ runCodeButton.setAttribute('aria-label', runCodeButton.title);
+
+ buttons.insertBefore(runCodeButton, buttons.firstChild);
+ runCodeButton.addEventListener('click', function (e) {
+ run_rust_code(pre_block);
+ });
+
+ if (window.playground_copyable) {
+ var copyCodeClipboardButton = document.createElement('button');
+ copyCodeClipboardButton.className = 'fa fa-copy clip-button';
+ copyCodeClipboardButton.innerHTML = '';
+ copyCodeClipboardButton.title = 'Copy to clipboard';
+ copyCodeClipboardButton.setAttribute('aria-label', copyCodeClipboardButton.title);
+
+ buttons.insertBefore(copyCodeClipboardButton, buttons.firstChild);
+ }
+
+ let code_block = pre_block.querySelector("code");
+ if (window.ace && code_block.classList.contains("editable")) {
+ var undoChangesButton = document.createElement('button');
+ undoChangesButton.className = 'fa fa-history reset-button';
+ undoChangesButton.title = 'Undo changes';
+ undoChangesButton.setAttribute('aria-label', undoChangesButton.title);
+
+ buttons.insertBefore(undoChangesButton, buttons.firstChild);
+
+ undoChangesButton.addEventListener('click', function () {
+ let editor = window.ace.edit(code_block);
+ editor.setValue(editor.originalCode);
+ editor.clearSelection();
+ });
+ }
+ });
+})();
+
+(function themes() {
+ var html = document.querySelector('html');
+ var themeToggleButton = document.getElementById('theme-toggle');
+ var themePopup = document.getElementById('theme-list');
+ var themeColorMetaTag = document.querySelector('meta[name="theme-color"]');
+ var stylesheets = {
+ ayuHighlight: document.querySelector("[href$='ayu-highlight.css']"),
+ tomorrowNight: document.querySelector("[href$='tomorrow-night.css']"),
+ highlight: document.querySelector("[href$='highlight.css']"),
+ };
+
+ function showThemes() {
+ themePopup.style.display = 'block';
+ themeToggleButton.setAttribute('aria-expanded', true);
+ themePopup.querySelector("button#" + get_theme()).focus();
+ }
+
+ function updateThemeSelected() {
+ themePopup.querySelectorAll('.theme-selected').forEach(function (el) {
+ el.classList.remove('theme-selected');
+ });
+ themePopup.querySelector("button#" + get_theme()).classList.add('theme-selected');
+ }
+
+ function hideThemes() {
+ themePopup.style.display = 'none';
+ themeToggleButton.setAttribute('aria-expanded', false);
+ themeToggleButton.focus();
+ }
+
+ function get_theme() {
+ var theme;
+ try { theme = localStorage.getItem('mdbook-theme'); } catch (e) { }
+ if (theme === null || theme === undefined) {
+ return default_theme;
+ } else {
+ return theme;
+ }
+ }
+
+ function set_theme(theme, store = true) {
+ let ace_theme;
+
+ if (theme == 'coal' || theme == 'navy') {
+ stylesheets.ayuHighlight.disabled = true;
+ stylesheets.tomorrowNight.disabled = false;
+ stylesheets.highlight.disabled = true;
+
+ ace_theme = "ace/theme/tomorrow_night";
+ } else if (theme == 'ayu') {
+ stylesheets.ayuHighlight.disabled = false;
+ stylesheets.tomorrowNight.disabled = true;
+ stylesheets.highlight.disabled = true;
+ ace_theme = "ace/theme/tomorrow_night";
+ } else {
+ stylesheets.ayuHighlight.disabled = true;
+ stylesheets.tomorrowNight.disabled = true;
+ stylesheets.highlight.disabled = false;
+ ace_theme = "ace/theme/dawn";
+ }
+
+ setTimeout(function () {
+ themeColorMetaTag.content = getComputedStyle(document.documentElement).backgroundColor;
+ }, 1);
+
+ if (window.ace && window.editors) {
+ window.editors.forEach(function (editor) {
+ editor.setTheme(ace_theme);
+ });
+ }
+
+ var previousTheme = get_theme();
+
+ if (store) {
+ try { localStorage.setItem('mdbook-theme', theme); } catch (e) { }
+ }
+
+ html.classList.remove(previousTheme);
+ html.classList.add(theme);
+ updateThemeSelected();
+ }
+
+ // Set theme
+ var theme = get_theme();
+
+ set_theme(theme, false);
+
+ themeToggleButton.addEventListener('click', function () {
+ if (themePopup.style.display === 'block') {
+ hideThemes();
+ } else {
+ showThemes();
+ }
+ });
+
+ themePopup.addEventListener('click', function (e) {
+ var theme;
+ if (e.target.className === "theme") {
+ theme = e.target.id;
+ } else if (e.target.parentElement.className === "theme") {
+ theme = e.target.parentElement.id;
+ } else {
+ return;
+ }
+ set_theme(theme);
+ });
+
+ themePopup.addEventListener('focusout', function(e) {
+ // e.relatedTarget is null in Safari and Firefox on macOS (see workaround below)
+ if (!!e.relatedTarget && !themeToggleButton.contains(e.relatedTarget) && !themePopup.contains(e.relatedTarget)) {
+ hideThemes();
+ }
+ });
+
+ // Should not be needed, but it works around an issue on macOS & iOS: https://github.com/rust-lang/mdBook/issues/628
+ document.addEventListener('click', function(e) {
+ if (themePopup.style.display === 'block' && !themeToggleButton.contains(e.target) && !themePopup.contains(e.target)) {
+ hideThemes();
+ }
+ });
+
+ document.addEventListener('keydown', function (e) {
+ if (e.altKey || e.ctrlKey || e.metaKey || e.shiftKey) { return; }
+ if (!themePopup.contains(e.target)) { return; }
+
+ switch (e.key) {
+ case 'Escape':
+ e.preventDefault();
+ hideThemes();
+ break;
+ case 'ArrowUp':
+ e.preventDefault();
+ var li = document.activeElement.parentElement;
+ if (li && li.previousElementSibling) {
+ li.previousElementSibling.querySelector('button').focus();
+ }
+ break;
+ case 'ArrowDown':
+ e.preventDefault();
+ var li = document.activeElement.parentElement;
+ if (li && li.nextElementSibling) {
+ li.nextElementSibling.querySelector('button').focus();
+ }
+ break;
+ case 'Home':
+ e.preventDefault();
+ themePopup.querySelector('li:first-child button').focus();
+ break;
+ case 'End':
+ e.preventDefault();
+ themePopup.querySelector('li:last-child button').focus();
+ break;
+ }
+ });
+})();
+
+(function sidebar() {
+ var body = document.querySelector("body");
+ var sidebar = document.getElementById("sidebar");
+ var sidebarLinks = document.querySelectorAll('#sidebar a');
+ var sidebarToggleButton = document.getElementById("sidebar-toggle");
+ var sidebarResizeHandle = document.getElementById("sidebar-resize-handle");
+ var firstContact = null;
+
+ function showSidebar() {
+ body.classList.remove('sidebar-hidden')
+ body.classList.add('sidebar-visible');
+ Array.from(sidebarLinks).forEach(function (link) {
+ link.setAttribute('tabIndex', 0);
+ });
+ sidebarToggleButton.setAttribute('aria-expanded', true);
+ sidebar.setAttribute('aria-hidden', false);
+ try { localStorage.setItem('mdbook-sidebar', 'visible'); } catch (e) { }
+ }
+
+
+ var sidebarAnchorToggles = document.querySelectorAll('#sidebar a.toggle');
+
+ function toggleSection(ev) {
+ ev.currentTarget.parentElement.classList.toggle('expanded');
+ }
+
+ Array.from(sidebarAnchorToggles).forEach(function (el) {
+ el.addEventListener('click', toggleSection);
+ });
+
+ function hideSidebar() {
+ body.classList.remove('sidebar-visible')
+ body.classList.add('sidebar-hidden');
+ Array.from(sidebarLinks).forEach(function (link) {
+ link.setAttribute('tabIndex', -1);
+ });
+ sidebarToggleButton.setAttribute('aria-expanded', false);
+ sidebar.setAttribute('aria-hidden', true);
+ try { localStorage.setItem('mdbook-sidebar', 'hidden'); } catch (e) { }
+ }
+
+ // Toggle sidebar
+ sidebarToggleButton.addEventListener('click', function sidebarToggle() {
+ if (body.classList.contains("sidebar-hidden")) {
+ var current_width = parseInt(
+ document.documentElement.style.getPropertyValue('--sidebar-width'), 10);
+ if (current_width < 150) {
+ document.documentElement.style.setProperty('--sidebar-width', '150px');
+ }
+ showSidebar();
+ } else if (body.classList.contains("sidebar-visible")) {
+ hideSidebar();
+ } else {
+ if (getComputedStyle(sidebar)['transform'] === 'none') {
+ hideSidebar();
+ } else {
+ showSidebar();
+ }
+ }
+ });
+
+ sidebarResizeHandle.addEventListener('mousedown', initResize, false);
+
+ function initResize(e) {
+ window.addEventListener('mousemove', resize, false);
+ window.addEventListener('mouseup', stopResize, false);
+ body.classList.add('sidebar-resizing');
+ }
+ function resize(e) {
+ var pos = (e.clientX - sidebar.offsetLeft);
+ if (pos < 20) {
+ hideSidebar();
+ } else {
+ if (body.classList.contains("sidebar-hidden")) {
+ showSidebar();
+ }
+ pos = Math.min(pos, window.innerWidth - 100);
+ document.documentElement.style.setProperty('--sidebar-width', pos + 'px');
+ }
+ }
+ //on mouseup remove windows functions mousemove & mouseup
+ function stopResize(e) {
+ body.classList.remove('sidebar-resizing');
+ window.removeEventListener('mousemove', resize, false);
+ window.removeEventListener('mouseup', stopResize, false);
+ }
+
+ document.addEventListener('touchstart', function (e) {
+ firstContact = {
+ x: e.touches[0].clientX,
+ time: Date.now()
+ };
+ }, { passive: true });
+
+ document.addEventListener('touchmove', function (e) {
+ if (!firstContact)
+ return;
+
+ var curX = e.touches[0].clientX;
+ var xDiff = curX - firstContact.x,
+ tDiff = Date.now() - firstContact.time;
+
+ if (tDiff < 250 && Math.abs(xDiff) >= 150) {
+ if (xDiff >= 0 && firstContact.x < Math.min(document.body.clientWidth * 0.25, 300))
+ showSidebar();
+ else if (xDiff < 0 && curX < 300)
+ hideSidebar();
+
+ firstContact = null;
+ }
+ }, { passive: true });
+})();
+
+(function chapterNavigation() {
+ document.addEventListener('keydown', function (e) {
+ if (e.altKey || e.ctrlKey || e.metaKey || e.shiftKey) { return; }
+ if (window.search && window.search.hasFocus()) { return; }
+ var html = document.querySelector('html');
+
+ function next() {
+ var nextButton = document.querySelector('.nav-chapters.next');
+ if (nextButton) {
+ window.location.href = nextButton.href;
+ }
+ }
+ function prev() {
+ var previousButton = document.querySelector('.nav-chapters.previous');
+ if (previousButton) {
+ window.location.href = previousButton.href;
+ }
+ }
+ switch (e.key) {
+ case 'ArrowRight':
+ e.preventDefault();
+ if (html.dir == 'rtl') {
+ prev();
+ } else {
+ next();
+ }
+ break;
+ case 'ArrowLeft':
+ e.preventDefault();
+ if (html.dir == 'rtl') {
+ next();
+ } else {
+ prev();
+ }
+ break;
+ }
+ });
+})();
+
+(function clipboard() {
+ var clipButtons = document.querySelectorAll('.clip-button');
+
+ function hideTooltip(elem) {
+ elem.firstChild.innerText = "";
+ elem.className = 'fa fa-copy clip-button';
+ }
+
+ function showTooltip(elem, msg) {
+ elem.firstChild.innerText = msg;
+ elem.className = 'fa fa-copy tooltipped';
+ }
+
+ var clipboardSnippets = new ClipboardJS('.clip-button', {
+ text: function (trigger) {
+ hideTooltip(trigger);
+ let playground = trigger.closest("pre");
+ return playground_text(playground, false);
+ }
+ });
+
+ Array.from(clipButtons).forEach(function (clipButton) {
+ clipButton.addEventListener('mouseout', function (e) {
+ hideTooltip(e.currentTarget);
+ });
+ });
+
+ clipboardSnippets.on('success', function (e) {
+ e.clearSelection();
+ showTooltip(e.trigger, "Copied!");
+ });
+
+ clipboardSnippets.on('error', function (e) {
+ showTooltip(e.trigger, "Clipboard error!");
+ });
+})();
+
+(function scrollToTop () {
+ var menuTitle = document.querySelector('.menu-title');
+
+ menuTitle.addEventListener('click', function () {
+ document.scrollingElement.scrollTo({ top: 0, behavior: 'smooth' });
+ });
+})();
+
+(function controllMenu() {
+ var menu = document.getElementById('menu-bar');
+
+ (function controllPosition() {
+ var scrollTop = document.scrollingElement.scrollTop;
+ var prevScrollTop = scrollTop;
+ var minMenuY = -menu.clientHeight - 50;
+ // When the script loads, the page can be at any scroll (e.g. if you reforesh it).
+ menu.style.top = scrollTop + 'px';
+ // Same as parseInt(menu.style.top.slice(0, -2), but faster
+ var topCache = menu.style.top.slice(0, -2);
+ menu.classList.remove('sticky');
+ var stickyCache = false; // Same as menu.classList.contains('sticky'), but faster
+ document.addEventListener('scroll', function () {
+ scrollTop = Math.max(document.scrollingElement.scrollTop, 0);
+ // `null` means that it doesn't need to be updated
+ var nextSticky = null;
+ var nextTop = null;
+ var scrollDown = scrollTop > prevScrollTop;
+ var menuPosAbsoluteY = topCache - scrollTop;
+ if (scrollDown) {
+ nextSticky = false;
+ if (menuPosAbsoluteY > 0) {
+ nextTop = prevScrollTop;
+ }
+ } else {
+ if (menuPosAbsoluteY > 0) {
+ nextSticky = true;
+ } else if (menuPosAbsoluteY < minMenuY) {
+ nextTop = prevScrollTop + minMenuY;
+ }
+ }
+ if (nextSticky === true && stickyCache === false) {
+ menu.classList.add('sticky');
+ stickyCache = true;
+ } else if (nextSticky === false && stickyCache === true) {
+ menu.classList.remove('sticky');
+ stickyCache = false;
+ }
+ if (nextTop !== null) {
+ menu.style.top = nextTop + 'px';
+ topCache = nextTop;
+ }
+ prevScrollTop = scrollTop;
+ }, { passive: true });
+ })();
+ (function controllBorder() {
+ function updateBorder() {
+ if (menu.offsetTop === 0) {
+ menu.classList.remove('bordered');
+ } else {
+ menu.classList.add('bordered');
+ }
+ }
+ updateBorder();
+ document.addEventListener('scroll', updateBorder, { passive: true });
+ })();
+})();
diff --git a/clipboard.min.js b/clipboard.min.js
new file mode 100644
index 000000000..02c549e35
--- /dev/null
+++ b/clipboard.min.js
@@ -0,0 +1,7 @@
+/*!
+ * clipboard.js v2.0.4
+ * https://zenorocha.github.io/clipboard.js
+ *
+ * Licensed MIT © Zeno Rocha
+ */
+!function(t,e){"object"==typeof exports&&"object"==typeof module?module.exports=e():"function"==typeof define&&define.amd?define([],e):"object"==typeof exports?exports.ClipboardJS=e():t.ClipboardJS=e()}(this,function(){return function(n){var o={};function r(t){if(o[t])return o[t].exports;var e=o[t]={i:t,l:!1,exports:{}};return n[t].call(e.exports,e,e.exports,r),e.l=!0,e.exports}return r.m=n,r.c=o,r.d=function(t,e,n){r.o(t,e)||Object.defineProperty(t,e,{enumerable:!0,get:n})},r.r=function(t){"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(t,"__esModule",{value:!0})},r.t=function(e,t){if(1&t&&(e=r(e)),8&t)return e;if(4&t&&"object"==typeof e&&e&&e.__esModule)return e;var n=Object.create(null);if(r.r(n),Object.defineProperty(n,"default",{enumerable:!0,value:e}),2&t&&"string"!=typeof e)for(var o in e)r.d(n,o,function(t){return e[t]}.bind(null,o));return n},r.n=function(t){var e=t&&t.__esModule?function(){return t.default}:function(){return t};return r.d(e,"a",e),e},r.o=function(t,e){return Object.prototype.hasOwnProperty.call(t,e)},r.p="",r(r.s=0)}([function(t,e,n){"use strict";var r="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t},i=function(){function o(t,e){for(var n=0;n
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Statements and Expressions
+Examples
++fn main() { + let x = 5u32; + + let y = { + let x_squared = x * x; + let x_cube = x_squared * x; + + // This expression will be assigned to `y` + x_cube + x_squared + x + }; + + let z = { + // The semicolon suppresses this expression and `()` is assigned to `z` + 2 * x; + }; + + println!("x is {:?}", x); + println!("y is {:?}", y); + println!("z is {:?}", z); +}
Exercises
+-
+
- 🌟🌟 +
+// Make it work with two ways +fn main() { + let v = { + let mut x = 1; + x += 2 + }; + + assert_eq!(v, 3); + + println!("Success!"); +}
-
+
- 🌟 +
++fn main() { + let v = (let x = 3); + + assert!(v == 3); + + println!("Success!"); +}
-
+
- 🌟 +
++fn main() { + let s = sum(1 , 2); + assert_eq!(s, 3); + + println!("Success!"); +} + +fn sum(x: i32, y: i32) -> i32 { + x + y; +}
++ + +You can find the solutions here(under the solutions path), but only use it when you need it
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/collections/intro.html b/collections/intro.html
new file mode 100644
index 000000000..2785c1d30
--- /dev/null
+++ b/collections/intro.html
@@ -0,0 +1,221 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ HashMap
+Where vectors store values by an integer index, HashMaps store values by key. It is a hash map implemented with quadratic probing and SIMD lookup. By default, HashMap uses a hashing algorithm selected to provide resistance against HashDoS attacks.
The default hashing algorithm is currently SipHash 1-3, though this is subject to change at any point in the future. While its performance is very competitive for medium sized keys, other hashing algorithms will outperform it for small keys such as integers as well as large keys such as long strings, though those algorithms will typically not protect against attacks such as HashDoS.
The hash table implementation is a Rust port of Google’s SwissTable. The original C++ version of SwissTable can be found here, and this CppCon talk gives an overview of how the algorithm works.
+Basic Operations
+-
+
- 🌟🌟 +
++// FILL in the blanks and FIX the errors +use std::collections::HashMap; +fn main() { + let mut scores = HashMap::new(); + scores.insert("Sunface", 98); + scores.insert("Daniel", 95); + scores.insert("Ashley", 69.0); + scores.insert("Katie", "58"); + + // Get returns an Option<&V> + let score = scores.get("Sunface"); + assert_eq!(score, Some(98)); + + if scores.contains_key("Daniel") { + // Indexing returns a value V + let score = scores["Daniel"]; + assert_eq!(score, __); + scores.remove("Daniel"); + } + + assert_eq!(scores.len(), __); + + for (name, score) in scores { + println!("The score of {} is {}", name, score); + } +}
-
+
- 🌟🌟 +
++use std::collections::HashMap; +fn main() { + let teams = [ + ("Chinese Team", 100), + ("American Team", 10), + ("France Team", 50), + ]; + + let mut teams_map1 = HashMap::new(); + for team in &teams { + teams_map1.insert(team.0, team.1); + } + + // IMPLEMENT team_map2 in two ways + // Tips: one of the approaches is to use `collect` method + let teams_map2... + + assert_eq!(teams_map1, teams_map2); + + println!("Success!"); +}
-
+
- 🌟🌟 +
++// FILL in the blanks +use std::collections::HashMap; +fn main() { + // Type inference lets us omit an explicit type signature (which + // would be `HashMap<&str, u8>` in this example). + let mut player_stats = HashMap::new(); + + // Insert a key only if it doesn't already exist + player_stats.entry("health").or_insert(100); + + assert_eq!(player_stats["health"], __); + + // Insert a key using a function that provides a new value only if it + // doesn't already exist + player_stats.entry("health").or_insert_with(random_stat_buff); + assert_eq!(player_stats["health"], __); + + // Ensures a value is in the entry by inserting the default if empty, and returns + // a mutable reference to the value in the entry. + let health = player_stats.entry("health").or_insert(50); + assert_eq!(health, __); + *health -= 50; + assert_eq!(*health, __); + + println!("Success!"); +} + +fn random_stat_buff() -> u8 { + // Could actually return some random value here - let's just return + // some fixed value for now + 42 +}
Requirements of HashMap key
+Any type that implements the Eq and Hash traits can be a key in HashMap. This includes:
-
+
bool(though not very useful since there is only two possible keys)
+int,uint, and all variations thereof
+Stringand&str(tips: you can have aHashMapkeyed byStringand call.get()with an&str)
+
Note that f32 and f64 do not implement Hash, likely because floating-point precision errors would make using them as hashmap keys horribly error-prone.
All collection classes implement Eq and Hash if their contained type also respectively implements Eq and Hash. For example, Vec<T> will implement Hash if Timplements Hash.
-
+
- 🌟🌟 +
++// FIX the errors +// Tips: `derive` is usually a good way to implement some common used traits +use std::collections::HashMap; + +struct Viking { + name: String, + country: String, +} + +impl Viking { + /// Creates a new Viking. + fn new(name: &str, country: &str) -> Viking { + Viking { + name: name.to_string(), + country: country.to_string(), + } + } +} + +fn main() { + // Use a HashMap to store the vikings' health points. + let vikings = HashMap::from([ + (Viking::new("Einar", "Norway"), 25), + (Viking::new("Olaf", "Denmark"), 24), + (Viking::new("Harald", "Iceland"), 12), + ]); + + // Use derived implementation to print the status of the vikings. + for (viking, health) in &vikings { + println!("{:?} has {} hp", viking, health); + } +}
Capacity
+Like vectors, HashMaps are growable, but HashMaps can also shrink themselves when they have excess space. You can create a HashMap with a certain starting capacity using HashMap::with_capacity(uint), or use HashMap::new() to get a HashMap with a default initial capacity (recommended).
Example
+++use std::collections::HashMap; +fn main() { + let mut map: HashMap<i32, i32> = HashMap::with_capacity(100); + map.insert(1, 2); + map.insert(3, 4); + // Indeed ,the capacity of HashMap is not 100, so we can't compare the equality here. + assert!(map.capacity() >= 100); + + // Shrinks the capacity of the map with a lower limit. It will drop + // down no lower than the supplied limit while maintaining the internal rules + // and possibly leaving some space in accordance with the resize policy. + + map.shrink_to(50); + assert!(map.capacity() >= 50); + + // Shrinks the capacity of the map as much as possible. It will drop + // down as much as possible while maintaining the internal rules + // and possibly leaving some space in accordance with the resize policy. + map.shrink_to_fit(); + assert!(map.capacity() >= 2); + println!("Success!"); +}
Ownership
+For types that implement the Copy trait, like i32 , the values are copied into HashMap. For owned values like String, the values will be moved and HashMap will be the owner of those values.
-
+
- 🌟🌟 +
+// FIX the errors with least changes +// DON'T remove any code line +use std::collections::HashMap; +fn main() { + let v1 = 10; + let mut m1 = HashMap::new(); + m1.insert(v1, v1); + println!("v1 is still usable after inserting to hashmap : {}", v1); + + let v2 = "hello".to_string(); + let mut m2 = HashMap::new(); + // Ownership moved here + m2.insert(v2, v1); + + assert_eq!(v2, "hello"); + + println!("Success!"); +}
Third-party Hash libs
+If the performance of SipHash 1-3 doesn't meet your requirements, you can find replacements in crates.io or github.com.
The usage of third-party hash looks like this:
++ + +#![allow(unused)] +fn main() { +use std::hash::BuildHasherDefault; +use std::collections::HashMap; +// Introduce a third party hash function +use twox_hash::XxHash64; + + +let mut hash: HashMap<_, _, BuildHasherDefault<XxHash64>> = Default::default(); +hash.insert(42, "the answer"); +assert_eq!(hash.get(&42), Some(&"the answer")); +}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/collections/string.html b/collections/string.html
new file mode 100644
index 000000000..d60ea1b79
--- /dev/null
+++ b/collections/string.html
@@ -0,0 +1,402 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Collection Types
+Learning resources:
+-
+
- English: Rust Book Chapter 8 +
- 简体中文: Rust语言圣经 - 集合类型 +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/collections/vector.html b/collections/vector.html
new file mode 100644
index 000000000..e529e731d
--- /dev/null
+++ b/collections/vector.html
@@ -0,0 +1,441 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ String
+std::string::String is a UTF-8 encoded, growable string. It is the most common string type we used in daily development, it also has ownership over the string contents.
Basic operations
+-
+
- 🌟🌟 +
++// FILL in the blanks and FIX errors +// 1. Don't use `to_string()` +// 2. Don't add/remove any code line +fn main() { + let mut s: String = "hello, "; + s.push_str("world".to_string()); + s.push(__); + + move_ownership(s); + + assert_eq!(s, "hello, world!"); + + println!("Success!"); +} + +fn move_ownership(s: String) { + println!("ownership of \"{}\" is moved here!", s) +}
String and &str
+A String is stored as a vector of bytes (Vec<u8>), but guaranteed to always be a valid UTF-8 sequence. String is heap allocated, growable and not null terminated.
&str is a slice (&[u8]) that always points to a valid UTF-8 sequence, and can be used to view into a String, just like &[T] is a view into Vec<T>.
-
+
- 🌟🌟 +
+// FILL in the blanks +fn main() { + let mut s = String::from("hello, world"); + + let slice1: &str = __; // In two ways + assert_eq!(slice1, "hello, world"); + + let slice2 = __; + assert_eq!(slice2, "hello"); + + let slice3: __ = __; + slice3.push('!'); + assert_eq!(slice3, "hello, world!"); + + println!("Success!"); +}
-
+
- 🌟🌟 +
++// Question: how many heap allocations are happening here? +// Your answer: +fn main() { + // Create a String type based on `&str` + // The type of string literals is `&str` + let s: String = String::from("hello, world!"); + + // Create a slice point to String `s` + let slice: &str = &s; + + // Create a String type based on the recently created slice + let s: String = slice.to_string(); + + assert_eq!(s, "hello, world!"); + + println!("Success!"); +}
UTF-8 & Indexing
+Strings are always valid UTF-8. This has a few implications:
+-
+
- The first of which is that if you need a non-UTF-8 string, consider OsString. It is similar, but without the UTF-8 constraint. +
- The second implication is that you cannot index into a String. +
Indexing is intended to be a constant-time operation, but UTF-8 encoding does not allow us to do this. Furthermore, it’s not clear what sort of thing the index should return: a byte, a codepoint, or a grapheme cluster. The bytes and chars methods return iterators over the first two, respectively.
+-
+
- 🌟🌟🌟 You can't use index to access a char in a string, but you can use slice
&s1[start..end].
+
++// FILL in the blank and FIX errors +fn main() { + let s = String::from("hello, 世界"); + let slice1 = s[0]; //tips: `h` only takes 1 byte in UTF8 format + assert_eq!(slice1, "h"); + + let slice2 = &s[3..5]; // Tips: `中` takes 3 bytes in UTF8 format + assert_eq!(slice2, "世"); + + // Iterate through all chars in s + for (i, c) in s.__ { + if i == 7 { + assert_eq!(c, '世') + } + } + + println!("Success!"); +}
UTF8_slice
+You can use utf8_slice to slice UTF8 string, it can index chars instead of bytes.
+Example
++use utf8_slice; +fn main() { + let s = "The 🚀 goes to the 🌑!"; + + let rocket = utf8_slice::slice(s, 4, 5); + // Will equal "🚀" +}
-
+
- 🌟🌟🌟 +
++Tips: maybe you need
+from_utf8method
++// FILL in the blanks +fn main() { + let mut s = String::new(); + __; + + // Some bytes, in a vector + let v = vec![104, 101, 108, 108, 111]; + + // Turn a byte's vector into a String + let s1 = __; + + + assert_eq!(s, s1); + + println!("Success!"); +}
Representation
+A String is made up of three components: a pointer to some bytes, a length, and a capacity.
+The pointer points to an internal buffer String uses to store its data. The length is the number of bytes currently stored in the buffer( always stored on the heap ), and the capacity is the size of the buffer in bytes. As such, the length will always be less than or equal to the capacity.
+-
+
- 🌟🌟 If a String has enough capacity, adding elements to it will not re-allocate +
++// Modify the code below to print out: +// 25 +// 25 +// 25 +// Here, there’s no need to allocate more memory inside the loop. +fn main() { + let mut s = String::new(); + + println!("{}", s.capacity()); + + for _ in 0..2 { + s.push_str("hello"); + println!("{}", s.capacity()); + } + + println!("Success!"); +}
-
+
- 🌟🌟🌟 +
++// FILL in the blanks +use std::mem; + +fn main() { + let story = String::from("Rust By Practice"); + + // Prevent automatically dropping of the String's data + let mut story = mem::ManuallyDrop::new(story); + + let ptr = story.__(); + let len = story.__(); + let capacity = story.__(); + + assert_eq!(16, len); + + // We can rebuild a String out of ptr, len, and capacity. This is all + // unsafe because we are responsible for making sure the components are + // valid: + let s = unsafe { String::from_raw_parts(ptr, len, capacity) }; + + assert_eq!(*story, s); + + println!("Success!"); +}
Common methods
+More exercises of String methods can be found here.
+++ + +You can find the solutions here(under the solutions path), but only use it when you need it
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/comments-docs.html b/comments-docs.html
new file mode 100644
index 000000000..949e3b173
--- /dev/null
+++ b/comments-docs.html
@@ -0,0 +1,480 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Vector
+Vectors are resizable arrays. Like slices, their size is not known at compile time, but they can grow or shrink at any time.
+Basic Operations
+-
+
- 🌟🌟🌟 +
++fn main() { + let arr: [u8; 3] = [1, 2, 3]; + + let v = Vec::from(arr); + is_vec(&v); + + let v = vec![1, 2, 3]; + is_vec(&v); + + // vec!(..) and vec![..] are same macros, so + let v = vec!(1, 2, 3); + is_vec(&v); + + // In code below, v is Vec<[u8; 3]> , not Vec<u8> + // USE Vec::new and `for` to rewrite the below code + let v1 = vec!(arr); + is_vec(&v1); + + assert_eq!(v, v1); + + println!("Success!"); +} + +fn is_vec(v: &Vec<u8>) {}
-
+
- 🌟🌟 A Vec can be extended with
extendmethod
+
++// FILL in the blank +fn main() { + let mut v1 = Vec::from([1, 2, 4]); + v1.pop(); + v1.push(3); + + let mut v2 = Vec::new(); + v2.__; + + assert_eq!(v1, v2); + + println!("Success!"); +}
Turn X Into Vec
+-
+
- 🌟🌟🌟 +
++// FILL in the blanks +fn main() { + // Array -> Vec + // impl From<[T; N]> for Vec + let arr = [1, 2, 3]; + let v1 = __(arr); + let v2: Vec<i32> = arr.__(); + + assert_eq!(v1, v2); + + + // String -> Vec + // impl From<String> for Vec + let s = "hello".to_string(); + let v1: Vec<u8> = s.__(); + + let s = "hello".to_string(); + let v2 = s.into_bytes(); + assert_eq!(v1, v2); + + // impl<'_> From<&'_ str> for Vec + let s = "hello"; + let v3 = Vec::__(s); + assert_eq!(v2, v3); + + // Iterators can be collected into vectors + let v4: Vec<i32> = [0; 10].into_iter().collect(); + assert_eq!(v4, vec![0; 10]); + + println!("Success!"); + }
Indexing
+-
+
- 🌟🌟🌟 +
++// FIX the error and IMPLEMENT the code +fn main() { + let mut v = Vec::from([1, 2, 3]); + for i in 0..5 { + println!("{:?}", v[i]) + } + + for i in 0..5 { + // IMPLEMENT the code here... + } + + assert_eq!(v, vec![2, 3, 4, 5, 6]); + + println!("Success!"); +}
Slicing
+A Vec can be mutable. On the other hand, slices are read-only objects. To get a slice, use &.
In Rust, it’s more common to pass slices as arguments rather than vectors when you just want to provide read access. The same goes for String and &str.
-
+
- 🌟🌟 +
++// FIX the errors +fn main() { + let mut v = vec![1, 2, 3]; + + let slice1 = &v[..]; + // Out of bounds will cause a panic + // You must use `v.len` here + let slice2 = &v[0..4]; + + assert_eq!(slice1, slice2); + + // Slices are read only + // Note: slice and &Vec are different + let vec_ref: &mut Vec<i32> = &mut v; + (*vec_ref).push(4); + let slice3 = &mut v[0..3]; + slice3.push(4); + + assert_eq!(slice3, &[1, 2, 3, 4]); + + println!("Success!"); +}
Capacity
+The capacity of a vector is the amount of space allocated for any future elements that will be added onto the vector. This is not to be confused with the length of a vector, which specifies the number of actual elements within the vector. If a vector’s length exceeds its capacity, its capacity will automatically be increased, but its elements will have to be reallocated.
+For example, a vector with capacity 10 and length 0 would be an empty vector with space for 10 more elements. Pushing 10 or fewer elements onto the vector will not change its capacity or cause reallocation to occur. However, if the vector’s length is increased to 11, it will have to reallocate, which can be slow. For this reason, it is recommended to use Vec::with_capacity whenever possible to specify how big the vector is expected to get.
-
+
- 🌟🌟 +
+// FIX the errors +fn main() { + let mut vec = Vec::with_capacity(10); + + // The vector contains no items, even though it has capacity for more + assert_eq!(vec.len(), __); + assert_eq!(vec.capacity(), 10); + + // These are all done without reallocating... + for i in 0..10 { + vec.push(i); + } + assert_eq!(vec.len(), __); + assert_eq!(vec.capacity(), __); + + // ...but this may make the vector reallocate + vec.push(11); + assert_eq!(vec.len(), 11); + assert!(vec.capacity() >= 11); + + + // Fill in an appropriate value to make the `for` done without reallocating + let mut vec = Vec::with_capacity(__); + for i in 0..100 { + vec.push(i); + } + + assert_eq!(vec.len(), __); + assert_eq!(vec.capacity(), __); + + println!("Success!"); +}
Store distinct types in Vector
+The elements in a vector must be the same type, for example , the code below will cause an error:
++fn main() { + let v = vec![1, 2.0, 3]; +}
But we can use enums or trait objects to store distinct types.
+-
+
- 🌟🌟 +
+#[derive(Debug)] +enum IpAddr { + V4(String), + V6(String), +} +fn main() { + // FILL in the blank + let v : Vec<IpAddr>= __; + + // Comparing two enums need to derive the PartialEq trait + assert_eq!(v[0], IpAddr::V4("127.0.0.1".to_string())); + assert_eq!(v[1], IpAddr::V6("::1".to_string())); + + println!("Success!"); +}
-
+
- 🌟🌟 +
+ + +trait IpAddr { + fn display(&self); +} + +struct V4(String); +impl IpAddr for V4 { + fn display(&self) { + println!("ipv4: {:?}",self.0) + } +} +struct V6(String); +impl IpAddr for V6 { + fn display(&self) { + println!("ipv6: {:?}",self.0) + } +} + +fn main() { + // FILL in the blank + let v: __= vec![ + Box::new(V4("127.0.0.1".to_string())), + Box::new(V6("::1".to_string())), + ]; + + for ip in v { + ip.display(); + } +}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/compound-types/array.html b/compound-types/array.html
new file mode 100644
index 000000000..e44db63cc
--- /dev/null
+++ b/compound-types/array.html
@@ -0,0 +1,310 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Line doc comments
+Block doc comments
+
+
+
+
+
+
+
+ Comments and Docs
+Every program requires comments:
+Comments
+-
+
- Regular comments which are ignored by the compiler:
+
-
+
// Line comment, which goes to the end of the line
+/* Block comment, which goes to the end of the closing delimiter */
+
+
Examples
++fn main() { + // This is an example of a line comment + // There are two slashes at the beginning of the line + // And nothing written inside these will be read by the compiler + + // println!("Hello, world!"); + + // Run it. See? Now try deleting the two slashes, and run it again. + + /* + * This is another type of comment, a block comment. In general, + * line comments are the recommended comment style. But + * block comments are extremely useful for temporarily disabling + * chunks of code. /* Block comments can be /* nested, */ */ + * so it takes only a few keystrokes to comment out everything + * in this main() function. /*/*/* Try it yourself! */*/*/ + */ + + /* + Note: The previous column of `*` was entirely for style. There's + no actual need for it. + */ +}
Exercises
+-
+
- 🌟🌟 +
++/* Make it work, only using comments! */ +fn main() { + todo!(); + unimplemented!(); + + assert_eq!(6, 5 + 3 + 2 + 1 ) +}
Doc Comments
+-
+
- Doc comments which are parsed into HTML and supported
Markdown+-
+
/// Generate library docs for the following item
+//! Generate library docs for the eclosing item
+
+
Before starting, we need to create a new package for practice: cargo new --lib doc-comments.
Line doc comments ///
+Add docs for function add_one
+#![allow(unused)] +fn main() { +// in lib.rs + +/// Add one to the given value and return the value +/// +/// # Examples +/// +/// ``` +/// let arg = 5; +/// let answer = my_crate::add_one(arg); +/// +/// assert_eq!(6, answer); +/// ``` +pub fn add_one(x: i32) -> i32 { + x + 1 +} +}
Cargo doc
+We can use cargo doc --open to generate html files and open them in the browser.
Block doc comments /** ... */
+Add docs for function add_two:
+#![allow(unused)] +fn main() { +/** Add two to the given value and return a new value + +Examples + +let arg = 5; +let answer = my_crate::add_two(arg); + +assert_eq!(7, answer); + +*/ +pub fn add_two(x: i32) -> i32 { + x + 2 +} +}
Doc comments for crate and module
+We can also add doc comments for our crates and modules.
+Firstly, let's add some doc comments for our library crate:
+++Note: We must place crates and module comments at the top of crate root or module file.
+
+#![allow(unused)] +fn main() { +//! # Doc comments +//! +//! A library for showing how to use doc comments + +// in lib.rs +pub mod compute; +}
You can also use block comments to achieve this:
++#![allow(unused)] +fn main() { +/*! # Doc comments + + A library for showing how to use doc comments */ +}
Next, create a new module file src/compute.rs, and add following comments to it:
+#![allow(unused)] +fn main() { +//! //! Do some complicated arithmetic that you can't do by yourself + +// in compute.rs +}
Then run cargo doc --open and see the results.
Doc tests
+The doc comments of add_one and add_two contain two example code blocks.
The examples can not only demonstrate how to use your library, but also running as test with cargo test command.
-
+
- 🌟🌟 But there are errors in the two examples, please fix them, and running with
cargo testto get following result:
+
running 0 tests
+
+test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
+
+ Doc-tests doc-comments
+
+running 2 tests
+test src/lib.rs - add_one (line 11) ... ok
+test src/lib.rs - add_two (line 26) ... ok
+
+test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.55s
+-
+
- 🌟🌟 Sometimes we expect an example to be panic, add following code to
src/compute.rsand make thecargo testpassed.
+
++You can only modify the comments, DON'T modify
+fn div
+#![allow(unused)] +fn main() { +// in src/compute.rs + +/// # Panics +/// +/// The function panics if the second argument is zero. +/// +/// ```rust,should_panic +/// // panics on division by zero +/// doc_comments::compute::div(10, 0); +/// ``` +pub fn div(a: i32, b: i32) -> i32 { + if b == 0 { + panic!("Divide-by-zero error"); + } + + a / b +} +}
-
+
- 🌟🌟 Sometimes we want to hide the doc comments, but keep the doc tests. +
Add following code to src/compute.rs ,
+// in src/compute.rs + +/// ``` +/// # fn try_main() -> Result<(), String> { +/// # let res = doc_comments::compute::try_div(10, 0)?; +/// # Ok(()) // returning from try_main +/// # } +/// # fn main() { +/// # try_main().unwrap(); +/// # +/// # } +/// ``` +pub fn try_div(a: i32, b: i32) -> Result<i32, String> { + if b == 0 { + Err(String::from("Divide-by-zero")) + } else { + Ok(a / b) + } +}
and modify this code to achieve two goals:
+-
+
- The doc comments must not be presented in html files generated by
cargo doc --open
+ - run the tests, you should see results as below: +
running 0 tests
+
+test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
+
+ Doc-tests doc-comments
+
+running 4 tests
+test src/compute.rs - compute::div (line 7) ... ok
+test src/lib.rs - add_two (line 27) ... ok
+test src/lib.rs - add_one (line 11) ... ok
+test src/compute.rs - compute::try_div (line 20) ... ok
+
+test result: ok. 4 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.51s
+Code navigation
+Rust provide a very powerful feature for us, that is code navigation in doc comments.
+Add following code to src/lib.rs:
+#![allow(unused)] +fn main() { +// in lib.rs + +/// Add three to the given value and return a [`Option`] type +pub fn add_three(x: i32) -> Option<i32> { + Some(x + 3) +} +}
Besides jump into the standard library, you can also jump to another module in the package.
++#![allow(unused)] +fn main() { +// in lib.rs + +mod a { + /// Add four to the given value and return a [`Option`] type + /// [`crate::MySpecialFormatter`] + pub fn add_four(x: i32) -> Option<i32> { + Some(x + 4) + } +} + +struct MySpecialFormatter; +}
Doc attributes
+Below are a few examples of the most common #[doc] attributes used with rustdoc.
inline
+Used to inline docs, instead of linking out to separate page.
+#[doc(inline)]
+pub use bar::Bar;
+
+/// bar docs
+mod bar {
+ /// the docs for Bar
+ pub struct Bar;
+}no_inline
+Used to prevent linking out to separate page or anywhere.
+// Example from libcore/prelude
+#[doc(no_inline)]
+pub use crate::mem::drop;hidden
+Using this tells rustdoc not to include this in documentation:
// Example from the futures-rs library
+#[doc(hidden)]
+pub use self::async_await::*;For documentation, rustdoc is widely used by the community. It's what is used to generate the std library docs.
Full Code
+The full code of package doc-comments is here.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/compound-types/enum.html b/compound-types/enum.html
new file mode 100644
index 000000000..507a060d0
--- /dev/null
+++ b/compound-types/enum.html
@@ -0,0 +1,418 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Array
+The type of array is [T; Length], as you can see, array's length is part of their type signature. So their length must be known at compile time.
For example, you cant initialize an array like below:
++#![allow(unused)] +fn main() { +fn init_arr(n: i32) { + let arr = [1; n]; +} +}
This will cause an error, because the compiler has no idea of the exact size of the array at compile time.
+-
+
- 🌟 +
++fn main() { + // Fill the blank with proper array type + let arr: __ = [1, 2, 3, 4, 5]; + + // Modify the code below to make it work + assert!(arr.len() == 4); + + println!("Success!"); +}
-
+
- 🌟🌟 +
++fn main() { + // We can ignore parts of the array type or even the whole type, let the compiler infer it for us + let arr0 = [1, 2, 3]; + let arr: [_; 3] = ['a', 'b', 'c']; + + // Fill the blank + // Arrays are stack allocated, `std::mem::size_of_val` returns the bytes which an array occupies + // A char takes 4 bytes in Rust: Unicode char + assert!(std::mem::size_of_val(&arr) == __); + + println!("Success!"); +}
-
+
- 🌟 All elements in an array can be initialized to the same value at once. +
++fn main() { + // Fill the blank + let list: [i32; 100] = __ ; + + assert!(list[0] == 1); + assert!(list.len() == 100); + + println!("Success!"); +}
-
+
- 🌟 All elements in an array must be of the same type +
++fn main() { + // Fix the error + let _arr = [1, 2, '3']; + + println!("Success!"); +}
-
+
- 🌟 Indexing starts at 0. +
++fn main() { + let arr = ['a', 'b', 'c']; + + let ele = arr[1]; // Only modify this line to make the code work! + + assert!(ele == 'a'); + + println!("Success!"); +}
-
+
- 🌟 Out of bounds indexing causes
panic.
+
++// Fix the error +fn main() { + let names = [String::from("Sunfei"), "Sunface".to_string()]; + + // `Get` returns an Option<T>, it's safe to use + let name0 = names.get(0).unwrap(); + + // But indexing is not safe + let _name1 = &names[2]; + + println!("Success!"); +} +
++ + +You can find the solutions here(under the solutions path), but only use it when you need it
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/compound-types/intro.html b/compound-types/intro.html
new file mode 100644
index 000000000..51a01d305
--- /dev/null
+++ b/compound-types/intro.html
@@ -0,0 +1,221 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Enum
+-
+
- 🌟🌟 Enums can be created with explicit discriminator. +
++// Fix the errors +enum Number { + Zero, + One, + Two, +} + +enum Number1 { + Zero = 0, + One, + Two, +} + +// C-like enum +enum Number2 { + Zero = 0.0, + One = 1.0, + Two = 2.0, +} + + +fn main() { + // An enum variant can be converted to a integer by `as` + assert_eq!(Number::One, Number1::One); + assert_eq!(Number1::One, Number2::One); + + println!("Success!"); +}
-
+
- 🌟 Each enum variant can hold its own data. +
++// Fill in the blank +enum Message { + Quit, + Move { x: i32, y: i32 }, + Write(String), + ChangeColor(i32, i32, i32), +} + +fn main() { + let msg1 = Message::Move{__}; // Instantiating with x = 1, y = 2 + let msg2 = Message::Write(__); // Instantiating with "hello, world!" + + println!("Success!"); +}
-
+
- 🌟🌟 We can get the data which an enum variant is holding by pattern match. +
++// Fill in the blank and fix the error +enum Message { + Quit, + Move { x: i32, y: i32 }, + Write(String), + ChangeColor(i32, i32, i32), +} + +fn main() { + let msg = Message::Move{x: 1, y: 2}; + + if let Message::Move{__} = msg { + assert_eq!(a, b); + } else { + panic!("NEVER LET THIS RUN！"); + } + + println!("Success!"); +}
-
+
- 🌟🌟 +
++// Fill in the blank and fix the errors +enum Message { + Quit, + Move { x: i32, y: i32 }, + Write(String), + ChangeColor(i32, i32, i32), +} + +fn main() { + let msgs: __ = [ + Message::Quit, + Message::Move{x:1, y:3}, + Message::ChangeColor(255,255,0) + ]; + + for msg in msgs { + show_message(msg) + } +} + +fn show_message(msg: Message) { + println!("{}", msg); +}
-
+
- 🌟🌟 Since there is no
nullin Rust, we have to use enumOption<T>to deal with the cases when the value is absent.
+
++// Fill in the blank to make the `println` work. +// Also add some code to prevent the `panic` from running. +fn main() { + let five = Some(5); + let six = plus_one(five); + let none = plus_one(None); + + if let __ = six { + println!("{}", n); + + println!("Success!"); + } + + panic!("NEVER LET THIS RUN！"); +} + +fn plus_one(x: Option<i32>) -> Option<i32> { + match x { + __ => None, + __ => Some(i + 1), + } +}
-
+
- 🌟🌟🌟🌟 Implement a
linked-listvia enums.
+
++use crate::List::*; + +enum List { + // Cons: Tuple struct that wraps an element and a pointer to the next node + Cons(u32, Box<List>), + // Nil: A node that signifies the end of the linked list + Nil, +} + +// Methods can be attached to an enum +impl List { + // Create an empty list + fn new() -> List { + // `Nil` has type `List` + Nil + } + + // Consume a list, and return the same list with a new element at its front + fn prepend(self, elem: u32) -> __ { + // `Cons` also has type List + Cons(elem, Box::new(self)) + } + + // Return the length of the list + fn len(&self) -> u32 { + // `self` has to be matched, because the behavior of this method + // depends on the variant of `self` + // `self` has type `&List`, and `*self` has type `List`, matching on a + // concrete type `T` is preferred over a match on a reference `&T` + // After Rust 2018 you can use self here and tail (with no ref) below as well, + // rust will infer &s and ref tail. + // See https://doc.rust-lang.org/edition-guide/rust-2018/ownership-and-lifetimes/default-match-bindings.html + match *self { + // Can't take ownership of the tail, because `self` is borrowed; + // Instead take a reference to the tail + Cons(_, ref tail) => 1 + tail.len(), + // Base Case: An empty list has zero length + Nil => 0 + } + } + + // Return representation of the list as a (heap allocated) string + fn stringify(&self) -> String { + match *self { + Cons(head, __ tail) => { + // `format!` is similar to `print!`, but returns a heap + // allocated string instead of printing to the console + format!("{}, {}", head, tail.__()) + }, + Nil => { + format!("Nil") + }, + } + } +} + +fn main() { + // Create an empty linked list + let mut list = List::new(); + + // Prepend some elements + list = list.prepend(1); + list = list.prepend(2); + list = list.prepend(3); + + // Show the final state of the list + println!("linked list has length: {}", list.len()); + println!("{}", list.stringify()); +}
++ + +You can find the solutions here(under the solutions path), but only use it when you need it
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/compound-types/slice.html b/compound-types/slice.html
new file mode 100644
index 000000000..fe84f256b
--- /dev/null
+++ b/compound-types/slice.html
@@ -0,0 +1,309 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Compound Types
+Learning resources:
+-
+
- English: Rust Book 4.3, 5.1, 6.1, 8.2 +
- 简体中文: Rust语言圣经 - 复合类型 +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/compound-types/string.html b/compound-types/string.html
new file mode 100644
index 000000000..b7e6bb455
--- /dev/null
+++ b/compound-types/string.html
@@ -0,0 +1,451 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Slice
+Slices are similar to arrays, but their length is not known at compile time, so you can't use slice directly.
+-
+
- 🌟🌟 Here, both
[i32]andstrare slice types, but directly using it will cause errors. You have to use the reference of the slice instead:&[i32],&str.
+
++// Fix the errors, DON'T add new lines! +fn main() { + let arr = [1, 2, 3]; + let s1: [i32] = arr[0..2]; + + let s2: str = "hello, world" as str; + + println!("Success!"); +}
A slice reference is a two-word object, for simplicity reasons, from now on we will use slice instead of slice reference. The first word is a pointer to the data, and the second word is the length of the slice. The word size is the same as usize, determined by the processor architecture, e.g. 64 bits on an x86-64. Slices can be used to borrow a section of an array, and have the type signature &[T].
-
+
- 🌟🌟🌟 +
++fn main() { + let arr: [char; 3] = ['中', '国', '人']; + + let slice = &arr[..2]; + + // Modify '8' to make it work + // TIPS: slice( reference ) IS NOT an array, if it is an array, then `assert!` will be passed: Each of the two chars '中' and '国' occupies 4 bytes, 2 * 4 = 8 + assert!(std::mem::size_of_val(&slice) == 8); + + println!("Success!"); +}
-
+
- 🌟🌟 +
++fn main() { + let arr: [i32; 5] = [1, 2, 3, 4, 5]; + // Fill the blanks to make the code work + let slice: __ = __; + assert_eq!(slice, &[2, 3, 4]); + + println!("Success!"); +}
String slices
+-
+
- 🌟 +
++fn main() { + let s = String::from("hello"); + + let slice1 = &s[0..2]; + // Fill the blank to make the code work, DON'T USE 0..2 again + let slice2 = &s[__]; + + assert_eq!(slice1, slice2); + + println!("Success!"); +}
-
+
- 🌟 +
++fn main() { + let s = "你好，世界"; + // Modify this line to make the code work + let slice = &s[0..2]; + + assert!(slice == "你"); + + println!("Success!"); +}
-
+
- 🌟🌟
&Stringcan be implicitly converted into&str.
+
++// Fix errors +fn main() { + let mut s = String::from("hello world"); + + // Here, &s is `&String` type, but `first_letter` needs a `&str` type. + // It works because `&String` can be implicitly converted to `&str. If you want to know more, this is called `Deref coercion`. + let letter = first_letter(&s); + + s.clear(); // error! + + println!("the first letter is: {}", letter); +} +fn first_letter(s: &str) -> &str { + &s[..1] +}
++ + +You can find the solutions here(under the solutions path), but only use it when you need it
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/compound-types/struct.html b/compound-types/struct.html
new file mode 100644
index 000000000..8a7b0b926
--- /dev/null
+++ b/compound-types/struct.html
@@ -0,0 +1,428 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ String
+The type of string literal "hello, world" is &str, e.g let s: &str = "hello, world".
Str and &str
+-
+
- 🌟 We can't use
strtype in normal ways, but we can use&str.
+
++// Fix error without adding new line +fn main() { + let s: str = "hello, world"; + + println!("Success!"); +}
-
+
- 🌟🌟 We can only use
strby boxing it,&can be used to convertBox<str>to&str
+
++// Fix the error with at least two solutions +fn main() { + let s: Box<str> = "hello, world".into(); + greetings(s) +} + +fn greetings(s: &str) { + println!("{}",s) +}
String
+String type is defined in std and stored as a vector of bytes (Vec
-
+
- 🌟 +
++// Fill the blank +fn main() { + let mut s = __; + s.push_str("hello, world"); + s.push('!'); + + assert_eq!(s, "hello, world!"); + + println!("Success!"); +}
-
+
- 🌟🌟🌟 +
++// Fix all errors without adding newline +fn main() { + let s = String::from("hello"); + s.push(','); + s.push(" world"); + s += "!".to_string(); + + println!("{}", s); +}
-
+
- 🌟🌟
replacecan be used to replace substring
+
++// Fill the blank +fn main() { + let s = String::from("I like dogs"); + // Allocate new memory and store the modified string there + let s1 = s.__("dogs", "cats"); + + assert_eq!(s1, "I like cats"); + + println!("Success!"); +}
More String methods can be found under String module.
-
+
- 🌟🌟 You can only concat a
Stringwith&str, andString's ownership can be moved to another variable.
+
++// Fix errors without removing any line +fn main() { + let s1 = String::from("hello,"); + let s2 = String::from("world!"); + let s3 = s1 + s2; + assert_eq!(s3, "hello,world!"); + println!("{}", s1); +}
&str and String
+Opposite to the seldom using of str, &str and String are used everywhere!
-
+
- 🌟🌟
&strcan be converted toStringin two ways
+
++// Fix error with at least two solutions +fn main() { + let s = "hello, world"; + greetings(s) +} + +fn greetings(s: String) { + println!("{}", s) +}
-
+
- 🌟🌟 We can use
String::fromorto_stringto convert a&strtoString
+
++// Use two approaches to fix the error and without adding a new line +fn main() { + let s = "hello, world".to_string(); + let s1: &str = s; + + println!("Success!"); +}
String escapes
+-
+
- 🌟 +
+fn main() { + // You can use escapes to write bytes by their hexadecimal values + // Fill the blank below to show "I'm writing Rust" + let byte_escape = "I'm writing Ru\x73__!"; + println!("What are you doing\x3F (\\x3F means ?) {}", byte_escape); + + // ...Or Unicode code points. + let unicode_codepoint = "\u{211D}"; + let character_name = "\"DOUBLE-STRUCK CAPITAL R\""; + + println!("Unicode character {} (U+211D) is called {}", + unicode_codepoint, character_name ); + + let long_string = "String literals + can span multiple lines. + The linebreak and indentation here \ + can be escaped too!"; + println!("{}", long_string); +}
-
+
- 🌟🌟🌟 Sometimes there are just too many characters that need to be escaped or it's just much more convenient to write a string out as-is. This is where raw string literals come into play. +
++/* Fill in the blank and fix the errors */ +fn main() { + let raw_str = r"Escapes don't work here: \x3F \u{211D}"; + // Modify above line to make it work + assert_eq!(raw_str, "Escapes don't work here: ? ℝ"); + + // If you need quotes in a raw string, add a pair of #s + let quotes = r#"And then I said: "There is no escape!""#; + println!("{}", quotes); + + // If you need "# in your string, just use more #s in the delimiter. + // You can use up to 65535 #s. + let delimiter = r###"A string with "# in it. And even "##!"###; + println!("{}", delimiter); + + // Fill the blank + let long_delimiter = __; + assert_eq!(long_delimiter, "Hello, \"##\""); + + println!("Success!"); +}
Byte string
+Want a string that's not UTF-8? (Remember, str and String must be valid UTF-8). Or maybe you want an array of bytes that's mostly text? Byte strings to the rescue!
+Example:
++use std::str; + +fn main() { + // Note that this is not actually a `&str` + let bytestring: &[u8; 21] = b"this is a byte string"; + + // Byte arrays don't have the `Display` trait, so printing them is a bit limited + println!("A byte string: {:?}", bytestring); + + // Byte strings can have byte escapes... + let escaped = b"\x52\x75\x73\x74 as bytes"; + // ...But no unicode escapes + // let escaped = b"\u{211D} Is not allowed"; + println!("Some escaped bytes: {:?}", escaped); + + + // Raw byte strings work just like raw strings + let raw_bytestring = br"\u{211D} is not escaped here"; + println!("{:?}", raw_bytestring); + + // Converting a byte array to `str` can fail + if let Ok(my_str) = str::from_utf8(raw_bytestring) { + println!("And the same as text: '{}'", my_str); + } + + let _quotes = br#"You can also use "fancier" formatting, \ + like with normal raw strings"#; + + // Byte strings don't have to be UTF-8 + let shift_jis = b"\x82\xe6\x82\xa8\x82\xb1\x82\xbb"; // "ようこそ" In SHIFT-JIS + + // But then they can't always be converted to `str` + match str::from_utf8(shift_jis) { + Ok(my_str) => println!("Conversion successful: '{}'", my_str), + Err(e) => println!("Conversion failed: {:?}", e), + }; +}
A more detailed listing of the ways to write string literals and escape characters is given in the 'Tokens' chapter of the Rust Reference.
+String index
+-
+
- 🌟🌟🌟 You can't use index to access a char in a string, but you can use slice
&s1[start..end].
+
++fn main() { + let s1 = String::from("hi,中国"); + let h = s1[0]; // Modify this line to fix the error, tips: `h` only takes 1 byte in UTF8 format + assert_eq!(h, "h"); + + let h1 = &s1[3..5]; // Modify this line to fix the error, tips: `中` takes 3 bytes in UTF8 format + assert_eq!(h1, "中"); + + println!("Success!"); +}
Operate on UTF8 string
+-
+
- 🌟 +
++fn main() { + // Fill the blank to print each char in "你好，世界" + for c in "你好，世界".__ { + println!("{}", c) + } +}
utf8_slice
+You can use utf8_slice to slice UTF8 string, it can index chars instead of bytes.
+Example
++use utf8_slice; +fn main() { + let s = "The 🚀 goes to the 🌑!"; + + let rocket = utf8_slice::slice(s, 4, 5); + // Will equal "🚀" +}
++ + +You can find the solutions here(under the solutions path), but only use it when you need it
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/compound-types/tuple.html b/compound-types/tuple.html
new file mode 100644
index 000000000..3b3f3a328
--- /dev/null
+++ b/compound-types/tuple.html
@@ -0,0 +1,300 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Struct
+The types of structs
+-
+
- 🌟 We must specify concrete values for each of the fields in struct. +
++// Fix the error +struct Person { + name: String, + age: u8, + hobby: String +} +fn main() { + let age = 30; + let p = Person { + name: String::from("sunface"), + age, + }; + + println!("Success!"); +}
-
+
- 🌟 Unit struct don't have any fields. It can be useful when you need to implement a trait on some type but don’t have any data that you want to store in the type itself. +
++struct Unit; +trait SomeTrait { + // ...Some behaviors defined here. +} + +// We don't care about what fields are in the Unit, but we care about its behaviors. +// So we use a struct with no fields and implement some behaviors for it +impl SomeTrait for Unit { } +fn main() { + let u = Unit; + do_something_with_unit(u); + + println!("Success!"); +} + +// Fill the blank to make the code work +fn do_something_with_unit(u: __) { }
-
+
- 🌟🌟🌟 Tuple struct looks similar to tuples, it has added meaning the struct name provides but has no named fields. It's useful when you want to give the whole tuple a name, but don't care about the fields's names. +
++// Fix the error and fill the blanks +struct Color(i32, i32, i32); +struct Point(i32, i32, i32); +fn main() { + let v = Point(__, __, __); + check_color(v); + + println!("Success!"); +} + +fn check_color(p: Color) { + let (x, _, _) = p; + assert_eq!(x, 0); + assert_eq!(p.1, 127); + assert_eq!(__, 255); + }
Operating on structs
+-
+
- 🌟 You can make a whole struct mutable when instantiating it, but Rust doesn't allow us to mark only certain fields as mutable. +
++// Fill the blank and fix the error without adding/removing new line +struct Person { + name: String, + age: u8, +} +fn main() { + let age = 18; + let p = Person { + name: String::from("sunface"), + age, + }; + + // How can you believe sunface is only 18? + p.age = 30; + + // Fill the blank + __ = String::from("sunfei"); + + println!("Success!"); +}
-
+
- 🌟 Using field init shorthand syntax to reduce repetitions. +
++// Fill the blank +struct Person { + name: String, + age: u8, +} +fn main() { + println!("Success!"); +} + +fn build_person(name: String, age: u8) -> Person { + Person { + age, + __ + } +}
-
+
- 🌟 You can create instance from other instance with struct update syntax +
++// Fill the blank to make the code work +struct User { + active: bool, + username: String, + email: String, + sign_in_count: u64, +} +fn main() { + let u1 = User { + email: String::from("someone@example.com"), + username: String::from("sunface"), + active: true, + sign_in_count: 1, + }; + + let u2 = set_email(u1); + + println!("Success!"); +} + +fn set_email(u: User) -> User { + User { + email: String::from("contact@im.dev"), + __ + } +}
Print the structs
+-
+
- 🌟🌟 We can use
#[derive(Debug)]to make a struct printable.
+
++// Fill the blanks to make the code work +#[__] +struct Rectangle { + width: u32, + height: u32, +} + +fn main() { + let scale = 2; + let rect1 = Rectangle { + width: dbg!(30 * scale), // Print debug info to stderr and assign the value of `30 * scale` to `width` + height: 50, + }; + + dbg!(&rect1); // Print debug info to stderr + + println!(__, rect1); // Print debug info to stdout +}
Partial move
+Within the destructuring of a single variable, both by-move and by-reference pattern bindings can be used at the same time. Doing this will result in a partial move of the variable, which means that parts of the variable will be moved while other parts stay. In such a case, the parent variable cannot be used afterwards as a whole, however the parts that are only referenced (and not moved) can still be used.
+Example
+++fn main() { + #[derive(Debug)] + struct Person { + name: String, + age: Box<u8>, + } + + let person = Person { + name: String::from("Alice"), + age: Box::new(20), + }; + + // `name` is moved out of person, but `age` is referenced + let Person { name, ref age } = person; + + println!("The person's age is {}", age); + + println!("The person's name is {}", name); + + // Error! borrow of partially moved value: `person` partial move occurs + //println!("The person struct is {:?}", person); + + // `person` cannot be used but `person.age` can be used as it is not moved + println!("The person's age from person struct is {}", person.age); +}
Exercises
+-
+
- 🌟🌟 +
++// Fix errors to make it work +#[derive(Debug)] +struct File { + name: String, + data: String, +} +fn main() { + let f = File { + name: String::from("readme.md"), + data: "Rust By Practice".to_string() + }; + + let _name = f.name; + + // ONLY modify this line + println!("{}, {}, {:?}",f.name, f.data, f); +}
++ + +You can find the solutions here(under the solutions path), but only use it when you need it
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/crate-module/crate.html b/crate-module/crate.html
new file mode 100644
index 000000000..822246797
--- /dev/null
+++ b/crate-module/crate.html
@@ -0,0 +1,312 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Tuple
+-
+
- 🌟 Elements in a tuple can have different types. Tuple's type signature is
(T1, T2, ...), whereT1,T2are the types of tuple's members.
+
++fn main() { + let _t0: (u8,i16) = (0, -1); + // Tuples can be tuple's members + let _t1: (u8, (i16, u32)) = (0, (-1, 1)); + // Fill the blanks to make the code work + let t: (u8, __, i64, __, __) = (1u8, 2u16, 3i64, "hello", String::from(", world")); + + println!("Success!"); +}
-
+
- 🌟 Members can be extracted from the tuple using indexing. +
++// Make it work +fn main() { + let t = ("i", "am", "sunface"); + assert_eq!(t.1, "sunface"); + + println!("Success!"); +}
-
+
- 🌟 Long tuples cannot be printed +
++// Fix the error +fn main() { + let too_long_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13); + println!("too long tuple: {:?}", too_long_tuple); +}
-
+
- 🌟 Destructuring tuple with pattern. +
++fn main() { + let tup = (1, 6.4, "hello"); + + // Fill the blank to make the code work + let __ = tup; + + assert_eq!(x, 1); + assert_eq!(y, "hello"); + assert_eq!(z, 6.4); + + println!("Success!"); +}
-
+
- 🌟🌟 Destructure assignments. +
+fn main() { + let (x, y, z); + + // Fill the blank + __ = (1, 2, 3); + + assert_eq!(x, 3); + assert_eq!(y, 1); + assert_eq!(z, 2); + + println!("Success!"); +}
-
+
- 🌟🌟 Tuples can be used as function arguments and return values +
++fn main() { + // Fill the blank, need a few computations here. + let (x, y) = sum_multiply(__); + + assert_eq!(x, 5); + assert_eq!(y, 6); + + println!("Success!"); +} + +fn sum_multiply(nums: (i32, i32)) -> (i32, i32) { + (nums.0 + nums.1, nums.0 * nums.1) +}
++ + +You can find the solutions here(under the solutions path), but only use it when you need it
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/crate-module/intro.html b/crate-module/intro.html
new file mode 100644
index 000000000..e489a083b
--- /dev/null
+++ b/crate-module/intro.html
@@ -0,0 +1,221 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Package and Crate
+A package is a project which you create with Cargo (in most cases), so it contains a Cargo.toml file in it.
-
+
- 🌟 Create a package with below layout: +
.
+├── Cargo.toml
+└── src
+ └── main.rs
+
+1 directory, 2 files
+# in Cargo.toml
+[package]
+name = "hello-package"
+version = "0.1.0"
+edition = "2021"
+++Note! We will use this package across the whole chapter as a practice project.
+
-
+
- 🌟 Create a package with below layout: +
.
+├── Cargo.toml
+└── src
+ └── lib.rs
+
+1 directory, 2 files
+# in Cargo.toml
+[package]
+name = "hello-package1"
+version = "0.1.0"
+edition = "2021"
+++Note! This package could be safely removed due to the first one's existence.
+
-
+
- 🌟 +
+/* FILL in the blank with your ANSWER */ + +// Q: What's the difference between package number 1 and number 2? +// A: __
Crate
+A crate is a binary or library. The crate root is a source file that the Rust compiler starts from and makes up the root module of the crate.
+In package hello-package, there is binary crate with the same name as the package : hello-package, and src/main.rs is the crate root of this binary crate.
Similar to hello-package, hello-package1 also has a crate in it, however, this package doesn't contain a binary crate but a library crate, and src/lib.rs is the crate root.
-
+
- 🌟 +
+/* FILL in the blank with your ANSWER */ + +// Q: What's the name of the library crate in package `hello-package1`? +// A: __
-
+
- 🌟🌟 Add a library crate for
hello-packageand describe it's files tree below:
+
# FILL in the blanks
+.
+├── Cargo.lock
+├── Cargo.toml
+├── src
+│ ├── __
+│ └── __
+After this step, there should be two crates in package hello-package: a binary crate and a library crate, both with the same name as the package.
-
+
- 🌟🌟🌟 A package can contain at most one library crate, but it can contain as many binary crates as you would like by placing files in
src/bindirectory: each file will be a separate binary crate with the same name as the file.
+
# Create a package which contains
+# 1. three binary crates: `hello-package`, `main1` and `main2`
+# 2. one library crate
+# describe the directory tree below
+.
+├── Cargo.toml
+├── Cargo.lock
+├── src
+│ ├── __
+│ ├── __
+│ └── __
+│ └── __
+│ └── __
+├── tests # directory for integrated tests files
+│ └── some_integration_tests.rs
+├── benches # dir for benchmark files
+│ └── simple_bench.rs
+└── examples # dir for example files
+ └── simple_example.rs
+Yep, as you can see, the above package structure is very standard and is widely used in many Rust projects.
+++ + +You can find the solutions here (under the solutions path), but only use it when you need it :)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/crate-module/module.html b/crate-module/module.html
new file mode 100644
index 000000000..f6e79ca98
--- /dev/null
+++ b/crate-module/module.html
@@ -0,0 +1,375 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Crate and module
+Learning resources:
+-
+
- English: Rust Book Chapter 7 +
- 简体中文: Rust语言圣经 - 包和模块 +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/crate-module/use-pub.html b/crate-module/use-pub.html
new file mode 100644
index 000000000..33c6559cb
--- /dev/null
+++ b/crate-module/use-pub.html
@@ -0,0 +1,274 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Module
+Modules let us organize the code within a crate into groups for readability and ease of reuse. Module also controls the privacy of items, which is whether an item can be seen by outside code( public ), or is just an internal implementation and not available for outside code( private ).
+We have created a package named hello-package in previous chapter, and it looks like this:
.
+├── Cargo.toml
+├── src
+│ ├── lib.rs
+│ └── main.rs
+Now it's time to create some modules in the library crate and use them in the binary crate, let's start.
+-
+
- 🌟🌟 Implement module
front_of_housebased on the module tree below:
+
library crate root
+ └── front_of_house
+ ├── hosting
+ │ ├── add_to_waitlist
+ │ └── seat_at_table
+ └── serving
+ ├── take_order
+ ├── serve_order
+ ├── take_payment
+ └── complain
++// FILL in the blank +// in __.rs + +mod front_of_house { + // IMPLEMENT this module.. +}
-
+
- 🌟🌟 Let's call
add_to_waitlistfrom a functioneat_at_restaurantwhich is within the library crate root.
+
+// In lib.rs + +// FILL in the blanks and FIX the errors +// You need to make something public with `pub` to provide accessibility for outside code `fn eat_at_restaurant()` +mod front_of_house { + /* ...snip... */ +} + +pub fn eat_at_restaurant() { + // Call add_to_waitlist with **absolute path**: + __.add_to_waitlist(); + + // Call with **relative path** + __.add_to_waitlist(); +}
-
+
- 🌟🌟 You can use
superto import items within the parent module
+
+// In lib.rs + +mod back_of_house { + fn fix_incorrect_order() { + cook_order(); + // FILL in the blank in three ways + //1. using keyword `super` + //2. using absolute path + __.serve_order(); + } + + fn cook_order() {} +}
Separating modules into different files
++// In lib.rs +pub mod front_of_house { + pub mod hosting { + pub fn add_to_waitlist() {} + + pub fn seat_at_table() -> String { + String::from("sit down please") + } + } + + pub mod serving { + pub fn take_order() {} + + pub fn serve_order() {} + + pub fn take_payment() {} + + // Maybe you don't want the guest hearing the your complaining about them + // So just make it private + fn complain() {} + } +} + +pub fn eat_at_restaurant() -> String { + front_of_house::hosting::add_to_waitlist(); + + back_of_house::cook_order(); + + String::from("yummy yummy!") +} + +pub mod back_of_house { + pub fn fix_incorrect_order() { + cook_order(); + crate::front_of_house::serving::serve_order(); + } + + pub fn cook_order() {} +}
-
+
- 🌟🌟🌟🌟 Please separate the modules and codes above into files resident in below dir tree : +
.
+├── Cargo.toml
+├── src
+│ ├── back_of_house.rs
+│ ├── front_of_house
+│ │ ├── hosting.rs
+│ │ ├── mod.rs
+│ │ └── serving.rs
+│ ├── lib.rs
+│ └── main.rs
++// In src/lib.rs + +// IMPLEMENT...
+// In src/back_of_house.rs + +// IMPLEMENT...
+// In src/front_of_house/mod.rs + +// IMPLEMENT...
+// In src/front_of_house/hosting.rs + +// IMPLEMENT...
+// In src/front_of_house/serving.rs + +// IMPLEMENT...
Accessing code in library crate from binary crate
+Please ensure you have completed the 4th exercise before making further progress.
+You should have below structures and the corresponding codes in them when reaching here:
+.
+├── Cargo.toml
+├── src
+│ ├── back_of_house.rs
+│ ├── front_of_house
+│ │ ├── hosting.rs
+│ │ ├── mod.rs
+│ │ └── serving.rs
+│ ├── lib.rs
+│ └── main.rs
+-
+
- 🌟🌟🌟 Now we will call a few library functions from the binary crate. +
+// In src/main.rs + +// FILL in the blank and FIX the errors +fn main() { + assert_eq!(__, "sit down please"); + assert_eq!(__,"yummy yummy!"); +}
++ + +You can find the solutions here (under the solutions path), but only use it when you need it :)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/css/chrome.css b/css/chrome.css
new file mode 100644
index 000000000..2314f7a16
--- /dev/null
+++ b/css/chrome.css
@@ -0,0 +1,587 @@
+/* CSS for UI elements (a.k.a. chrome) */
+
+@import 'variables.css';
+
+html {
+ scrollbar-color: var(--scrollbar) var(--bg);
+}
+#searchresults a,
+.content a:link,
+a:visited,
+a > .hljs {
+ color: var(--links);
+}
+
+/*
+ body-container is necessary because mobile browsers don't seem to like
+ overflow-x on the body tag when there is a tag.
+*/
+#body-container {
+ /*
+ This is used when the sidebar pushes the body content off the side of
+ the screen on small screens. Without it, dragging on mobile Safari
+ will want to reposition the viewport in a weird way.
+ */
+ overflow-x: clip;
+}
+
+/* Menu Bar */
+
+#menu-bar,
+#menu-bar-hover-placeholder {
+ z-index: 101;
+ margin: auto calc(0px - var(--page-padding));
+}
+#menu-bar {
+ position: relative;
+ display: flex;
+ flex-wrap: wrap;
+ background-color: var(--bg);
+ border-block-end-color: var(--bg);
+ border-block-end-width: 1px;
+ border-block-end-style: solid;
+}
+#menu-bar.sticky,
+.js #menu-bar-hover-placeholder:hover + #menu-bar,
+.js #menu-bar:hover,
+.js.sidebar-visible #menu-bar {
+ position: -webkit-sticky;
+ position: sticky;
+ top: 0 !important;
+}
+#menu-bar-hover-placeholder {
+ position: sticky;
+ position: -webkit-sticky;
+ top: 0;
+ height: var(--menu-bar-height);
+}
+#menu-bar.bordered {
+ border-block-end-color: var(--table-border-color);
+}
+#menu-bar i, #menu-bar .icon-button {
+ position: relative;
+ padding: 0 8px;
+ z-index: 10;
+ line-height: var(--menu-bar-height);
+ cursor: pointer;
+ transition: color 0.5s;
+}
+@media only screen and (max-width: 420px) {
+ #menu-bar i, #menu-bar .icon-button {
+ padding: 0 5px;
+ }
+}
+
+.icon-button {
+ border: none;
+ background: none;
+ padding: 0;
+ color: inherit;
+}
+.icon-button i {
+ margin: 0;
+}
+
+.right-buttons {
+ margin: 0 15px;
+}
+.right-buttons a {
+ text-decoration: none;
+}
+
+.left-buttons {
+ display: flex;
+ margin: 0 5px;
+}
+.no-js .left-buttons button {
+ display: none;
+}
+
+.menu-title {
+ display: inline-block;
+ font-weight: 200;
+ font-size: 2.4rem;
+ line-height: var(--menu-bar-height);
+ text-align: center;
+ margin: 0;
+ flex: 1;
+ white-space: nowrap;
+ overflow: hidden;
+ text-overflow: ellipsis;
+}
+.js .menu-title {
+ cursor: pointer;
+}
+
+.menu-bar,
+.menu-bar:visited,
+.nav-chapters,
+.nav-chapters:visited,
+.mobile-nav-chapters,
+.mobile-nav-chapters:visited,
+.menu-bar .icon-button,
+.menu-bar a i {
+ color: var(--icons);
+}
+
+.menu-bar i:hover,
+.menu-bar .icon-button:hover,
+.nav-chapters:hover,
+.mobile-nav-chapters i:hover {
+ color: var(--icons-hover);
+}
+
+/* Nav Icons */
+
+.nav-chapters {
+ font-size: 2.5em;
+ text-align: center;
+ text-decoration: none;
+
+ position: fixed;
+ top: 0;
+ bottom: 0;
+ margin: 0;
+ max-width: 150px;
+ min-width: 90px;
+
+ display: flex;
+ justify-content: center;
+ align-content: center;
+ flex-direction: column;
+
+ transition: color 0.5s, background-color 0.5s;
+}
+
+.nav-chapters:hover {
+ text-decoration: none;
+ background-color: var(--theme-hover);
+ transition: background-color 0.15s, color 0.15s;
+}
+
+.nav-wrapper {
+ margin-block-start: 50px;
+ display: none;
+}
+
+.mobile-nav-chapters {
+ font-size: 2.5em;
+ text-align: center;
+ text-decoration: none;
+ width: 90px;
+ border-radius: 5px;
+ background-color: var(--sidebar-bg);
+}
+
+/* Only Firefox supports flow-relative values */
+.previous { float: left; }
+[dir=rtl] .previous { float: right; }
+
+/* Only Firefox supports flow-relative values */
+.next {
+ float: right;
+ right: var(--page-padding);
+}
+[dir=rtl] .next {
+ float: left;
+ right: unset;
+ left: var(--page-padding);
+}
+
+/* Use the correct buttons for RTL layouts*/
+[dir=rtl] .previous i.fa-angle-left:before {content:"\f105";}
+[dir=rtl] .next i.fa-angle-right:before { content:"\f104"; }
+
+@media only screen and (max-width: 1080px) {
+ .nav-wide-wrapper { display: none; }
+ .nav-wrapper { display: block; }
+}
+
+/* sidebar-visible */
+@media only screen and (max-width: 1380px) {
+ #sidebar-toggle-anchor:checked ~ .page-wrapper .nav-wide-wrapper { display: none; }
+ #sidebar-toggle-anchor:checked ~ .page-wrapper .nav-wrapper { display: block; }
+}
+
+/* Inline code */
+
+:not(pre) > .hljs {
+ display: inline;
+ padding: 0.1em 0.3em;
+ border-radius: 3px;
+}
+
+:not(pre):not(a) > .hljs {
+ color: var(--inline-code-color);
+ overflow-x: initial;
+}
+
+a:hover > .hljs {
+ text-decoration: underline;
+}
+
+pre {
+ position: relative;
+}
+pre > .buttons {
+ position: absolute;
+ z-index: 100;
+ right: 0px;
+ top: 2px;
+ margin: 0px;
+ padding: 2px 0px;
+
+ color: var(--sidebar-fg);
+ cursor: pointer;
+ visibility: hidden;
+ opacity: 0;
+ transition: visibility 0.1s linear, opacity 0.1s linear;
+}
+pre:hover > .buttons {
+ visibility: visible;
+ opacity: 1
+}
+pre > .buttons :hover {
+ color: var(--sidebar-active);
+ border-color: var(--icons-hover);
+ background-color: var(--theme-hover);
+}
+pre > .buttons i {
+ margin-inline-start: 8px;
+}
+pre > .buttons button {
+ cursor: inherit;
+ margin: 0px 5px;
+ padding: 3px 5px;
+ font-size: 14px;
+
+ border-style: solid;
+ border-width: 1px;
+ border-radius: 4px;
+ border-color: var(--icons);
+ background-color: var(--theme-popup-bg);
+ transition: 100ms;
+ transition-property: color,border-color,background-color;
+ color: var(--icons);
+}
+@media (pointer: coarse) {
+ pre > .buttons button {
+ /* On mobile, make it easier to tap buttons. */
+ padding: 0.3rem 1rem;
+ }
+}
+pre > code {
+ padding: 1rem;
+}
+
+/* FIXME: ACE editors overlap their buttons because ACE does absolute
+ positioning within the code block which breaks padding. The only solution I
+ can think of is to move the padding to the outer pre tag (or insert a div
+ wrapper), but that would require fixing a whole bunch of CSS rules.
+*/
+.hljs.ace_editor {
+ padding: 0rem 0rem;
+}
+
+pre > .result {
+ margin-block-start: 10px;
+}
+
+/* Search */
+
+#searchresults a {
+ text-decoration: none;
+}
+
+mark {
+ border-radius: 2px;
+ padding-block-start: 0;
+ padding-block-end: 1px;
+ padding-inline-start: 3px;
+ padding-inline-end: 3px;
+ margin-block-start: 0;
+ margin-block-end: -1px;
+ margin-inline-start: -3px;
+ margin-inline-end: -3px;
+ background-color: var(--search-mark-bg);
+ transition: background-color 300ms linear;
+ cursor: pointer;
+}
+
+mark.fade-out {
+ background-color: rgba(0,0,0,0) !important;
+ cursor: auto;
+}
+
+.searchbar-outer {
+ margin-inline-start: auto;
+ margin-inline-end: auto;
+ max-width: var(--content-max-width);
+}
+
+#searchbar {
+ width: 100%;
+ margin-block-start: 5px;
+ margin-block-end: 0;
+ margin-inline-start: auto;
+ margin-inline-end: auto;
+ padding: 10px 16px;
+ transition: box-shadow 300ms ease-in-out;
+ border: 1px solid var(--searchbar-border-color);
+ border-radius: 3px;
+ background-color: var(--searchbar-bg);
+ color: var(--searchbar-fg);
+}
+#searchbar:focus,
+#searchbar.active {
+ box-shadow: 0 0 3px var(--searchbar-shadow-color);
+}
+
+.searchresults-header {
+ font-weight: bold;
+ font-size: 1em;
+ padding-block-start: 18px;
+ padding-block-end: 0;
+ padding-inline-start: 5px;
+ padding-inline-end: 0;
+ color: var(--searchresults-header-fg);
+}
+
+.searchresults-outer {
+ margin-inline-start: auto;
+ margin-inline-end: auto;
+ max-width: var(--content-max-width);
+ border-block-end: 1px dashed var(--searchresults-border-color);
+}
+
+ul#searchresults {
+ list-style: none;
+ padding-inline-start: 20px;
+}
+ul#searchresults li {
+ margin: 10px 0px;
+ padding: 2px;
+ border-radius: 2px;
+}
+ul#searchresults li.focus {
+ background-color: var(--searchresults-li-bg);
+}
+ul#searchresults span.teaser {
+ display: block;
+ clear: both;
+ margin-block-start: 5px;
+ margin-block-end: 0;
+ margin-inline-start: 20px;
+ margin-inline-end: 0;
+ font-size: 0.8em;
+}
+ul#searchresults span.teaser em {
+ font-weight: bold;
+ font-style: normal;
+}
+
+/* Sidebar */
+
+.sidebar {
+ position: fixed;
+ left: 0;
+ top: 0;
+ bottom: 0;
+ width: var(--sidebar-width);
+ font-size: 0.875em;
+ box-sizing: border-box;
+ -webkit-overflow-scrolling: touch;
+ overscroll-behavior-y: contain;
+ background-color: var(--sidebar-bg);
+ color: var(--sidebar-fg);
+}
+[dir=rtl] .sidebar { left: unset; right: 0; }
+.sidebar-resizing {
+ -moz-user-select: none;
+ -webkit-user-select: none;
+ -ms-user-select: none;
+ user-select: none;
+}
+.no-js .sidebar,
+.js:not(.sidebar-resizing) .sidebar {
+ transition: transform 0.3s; /* Animation: slide away */
+}
+.sidebar code {
+ line-height: 2em;
+}
+.sidebar .sidebar-scrollbox {
+ overflow-y: auto;
+ position: absolute;
+ top: 0;
+ bottom: 0;
+ left: 0;
+ right: 0;
+ padding: 10px 10px;
+}
+.sidebar .sidebar-resize-handle {
+ position: absolute;
+ cursor: col-resize;
+ width: 0;
+ right: 0;
+ top: 0;
+ bottom: 0;
+}
+[dir=rtl] .sidebar .sidebar-resize-handle { right: unset; left: 0; }
+.js .sidebar .sidebar-resize-handle {
+ cursor: col-resize;
+ width: 5px;
+}
+/* sidebar-hidden */
+#sidebar-toggle-anchor:not(:checked) ~ .sidebar {
+ transform: translateX(calc(0px - var(--sidebar-width)));
+ z-index: -1;
+}
+[dir=rtl] #sidebar-toggle-anchor:not(:checked) ~ .sidebar {
+ transform: translateX(var(--sidebar-width));
+}
+.sidebar::-webkit-scrollbar {
+ background: var(--sidebar-bg);
+}
+.sidebar::-webkit-scrollbar-thumb {
+ background: var(--scrollbar);
+}
+
+/* sidebar-visible */
+#sidebar-toggle-anchor:checked ~ .page-wrapper {
+ transform: translateX(var(--sidebar-width));
+}
+[dir=rtl] #sidebar-toggle-anchor:checked ~ .page-wrapper {
+ transform: translateX(calc(0px - var(--sidebar-width)));
+}
+@media only screen and (min-width: 620px) {
+ #sidebar-toggle-anchor:checked ~ .page-wrapper {
+ transform: none;
+ margin-inline-start: var(--sidebar-width);
+ }
+ [dir=rtl] #sidebar-toggle-anchor:checked ~ .page-wrapper {
+ transform: none;
+ }
+}
+
+.chapter {
+ list-style: none outside none;
+ padding-inline-start: 0;
+ line-height: 2.2em;
+}
+
+.chapter ol {
+ width: 100%;
+}
+
+.chapter li {
+ display: flex;
+ color: var(--sidebar-non-existant);
+}
+.chapter li a {
+ display: block;
+ padding: 0;
+ text-decoration: none;
+ color: var(--sidebar-fg);
+}
+
+.chapter li a:hover {
+ color: var(--sidebar-active);
+}
+
+.chapter li a.active {
+ color: var(--sidebar-active);
+}
+
+.chapter li > a.toggle {
+ cursor: pointer;
+ display: block;
+ margin-inline-start: auto;
+ padding: 0 10px;
+ user-select: none;
+ opacity: 0.68;
+}
+
+.chapter li > a.toggle div {
+ transition: transform 0.5s;
+}
+
+/* collapse the section */
+.chapter li:not(.expanded) + li > ol {
+ display: none;
+}
+
+.chapter li.chapter-item {
+ line-height: 1.5em;
+ margin-block-start: 0.6em;
+}
+
+.chapter li.expanded > a.toggle div {
+ transform: rotate(90deg);
+}
+
+.spacer {
+ width: 100%;
+ height: 3px;
+ margin: 5px 0px;
+}
+.chapter .spacer {
+ background-color: var(--sidebar-spacer);
+}
+
+@media (-moz-touch-enabled: 1), (pointer: coarse) {
+ .chapter li a { padding: 5px 0; }
+ .spacer { margin: 10px 0; }
+}
+
+.section {
+ list-style: none outside none;
+ padding-inline-start: 20px;
+ line-height: 1.9em;
+}
+
+/* Theme Menu Popup */
+
+.theme-popup {
+ position: absolute;
+ left: 10px;
+ top: var(--menu-bar-height);
+ z-index: 1000;
+ border-radius: 4px;
+ font-size: 0.7em;
+ color: var(--fg);
+ background: var(--theme-popup-bg);
+ border: 1px solid var(--theme-popup-border);
+ margin: 0;
+ padding: 0;
+ list-style: none;
+ display: none;
+ /* Don't let the children's background extend past the rounded corners. */
+ overflow: hidden;
+}
+[dir=rtl] .theme-popup { left: unset; right: 10px; }
+.theme-popup .default {
+ color: var(--icons);
+}
+.theme-popup .theme {
+ width: 100%;
+ border: 0;
+ margin: 0;
+ padding: 2px 20px;
+ line-height: 25px;
+ white-space: nowrap;
+ text-align: start;
+ cursor: pointer;
+ color: inherit;
+ background: inherit;
+ font-size: inherit;
+}
+.theme-popup .theme:hover {
+ background-color: var(--theme-hover);
+}
+
+.theme-selected::before {
+ display: inline-block;
+ content: "✓";
+ margin-inline-start: -14px;
+ width: 14px;
+}
diff --git a/css/general.css b/css/general.css
new file mode 100644
index 000000000..e7d20da72
--- /dev/null
+++ b/css/general.css
@@ -0,0 +1,234 @@
+/* Base styles and content styles */
+
+@import 'variables.css';
+
+:root {
+ /* Browser default font-size is 16px, this way 1 rem = 10px */
+ font-size: 62.5%;
+ color-scheme: var(--color-scheme);
+}
+
+html {
+ font-family: "Open Sans", sans-serif;
+ color: var(--fg);
+ background-color: var(--bg);
+ text-size-adjust: none;
+ -webkit-text-size-adjust: none;
+}
+
+body {
+ margin: 0;
+ font-size: 1.6rem;
+ overflow-x: hidden;
+}
+
+code {
+ font-family: var(--mono-font) !important;
+ font-size: var(--code-font-size);
+ direction: ltr !important;
+}
+
+/* make long words/inline code not x overflow */
+main {
+ overflow-wrap: break-word;
+}
+
+/* make wide tables scroll if they overflow */
+.table-wrapper {
+ overflow-x: auto;
+}
+
+/* Don't change font size in headers. */
+h1 code, h2 code, h3 code, h4 code, h5 code, h6 code {
+ font-size: unset;
+}
+
+.left { float: left; }
+.right { float: right; }
+.boring { opacity: 0.6; }
+.hide-boring .boring { display: none; }
+.hidden { display: none !important; }
+
+h2, h3 { margin-block-start: 2.5em; }
+h4, h5 { margin-block-start: 2em; }
+
+.header + .header h3,
+.header + .header h4,
+.header + .header h5 {
+ margin-block-start: 1em;
+}
+
+h1:target::before,
+h2:target::before,
+h3:target::before,
+h4:target::before,
+h5:target::before,
+h6:target::before {
+ display: inline-block;
+ content: "»";
+ margin-inline-start: -30px;
+ width: 30px;
+}
+
+/* This is broken on Safari as of version 14, but is fixed
+ in Safari Technology Preview 117 which I think will be Safari 14.2.
+ https://bugs.webkit.org/show_bug.cgi?id=218076
+*/
+:target {
+ /* Safari does not support logical properties */
+ scroll-margin-top: calc(var(--menu-bar-height) + 0.5em);
+}
+
+.page {
+ outline: 0;
+ padding: 0 var(--page-padding);
+ margin-block-start: calc(0px - var(--menu-bar-height)); /* Compensate for the #menu-bar-hover-placeholder */
+}
+.page-wrapper {
+ box-sizing: border-box;
+ background-color: var(--bg);
+}
+.no-js .page-wrapper,
+.js:not(.sidebar-resizing) .page-wrapper {
+ transition: margin-left 0.3s ease, transform 0.3s ease; /* Animation: slide away */
+}
+[dir=rtl] .js:not(.sidebar-resizing) .page-wrapper {
+ transition: margin-right 0.3s ease, transform 0.3s ease; /* Animation: slide away */
+}
+
+.content {
+ overflow-y: auto;
+ padding: 0 5px 50px 5px;
+}
+.content main {
+ margin-inline-start: auto;
+ margin-inline-end: auto;
+ max-width: var(--content-max-width);
+}
+.content p { line-height: 1.45em; }
+.content ol { line-height: 1.45em; }
+.content ul { line-height: 1.45em; }
+.content a { text-decoration: none; }
+.content a:hover { text-decoration: underline; }
+.content img, .content video { max-width: 100%; }
+.content .header:link,
+.content .header:visited {
+ color: var(--fg);
+}
+.content .header:link,
+.content .header:visited:hover {
+ text-decoration: none;
+}
+
+table {
+ margin: 0 auto;
+ border-collapse: collapse;
+}
+table td {
+ padding: 3px 20px;
+ border: 1px var(--table-border-color) solid;
+}
+table thead {
+ background: var(--table-header-bg);
+}
+table thead td {
+ font-weight: 700;
+ border: none;
+}
+table thead th {
+ padding: 3px 20px;
+}
+table thead tr {
+ border: 1px var(--table-header-bg) solid;
+}
+/* Alternate background colors for rows */
+table tbody tr:nth-child(2n) {
+ background: var(--table-alternate-bg);
+}
+
+
+blockquote {
+ margin: 20px 0;
+ padding: 0 20px;
+ color: var(--fg);
+ background-color: var(--quote-bg);
+ border-block-start: .1em solid var(--quote-border);
+ border-block-end: .1em solid var(--quote-border);
+}
+
+.warning {
+ margin: 20px;
+ padding: 0 20px;
+ border-inline-start: 2px solid var(--warning-border);
+}
+
+.warning:before {
+ position: absolute;
+ width: 3rem;
+ height: 3rem;
+ margin-inline-start: calc(-1.5rem - 21px);
+ content: "ⓘ";
+ text-align: center;
+ background-color: var(--bg);
+ color: var(--warning-border);
+ font-weight: bold;
+ font-size: 2rem;
+}
+
+blockquote .warning:before {
+ background-color: var(--quote-bg);
+}
+
+kbd {
+ background-color: var(--table-border-color);
+ border-radius: 4px;
+ border: solid 1px var(--theme-popup-border);
+ box-shadow: inset 0 -1px 0 var(--theme-hover);
+ display: inline-block;
+ font-size: var(--code-font-size);
+ font-family: var(--mono-font);
+ line-height: 10px;
+ padding: 4px 5px;
+ vertical-align: middle;
+}
+
+:not(.footnote-definition) + .footnote-definition,
+.footnote-definition + :not(.footnote-definition) {
+ margin-block-start: 2em;
+}
+.footnote-definition {
+ font-size: 0.9em;
+ margin: 0.5em 0;
+}
+.footnote-definition p {
+ display: inline;
+}
+
+.tooltiptext {
+ position: absolute;
+ visibility: hidden;
+ color: #fff;
+ background-color: #333;
+ transform: translateX(-50%); /* Center by moving tooltip 50% of its width left */
+ left: -8px; /* Half of the width of the icon */
+ top: -35px;
+ font-size: 0.8em;
+ text-align: center;
+ border-radius: 6px;
+ padding: 5px 8px;
+ margin: 5px;
+ z-index: 1000;
+}
+.tooltipped .tooltiptext {
+ visibility: visible;
+}
+
+.chapter li.part-title {
+ color: var(--sidebar-fg);
+ margin: 5px 0px;
+ font-weight: bold;
+}
+
+.result-no-output {
+ font-style: italic;
+}
diff --git a/css/print.css b/css/print.css
new file mode 100644
index 000000000..dcf0ba64b
--- /dev/null
+++ b/css/print.css
@@ -0,0 +1,50 @@
+
+#sidebar,
+#menu-bar,
+.nav-chapters,
+.mobile-nav-chapters {
+ display: none;
+}
+
+#page-wrapper.page-wrapper {
+ transform: none;
+ margin-inline-start: 0px;
+ overflow-y: initial;
+}
+
+#content {
+ max-width: none;
+ margin: 0;
+ padding: 0;
+}
+
+.page {
+ overflow-y: initial;
+}
+
+code {
+ direction: ltr !important;
+}
+
+pre > .buttons {
+ z-index: 2;
+}
+
+a, a:visited, a:active, a:hover {
+ color: #4183c4;
+ text-decoration: none;
+}
+
+h1, h2, h3, h4, h5, h6 {
+ page-break-inside: avoid;
+ page-break-after: avoid;
+}
+
+pre, code {
+ page-break-inside: avoid;
+ white-space: pre-wrap;
+}
+
+.fa {
+ display: none !important;
+}
diff --git a/css/variables.css b/css/variables.css
new file mode 100644
index 000000000..10a759094
--- /dev/null
+++ b/css/variables.css
@@ -0,0 +1,277 @@
+
+/* Globals */
+
+:root {
+ --sidebar-width: 300px;
+ --page-padding: 15px;
+ --content-max-width: 750px;
+ --menu-bar-height: 50px;
+ --mono-font: "Source Code Pro", Consolas, "Ubuntu Mono", Menlo, "DejaVu Sans Mono", monospace, monospace;
+ --code-font-size: 0.875em /* please adjust the ace font size accordingly in editor.js */
+}
+
+/* Themes */
+
+.ayu {
+ --bg: hsl(210, 25%, 8%);
+ --fg: #c5c5c5;
+
+ --sidebar-bg: #14191f;
+ --sidebar-fg: #c8c9db;
+ --sidebar-non-existant: #5c6773;
+ --sidebar-active: #ffb454;
+ --sidebar-spacer: #2d334f;
+
+ --scrollbar: var(--sidebar-fg);
+
+ --icons: #737480;
+ --icons-hover: #b7b9cc;
+
+ --links: #0096cf;
+
+ --inline-code-color: #ffb454;
+
+ --theme-popup-bg: #14191f;
+ --theme-popup-border: #5c6773;
+ --theme-hover: #191f26;
+
+ --quote-bg: hsl(226, 15%, 17%);
+ --quote-border: hsl(226, 15%, 22%);
+
+ --warning-border: #ff8e00;
+
+ --table-border-color: hsl(210, 25%, 13%);
+ --table-header-bg: hsl(210, 25%, 28%);
+ --table-alternate-bg: hsl(210, 25%, 11%);
+
+ --searchbar-border-color: #848484;
+ --searchbar-bg: #424242;
+ --searchbar-fg: #fff;
+ --searchbar-shadow-color: #d4c89f;
+ --searchresults-header-fg: #666;
+ --searchresults-border-color: #888;
+ --searchresults-li-bg: #252932;
+ --search-mark-bg: #e3b171;
+
+ --color-scheme: dark;
+}
+
+.coal {
+ --bg: hsl(200, 7%, 8%);
+ --fg: #98a3ad;
+
+ --sidebar-bg: #292c2f;
+ --sidebar-fg: #a1adb8;
+ --sidebar-non-existant: #505254;
+ --sidebar-active: #3473ad;
+ --sidebar-spacer: #393939;
+
+ --scrollbar: var(--sidebar-fg);
+
+ --icons: #43484d;
+ --icons-hover: #b3c0cc;
+
+ --links: #2b79a2;
+
+ --inline-code-color: #c5c8c6;
+
+ --theme-popup-bg: #141617;
+ --theme-popup-border: #43484d;
+ --theme-hover: #1f2124;
+
+ --quote-bg: hsl(234, 21%, 18%);
+ --quote-border: hsl(234, 21%, 23%);
+
+ --warning-border: #ff8e00;
+
+ --table-border-color: hsl(200, 7%, 13%);
+ --table-header-bg: hsl(200, 7%, 28%);
+ --table-alternate-bg: hsl(200, 7%, 11%);
+
+ --searchbar-border-color: #aaa;
+ --searchbar-bg: #b7b7b7;
+ --searchbar-fg: #000;
+ --searchbar-shadow-color: #aaa;
+ --searchresults-header-fg: #666;
+ --searchresults-border-color: #98a3ad;
+ --searchresults-li-bg: #2b2b2f;
+ --search-mark-bg: #355c7d;
+
+ --color-scheme: dark;
+}
+
+.light {
+ --bg: hsl(0, 0%, 100%);
+ --fg: hsl(0, 0%, 0%);
+
+ --sidebar-bg: #fafafa;
+ --sidebar-fg: hsl(0, 0%, 0%);
+ --sidebar-non-existant: #aaaaaa;
+ --sidebar-active: #1f1fff;
+ --sidebar-spacer: #f4f4f4;
+
+ --scrollbar: #8F8F8F;
+
+ --icons: #747474;
+ --icons-hover: #000000;
+
+ --links: #20609f;
+
+ --inline-code-color: #301900;
+
+ --theme-popup-bg: #fafafa;
+ --theme-popup-border: #cccccc;
+ --theme-hover: #e6e6e6;
+
+ --quote-bg: hsl(197, 37%, 96%);
+ --quote-border: hsl(197, 37%, 91%);
+
+ --warning-border: #ff8e00;
+
+ --table-border-color: hsl(0, 0%, 95%);
+ --table-header-bg: hsl(0, 0%, 80%);
+ --table-alternate-bg: hsl(0, 0%, 97%);
+
+ --searchbar-border-color: #aaa;
+ --searchbar-bg: #fafafa;
+ --searchbar-fg: #000;
+ --searchbar-shadow-color: #aaa;
+ --searchresults-header-fg: #666;
+ --searchresults-border-color: #888;
+ --searchresults-li-bg: #e4f2fe;
+ --search-mark-bg: #a2cff5;
+
+ --color-scheme: light;
+}
+
+.navy {
+ --bg: hsl(226, 23%, 11%);
+ --fg: #bcbdd0;
+
+ --sidebar-bg: #282d3f;
+ --sidebar-fg: #c8c9db;
+ --sidebar-non-existant: #505274;
+ --sidebar-active: #2b79a2;
+ --sidebar-spacer: #2d334f;
+
+ --scrollbar: var(--sidebar-fg);
+
+ --icons: #737480;
+ --icons-hover: #b7b9cc;
+
+ --links: #2b79a2;
+
+ --inline-code-color: #c5c8c6;
+
+ --theme-popup-bg: #161923;
+ --theme-popup-border: #737480;
+ --theme-hover: #282e40;
+
+ --quote-bg: hsl(226, 15%, 17%);
+ --quote-border: hsl(226, 15%, 22%);
+
+ --warning-border: #ff8e00;
+
+ --table-border-color: hsl(226, 23%, 16%);
+ --table-header-bg: hsl(226, 23%, 31%);
+ --table-alternate-bg: hsl(226, 23%, 14%);
+
+ --searchbar-border-color: #aaa;
+ --searchbar-bg: #aeaec6;
+ --searchbar-fg: #000;
+ --searchbar-shadow-color: #aaa;
+ --searchresults-header-fg: #5f5f71;
+ --searchresults-border-color: #5c5c68;
+ --searchresults-li-bg: #242430;
+ --search-mark-bg: #a2cff5;
+
+ --color-scheme: dark;
+}
+
+.rust {
+ --bg: hsl(60, 9%, 87%);
+ --fg: #262625;
+
+ --sidebar-bg: #3b2e2a;
+ --sidebar-fg: #c8c9db;
+ --sidebar-non-existant: #505254;
+ --sidebar-active: #e69f67;
+ --sidebar-spacer: #45373a;
+
+ --scrollbar: var(--sidebar-fg);
+
+ --icons: #737480;
+ --icons-hover: #262625;
+
+ --links: #2b79a2;
+
+ --inline-code-color: #6e6b5e;
+
+ --theme-popup-bg: #e1e1db;
+ --theme-popup-border: #b38f6b;
+ --theme-hover: #99908a;
+
+ --quote-bg: hsl(60, 5%, 75%);
+ --quote-border: hsl(60, 5%, 70%);
+
+ --warning-border: #ff8e00;
+
+ --table-border-color: hsl(60, 9%, 82%);
+ --table-header-bg: #b3a497;
+ --table-alternate-bg: hsl(60, 9%, 84%);
+
+ --searchbar-border-color: #aaa;
+ --searchbar-bg: #fafafa;
+ --searchbar-fg: #000;
+ --searchbar-shadow-color: #aaa;
+ --searchresults-header-fg: #666;
+ --searchresults-border-color: #888;
+ --searchresults-li-bg: #dec2a2;
+ --search-mark-bg: #e69f67;
+
+ --color-scheme: light;
+}
+
+@media (prefers-color-scheme: dark) {
+ .light.no-js {
+ --bg: hsl(200, 7%, 8%);
+ --fg: #98a3ad;
+
+ --sidebar-bg: #292c2f;
+ --sidebar-fg: #a1adb8;
+ --sidebar-non-existant: #505254;
+ --sidebar-active: #3473ad;
+ --sidebar-spacer: #393939;
+
+ --scrollbar: var(--sidebar-fg);
+
+ --icons: #43484d;
+ --icons-hover: #b3c0cc;
+
+ --links: #2b79a2;
+
+ --inline-code-color: #c5c8c6;
+
+ --theme-popup-bg: #141617;
+ --theme-popup-border: #43484d;
+ --theme-hover: #1f2124;
+
+ --quote-bg: hsl(234, 21%, 18%);
+ --quote-border: hsl(234, 21%, 23%);
+
+ --warning-border: #ff8e00;
+
+ --table-border-color: hsl(200, 7%, 13%);
+ --table-header-bg: hsl(200, 7%, 28%);
+ --table-alternate-bg: hsl(200, 7%, 11%);
+
+ --searchbar-border-color: #aaa;
+ --searchbar-bg: #b7b7b7;
+ --searchbar-fg: #000;
+ --searchbar-shadow-color: #aaa;
+ --searchresults-header-fg: #666;
+ --searchresults-border-color: #98a3ad;
+ --searchresults-li-bg: #2b2b2f;
+ --search-mark-bg: #355c7d;
+ }
+}
diff --git a/editor.js b/editor.js
new file mode 100644
index 000000000..464790c49
--- /dev/null
+++ b/editor.js
@@ -0,0 +1,29 @@
+"use strict";
+window.editors = [];
+(function(editors) {
+ if (typeof(ace) === 'undefined' || !ace) {
+ return;
+ }
+
+ Array.from(document.querySelectorAll('.editable')).forEach(function(editable) {
+ let display_line_numbers = window.playground_line_numbers || false;
+
+ let editor = ace.edit(editable);
+ editor.setOptions({
+ highlightActiveLine: false,
+ showPrintMargin: false,
+ showLineNumbers: display_line_numbers,
+ showGutter: display_line_numbers,
+ maxLines: Infinity,
+ fontSize: "0.875em" // please adjust the font size of the code in general.css
+ });
+
+ editor.$blockScrolling = Infinity;
+
+ editor.getSession().setMode("ace/mode/rust");
+
+ editor.originalCode = editor.getValue();
+
+ editors.push(editor);
+ });
+})(window.editors);
diff --git a/elasticlunr.min.js b/elasticlunr.min.js
new file mode 100644
index 000000000..94b20dd2e
--- /dev/null
+++ b/elasticlunr.min.js
@@ -0,0 +1,10 @@
+/**
+ * elasticlunr - http://weixsong.github.io
+ * Lightweight full-text search engine in Javascript for browser search and offline search. - 0.9.5
+ *
+ * Copyright (C) 2017 Oliver Nightingale
+ * Copyright (C) 2017 Wei Song
+ * MIT Licensed
+ * @license
+ */
+!function(){function e(e){if(null===e||"object"!=typeof e)return e;var t=e.constructor();for(var n in e)e.hasOwnProperty(n)&&(t[n]=e[n]);return t}var t=function(e){var n=new t.Index;return n.pipeline.add(t.trimmer,t.stopWordFilter,t.stemmer),e&&e.call(n,n),n};t.version="0.9.5",lunr=t,t.utils={},t.utils.warn=function(e){return function(t){e.console&&console.warn&&console.warn(t)}}(this),t.utils.toString=function(e){return void 0===e||null===e?"":e.toString()},t.EventEmitter=function(){this.events={}},t.EventEmitter.prototype.addListener=function(){var e=Array.prototype.slice.call(arguments),t=e.pop(),n=e;if("function"!=typeof t)throw new TypeError("last argument must be a function");n.forEach(function(e){this.hasHandler(e)||(this.events[e]=[]),this.events[e].push(t)},this)},t.EventEmitter.prototype.removeListener=function(e,t){if(this.hasHandler(e)){var n=this.events[e].indexOf(t);-1!==n&&(this.events[e].splice(n,1),0==this.events[e].length&&delete this.events[e])}},t.EventEmitter.prototype.emit=function(e){if(this.hasHandler(e)){var t=Array.prototype.slice.call(arguments,1);this.events[e].forEach(function(e){e.apply(void 0,t)},this)}},t.EventEmitter.prototype.hasHandler=function(e){return e in this.events},t.tokenizer=function(e){if(!arguments.length||null===e||void 0===e)return[];if(Array.isArray(e)){var n=e.filter(function(e){return null===e||void 0===e?!1:!0});n=n.map(function(e){return t.utils.toString(e).toLowerCase()});var i=[];return n.forEach(function(e){var n=e.split(t.tokenizer.seperator);i=i.concat(n)},this),i}return e.toString().trim().toLowerCase().split(t.tokenizer.seperator)},t.tokenizer.defaultSeperator=/[\s\-]+/,t.tokenizer.seperator=t.tokenizer.defaultSeperator,t.tokenizer.setSeperator=function(e){null!==e&&void 0!==e&&"object"==typeof e&&(t.tokenizer.seperator=e)},t.tokenizer.resetSeperator=function(){t.tokenizer.seperator=t.tokenizer.defaultSeperator},t.tokenizer.getSeperator=function(){return t.tokenizer.seperator},t.Pipeline=function(){this._queue=[]},t.Pipeline.registeredFunctions={},t.Pipeline.registerFunction=function(e,n){n in t.Pipeline.registeredFunctions&&t.utils.warn("Overwriting existing registered function: "+n),e.label=n,t.Pipeline.registeredFunctions[n]=e},t.Pipeline.getRegisteredFunction=function(e){return e in t.Pipeline.registeredFunctions!=!0?null:t.Pipeline.registeredFunctions[e]},t.Pipeline.warnIfFunctionNotRegistered=function(e){var n=e.label&&e.label in this.registeredFunctions;n||t.utils.warn("Function is not registered with pipeline. This may cause problems when serialising the index.\n",e)},t.Pipeline.load=function(e){var n=new t.Pipeline;return e.forEach(function(e){var i=t.Pipeline.getRegisteredFunction(e);if(!i)throw new Error("Cannot load un-registered function: "+e);n.add(i)}),n},t.Pipeline.prototype.add=function(){var e=Array.prototype.slice.call(arguments);e.forEach(function(e){t.Pipeline.warnIfFunctionNotRegistered(e),this._queue.push(e)},this)},t.Pipeline.prototype.after=function(e,n){t.Pipeline.warnIfFunctionNotRegistered(n);var i=this._queue.indexOf(e);if(-1===i)throw new Error("Cannot find existingFn");this._queue.splice(i+1,0,n)},t.Pipeline.prototype.before=function(e,n){t.Pipeline.warnIfFunctionNotRegistered(n);var i=this._queue.indexOf(e);if(-1===i)throw new Error("Cannot find existingFn");this._queue.splice(i,0,n)},t.Pipeline.prototype.remove=function(e){var t=this._queue.indexOf(e);-1!==t&&this._queue.splice(t,1)},t.Pipeline.prototype.run=function(e){for(var t=[],n=e.length,i=this._queue.length,o=0;n>o;o++){for(var r=e[o],s=0;i>s&&(r=this._queue[s](r,o,e),void 0!==r&&null!==r);s++);void 0!==r&&null!==r&&t.push(r)}return t},t.Pipeline.prototype.reset=function(){this._queue=[]},t.Pipeline.prototype.get=function(){return this._queue},t.Pipeline.prototype.toJSON=function(){return this._queue.map(function(e){return t.Pipeline.warnIfFunctionNotRegistered(e),e.label})},t.Index=function(){this._fields=[],this._ref="id",this.pipeline=new t.Pipeline,this.documentStore=new t.DocumentStore,this.index={},this.eventEmitter=new t.EventEmitter,this._idfCache={},this.on("add","remove","update",function(){this._idfCache={}}.bind(this))},t.Index.prototype.on=function(){var e=Array.prototype.slice.call(arguments);return this.eventEmitter.addListener.apply(this.eventEmitter,e)},t.Index.prototype.off=function(e,t){return this.eventEmitter.removeListener(e,t)},t.Index.load=function(e){e.version!==t.version&&t.utils.warn("version mismatch: current "+t.version+" importing "+e.version);var n=new this;n._fields=e.fields,n._ref=e.ref,n.documentStore=t.DocumentStore.load(e.documentStore),n.pipeline=t.Pipeline.load(e.pipeline),n.index={};for(var i in e.index)n.index[i]=t.InvertedIndex.load(e.index[i]);return n},t.Index.prototype.addField=function(e){return this._fields.push(e),this.index[e]=new t.InvertedIndex,this},t.Index.prototype.setRef=function(e){return this._ref=e,this},t.Index.prototype.saveDocument=function(e){return this.documentStore=new t.DocumentStore(e),this},t.Index.prototype.addDoc=function(e,n){if(e){var n=void 0===n?!0:n,i=e[this._ref];this.documentStore.addDoc(i,e),this._fields.forEach(function(n){var o=this.pipeline.run(t.tokenizer(e[n]));this.documentStore.addFieldLength(i,n,o.length);var r={};o.forEach(function(e){e in r?r[e]+=1:r[e]=1},this);for(var s in r){var u=r[s];u=Math.sqrt(u),this.index[n].addToken(s,{ref:i,tf:u})}},this),n&&this.eventEmitter.emit("add",e,this)}},t.Index.prototype.removeDocByRef=function(e){if(e&&this.documentStore.isDocStored()!==!1&&this.documentStore.hasDoc(e)){var t=this.documentStore.getDoc(e);this.removeDoc(t,!1)}},t.Index.prototype.removeDoc=function(e,n){if(e){var n=void 0===n?!0:n,i=e[this._ref];this.documentStore.hasDoc(i)&&(this.documentStore.removeDoc(i),this._fields.forEach(function(n){var o=this.pipeline.run(t.tokenizer(e[n]));o.forEach(function(e){this.index[n].removeToken(e,i)},this)},this),n&&this.eventEmitter.emit("remove",e,this))}},t.Index.prototype.updateDoc=function(e,t){var t=void 0===t?!0:t;this.removeDocByRef(e[this._ref],!1),this.addDoc(e,!1),t&&this.eventEmitter.emit("update",e,this)},t.Index.prototype.idf=function(e,t){var n="@"+t+"/"+e;if(Object.prototype.hasOwnProperty.call(this._idfCache,n))return this._idfCache[n];var i=this.index[t].getDocFreq(e),o=1+Math.log(this.documentStore.length/(i+1));return this._idfCache[n]=o,o},t.Index.prototype.getFields=function(){return this._fields.slice()},t.Index.prototype.search=function(e,n){if(!e)return[];e="string"==typeof e?{any:e}:JSON.parse(JSON.stringify(e));var i=null;null!=n&&(i=JSON.stringify(n));for(var o=new t.Configuration(i,this.getFields()).get(),r={},s=Object.keys(e),u=0;u
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Re-exporting names with
+
+
+
+
+ Use and pub
+-
+
- 🌟 We can bring two types of the same name into the same scope with use, but you need
askeyword.
+
+use std::fmt::Result; +use std::io::Result; + +fn main() {}
-
+
- 🌟🌟 If we are using multiple items defined in the same crate or module, then listing each item on its own line will take up too much vertical space. +
++// FILL in the blank in two ways +// DON'T add new code line +use std::collections::__; + +fn main() { + let _c1:HashMap<&str, i32> = HashMap::new(); + let mut c2 = BTreeMap::new(); + c2.insert(1, "a"); + let _c3: HashSet<i32> = HashSet::new(); +}
Re-exporting names with pub use
+-
+
- 🌟🌟🌟 In our recently created package
hello-package, add something to make the below code work
+
+fn main() { + assert_eq!(hello_package::hosting::seat_at_table(), "sit down please"); + assert_eq!(hello_package::eat_at_restaurant(),"yummy yummy!"); +}
Pub(in Crate)
+Sometimes we want an item only be public to a certain crate. For this we can use the pub(in Crate) syntax.
Example
++pub mod a { + pub const I: i32 = 3; + + fn semisecret(x: i32) -> i32 { + use self::b::c::J; + x + J + } + + pub fn bar(z: i32) -> i32 { + semisecret(I) * z + } + pub fn foo(y: i32) -> i32 { + semisecret(I) + y + } + + mod b { + pub(in crate::a) mod c { + pub(in crate::a) const J: i32 = 4; + } + } +}
Full Code
+The full code of hello-package is here.
++ + +You can find the solutions here (under the solutions path), but only use it when you need it :)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/errors.html b/errors.html
new file mode 100644
index 000000000..b733da8a6
--- /dev/null
+++ b/errors.html
@@ -0,0 +1,216 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Small projects with Elegant code base
+Following questions come up weekly in online Rust discussions:
+-
+
- I just finished reading The Book, what should I do next ? +
- What projects would you recommend to a Rust beginner? +
- Looking for small projects with an elegant code base +
- Codes that is easy to read and learn +
The answers to these questions are always Practice: doing some exercises, and then reading some small and excellent Rust projects.
+This is precisely the goal of this book, so, collecting relative resourses and representing in Rust By Practice seems not a bad idea.
+1. Ripgrep
+Answers for above questions usually came with ripgrep, though I don't think it is a small project, but yes, go for it if you are not afraid to delve deep a bit.
2. Building a text editor
+Tutorial https://www.flenker.blog/hecto/ will lead you to build a text editor from scratch.
3. Ncspot
+Ncspot, a terminal Spotify client. Small, simple, well organized and async, it's good for learning.
+4. Command Line Rust
+This project is for the book Command-Line Rust(O'Reily), it will show you how to write small CLIs (clones of head, cat, ls).
5. pngme book
+This book will guide you to make a command line program that lets you hide secret messages in PNG files. The primary goal here is to get you writing code. The secondary goal is to get you reading documentation.
+6. Writing an OS in Rust
+This blog series creates a small operating system in the Rust programming language. Each post is a small tutorial and includes all needed code, so you can follow along if you like. The source code is also available in the corresponding Github repository.
+7. CodeCrafters.io: Build your own Git, Docker, SQLite, or Redis
+On CodeCrafters, you can recreate your favorite developer tools from scratch. It's a hands-on, minimally-guided approach to master Rust, while appreciating the internals and documentation of popular technology that we use every day.
+8. mini-redis
+mini-redis is an incomplete Redis client and server implementation using tokio, it has decent code base and detail explanations, very suitable for learning Rust and asynchronous programming.
+9. Writing Interpreters in Rust
+This online book will walk through the basics of interpreted language implementation in Rust with a focus on the challenges that are specific to using Rust.
++
To be continued...
+ + +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/favicon.png b/favicon.png
new file mode 100644
index 000000000..a5b1aa16c
Binary files /dev/null and b/favicon.png differ
diff --git a/favicon.svg b/favicon.svg
new file mode 100644
index 000000000..90e0ea58b
--- /dev/null
+++ b/favicon.svg
@@ -0,0 +1,22 @@
+
+
diff --git a/fight-compiler/borrowing.html b/fight-compiler/borrowing.html
new file mode 100644
index 000000000..292319d87
--- /dev/null
+++ b/fight-compiler/borrowing.html
@@ -0,0 +1,240 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Errors
+ + +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/fight-compiler/intro.html b/fight-compiler/intro.html
new file mode 100644
index 000000000..cfebfa61f
--- /dev/null
+++ b/fight-compiler/intro.html
@@ -0,0 +1,218 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Borrowing
+-
+
- 🌟🌟 +
+// FIX the error without removing any code line +struct test { + list: Vec<i32>, + a: i32 +} + +impl test { + pub fn new() -> Self { + test { list:vec![1,2,3,4,5,6,7], a:0 } + } + + pub fn run(&mut self) { + for i in self.list.iter() { + self.do_something(*i) + } + + } + + pub fn do_something(&mut self, n: i32) { + self.a = n; + } +} + +fn main() {}
++ + +You can find the solutions here(under the solutions path), but only use it when you need it :)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/flow-control.html b/flow-control.html
new file mode 100644
index 000000000..298d4c6a7
--- /dev/null
+++ b/flow-control.html
@@ -0,0 +1,458 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Fighting with Compiler
+Fighting with compiler is very common in our daily coding, especially for those unfamiliar with Rust.
+This chapter will provide some exercises to help us avoid such cases to lower the steep learning curve.
+ + +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/fonts/OPEN-SANS-LICENSE.txt b/fonts/OPEN-SANS-LICENSE.txt
new file mode 100644
index 000000000..d64569567
--- /dev/null
+++ b/fonts/OPEN-SANS-LICENSE.txt
@@ -0,0 +1,202 @@
+
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
+ APPENDIX: How to apply the Apache License to your work.
+
+ To apply the Apache License to your work, attach the following
+ boilerplate notice, with the fields enclosed by brackets "[]"
+ replaced with your own identifying information. (Don't include
+ the brackets!) The text should be enclosed in the appropriate
+ comment syntax for the file format. We also recommend that a
+ file or class name and description of purpose be included on the
+ same "printed page" as the copyright notice for easier
+ identification within third-party archives.
+
+ Copyright [yyyy] [name of copyright owner]
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
diff --git a/fonts/SOURCE-CODE-PRO-LICENSE.txt b/fonts/SOURCE-CODE-PRO-LICENSE.txt
new file mode 100644
index 000000000..366206f54
--- /dev/null
+++ b/fonts/SOURCE-CODE-PRO-LICENSE.txt
@@ -0,0 +1,93 @@
+Copyright 2010, 2012 Adobe Systems Incorporated (http://www.adobe.com/), with Reserved Font Name 'Source'. All Rights Reserved. Source is a trademark of Adobe Systems Incorporated in the United States and/or other countries.
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+http://scripts.sil.org/OFL
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded,
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.
diff --git a/fonts/fonts.css b/fonts/fonts.css
new file mode 100644
index 000000000..858efa598
--- /dev/null
+++ b/fonts/fonts.css
@@ -0,0 +1,100 @@
+/* Open Sans is licensed under the Apache License, Version 2.0. See http://www.apache.org/licenses/LICENSE-2.0 */
+/* Source Code Pro is under the Open Font License. See https://scripts.sil.org/cms/scripts/page.php?site_id=nrsi&id=OFL */
+
+/* open-sans-300 - latin_vietnamese_latin-ext_greek-ext_greek_cyrillic-ext_cyrillic */
+@font-face {
+ font-family: 'Open Sans';
+ font-style: normal;
+ font-weight: 300;
+ src: local('Open Sans Light'), local('OpenSans-Light'),
+ url('open-sans-v17-all-charsets-300.woff2') format('woff2');
+}
+
+/* open-sans-300italic - latin_vietnamese_latin-ext_greek-ext_greek_cyrillic-ext_cyrillic */
+@font-face {
+ font-family: 'Open Sans';
+ font-style: italic;
+ font-weight: 300;
+ src: local('Open Sans Light Italic'), local('OpenSans-LightItalic'),
+ url('open-sans-v17-all-charsets-300italic.woff2') format('woff2');
+}
+
+/* open-sans-regular - latin_vietnamese_latin-ext_greek-ext_greek_cyrillic-ext_cyrillic */
+@font-face {
+ font-family: 'Open Sans';
+ font-style: normal;
+ font-weight: 400;
+ src: local('Open Sans Regular'), local('OpenSans-Regular'),
+ url('open-sans-v17-all-charsets-regular.woff2') format('woff2');
+}
+
+/* open-sans-italic - latin_vietnamese_latin-ext_greek-ext_greek_cyrillic-ext_cyrillic */
+@font-face {
+ font-family: 'Open Sans';
+ font-style: italic;
+ font-weight: 400;
+ src: local('Open Sans Italic'), local('OpenSans-Italic'),
+ url('open-sans-v17-all-charsets-italic.woff2') format('woff2');
+}
+
+/* open-sans-600 - latin_vietnamese_latin-ext_greek-ext_greek_cyrillic-ext_cyrillic */
+@font-face {
+ font-family: 'Open Sans';
+ font-style: normal;
+ font-weight: 600;
+ src: local('Open Sans SemiBold'), local('OpenSans-SemiBold'),
+ url('open-sans-v17-all-charsets-600.woff2') format('woff2');
+}
+
+/* open-sans-600italic - latin_vietnamese_latin-ext_greek-ext_greek_cyrillic-ext_cyrillic */
+@font-face {
+ font-family: 'Open Sans';
+ font-style: italic;
+ font-weight: 600;
+ src: local('Open Sans SemiBold Italic'), local('OpenSans-SemiBoldItalic'),
+ url('open-sans-v17-all-charsets-600italic.woff2') format('woff2');
+}
+
+/* open-sans-700 - latin_vietnamese_latin-ext_greek-ext_greek_cyrillic-ext_cyrillic */
+@font-face {
+ font-family: 'Open Sans';
+ font-style: normal;
+ font-weight: 700;
+ src: local('Open Sans Bold'), local('OpenSans-Bold'),
+ url('open-sans-v17-all-charsets-700.woff2') format('woff2');
+}
+
+/* open-sans-700italic - latin_vietnamese_latin-ext_greek-ext_greek_cyrillic-ext_cyrillic */
+@font-face {
+ font-family: 'Open Sans';
+ font-style: italic;
+ font-weight: 700;
+ src: local('Open Sans Bold Italic'), local('OpenSans-BoldItalic'),
+ url('open-sans-v17-all-charsets-700italic.woff2') format('woff2');
+}
+
+/* open-sans-800 - latin_vietnamese_latin-ext_greek-ext_greek_cyrillic-ext_cyrillic */
+@font-face {
+ font-family: 'Open Sans';
+ font-style: normal;
+ font-weight: 800;
+ src: local('Open Sans ExtraBold'), local('OpenSans-ExtraBold'),
+ url('open-sans-v17-all-charsets-800.woff2') format('woff2');
+}
+
+/* open-sans-800italic - latin_vietnamese_latin-ext_greek-ext_greek_cyrillic-ext_cyrillic */
+@font-face {
+ font-family: 'Open Sans';
+ font-style: italic;
+ font-weight: 800;
+ src: local('Open Sans ExtraBold Italic'), local('OpenSans-ExtraBoldItalic'),
+ url('open-sans-v17-all-charsets-800italic.woff2') format('woff2');
+}
+
+/* source-code-pro-500 - latin_vietnamese_latin-ext_greek_cyrillic-ext_cyrillic */
+@font-face {
+ font-family: 'Source Code Pro';
+ font-style: normal;
+ font-weight: 500;
+ src: url('source-code-pro-v11-all-charsets-500.woff2') format('woff2');
+}
diff --git a/fonts/open-sans-v17-all-charsets-300.woff2 b/fonts/open-sans-v17-all-charsets-300.woff2
new file mode 100644
index 000000000..9f51be370
Binary files /dev/null and b/fonts/open-sans-v17-all-charsets-300.woff2 differ
diff --git a/fonts/open-sans-v17-all-charsets-300italic.woff2 b/fonts/open-sans-v17-all-charsets-300italic.woff2
new file mode 100644
index 000000000..2f5454484
Binary files /dev/null and b/fonts/open-sans-v17-all-charsets-300italic.woff2 differ
diff --git a/fonts/open-sans-v17-all-charsets-600.woff2 b/fonts/open-sans-v17-all-charsets-600.woff2
new file mode 100644
index 000000000..f503d558d
Binary files /dev/null and b/fonts/open-sans-v17-all-charsets-600.woff2 differ
diff --git a/fonts/open-sans-v17-all-charsets-600italic.woff2 b/fonts/open-sans-v17-all-charsets-600italic.woff2
new file mode 100644
index 000000000..c99aabe80
Binary files /dev/null and b/fonts/open-sans-v17-all-charsets-600italic.woff2 differ
diff --git a/fonts/open-sans-v17-all-charsets-700.woff2 b/fonts/open-sans-v17-all-charsets-700.woff2
new file mode 100644
index 000000000..421a1ab25
Binary files /dev/null and b/fonts/open-sans-v17-all-charsets-700.woff2 differ
diff --git a/fonts/open-sans-v17-all-charsets-700italic.woff2 b/fonts/open-sans-v17-all-charsets-700italic.woff2
new file mode 100644
index 000000000..12ce3d20d
Binary files /dev/null and b/fonts/open-sans-v17-all-charsets-700italic.woff2 differ
diff --git a/fonts/open-sans-v17-all-charsets-800.woff2 b/fonts/open-sans-v17-all-charsets-800.woff2
new file mode 100644
index 000000000..c94a223b0
Binary files /dev/null and b/fonts/open-sans-v17-all-charsets-800.woff2 differ
diff --git a/fonts/open-sans-v17-all-charsets-800italic.woff2 b/fonts/open-sans-v17-all-charsets-800italic.woff2
new file mode 100644
index 000000000..eed7d3c63
Binary files /dev/null and b/fonts/open-sans-v17-all-charsets-800italic.woff2 differ
diff --git a/fonts/open-sans-v17-all-charsets-italic.woff2 b/fonts/open-sans-v17-all-charsets-italic.woff2
new file mode 100644
index 000000000..398b68a08
Binary files /dev/null and b/fonts/open-sans-v17-all-charsets-italic.woff2 differ
diff --git a/fonts/open-sans-v17-all-charsets-regular.woff2 b/fonts/open-sans-v17-all-charsets-regular.woff2
new file mode 100644
index 000000000..8383e94c6
Binary files /dev/null and b/fonts/open-sans-v17-all-charsets-regular.woff2 differ
diff --git a/fonts/source-code-pro-v11-all-charsets-500.woff2 b/fonts/source-code-pro-v11-all-charsets-500.woff2
new file mode 100644
index 000000000..722245682
Binary files /dev/null and b/fonts/source-code-pro-v11-all-charsets-500.woff2 differ
diff --git a/formatted-output/debug-display.html b/formatted-output/debug-display.html
new file mode 100644
index 000000000..7a7815579
--- /dev/null
+++ b/formatted-output/debug-display.html
@@ -0,0 +1,355 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Flow control
+If/else
+-
+
- 🌟 +
++// Fill in the blanks +fn main() { + let n = 5; + + if n < 0 { + println!("{} is negative", n); + } __ n > 0 { + println!("{} is positive", n); + } __ { + println!("{} is zero", n); + } +}
-
+
- 🌟🌟
If/elseexpression can be used in assignments.
+
++// Fix the errors +fn main() { + let n = 5; + + let big_n = + if n < 10 && n > -10 { + println!(", and is a small number, increase ten-fold"); + + 10 * n + } else { + println!(", and is a big number, halve the number"); + + n / 2.0 ; + } + + println!("{} -> {}", n, big_n); +}
For
+-
+
- 🌟 The
for inconstruct can be used to iterate through an Iterator, e.g a rangea..b.
+
++fn main() { + for n in 1..=100 { // modify this line to make the code work + if n == 100 { + panic!("NEVER LET THIS RUN") + } + } + + println!("Success!"); +}
-
+
- 🌟🌟 +
++// Fix the errors without adding or removing lines +fn main() { + let names = [String::from("liming"),String::from("hanmeimei")]; + for name in names { + // Do something with name... + } + + println!("{:?}", names); + + let numbers = [1, 2, 3]; + // The elements in numbers are Copy，so there is no move here + for n in numbers { + // Do something with n... + } + + println!("{:?}", numbers); +}
-
+
- 🌟 +
+fn main() { + let a = [4, 3, 2, 1]; + + // Iterate the indexing and value in 'a' + for (i,v) in a.__ { + println!("The {}th element is {}",i+1,v); + } +}
While
+-
+
- 🌟🌟 The
whilekeyword can be used to run a loop when a condition is true.
+
++// Fill in the blanks to make the last println! work ! +fn main() { + // A counter variable + let mut n = 1; + + // Loop while the condition is true + while n __ 10 { + if n % 15 == 0 { + println!("fizzbuzz"); + } else if n % 3 == 0 { + println!("fizz"); + } else if n % 5 == 0 { + println!("buzz"); + } else { + println!("{}", n); + } + + + __; + } + + println!("n reached {}, so loop is over",n); +}
Continue and break
+-
+
- 🌟 Use
breakto break the loop.
+
++// Fill in the blank +fn main() { + let mut n = 0; + for i in 0..=100 { + if n == 66 { + __ + } + n += 1; + } + + assert_eq!(n, 66); + + println!("Success!"); +}
-
+
- 🌟🌟
continuewill skip over the remaining code in current iteration and go to the next iteration.
+
++// Fill in the blanks +fn main() { + let mut n = 0; + for i in 0..=100 { + if n != 66 { + n+=1; + __; + } + + __ + } + + assert_eq!(n, 66); + + println!("Success!"); +}
Loop
+-
+
- 🌟🌟 Loop is usually used together with
breakorcontinue.
+
++// Fill in the blanks +fn main() { + let mut count = 0u32; + + println!("Let's count until infinity!"); + + // Infinite loop + loop { + count += 1; + + if count == 3 { + println!("three"); + + // Skip the rest of this iteration + __; + } + + println!("{}", count); + + if count == 5 { + println!("OK, that's enough"); + + __; + } + } + + assert_eq!(count, 5); + + println!("Success!"); +}
-
+
- 🌟🌟 Loop is an expression, so we can use it with
breakto return a value
+
++// Fill in the blank +fn main() { + let mut counter = 0; + + let result = loop { + counter += 1; + + if counter == 10 { + __; + } + }; + + assert_eq!(result, 20); + + println!("Success!"); +}
-
+
- 🌟🌟🌟 It's possible to break or continue outer loops when dealing with nested loops. In these cases, the loops must be annotated with some 'label, and the label must be passed to the break/continue statement. +
++// Fill in the blank +fn main() { + let mut count = 0; + 'outer: loop { + 'inner1: loop { + if count >= 20 { + // This would break only the inner1 loop + break 'inner1; // `break` is also works. + } + count += 2; + } + + count += 5; + + 'inner2: loop { + if count >= 30 { + // This breaks the outer loop + break 'outer; + } + + // This will continue the outer loop + continue 'outer; + } + } + + assert!(count == __); + + println!("Success!"); +}
++ + +You can find the solutions here(under the solutions path), but only use it when you need it
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/formatted-output/formatting.html b/formatted-output/formatting.html
new file mode 100644
index 000000000..95f01aaed
--- /dev/null
+++ b/formatted-output/formatting.html
@@ -0,0 +1,365 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Debug and Display
+All types which want to be printable must implement the std::fmt formatting trait: std::fmt::Debug or std::fmt::Display.
Automatic implementations are only provided for types such as in the std library. All others have to be manually implemented.
Debug
+The implementation of Debug is very straightforward: All types can derive the std::fmt::Debug implementation. This is not true for std::fmt::Display which must be manually implemented.
{:?} must be used to print out the type which has implemented the Debug trait.
+#![allow(unused)] +fn main() { +// This structure cannot be printed either with `fmt::Display` or +// with `fmt::Debug`. +struct UnPrintable(i32); + +// To make this struct printable with `fmt::Debug`, we can derive the automatic implementations provided by Rust +#[derive(Debug)] +struct DebugPrintable(i32); +}
-
+
- 🌟 +
++/* Fill in the blanks and Fix the errors */ +struct Structure(i32); + +fn main() { + // Types in std and Rust have implemented the fmt::Debug trait + println!("__ months in a year.", 12); + + println!("Now __ will print!", Structure(3)); +}
-
+
- 🌟🌟 So
fmt::Debugdefinitely makes one type printable, but sacrifices some elegance. Maybe we can get more elegant by replacing{:?}with something else( but not{}!)
+
+#[derive(Debug)] +struct Person { + name: String, + age: u8 +} + +fn main() { + let person = Person { name: "Sunface".to_string(), age: 18 }; + + /* Make it output: + Person { + name: "Sunface", + age: 18, + } + */ + println!("{:?}", person); +}
-
+
- 🌟🌟 We can also manually implement
Debugtrait for our types
+
++#[derive(Debug)] +struct Structure(i32); + +#[derive(Debug)] +struct Deep(Structure); + + +fn main() { + // The problem with `derive` is there is no control over how + // the results look. What if I want this to just show a `7`? + + /* Make it print: Now 7 will print! */ + println!("Now {:?} will print!", Deep(Structure(7))); +}
Display
+Yeah, Debug is simple and easy to use. But sometimes we want to customize the output appearance of our type. This is where Display really shines.
Unlike Debug, there is no way to derive the implementation of the Display trait, we have to manually implement it.
Another thing to note: the placeholder for Display is {} not {:?}.
-
+
- 🌟🌟 +
++/* Make it work*/ +use std::fmt; + +struct Point2D { + x: f64, + y: f64, +} + +impl fmt::Display for Point2D { + /* Implement.. */ +} + +impl fmt::Debug for Point2D { + /* Implement.. */ +} + +fn main() { + let point = Point2D { x: 3.3, y: 7.2 }; + assert_eq!(format!("{}",point), "Display: 3.3 + 7.2i"); + assert_eq!(format!("{:?}",point), "Debug: Complex { real: 3.3, imag: 7.2 }"); + + println!("Success!"); +}
? operator
+Implementing fmt::Display for a structure whose elements must be handled separately is tricky. The problem is each write! generates a fmt::Result which must be handled in the same place.
Fortunately, Rust provides the ? operator to help us eliminate some unnecessary codes for dealing with fmt::Result.
-
+
- 🌟🌟 +
++/* Make it work */ +use std::fmt; + +struct List(Vec<i32>); + +impl fmt::Display for List { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + // Extract the value using tuple indexing, + // and create a reference to `vec`. + let vec = &self.0; + + write!(f, "[")?; + + // Iterate over `v` in `vec` while enumerating the iteration + // count in `count`. + for (count, v) in vec.iter().enumerate() { + // For every element except the first, add a comma. + // Use the ? operator to return on errors. + if count != 0 { write!(f, ", ")?; } + write!(f, "{}", v)?; + } + + // Close the opened bracket and return a fmt::Result value. + write!(f, "]") + } +} + +fn main() { + let v = List(vec![1, 2, 3]); + assert_eq!(format!("{}",v), "[0: 1, 1: 2, 2: 3]"); + println!("Success!"); +}
++ + +You can find the solutions here(under the solutions path), but only use it when you need it :)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/formatted-output/intro.html b/formatted-output/intro.html
new file mode 100644
index 000000000..c9e8c919d
--- /dev/null
+++ b/formatted-output/intro.html
@@ -0,0 +1,276 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Formatting
+Positional arguments
+1.🌟🌟
++/* Fill in the blanks */ +fn main() { + println!("{0}, this is {1}. {1}, this is {0}", "Alice", "Bob"); // => Alice, this is Bob. Bob, this is Alice + assert_eq!(format!("{1}{0}", 1, 2), __); + assert_eq!(format!(__, 1, 2), "2112"); + println!("Success!"); +}
Named arguments
+2.🌟🌟
++fn main() { + println!("{argument}", argument = "test"); // => "test" + + /* Fill in the blanks */ + assert_eq!(format!("{name}{}", 1, __), "21"); + assert_eq!(format!(__,a = "a", b = 'b', c = 3 ), "a 3 b"); + + /* Fix the error */ + // Named argument must be placed after other arguments + println!("{abc} {1}", abc = "def", 2); + + println!("Success!"); +}
Padding with string
+3.🌟🌟 By default, you can pad string with spaces
++fn main() { + // The following two are padding with 5 spaces + println!("Hello {:5}!", "x"); // => "Hello x !" + println!("Hello {:1$}!", "x", 5); // => "Hello x !" + + /* Fill in the blanks */ + assert_eq!(format!("Hello __!", 5, "x"), "Hello x !"); + assert_eq!(format!("Hello __!", "x", width = 5), "Hello x !"); + + println!("Success!"); +}
4.🌟🌟🌟 Left align, right align, pad with specified characters.
++fn main() { + // Left align + println!("Hello {:<5}!", "x"); // => Hello x ! + // Right align + assert_eq!(format!("Hello __!", "x"), "Hello x!"); + // Center align + assert_eq!(format!("Hello __!", "x"), "Hello x !"); + + // Left align, pad with '&' + assert_eq!(format!("Hello {:&<5}!", "x"), __); + + println!("Success!"); +}
5.🌟🌟 You can pad numbers with extra zeros.
++fn main() { + println!("Hello {:5}!", 5); // => Hello 5! + println!("Hello {:+}!", 5); // => Hello +5! + println!("Hello {:05}!", 5); // => Hello 00005! + println!("Hello {:05}!", -5); // => Hello -0005! + + /* Fill in the blank */ + assert!(format!("{number:0>width$}", number=1, width=6) == __); + + println!("Success!") +;}
Precision
+6.🌟🌟 Floating point precision
+++/* Fill in the blanks */ +fn main() { + let v = 3.1415926; + + println!("{:.1$}", v, 4); // same as {:.4} => 3.1416 + + assert_eq!(format!("__", v), "3.14"); + assert_eq!(format!("__", v), "+3.14"); + assert_eq!(format!("__", v), "3"); + + println!("Success!"); +}
7.🌟🌟🌟 String length
++fn main() { + let s = "Hello, world!"; + + println!("{0:.5}", s); // => Hello + + assert_eq!(format!("Hello __!", 3, "abcdefg"), "Hello abc!"); + + println!("Success!"); +}
Binary, octal, hex
+-
+
- format!("{}", foo) -> "3735928559" +
- format!("0x{:X}", foo) -> "0xDEADBEEF" +
- format!("0o{:o}", foo) -> "0o33653337357" +
8.🌟🌟
++fn main() { + assert_eq!(format!("__", 27), "0b11011"); + assert_eq!(format!("__", 27), "0o33"); + assert_eq!(format!("__", 27), "0x1b"); + assert_eq!(format!("__", 27), "0x1B"); + + println!("{:x}!", 27); // Hex with no prefix => 1b + + println!("{:#010b}", 27); // Pad binary with 0, width = 10, => 0b00011011 + + println!("Success!"); +}
Capture the environment
+9.🌟🌟🌟
++fn get_person() -> String { + String::from("sunface") +} + +fn get_format() -> (usize, usize) { + (4, 1) +} + + +fn main() { + let person = get_person(); + println!("Hello, {person}!"); + + let (width, precision) = get_format(); + let scores = [("sunface", 99.12), ("jack", 60.34)]; + /* Make it print: + sunface: 99.1 + jack: 60.3 + */ + for (name, score) in scores { + println!("{name}: __"); + } +}
Others
+Example
++fn main() { + // Exponent + println!("{:2e}", 1000000000); // => 1e9 + println!("{:2E}", 1000000000); // => 1E9 + + // Pointer address + let v= vec![1, 2, 3]; + println!("{:p}", v.as_ptr()); // => 0x600002324050 + + // Escape + println!("Hello {{}}"); // => Hello {} +}
++ + +You can find the solutions here(under the solutions path), but only use it when you need it :)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/formatted-output/println.html b/formatted-output/println.html
new file mode 100644
index 000000000..a6e21f40e
--- /dev/null
+++ b/formatted-output/println.html
@@ -0,0 +1,250 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Formatted output
++fn main() { + // In general, the `{}` will be automatically replaced with any + // arguments. These will be stringified. + println!("{} days", 31); + + // Without a suffix, 31 becomes an i32. You can change what type 31 is + // by providing a suffix. The number 31i64 for example has the type i64. + + // There are various optional patterns this works with. Positional + // arguments can be used. + println!("{0}, this is {1}. {1}, this is {0}", "Alice", "Bob"); + + // As can named arguments. + println!("{subject} {verb} {object}", + object="the lazy dog", + subject="the quick brown fox", + verb="jumps over"); + + // Special formatting can be specified after a `:`. + println!("{} of {:b} people know binary, the other half doesn't", 1, 2); + + // You can right-align text with a specified width. This will output + // " 1". 5 white spaces and a "1". + println!("{number:>width$}", number=1, width=6); + + // You can pad numbers with extra zeroes. This will output "000001". + println!("{number:0>width$}", number=1, width=6); + + // Rust even checks to make sure the correct number of arguments are + // used. + println!("My name is {0}, {1} {0}", "Bond"); + // FIXME ^ Add the missing argument: "James" + + // Create a structure named `Structure` which contains an `i32`. + #[allow(dead_code)] + struct Structure(i32); + + // However, custom types such as this structure require more complicated + // handling. This will not work. + println!("This struct `{}` won't print...", Structure(3)); + // FIXME ^ Comment out this line. + + // For Rust 1.58 and above, you can directly capture the argument from + // surrounding variable. Just like the above, this will output + // " 1". 5 white spaces and a "1". + let number: f64 = 1.0; + let width: usize = 6; + println!("{number:>width$}"); +}
[std::fmt][fmt] contains many [traits][traits] which govern the display
+of text. The base form of two important ones are listed below:
-
+
fmt::Debug: Uses the{:?}marker. Format text for debugging purposes.
+fmt::Display: Uses the{}marker. Format text in a more elegant, user +friendly fashion.
+
Here, we used fmt::Display because the std library provides implementations
+for these types. To print text for custom types, more steps are required.
Implementing the fmt::Display trait automatically implements the
+[ToString] trait which allows us to [convert] the type to [String][string].
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/functional-programing/closure.html b/functional-programing/closure.html
new file mode 100644
index 000000000..6c67ba2a9
--- /dev/null
+++ b/functional-programing/closure.html
@@ -0,0 +1,596 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ println! and format!
+Printing is handled by a series of [macros][macros] defined in [std::fmt][fmt]
+Some of which include:
-
+
format!: write formatted text to [String][string]
+print!: same asformat!but the text is printed to the console (io::stdout).
+println!: same asprint!but a newline is appended.
+eprint!: same asformat!but the text is printed to the standard error (io::stderr).
+eprintln!: same aseprint!but a newline is appended.
+
All parse text in the same fashion. As a plus, Rust checks format correctness at compile time.
+format!
+1.🌟
+++fn main() { + let s1 = "hello"; + /* Fill in the blank */ + let s = format!(__); + assert_eq!(s, "hello, world!"); +}
print!, println!
+2.🌟
+++fn main() { + /* Fill in the blanks to make it print: + Hello world, I am + Sunface! + */ + __("hello world, "); + __("I am"); + __("Sunface!"); +}
++ + +You can find the solutions here(under the solutions path), but only use it when you need it :)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/functional-programing/intro.html b/functional-programing/intro.html
new file mode 100644
index 000000000..f9bf69cb4
--- /dev/null
+++ b/functional-programing/intro.html
@@ -0,0 +1,221 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Closure
+Closures can capture the enclosing environments. For example we can capture the x variable :
+fn main() { + let x = 1; + let closure = |val| val + x; + assert_eq!(closure(2), 3); +}
From the syntax, we can see that closures are very convenient for on the fly usage. Unlike functions, both the input and return types of a closure can be inferred by the compiler.
++fn main() { + // Increment via closures and functions. + fn function(i: i32) -> i32 { i + 1 } + + // Closures are anonymous, here we are binding them to references + // + // These nameless functions are assigned to appropriately named variables. + let closure_annotated = |i: i32| -> i32 { i + 1 }; + let closure_inferred = |i | i + 1 ; + + let i = 1; + // Call the function and closures. + println!("function: {}", function(i)); + println!("closure_annotated: {}", closure_annotated(i)); + println!("closure_inferred: {}", closure_inferred(i)); + + // A closure taking no arguments which returns an `i32`. + // The return type is inferred. + let one = || 1; + println!("closure returning one: {}", one()); + +}
Capturing
+Closures can capture variables by borrowing or moving. But they prefer to capture by borrowing and only go lower when required:
+-
+
- By reference:
&T
+ - By mutable reference:
&mut T
+ - By value:
T
+
-
+
- 🌟 +
+/* Make it work with least amount of changes*/ +fn main() { + let color = String::from("green"); + + let print = move || println!("`color`: {}", color); + + print(); + print(); + + // `color` can be borrowed immutably again, because the closure only holds + // an immutable reference to `color`. + let _reborrow = &color; + + println!("{}",color); +}
-
+
- 🌟🌟 +
+/* Make it work +- Dont use `_reborrow` and `_count_reborrowed` +- Dont modify `assert_eq` +*/ +fn main() { + let mut count = 0; + + let mut inc = || { + count += 1; + println!("`count`: {}", count); + }; + + inc(); + + + let _reborrow = &count; + + inc(); + + // The closure no longer needs to borrow `&mut count`. Therefore, it is + // possible to reborrow without an error + let _count_reborrowed = &mut count; + + assert_eq!(count, 0); +}
-
+
- 🌟🌟 +
+/* Make it work in two ways, none of them is to remove `take(movable)` away from the code +*/ +fn main() { + let movable = Box::new(3); + + let consume = || { + println!("`movable`: {:?}", movable); + take(movable); + }; + + consume(); + consume(); +} + +fn take<T>(_v: T) {}
For comparison, the following code has no error:
++fn main() { + let movable = Box::new(3); + + let consume = move || { + println!("`movable`: {:?}", movable); + }; + + consume(); + consume(); +}
Type inferred
+The following four closures has no difference in input and return types.
++#![allow(unused)] +fn main() { +fn add_one_v1 (x: u32) -> u32 { x + 1 } +let add_one_v2 = |x: u32| -> u32 { x + 1 }; +let add_one_v3 = |x| { x + 1 }; +let add_one_v4 = |x| x + 1 ; +}
-
+
- 🌟 +
+fn main() { + let example_closure = |x| x; + + let s = example_closure(String::from("hello")); + + /* Make it work, only change the following line */ + let n = example_closure(5); +}
Fn, FnMut, FnOnce
+When taking a closure as an input parameter, the closure's complete type must be annotated using one of the following traits:
+-
+
- Fn: the closure uses the captured value by reference (&T) +
- FnMut: the closure uses the captured value by mutable reference (&mut T) +
- FnOnce: the closure uses the captured value by value (T) +
-
+
- 🌟🌟 +
+/* Make it work by changing the trait bound, in two ways*/ +fn fn_once<F>(func: F) +where + F: FnOnce(usize) -> bool, +{ + println!("{}", func(3)); + println!("{}", func(4)); +} + +fn main() { + let x = vec![1, 2, 3]; + fn_once(|z|{z == x.len()}) +}
-
+
- 🌟🌟 +
+fn main() { + let mut s = String::new(); + + let update_string = |str| s.push_str(str); + + exec(update_string); + + println!("{:?}",s); +} + +/* Fill in the blank */ +fn exec<'a, F: __>(mut f: F) { + f("hello") +}
Which trait does the compiler prefer to use?
+-
+
- Fn: the closure uses the captured value by reference (&T) +
- FnMut: the closure uses the captured value by mutable reference (&mut T) +
- FnOnce: the closure uses the captured value by value (T) +
On a variable-by-variable basis, the compiler will capture variables in the least restrictive manner possible.
+For instance, consider a parameter annotated as FnOnce. This specifies that the closure may capture by &T, &mut T, or T, but the compiler will ultimately choose based on how the captured variables are used in the closure.
+Which trait to use is determined by what the closure does with captured value.
This is because if a move is possible, then any type of borrow should also be possible. Note that the reverse is not true. If the parameter is annotated as Fn, then capturing variables by &mut T or T are not allowed.
-
+
- 🌟🌟 +
+/* Fill in the blank */ + +// A function which takes a closure as an argument and calls it. +// <F> denotes that F is a "Generic type parameter" +fn apply<F>(f: F) where + // The closure takes no input and returns nothing. + F: __ { + + f(); +} + +// A function which takes a closure and returns an `i32`. +fn apply_to_3<F>(f: F) -> i32 where + // The closure takes an `i32` and returns an `i32`. + F: Fn(i32) -> i32 { + + f(3) +} + +fn main() { + use std::mem; + + let greeting = "hello"; + // A non-copy type. + // `to_owned` creates owned data from borrowed one + let mut farewell = "goodbye".to_owned(); + + // Capture 2 variables: `greeting` by reference and + // `farewell` by value. + let diary = || { + // `greeting` is by reference: requires `Fn`. + println!("I said {}.", greeting); + + // Mutation forces `farewell` to be captured by + // mutable reference. Now requires `FnMut`. + farewell.push_str("!!!"); + println!("Then I screamed {}.", farewell); + println!("Now I can sleep. zzzzz"); + + // Manually calling drop forces `farewell` to + // be captured by value. Now requires `FnOnce`. + mem::drop(farewell); + }; + + // Call the function which applies the closure. + apply(diary); + + // `double` satisfies `apply_to_3`'s trait bound + let double = |x| 2 * x; + + println!("3 doubled: {}", apply_to_3(double)); +}
Move closures may still implement Fn or FnMut, even though they capture variables by move. This is because the traits implemented by a closure type are determined by what the closure does with captured values, not how it captures them. The move keyword only specifies the latter.
+fn main() { + let s = String::new(); + + let update_string = move || println!("{}",s); + + exec(update_string); +} + +fn exec<F: FnOnce()>(f: F) { + f() +}
The following code also has no error:
++fn main() { + let s = String::new(); + + let update_string = move || println!("{}",s); + + exec(update_string); +} + +fn exec<F: Fn()>(f: F) { + f() +}
-
+
- 🌟🌟 +
+/* Fill in the blank */ +fn main() { + let mut s = String::new(); + + let update_string = |str| -> String {s.push_str(str); s }; + + exec(update_string); +} + +fn exec<'a, F: __>(mut f: F) { + f("hello"); +}
Input functions
+Since closure can be used as arguments, you might wonder can we use functions as arguments too? And indeed we can.
+-
+
- 🌟🌟 +
++/* Implement `call_me` to make it work */ +fn call_me { + f(); +} + +fn function() { + println!("I'm a function!"); +} + +fn main() { + let closure = || println!("I'm a closure!"); + + call_me(closure); + call_me(function); +}
Closure as return types
+Returning a closure is much harder than you may have thought of.
+-
+
- 🌟🌟 +
+/* Fill in the blank using two approaches, + and fix the error */ +fn create_fn() -> __ { + let num = 5; + + // How does the following closure capture the environment variable `num` + // &T, &mut T, T ? + |x| x + num +} + + +fn main() { + let fn_plain = create_fn(); + fn_plain(1); +}
-
+
- 🌟🌟 +
+/* Fill in the blank and fix the error*/ +fn factory(x:i32) -> __ { + + let num = 5; + + if x > 1{ + move |x| x + num + } else { + move |x| x + num + } +}
Closure in structs
+Example
++struct Cacher<T,E> +where + T: Fn(E) -> E, + E: Copy +{ + query: T, + value: Option<E>, +} + +impl<T,E> Cacher<T,E> +where + T: Fn(E) -> E, + E: Copy +{ + fn new(query: T) -> Cacher<T,E> { + Cacher { + query, + value: None, + } + } + + fn value(&mut self, arg: E) -> E { + match self.value { + Some(v) => v, + None => { + let v = (self.query)(arg); + self.value = Some(v); + v + } + } + } +} +fn main() { + +} + +#[test] +fn call_with_different_values() { + let mut c = Cacher::new(|a| a); + + let v1 = c.value(1); + let v2 = c.value(2); + + assert_eq!(v2, 1); +}
++ + +You can find the solutions here(under the solutions path), but only use it when you need it :)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/functional-programing/iterator.html b/functional-programing/iterator.html
new file mode 100644
index 000000000..a35362f41
--- /dev/null
+++ b/functional-programing/iterator.html
@@ -0,0 +1,512 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Functional programing
+Learning resources:
+-
+
- English: Rust Book 13 +
- 简体中文: Rust语言圣经 - 函数式编程：闭包和迭代器 +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/generics-traits/advanced-traits.html b/generics-traits/advanced-traits.html
new file mode 100644
index 000000000..6008cd0ca
--- /dev/null
+++ b/generics-traits/advanced-traits.html
@@ -0,0 +1,479 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Iterator
+The iterator pattern allows us to perform some tasks on a sequence of items in turn. An iterator is responsible for the logic of iterating over each item and determining when the sequence has finished.
+for and iterator
++fn main() { + let v = vec![1, 2, 3]; + for x in v { + println!("{}",x) + } +}
In the code above, You may consider for as a simple loop, but actually it is iterating over a iterator.
By default for will apply the into_iter to the collection, and change it into a iterator. As a result, the following code is equivalent to previous one:
+fn main() { + let v = vec![1, 2, 3]; + for x in v.into_iter() { + println!("{}",x) + } +}
-
+
- 🌟 +
+/* Refactoring the following code using iterators */ +fn main() { + let arr = [0; 10]; + for i in 0..arr.len() { + println!("{}",arr[i]); + } +}
-
+
- 🌟 One of the easiest ways to create an iterator is to use the range notion:
a..b.
+
+/* Fill in the blank */ +fn main() { + let mut v = Vec::new(); + for n in __ { + v.push(n); + } + + assert_eq!(v.len(), 100); +}
next method
+All iterators implement a trait named Iterator that is defined in the standard library:
+#![allow(unused)] +fn main() { +pub trait Iterator { + type Item; + + fn next(&mut self) -> Option<Self::Item>; + + // Methods with default implementations elided +} +}
And we can call the next method on iterators directly.
-
+
- 🌟🌟 +
+/* Fill the blanks and fix the errors. +Using two ways if possible */ +fn main() { + let v1 = vec![1, 2]; + + assert_eq!(v1.next(), __); + assert_eq!(v1.next(), __); + assert_eq!(v1.next(), __); +}
into_iter, iter and iter_mut
+In the previous section, we have mentioned that for will apply the into_iter to the collection, and change it into a iterator. However, this is not the only way to convert collections into iterators.
into_iter, iter, iter_mut, all of them can convert a collection into iterator, but in different ways.
-
+
into_iterconsumes the collection, once the collection has been consumed, it is no longer available for reuse, because its ownership has been moved within the loop.
+iter, this borrows each element of the collection through each iteration, thus leaving the collection untouched and available for reuse after the loop
+iter_mut, this mutably borrows each element of the collection, allowing for the collection to be modified in place.
+
-
+
- 🌟 +
+/* Make it work */ +fn main() { + let arr = vec![0; 10]; + for i in arr { + println!("{}", i); + } + + println!("{:?}",arr); +}
-
+
- 🌟 +
+/* Fill in the blank */ +fn main() { + let mut names = vec!["Bob", "Frank", "Ferris"]; + + for name in names.__{ + *name = match name { + &mut "Ferris" => "There is a rustacean among us!", + _ => "Hello", + } + } + + println!("names: {:?}", names); +}
-
+
- 🌟🌟 +
+/* Fill in the blank */ +fn main() { + let mut values = vec![1, 2, 3]; + let mut values_iter = values.__; + + if let Some(v) = values_iter.__{ + __ + } + + assert_eq!(values, vec![0, 2, 3]); +}
Creating our own iterator
+We can not only create iterators from collection's types, but also can create iterators by implementing the Iterator trait on our own types.
Example
++struct Counter { + count: u32, +} + +impl Counter { + fn new() -> Counter { + Counter { count: 0 } + } +} + +impl Iterator for Counter { + type Item = u32; + + fn next(&mut self) -> Option<Self::Item> { + if self.count < 5 { + self.count += 1; + Some(self.count) + } else { + None + } + } +} + +fn main() { + let mut counter = Counter::new(); + + assert_eq!(counter.next(), Some(1)); + assert_eq!(counter.next(), Some(2)); + assert_eq!(counter.next(), Some(3)); + assert_eq!(counter.next(), Some(4)); + assert_eq!(counter.next(), Some(5)); + assert_eq!(counter.next(), None); +}
-
+
- 🌟🌟🌟 +
+struct Fibonacci { + curr: u32, + next: u32, +} + +// Implement `Iterator` for `Fibonacci`. +// The `Iterator` trait only requires a method to be defined for the `next` element. +impl Iterator for Fibonacci { + // We can refer to this type using Self::Item + type Item = u32; + + /* Implement next method */ + fn next(&mut self) +} + +// Returns a Fibonacci sequence generator +fn fibonacci() -> Fibonacci { + Fibonacci { curr: 0, next: 1 } +} + +fn main() { + let mut fib = fibonacci(); + assert_eq!(fib.next(), Some(1)); + assert_eq!(fib.next(), Some(1)); + assert_eq!(fib.next(), Some(2)); + assert_eq!(fib.next(), Some(3)); + assert_eq!(fib.next(), Some(5)); +}
Methods that Consume the Iterator
+The Iterator trait has a number of methods with default implementations provided by the standard library.
Consuming adaptors
+Some of these methods call the method nextto use up the iterator, so they are called consuming adaptors.
-
+
- 🌟🌟 +
++/* Fill in the blank and fix the errors */ +fn main() { + let v1 = vec![1, 2, 3]; + + let v1_iter = v1.iter(); + + // The sum method will take the ownership of the iterator and iterates through the items by repeatedly calling next method + let total = v1_iter.sum(); + + assert_eq!(total, __); + + println!("{:?}, {:?}",v1, v1_iter); +}
Collect
+Other than converting a collection into an iterator, we can also collect the result values into a collection, collect will consume the iterator.
-
+
- 🌟🌟 +
+/* Make it work */ +use std::collections::HashMap; +fn main() { + let names = [("sunface",18), ("sunfei",18)]; + let folks: HashMap<_, _> = names.into_iter().collect(); + + println!("{:?}",folks); + + let v1: Vec<i32> = vec![1, 2, 3]; + + let v2 = v1.iter().collect(); + + assert_eq!(v2, vec![1, 2, 3]); +}
Iterator adaptors
+Methods allowing you to change one iterator into another iterator are known as iterator adaptors. You can chain multiple iterator adaptors to perform complex actions in a readable way.
+But because all iterators are lazy, you have to call one of the consuming adapters to get results from calls to iterator adapters.
+-
+
- 🌟🌟 +
+/* Fill in the blanks */ +fn main() { + let v1: Vec<i32> = vec![1, 2, 3]; + + let v2: Vec<_> = v1.iter().__.__; + + assert_eq!(v2, vec![2, 3, 4]); +}
-
+
- 🌟🌟 +
+/* Fill in the blanks */ +use std::collections::HashMap; +fn main() { + let names = ["sunface", "sunfei"]; + let ages = [18, 18]; + let folks: HashMap<_, _> = names.into_iter().__.collect(); + + println!("{:?}",folks); +}
Using closures in iterator adaptors
+-
+
- 🌟🌟 +
+/* Fill in the blanks */ +#[derive(PartialEq, Debug)] +struct Shoe { + size: u32, + style: String, +} + +fn shoes_in_size(shoes: Vec<Shoe>, shoe_size: u32) -> Vec<Shoe> { + shoes.into_iter().__.collect() +} + +fn main() { + let shoes = vec![ + Shoe { + size: 10, + style: String::from("sneaker"), + }, + Shoe { + size: 13, + style: String::from("sandal"), + }, + Shoe { + size: 10, + style: String::from("boot"), + }, + ]; + + let in_my_size = shoes_in_size(shoes, 10); + + assert_eq!( + in_my_size, + vec![ + Shoe { + size: 10, + style: String::from("sneaker") + }, + Shoe { + size: 10, + style: String::from("boot") + }, + ] + ); +}
++ + +You can find the solutions here(under the solutions path), but only use it when you need it :)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/generics-traits/const-generics.html b/generics-traits/const-generics.html
new file mode 100644
index 000000000..479f687de
--- /dev/null
+++ b/generics-traits/const-generics.html
@@ -0,0 +1,351 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Advance Traits
+Associated types
+The use of "Associated types" improves the overall readability of code by moving inner types locally into a trait as output types. For example :
++#![allow(unused)] +fn main() { +pub trait CacheableItem: Clone + Default + fmt::Debug + Decodable + Encodable { + type Address: AsRef<[u8]> + Clone + fmt::Debug + Eq + Hash; + fn is_null(&self) -> bool; +} +}
Using of Address is much more clearer and convenient than AsRef<[u8]> + Clone + fmt::Debug + Eq + Hash.
-
+
- 🌟🌟🌟 +
++struct Container(i32, i32); + +// USING associated types to re-implement trait Contains. +// trait Contains { +// type A; +// type B; + +trait Contains<A, B> { + fn contains(&self, _: &A, _: &B) -> bool; + fn first(&self) -> i32; + fn last(&self) -> i32; +} + +impl Contains<i32, i32> for Container { + fn contains(&self, number_1: &i32, number_2: &i32) -> bool { + (&self.0 == number_1) && (&self.1 == number_2) + } + // Grab the first number. + fn first(&self) -> i32 { self.0 } + + // Grab the last number. + fn last(&self) -> i32 { self.1 } +} + +fn difference<A, B, C: Contains<A, B>>(container: &C) -> i32 { + container.last() - container.first() +} + +fn main() { + let number_1 = 3; + let number_2 = 10; + + let container = Container(number_1, number_2); + + println!("Does container contain {} and {}: {}", + &number_1, &number_2, + container.contains(&number_1, &number_2)); + println!("First number: {}", container.first()); + println!("Last number: {}", container.last()); + + println!("The difference is: {}", difference(&container)); +}
Default Generic Type Parameters
+When we use generic type parameters, we can specify a default concrete type for the generic type. This eliminates the need for implementors of the trait to specify a concrete type if the default type works.
+-
+
- 🌟🌟 +
++use std::ops::Sub; + +#[derive(Debug, PartialEq)] +struct Point<T> { + x: T, + y: T, +} + +// FILL in the blank in three ways: two of them use the default generic parameters, the other one not. +// Notice that the implementation uses the associated type `Output`. +impl __ { + type Output = Self; + + fn sub(self, other: Self) -> Self::Output { + Point { + x: self.x - other.x, + y: self.y - other.y, + } + } +} + +fn main() { + assert_eq!(Point { x: 2, y: 3 } - Point { x: 1, y: 0 }, + Point { x: 1, y: 3 }); + + println!("Success!"); +}
Fully Qualified Syntax
+Nothing in Rust prevents a trait from having a method with the same name as another trait’s method, nor does Rust prevent you from implementing both traits on one type. It’s also possible to implement a method directly on the type with the same name as methods from traits.
+When calling methods with the same name, we have to use Fully Qualified Syntax.
+Example
++trait UsernameWidget { + // Get the selected username out of this widget + fn get(&self) -> String; +} + +trait AgeWidget { + // Get the selected age out of this widget + fn get(&self) -> u8; +} + +// A form with both a UsernameWidget and an AgeWidget. +struct Form { + username: String, + age: u8, +} + +impl UsernameWidget for Form { + fn get(&self) -> String { + self.username.clone() + } +} + +impl AgeWidget for Form { + fn get(&self) -> u8 { + self.age + } +} + +fn main() { + let form = Form{ + username: "rustacean".to_owned(), + age: 28, + }; + + // If you uncomment this line, you'll get an error saying + // "multiple `get` found". Because, after all, there are multiple methods + // named `get`. + // println!("{}", form.get()); + + let username = UsernameWidget::get(&form); + assert_eq!("rustacean".to_owned(), username); + let age = AgeWidget::get(&form); // You can also use `<Form as AgeWidget>::get` + assert_eq!(28, age); + + println!("Success!"); +}
Exercise
+-
+
- 🌟🌟 +
+trait Pilot { + fn fly(&self) -> String; +} + +trait Wizard { + fn fly(&self) -> String; +} + +struct Human; + +impl Pilot for Human { + fn fly(&self) -> String { + String::from("This is your captain speaking.") + } +} + +impl Wizard for Human { + fn fly(&self) -> String { + String::from("Up!") + } +} + +impl Human { + fn fly(&self) -> String { + String::from("*waving arms furiously*") + } +} + +fn main() { + let person = Human; + + assert_eq!(__, "This is your captain speaking."); + assert_eq!(__, "Up!"); + + assert_eq!(__, "*waving arms furiously*"); + + println!("Success!"); +}
Supertraits
+Sometimes, you might need one trait to use another trait’s functionality( like the "inheritance" in other languages ). In this case, you need to rely on the dependent trait also being implemented. The trait you rely on is a supertrait of the trait you’re implementing.
-
+
- 🌟🌟🌟 +
++trait Person { + fn name(&self) -> String; +} + +// Person is a supertrait of Student. +// Implementing Student requires you to also impl Person. +trait Student: Person { + fn university(&self) -> String; +} + +trait Programmer { + fn fav_language(&self) -> String; +} + +// CompSciStudent (computer science student) is a subtrait of both Programmer +// and Student. Implementing CompSciStudent requires you to impl both supertraits. +trait CompSciStudent: Programmer + Student { + fn git_username(&self) -> String; +} + +fn comp_sci_student_greeting(student: &dyn CompSciStudent) -> String { + format!( + "My name is {} and I attend {}. My favorite language is {}. My Git username is {}", + student.name(), + student.university(), + student.fav_language(), + student.git_username() + ) +} + +struct CSStudent { + name: String, + university: String, + fav_language: String, + git_username: String +} + +// IMPLEMENT the necessary traits for CSStudent to make the code work +impl ... + +fn main() { + let student = CSStudent { + name: "Sunfei".to_string(), + university: "XXX".to_string(), + fav_language: "Rust".to_string(), + git_username: "sunface".to_string() + }; + + // FILL in the blank + println!("{}", comp_sci_student_greeting(__)); +}
Orphan Rules
+We can’t implement external traits on external types. For example, we can’t implement the Display trait on Vec<T> within our own crate, because Display and Vec<T> are defined in the standard library and aren’t local to our crate.
This restriction is often called the orphan rule, so named because the parent type is not present. This rule ensures that other people’s code can’t break your code and vice versa.
+It’s possible to get around this restriction using the newtype pattern, which involves creating a new type in a tuple struct.
+-
+
- 🌟🌟 +
+use std::fmt; + +// DEFINE a newtype `Pretty` here + + +impl fmt::Display for Pretty { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!(f, "\"{}\"", self.0.clone() + ", world") + } +} + +fn main() { + let w = Pretty("hello".to_string()); + println!("w = {}", w); +}
++ + +You can find the solutions here(under the solutions path), but only use it when you need it :)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/generics-traits/generics.html b/generics-traits/generics.html
new file mode 100644
index 000000000..4a5945f62
--- /dev/null
+++ b/generics-traits/generics.html
@@ -0,0 +1,361 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Const Generics
+Const generics are generic arguments that range over constant values, rather than types or lifetimes. This allows, for instance, types to be parameterized by integers. In fact, there has been one example of const generic types since early on in Rust's development: the array types [T; N], for some type T and N: usize. However, there has previously been no way to abstract over arrays of an arbitrary size: if you wanted to implement a trait for arrays of any size, you would have to do so manually for each possible value. For a long time, even the standard library methods for arrays were limited to arrays of length at most 32 due to this problem.
+Examples
+-
+
- Here's an example of a type and implementation making use of const generics: a type wrapping a pair of arrays of the same size. +
+struct ArrayPair<T, const N: usize> { + left: [T; N], + right: [T; N], +} + +impl<T: Debug, const N: usize> Debug for ArrayPair<T, N> { + // ... +}
-
+
- Currently, const parameters may only be instantiated by const arguments of the following forms: +
-
+
- A standalone const parameter. +
- A literal (i.e. an integer, bool, or character). +
- A concrete constant expression (enclosed by {}), involving no generic parameters. +
+fn foo<const N: usize>() {} + +fn bar<T, const M: usize>() { + foo::<M>(); // Okay: `M` is a const parameter + foo::<2021>(); // Okay: `2021` is a literal + foo::<{20 * 100 + 20 * 10 + 1}>(); // Okay: const expression contains no generic parameters + + foo::<{ M + 1 }>(); // Error: const expression contains the generic parameter `M` + foo::<{ std::mem::size_of::<T>() }>(); // Error: const expression contains the generic parameter `T` + + let _: [u8; M]; // Okay: `M` is a const parameter + let _: [u8; std::mem::size_of::<T>()]; // Error: const expression contains the generic parameter `T` +} + +fn main() {}
-
+
- Const generics can also let us avoid some runtime checks. +
+/// A region of memory containing at least `N` `T`s. +pub struct MinSlice<T, const N: usize> { + /// The bounded region of memory. Exactly `N` `T`s. + pub head: [T; N], + /// Zero or more remaining `T`s after the `N` in the bounded region. + pub tail: [T], +} + +fn main() { + let slice: &[u8] = b"Hello, world"; + let reference: Option<&u8> = slice.get(6); + // We know this value is `Some(b' ')`, + // but the compiler can't know that. + assert!(reference.is_some()); + + let slice: &[u8] = b"Hello, world"; + // Length check is performed when we construct a MinSlice, + // and it's known at compile time to be of length 12. + // If the `unwrap()` succeeds, no more checks are needed + // throughout the `MinSlice`'s lifetime. + let minslice = MinSlice::<u8, 12>::from_slice(slice).unwrap(); + let value: u8 = minslice.head[6]; + assert_eq!(value, b' ') +}
Exercises
+-
+
- 🌟🌟
<T, const N: usize>is part of the struct type, it meansArray<i32, 3>andArray<i32, 4>are different types.
+
+struct Array<T, const N: usize> { + data : [T; N] +} + +fn main() { + let arrays = [ + Array{ + data: [1, 2, 3], + }, + Array { + data: [1.0, 2.0, 3.0], + }, + Array { + data: [1, 2] + } + ]; + + println!("Success!"); +}
-
+
- 🌟🌟 +
++// Fill in the blanks to make it work. +fn print_array<__>(__) { + println!("{:?}", arr); +} +fn main() { + let arr = [1, 2, 3]; + print_array(arr); + + let arr = ["hello", "world"]; + print_array(arr); +}
-
+
- 🌟🌟🌟 Sometimes we want to limit the size of a variable, e.g when using in embedding environments, then
const expressionswill fit your needs.
+
+#![allow(incomplete_features)] +#![feature(generic_const_exprs)] + +fn check_size<T>(val: T) +where + Assert<{ core::mem::size_of::<T>() < 768 }>: IsTrue, +{ + //... +} + +// Fix the errors in main. +fn main() { + check_size([0u8; 767]); + check_size([0i32; 191]); + check_size(["hello你好"; __]); // Size of &str ? + check_size([(); __].map(|_| "hello你好".to_string())); // Size of String? + check_size(['中'; __]); // Size of char ? + + println!("Success!"); +} + + + +pub enum Assert<const CHECK: bool> {} + +pub trait IsTrue {} + +impl IsTrue for Assert<true> {}
++ + +You can find the solutions here(under the solutions path), but only use it when you need it :)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/generics-traits/intro.html b/generics-traits/intro.html
new file mode 100644
index 000000000..96f21fd55
--- /dev/null
+++ b/generics-traits/intro.html
@@ -0,0 +1,221 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Struct and
+
+
+
+
+ Generics
+Functions
+-
+
- 🌟🌟🌟 +
++// Fill in the blanks to make it work +struct A; // Concrete type `A`. +struct S(A); // Concrete type `S`. +struct SGen<T>(T); // Generic type `SGen`. + +fn reg_fn(_s: S) {} + +fn gen_spec_t(_s: SGen<A>) {} + +fn gen_spec_i32(_s: SGen<i32>) {} + +fn generic<T>(_s: SGen<T>) {} + +fn main() { + // Using the non-generic functions + reg_fn(__); // Concrete type. + gen_spec_t(__); // Implicitly specified type parameter `A`. + gen_spec_i32(__); // Implicitly specified type parameter `i32`. + + // Explicitly specified type parameter `char` to `generic()`. + generic::<char>(__); + + // Implicitly specified type parameter `char` to `generic()`. + generic(__); + + println!("Success!"); +}
-
+
- 🌟🌟 A function call with explicitly specified type parameters looks like:
fun::<A, B, ...>().
+
++// Implement the generic function below. +fn sum + +fn main() { + assert_eq!(5, sum(2i8, 3i8)); + assert_eq!(50, sum(20, 30)); + assert_eq!(2.46, sum(1.23, 1.23)); + + println!("Success!"); +}
Struct and impl
+-
+
- 🌟 +
++// Implement struct Point to make it work. + + +fn main() { + let integer = Point { x: 5, y: 10 }; + let float = Point { x: 1.0, y: 4.0 }; + + println!("Success!"); +}
-
+
- 🌟🌟 +
++// Modify this struct to make the code work +struct Point<T> { + x: T, + y: T, +} + +fn main() { + // DON'T modify this code. + let p = Point{x: 5, y : "hello".to_string()}; + + println!("Success!"); +}
-
+
- 🌟🌟 +
++// Add generic for Val to make the code work, DON'T modify the code in `main`. +struct Val { + val: f64, +} + +impl Val { + fn value(&self) -> &f64 { + &self.val + } +} + + +fn main() { + let x = Val{ val: 3.0 }; + let y = Val{ val: "hello".to_string()}; + println!("{}, {}", x.value(), y.value()); +}
Method
+-
+
- 🌟🌟🌟 +
+struct Point<T, U> { + x: T, + y: U, +} + +impl<T, U> Point<T, U> { + // Implement mixup to make it work, DON'T modify other code. + fn mixup +} + +fn main() { + let p1 = Point { x: 5, y: 10 }; + let p2 = Point { x: "Hello", y: '中'}; + + let p3 = p1.mixup(p2); + + assert_eq!(p3.x, 5); + assert_eq!(p3.y, '中'); + + println!("Success!"); +}
-
+
- 🌟🌟 +
++// Fix the errors to make the code work. +struct Point<T> { + x: T, + y: T, +} + +impl Point<f32> { + fn distance_from_origin(&self) -> f32 { + (self.x.powi(2) + self.y.powi(2)).sqrt() + } +} + +fn main() { + let p = Point{x: 5, y: 10}; + println!("{}",p.distance_from_origin()); +}
++ + +You can find the solutions here(under the solutions path), but only use it when you need it
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/generics-traits/trait-object.html b/generics-traits/trait-object.html
new file mode 100644
index 000000000..89283e931
--- /dev/null
+++ b/generics-traits/trait-object.html
@@ -0,0 +1,434 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Generics and Traits
+Learning resources:
+-
+
- English: Rust Book 10.1, 10.2 +
- 简体中文: Rust语言圣经 - 模式匹配 +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/generics-traits/traits.html b/generics-traits/traits.html
new file mode 100644
index 000000000..ea748a879
--- /dev/null
+++ b/generics-traits/traits.html
@@ -0,0 +1,670 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Trait Object
+In traits chapter we have seen that we can't use impl Trait when returning multiple types.
Another limitation of arrays is that they can only store elements of one type. Using enums is not a bad solution when we have a fixed set of types at compile time, but trait objects would be more flexible and powerful.
+Returning Traits with dyn
+The Rust compiler needs to know how much space a function's return type requires. Because the different implementations of a trait probably uses different amounts of memory, functions need to either return a concrete type or the same type when using impl Trait, or return a trait object with dyn.
-
+
- 🌟🌟🌟 +
++trait Bird { + fn quack(&self) -> String; +} + +struct Duck; +impl Duck { + fn swim(&self) { + println!("Look, the duck is swimming") + } +} +struct Swan; +impl Swan { + fn fly(&self) { + println!("Look, the duck.. oh sorry, the swan is flying") + } +} + +impl Bird for Duck { + fn quack(&self) -> String{ + "duck duck".to_string() + } +} + +impl Bird for Swan { + fn quack(&self) -> String{ + "swan swan".to_string() + } +} + +fn main() { + // FILL in the blank. + let duck = __; + duck.swim(); + + let bird = hatch_a_bird(2); + // This bird has forgotten how to swim, so below line will cause an error. + // bird.swim(); + // But it can quak. + assert_eq!(bird.quack(), "duck duck"); + + let bird = hatch_a_bird(1); + // This bird has forgotten how to fly, so below line will cause an error. + // bird.fly(); + // But it can quak too. + assert_eq!(bird.quack(), "swan swan"); + + println!("Success!"); +} + +// IMPLEMENT this function. +fn hatch_a_bird... +
Array with trait objects
+-
+
- 🌟🌟 +
+trait Bird { + fn quack(&self); +} + +struct Duck; +impl Duck { + fn fly(&self) { + println!("Look, the duck is flying") + } +} +struct Swan; +impl Swan { + fn fly(&self) { + println!("Look, the duck.. oh sorry, the swan is flying") + } +} + +impl Bird for Duck { + fn quack(&self) { + println!("{}", "duck duck"); + } +} + +impl Bird for Swan { + fn quack(&self) { + println!("{}", "swan swan"); + } +} + +fn main() { + // FILL in the blank to make the code work. + let birds __; + + for bird in birds { + bird.quack(); + // When duck and swan turn into Birds, they all forgot how to fly, only remember how to quack. + // So, the code below will cause an error. + // bird.fly(); + } +}
&dyn and Box<dyn>
+-
+
- 🌟🌟 +
++// FILL in the blanks. +trait Draw { + fn draw(&self) -> String; +} + +impl Draw for u8 { + fn draw(&self) -> String { + format!("u8: {}", *self) + } +} + +impl Draw for f64 { + fn draw(&self) -> String { + format!("f64: {}", *self) + } +} + +fn main() { + let x = 1.1f64; + let y = 8u8; + + // Draw x. + draw_with_box(__); + + // Draw y. + draw_with_ref(&y); + + println!("Success!"); +} + +fn draw_with_box(x: Box<dyn Draw>) { + x.draw(); +} + +fn draw_with_ref(x: __) { + x.draw(); +}
Static and Dynamic dispatch
+When we use trait bounds on generics, the compiler generates nongeneric implementations of functions and methods for each concrete type that we use in place of a generic type parameter. The code that results from monomorphization is doing static dispatch, which is when the compiler knows what method you’re calling at compile time.
+When we use trait objects, Rust must use dynamic dispatch. The compiler doesn’t know all the types that might be used with the code that is using trait objects, so it doesn’t know which method implemented on which type to call. Instead, at runtime, Rust uses the pointers inside the trait object to know which method to call. There is a runtime cost when this lookup happens that doesn’t occur with static dispatch. Dynamic dispatch also prevents the compiler from choosing to inline a method’s code, which in turn prevents some optimizations.
+However, we do get extra flexibility when using dynamic dispatch.
+-
+
- 🌟🌟 +
++trait Foo { + fn method(&self) -> String; +} + +impl Foo for u8 { + fn method(&self) -> String { format!("u8: {}", *self) } +} + +impl Foo for String { + fn method(&self) -> String { format!("string: {}", *self) } +} + +// IMPLEMENT below with generics. +fn static_dispatch... + +// Implement below with trait objects. +fn dynamic_dispatch... + +fn main() { + let x = 5u8; + let y = "Hello".to_string(); + + static_dispatch(x); + dynamic_dispatch(&y); + + println!("Success!"); +}
Object safe
+You can only make object-safe traits into trait objects. A trait is object safe if all the methods defined in the trait have the following properties:
+-
+
- The return type isn’t
Self.
+ - There are no generic type parameters. +
-
+
- 🌟🌟🌟🌟 +
++// Use at least two approaches to make it work. +// DON'T add/remove any code line. +trait MyTrait { + fn f(&self) -> Self; +} + +impl MyTrait for u32 { + fn f(&self) -> Self { 42 } +} + +impl MyTrait for String { + fn f(&self) -> Self { self.clone() } +} + +fn my_function(x: Box<dyn MyTrait>) { + x.f() +} + +fn main() { + my_function(Box::new(13_u32)); + my_function(Box::new(String::from("abc"))); + + println!("Success!"); +}
++ + +You can find the solutions here(under the solutions path), but only use it when you need it :)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/global-variables.html b/global-variables.html
new file mode 100644
index 000000000..affb4cd62
--- /dev/null
+++ b/global-variables.html
@@ -0,0 +1,216 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Traits
+A trait tells the Rust compiler about functionality a particular type has and can share with other types. We can use traits to define shared behavior in an abstract way. We can use trait bounds to specify that a generic type can be any type that has certain behavior.
+++Note: Traits are similar to interfaces in other languages, although with some differences.
+
Examples
+++struct Sheep { naked: bool, name: String } + +trait Animal { + // Associated function signature; `Self` refers to the implementor type. + fn new(name: String) -> Self; + + // Method signatures; these will return a string. + fn name(&self) -> String; + + fn noise(&self) -> String; + + // Traits can provide default method definitions. + fn talk(&self) { + println!("{} says {}", self.name(), self.noise()); + } +} + +impl Sheep { + fn is_naked(&self) -> bool { + self.naked + } + + fn shear(&mut self) { + if self.is_naked() { + // Implementor methods can use the implementor's trait methods. + println!("{} is already naked...", self.name()); + } else { + println!("{} gets a haircut!", self.name); + + self.naked = true; + } + } +} + +// Implement the `Animal` trait for `Sheep`. +impl Animal for Sheep { + // `Self` is the implementor type: `Sheep`. + fn new(name: String) -> Sheep { + Sheep { name: name, naked: false } + } + + fn name(&self) -> String { + self.name.clone() + } + + fn noise(&self) -> String { + if self.is_naked() { + "baaaaah?".to_string() + } else { + "baaaaah!".to_string() + } + } + + // Default trait methods can be overridden. + fn talk(&self) { + // For example, we can add some quiet contemplation. + println!("{} pauses briefly... {}", self.name, self.noise()); + } +} + +fn main() { + // Type annotation is necessary in this case. + let mut dolly: Sheep = Animal::new("Dolly".to_string()); + // TODO ^ Try removing the type annotations. + + dolly.talk(); + dolly.shear(); + dolly.talk(); +}
Exercises
+-
+
- 🌟🌟 +
++// Fill in the two impl blocks to make the code work. +// DON'T modify the code in `main`. +trait Hello { + fn say_hi(&self) -> String { + String::from("hi") + } + + fn say_something(&self) -> String; +} + +struct Student {} +impl Hello for Student { +} +struct Teacher {} +impl Hello for Teacher { +} + +fn main() { + let s = Student {}; + assert_eq!(s.say_hi(), "hi"); + assert_eq!(s.say_something(), "I'm a good student"); + + let t = Teacher {}; + assert_eq!(t.say_hi(), "Hi, I'm your new teacher"); + assert_eq!(t.say_something(), "I'm not a bad teacher"); + + println!("Success!"); +}
Derive
+The compiler is capable of providing basic implementations for some traits via
+the #[derive] attribute. For more info, please visit here.
-
+
- 🌟🌟 +
++// `Centimeters`, a tuple struct that can be compared +#[derive(PartialEq, PartialOrd)] +struct Centimeters(f64); + +// `Inches`, a tuple struct that can be printed +#[derive(Debug)] +struct Inches(i32); + +impl Inches { + fn to_centimeters(&self) -> Centimeters { + let &Inches(inches) = self; + + Centimeters(inches as f64 * 2.54) + } +} + +// ADD some attributes to make the code work! +// DON'T modify other code! +struct Seconds(i32); + +fn main() { + let _one_second = Seconds(1); + + println!("One second looks like: {:?}", _one_second); + let _this_is_true = (_one_second == _one_second); + let _this_is_false = (_one_second > _one_second); + + let foot = Inches(12); + + println!("One foot equals {:?}", foot); + + let meter = Centimeters(100.0); + + let cmp = + if foot.to_centimeters() < meter { + "smaller" + } else { + "bigger" + }; + + println!("One foot is {} than one meter.", cmp); +}
Operator
+In Rust, many of the operators can be overloaded via traits. That is, some operators can be used to accomplish different tasks based on their input arguments. This is possible because operators are syntactic sugar for method calls. For example, the + operator in a + b calls the add method (as in a.add(b)). This add method is part of the Add trait. Hence, the + operator can be used by any implementor of the Add trait.
+-
+
- 🌟🌟 +
++use std::ops; + +// Implement fn multiply to make the code work. +// As mentioned above, `+` needs `T` to implement `std::ops::Add` Trait. +// So, what about `*`? You can find the answer here: https://doc.rust-lang.org/core/ops/ +fn multipl + +fn main() { + assert_eq!(6, multiply(2u8, 3u8)); + assert_eq!(5.0, multiply(1.0, 5.0)); + + println!("Success!"); +}
-
+
- 🌟🌟🌟 +
++// Fix the errors, DON'T modify the code in `main`. +use std::ops; + +struct Foo; +struct Bar; + +struct FooBar; + +struct BarFoo; + +// The `std::ops::Add` trait is used to specify the functionality of `+`. +// Here, we make `Add<Bar>` - the trait for addition with a RHS of type `Bar`. +// The following block implements the operation: Foo + Bar = FooBar +impl ops::Add<Bar> for Foo { + type Output = FooBar; + + fn add(self, _rhs: Bar) -> FooBar { + FooBar + } +} + +impl ops::Sub<Foo> for Bar { + type Output = BarFoo; + + fn sub(self, _rhs: Foo) -> BarFoo { + BarFoo + } +} + +fn main() { + // DON'T modify the code below. + // You need to derive some trait for FooBar to make it comparable. + assert_eq!(Foo + Bar, FooBar); + assert_eq!(Foo - Bar, BarFoo); + + println!("Success!"); +}
Use trait as function parameters
+Instead of a concrete type for the item parameter, we specify the impl keyword and the trait name. This parameter accepts any type that implements the specified trait.
+-
+
- 🌟🌟🌟 +
++// Implement `fn summary` to make the code work. +// Fix the errors without removing any code line +trait Summary { + fn summarize(&self) -> String; +} + +#[derive(Debug)] +struct Post { + title: String, + author: String, + content: String, +} + +impl Summary for Post { + fn summarize(&self) -> String { + format!("The author of post {} is {}", self.title, self.author) + } +} + +#[derive(Debug)] +struct Weibo { + username: String, + content: String, +} + +impl Summary for Weibo { + fn summarize(&self) -> String { + format!("{} published a weibo {}", self.username, self.content) + } +} + +fn main() { + let post = Post { + title: "Popular Rust".to_string(), + author: "Sunface".to_string(), + content: "Rust is awesome!".to_string(), + }; + let weibo = Weibo { + username: "sunface".to_string(), + content: "Weibo seems to be worse than Tweet".to_string(), + }; + + summary(post); + summary(weibo); + + println!("{:?}", post); + println!("{:?}", weibo); +} + +// Implement `fn summary` below. +
Returning Types that Implement Traits
+We can also use the impl Trait syntax in the return position to return a value of some type that implements a trait.
+However, you can only use impl Trait if you’re returning a single type, use Trait Objects instead when you really need to return several types.
+-
+
- 🌟🌟 +
++struct Sheep {} +struct Cow {} + +trait Animal { + fn noise(&self) -> String; +} + +impl Animal for Sheep { + fn noise(&self) -> String { + "baaaaah!".to_string() + } +} + +impl Animal for Cow { + fn noise(&self) -> String { + "moooooo!".to_string() + } +} + +// Returns some struct that implements Animal, but we don't know which one at compile time. +// FIX the errors here, you can make a fake random, or you can use trait object. +fn random_animal(random_number: f64) -> impl Animal { + if random_number < 0.5 { + Sheep {} + } else { + Cow {} + } +} + +fn main() { + let random_number = 0.234; + let animal = random_animal(random_number); + println!("You've randomly chosen an animal, and it says {}", animal.noise()); +}
Trait bound
+The impl Trait syntax works for straightforward cases but is actually syntax sugar for a longer form, which is called a trait bound.
When working with generics, the type parameters often must use traits as bounds to stipulate what functionality a type implements.
+-
+
- 🌟🌟 +
+fn main() { + assert_eq!(sum(1, 2), 3); +} + +// Implement `fn sum` with trait bound in two ways. +fn sum<T>(x: T, y: T) -> T { + x + y +}
-
+
- 🌟🌟 +
++// FIX the errors. +struct Pair<T> { + x: T, + y: T, +} + +impl<T> Pair<T> { + fn new(x: T, y: T) -> Self { + Self { + x, + y, + } + } +} + +impl<T: std::fmt::Debug + PartialOrd> Pair<T> { + fn cmp_display(&self) { + if self.x >= self.y { + println!("The largest member is x = {:?}", self.x); + } else { + println!("The largest member is y = {:?}", self.y); + } + } +} + +struct Unit(i32); + +fn main() { + let pair = Pair{ + x: Unit(1), + y: Unit(3) + }; + + pair.cmp_display(); +}
-
+
- 🌟🌟🌟 +
++// Fill in the blanks to make it work +fn example1() { + // `T: Trait` is the commonly used way. + // `T: Fn(u32) -> u32` specifies that we can only pass a closure to `T`. + struct Cacher<T: Fn(u32) -> u32> { + calculation: T, + value: Option<u32>, + } + + impl<T: Fn(u32) -> u32> Cacher<T> { + fn new(calculation: T) -> Cacher<T> { + Cacher { + calculation, + value: None, + } + } + + fn value(&mut self, arg: u32) -> u32 { + match self.value { + Some(v) => v, + None => { + let v = (self.calculation)(arg); + self.value = Some(v); + v + }, + } + } + } + + let mut cacher = Cacher::new(|x| x+1); + assert_eq!(cacher.value(10), __); + assert_eq!(cacher.value(15), __); +} + + +fn example2() { + // We can also use `where` to construct `T` + struct Cacher<T> + where T: Fn(u32) -> u32, + { + calculation: T, + value: Option<u32>, + } + + impl<T> Cacher<T> + where T: Fn(u32) -> u32, + { + fn new(calculation: T) -> Cacher<T> { + Cacher { + calculation, + value: None, + } + } + + fn value(&mut self, arg: u32) -> u32 { + match self.value { + Some(v) => v, + None => { + let v = (self.calculation)(arg); + self.value = Some(v); + v + }, + } + } + } + + let mut cacher = Cacher::new(|x| x+1); + assert_eq!(cacher.value(20), __); + assert_eq!(cacher.value(25), __); +} + + + +fn main() { + example1(); + example2(); + + println!("Success!"); +}
++ + +You can find the solutions here(under the solutions path), but only use it when you need it :)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/highlight.css b/highlight.css
new file mode 100644
index 000000000..ba57b82b2
--- /dev/null
+++ b/highlight.css
@@ -0,0 +1,82 @@
+/*
+ * An increased contrast highlighting scheme loosely based on the
+ * "Base16 Atelier Dune Light" theme by Bram de Haan
+ * (http://atelierbram.github.io/syntax-highlighting/atelier-schemes/dune)
+ * Original Base16 color scheme by Chris Kempson
+ * (https://github.com/chriskempson/base16)
+ */
+
+/* Comment */
+.hljs-comment,
+.hljs-quote {
+ color: #575757;
+}
+
+/* Red */
+.hljs-variable,
+.hljs-template-variable,
+.hljs-attribute,
+.hljs-tag,
+.hljs-name,
+.hljs-regexp,
+.hljs-link,
+.hljs-name,
+.hljs-selector-id,
+.hljs-selector-class {
+ color: #d70025;
+}
+
+/* Orange */
+.hljs-number,
+.hljs-meta,
+.hljs-built_in,
+.hljs-builtin-name,
+.hljs-literal,
+.hljs-type,
+.hljs-params {
+ color: #b21e00;
+}
+
+/* Green */
+.hljs-string,
+.hljs-symbol,
+.hljs-bullet {
+ color: #008200;
+}
+
+/* Blue */
+.hljs-title,
+.hljs-section {
+ color: #0030f2;
+}
+
+/* Purple */
+.hljs-keyword,
+.hljs-selector-tag {
+ color: #9d00ec;
+}
+
+.hljs {
+ display: block;
+ overflow-x: auto;
+ background: #f6f7f6;
+ color: #000;
+}
+
+.hljs-emphasis {
+ font-style: italic;
+}
+
+.hljs-strong {
+ font-weight: bold;
+}
+
+.hljs-addition {
+ color: #22863a;
+ background-color: #f0fff4;
+}
+
+.hljs-deletion {
+ color: #b31d28;
+ background-color: #ffeef0;
+}
diff --git a/highlight.js b/highlight.js
new file mode 100644
index 000000000..180385b70
--- /dev/null
+++ b/highlight.js
@@ -0,0 +1,6 @@
+/*
+ Highlight.js 10.1.1 (93fd0d73)
+ License: BSD-3-Clause
+ Copyright (c) 2006-2020, Ivan Sagalaev
+*/
+var hljs=function(){"use strict";function e(n){Object.freeze(n);var t="function"==typeof n;return Object.getOwnPropertyNames(n).forEach((function(r){!Object.hasOwnProperty.call(n,r)||null===n[r]||"object"!=typeof n[r]&&"function"!=typeof n[r]||t&&("caller"===r||"callee"===r||"arguments"===r)||Object.isFrozen(n[r])||e(n[r])})),n}class n{constructor(e){void 0===e.data&&(e.data={}),this.data=e.data}ignoreMatch(){this.ignore=!0}}function t(e){return e.replace(/&/g,"&").replace(//g,">").replace(/"/g,""").replace(/'/g,"'")}function r(e,...n){var t={};for(const n in e)t[n]=e[n];return n.forEach((function(e){for(const n in e)t[n]=e[n]})),t}function a(e){return e.nodeName.toLowerCase()}var i=Object.freeze({__proto__:null,escapeHTML:t,inherit:r,nodeStream:function(e){var n=[];return function e(t,r){for(var i=t.firstChild;i;i=i.nextSibling)3===i.nodeType?r+=i.nodeValue.length:1===i.nodeType&&(n.push({event:"start",offset:r,node:i}),r=e(i,r),a(i).match(/br|hr|img|input/)||n.push({event:"stop",offset:r,node:i}));return r}(e,0),n},mergeStreams:function(e,n,r){var i=0,s="",o=[];function l(){return e.length&&n.length?e[0].offset!==n[0].offset?e[0].offset
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Global variables
+ + +":e:f.tabReplace?e.replace(/\t/g,f.tabReplace):e):e}function E(e){let n=null;const t=function(e){var n=e.className+" ";n+=e.parentNode?e.parentNode.className:"";const t=f.languageDetectRe.exec(n);if(t){var r=T(t[1]);return r||(console.warn(g.replace("{}",t[1])),console.warn("Falling back to no-highlight mode for this block.",e)),r?t[1]:"no-highlight"}return n.split(/\s+/).find(e=>p(e)||T(e))}(e);if(p(t))return;S("before:highlightBlock",{block:e,language:t}),f.useBR?(n=document.createElement("div")).innerHTML=e.innerHTML.replace(/\n/g,"").replace(/
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/lifetime/advance.html b/lifetime/advance.html
new file mode 100644
index 000000000..bf2d9210e
--- /dev/null
+++ b/lifetime/advance.html
@@ -0,0 +1,473 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+Practice Rust with challenging examples, exercises and projects
+
+
+
+
This book was designed for easily diving into and getting skilled with Rust, and it's very easy to use: All you need to do is to make each exercise compile without ERRORS and Panics !
+Reading online
+ +Running locally
+We use mdbook building our exercises. You can run locally with below steps:
+$ git clone git@github.com:sunface/rust-by-practice.git
+$ cargo install mdbook
+$ cd rust-by-practice && mdbook serve en/
+Features
+Part of our examples and exercises are borrowed from Rust By Example, thanks for your great works!
+Although they are so awesome, we have our own secret weapons :)
+-
+
-
+
There are three parts in each chapter: examples, exercises and practices
+
+ -
+
Besides examples, we have
+a lot of exercises, you can Read, Edit and Run them ONLINE
+ -
+
Covering nearly all aspects of Rust, such as async/await, threads, sync primitives, optimizing, standard libraries, tool chain, data structures and algorithms etc.
+
+ -
+
Every exercise has its own solutions
+
+ -
+
The overall difficulties are a bit higher and from easy to super hard: easy 🌟 medium 🌟🌟 hard 🌟🌟🌟 super hard 🌟🌟🌟🌟
+
+
What we want to do is fill in the gap between learning and getting started with real projects.
+ + +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/lifetime/basic.html b/lifetime/basic.html
new file mode 100644
index 000000000..a2c38d87d
--- /dev/null
+++ b/lifetime/basic.html
@@ -0,0 +1,551 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Advance lifetime
+Trait Bounds
+Just like generic types can be bounded, lifetimes can also be bounded as below:
+-
+
T: 'a，all references inTmust outlive the lifetime'a
+T: Trait + 'a:Tmust implement traitTraitand all references inTmust outlive'a
+
Example
++use std::fmt::Debug; // Trait to bound with. + +#[derive(Debug)] +struct Ref<'a, T: 'a>(&'a T); +// `Ref` contains a reference to a generic type `T` that has +// an unknown lifetime `'a`. `T` is bounded such that any +// *references* in `T` must outlive `'a`. Additionally, the lifetime +// of `Ref` may not exceed `'a`. + +// A generic function which prints using the `Debug` trait. +fn print<T>(t: T) where + T: Debug { + println!("`print`: t is {:?}", t); +} + +// Here a reference to `T` is taken where `T` implements +// `Debug` and all *references* in `T` outlive `'a`. In +// addition, `'a` must outlive the function. +fn print_ref<'a, T>(t: &'a T) where + T: Debug + 'a { + println!("`print_ref`: t is {:?}", t); +} + +fn main() { + let x = 7; + let ref_x = Ref(&x); + + print_ref(&ref_x); + print(ref_x); +}
-
+
- 🌟 +
+/* Annotate struct with lifetime: +1. `r` and `s` must have different lifetimes +2. lifetime of `s` is bigger than that of 'r' +*/ +struct DoubleRef<T> { + r: &T, + s: &T +} +fn main() { + println!("Success!") +}
-
+
- 🌟🌟 +
+/* Adding trait bounds to make it work */ +struct ImportantExcerpt<'a> { + part: &'a str, +} + +impl<'a, 'b> ImportantExcerpt<'a> { + fn announce_and_return_part(&'a self, announcement: &'b str) -> &'b str { + println!("Attention please: {}", announcement); + self.part + } +} + +fn main() { + println!("Success!") +}
-
+
- 🌟🌟 +
+/* Adding trait bounds to make it work */ +fn f<'a, 'b>(x: &'a i32, mut y: &'b i32) { + y = x; + let r: &'b &'a i32 = &&0; +} + +fn main() { + println!("Success!") +}
HRTB(Higher-ranked trait bounds)
+Type bounds may be higher ranked over lifetimes. These bounds specify a bound is true for all lifetimes. For example, a bound such as for<'a> &'a T: PartialEq<i32> would require an implementation like:
+#![allow(unused)] +fn main() { +impl<'a> PartialEq<i32> for &'a T { + // ... +} +}
and could then be used to compare a &'a T with any lifetime to an i32.
Only a higher-ranked bound can be used here, because the lifetime of the reference is shorter than any possible lifetime parameter on the function.
+-
+
- 🌟🌟🌟 +
+/* Adding HRTB to make it work!*/ +fn call_on_ref_zero<'a, F>(f: F) where F: Fn(&'a i32) { + let zero = 0; + f(&zero); +} + +fn main() { + println!("Success!"); +}
NLL (Non-Lexical Lifetime)
+Before explaining NLL, let's see some code first:
++fn main() { + let mut s = String::from("hello"); + + let r1 = &s; + let r2 = &s; + println!("{} and {}", r1, r2); + + let r3 = &mut s; + println!("{}", r3); +}
Based on our current knowledge, this code will cause en error due to violating the borrowing rules in Rust.
+But if you cargo run it, then everything will be ok, so what's going on here?
The ability of the compiler to tell that a reference is no longer used at a point before the end of the scope, is called Non-Lexical Lifetimes (NLL for short).
+With this ability the compiler knows when is the last time that a reference is used and optimizing the borrowing rules based on this knowledge.
++#![allow(unused)] +fn main() { +let mut u = 0i32; +let mut v = 1i32; +let mut w = 2i32; + +// lifetime of `a` = α ∪ β ∪ γ +let mut a = &mut u; // --+ α. lifetime of `&mut u` --+ lexical "lifetime" of `&mut u`,`&mut u`, `&mut w` and `a` +use(a); // | | +*a = 3; // <-----------------+ | +... // | +a = &mut v; // --+ β. lifetime of `&mut v` | +use(a); // | | +*a = 4; // <-----------------+ | +... // | +a = &mut w; // --+ γ. lifetime of `&mut w` | +use(a); // | | +*a = 5; // <-----------------+ <--------------------------+ +}
Reborrow
+After learning NLL, we can easily understand reborrow now.
+Example
++#[derive(Debug)] +struct Point { + x: i32, + y: i32, +} + +impl Point { + fn move_to(&mut self, x: i32, y: i32) { + self.x = x; + self.y = y; + } +} + +fn main() { + let mut p = Point { x: 0, y: 0 }; + let r = &mut p; + // Here comes the reborrow + let rr: &Point = &*r; + + println!("{:?}", rr); // Reborrow ends here, NLL introduced + + // Reborrow is over, we can continue using `r` now + r.move_to(10, 10); + println!("{:?}", r); +}
-
+
- 🌟🌟 +
+/* Make it work by reordering some code */ +fn main() { + let mut data = 10; + let ref1 = &mut data; + let ref2 = &mut *ref1; + + *ref1 += 1; + *ref2 += 2; + + println!("{}", data); +}
Unbound lifetime
+See more info in Nomicon - Unbounded Lifetimes.
+More elision rules
++#![allow(unused)] +fn main() { +impl<'a> Reader for BufReader<'a> { + // 'a is not used in the following methods +} + +// can be written as : +impl Reader for BufReader<'_> { + +} +}
+#![allow(unused)] +fn main() { +// Rust 2015 +struct Ref<'a, T: 'a> { + field: &'a T +} + +// Rust 2018 +struct Ref<'a, T> { + field: &'a T +} +}
A difficult exercise
+-
+
- 🌟🌟🌟🌟 +
+/* Make it work */ +struct Interface<'a> { + manager: &'a mut Manager<'a> +} + +impl<'a> Interface<'a> { + pub fn noop(self) { + println!("interface consumed"); + } +} + +struct Manager<'a> { + text: &'a str +} + +struct List<'a> { + manager: Manager<'a>, +} + +impl<'a> List<'a> { + pub fn get_interface(&'a mut self) -> Interface { + Interface { + manager: &mut self.manager + } + } +} + +fn main() { + let mut list = List { + manager: Manager { + text: "hello" + } + }; + + list.get_interface().noop(); + + println!("Interface should be dropped here and the borrow released"); + + use_list(&list); +} + +fn use_list(list: &List) { + println!("{}", list.manager.text); +}
++ + +You can find the solutions here(under the solutions path), but only use it when you need it :)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/lifetime/intro.html b/lifetime/intro.html
new file mode 100644
index 000000000..56e333cd8
--- /dev/null
+++ b/lifetime/intro.html
@@ -0,0 +1,221 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Lifetime
+The compiler uses lifetime to ensure all borrows are valid. Typically, a variable's lifetime begins when it is created and ends when it is destroyed.
+The scope of lifetime
+-
+
- 🌟 +
+/* Annotate the lifetime of `i` and `borrow2` */ + +// Lifetimes are annotated below with lines denoting the creation +// and destruction of each variable. +// `i` has the longest lifetime because its scope entirely encloses +// both `borrow1` and `borrow2`. The duration of `borrow1` compared +// to `borrow2` is irrelevant since they are disjoint. +fn main() { + let i = 3; + { + let borrow1 = &i; // `borrow1` lifetime starts. ──┐ + // │ + println!("borrow1: {}", borrow1); // │ + } // `borrow1 ends. ──────────────────────────────────┘ + { + let borrow2 = &i; + + println!("borrow2: {}", borrow2); + } +}
-
+
- 🌟🌟 +
Example
++#![allow(unused)] +fn main() { +{ + let x = 5; // ----------+-- 'b + // | + let r = &x; // --+-- 'a | + // | | + println!("r: {}", r); // | | + // --+ | +} // ----------+ +}
+/* Annotate `r` and `x` as above, and explain why this code fails to compile, in the lifetime aspect. */ + +fn main() { + { + let r; // ---------+-- 'a + // | + { // | + let x = 5; // -+-- 'b | + r = &x; // | | + } // -+ | + // | + println!("r: {}", r); // | + } // ---------+ +}
Lifetime annotating
+The borrow checker uses explicit lifetime annotations to determine how long a reference should be valid.
+But for us users, in most cases, there is no need to annotate the lifetime, because there are several elision rules, before learning these rules, we need to know how to annotate lifetime manually.
+Function
+Ignoring elision rules, lifetimes in function signatures have a few constraints:
+-
+
- Any reference must have an annotated lifetime +
- Any reference being returned must have the same lifetime as one of the inputs or be static +
Example
++// One input reference with lifetime `'a` which must live +// at least as long as the function. +fn print_one<'a>(x: &'a i32) { + println!("`print_one`: x is {}", x); +} + +// Mutable references are possible with lifetimes as well. +fn add_one<'a>(x: &'a mut i32) { + *x += 1; +} + +// Multiple elements with different lifetimes. In this case, it +// would be fine for both to have the same lifetime `'a`, but +// in more complex cases, different lifetimes may be required. +fn print_multi<'a, 'b>(x: &'a i32, y: &'b i32) { + println!("`print_multi`: x is {}, y is {}", x, y); +} + +// Returning references that have been passed in is acceptable. +// However, the correct lifetime must be returned. +fn pass_x<'a, 'b>(x: &'a i32, _: &'b i32) -> &'a i32 { x } + +fn main() { + let x = 7; + let y = 9; + + print_one(&x); + print_multi(&x, &y); + + let z = pass_x(&x, &y); + print_one(z); + + let mut t = 3; + add_one(&mut t); + print_one(&t); +}
-
+
- 🌟 +
+/* Make it work by adding proper lifetime annotation */ +fn longest(x: &str, y: &str) -> &str { + if x.len() > y.len() { + x + } else { + y + } +} + +fn main() {}
-
+
- 🌟🌟🌟 +
+// `'a` must live longer than the function. +// Here, `&String::from("foo")` would create a `String`, followed by a +// reference. Then the data is dropped upon exiting the scope, leaving +// a reference to invalid data to be returned. + +/* Fix the error in three ways */ +fn invalid_output<'a>() -> &'a String { + &String::from("foo") +} + +fn main() { +}
-
+
- 🌟🌟 +
+// `print_refs` takes two references to `i32` which have different +// lifetimes `'a` and `'b`. These two lifetimes must both be at +// least as long as the function `print_refs`. +fn print_refs<'a, 'b>(x: &'a i32, y: &'b i32) { + println!("x is {} and y is {}", x, y); +} + +/* Make it work */ +// A function which takes no arguments, but has a lifetime parameter `'a`. +fn failed_borrow<'a>() { + let _x = 12; + + // ERROR: `_x` does not live long enough + let y: &'a i32 = &_x; + // Attempting to use the lifetime `'a` as an explicit type annotation + // inside the function will fail because the lifetime of `&_x` is shorter + // than `'a` . A short lifetime cannot be coerced into a longer one. +} + +fn main() { + let (four, nine) = (4, 9); + + // Borrows (`&`) of both variables are passed into the function. + print_refs(&four, &nine); + // Any input which is borrowed must outlive the borrower. + // In other words, the lifetime of `four` and `nine` must + // be longer than that of `print_refs`. + + failed_borrow(); + // `failed_borrow` contains no references to force `'a` to be + // longer than the lifetime of the function, but `'a` is longer. + // Because the lifetime is never constrained, it defaults to `'static`. +}
Structs
+-
+
- 🌟 +
+/* Make it work by adding proper lifetime annotation */ + +// A type `Borrowed` which houses a reference to an +// `i32`. The reference to `i32` must outlive `Borrowed`. +#[derive(Debug)] +struct Borrowed(&i32); + +// Similarly, both references here must outlive this structure. +#[derive(Debug)] +struct NamedBorrowed { + x: &i32, + y: &i32, +} + +// An enum which is either an `i32` or a reference to one. +#[derive(Debug)] +enum Either { + Num(i32), + Ref(&i32), +} + +fn main() { + let x = 18; + let y = 15; + + let single = Borrowed(&x); + let double = NamedBorrowed { x: &x, y: &y }; + let reference = Either::Ref(&x); + let number = Either::Num(y); + + println!("x is borrowed in {:?}", single); + println!("x and y are borrowed in {:?}", double); + println!("x is borrowed in {:?}", reference); + println!("y is *not* borrowed in {:?}", number); +}
-
+
- 🌟🌟 +
+/* Make it work */ + +#[derive(Debug)] +struct NoCopyType {} + +#[derive(Debug)] +struct Example<'a, 'b> { + a: &'a u32, + b: &'b NoCopyType +} + +fn main() +{ + /* 'a tied to fn-main stackframe */ + let var_a = 35; + let example: Example; + + { + /* Lifetime 'b tied to new stackframe/scope */ + let var_b = NoCopyType {}; + + /* fixme */ + example = Example { a: &var_a, b: &var_b }; + } + + println!("(Success!) {:?}", example); +}
-
+
- 🌟🌟 +
++#[derive(Debug)] +struct NoCopyType {} + +#[derive(Debug)] +#[allow(dead_code)] +struct Example<'a, 'b> { + a: &'a u32, + b: &'b NoCopyType +} + +/* Fix function signature */ +fn fix_me(foo: &Example) -> &NoCopyType +{ foo.b } + +fn main() +{ + let no_copy = NoCopyType {}; + let example = Example { a: &1, b: &no_copy }; + fix_me(&example); + println!("Success!") +}
Method
+Methods are annotated similarly to functions.
+Example
++struct Owner(i32); + +impl Owner { + // Annotate lifetimes as in a standalone function. + fn add_one<'a>(&'a mut self) { self.0 += 1; } + fn print<'a>(&'a self) { + println!("`print`: {}", self.0); + } +} + +fn main() { + let mut owner = Owner(18); + + owner.add_one(); + owner.print(); +}
-
+
- 🌟🌟 +
+/* Make it work by adding proper lifetime annotations */ +struct ImportantExcerpt { + part: &str, +} + +impl ImportantExcerpt { + fn level(&'a self) -> i32 { + 3 + } +} + +fn main() {}
Elision
+Some lifetime patterns are so common that borrow checker will allow you to omit them to save typing and improve readability.
+This is known as Elision. Elision exist in Rust only because these patterns are common.
+For a more comprehensive understanding of elision, please see lifetime elision in the official book.
+-
+
- 🌟🌟 +
+/* Remove all the lifetimes that can be elided */ + +fn input<'a>(x: &'a i32) { + println!("`annotated_input`: {}", x); +} + +fn pass<'a>(x: &'a i32) -> &'a i32 { x } + +fn longest<'a, 'b>(x: &'a str, y: &'b str) -> &'a str { + x +} + +struct Owner(i32); + +impl Owner { + // Annotate lifetimes as in a standalone function. + fn add_one<'a>(&'a mut self) { self.0 += 1; } + fn print<'a>(&'a self) { + println!("`print`: {}", self.0); + } +} + +struct Person<'a> { + age: u8, + name: &'a str, +} + +enum Either<'a> { + Num(i32), + Ref(&'a i32), +} + +fn main() {}
++ + +You can find the solutions here(under the solutions path), but only use it when you need it :)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/lifetime/static.html b/lifetime/static.html
new file mode 100644
index 000000000..46f521fba
--- /dev/null
+++ b/lifetime/static.html
@@ -0,0 +1,397 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Lifetime
+Learning resources:
+-
+
- English: Rust Book 10.3 +
- 简体中文: Rust语言圣经 - 生命周期 +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/macro.html b/macro.html
new file mode 100644
index 000000000..924ea2292
--- /dev/null
+++ b/macro.html
@@ -0,0 +1,216 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ &'static and T: 'static
+'static is a reserved lifetime name, you might have encountered it several times:
+#![allow(unused)] +fn main() { +// A reference with 'static lifetime: +let s: &'static str = "hello world"; + +// 'static as part of a trait bound: +fn generic<T>(x: T) where T: 'static {} +}
Though they are all 'static, but subtly different.
&'static
+As a reference lifetime, &'static indicates the data pointed to by the reference lives as long as the running program. But it can still be coerced to a shorter lifetime.
-
+
- 🌟🌟 There are several ways to make a variable with
'staticlifetime, two of them are stored in the read-only memory of the binary.
+
++/* Fill in the blank in two ways */ +fn main() { + __; + need_static(v); + + println!("Success!") +} + +fn need_static(r : &'static str) { + assert_eq!(r, "hello"); +}
-
+
- 🌟🌟🌟🌟 Another way to make
'staticlifetime is usingBox::leak
+
+#[derive(Debug)] +struct Config { + a: String, + b: String, +} +static mut config: Option<&mut Config> = None; + +/* Make it work without changing the function signatures of `init`*/ +fn init() -> Option<&'static mut Config> { + Some(&mut Config { + a: "A".to_string(), + b: "B".to_string(), + }) +} + + +fn main() { + unsafe { + config = init(); + + println!("{:?}",config) + } +}
-
+
- 🌟
&'staticonly indicates that the data can live forever, not the reference. The latter one will be constrained by its scope.
+
+fn main() { + { + // Make a `string` literal and print it: + let static_string = "I'm in read-only memory"; + println!("static_string: {}", static_string); + + // When `static_string` goes out of scope, the reference + // can no longer be used, but the data remains in the binary. + } + + println!("static_string reference remains alive: {}", static_string); +}
-
+
&'staticcan be coerced to a shorter lifetime.
+
Example
++// Make a constant with `'static` lifetime. +static NUM: i32 = 18; + +// Returns a reference to `NUM` where its `'static` +// lifetime is coerced to that of the input argument. +fn coerce_static<'a>(_: &'a i32) -> &'a i32 { + &NUM +} + +fn main() { + { + // Make an integer to use for `coerce_static`: + let lifetime_num = 9; + + // Coerce `NUM` to lifetime of `lifetime_num`: + let coerced_static = coerce_static(&lifetime_num); + + println!("coerced_static: {}", coerced_static); + } + + println!("NUM: {} stays accessible!", NUM); +}
T: 'static
+As a trait bound, it means the type does not contain any non-static references. Eg. the receiver can hold on to the type for as long as they want and it will never become invalid until they drop it.
+It's important to understand this means that any owned data always passes a 'static lifetime bound, but a reference to that owned data generally does not.
-
+
- 🌟🌟 +
+/* Make it work */ +use std::fmt::Debug; + +fn print_it<T: Debug + 'static>( input: T) { + println!( "'static value passed in is: {:?}", input ); +} + +fn print_it1( input: impl Debug + 'static ) { + println!( "'static value passed in is: {:?}", input ); +} + + +fn print_it2<T: Debug + 'static>( input: &T) { + println!( "'static value passed in is: {:?}", input ); +} + +fn main() { + // i is owned and contains no references, thus it's 'static: + let i = 5; + print_it(i); + + // oops, &i only has the lifetime defined by the scope of + // main(), so it's not 'static: + print_it(&i); + + print_it1(&i); + + // but this one WORKS ! + print_it2(&i); +}
-
+
- 🌟🌟🌟 +
+use std::fmt::Display; + +fn main() { + let mut string = "First".to_owned(); + + string.push_str(string.to_uppercase().as_str()); + print_a(&string); + print_b(&string); + print_c(&string); // Compilation error + print_d(&string); // Compilation error + print_e(&string); + print_f(&string); + print_g(&string); // Compilation error +} + +fn print_a<T: Display + 'static>(t: &T) { + println!("{}", t); +} + +fn print_b<T>(t: &T) +where + T: Display + 'static, +{ + println!("{}", t); +} + +fn print_c(t: &'static dyn Display) { + println!("{}", t) +} + +fn print_d(t: &'static impl Display) { + println!("{}", t) +} + +fn print_e(t: &(dyn Display + 'static)) { + println!("{}", t) +} + +fn print_f(t: &(impl Display + 'static)) { + println!("{}", t) +} + +fn print_g(t: &'static String) { + println!("{}", t); +}
++ + +You can find the solutions here(under the solutions path), but only use it when you need it :)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/mark.min.js b/mark.min.js
new file mode 100644
index 000000000..163623188
--- /dev/null
+++ b/mark.min.js
@@ -0,0 +1,7 @@
+/*!***************************************************
+* mark.js v8.11.1
+* https://markjs.io/
+* Copyright (c) 2014–2018, Julian Kühnel
+* Released under the MIT license https://git.io/vwTVl
+*****************************************************/
+!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?module.exports=t():"function"==typeof define&&define.amd?define(t):e.Mark=t()}(this,function(){"use strict";var e="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e},t=function(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")},n=function(){function e(e,t){for(var n=0;n
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ macro
+ + +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/mode-rust.js b/mode-rust.js
new file mode 100644
index 000000000..efe35baeb
--- /dev/null
+++ b/mode-rust.js
@@ -0,0 +1,7 @@
+ace.define("ace/mode/rust_highlight_rules",["require","exports","module","ace/lib/oop","ace/mode/text_highlight_rules"],function(e,t,n){"use strict";var r=e("../lib/oop"),i=e("./text_highlight_rules").TextHighlightRules,s=/\\(?:[nrt0'"\\]|x[\da-fA-F]{2}|u\{[\da-fA-F]{6}\})/.source,o=function(){this.$rules={start:[{token:"variable.other.source.rust",regex:"'[a-zA-Z_][a-zA-Z0-9_]*(?![\\'])"},{token:"string.quoted.single.source.rust",regex:"'(?:[^'\\\\]|"+s+")'"},{token:"identifier",regex:/r#[a-zA-Z_][a-zA-Z0-9_]*\b/},{stateName:"bracketedComment",onMatch:function(e,t,n){return n.unshift(this.next,e.length-1,t),"string.quoted.raw.source.rust"},regex:/r#*"/,next:[{onMatch:function(e,t,n){var r="string.quoted.raw.source.rust";return e.length>=n[1]?(e.length>n[1]&&(r="invalid"),n.shift(),n.shift(),this.next=n.shift()):this.next="",r},regex:/"#*/,next:"start"},{defaultToken:"string.quoted.raw.source.rust"}]},{token:"string.quoted.double.source.rust",regex:'"',push:[{token:"string.quoted.double.source.rust",regex:'"',next:"pop"},{token:"constant.character.escape.source.rust",regex:s},{defaultToken:"string.quoted.double.source.rust"}]},{token:["keyword.source.rust","text","entity.name.function.source.rust"],regex:"\\b(fn)(\\s+)((?:r#)?[a-zA-Z_][a-zA-Z0-9_]*)"},{token:"support.constant",regex:"\\b[a-zA-Z_][\\w\\d]*::"},{token:"keyword.source.rust",regex:"\\b(?:abstract|alignof|as|become|box|break|catch|continue|const|crate|default|do|dyn|else|enum|extern|for|final|if|impl|in|let|loop|macro|match|mod|move|mut|offsetof|override|priv|proc|pub|pure|ref|return|self|sizeof|static|struct|super|trait|type|typeof|union|unsafe|unsized|use|virtual|where|while|yield)\\b"},{token:"storage.type.source.rust",regex:"\\b(?:Self|isize|usize|char|bool|u8|u16|u32|u64|u128|f16|f32|f64|i8|i16|i32|i64|i128|str|option|either|c_float|c_double|c_void|FILE|fpos_t|DIR|dirent|c_char|c_schar|c_uchar|c_short|c_ushort|c_int|c_uint|c_long|c_ulong|size_t|ptrdiff_t|clock_t|time_t|c_longlong|c_ulonglong|intptr_t|uintptr_t|off_t|dev_t|ino_t|pid_t|mode_t|ssize_t)\\b"},{token:"variable.language.source.rust",regex:"\\bself\\b"},{token:"comment.line.doc.source.rust",regex:"//!.*$"},{token:"comment.line.double-dash.source.rust",regex:"//.*$"},{token:"comment.start.block.source.rust",regex:"/\\*",stateName:"comment",push:[{token:"comment.start.block.source.rust",regex:"/\\*",push:"comment"},{token:"comment.end.block.source.rust",regex:"\\*/",next:"pop"},{defaultToken:"comment.block.source.rust"}]},{token:"keyword.operator",regex:/\$|[-=]>|[-+%^=!&|<>]=?|[*/](?![*/])=?/},{token:"punctuation.operator",regex:/[?:,;.]/},{token:"paren.lparen",regex:/[\[({]/},{token:"paren.rparen",regex:/[\])}]/},{token:"constant.language.source.rust",regex:"\\b(?:true|false|Some|None|Ok|Err)\\b"},{token:"support.constant.source.rust",regex:"\\b(?:EXIT_FAILURE|EXIT_SUCCESS|RAND_MAX|EOF|SEEK_SET|SEEK_CUR|SEEK_END|_IOFBF|_IONBF|_IOLBF|BUFSIZ|FOPEN_MAX|FILENAME_MAX|L_tmpnam|TMP_MAX|O_RDONLY|O_WRONLY|O_RDWR|O_APPEND|O_CREAT|O_EXCL|O_TRUNC|S_IFIFO|S_IFCHR|S_IFBLK|S_IFDIR|S_IFREG|S_IFMT|S_IEXEC|S_IWRITE|S_IREAD|S_IRWXU|S_IXUSR|S_IWUSR|S_IRUSR|F_OK|R_OK|W_OK|X_OK|STDIN_FILENO|STDOUT_FILENO|STDERR_FILENO)\\b"},{token:"meta.preprocessor.source.rust",regex:"\\b\\w\\(\\w\\)*!|#\\[[\\w=\\(\\)_]+\\]\\b"},{token:"constant.numeric.source.rust",regex:/\b(?:0x[a-fA-F0-9_]+|0o[0-7_]+|0b[01_]+|[0-9][0-9_]*(?!\.))(?:[iu](?:size|8|16|32|64|128))?\b/},{token:"constant.numeric.source.rust",regex:/\b(?:[0-9][0-9_]*)(?:\.[0-9][0-9_]*)?(?:[Ee][+-][0-9][0-9_]*)?(?:f32|f64)?\b/}]},this.normalizeRules()};o.metaData={fileTypes:["rs","rc"],foldingStartMarker:"^.*\\bfn\\s*(\\w+\\s*)?\\([^\\)]*\\)(\\s*\\{[^\\}]*)?\\s*$",foldingStopMarker:"^\\s*\\}",name:"Rust",scopeName:"source.rust"},r.inherits(o,i),t.RustHighlightRules=o}),ace.define("ace/mode/folding/cstyle",["require","exports","module","ace/lib/oop","ace/range","ace/mode/folding/fold_mode"],function(e,t,n){"use strict";var r=e("../../lib/oop"),i=e("../../range").Range,s=e("./fold_mode").FoldMode,o=t.FoldMode=function(e){e&&(this.foldingStartMarker=new RegExp(this.foldingStartMarker.source.replace(/\|[^|]*?$/,"|"+e.start)),this.foldingStopMarker=new RegExp(this.foldingStopMarker.source.replace(/\|[^|]*?$/,"|"+e.end)))};r.inherits(o,s),function(){this.foldingStartMarker=/([\{\[\(])[^\}\]\)]*$|^\s*(\/\*)/,this.foldingStopMarker=/^[^\[\{\(]*([\}\]\)])|^[\s\*]*(\*\/)/,this.singleLineBlockCommentRe=/^\s*(\/\*).*\*\/\s*$/,this.tripleStarBlockCommentRe=/^\s*(\/\*\*\*).*\*\/\s*$/,this.startRegionRe=/^\s*(\/\*|\/\/)#?region\b/,this._getFoldWidgetBase=this.getFoldWidget,this.getFoldWidget=function(e,t,n){var r=e.getLine(n);if(this.singleLineBlockCommentRe.test(r)&&!this.startRegionRe.test(r)&&!this.tripleStarBlockCommentRe.test(r))return"";var i=this._getFoldWidgetBase(e,t,n);return!i&&this.startRegionRe.test(r)?"start":i},this.getFoldWidgetRange=function(e,t,n,r){var i=e.getLine(n);if(this.startRegionRe.test(i))return this.getCommentRegionBlock(e,i,n);var s=i.match(this.foldingStartMarker);if(s){var o=s.index;if(s[1])return this.openingBracketBlock(e,s[1],n,o);var u=e.getCommentFoldRange(n,o+s[0].length,1);return u&&!u.isMultiLine()&&(r?u=this.getSectionRange(e,n):t!="all"&&(u=null)),u}if(t==="markbegin")return;var s=i.match(this.foldingStopMarker);if(s){var o=s.index+s[0].length;return s[1]?this.closingBracketBlock(e,s[1],n,o):e.getCommentFoldRange(n,o,-1)}},this.getSectionRange=function(e,t){var n=e.getLine(t),r=n.search(/\S/),s=t,o=n.length;t+=1;var u=t,a=e.getLength();while(++t
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Multiple
+
+
+
+
+ Associated functions & Methods
+Examples
++struct Point { + x: f64, + y: f64, +} + +// Implementation block, all `Point` associated functions & methods go in here. +impl Point { + // This is an "associated function" because this function is associated with + // a particular type, that is, Point. + // + // Associated functions don't need to be called with an instance. + // These functions are generally used like constructors. + fn origin() -> Point { + Point { x: 0.0, y: 0.0 } + } + + // Another associated function, taking two arguments: + fn new(x: f64, y: f64) -> Point { + Point { x: x, y: y } + } +} + +struct Rectangle { + p1: Point, + p2: Point, +} + +impl Rectangle { + // This is a method. + // `&self` is sugar for `self: &Self`, where `Self` is the type of the + // caller object. In this case `Self` = `Rectangle` + fn area(&self) -> f64 { + // `self` gives access to the struct fields via the dot operator. + let Point { x: x1, y: y1 } = self.p1; + let Point { x: x2, y: y2 } = self.p2; + + // `abs` is a `f64` method that returns the absolute value of the + // caller + ((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()) + } + + // This method requires the caller object to be mutable + // `&mut self` desugars to `self: &mut Self` + fn translate(&mut self, x: f64, y: f64) { + self.p1.x += x; + self.p2.x += x; + + self.p1.y += y; + self.p2.y += y; + } +} + +// `Pair` owns resources: two heap allocated integers. +struct Pair(Box<i32>, Box<i32>); + +impl Pair { + // This method "consumes" the resources of the caller object + // `self` desugars to `self: Self` + fn destroy(self) { + // Destructure `self` + let Pair(first, second) = self; + + println!("Destroying Pair({}, {})", first, second); + + // `first` and `second` go out of scope and get freed. + } +} + +fn main() { + let rectangle = Rectangle { + // Associated functions are called using double colons + p1: Point::origin(), + p2: Point::new(3.0, 4.0), + }; + + // Methods are called using the dot operator. + // Note that the first argument `&self` is implicitly passed, i.e. + // `rectangle.perimeter()` === `Rectangle::perimeter(&rectangle)` + println!("Rectangle perimeter: {}", rectangle.perimeter()); + println!("Rectangle area: {}", rectangle.area()); + + let mut square = Rectangle { + p1: Point::origin(), + p2: Point::new(1.0, 1.0), + }; + + // Error! `rectangle` is immutable, but this method requires a mutable + // object. + //rectangle.translate(1.0, 0.0); + // TODO ^ Try uncommenting this line + + // Okay! Mutable objects can call mutable methods + square.translate(1.0, 1.0); + + let pair = Pair(Box::new(1), Box::new(2)); + + pair.destroy(); + + // Error! Previous `destroy` call "consumed" `pair` + //pair.destroy(); + // TODO ^ Try uncommenting this line +}
Exercises
+Method
+-
+
- 🌟🌟 Methods are similar to functions: Declare with
fn, have parameters and a return value. Unlike functions, methods are defined within the context of a struct (or an enum or a trait object), and their first parameter is alwaysself, which represents the instance of the struct the method is being called on.
+
+struct Rectangle { + width: u32, + height: u32, +} + +impl Rectangle { + // Complete the area method which return the area of a Rectangle. + fn area +} + +fn main() { + let rect1 = Rectangle { width: 30, height: 50 }; + + assert_eq!(rect1.area(), 1500); + + println!("Success!"); +}
-
+
- 🌟🌟
selfwill take the ownership of current struct instance, however,&selfwill only borrow a reference from the instance.
+
+// Only fill in the blanks, DON'T remove any line! +#[derive(Debug)] +struct TrafficLight { + color: String, +} + +impl TrafficLight { + pub fn show_state(__) { + println!("the current state is {}", __.color); + } +} +fn main() { + let light = TrafficLight{ + color: "red".to_owned(), + }; + // Don't take the ownership of `light` here. + light.show_state(); + // ... Otherwise, there will be an error below + println!("{:?}", light); +}
-
+
- 🌟🌟 The
&selfis actually short forself: &Self. Within animplblock, the typeSelfis an alias for the type that theimplblock is for. Methods must have a parameter namedselfof typeSelffor their first parameter, so Rust lets you abbreviate this with only the nameselfin the first parameter spot.
+
+struct TrafficLight { + color: String, +} + +impl TrafficLight { + // Using `Self` to fill in the blank. + pub fn show_state(__) { + println!("the current state is {}", self.color); + } + + // Fill in the blank, DON'T use any variants of `Self`. + pub fn change_state(__) { + self.color = "green".to_string() + } +} +fn main() { + println!("Success!"); +}
Associated functions
+-
+
- 🌟🌟 All functions defined within an
implblock are called associated functions because they’re associated with the type named after theimpl. We can define associated functions that don’t haveselfas their first parameter (and thus are not methods) because they don’t need an instance of the type to work with.
+
+#[derive(Debug)] +struct TrafficLight { + color: String, +} + +impl TrafficLight { + // 1. Implement an associated function `new`, + // 2. It will return a TrafficLight contains color "red" + // 3. Must use `Self`, DONT use `TrafficLight` in fn signatures or body + pub fn new() + + pub fn get_state(&self) -> &str { + &self.color + } +} + +fn main() { + let light = TrafficLight::new(); + assert_eq!(light.get_state(), "red"); + + println!("Success!"); +}
Multiple impl blocks
+-
+
- 🌟 Each struct is allowed to have multiple impl blocks. +
++struct Rectangle { + width: u32, + height: u32, +} + +// Using multiple `impl` blocks to rewrite the code below. +impl Rectangle { + fn area(&self) -> u32 { + self.width * self.height + } + + fn can_hold(&self, other: &Rectangle) -> bool { + self.width > other.width && self.height > other.height + } +} + + +fn main() { + println!("Success!"); +}
Enums
+-
+
- 🌟🌟🌟 We can also implement methods for enums. +
++#[derive(Debug)] +enum TrafficLightColor { + Red, + Yellow, + Green, +} + +// Implement TrafficLightColor with a method. +impl TrafficLightColor { + +} + +fn main() { + let c = TrafficLightColor::Yellow; + + assert_eq!(c.color(), "yellow"); + + println!("{:?}",c); +}
Practice
+@todo
+++ + +You can find the solutions here(under the solutions path), but only use it when you need it
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/ownership/borrowing.html b/ownership/borrowing.html
new file mode 100644
index 000000000..e45188f15
--- /dev/null
+++ b/ownership/borrowing.html
@@ -0,0 +1,390 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ newtype and Sized
+Newtype
+The orphan rule tells us that we are allowed to implement a trait on a type as long as either the trait or the type are local to our crate.
+The newtype pattern can help us get around this restriction, which involves creating a new type in a tuple struct.
+-
+
- 🌟 +
+use std::fmt; + +/* Define the Wrapper type */ +__; + +// Display is an external trait +impl fmt::Display for Wrapper { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!(f, "[{}]", self.0.join(", ")) + } +} + +fn main() { + // Vec is an external type, so you cannot implement Display trait on Vec type + let w = Wrapper(vec![String::from("hello"), String::from("world")]); + println!("w = {}", w); +}
-
+
- 🌟 Hide the methods of the original type. +
+/* Make it workd */ +struct Meters(u32); + +fn main() { + let i: u32 = 2; + assert_eq!(i.pow(2), 4); + + let n = Meters(i); + // The `pow` method is defined on `u32` type, we can't directly call it + assert_eq!(n.pow(2), 4); +}
-
+
- 🌟🌟 The
newtypeidiom gives compile time guarantees that the right type of value is supplied to a program.
+
+/* Make it work */ +struct Years(i64); + +struct Days(i64); + +impl Years { + pub fn to_days(&self) -> Days { + Days(self.0 * 365) + } +} + + +impl Days { + pub fn to_years(&self) -> Years { + Years(self.0 / 365) + } +} + +// An age verification function that checks age in years, must be given a value of type Years. +fn old_enough(age: &Years) -> bool { + age.0 >= 18 +} + +fn main() { + let age = Years(5); + let age_days = age.to_days(); + println!("Old enough {}", old_enough(&age)); + println!("Old enough {}", old_enough(&age_days)); +}
-
+
- 🌟🌟 +
+use std::ops::Add; +use std::fmt::{self, format}; + +struct Meters(u32); +impl fmt::Display for Meters { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!(f, "There are still {} meters left", self.0) + } +} + +impl Add for Meters { + type Output = Self; + + fn add(self, other: Meters) -> Self { + Self(self.0 + other.0) + } +} +fn main() { + let d = calculate_distance(Meters(10), Meters(20)); + assert_eq!(format!("{}",d), "There are still 30 meters left"); +} + +/* Implement calculate_distance */ +fn calculate_distance
Type alias
+Type alias is important to improve the readability of our code.
++#![allow(unused)] +fn main() { +type Thunk = Box<dyn Fn() + Send + 'static>; + +let f: Thunk = Box::new(|| println!("hi")); + +fn takes_long_type(f: Thunk) { + // --snip-- +} + +fn returns_long_type() -> Thunk { + // --snip-- +} +}
+#![allow(unused)] +fn main() { +type Result<T> = std::result::Result<T, std::io::Error>; +}
And Unlike newtype, type alias don't create new types, so the following code is valid:
++#![allow(unused)] +fn main() { +type Meters = u32; + +let x: u32 = 5; +let y: Meters = 5; + +println!("x + y = {}", x + y); +}
-
+
- 🌟 +
+enum VeryVerboseEnumOfThingsToDoWithNumbers { + Add, + Subtract, +} + +/* Fill in the blank */ +__ + +fn main() { + // We can refer to each variant via its alias, not its long and inconvenient + // name. + let x = Operations::Add; +}
-
+
- 🌟🌟 There are a few preserved aliases in Rust, one of which can be used in
implblocks.
+
+enum VeryVerboseEnumOfThingsToDoWithNumbers { + Add, + Subtract, +} + +impl VeryVerboseEnumOfThingsToDoWithNumbers { + fn run(&self, x: i32, y: i32) -> i32 { + match self { + __::Add => x + y, + __::Subtract => x - y, + } + } +}
DST and unsized type
+These concepts are complicated, so we are not going to explain here, but you can find them in The Book.
+-
+
- 🌟🌟🌟 Array with dynamic length is a Dynamic Sized Type ( DST ), we can't directly use it +
+/* Make it work with const generics */ +fn my_function(n: usize) -> [u32; usize] { + [123; n] +} + +fn main() { + let arr = my_function(); + println!("{:?}",arr); +}
-
+
- 🌟🌟 Slice is unsized type, but the reference of slice is not. +
+/* Make it work with slice references */ +fn main() { + let s: str = "Hello there!"; + + let arr: [u8] = [1, 2, 3]; +}
-
+
- 🌟🌟 Trait is also an unsized type +
+ + +/* Make it work in two ways */ +use std::fmt::Display; +fn foobar(thing: Display) {} + +fn main() { +}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/ownership/intro.html b/ownership/intro.html
new file mode 100644
index 000000000..46877dd3b
--- /dev/null
+++ b/ownership/intro.html
@@ -0,0 +1,221 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Reference and Borrowing
+Reference
+-
+
- 🌟 +
++fn main() { + let x = 5; + // Fill the blank + let p = __; + + println!("the memory address of x is {:p}", p); // One possible output: 0x16fa3ac84 +}
-
+
- 🌟 +
++fn main() { + let x = 5; + let y = &x; + + // Modify this line only + assert_eq!(5, y); + + println!("Success!"); +}
-
+
- 🌟 +
++// Fix error +fn main() { + let mut s = String::from("hello, "); + + borrow_object(s); + + println!("Success!"); +} + +fn borrow_object(s: &String) {}
-
+
- 🌟 +
++// Fix error +fn main() { + let mut s = String::from("hello, "); + + push_str(s); + + println!("Success!"); +} + +fn push_str(s: &mut String) { + s.push_str("world") +}
-
+
- 🌟🌟 +
++fn main() { + let mut s = String::from("hello, "); + + // Fill the blank to make it work + let p = __; + + p.push_str("world"); + + println!("Success!"); +}
Ref
+ref can be used to take references to a value, similar to &.
-
+
- 🌟🌟🌟 +
++fn main() { + let c = '中'; + + let r1 = &c; + // Fill the blank，dont change other code + let __ r2 = c; + + assert_eq!(*r1, *r2); + + // Check the equality of the two address strings + assert_eq!(get_addr(r1),get_addr(r2)); + + println!("Success!"); +} + +// Get memory address string +fn get_addr(r: &char) -> String { + format!("{:p}", r) +}
Borrowing rules
+-
+
- 🌟 +
++// Remove something to make it work +// Don't remove a whole line ! +fn main() { + let mut s = String::from("hello"); + + let r1 = &mut s; + let r2 = &mut s; + + println!("{}, {}", r1, r2); + + println!("Success!"); +}
Mutability
+-
+
- 🌟 Error: Borrow an immutable object as mutable +
++fn main() { + // Fix error by modifying this line + let s = String::from("hello, "); + + borrow_object(&mut s); + + println!("Success!"); +} + +fn borrow_object(s: &mut String) {}
-
+
- 🌟🌟 Ok: Borrow a mutable object as immutable +
++// This code has no errors! +fn main() { + let mut s = String::from("hello, "); + + borrow_object(&s); + + s.push_str("world"); + + println!("Success!"); +} + +fn borrow_object(s: &String) {}
NLL
+-
+
- 🌟🌟 +
++// Comment one line to make it work +fn main() { + let mut s = String::from("hello, "); + + let r1 = &mut s; + r1.push_str("world"); + let r2 = &mut s; + r2.push_str("!"); + + println!("{}",r1); +}
-
+
- 🌟🌟 +
++fn main() { + let mut s = String::from("hello, "); + + let r1 = &mut s; + let r2 = &mut s; + + // Add one line below to make a compiler error: cannot borrow `s` as mutable more than once at a time + // You can't use r1 and r2 at the same time +}
++ + +You can find the solutions here(under the solutions path), but only use it when you need it
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/ownership/ownership.html b/ownership/ownership.html
new file mode 100644
index 000000000..de691537c
--- /dev/null
+++ b/ownership/ownership.html
@@ -0,0 +1,369 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Ownership and Borrowing
+Learning resources:
+-
+
- English: Rust Book 4.1-4.4 +
- 简体中文: Rust语言圣经 - 所有权与借用 +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/pattern-match/intro.html b/pattern-match/intro.html
new file mode 100644
index 000000000..32b8c5ce2
--- /dev/null
+++ b/pattern-match/intro.html
@@ -0,0 +1,221 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Ownership
+-
+
- 🌟🌟 +
++fn main() { + // Use as many approaches as you can to make it work + let x = String::from("Hello world"); + let y = x; + println!("{}, {}",x, y); +}
-
+
- 🌟🌟 +
+// Don't modify code in main! +fn main() { + let s1 = String::from("Hello world"); + let s2 = take_ownership(s1); + + println!("{}", s2); +} + +// Only modify the code below! +fn take_ownership(s: String) { + println!("{}", s); +}
-
+
- 🌟🌟 +
++fn main() { + let s = give_ownership(); + println!("{}", s); +} + +// Only modify the code below! +fn give_ownership() -> String { + let s = String::from("Hello world"); + // Convert String to Vec + let _s = s.into_bytes(); + s +}
-
+
- 🌟🌟 +
+// Fix the error without removing any code +fn main() { + let s = String::from("Hello World"); + + print_str(s); + + println!("{}", s); +} + +fn print_str(s: String) { + println!("{}",s) +}
-
+
- 🌟🌟 +
+// Don't use clone ,use copy instead +fn main() { + let x = (1, 2, (), "hello".to_string()); + let y = x.clone(); + println!("{:?}, {:?}", x, y); +}
Mutability
+Mutability can be changed when ownership is transferred.
+-
+
- 🌟 +
++// make the necessary variable mutable +fn main() { + let s = String::from("Hello "); + + let s1 = s; + + s1.push_str("World!"); + + println!("Success!"); +}
-
+
- 🌟🌟🌟 +
++fn main() { + let x = Box::new(5); + + let ... // update this line, don't change other lines! + + *y = 4; + + assert_eq!(*x, 5); + + println!("Success!"); +}
Partial move
+Within the destructuring of a single variable, both by-move and by-reference pattern bindings can be used at the same time. Doing this will result in a partial move of the variable, which means that parts of the variable will be moved while other parts stay. In such a case, the parent variable cannot be used afterwards as a whole, however the parts that are only referenced (and not moved) can still be used.
+Example
+++fn main() { + #[derive(Debug)] + struct Person { + name: String, + age: Box<u8>, + } + + let person = Person { + name: String::from("Alice"), + age: Box::new(20), + }; + + // `name` is moved out of person, but `age` is referenced + let Person { name, ref age } = person; + + println!("The person's age is {}", age); + + println!("The person's name is {}", name); + + // Error! borrow of partially moved value: `person` partial move occurs + //println!("The person struct is {:?}", person); + + // `person` cannot be used but `person.age` can be used as it is not moved + println!("The person's age from person struct is {}", person.age); +}
Exercises
+-
+
- 🌟 +
++fn main() { + let t = (String::from("hello"), String::from("world")); + + let _s = t.0; + + // Modify this line only, don't use `_s` + println!("{:?}", t); +}
-
+
- 🌟🌟 +
++fn main() { + let t = (String::from("hello"), String::from("world")); + + // Fill the blanks + let (__, __) = __; + + println!("{:?}, {:?}, {:?}", s1, s2, t); // -> "hello", "world", ("hello", "world") +}
++ + +You can find the solutions here(under the solutions path), but only use it when you need it
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/pattern-match/match-iflet.html b/pattern-match/match-iflet.html
new file mode 100644
index 000000000..6521b3c2d
--- /dev/null
+++ b/pattern-match/match-iflet.html
@@ -0,0 +1,414 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Pattern Match
+Learning resources:
+-
+
- English: Rust Book 18 +
- 简体中文: Rust语言圣经 - 模式匹配 +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/pattern-match/patterns.html b/pattern-match/patterns.html
new file mode 100644
index 000000000..a173e6a1c
--- /dev/null
+++ b/pattern-match/patterns.html
@@ -0,0 +1,328 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Match, if let
+Match
+-
+
- 🌟🌟 +
++// Fill the blanks +enum Direction { + East, + West, + North, + South, +} + +fn main() { + let dire = Direction::South; + match dire { + Direction::East => println!("East"), + __ => { // Matching South or North here + println!("South or North"); + }, + _ => println!(__), + }; +}
-
+
- 🌟🌟 Match is an expression, so we can use it in assignments. +
++fn main() { + let boolean = true; + + // Fill the blank with a match expression: + // + // boolean = true => binary = 1 + // boolean = false => binary = 0 + let binary = __; + + assert_eq!(binary, 1); + + println!("Success!"); +}
-
+
- 🌟🌟 Using match to get the data an enum variant holds. +
++// Fill in the blanks +enum Message { + Quit, + Move { x: i32, y: i32 }, + Write(String), + ChangeColor(i32, i32, i32), +} + +fn main() { + let msgs = [ + Message::Quit, + Message::Move{x:1, y:3}, + Message::ChangeColor(255,255,0) + ]; + + for msg in msgs { + show_message(msg) + } + + println!("Success!"); +} + +fn show_message(msg: Message) { + match msg { + __ => { // match Message::Move + assert_eq!(a, 1); + assert_eq!(b, 3); + }, + Message::ChangeColor(_, g, b) => { + assert_eq!(g, __); + assert_eq!(b, __); + } + __ => println!("no data in these variants") + } +}
matches!
+matches! looks like match, but can do something different.
-
+
- 🌟🌟 +
++fn main() { + let alphabets = ['a', 'E', 'Z', '0', 'x', '9' , 'Y']; + + // Fill the blank with `matches!` to make the code work + for ab in alphabets { + assert!(__) + } + + println!("Success!"); +}
-
+
- 🌟🌟 +
++enum MyEnum { + Foo, + Bar +} + +fn main() { + let mut count = 0; + + let v = vec![MyEnum::Foo,MyEnum::Bar,MyEnum::Foo]; + for e in v { + if e == MyEnum::Foo { // Fix the error by changing only this line + count += 1; + } + } + + assert_eq!(count, 2); + + println!("Success!"); +}
If let
+For some cases, when matching enums, match is too heavy. We can use if let instead.
-
+
- 🌟 +
++fn main() { + let o = Some(7); + + // Remove the whole `match` block, using `if let` instead + match o { + Some(i) => { + println!("This is a really long string and `{:?}`", i); + + println!("Success!"); + } + _ => {} + }; +}
-
+
- 🌟🌟 +
++// Fill in the blank +enum Foo { + Bar(u8) +} + +fn main() { + let a = Foo::Bar(1); + + __ { + println!("foobar holds the value: {}", i); + + println!("Success!"); + } +}
-
+
- 🌟🌟 +
++enum Foo { + Bar, + Baz, + Qux(u32) +} + +fn main() { + let a = Foo::Qux(10); + + // Remove the codes below, using `match` instead + if let Foo::Bar = a { + println!("match foo::bar") + } else if let Foo::Baz = a { + println!("match foo::baz") + } else { + println!("match others") + } +}
Shadowing
+-
+
- 🌟🌟 +
++// Fix the errors in-place +fn main() { + let age = Some(30); + if let Some(age) = age { // Create a new variable with the same name as previous `age` + assert_eq!(age, Some(30)); + } // The new variable `age` goes out of scope here + + match age { + // Match can also introduce a new shadowed variable + Some(age) => println!("age is a new variable, it's value is {}",age), + _ => () + } + }
++ + +You can find the solutions here(under the solutions path), but only use it when you need it
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/print.html b/print.html
new file mode 100644
index 000000000..37dad6867
--- /dev/null
+++ b/print.html
@@ -0,0 +1,8592 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Patterns
+-
+
- 🌟🌟 Use
|to match several values, use..=to match an inclusive range.
+
++fn main() {} +fn match_number(n: i32) { + match n { + // Match a single value + 1 => println!("One!"), + // Fill in the blank with `|`, DON'T use `..` or `..=` + __ => println!("match 2 -> 5"), + // Match an inclusive range + 6..=10 => { + println!("match 6 -> 10") + }, + _ => { + println!("match -infinite -> 0 or 11 -> +infinite") + } + } +}
-
+
- 🌟🌟🌟 The
@operator lets us create a variable that holds a value, at the same time we are testing that value to see whether it matches a pattern.
+
++struct Point { + x: i32, + y: i32, +} + +fn main() { + // Fill in the blank to let p match the second arm + let p = Point { x: __, y: __ }; + + match p { + Point { x, y: 0 } => println!("On the x axis at {}", x), + // Second arm + Point { x: 0..=5, y: y@ (10 | 20 | 30) } => println!("On the y axis at {}", y), + Point { x, y } => println!("On neither axis: ({}, {})", x, y), + } +}
-
+
- 🌟🌟🌟 +
++// Fix the errors +enum Message { + Hello { id: i32 }, +} + +fn main() { + let msg = Message::Hello { id: 5 }; + + match msg { + Message::Hello { + id: 3..=7, + } => println!("Found an id in range [3, 7]: {}", id), + Message::Hello { id: newid@10 | 11 | 12 } => { + println!("Found an id in another range [10, 12]: {}", newid) + } + Message::Hello { id } => println!("Found some other id: {}", id), + } +}
-
+
- 🌟🌟 A match guard is an additional if condition specified after the pattern in a match arm that must also match, along with the pattern matching, for that arm to be chosen. +
++// Fill in the blank to make the code work, `split` MUST be used +fn main() { + let num = Some(4); + let split = 5; + match num { + Some(x) __ => assert!(x < split), + Some(x) => assert!(x >= split), + None => (), + } + + println!("Success!"); +}
-
+
- 🌟🌟 Ignoring remaining parts of the value with
..
+
++// Fill the blank to make the code work +fn main() { + let numbers = (2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048); + + match numbers { + __ => { + assert_eq!(first, 2); + assert_eq!(last, 2048); + } + } + + println!("Success!"); +}
-
+
- 🌟🌟 Using pattern
&mut Vto match a mutable reference requires you to be very careful, due toVbeing a value after matching.
+
++// FIX the error with least changing +// DON'T remove any code line +fn main() { + let mut v = String::from("hello,"); + let r = &mut v; + + match r { + &mut value => value.push_str(" world!") + } +}
++ + +You can find the solutions here(under the solutions path), but only use it when you need it
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/result-panic/intro.html b/result-panic/intro.html
new file mode 100644
index 000000000..ed7f912d2
--- /dev/null
+++ b/result-panic/intro.html
@@ -0,0 +1,221 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Multiple
+Struct and
+
+Convert by
+Implement
+
+Using Result in
+Re-exporting names with
+Line doc comments
+Block doc comments
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Practice Rust with challenging examples, exercises and projects
+
+
+
+
This book was designed for easily diving into and getting skilled with Rust, and it's very easy to use: All you need to do is to make each exercise compile without ERRORS and Panics !
+Reading online
+ +Running locally
+We use mdbook building our exercises. You can run locally with below steps:
+$ git clone git@github.com:sunface/rust-by-practice.git
+$ cargo install mdbook
+$ cd rust-by-practice && mdbook serve en/
+Features
+Part of our examples and exercises are borrowed from Rust By Example, thanks for your great works!
+Although they are so awesome, we have our own secret weapons :)
+-
+
-
+
There are three parts in each chapter: examples, exercises and practices
+
+ -
+
Besides examples, we have
+a lot of exercises, you can Read, Edit and Run them ONLINE
+ -
+
Covering nearly all aspects of Rust, such as async/await, threads, sync primitives, optimizing, standard libraries, tool chain, data structures and algorithms etc.
+
+ -
+
Every exercise has its own solutions
+
+ -
+
The overall difficulties are a bit higher and from easy to super hard: easy 🌟 medium 🌟🌟 hard 🌟🌟🌟 super hard 🌟🌟🌟🌟
+
+
What we want to do is fill in the gap between learning and getting started with real projects.
+Small projects with Elegant code base
+Following questions come up weekly in online Rust discussions:
+-
+
- I just finished reading The Book, what should I do next ? +
- What projects would you recommend to a Rust beginner? +
- Looking for small projects with an elegant code base +
- Codes that is easy to read and learn +
The answers to these questions are always Practice: doing some exercises, and then reading some small and excellent Rust projects.
+This is precisely the goal of this book, so, collecting relative resourses and representing in Rust By Practice seems not a bad idea.
+1. Ripgrep
+Answers for above questions usually came with ripgrep, though I don't think it is a small project, but yes, go for it if you are not afraid to delve deep a bit.
2. Building a text editor
+Tutorial https://www.flenker.blog/hecto/ will lead you to build a text editor from scratch.
3. Ncspot
+Ncspot, a terminal Spotify client. Small, simple, well organized and async, it's good for learning.
+4. Command Line Rust
+This project is for the book Command-Line Rust(O'Reily), it will show you how to write small CLIs (clones of head, cat, ls).
5. pngme book
+This book will guide you to make a command line program that lets you hide secret messages in PNG files. The primary goal here is to get you writing code. The secondary goal is to get you reading documentation.
+6. Writing an OS in Rust
+This blog series creates a small operating system in the Rust programming language. Each post is a small tutorial and includes all needed code, so you can follow along if you like. The source code is also available in the corresponding Github repository.
+7. CodeCrafters.io: Build your own Git, Docker, SQLite, or Redis
+On CodeCrafters, you can recreate your favorite developer tools from scratch. It's a hands-on, minimally-guided approach to master Rust, while appreciating the internals and documentation of popular technology that we use every day.
+8. mini-redis
+mini-redis is an incomplete Redis client and server implementation using tokio, it has decent code base and detail explanations, very suitable for learning Rust and asynchronous programming.
+9. Writing Interpreters in Rust
+This online book will walk through the basics of interpreted language implementation in Rust with a focus on the challenges that are specific to using Rust.
++
To be continued...
+Variables
+Binding and mutability
+-
+
- 🌟 A variable can be used only if it has been initialized. +
++// Fix the error below with least amount of modification to the code +fn main() { + let x: i32; // Uninitialized but used, ERROR ! + let y: i32; // Uninitialized but also unused, only a Warning ! + + assert_eq!(x, 5); + println!("Success!"); +}
-
+
- 🌟 Use
mutto mark a variable as mutable.
+
++// Fill the blanks in the code to make it compile +fn main() { + let __ __ = 1; + __ += 2; + + assert_eq!(x, 3); + println!("Success!"); +}
Scope
+A scope is the range within the program for which the item is valid.
+-
+
- 🌟 +
++// Fix the error below with least amount of modification +fn main() { + let x: i32 = 10; + { + let y: i32 = 5; + println!("The value of x is {} and value of y is {}", x, y); + } + println!("The value of x is {} and value of y is {}", x, y); +}
-
+
- 🌟🌟 +
++// Fix the error with the use of define_x +fn main() { + println!("{}, world", x); +} + +fn define_x() { + let x = "hello"; +}
Shadowing
+You can declare a new variable with the same name as a previous variable, here we can say the first one is shadowed by the second one.
+-
+
- 🌟🌟 +
++// Only modify `assert_eq!` to make the `println!` work(print `42` in terminal) +fn main() { + let x: i32 = 5; + { + let x = 12; + assert_eq!(x, 5); + } + + assert_eq!(x, 12); + + let x = 42; + println!("{}", x); // Prints "42". +}
-
+
- 🌟🌟 +
++// Remove a line in the code to make it compile +fn main() { + let mut x: i32 = 1; + x = 7; + // Shadowing and re-binding + let x = x; + x += 3; + + + let y = 4; + // Shadowing + let y = "I can also be bound to text!"; + + println!("Success!"); +}
Unused variables
+-
+
- Fix the warning below with : +
-
+
- 🌟 Only one solution +
- 🌟🌟 Two distinct solutions +
++Note: none of the solutions is to remove the line
+let x = 1
++fn main() { + let x = 1; +} + +// Warning: unused variable: `x`
Destructuring
+-
+
- 🌟🌟 We can use a pattern with
letto destructure a tuple to separate variables.
+
++Tips: you can use Shadowing or Mutability
+
++// Fix the error below with least amount of modification +fn main() { + let (x, y) = (1, 2); + x += 2; + + assert_eq!(x, 3); + assert_eq!(y, 2); + + println!("Success!"); +}
Destructuring assignments
+Introduced in Rust 1.59: You can now use tuple, slice, and struct patterns as the left-hand side of an assignment.
+-
+
- 🌟🌟 +
++Note: the feature
+Destructuring assignmentsneed 1.59 or higher Rust version
++fn main() { + let (x, y); + (x,..) = (3, 4); + [.., y] = [1, 2]; + // Fill the blank to make the code work + assert_eq!([x,y], __); + + println!("Success!"); +}
++You can find the solutions here(under the solutions path), but only use it when you need it
+
Basic Types
+Learning resources:
+-
+
- English: Rust Book 3.2 and 3.3 +
- 简体中文: Rust语言圣经 - 基本类型 +
Numbers
+Integer
+-
+
- 🌟 +
++Tips: If we don't explicitly assign a type to a variable, then the compiler will infer one for us.
+
++// Remove something to make it work +fn main() { + let x: i32 = 5; + let mut y: u32 = 5; + + y = x; + + let z = 10; // Type of z ? + + println!("Success!"); +}
-
+
- 🌟 +
++// Fill the blank +fn main() { + let v: u16 = 38_u8 as __; + + println!("Success!"); +}
-
+
- 🌟🌟🌟 +
++Tips: If we don't explicitly assign a type to a variable, then the compiler will infer one for us.
+
++// Modify `assert_eq!` to make it work +fn main() { + let x = 5; + assert_eq!("u32".to_string(), type_of(&x)); + + println!("Success!"); +} + +// Get the type of given variable, return a string representation of the type , e.g "i8", "u8", "i32", "u32" +fn type_of<T>(_: &T) -> String { + format!("{}", std::any::type_name::<T>()) +}
-
+
- 🌟🌟 +
++// Fill the blanks to make it work +fn main() { + assert_eq!(i8::MAX, __); + assert_eq!(u8::MAX, __); + + println!("Success!"); +}
-
+
- 🌟🌟 +
++// Fix errors and panics to make it work +fn main() { + let v1 = 251_u8 + 8; + let v2 = i8::checked_add(251, 8).unwrap(); + println!("{},{}",v1,v2); +}
-
+
- 🌟🌟 +
++// Modify `assert!` to make it work +fn main() { + let v = 1_024 + 0xff + 0o77 + 0b1111_1111; + assert!(v == 1579); + + println!("Success!"); +}
Floating-Point
+-
+
- 🌟 +
++// Fill the blank to make it work +fn main() { + let x = 1_000.000_1; // ? + let y: f32 = 0.12; // f32 + let z = 0.01_f64; // f64 + + assert_eq!(type_of(&x), "__".to_string()); + println!("Success!"); +} + +fn type_of<T>(_: &T) -> String { + format!("{}", std::any::type_name::<T>()) +}
-
+
- 🌟🌟 Make it work in two distinct ways +
++fn main() { + assert!(0.1+0.2==0.3); + + println!("Success!"); +}
Range
+-
+
- 🌟🌟 Two goals: 1. Modify
assert!to make it work 2. Makeprintln!output: 97 - 122
+
+fn main() { + let mut sum = 0; + for i in -3..2 { + sum += i + } + + assert!(sum == -3); + + for c in 'a'..='z' { + println!("{}",c); + } +}
-
+
- 🌟🌟 +
++// Fill the blanks +use std::ops::{Range, RangeInclusive}; +fn main() { + assert_eq!((1..__), Range{ start: 1, end: 5 }); + assert_eq!((1..__), RangeInclusive::new(1, 5)); + + println!("Success!"); +}
Computations
+-
+
- 🌟 +
++// Fill the blanks and fix the errors +fn main() { + // Integer addition + assert!(1u32 + 2 == __); + + // Integer subtraction + assert!(1i32 - 2 == __); + assert!(1u8 - 2 == -1); + + assert!(3 * 50 == __); + + assert!(9.6 / 3.2 == 3.0); // error ! make it work + + assert!(24 % 5 == __); + // Short-circuiting boolean logic + assert!(true && false == __); + assert!(true || false == __); + assert!(!true == __); + + // Bitwise operations + println!("0011 AND 0101 is {:04b}", 0b0011u32 & 0b0101); + println!("0011 OR 0101 is {:04b}", 0b0011u32 | 0b0101); + println!("0011 XOR 0101 is {:04b}", 0b0011u32 ^ 0b0101); + println!("1 << 5 is {}", 1u32 << 5); + println!("0x80 >> 2 is 0x{:x}", 0x80u32 >> 2); +}
++You can find the solutions here(under the solutions path), but only use it when you need it
+
Char, Bool and Unit
+Char
+-
+
- 🌟 +
++// Make it work +use std::mem::size_of_val; +fn main() { + let c1 = 'a'; + assert_eq!(size_of_val(&c1),1); + + let c2 = '中'; + assert_eq!(size_of_val(&c2),3); + + println!("Success!"); +}
-
+
- 🌟 +
++// Make it work +fn main() { + let c1 = "中"; + print_char(c1); +} + +fn print_char(c : char) { + println!("{}", c); +}
Bool
+-
+
- 🌟 +
++// Make println! work +fn main() { + let _f: bool = false; + + let t = true; + if !t { + println!("Success!"); + } +}
-
+
- 🌟 +
++// Make it work +fn main() { + let f = true; + let t = true && false; + assert_eq!(t, f); + + println!("Success!"); +}
Unit type
+-
+
- 🌟🌟 +
++// Make it work, don't modify `implicitly_ret_unit` ! +fn main() { + let _v: () = (); + + let v = (2, 3); + assert_eq!(v, implicitly_ret_unit()); + + println!("Success!"); +} + +fn implicitly_ret_unit() { + println!("I will return a ()"); +} + +// Don't use this one +fn explicitly_ret_unit() -> () { + println!("I will return a ()"); +}
-
+
- 🌟🌟 What's the size of the unit type? +
++// Modify `4` in assert to make it work +use std::mem::size_of_val; +fn main() { + let unit: () = (); + assert!(size_of_val(&unit) == 4); + + println!("Success!"); +}
++You can find the solutions here(under the solutions path), but only use it when you need it
+
Statements and Expressions
+Examples
++fn main() { + let x = 5u32; + + let y = { + let x_squared = x * x; + let x_cube = x_squared * x; + + // This expression will be assigned to `y` + x_cube + x_squared + x + }; + + let z = { + // The semicolon suppresses this expression and `()` is assigned to `z` + 2 * x; + }; + + println!("x is {:?}", x); + println!("y is {:?}", y); + println!("z is {:?}", z); +}
Exercises
+-
+
- 🌟🌟 +
+// Make it work with two ways +fn main() { + let v = { + let mut x = 1; + x += 2 + }; + + assert_eq!(v, 3); + + println!("Success!"); +}
-
+
- 🌟 +
++fn main() { + let v = (let x = 3); + + assert!(v == 3); + + println!("Success!"); +}
-
+
- 🌟 +
++fn main() { + let s = sum(1 , 2); + assert_eq!(s, 3); + + println!("Success!"); +} + +fn sum(x: i32, y: i32) -> i32 { + x + y; +}
++You can find the solutions here(under the solutions path), but only use it when you need it
+
Functions
+-
+
- 🌟🌟🌟 +
++fn main() { + // Don't modify the following two lines! + let (x, y) = (1, 2); + let s = sum(x, y); + + assert_eq!(s, 3); + + println!("Success!"); +} + +fn sum(x, y: i32) { + x + y; +}
-
+
- 🌟 +
+fn main() { + print(); +} + +// Replace i32 with another type +fn print() -> i32 { + println!("Success!"); +}
-
+
- 🌟🌟🌟 +
+// Solve it in two ways +// DON'T let `println!` work +fn main() { + never_return(); + + println!("Failed!"); +} + +fn never_return() -> ! { + // Implement this function, don't modify the fn signatures + +}
Diverging functions
+Diverging functions never return to the caller, so they may be used in places where a value of any type is expected.
+-
+
- 🌟🌟 +
++fn main() { + println!("Success!"); +} + +fn get_option(tp: u8) -> Option<i32> { + match tp { + 1 => { + // TODO + } + _ => { + // TODO + } + }; + + // Rather than returning a None, we use a diverging function instead + never_return_fn() +} + +// IMPLEMENT this function in THREE ways +fn never_return_fn() -> ! { + +}
-
+
- 🌟🌟 +
++fn main() { + // FILL in the blank + let b = __; + + let _v = match b { + true => 1, + // Diverging functions can also be used in match expression to replace a value of any value + false => { + println!("Success!"); + panic!("we have no value for `false`, but we can panic"); + } + }; + + println!("Exercise Failed if printing out this line!"); +}
++You can find the solutions here(under the solutions path), but only use it when you need it
+
Ownership and Borrowing
+Learning resources:
+-
+
- English: Rust Book 4.1-4.4 +
- 简体中文: Rust语言圣经 - 所有权与借用 +
Ownership
+-
+
- 🌟🌟 +
++fn main() { + // Use as many approaches as you can to make it work + let x = String::from("Hello world"); + let y = x; + println!("{}, {}",x, y); +}
-
+
- 🌟🌟 +
+// Don't modify code in main! +fn main() { + let s1 = String::from("Hello world"); + let s2 = take_ownership(s1); + + println!("{}", s2); +} + +// Only modify the code below! +fn take_ownership(s: String) { + println!("{}", s); +}
-
+
- 🌟🌟 +
++fn main() { + let s = give_ownership(); + println!("{}", s); +} + +// Only modify the code below! +fn give_ownership() -> String { + let s = String::from("Hello world"); + // Convert String to Vec + let _s = s.into_bytes(); + s +}
-
+
- 🌟🌟 +
+// Fix the error without removing any code +fn main() { + let s = String::from("Hello World"); + + print_str(s); + + println!("{}", s); +} + +fn print_str(s: String) { + println!("{}",s) +}
-
+
- 🌟🌟 +
+// Don't use clone ,use copy instead +fn main() { + let x = (1, 2, (), "hello".to_string()); + let y = x.clone(); + println!("{:?}, {:?}", x, y); +}
Mutability
+Mutability can be changed when ownership is transferred.
+-
+
- 🌟 +
++// make the necessary variable mutable +fn main() { + let s = String::from("Hello "); + + let s1 = s; + + s1.push_str("World!"); + + println!("Success!"); +}
-
+
- 🌟🌟🌟 +
++fn main() { + let x = Box::new(5); + + let ... // update this line, don't change other lines! + + *y = 4; + + assert_eq!(*x, 5); + + println!("Success!"); +}
Partial move
+Within the destructuring of a single variable, both by-move and by-reference pattern bindings can be used at the same time. Doing this will result in a partial move of the variable, which means that parts of the variable will be moved while other parts stay. In such a case, the parent variable cannot be used afterwards as a whole, however the parts that are only referenced (and not moved) can still be used.
+Example
+++fn main() { + #[derive(Debug)] + struct Person { + name: String, + age: Box<u8>, + } + + let person = Person { + name: String::from("Alice"), + age: Box::new(20), + }; + + // `name` is moved out of person, but `age` is referenced + let Person { name, ref age } = person; + + println!("The person's age is {}", age); + + println!("The person's name is {}", name); + + // Error! borrow of partially moved value: `person` partial move occurs + //println!("The person struct is {:?}", person); + + // `person` cannot be used but `person.age` can be used as it is not moved + println!("The person's age from person struct is {}", person.age); +}
Exercises
+-
+
- 🌟 +
++fn main() { + let t = (String::from("hello"), String::from("world")); + + let _s = t.0; + + // Modify this line only, don't use `_s` + println!("{:?}", t); +}
-
+
- 🌟🌟 +
++fn main() { + let t = (String::from("hello"), String::from("world")); + + // Fill the blanks + let (__, __) = __; + + println!("{:?}, {:?}, {:?}", s1, s2, t); // -> "hello", "world", ("hello", "world") +}
++You can find the solutions here(under the solutions path), but only use it when you need it
+
Reference and Borrowing
+Reference
+-
+
- 🌟 +
++fn main() { + let x = 5; + // Fill the blank + let p = __; + + println!("the memory address of x is {:p}", p); // One possible output: 0x16fa3ac84 +}
-
+
- 🌟 +
++fn main() { + let x = 5; + let y = &x; + + // Modify this line only + assert_eq!(5, y); + + println!("Success!"); +}
-
+
- 🌟 +
++// Fix error +fn main() { + let mut s = String::from("hello, "); + + borrow_object(s); + + println!("Success!"); +} + +fn borrow_object(s: &String) {}
-
+
- 🌟 +
++// Fix error +fn main() { + let mut s = String::from("hello, "); + + push_str(s); + + println!("Success!"); +} + +fn push_str(s: &mut String) { + s.push_str("world") +}
-
+
- 🌟🌟 +
++fn main() { + let mut s = String::from("hello, "); + + // Fill the blank to make it work + let p = __; + + p.push_str("world"); + + println!("Success!"); +}
Ref
+ref can be used to take references to a value, similar to &.
-
+
- 🌟🌟🌟 +
++fn main() { + let c = '中'; + + let r1 = &c; + // Fill the blank，dont change other code + let __ r2 = c; + + assert_eq!(*r1, *r2); + + // Check the equality of the two address strings + assert_eq!(get_addr(r1),get_addr(r2)); + + println!("Success!"); +} + +// Get memory address string +fn get_addr(r: &char) -> String { + format!("{:p}", r) +}
Borrowing rules
+-
+
- 🌟 +
++// Remove something to make it work +// Don't remove a whole line ! +fn main() { + let mut s = String::from("hello"); + + let r1 = &mut s; + let r2 = &mut s; + + println!("{}, {}", r1, r2); + + println!("Success!"); +}
Mutability
+-
+
- 🌟 Error: Borrow an immutable object as mutable +
++fn main() { + // Fix error by modifying this line + let s = String::from("hello, "); + + borrow_object(&mut s); + + println!("Success!"); +} + +fn borrow_object(s: &mut String) {}
-
+
- 🌟🌟 Ok: Borrow a mutable object as immutable +
++// This code has no errors! +fn main() { + let mut s = String::from("hello, "); + + borrow_object(&s); + + s.push_str("world"); + + println!("Success!"); +} + +fn borrow_object(s: &String) {}
NLL
+-
+
- 🌟🌟 +
++// Comment one line to make it work +fn main() { + let mut s = String::from("hello, "); + + let r1 = &mut s; + r1.push_str("world"); + let r2 = &mut s; + r2.push_str("!"); + + println!("{}",r1); +}
-
+
- 🌟🌟 +
++fn main() { + let mut s = String::from("hello, "); + + let r1 = &mut s; + let r2 = &mut s; + + // Add one line below to make a compiler error: cannot borrow `s` as mutable more than once at a time + // You can't use r1 and r2 at the same time +}
++You can find the solutions here(under the solutions path), but only use it when you need it
+
Compound Types
+Learning resources:
+-
+
- English: Rust Book 4.3, 5.1, 6.1, 8.2 +
- 简体中文: Rust语言圣经 - 复合类型 +
String
+The type of string literal "hello, world" is &str, e.g let s: &str = "hello, world".
Str and &str
+-
+
- 🌟 We can't use
strtype in normal ways, but we can use&str.
+
++// Fix error without adding new line +fn main() { + let s: str = "hello, world"; + + println!("Success!"); +}
-
+
- 🌟🌟 We can only use
strby boxing it,&can be used to convertBox<str>to&str
+
++// Fix the error with at least two solutions +fn main() { + let s: Box<str> = "hello, world".into(); + greetings(s) +} + +fn greetings(s: &str) { + println!("{}",s) +}
String
+String type is defined in std and stored as a vector of bytes (Vec
-
+
- 🌟 +
++// Fill the blank +fn main() { + let mut s = __; + s.push_str("hello, world"); + s.push('!'); + + assert_eq!(s, "hello, world!"); + + println!("Success!"); +}
-
+
- 🌟🌟🌟 +
++// Fix all errors without adding newline +fn main() { + let s = String::from("hello"); + s.push(','); + s.push(" world"); + s += "!".to_string(); + + println!("{}", s); +}
-
+
- 🌟🌟
replacecan be used to replace substring
+
++// Fill the blank +fn main() { + let s = String::from("I like dogs"); + // Allocate new memory and store the modified string there + let s1 = s.__("dogs", "cats"); + + assert_eq!(s1, "I like cats"); + + println!("Success!"); +}
More String methods can be found under String module.
-
+
- 🌟🌟 You can only concat a
Stringwith&str, andString's ownership can be moved to another variable.
+
++// Fix errors without removing any line +fn main() { + let s1 = String::from("hello,"); + let s2 = String::from("world!"); + let s3 = s1 + s2; + assert_eq!(s3, "hello,world!"); + println!("{}", s1); +}
&str and String
+Opposite to the seldom using of str, &str and String are used everywhere!
-
+
- 🌟🌟
&strcan be converted toStringin two ways
+
++// Fix error with at least two solutions +fn main() { + let s = "hello, world"; + greetings(s) +} + +fn greetings(s: String) { + println!("{}", s) +}
-
+
- 🌟🌟 We can use
String::fromorto_stringto convert a&strtoString
+
++// Use two approaches to fix the error and without adding a new line +fn main() { + let s = "hello, world".to_string(); + let s1: &str = s; + + println!("Success!"); +}
String escapes
+-
+
- 🌟 +
+fn main() { + // You can use escapes to write bytes by their hexadecimal values + // Fill the blank below to show "I'm writing Rust" + let byte_escape = "I'm writing Ru\x73__!"; + println!("What are you doing\x3F (\\x3F means ?) {}", byte_escape); + + // ...Or Unicode code points. + let unicode_codepoint = "\u{211D}"; + let character_name = "\"DOUBLE-STRUCK CAPITAL R\""; + + println!("Unicode character {} (U+211D) is called {}", + unicode_codepoint, character_name ); + + let long_string = "String literals + can span multiple lines. + The linebreak and indentation here \ + can be escaped too!"; + println!("{}", long_string); +}
-
+
- 🌟🌟🌟 Sometimes there are just too many characters that need to be escaped or it's just much more convenient to write a string out as-is. This is where raw string literals come into play. +
++/* Fill in the blank and fix the errors */ +fn main() { + let raw_str = r"Escapes don't work here: \x3F \u{211D}"; + // Modify above line to make it work + assert_eq!(raw_str, "Escapes don't work here: ? ℝ"); + + // If you need quotes in a raw string, add a pair of #s + let quotes = r#"And then I said: "There is no escape!""#; + println!("{}", quotes); + + // If you need "# in your string, just use more #s in the delimiter. + // You can use up to 65535 #s. + let delimiter = r###"A string with "# in it. And even "##!"###; + println!("{}", delimiter); + + // Fill the blank + let long_delimiter = __; + assert_eq!(long_delimiter, "Hello, \"##\""); + + println!("Success!"); +}
Byte string
+Want a string that's not UTF-8? (Remember, str and String must be valid UTF-8). Or maybe you want an array of bytes that's mostly text? Byte strings to the rescue!
+Example:
++use std::str; + +fn main() { + // Note that this is not actually a `&str` + let bytestring: &[u8; 21] = b"this is a byte string"; + + // Byte arrays don't have the `Display` trait, so printing them is a bit limited + println!("A byte string: {:?}", bytestring); + + // Byte strings can have byte escapes... + let escaped = b"\x52\x75\x73\x74 as bytes"; + // ...But no unicode escapes + // let escaped = b"\u{211D} Is not allowed"; + println!("Some escaped bytes: {:?}", escaped); + + + // Raw byte strings work just like raw strings + let raw_bytestring = br"\u{211D} is not escaped here"; + println!("{:?}", raw_bytestring); + + // Converting a byte array to `str` can fail + if let Ok(my_str) = str::from_utf8(raw_bytestring) { + println!("And the same as text: '{}'", my_str); + } + + let _quotes = br#"You can also use "fancier" formatting, \ + like with normal raw strings"#; + + // Byte strings don't have to be UTF-8 + let shift_jis = b"\x82\xe6\x82\xa8\x82\xb1\x82\xbb"; // "ようこそ" In SHIFT-JIS + + // But then they can't always be converted to `str` + match str::from_utf8(shift_jis) { + Ok(my_str) => println!("Conversion successful: '{}'", my_str), + Err(e) => println!("Conversion failed: {:?}", e), + }; +}
A more detailed listing of the ways to write string literals and escape characters is given in the 'Tokens' chapter of the Rust Reference.
+String index
+-
+
- 🌟🌟🌟 You can't use index to access a char in a string, but you can use slice
&s1[start..end].
+
++fn main() { + let s1 = String::from("hi,中国"); + let h = s1[0]; // Modify this line to fix the error, tips: `h` only takes 1 byte in UTF8 format + assert_eq!(h, "h"); + + let h1 = &s1[3..5]; // Modify this line to fix the error, tips: `中` takes 3 bytes in UTF8 format + assert_eq!(h1, "中"); + + println!("Success!"); +}
Operate on UTF8 string
+-
+
- 🌟 +
++fn main() { + // Fill the blank to print each char in "你好，世界" + for c in "你好，世界".__ { + println!("{}", c) + } +}
utf8_slice
+You can use utf8_slice to slice UTF8 string, it can index chars instead of bytes.
+Example
++use utf8_slice; +fn main() { + let s = "The 🚀 goes to the 🌑!"; + + let rocket = utf8_slice::slice(s, 4, 5); + // Will equal "🚀" +}
++You can find the solutions here(under the solutions path), but only use it when you need it
+
Array
+The type of array is [T; Length], as you can see, array's length is part of their type signature. So their length must be known at compile time.
For example, you cant initialize an array like below:
++#![allow(unused)] +fn main() { +fn init_arr(n: i32) { + let arr = [1; n]; +} +}
This will cause an error, because the compiler has no idea of the exact size of the array at compile time.
+-
+
- 🌟 +
++fn main() { + // Fill the blank with proper array type + let arr: __ = [1, 2, 3, 4, 5]; + + // Modify the code below to make it work + assert!(arr.len() == 4); + + println!("Success!"); +}
-
+
- 🌟🌟 +
++fn main() { + // We can ignore parts of the array type or even the whole type, let the compiler infer it for us + let arr0 = [1, 2, 3]; + let arr: [_; 3] = ['a', 'b', 'c']; + + // Fill the blank + // Arrays are stack allocated, `std::mem::size_of_val` returns the bytes which an array occupies + // A char takes 4 bytes in Rust: Unicode char + assert!(std::mem::size_of_val(&arr) == __); + + println!("Success!"); +}
-
+
- 🌟 All elements in an array can be initialized to the same value at once. +
++fn main() { + // Fill the blank + let list: [i32; 100] = __ ; + + assert!(list[0] == 1); + assert!(list.len() == 100); + + println!("Success!"); +}
-
+
- 🌟 All elements in an array must be of the same type +
++fn main() { + // Fix the error + let _arr = [1, 2, '3']; + + println!("Success!"); +}
-
+
- 🌟 Indexing starts at 0. +
++fn main() { + let arr = ['a', 'b', 'c']; + + let ele = arr[1]; // Only modify this line to make the code work! + + assert!(ele == 'a'); + + println!("Success!"); +}
-
+
- 🌟 Out of bounds indexing causes
panic.
+
++// Fix the error +fn main() { + let names = [String::from("Sunfei"), "Sunface".to_string()]; + + // `Get` returns an Option<T>, it's safe to use + let name0 = names.get(0).unwrap(); + + // But indexing is not safe + let _name1 = &names[2]; + + println!("Success!"); +} +
++You can find the solutions here(under the solutions path), but only use it when you need it
+
Slice
+Slices are similar to arrays, but their length is not known at compile time, so you can't use slice directly.
+-
+
- 🌟🌟 Here, both
[i32]andstrare slice types, but directly using it will cause errors. You have to use the reference of the slice instead:&[i32],&str.
+
++// Fix the errors, DON'T add new lines! +fn main() { + let arr = [1, 2, 3]; + let s1: [i32] = arr[0..2]; + + let s2: str = "hello, world" as str; + + println!("Success!"); +}
A slice reference is a two-word object, for simplicity reasons, from now on we will use slice instead of slice reference. The first word is a pointer to the data, and the second word is the length of the slice. The word size is the same as usize, determined by the processor architecture, e.g. 64 bits on an x86-64. Slices can be used to borrow a section of an array, and have the type signature &[T].
-
+
- 🌟🌟🌟 +
++fn main() { + let arr: [char; 3] = ['中', '国', '人']; + + let slice = &arr[..2]; + + // Modify '8' to make it work + // TIPS: slice( reference ) IS NOT an array, if it is an array, then `assert!` will be passed: Each of the two chars '中' and '国' occupies 4 bytes, 2 * 4 = 8 + assert!(std::mem::size_of_val(&slice) == 8); + + println!("Success!"); +}
-
+
- 🌟🌟 +
++fn main() { + let arr: [i32; 5] = [1, 2, 3, 4, 5]; + // Fill the blanks to make the code work + let slice: __ = __; + assert_eq!(slice, &[2, 3, 4]); + + println!("Success!"); +}
String slices
+-
+
- 🌟 +
++fn main() { + let s = String::from("hello"); + + let slice1 = &s[0..2]; + // Fill the blank to make the code work, DON'T USE 0..2 again + let slice2 = &s[__]; + + assert_eq!(slice1, slice2); + + println!("Success!"); +}
-
+
- 🌟 +
++fn main() { + let s = "你好，世界"; + // Modify this line to make the code work + let slice = &s[0..2]; + + assert!(slice == "你"); + + println!("Success!"); +}
-
+
- 🌟🌟
&Stringcan be implicitly converted into&str.
+
++// Fix errors +fn main() { + let mut s = String::from("hello world"); + + // Here, &s is `&String` type, but `first_letter` needs a `&str` type. + // It works because `&String` can be implicitly converted to `&str. If you want to know more, this is called `Deref coercion`. + let letter = first_letter(&s); + + s.clear(); // error! + + println!("the first letter is: {}", letter); +} +fn first_letter(s: &str) -> &str { + &s[..1] +}
++You can find the solutions here(under the solutions path), but only use it when you need it
+
Tuple
+-
+
- 🌟 Elements in a tuple can have different types. Tuple's type signature is
(T1, T2, ...), whereT1,T2are the types of tuple's members.
+
++fn main() { + let _t0: (u8,i16) = (0, -1); + // Tuples can be tuple's members + let _t1: (u8, (i16, u32)) = (0, (-1, 1)); + // Fill the blanks to make the code work + let t: (u8, __, i64, __, __) = (1u8, 2u16, 3i64, "hello", String::from(", world")); + + println!("Success!"); +}
-
+
- 🌟 Members can be extracted from the tuple using indexing. +
++// Make it work +fn main() { + let t = ("i", "am", "sunface"); + assert_eq!(t.1, "sunface"); + + println!("Success!"); +}
-
+
- 🌟 Long tuples cannot be printed +
++// Fix the error +fn main() { + let too_long_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13); + println!("too long tuple: {:?}", too_long_tuple); +}
-
+
- 🌟 Destructuring tuple with pattern. +
++fn main() { + let tup = (1, 6.4, "hello"); + + // Fill the blank to make the code work + let __ = tup; + + assert_eq!(x, 1); + assert_eq!(y, "hello"); + assert_eq!(z, 6.4); + + println!("Success!"); +}
-
+
- 🌟🌟 Destructure assignments. +
+fn main() { + let (x, y, z); + + // Fill the blank + __ = (1, 2, 3); + + assert_eq!(x, 3); + assert_eq!(y, 1); + assert_eq!(z, 2); + + println!("Success!"); +}
-
+
- 🌟🌟 Tuples can be used as function arguments and return values +
++fn main() { + // Fill the blank, need a few computations here. + let (x, y) = sum_multiply(__); + + assert_eq!(x, 5); + assert_eq!(y, 6); + + println!("Success!"); +} + +fn sum_multiply(nums: (i32, i32)) -> (i32, i32) { + (nums.0 + nums.1, nums.0 * nums.1) +}
++You can find the solutions here(under the solutions path), but only use it when you need it
+
Struct
+The types of structs
+-
+
- 🌟 We must specify concrete values for each of the fields in struct. +
++// Fix the error +struct Person { + name: String, + age: u8, + hobby: String +} +fn main() { + let age = 30; + let p = Person { + name: String::from("sunface"), + age, + }; + + println!("Success!"); +}
-
+
- 🌟 Unit struct don't have any fields. It can be useful when you need to implement a trait on some type but don’t have any data that you want to store in the type itself. +
++struct Unit; +trait SomeTrait { + // ...Some behaviors defined here. +} + +// We don't care about what fields are in the Unit, but we care about its behaviors. +// So we use a struct with no fields and implement some behaviors for it +impl SomeTrait for Unit { } +fn main() { + let u = Unit; + do_something_with_unit(u); + + println!("Success!"); +} + +// Fill the blank to make the code work +fn do_something_with_unit(u: __) { }
-
+
- 🌟🌟🌟 Tuple struct looks similar to tuples, it has added meaning the struct name provides but has no named fields. It's useful when you want to give the whole tuple a name, but don't care about the fields's names. +
++// Fix the error and fill the blanks +struct Color(i32, i32, i32); +struct Point(i32, i32, i32); +fn main() { + let v = Point(__, __, __); + check_color(v); + + println!("Success!"); +} + +fn check_color(p: Color) { + let (x, _, _) = p; + assert_eq!(x, 0); + assert_eq!(p.1, 127); + assert_eq!(__, 255); + }
Operating on structs
+-
+
- 🌟 You can make a whole struct mutable when instantiating it, but Rust doesn't allow us to mark only certain fields as mutable. +
++// Fill the blank and fix the error without adding/removing new line +struct Person { + name: String, + age: u8, +} +fn main() { + let age = 18; + let p = Person { + name: String::from("sunface"), + age, + }; + + // How can you believe sunface is only 18? + p.age = 30; + + // Fill the blank + __ = String::from("sunfei"); + + println!("Success!"); +}
-
+
- 🌟 Using field init shorthand syntax to reduce repetitions. +
++// Fill the blank +struct Person { + name: String, + age: u8, +} +fn main() { + println!("Success!"); +} + +fn build_person(name: String, age: u8) -> Person { + Person { + age, + __ + } +}
-
+
- 🌟 You can create instance from other instance with struct update syntax +
++// Fill the blank to make the code work +struct User { + active: bool, + username: String, + email: String, + sign_in_count: u64, +} +fn main() { + let u1 = User { + email: String::from("someone@example.com"), + username: String::from("sunface"), + active: true, + sign_in_count: 1, + }; + + let u2 = set_email(u1); + + println!("Success!"); +} + +fn set_email(u: User) -> User { + User { + email: String::from("contact@im.dev"), + __ + } +}
Print the structs
+-
+
- 🌟🌟 We can use
#[derive(Debug)]to make a struct printable.
+
++// Fill the blanks to make the code work +#[__] +struct Rectangle { + width: u32, + height: u32, +} + +fn main() { + let scale = 2; + let rect1 = Rectangle { + width: dbg!(30 * scale), // Print debug info to stderr and assign the value of `30 * scale` to `width` + height: 50, + }; + + dbg!(&rect1); // Print debug info to stderr + + println!(__, rect1); // Print debug info to stdout +}
Partial move
+Within the destructuring of a single variable, both by-move and by-reference pattern bindings can be used at the same time. Doing this will result in a partial move of the variable, which means that parts of the variable will be moved while other parts stay. In such a case, the parent variable cannot be used afterwards as a whole, however the parts that are only referenced (and not moved) can still be used.
+Example
+++fn main() { + #[derive(Debug)] + struct Person { + name: String, + age: Box<u8>, + } + + let person = Person { + name: String::from("Alice"), + age: Box::new(20), + }; + + // `name` is moved out of person, but `age` is referenced + let Person { name, ref age } = person; + + println!("The person's age is {}", age); + + println!("The person's name is {}", name); + + // Error! borrow of partially moved value: `person` partial move occurs + //println!("The person struct is {:?}", person); + + // `person` cannot be used but `person.age` can be used as it is not moved + println!("The person's age from person struct is {}", person.age); +}
Exercises
+-
+
- 🌟🌟 +
++// Fix errors to make it work +#[derive(Debug)] +struct File { + name: String, + data: String, +} +fn main() { + let f = File { + name: String::from("readme.md"), + data: "Rust By Practice".to_string() + }; + + let _name = f.name; + + // ONLY modify this line + println!("{}, {}, {:?}",f.name, f.data, f); +}
++You can find the solutions here(under the solutions path), but only use it when you need it
+
Enum
+-
+
- 🌟🌟 Enums can be created with explicit discriminator. +
++// Fix the errors +enum Number { + Zero, + One, + Two, +} + +enum Number1 { + Zero = 0, + One, + Two, +} + +// C-like enum +enum Number2 { + Zero = 0.0, + One = 1.0, + Two = 2.0, +} + + +fn main() { + // An enum variant can be converted to a integer by `as` + assert_eq!(Number::One, Number1::One); + assert_eq!(Number1::One, Number2::One); + + println!("Success!"); +}
-
+
- 🌟 Each enum variant can hold its own data. +
++// Fill in the blank +enum Message { + Quit, + Move { x: i32, y: i32 }, + Write(String), + ChangeColor(i32, i32, i32), +} + +fn main() { + let msg1 = Message::Move{__}; // Instantiating with x = 1, y = 2 + let msg2 = Message::Write(__); // Instantiating with "hello, world!" + + println!("Success!"); +}
-
+
- 🌟🌟 We can get the data which an enum variant is holding by pattern match. +
++// Fill in the blank and fix the error +enum Message { + Quit, + Move { x: i32, y: i32 }, + Write(String), + ChangeColor(i32, i32, i32), +} + +fn main() { + let msg = Message::Move{x: 1, y: 2}; + + if let Message::Move{__} = msg { + assert_eq!(a, b); + } else { + panic!("NEVER LET THIS RUN！"); + } + + println!("Success!"); +}
-
+
- 🌟🌟 +
++// Fill in the blank and fix the errors +enum Message { + Quit, + Move { x: i32, y: i32 }, + Write(String), + ChangeColor(i32, i32, i32), +} + +fn main() { + let msgs: __ = [ + Message::Quit, + Message::Move{x:1, y:3}, + Message::ChangeColor(255,255,0) + ]; + + for msg in msgs { + show_message(msg) + } +} + +fn show_message(msg: Message) { + println!("{}", msg); +}
-
+
- 🌟🌟 Since there is no
nullin Rust, we have to use enumOption<T>to deal with the cases when the value is absent.
+
++// Fill in the blank to make the `println` work. +// Also add some code to prevent the `panic` from running. +fn main() { + let five = Some(5); + let six = plus_one(five); + let none = plus_one(None); + + if let __ = six { + println!("{}", n); + + println!("Success!"); + } + + panic!("NEVER LET THIS RUN！"); +} + +fn plus_one(x: Option<i32>) -> Option<i32> { + match x { + __ => None, + __ => Some(i + 1), + } +}
-
+
- 🌟🌟🌟🌟 Implement a
linked-listvia enums.
+
++use crate::List::*; + +enum List { + // Cons: Tuple struct that wraps an element and a pointer to the next node + Cons(u32, Box<List>), + // Nil: A node that signifies the end of the linked list + Nil, +} + +// Methods can be attached to an enum +impl List { + // Create an empty list + fn new() -> List { + // `Nil` has type `List` + Nil + } + + // Consume a list, and return the same list with a new element at its front + fn prepend(self, elem: u32) -> __ { + // `Cons` also has type List + Cons(elem, Box::new(self)) + } + + // Return the length of the list + fn len(&self) -> u32 { + // `self` has to be matched, because the behavior of this method + // depends on the variant of `self` + // `self` has type `&List`, and `*self` has type `List`, matching on a + // concrete type `T` is preferred over a match on a reference `&T` + // After Rust 2018 you can use self here and tail (with no ref) below as well, + // rust will infer &s and ref tail. + // See https://doc.rust-lang.org/edition-guide/rust-2018/ownership-and-lifetimes/default-match-bindings.html + match *self { + // Can't take ownership of the tail, because `self` is borrowed; + // Instead take a reference to the tail + Cons(_, ref tail) => 1 + tail.len(), + // Base Case: An empty list has zero length + Nil => 0 + } + } + + // Return representation of the list as a (heap allocated) string + fn stringify(&self) -> String { + match *self { + Cons(head, __ tail) => { + // `format!` is similar to `print!`, but returns a heap + // allocated string instead of printing to the console + format!("{}, {}", head, tail.__()) + }, + Nil => { + format!("Nil") + }, + } + } +} + +fn main() { + // Create an empty linked list + let mut list = List::new(); + + // Prepend some elements + list = list.prepend(1); + list = list.prepend(2); + list = list.prepend(3); + + // Show the final state of the list + println!("linked list has length: {}", list.len()); + println!("{}", list.stringify()); +}
++You can find the solutions here(under the solutions path), but only use it when you need it
+
Flow control
+If/else
+-
+
- 🌟 +
++// Fill in the blanks +fn main() { + let n = 5; + + if n < 0 { + println!("{} is negative", n); + } __ n > 0 { + println!("{} is positive", n); + } __ { + println!("{} is zero", n); + } +}
-
+
- 🌟🌟
If/elseexpression can be used in assignments.
+
++// Fix the errors +fn main() { + let n = 5; + + let big_n = + if n < 10 && n > -10 { + println!(", and is a small number, increase ten-fold"); + + 10 * n + } else { + println!(", and is a big number, halve the number"); + + n / 2.0 ; + } + + println!("{} -> {}", n, big_n); +}
For
+-
+
- 🌟 The
for inconstruct can be used to iterate through an Iterator, e.g a rangea..b.
+
++fn main() { + for n in 1..=100 { // modify this line to make the code work + if n == 100 { + panic!("NEVER LET THIS RUN") + } + } + + println!("Success!"); +}
-
+
- 🌟🌟 +
++// Fix the errors without adding or removing lines +fn main() { + let names = [String::from("liming"),String::from("hanmeimei")]; + for name in names { + // Do something with name... + } + + println!("{:?}", names); + + let numbers = [1, 2, 3]; + // The elements in numbers are Copy，so there is no move here + for n in numbers { + // Do something with n... + } + + println!("{:?}", numbers); +}
-
+
- 🌟 +
+fn main() { + let a = [4, 3, 2, 1]; + + // Iterate the indexing and value in 'a' + for (i,v) in a.__ { + println!("The {}th element is {}",i+1,v); + } +}
While
+-
+
- 🌟🌟 The
whilekeyword can be used to run a loop when a condition is true.
+
++// Fill in the blanks to make the last println! work ! +fn main() { + // A counter variable + let mut n = 1; + + // Loop while the condition is true + while n __ 10 { + if n % 15 == 0 { + println!("fizzbuzz"); + } else if n % 3 == 0 { + println!("fizz"); + } else if n % 5 == 0 { + println!("buzz"); + } else { + println!("{}", n); + } + + + __; + } + + println!("n reached {}, so loop is over",n); +}
Continue and break
+-
+
- 🌟 Use
breakto break the loop.
+
++// Fill in the blank +fn main() { + let mut n = 0; + for i in 0..=100 { + if n == 66 { + __ + } + n += 1; + } + + assert_eq!(n, 66); + + println!("Success!"); +}
-
+
- 🌟🌟
continuewill skip over the remaining code in current iteration and go to the next iteration.
+
++// Fill in the blanks +fn main() { + let mut n = 0; + for i in 0..=100 { + if n != 66 { + n+=1; + __; + } + + __ + } + + assert_eq!(n, 66); + + println!("Success!"); +}
Loop
+-
+
- 🌟🌟 Loop is usually used together with
breakorcontinue.
+
++// Fill in the blanks +fn main() { + let mut count = 0u32; + + println!("Let's count until infinity!"); + + // Infinite loop + loop { + count += 1; + + if count == 3 { + println!("three"); + + // Skip the rest of this iteration + __; + } + + println!("{}", count); + + if count == 5 { + println!("OK, that's enough"); + + __; + } + } + + assert_eq!(count, 5); + + println!("Success!"); +}
-
+
- 🌟🌟 Loop is an expression, so we can use it with
breakto return a value
+
++// Fill in the blank +fn main() { + let mut counter = 0; + + let result = loop { + counter += 1; + + if counter == 10 { + __; + } + }; + + assert_eq!(result, 20); + + println!("Success!"); +}
-
+
- 🌟🌟🌟 It's possible to break or continue outer loops when dealing with nested loops. In these cases, the loops must be annotated with some 'label, and the label must be passed to the break/continue statement. +
++// Fill in the blank +fn main() { + let mut count = 0; + 'outer: loop { + 'inner1: loop { + if count >= 20 { + // This would break only the inner1 loop + break 'inner1; // `break` is also works. + } + count += 2; + } + + count += 5; + + 'inner2: loop { + if count >= 30 { + // This breaks the outer loop + break 'outer; + } + + // This will continue the outer loop + continue 'outer; + } + } + + assert!(count == __); + + println!("Success!"); +}
++You can find the solutions here(under the solutions path), but only use it when you need it
+
Pattern Match
+Learning resources:
+-
+
- English: Rust Book 18 +
- 简体中文: Rust语言圣经 - 模式匹配 +
Match, if let
+Match
+-
+
- 🌟🌟 +
++// Fill the blanks +enum Direction { + East, + West, + North, + South, +} + +fn main() { + let dire = Direction::South; + match dire { + Direction::East => println!("East"), + __ => { // Matching South or North here + println!("South or North"); + }, + _ => println!(__), + }; +}
-
+
- 🌟🌟 Match is an expression, so we can use it in assignments. +
++fn main() { + let boolean = true; + + // Fill the blank with a match expression: + // + // boolean = true => binary = 1 + // boolean = false => binary = 0 + let binary = __; + + assert_eq!(binary, 1); + + println!("Success!"); +}
-
+
- 🌟🌟 Using match to get the data an enum variant holds. +
++// Fill in the blanks +enum Message { + Quit, + Move { x: i32, y: i32 }, + Write(String), + ChangeColor(i32, i32, i32), +} + +fn main() { + let msgs = [ + Message::Quit, + Message::Move{x:1, y:3}, + Message::ChangeColor(255,255,0) + ]; + + for msg in msgs { + show_message(msg) + } + + println!("Success!"); +} + +fn show_message(msg: Message) { + match msg { + __ => { // match Message::Move + assert_eq!(a, 1); + assert_eq!(b, 3); + }, + Message::ChangeColor(_, g, b) => { + assert_eq!(g, __); + assert_eq!(b, __); + } + __ => println!("no data in these variants") + } +}
matches!
+matches! looks like match, but can do something different.
-
+
- 🌟🌟 +
++fn main() { + let alphabets = ['a', 'E', 'Z', '0', 'x', '9' , 'Y']; + + // Fill the blank with `matches!` to make the code work + for ab in alphabets { + assert!(__) + } + + println!("Success!"); +}
-
+
- 🌟🌟 +
++enum MyEnum { + Foo, + Bar +} + +fn main() { + let mut count = 0; + + let v = vec![MyEnum::Foo,MyEnum::Bar,MyEnum::Foo]; + for e in v { + if e == MyEnum::Foo { // Fix the error by changing only this line + count += 1; + } + } + + assert_eq!(count, 2); + + println!("Success!"); +}
If let
+For some cases, when matching enums, match is too heavy. We can use if let instead.
-
+
- 🌟 +
++fn main() { + let o = Some(7); + + // Remove the whole `match` block, using `if let` instead + match o { + Some(i) => { + println!("This is a really long string and `{:?}`", i); + + println!("Success!"); + } + _ => {} + }; +}
-
+
- 🌟🌟 +
++// Fill in the blank +enum Foo { + Bar(u8) +} + +fn main() { + let a = Foo::Bar(1); + + __ { + println!("foobar holds the value: {}", i); + + println!("Success!"); + } +}
-
+
- 🌟🌟 +
++enum Foo { + Bar, + Baz, + Qux(u32) +} + +fn main() { + let a = Foo::Qux(10); + + // Remove the codes below, using `match` instead + if let Foo::Bar = a { + println!("match foo::bar") + } else if let Foo::Baz = a { + println!("match foo::baz") + } else { + println!("match others") + } +}
Shadowing
+-
+
- 🌟🌟 +
++// Fix the errors in-place +fn main() { + let age = Some(30); + if let Some(age) = age { // Create a new variable with the same name as previous `age` + assert_eq!(age, Some(30)); + } // The new variable `age` goes out of scope here + + match age { + // Match can also introduce a new shadowed variable + Some(age) => println!("age is a new variable, it's value is {}",age), + _ => () + } + }
++You can find the solutions here(under the solutions path), but only use it when you need it
+
Patterns
+-
+
- 🌟🌟 Use
|to match several values, use..=to match an inclusive range.
+
++fn main() {} +fn match_number(n: i32) { + match n { + // Match a single value + 1 => println!("One!"), + // Fill in the blank with `|`, DON'T use `..` or `..=` + __ => println!("match 2 -> 5"), + // Match an inclusive range + 6..=10 => { + println!("match 6 -> 10") + }, + _ => { + println!("match -infinite -> 0 or 11 -> +infinite") + } + } +}
-
+
- 🌟🌟🌟 The
@operator lets us create a variable that holds a value, at the same time we are testing that value to see whether it matches a pattern.
+
++struct Point { + x: i32, + y: i32, +} + +fn main() { + // Fill in the blank to let p match the second arm + let p = Point { x: __, y: __ }; + + match p { + Point { x, y: 0 } => println!("On the x axis at {}", x), + // Second arm + Point { x: 0..=5, y: y@ (10 | 20 | 30) } => println!("On the y axis at {}", y), + Point { x, y } => println!("On neither axis: ({}, {})", x, y), + } +}
-
+
- 🌟🌟🌟 +
++// Fix the errors +enum Message { + Hello { id: i32 }, +} + +fn main() { + let msg = Message::Hello { id: 5 }; + + match msg { + Message::Hello { + id: 3..=7, + } => println!("Found an id in range [3, 7]: {}", id), + Message::Hello { id: newid@10 | 11 | 12 } => { + println!("Found an id in another range [10, 12]: {}", newid) + } + Message::Hello { id } => println!("Found some other id: {}", id), + } +}
-
+
- 🌟🌟 A match guard is an additional if condition specified after the pattern in a match arm that must also match, along with the pattern matching, for that arm to be chosen. +
++// Fill in the blank to make the code work, `split` MUST be used +fn main() { + let num = Some(4); + let split = 5; + match num { + Some(x) __ => assert!(x < split), + Some(x) => assert!(x >= split), + None => (), + } + + println!("Success!"); +}
-
+
- 🌟🌟 Ignoring remaining parts of the value with
..
+
++// Fill the blank to make the code work +fn main() { + let numbers = (2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048); + + match numbers { + __ => { + assert_eq!(first, 2); + assert_eq!(last, 2048); + } + } + + println!("Success!"); +}
-
+
- 🌟🌟 Using pattern
&mut Vto match a mutable reference requires you to be very careful, due toVbeing a value after matching.
+
++// FIX the error with least changing +// DON'T remove any code line +fn main() { + let mut v = String::from("hello,"); + let r = &mut v; + + match r { + &mut value => value.push_str(" world!") + } +}
++You can find the solutions here(under the solutions path), but only use it when you need it
+
Associated functions & Methods
+Examples
++struct Point { + x: f64, + y: f64, +} + +// Implementation block, all `Point` associated functions & methods go in here. +impl Point { + // This is an "associated function" because this function is associated with + // a particular type, that is, Point. + // + // Associated functions don't need to be called with an instance. + // These functions are generally used like constructors. + fn origin() -> Point { + Point { x: 0.0, y: 0.0 } + } + + // Another associated function, taking two arguments: + fn new(x: f64, y: f64) -> Point { + Point { x: x, y: y } + } +} + +struct Rectangle { + p1: Point, + p2: Point, +} + +impl Rectangle { + // This is a method. + // `&self` is sugar for `self: &Self`, where `Self` is the type of the + // caller object. In this case `Self` = `Rectangle` + fn area(&self) -> f64 { + // `self` gives access to the struct fields via the dot operator. + let Point { x: x1, y: y1 } = self.p1; + let Point { x: x2, y: y2 } = self.p2; + + // `abs` is a `f64` method that returns the absolute value of the + // caller + ((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()) + } + + // This method requires the caller object to be mutable + // `&mut self` desugars to `self: &mut Self` + fn translate(&mut self, x: f64, y: f64) { + self.p1.x += x; + self.p2.x += x; + + self.p1.y += y; + self.p2.y += y; + } +} + +// `Pair` owns resources: two heap allocated integers. +struct Pair(Box<i32>, Box<i32>); + +impl Pair { + // This method "consumes" the resources of the caller object + // `self` desugars to `self: Self` + fn destroy(self) { + // Destructure `self` + let Pair(first, second) = self; + + println!("Destroying Pair({}, {})", first, second); + + // `first` and `second` go out of scope and get freed. + } +} + +fn main() { + let rectangle = Rectangle { + // Associated functions are called using double colons + p1: Point::origin(), + p2: Point::new(3.0, 4.0), + }; + + // Methods are called using the dot operator. + // Note that the first argument `&self` is implicitly passed, i.e. + // `rectangle.perimeter()` === `Rectangle::perimeter(&rectangle)` + println!("Rectangle perimeter: {}", rectangle.perimeter()); + println!("Rectangle area: {}", rectangle.area()); + + let mut square = Rectangle { + p1: Point::origin(), + p2: Point::new(1.0, 1.0), + }; + + // Error! `rectangle` is immutable, but this method requires a mutable + // object. + //rectangle.translate(1.0, 0.0); + // TODO ^ Try uncommenting this line + + // Okay! Mutable objects can call mutable methods + square.translate(1.0, 1.0); + + let pair = Pair(Box::new(1), Box::new(2)); + + pair.destroy(); + + // Error! Previous `destroy` call "consumed" `pair` + //pair.destroy(); + // TODO ^ Try uncommenting this line +}
Exercises
+Method
+-
+
- 🌟🌟 Methods are similar to functions: Declare with
fn, have parameters and a return value. Unlike functions, methods are defined within the context of a struct (or an enum or a trait object), and their first parameter is alwaysself, which represents the instance of the struct the method is being called on.
+
+struct Rectangle { + width: u32, + height: u32, +} + +impl Rectangle { + // Complete the area method which return the area of a Rectangle. + fn area +} + +fn main() { + let rect1 = Rectangle { width: 30, height: 50 }; + + assert_eq!(rect1.area(), 1500); + + println!("Success!"); +}
-
+
- 🌟🌟
selfwill take the ownership of current struct instance, however,&selfwill only borrow a reference from the instance.
+
+// Only fill in the blanks, DON'T remove any line! +#[derive(Debug)] +struct TrafficLight { + color: String, +} + +impl TrafficLight { + pub fn show_state(__) { + println!("the current state is {}", __.color); + } +} +fn main() { + let light = TrafficLight{ + color: "red".to_owned(), + }; + // Don't take the ownership of `light` here. + light.show_state(); + // ... Otherwise, there will be an error below + println!("{:?}", light); +}
-
+
- 🌟🌟 The
&selfis actually short forself: &Self. Within animplblock, the typeSelfis an alias for the type that theimplblock is for. Methods must have a parameter namedselfof typeSelffor their first parameter, so Rust lets you abbreviate this with only the nameselfin the first parameter spot.
+
+struct TrafficLight { + color: String, +} + +impl TrafficLight { + // Using `Self` to fill in the blank. + pub fn show_state(__) { + println!("the current state is {}", self.color); + } + + // Fill in the blank, DON'T use any variants of `Self`. + pub fn change_state(__) { + self.color = "green".to_string() + } +} +fn main() { + println!("Success!"); +}
Associated functions
+-
+
- 🌟🌟 All functions defined within an
implblock are called associated functions because they’re associated with the type named after theimpl. We can define associated functions that don’t haveselfas their first parameter (and thus are not methods) because they don’t need an instance of the type to work with.
+
+#[derive(Debug)] +struct TrafficLight { + color: String, +} + +impl TrafficLight { + // 1. Implement an associated function `new`, + // 2. It will return a TrafficLight contains color "red" + // 3. Must use `Self`, DONT use `TrafficLight` in fn signatures or body + pub fn new() + + pub fn get_state(&self) -> &str { + &self.color + } +} + +fn main() { + let light = TrafficLight::new(); + assert_eq!(light.get_state(), "red"); + + println!("Success!"); +}
Multiple impl blocks
+-
+
- 🌟 Each struct is allowed to have multiple impl blocks. +
++struct Rectangle { + width: u32, + height: u32, +} + +// Using multiple `impl` blocks to rewrite the code below. +impl Rectangle { + fn area(&self) -> u32 { + self.width * self.height + } + + fn can_hold(&self, other: &Rectangle) -> bool { + self.width > other.width && self.height > other.height + } +} + + +fn main() { + println!("Success!"); +}
Enums
+-
+
- 🌟🌟🌟 We can also implement methods for enums. +
++#[derive(Debug)] +enum TrafficLightColor { + Red, + Yellow, + Green, +} + +// Implement TrafficLightColor with a method. +impl TrafficLightColor { + +} + +fn main() { + let c = TrafficLightColor::Yellow; + + assert_eq!(c.color(), "yellow"); + + println!("{:?}",c); +}
Practice
+@todo
+++You can find the solutions here(under the solutions path), but only use it when you need it
+
Generics and Traits
+Learning resources:
+-
+
- English: Rust Book 10.1, 10.2 +
- 简体中文: Rust语言圣经 - 模式匹配 +
Generics
+Functions
+-
+
- 🌟🌟🌟 +
++// Fill in the blanks to make it work +struct A; // Concrete type `A`. +struct S(A); // Concrete type `S`. +struct SGen<T>(T); // Generic type `SGen`. + +fn reg_fn(_s: S) {} + +fn gen_spec_t(_s: SGen<A>) {} + +fn gen_spec_i32(_s: SGen<i32>) {} + +fn generic<T>(_s: SGen<T>) {} + +fn main() { + // Using the non-generic functions + reg_fn(__); // Concrete type. + gen_spec_t(__); // Implicitly specified type parameter `A`. + gen_spec_i32(__); // Implicitly specified type parameter `i32`. + + // Explicitly specified type parameter `char` to `generic()`. + generic::<char>(__); + + // Implicitly specified type parameter `char` to `generic()`. + generic(__); + + println!("Success!"); +}
-
+
- 🌟🌟 A function call with explicitly specified type parameters looks like:
fun::<A, B, ...>().
+
++// Implement the generic function below. +fn sum + +fn main() { + assert_eq!(5, sum(2i8, 3i8)); + assert_eq!(50, sum(20, 30)); + assert_eq!(2.46, sum(1.23, 1.23)); + + println!("Success!"); +}
Struct and impl
+-
+
- 🌟 +
++// Implement struct Point to make it work. + + +fn main() { + let integer = Point { x: 5, y: 10 }; + let float = Point { x: 1.0, y: 4.0 }; + + println!("Success!"); +}
-
+
- 🌟🌟 +
++// Modify this struct to make the code work +struct Point<T> { + x: T, + y: T, +} + +fn main() { + // DON'T modify this code. + let p = Point{x: 5, y : "hello".to_string()}; + + println!("Success!"); +}
-
+
- 🌟🌟 +
++// Add generic for Val to make the code work, DON'T modify the code in `main`. +struct Val { + val: f64, +} + +impl Val { + fn value(&self) -> &f64 { + &self.val + } +} + + +fn main() { + let x = Val{ val: 3.0 }; + let y = Val{ val: "hello".to_string()}; + println!("{}, {}", x.value(), y.value()); +}
Method
+-
+
- 🌟🌟🌟 +
+struct Point<T, U> { + x: T, + y: U, +} + +impl<T, U> Point<T, U> { + // Implement mixup to make it work, DON'T modify other code. + fn mixup +} + +fn main() { + let p1 = Point { x: 5, y: 10 }; + let p2 = Point { x: "Hello", y: '中'}; + + let p3 = p1.mixup(p2); + + assert_eq!(p3.x, 5); + assert_eq!(p3.y, '中'); + + println!("Success!"); +}
-
+
- 🌟🌟 +
++// Fix the errors to make the code work. +struct Point<T> { + x: T, + y: T, +} + +impl Point<f32> { + fn distance_from_origin(&self) -> f32 { + (self.x.powi(2) + self.y.powi(2)).sqrt() + } +} + +fn main() { + let p = Point{x: 5, y: 10}; + println!("{}",p.distance_from_origin()); +}
++You can find the solutions here(under the solutions path), but only use it when you need it
+
Const Generics
+Const generics are generic arguments that range over constant values, rather than types or lifetimes. This allows, for instance, types to be parameterized by integers. In fact, there has been one example of const generic types since early on in Rust's development: the array types [T; N], for some type T and N: usize. However, there has previously been no way to abstract over arrays of an arbitrary size: if you wanted to implement a trait for arrays of any size, you would have to do so manually for each possible value. For a long time, even the standard library methods for arrays were limited to arrays of length at most 32 due to this problem.
+Examples
+-
+
- Here's an example of a type and implementation making use of const generics: a type wrapping a pair of arrays of the same size. +
+struct ArrayPair<T, const N: usize> { + left: [T; N], + right: [T; N], +} + +impl<T: Debug, const N: usize> Debug for ArrayPair<T, N> { + // ... +}
-
+
- Currently, const parameters may only be instantiated by const arguments of the following forms: +
-
+
- A standalone const parameter. +
- A literal (i.e. an integer, bool, or character). +
- A concrete constant expression (enclosed by {}), involving no generic parameters. +
+fn foo<const N: usize>() {} + +fn bar<T, const M: usize>() { + foo::<M>(); // Okay: `M` is a const parameter + foo::<2021>(); // Okay: `2021` is a literal + foo::<{20 * 100 + 20 * 10 + 1}>(); // Okay: const expression contains no generic parameters + + foo::<{ M + 1 }>(); // Error: const expression contains the generic parameter `M` + foo::<{ std::mem::size_of::<T>() }>(); // Error: const expression contains the generic parameter `T` + + let _: [u8; M]; // Okay: `M` is a const parameter + let _: [u8; std::mem::size_of::<T>()]; // Error: const expression contains the generic parameter `T` +} + +fn main() {}
-
+
- Const generics can also let us avoid some runtime checks. +
+/// A region of memory containing at least `N` `T`s. +pub struct MinSlice<T, const N: usize> { + /// The bounded region of memory. Exactly `N` `T`s. + pub head: [T; N], + /// Zero or more remaining `T`s after the `N` in the bounded region. + pub tail: [T], +} + +fn main() { + let slice: &[u8] = b"Hello, world"; + let reference: Option<&u8> = slice.get(6); + // We know this value is `Some(b' ')`, + // but the compiler can't know that. + assert!(reference.is_some()); + + let slice: &[u8] = b"Hello, world"; + // Length check is performed when we construct a MinSlice, + // and it's known at compile time to be of length 12. + // If the `unwrap()` succeeds, no more checks are needed + // throughout the `MinSlice`'s lifetime. + let minslice = MinSlice::<u8, 12>::from_slice(slice).unwrap(); + let value: u8 = minslice.head[6]; + assert_eq!(value, b' ') +}
Exercises
+-
+
- 🌟🌟
<T, const N: usize>is part of the struct type, it meansArray<i32, 3>andArray<i32, 4>are different types.
+
+struct Array<T, const N: usize> { + data : [T; N] +} + +fn main() { + let arrays = [ + Array{ + data: [1, 2, 3], + }, + Array { + data: [1.0, 2.0, 3.0], + }, + Array { + data: [1, 2] + } + ]; + + println!("Success!"); +}
-
+
- 🌟🌟 +
++// Fill in the blanks to make it work. +fn print_array<__>(__) { + println!("{:?}", arr); +} +fn main() { + let arr = [1, 2, 3]; + print_array(arr); + + let arr = ["hello", "world"]; + print_array(arr); +}
-
+
- 🌟🌟🌟 Sometimes we want to limit the size of a variable, e.g when using in embedding environments, then
const expressionswill fit your needs.
+
+#![allow(incomplete_features)] +#![feature(generic_const_exprs)] + +fn check_size<T>(val: T) +where + Assert<{ core::mem::size_of::<T>() < 768 }>: IsTrue, +{ + //... +} + +// Fix the errors in main. +fn main() { + check_size([0u8; 767]); + check_size([0i32; 191]); + check_size(["hello你好"; __]); // Size of &str ? + check_size([(); __].map(|_| "hello你好".to_string())); // Size of String? + check_size(['中'; __]); // Size of char ? + + println!("Success!"); +} + + + +pub enum Assert<const CHECK: bool> {} + +pub trait IsTrue {} + +impl IsTrue for Assert<true> {}
++You can find the solutions here(under the solutions path), but only use it when you need it :)
+
Traits
+A trait tells the Rust compiler about functionality a particular type has and can share with other types. We can use traits to define shared behavior in an abstract way. We can use trait bounds to specify that a generic type can be any type that has certain behavior.
+++Note: Traits are similar to interfaces in other languages, although with some differences.
+
Examples
+++struct Sheep { naked: bool, name: String } + +trait Animal { + // Associated function signature; `Self` refers to the implementor type. + fn new(name: String) -> Self; + + // Method signatures; these will return a string. + fn name(&self) -> String; + + fn noise(&self) -> String; + + // Traits can provide default method definitions. + fn talk(&self) { + println!("{} says {}", self.name(), self.noise()); + } +} + +impl Sheep { + fn is_naked(&self) -> bool { + self.naked + } + + fn shear(&mut self) { + if self.is_naked() { + // Implementor methods can use the implementor's trait methods. + println!("{} is already naked...", self.name()); + } else { + println!("{} gets a haircut!", self.name); + + self.naked = true; + } + } +} + +// Implement the `Animal` trait for `Sheep`. +impl Animal for Sheep { + // `Self` is the implementor type: `Sheep`. + fn new(name: String) -> Sheep { + Sheep { name: name, naked: false } + } + + fn name(&self) -> String { + self.name.clone() + } + + fn noise(&self) -> String { + if self.is_naked() { + "baaaaah?".to_string() + } else { + "baaaaah!".to_string() + } + } + + // Default trait methods can be overridden. + fn talk(&self) { + // For example, we can add some quiet contemplation. + println!("{} pauses briefly... {}", self.name, self.noise()); + } +} + +fn main() { + // Type annotation is necessary in this case. + let mut dolly: Sheep = Animal::new("Dolly".to_string()); + // TODO ^ Try removing the type annotations. + + dolly.talk(); + dolly.shear(); + dolly.talk(); +}
Exercises
+-
+
- 🌟🌟 +
++// Fill in the two impl blocks to make the code work. +// DON'T modify the code in `main`. +trait Hello { + fn say_hi(&self) -> String { + String::from("hi") + } + + fn say_something(&self) -> String; +} + +struct Student {} +impl Hello for Student { +} +struct Teacher {} +impl Hello for Teacher { +} + +fn main() { + let s = Student {}; + assert_eq!(s.say_hi(), "hi"); + assert_eq!(s.say_something(), "I'm a good student"); + + let t = Teacher {}; + assert_eq!(t.say_hi(), "Hi, I'm your new teacher"); + assert_eq!(t.say_something(), "I'm not a bad teacher"); + + println!("Success!"); +}
Derive
+The compiler is capable of providing basic implementations for some traits via
+the #[derive] attribute. For more info, please visit here.
-
+
- 🌟🌟 +
++// `Centimeters`, a tuple struct that can be compared +#[derive(PartialEq, PartialOrd)] +struct Centimeters(f64); + +// `Inches`, a tuple struct that can be printed +#[derive(Debug)] +struct Inches(i32); + +impl Inches { + fn to_centimeters(&self) -> Centimeters { + let &Inches(inches) = self; + + Centimeters(inches as f64 * 2.54) + } +} + +// ADD some attributes to make the code work! +// DON'T modify other code! +struct Seconds(i32); + +fn main() { + let _one_second = Seconds(1); + + println!("One second looks like: {:?}", _one_second); + let _this_is_true = (_one_second == _one_second); + let _this_is_false = (_one_second > _one_second); + + let foot = Inches(12); + + println!("One foot equals {:?}", foot); + + let meter = Centimeters(100.0); + + let cmp = + if foot.to_centimeters() < meter { + "smaller" + } else { + "bigger" + }; + + println!("One foot is {} than one meter.", cmp); +}
Operator
+In Rust, many of the operators can be overloaded via traits. That is, some operators can be used to accomplish different tasks based on their input arguments. This is possible because operators are syntactic sugar for method calls. For example, the + operator in a + b calls the add method (as in a.add(b)). This add method is part of the Add trait. Hence, the + operator can be used by any implementor of the Add trait.
+-
+
- 🌟🌟 +
++use std::ops; + +// Implement fn multiply to make the code work. +// As mentioned above, `+` needs `T` to implement `std::ops::Add` Trait. +// So, what about `*`? You can find the answer here: https://doc.rust-lang.org/core/ops/ +fn multipl + +fn main() { + assert_eq!(6, multiply(2u8, 3u8)); + assert_eq!(5.0, multiply(1.0, 5.0)); + + println!("Success!"); +}
-
+
- 🌟🌟🌟 +
++// Fix the errors, DON'T modify the code in `main`. +use std::ops; + +struct Foo; +struct Bar; + +struct FooBar; + +struct BarFoo; + +// The `std::ops::Add` trait is used to specify the functionality of `+`. +// Here, we make `Add<Bar>` - the trait for addition with a RHS of type `Bar`. +// The following block implements the operation: Foo + Bar = FooBar +impl ops::Add<Bar> for Foo { + type Output = FooBar; + + fn add(self, _rhs: Bar) -> FooBar { + FooBar + } +} + +impl ops::Sub<Foo> for Bar { + type Output = BarFoo; + + fn sub(self, _rhs: Foo) -> BarFoo { + BarFoo + } +} + +fn main() { + // DON'T modify the code below. + // You need to derive some trait for FooBar to make it comparable. + assert_eq!(Foo + Bar, FooBar); + assert_eq!(Foo - Bar, BarFoo); + + println!("Success!"); +}
Use trait as function parameters
+Instead of a concrete type for the item parameter, we specify the impl keyword and the trait name. This parameter accepts any type that implements the specified trait.
+-
+
- 🌟🌟🌟 +
++// Implement `fn summary` to make the code work. +// Fix the errors without removing any code line +trait Summary { + fn summarize(&self) -> String; +} + +#[derive(Debug)] +struct Post { + title: String, + author: String, + content: String, +} + +impl Summary for Post { + fn summarize(&self) -> String { + format!("The author of post {} is {}", self.title, self.author) + } +} + +#[derive(Debug)] +struct Weibo { + username: String, + content: String, +} + +impl Summary for Weibo { + fn summarize(&self) -> String { + format!("{} published a weibo {}", self.username, self.content) + } +} + +fn main() { + let post = Post { + title: "Popular Rust".to_string(), + author: "Sunface".to_string(), + content: "Rust is awesome!".to_string(), + }; + let weibo = Weibo { + username: "sunface".to_string(), + content: "Weibo seems to be worse than Tweet".to_string(), + }; + + summary(post); + summary(weibo); + + println!("{:?}", post); + println!("{:?}", weibo); +} + +// Implement `fn summary` below. +
Returning Types that Implement Traits
+We can also use the impl Trait syntax in the return position to return a value of some type that implements a trait.
+However, you can only use impl Trait if you’re returning a single type, use Trait Objects instead when you really need to return several types.
+-
+
- 🌟🌟 +
++struct Sheep {} +struct Cow {} + +trait Animal { + fn noise(&self) -> String; +} + +impl Animal for Sheep { + fn noise(&self) -> String { + "baaaaah!".to_string() + } +} + +impl Animal for Cow { + fn noise(&self) -> String { + "moooooo!".to_string() + } +} + +// Returns some struct that implements Animal, but we don't know which one at compile time. +// FIX the errors here, you can make a fake random, or you can use trait object. +fn random_animal(random_number: f64) -> impl Animal { + if random_number < 0.5 { + Sheep {} + } else { + Cow {} + } +} + +fn main() { + let random_number = 0.234; + let animal = random_animal(random_number); + println!("You've randomly chosen an animal, and it says {}", animal.noise()); +}
Trait bound
+The impl Trait syntax works for straightforward cases but is actually syntax sugar for a longer form, which is called a trait bound.
When working with generics, the type parameters often must use traits as bounds to stipulate what functionality a type implements.
+-
+
- 🌟🌟 +
+fn main() { + assert_eq!(sum(1, 2), 3); +} + +// Implement `fn sum` with trait bound in two ways. +fn sum<T>(x: T, y: T) -> T { + x + y +}
-
+
- 🌟🌟 +
++// FIX the errors. +struct Pair<T> { + x: T, + y: T, +} + +impl<T> Pair<T> { + fn new(x: T, y: T) -> Self { + Self { + x, + y, + } + } +} + +impl<T: std::fmt::Debug + PartialOrd> Pair<T> { + fn cmp_display(&self) { + if self.x >= self.y { + println!("The largest member is x = {:?}", self.x); + } else { + println!("The largest member is y = {:?}", self.y); + } + } +} + +struct Unit(i32); + +fn main() { + let pair = Pair{ + x: Unit(1), + y: Unit(3) + }; + + pair.cmp_display(); +}
-
+
- 🌟🌟🌟 +
++// Fill in the blanks to make it work +fn example1() { + // `T: Trait` is the commonly used way. + // `T: Fn(u32) -> u32` specifies that we can only pass a closure to `T`. + struct Cacher<T: Fn(u32) -> u32> { + calculation: T, + value: Option<u32>, + } + + impl<T: Fn(u32) -> u32> Cacher<T> { + fn new(calculation: T) -> Cacher<T> { + Cacher { + calculation, + value: None, + } + } + + fn value(&mut self, arg: u32) -> u32 { + match self.value { + Some(v) => v, + None => { + let v = (self.calculation)(arg); + self.value = Some(v); + v + }, + } + } + } + + let mut cacher = Cacher::new(|x| x+1); + assert_eq!(cacher.value(10), __); + assert_eq!(cacher.value(15), __); +} + + +fn example2() { + // We can also use `where` to construct `T` + struct Cacher<T> + where T: Fn(u32) -> u32, + { + calculation: T, + value: Option<u32>, + } + + impl<T> Cacher<T> + where T: Fn(u32) -> u32, + { + fn new(calculation: T) -> Cacher<T> { + Cacher { + calculation, + value: None, + } + } + + fn value(&mut self, arg: u32) -> u32 { + match self.value { + Some(v) => v, + None => { + let v = (self.calculation)(arg); + self.value = Some(v); + v + }, + } + } + } + + let mut cacher = Cacher::new(|x| x+1); + assert_eq!(cacher.value(20), __); + assert_eq!(cacher.value(25), __); +} + + + +fn main() { + example1(); + example2(); + + println!("Success!"); +}
++You can find the solutions here(under the solutions path), but only use it when you need it :)
+
Trait Object
+In traits chapter we have seen that we can't use impl Trait when returning multiple types.
Another limitation of arrays is that they can only store elements of one type. Using enums is not a bad solution when we have a fixed set of types at compile time, but trait objects would be more flexible and powerful.
+Returning Traits with dyn
+The Rust compiler needs to know how much space a function's return type requires. Because the different implementations of a trait probably uses different amounts of memory, functions need to either return a concrete type or the same type when using impl Trait, or return a trait object with dyn.
-
+
- 🌟🌟🌟 +
++trait Bird { + fn quack(&self) -> String; +} + +struct Duck; +impl Duck { + fn swim(&self) { + println!("Look, the duck is swimming") + } +} +struct Swan; +impl Swan { + fn fly(&self) { + println!("Look, the duck.. oh sorry, the swan is flying") + } +} + +impl Bird for Duck { + fn quack(&self) -> String{ + "duck duck".to_string() + } +} + +impl Bird for Swan { + fn quack(&self) -> String{ + "swan swan".to_string() + } +} + +fn main() { + // FILL in the blank. + let duck = __; + duck.swim(); + + let bird = hatch_a_bird(2); + // This bird has forgotten how to swim, so below line will cause an error. + // bird.swim(); + // But it can quak. + assert_eq!(bird.quack(), "duck duck"); + + let bird = hatch_a_bird(1); + // This bird has forgotten how to fly, so below line will cause an error. + // bird.fly(); + // But it can quak too. + assert_eq!(bird.quack(), "swan swan"); + + println!("Success!"); +} + +// IMPLEMENT this function. +fn hatch_a_bird... +
Array with trait objects
+-
+
- 🌟🌟 +
+trait Bird { + fn quack(&self); +} + +struct Duck; +impl Duck { + fn fly(&self) { + println!("Look, the duck is flying") + } +} +struct Swan; +impl Swan { + fn fly(&self) { + println!("Look, the duck.. oh sorry, the swan is flying") + } +} + +impl Bird for Duck { + fn quack(&self) { + println!("{}", "duck duck"); + } +} + +impl Bird for Swan { + fn quack(&self) { + println!("{}", "swan swan"); + } +} + +fn main() { + // FILL in the blank to make the code work. + let birds __; + + for bird in birds { + bird.quack(); + // When duck and swan turn into Birds, they all forgot how to fly, only remember how to quack. + // So, the code below will cause an error. + // bird.fly(); + } +}
&dyn and Box<dyn>
+-
+
- 🌟🌟 +
++// FILL in the blanks. +trait Draw { + fn draw(&self) -> String; +} + +impl Draw for u8 { + fn draw(&self) -> String { + format!("u8: {}", *self) + } +} + +impl Draw for f64 { + fn draw(&self) -> String { + format!("f64: {}", *self) + } +} + +fn main() { + let x = 1.1f64; + let y = 8u8; + + // Draw x. + draw_with_box(__); + + // Draw y. + draw_with_ref(&y); + + println!("Success!"); +} + +fn draw_with_box(x: Box<dyn Draw>) { + x.draw(); +} + +fn draw_with_ref(x: __) { + x.draw(); +}
Static and Dynamic dispatch
+When we use trait bounds on generics, the compiler generates nongeneric implementations of functions and methods for each concrete type that we use in place of a generic type parameter. The code that results from monomorphization is doing static dispatch, which is when the compiler knows what method you’re calling at compile time.
+When we use trait objects, Rust must use dynamic dispatch. The compiler doesn’t know all the types that might be used with the code that is using trait objects, so it doesn’t know which method implemented on which type to call. Instead, at runtime, Rust uses the pointers inside the trait object to know which method to call. There is a runtime cost when this lookup happens that doesn’t occur with static dispatch. Dynamic dispatch also prevents the compiler from choosing to inline a method’s code, which in turn prevents some optimizations.
+However, we do get extra flexibility when using dynamic dispatch.
+-
+
- 🌟🌟 +
++trait Foo { + fn method(&self) -> String; +} + +impl Foo for u8 { + fn method(&self) -> String { format!("u8: {}", *self) } +} + +impl Foo for String { + fn method(&self) -> String { format!("string: {}", *self) } +} + +// IMPLEMENT below with generics. +fn static_dispatch... + +// Implement below with trait objects. +fn dynamic_dispatch... + +fn main() { + let x = 5u8; + let y = "Hello".to_string(); + + static_dispatch(x); + dynamic_dispatch(&y); + + println!("Success!"); +}
Object safe
+You can only make object-safe traits into trait objects. A trait is object safe if all the methods defined in the trait have the following properties:
+-
+
- The return type isn’t
Self.
+ - There are no generic type parameters. +
-
+
- 🌟🌟🌟🌟 +
++// Use at least two approaches to make it work. +// DON'T add/remove any code line. +trait MyTrait { + fn f(&self) -> Self; +} + +impl MyTrait for u32 { + fn f(&self) -> Self { 42 } +} + +impl MyTrait for String { + fn f(&self) -> Self { self.clone() } +} + +fn my_function(x: Box<dyn MyTrait>) { + x.f() +} + +fn main() { + my_function(Box::new(13_u32)); + my_function(Box::new(String::from("abc"))); + + println!("Success!"); +}
++You can find the solutions here(under the solutions path), but only use it when you need it :)
+
Advance Traits
+Associated types
+The use of "Associated types" improves the overall readability of code by moving inner types locally into a trait as output types. For example :
++#![allow(unused)] +fn main() { +pub trait CacheableItem: Clone + Default + fmt::Debug + Decodable + Encodable { + type Address: AsRef<[u8]> + Clone + fmt::Debug + Eq + Hash; + fn is_null(&self) -> bool; +} +}
Using of Address is much more clearer and convenient than AsRef<[u8]> + Clone + fmt::Debug + Eq + Hash.
-
+
- 🌟🌟🌟 +
++struct Container(i32, i32); + +// USING associated types to re-implement trait Contains. +// trait Contains { +// type A; +// type B; + +trait Contains<A, B> { + fn contains(&self, _: &A, _: &B) -> bool; + fn first(&self) -> i32; + fn last(&self) -> i32; +} + +impl Contains<i32, i32> for Container { + fn contains(&self, number_1: &i32, number_2: &i32) -> bool { + (&self.0 == number_1) && (&self.1 == number_2) + } + // Grab the first number. + fn first(&self) -> i32 { self.0 } + + // Grab the last number. + fn last(&self) -> i32 { self.1 } +} + +fn difference<A, B, C: Contains<A, B>>(container: &C) -> i32 { + container.last() - container.first() +} + +fn main() { + let number_1 = 3; + let number_2 = 10; + + let container = Container(number_1, number_2); + + println!("Does container contain {} and {}: {}", + &number_1, &number_2, + container.contains(&number_1, &number_2)); + println!("First number: {}", container.first()); + println!("Last number: {}", container.last()); + + println!("The difference is: {}", difference(&container)); +}
Default Generic Type Parameters
+When we use generic type parameters, we can specify a default concrete type for the generic type. This eliminates the need for implementors of the trait to specify a concrete type if the default type works.
+-
+
- 🌟🌟 +
++use std::ops::Sub; + +#[derive(Debug, PartialEq)] +struct Point<T> { + x: T, + y: T, +} + +// FILL in the blank in three ways: two of them use the default generic parameters, the other one not. +// Notice that the implementation uses the associated type `Output`. +impl __ { + type Output = Self; + + fn sub(self, other: Self) -> Self::Output { + Point { + x: self.x - other.x, + y: self.y - other.y, + } + } +} + +fn main() { + assert_eq!(Point { x: 2, y: 3 } - Point { x: 1, y: 0 }, + Point { x: 1, y: 3 }); + + println!("Success!"); +}
Fully Qualified Syntax
+Nothing in Rust prevents a trait from having a method with the same name as another trait’s method, nor does Rust prevent you from implementing both traits on one type. It’s also possible to implement a method directly on the type with the same name as methods from traits.
+When calling methods with the same name, we have to use Fully Qualified Syntax.
+Example
++trait UsernameWidget { + // Get the selected username out of this widget + fn get(&self) -> String; +} + +trait AgeWidget { + // Get the selected age out of this widget + fn get(&self) -> u8; +} + +// A form with both a UsernameWidget and an AgeWidget. +struct Form { + username: String, + age: u8, +} + +impl UsernameWidget for Form { + fn get(&self) -> String { + self.username.clone() + } +} + +impl AgeWidget for Form { + fn get(&self) -> u8 { + self.age + } +} + +fn main() { + let form = Form{ + username: "rustacean".to_owned(), + age: 28, + }; + + // If you uncomment this line, you'll get an error saying + // "multiple `get` found". Because, after all, there are multiple methods + // named `get`. + // println!("{}", form.get()); + + let username = UsernameWidget::get(&form); + assert_eq!("rustacean".to_owned(), username); + let age = AgeWidget::get(&form); // You can also use `<Form as AgeWidget>::get` + assert_eq!(28, age); + + println!("Success!"); +}
Exercise
+-
+
- 🌟🌟 +
+trait Pilot { + fn fly(&self) -> String; +} + +trait Wizard { + fn fly(&self) -> String; +} + +struct Human; + +impl Pilot for Human { + fn fly(&self) -> String { + String::from("This is your captain speaking.") + } +} + +impl Wizard for Human { + fn fly(&self) -> String { + String::from("Up!") + } +} + +impl Human { + fn fly(&self) -> String { + String::from("*waving arms furiously*") + } +} + +fn main() { + let person = Human; + + assert_eq!(__, "This is your captain speaking."); + assert_eq!(__, "Up!"); + + assert_eq!(__, "*waving arms furiously*"); + + println!("Success!"); +}
Supertraits
+Sometimes, you might need one trait to use another trait’s functionality( like the "inheritance" in other languages ). In this case, you need to rely on the dependent trait also being implemented. The trait you rely on is a supertrait of the trait you’re implementing.
-
+
- 🌟🌟🌟 +
++trait Person { + fn name(&self) -> String; +} + +// Person is a supertrait of Student. +// Implementing Student requires you to also impl Person. +trait Student: Person { + fn university(&self) -> String; +} + +trait Programmer { + fn fav_language(&self) -> String; +} + +// CompSciStudent (computer science student) is a subtrait of both Programmer +// and Student. Implementing CompSciStudent requires you to impl both supertraits. +trait CompSciStudent: Programmer + Student { + fn git_username(&self) -> String; +} + +fn comp_sci_student_greeting(student: &dyn CompSciStudent) -> String { + format!( + "My name is {} and I attend {}. My favorite language is {}. My Git username is {}", + student.name(), + student.university(), + student.fav_language(), + student.git_username() + ) +} + +struct CSStudent { + name: String, + university: String, + fav_language: String, + git_username: String +} + +// IMPLEMENT the necessary traits for CSStudent to make the code work +impl ... + +fn main() { + let student = CSStudent { + name: "Sunfei".to_string(), + university: "XXX".to_string(), + fav_language: "Rust".to_string(), + git_username: "sunface".to_string() + }; + + // FILL in the blank + println!("{}", comp_sci_student_greeting(__)); +}
Orphan Rules
+We can’t implement external traits on external types. For example, we can’t implement the Display trait on Vec<T> within our own crate, because Display and Vec<T> are defined in the standard library and aren’t local to our crate.
This restriction is often called the orphan rule, so named because the parent type is not present. This rule ensures that other people’s code can’t break your code and vice versa.
+It’s possible to get around this restriction using the newtype pattern, which involves creating a new type in a tuple struct.
+-
+
- 🌟🌟 +
+use std::fmt; + +// DEFINE a newtype `Pretty` here + + +impl fmt::Display for Pretty { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!(f, "\"{}\"", self.0.clone() + ", world") + } +} + +fn main() { + let w = Pretty("hello".to_string()); + println!("w = {}", w); +}
++You can find the solutions here(under the solutions path), but only use it when you need it :)
+
Collection Types
+Learning resources:
+-
+
- English: Rust Book Chapter 8 +
- 简体中文: Rust语言圣经 - 集合类型 +
String
+std::string::String is a UTF-8 encoded, growable string. It is the most common string type we used in daily development, it also has ownership over the string contents.
Basic operations
+-
+
- 🌟🌟 +
++// FILL in the blanks and FIX errors +// 1. Don't use `to_string()` +// 2. Don't add/remove any code line +fn main() { + let mut s: String = "hello, "; + s.push_str("world".to_string()); + s.push(__); + + move_ownership(s); + + assert_eq!(s, "hello, world!"); + + println!("Success!"); +} + +fn move_ownership(s: String) { + println!("ownership of \"{}\" is moved here!", s) +}
String and &str
+A String is stored as a vector of bytes (Vec<u8>), but guaranteed to always be a valid UTF-8 sequence. String is heap allocated, growable and not null terminated.
&str is a slice (&[u8]) that always points to a valid UTF-8 sequence, and can be used to view into a String, just like &[T] is a view into Vec<T>.
-
+
- 🌟🌟 +
+// FILL in the blanks +fn main() { + let mut s = String::from("hello, world"); + + let slice1: &str = __; // In two ways + assert_eq!(slice1, "hello, world"); + + let slice2 = __; + assert_eq!(slice2, "hello"); + + let slice3: __ = __; + slice3.push('!'); + assert_eq!(slice3, "hello, world!"); + + println!("Success!"); +}
-
+
- 🌟🌟 +
++// Question: how many heap allocations are happening here? +// Your answer: +fn main() { + // Create a String type based on `&str` + // The type of string literals is `&str` + let s: String = String::from("hello, world!"); + + // Create a slice point to String `s` + let slice: &str = &s; + + // Create a String type based on the recently created slice + let s: String = slice.to_string(); + + assert_eq!(s, "hello, world!"); + + println!("Success!"); +}
UTF-8 & Indexing
+Strings are always valid UTF-8. This has a few implications:
+-
+
- The first of which is that if you need a non-UTF-8 string, consider OsString. It is similar, but without the UTF-8 constraint. +
- The second implication is that you cannot index into a String. +
Indexing is intended to be a constant-time operation, but UTF-8 encoding does not allow us to do this. Furthermore, it’s not clear what sort of thing the index should return: a byte, a codepoint, or a grapheme cluster. The bytes and chars methods return iterators over the first two, respectively.
+-
+
- 🌟🌟🌟 You can't use index to access a char in a string, but you can use slice
&s1[start..end].
+
++// FILL in the blank and FIX errors +fn main() { + let s = String::from("hello, 世界"); + let slice1 = s[0]; //tips: `h` only takes 1 byte in UTF8 format + assert_eq!(slice1, "h"); + + let slice2 = &s[3..5]; // Tips: `中` takes 3 bytes in UTF8 format + assert_eq!(slice2, "世"); + + // Iterate through all chars in s + for (i, c) in s.__ { + if i == 7 { + assert_eq!(c, '世') + } + } + + println!("Success!"); +}
UTF8_slice
+You can use utf8_slice to slice UTF8 string, it can index chars instead of bytes.
+Example
++use utf8_slice; +fn main() { + let s = "The 🚀 goes to the 🌑!"; + + let rocket = utf8_slice::slice(s, 4, 5); + // Will equal "🚀" +}
-
+
- 🌟🌟🌟 +
++Tips: maybe you need
+from_utf8method
++// FILL in the blanks +fn main() { + let mut s = String::new(); + __; + + // Some bytes, in a vector + let v = vec![104, 101, 108, 108, 111]; + + // Turn a byte's vector into a String + let s1 = __; + + + assert_eq!(s, s1); + + println!("Success!"); +}
Representation
+A String is made up of three components: a pointer to some bytes, a length, and a capacity.
+The pointer points to an internal buffer String uses to store its data. The length is the number of bytes currently stored in the buffer( always stored on the heap ), and the capacity is the size of the buffer in bytes. As such, the length will always be less than or equal to the capacity.
+-
+
- 🌟🌟 If a String has enough capacity, adding elements to it will not re-allocate +
++// Modify the code below to print out: +// 25 +// 25 +// 25 +// Here, there’s no need to allocate more memory inside the loop. +fn main() { + let mut s = String::new(); + + println!("{}", s.capacity()); + + for _ in 0..2 { + s.push_str("hello"); + println!("{}", s.capacity()); + } + + println!("Success!"); +}
-
+
- 🌟🌟🌟 +
++// FILL in the blanks +use std::mem; + +fn main() { + let story = String::from("Rust By Practice"); + + // Prevent automatically dropping of the String's data + let mut story = mem::ManuallyDrop::new(story); + + let ptr = story.__(); + let len = story.__(); + let capacity = story.__(); + + assert_eq!(16, len); + + // We can rebuild a String out of ptr, len, and capacity. This is all + // unsafe because we are responsible for making sure the components are + // valid: + let s = unsafe { String::from_raw_parts(ptr, len, capacity) }; + + assert_eq!(*story, s); + + println!("Success!"); +}
Common methods
+More exercises of String methods can be found here.
+++You can find the solutions here(under the solutions path), but only use it when you need it
+
Vector
+Vectors are resizable arrays. Like slices, their size is not known at compile time, but they can grow or shrink at any time.
+Basic Operations
+-
+
- 🌟🌟🌟 +
++fn main() { + let arr: [u8; 3] = [1, 2, 3]; + + let v = Vec::from(arr); + is_vec(&v); + + let v = vec![1, 2, 3]; + is_vec(&v); + + // vec!(..) and vec![..] are same macros, so + let v = vec!(1, 2, 3); + is_vec(&v); + + // In code below, v is Vec<[u8; 3]> , not Vec<u8> + // USE Vec::new and `for` to rewrite the below code + let v1 = vec!(arr); + is_vec(&v1); + + assert_eq!(v, v1); + + println!("Success!"); +} + +fn is_vec(v: &Vec<u8>) {}
-
+
- 🌟🌟 A Vec can be extended with
extendmethod
+
++// FILL in the blank +fn main() { + let mut v1 = Vec::from([1, 2, 4]); + v1.pop(); + v1.push(3); + + let mut v2 = Vec::new(); + v2.__; + + assert_eq!(v1, v2); + + println!("Success!"); +}
Turn X Into Vec
+-
+
- 🌟🌟🌟 +
++// FILL in the blanks +fn main() { + // Array -> Vec + // impl From<[T; N]> for Vec + let arr = [1, 2, 3]; + let v1 = __(arr); + let v2: Vec<i32> = arr.__(); + + assert_eq!(v1, v2); + + + // String -> Vec + // impl From<String> for Vec + let s = "hello".to_string(); + let v1: Vec<u8> = s.__(); + + let s = "hello".to_string(); + let v2 = s.into_bytes(); + assert_eq!(v1, v2); + + // impl<'_> From<&'_ str> for Vec + let s = "hello"; + let v3 = Vec::__(s); + assert_eq!(v2, v3); + + // Iterators can be collected into vectors + let v4: Vec<i32> = [0; 10].into_iter().collect(); + assert_eq!(v4, vec![0; 10]); + + println!("Success!"); + }
Indexing
+-
+
- 🌟🌟🌟 +
++// FIX the error and IMPLEMENT the code +fn main() { + let mut v = Vec::from([1, 2, 3]); + for i in 0..5 { + println!("{:?}", v[i]) + } + + for i in 0..5 { + // IMPLEMENT the code here... + } + + assert_eq!(v, vec![2, 3, 4, 5, 6]); + + println!("Success!"); +}
Slicing
+A Vec can be mutable. On the other hand, slices are read-only objects. To get a slice, use &.
In Rust, it’s more common to pass slices as arguments rather than vectors when you just want to provide read access. The same goes for String and &str.
-
+
- 🌟🌟 +
++// FIX the errors +fn main() { + let mut v = vec![1, 2, 3]; + + let slice1 = &v[..]; + // Out of bounds will cause a panic + // You must use `v.len` here + let slice2 = &v[0..4]; + + assert_eq!(slice1, slice2); + + // Slices are read only + // Note: slice and &Vec are different + let vec_ref: &mut Vec<i32> = &mut v; + (*vec_ref).push(4); + let slice3 = &mut v[0..3]; + slice3.push(4); + + assert_eq!(slice3, &[1, 2, 3, 4]); + + println!("Success!"); +}
Capacity
+The capacity of a vector is the amount of space allocated for any future elements that will be added onto the vector. This is not to be confused with the length of a vector, which specifies the number of actual elements within the vector. If a vector’s length exceeds its capacity, its capacity will automatically be increased, but its elements will have to be reallocated.
+For example, a vector with capacity 10 and length 0 would be an empty vector with space for 10 more elements. Pushing 10 or fewer elements onto the vector will not change its capacity or cause reallocation to occur. However, if the vector’s length is increased to 11, it will have to reallocate, which can be slow. For this reason, it is recommended to use Vec::with_capacity whenever possible to specify how big the vector is expected to get.
-
+
- 🌟🌟 +
+// FIX the errors +fn main() { + let mut vec = Vec::with_capacity(10); + + // The vector contains no items, even though it has capacity for more + assert_eq!(vec.len(), __); + assert_eq!(vec.capacity(), 10); + + // These are all done without reallocating... + for i in 0..10 { + vec.push(i); + } + assert_eq!(vec.len(), __); + assert_eq!(vec.capacity(), __); + + // ...but this may make the vector reallocate + vec.push(11); + assert_eq!(vec.len(), 11); + assert!(vec.capacity() >= 11); + + + // Fill in an appropriate value to make the `for` done without reallocating + let mut vec = Vec::with_capacity(__); + for i in 0..100 { + vec.push(i); + } + + assert_eq!(vec.len(), __); + assert_eq!(vec.capacity(), __); + + println!("Success!"); +}
Store distinct types in Vector
+The elements in a vector must be the same type, for example , the code below will cause an error:
++fn main() { + let v = vec![1, 2.0, 3]; +}
But we can use enums or trait objects to store distinct types.
+-
+
- 🌟🌟 +
+#[derive(Debug)] +enum IpAddr { + V4(String), + V6(String), +} +fn main() { + // FILL in the blank + let v : Vec<IpAddr>= __; + + // Comparing two enums need to derive the PartialEq trait + assert_eq!(v[0], IpAddr::V4("127.0.0.1".to_string())); + assert_eq!(v[1], IpAddr::V6("::1".to_string())); + + println!("Success!"); +}
-
+
- 🌟🌟 +
+trait IpAddr { + fn display(&self); +} + +struct V4(String); +impl IpAddr for V4 { + fn display(&self) { + println!("ipv4: {:?}",self.0) + } +} +struct V6(String); +impl IpAddr for V6 { + fn display(&self) { + println!("ipv6: {:?}",self.0) + } +} + +fn main() { + // FILL in the blank + let v: __= vec![ + Box::new(V4("127.0.0.1".to_string())), + Box::new(V6("::1".to_string())), + ]; + + for ip in v { + ip.display(); + } +}
HashMap
+Where vectors store values by an integer index, HashMaps store values by key. It is a hash map implemented with quadratic probing and SIMD lookup. By default, HashMap uses a hashing algorithm selected to provide resistance against HashDoS attacks.
The default hashing algorithm is currently SipHash 1-3, though this is subject to change at any point in the future. While its performance is very competitive for medium sized keys, other hashing algorithms will outperform it for small keys such as integers as well as large keys such as long strings, though those algorithms will typically not protect against attacks such as HashDoS.
The hash table implementation is a Rust port of Google’s SwissTable. The original C++ version of SwissTable can be found here, and this CppCon talk gives an overview of how the algorithm works.
+Basic Operations
+-
+
- 🌟🌟 +
++// FILL in the blanks and FIX the errors +use std::collections::HashMap; +fn main() { + let mut scores = HashMap::new(); + scores.insert("Sunface", 98); + scores.insert("Daniel", 95); + scores.insert("Ashley", 69.0); + scores.insert("Katie", "58"); + + // Get returns an Option<&V> + let score = scores.get("Sunface"); + assert_eq!(score, Some(98)); + + if scores.contains_key("Daniel") { + // Indexing returns a value V + let score = scores["Daniel"]; + assert_eq!(score, __); + scores.remove("Daniel"); + } + + assert_eq!(scores.len(), __); + + for (name, score) in scores { + println!("The score of {} is {}", name, score); + } +}
-
+
- 🌟🌟 +
++use std::collections::HashMap; +fn main() { + let teams = [ + ("Chinese Team", 100), + ("American Team", 10), + ("France Team", 50), + ]; + + let mut teams_map1 = HashMap::new(); + for team in &teams { + teams_map1.insert(team.0, team.1); + } + + // IMPLEMENT team_map2 in two ways + // Tips: one of the approaches is to use `collect` method + let teams_map2... + + assert_eq!(teams_map1, teams_map2); + + println!("Success!"); +}
-
+
- 🌟🌟 +
++// FILL in the blanks +use std::collections::HashMap; +fn main() { + // Type inference lets us omit an explicit type signature (which + // would be `HashMap<&str, u8>` in this example). + let mut player_stats = HashMap::new(); + + // Insert a key only if it doesn't already exist + player_stats.entry("health").or_insert(100); + + assert_eq!(player_stats["health"], __); + + // Insert a key using a function that provides a new value only if it + // doesn't already exist + player_stats.entry("health").or_insert_with(random_stat_buff); + assert_eq!(player_stats["health"], __); + + // Ensures a value is in the entry by inserting the default if empty, and returns + // a mutable reference to the value in the entry. + let health = player_stats.entry("health").or_insert(50); + assert_eq!(health, __); + *health -= 50; + assert_eq!(*health, __); + + println!("Success!"); +} + +fn random_stat_buff() -> u8 { + // Could actually return some random value here - let's just return + // some fixed value for now + 42 +}
Requirements of HashMap key
+Any type that implements the Eq and Hash traits can be a key in HashMap. This includes:
-
+
bool(though not very useful since there is only two possible keys)
+int,uint, and all variations thereof
+Stringand&str(tips: you can have aHashMapkeyed byStringand call.get()with an&str)
+
Note that f32 and f64 do not implement Hash, likely because floating-point precision errors would make using them as hashmap keys horribly error-prone.
All collection classes implement Eq and Hash if their contained type also respectively implements Eq and Hash. For example, Vec<T> will implement Hash if Timplements Hash.
-
+
- 🌟🌟 +
++// FIX the errors +// Tips: `derive` is usually a good way to implement some common used traits +use std::collections::HashMap; + +struct Viking { + name: String, + country: String, +} + +impl Viking { + /// Creates a new Viking. + fn new(name: &str, country: &str) -> Viking { + Viking { + name: name.to_string(), + country: country.to_string(), + } + } +} + +fn main() { + // Use a HashMap to store the vikings' health points. + let vikings = HashMap::from([ + (Viking::new("Einar", "Norway"), 25), + (Viking::new("Olaf", "Denmark"), 24), + (Viking::new("Harald", "Iceland"), 12), + ]); + + // Use derived implementation to print the status of the vikings. + for (viking, health) in &vikings { + println!("{:?} has {} hp", viking, health); + } +}
Capacity
+Like vectors, HashMaps are growable, but HashMaps can also shrink themselves when they have excess space. You can create a HashMap with a certain starting capacity using HashMap::with_capacity(uint), or use HashMap::new() to get a HashMap with a default initial capacity (recommended).
Example
+++use std::collections::HashMap; +fn main() { + let mut map: HashMap<i32, i32> = HashMap::with_capacity(100); + map.insert(1, 2); + map.insert(3, 4); + // Indeed ,the capacity of HashMap is not 100, so we can't compare the equality here. + assert!(map.capacity() >= 100); + + // Shrinks the capacity of the map with a lower limit. It will drop + // down no lower than the supplied limit while maintaining the internal rules + // and possibly leaving some space in accordance with the resize policy. + + map.shrink_to(50); + assert!(map.capacity() >= 50); + + // Shrinks the capacity of the map as much as possible. It will drop + // down as much as possible while maintaining the internal rules + // and possibly leaving some space in accordance with the resize policy. + map.shrink_to_fit(); + assert!(map.capacity() >= 2); + println!("Success!"); +}
Ownership
+For types that implement the Copy trait, like i32 , the values are copied into HashMap. For owned values like String, the values will be moved and HashMap will be the owner of those values.
-
+
- 🌟🌟 +
+// FIX the errors with least changes +// DON'T remove any code line +use std::collections::HashMap; +fn main() { + let v1 = 10; + let mut m1 = HashMap::new(); + m1.insert(v1, v1); + println!("v1 is still usable after inserting to hashmap : {}", v1); + + let v2 = "hello".to_string(); + let mut m2 = HashMap::new(); + // Ownership moved here + m2.insert(v2, v1); + + assert_eq!(v2, "hello"); + + println!("Success!"); +}
Third-party Hash libs
+If the performance of SipHash 1-3 doesn't meet your requirements, you can find replacements in crates.io or github.com.
The usage of third-party hash looks like this:
++#![allow(unused)] +fn main() { +use std::hash::BuildHasherDefault; +use std::collections::HashMap; +// Introduce a third party hash function +use twox_hash::XxHash64; + + +let mut hash: HashMap<_, _, BuildHasherDefault<XxHash64>> = Default::default(); +hash.insert(42, "the answer"); +assert_eq!(hash.get(&42), Some(&"the answer")); +}
Type Conversion
+Learning resources:
+-
+
- English: Standary library +
- 简体中文: Rust语言圣经 - 所有权与借用 +
Convert by as
+Rust provides no implicit type conversion(coercion) between primitive types. But explicit type conversions can be performed using the as keyword.
-
+
- 🌟 +
+// FIX the errors and FILL in the blank +// DON'T remove any code +fn main() { + let decimal = 97.123_f32; + + let integer: __ = decimal as u8; + + let c1: char = decimal as char; + let c2 = integer as char; + + assert_eq!(integer, 'b' as u8); + + println!("Success!"); +}
-
+
- 🌟🌟 By default, overflow will cause compile errors, but we can add an global annotation to suppress these errors. +
+fn main() { + assert_eq!(u8::MAX, 255); + // The max of `u8` is 255 as shown above. + // so the below code will cause an overflow error: literal out of range for `u8`. + // PLEASE looking for clues within compile errors to FIX it. + // DON'T modify any code in main. + let v = 1000 as u8; + + println!("Success!"); +}
-
+
- 🌟🌟 When casting any value to an unsigned type
T,T::MAX + 1is added or subtracted until the value fits into the new type.
+
+fn main() { + assert_eq!(1000 as u16, __); + + assert_eq!(1000 as u8, __); + + // For positive numbers, this is the same as the modulus + println!("1000 mod 256 is : {}", 1000 % 256); + + assert_eq!(-1_i8 as u8, __); + + // Since Rust 1.45, the `as` keyword performs a *saturating cast* + // when casting from float to int. If the floating point value exceeds + // the upper bound or is less than the lower bound, the returned value + // will be equal to the bound crossed. + assert_eq!(300.1_f32 as u8, __); + assert_eq!(-100.1_f32 as u8, __); + + + // This behavior incurs a small runtime cost and can be avoided + // with unsafe methods, however the results might overflow and + // return **unsound values**. Use these methods wisely: + unsafe { + // 300.0 is 44 + println!("300.0 is {}", 300.0_f32.to_int_unchecked::<u8>()); + // -100.0 as u8 is 156 + println!("-100.0 as u8 is {}", (-100.0_f32).to_int_unchecked::<u8>()); + // nan as u8 is 0 + println!("nan as u8 is {}", f32::NAN.to_int_unchecked::<u8>()); + } +}
-
+
- 🌟🌟🌟 Raw pointers can be converted to memory address (integer) and vice versa. +
++// FILL in the blanks +fn main() { + let mut values: [i32; 2] = [1, 2]; + let p1: *mut i32 = values.as_mut_ptr(); + let first_address: usize = p1 __; + let second_address = first_address + 4; // 4 == std::mem::size_of::<i32>() + let p2: *mut i32 = second_address __; // p2 points to the 2nd element in values + unsafe { + // Add one to the second element + __ + } + + assert_eq!(values[1], 3); + + println!("Success!"); +}
-
+
- 🌟🌟🌟 +
+fn main() { + let arr :[u64; 13] = [0; 13]; + assert_eq!(std::mem::size_of_val(&arr), 8 * 13); + let a: *const [u64] = &arr; + let b = a as *const [u8]; + unsafe { + assert_eq!(std::mem::size_of_val(&*b), __) + } + + println!("Success!"); +}
++You can find the solutions here(under the solutions path), but only use it when you need it
+
From/Into
+The From trait allows for a type to define how to create itself from another type, hence providing a very simple mechanism for converting between several types.
The From and Into traits are inherently linked, and this is actually part of its implementation. It means if we write something like this: impl From<T> for U, then we can use
+let u: U = U::from(T) or let u:U = T.into().
The Into trait is simply the reciprocal of the From trait. That is, if you have implemented the From trait for your type, then the Into trait will be automatically implemented for the same type.
Using the Into trait will typically require the type annotations as the compiler is unable to determine this most of the time.
For example, we can easily convert &str into String :
+fn main() { + let my_str = "hello"; + + // three conversions below all depends on the fact: String implements From<&str>: + let string1 = String::from(my_str); + let string2 = my_str.to_string(); + // Explicit type annotation is required here + let string3: String = my_str.into(); +}
Because the standard library has already implemented this for us : impl From<&'_ str> for String .
Some implementations of From trait can be found here.
-
+
- 🌟🌟🌟 +
+fn main() { + // impl From<bool> for i32 + let i1: i32 = false.into(); + let i2: i32 = i32::from(false); + assert_eq!(i1, i2); + assert_eq!(i1, 0); + + // FIX the error in two ways + /* 1. use a similar type which `impl From<char>`, maybe you + should check the docs mentioned above to find the answer */ + // 2. a keyword from the last chapter + let i3: i32 = 'a'.into(); + + // FIX the error in two ways + let s: String = 'a' as String; + + println!("Success!"); +}
Implement From for custom types
+-
+
- 🌟🌟 +
+// From is now included in `std::prelude`, so there is no need to introduce it into the current scope +// use std::convert::From; + +#[derive(Debug)] +struct Number { + value: i32, +} + +impl From<i32> for Number { + // IMPLEMENT `from` method +} + +// FILL in the blanks +fn main() { + let num = __(30); + assert_eq!(num.value, 30); + + let num: Number = __; + assert_eq!(num.value, 30); + + println!("Success!"); +}
-
+
- 🌟🌟🌟 When performing error handling it is often useful to implement
Fromtrait for our own error type. Then we can use?to automatically convert the underlying error type to our own error type.
+
+use std::fs; +use std::io; +use std::num; + +enum CliError { + IoError(io::Error), + ParseError(num::ParseIntError), +} + +impl From<io::Error> for CliError { + // IMPLEMENT from method +} + +impl From<num::ParseIntError> for CliError { + // IMPLEMENT from method +} + +fn open_and_parse_file(file_name: &str) -> Result<i32, CliError> { + // ? automatically converts io::Error to CliError + let contents = fs::read_to_string(&file_name)?; + // num::ParseIntError -> CliError + let num: i32 = contents.trim().parse()?; + Ok(num) +} + +fn main() { + println!("Success!"); +}
TryFrom/TryInto
+Similar to From and Into, TryFrom and TryInto are generic traits for converting between types.
Unlike From/Into, TryFrom and TryInto are used for fallible conversions and return a Result instead of a plain value.
-
+
- 🌟🌟 +
+// TryFrom and TryInto are included in `std::prelude`, so there is no need to introduce it into the current scope +// use std::convert::TryInto; + +fn main() { + let n: i16 = 256; + + // Into trait has a method `into`, + // hence TryInto has a method ? + let n: u8 = match n.__() { + Ok(n) => n, + Err(e) => { + println!("there is an error when converting: {:?}, but we catch it", e.to_string()); + 0 + } + }; + + assert_eq!(n, __); + + println!("Success!"); +}
-
+
- 🌟🌟🌟 +
+#[derive(Debug, PartialEq)] +struct EvenNum(i32); + +impl TryFrom<i32> for EvenNum { + type Error = (); + + // IMPLEMENT `try_from` + fn try_from(value: i32) -> Result<Self, Self::Error> { + if value % 2 == 0 { + Ok(EvenNum(value)) + } else { + Err(()) + } + } +} + +fn main() { + assert_eq!(EvenNum::try_from(8), Ok(EvenNum(8))); + assert_eq!(EvenNum::try_from(5), Err(())); + + // FILL in the blanks + let result: Result<EvenNum, ()> = 8i32.try_into(); + assert_eq!(result, __); + let result: Result<EvenNum, ()> = 5i32.try_into(); + assert_eq!(result, __); + + println!("Success!"); +}
++You can find the solutions here(under the solutions path), but only use it when you need it
+
Others
+Convert any type to String
+To convert any type to String, you can simply use the ToString trait for that type. Rather than doing that directly, you should implement the fmt::Display trait which will automatically provides ToString and also allows you to print the type with println!.
-
+
- 🌟🌟 +
+use std::fmt; + +struct Point { + x: i32, + y: i32, +} + +impl fmt::Display for Point { + // IMPLEMENT fmt method +} + +fn main() { + let origin = Point { x: 0, y: 0 }; + // FILL in the blanks + assert_eq!(origin.__, "The point is (0, 0)"); + assert_eq!(format!(__), "The point is (0, 0)"); + + println!("Success!"); +}
Parse a String
+-
+
- 🌟🌟🌟 We can use
parsemethod to convert aStringinto ai32number, this is becauseFromStris implemented fori32type in standard library:impl FromStr for i32
+
+// To use `from_str` method, you need to introduce this trait into the current scope. +use std::str::FromStr; +fn main() { + let parsed: i32 = "5".__.unwrap(); + let turbo_parsed = "10".__.unwrap(); + let from_str = __.unwrap(); + let sum = parsed + turbo_parsed + from_str; + assert_eq!(sum, 35); + + println!("Success!"); +}
-
+
- 🌟🌟 We can also implement the
FromStrtrait for our custom types
+
+use std::str::FromStr; +use std::num::ParseIntError; + +#[derive(Debug, PartialEq)] +struct Point { + x: i32, + y: i32 +} + +impl FromStr for Point { + type Err = ParseIntError; + + fn from_str(s: &str) -> Result<Self, Self::Err> { + let coords: Vec<&str> = s.trim_matches(|p| p == '(' || p == ')' ) + .split(',') + .map(|x| x.trim()) + .collect(); + + let x_fromstr = coords[0].parse::<i32>()?; + let y_fromstr = coords[1].parse::<i32>()?; + + Ok(Point { x: x_fromstr, y: y_fromstr }) + } +} +fn main() { + // FILL in the blanks in two ways + // DON'T change code anywhere else + let p = __; + assert_eq!(p.unwrap(), Point{ x: 3, y: 4} ); + + println!("Success!"); +}
Deref
+You can find all the examples and exercises of the Deref trait here.
Transmute
+std::mem::transmute is a unsafe function can be used to reinterprets the bits of a value of one type as another type. Both of the original and the result types must have the same size and neither of them can be invalid.
transmute is semantically equivalent to a bitwise move of one type into another. It copies the bits from the source value into the destination value, then forgets the original, seems equivalent to C's memcpy under the hood.
So, transmute is incredibly unsafe ! The caller has to ensure all the safes himself!
Examples
+-
+
transmutecan be used to turn a pointer into a function pointer, this is not portable on machines where function pointer and data pointer have different sizes.
+
+fn foo() -> i32 { + 0 +} + +fn main() { + let pointer = foo as *const (); + let function = unsafe { + std::mem::transmute::<*const (), fn() -> i32>(pointer) + }; + assert_eq!(function(), 0); +}
-
+
- Extending a lifetime or shortening the lifetime of an invariant is an advanced usage of
transmute, yeah, very unsafe Rust!.
+
+struct R<'a>(&'a i32); +unsafe fn extend_lifetime<'b>(r: R<'b>) -> R<'static> { + std::mem::transmute::<R<'b>, R<'static>>(r) +} + +unsafe fn shorten_invariant_lifetime<'b, 'c>(r: &'b mut R<'static>) + -> &'b mut R<'c> { + std::mem::transmute::<&'b mut R<'static>, &'b mut R<'c>>(r) +}
-
+
- Rather than using
transmute, you can use some alternatives instead.
+
+fn main() { + /*Turning raw bytes(&[u8]) to u32, f64, etc.: */ + let raw_bytes = [0x78, 0x56, 0x34, 0x12]; + + let num = unsafe { std::mem::transmute::<[u8; 4], u32>(raw_bytes) }; + + // Use `u32::from_ne_bytes` instead + let num = u32::from_ne_bytes(raw_bytes); + // Or use `u32::from_le_bytes` or `u32::from_be_bytes` to specify the endianness + let num = u32::from_le_bytes(raw_bytes); + assert_eq!(num, 0x12345678); + let num = u32::from_be_bytes(raw_bytes); + assert_eq!(num, 0x78563412); + + /*Turning a pointer into a usize: */ + let ptr = &0; + let ptr_num_transmute = unsafe { std::mem::transmute::<&i32, usize>(ptr) }; + + // Use an `as` cast instead + let ptr_num_cast = ptr as *const i32 as usize; + + /*Turning an &mut T into an &mut U: */ + let ptr = &mut 0; + let val_transmuted = unsafe { std::mem::transmute::<&mut i32, &mut u32>(ptr) }; + + // Now, put together `as` and reborrowing - note the chaining of `as` + // `as` is not transitive + let val_casts = unsafe { &mut *(ptr as *mut i32 as *mut u32) }; + + /*Turning an &str into a &[u8]: */ + // This is not a good way to do this. + let slice = unsafe { std::mem::transmute::<&str, &[u8]>("Rust") }; + assert_eq!(slice, &[82, 117, 115, 116]); + + // You could use `str::as_bytes` + let slice = "Rust".as_bytes(); + assert_eq!(slice, &[82, 117, 115, 116]); + + // Or, just use a byte string, if you have control over the string + // literal + assert_eq!(b"Rust", &[82, 117, 115, 116]); +}
++You can find the solutions here(under the solutions path), but only use it when you need it
+
Result and panic
+Learning resources:
+-
+
- English: Rust Book 9.1, 9.2 +
- 简体中文: Rust语言圣经 - 返回值和错误处理 +
panic!
+The simplest error handling mechanism is to use panic. It just prints an error message and starts unwinding the stack, finally exit the current thread:
-
+
- if panic occurred in
mainthread, then the program will be exited.
+ - if in spawned thread, then this thread will be terminated, but the program won't +
-
+
- 🌟🌟 +
++// FILL the blanks +fn drink(beverage: &str) { + if beverage == "lemonade" { + println!("Success!"); + // IMPLEMENT the below code + __ + } + + println!("Exercise Failed if printing out this line!"); +} + +fn main() { + drink(__); + + println!("Exercise Failed if printing out this line!"); +}
common panic cases
+-
+
- 🌟🌟 +
+// MAKE the code work by fixing all panics +fn main() { + assert_eq!("abc".as_bytes(), [96, 97, 98]); + + let v = vec![1, 2, 3]; + let ele = v[3]; + // unwrap may panic when get return a None + let ele = v.get(3).unwrap(); + + // Sometimes, the compiler is unable to find the overflow errors for you in compile time ,so a panic will occur + let v = production_rate_per_hour(2); + + // because of the same reason as above, we have to wrap it in a function to make the panic occur + divide(15, 0); + + println!("Success!") +} + +fn divide(x:u8, y:u8) { + println!("{}", x / y) +} + +fn production_rate_per_hour(speed: u8) -> f64 { + let cph: u8 = 221; + match speed { + 1..=4 => (speed * cph) as f64, + 5..=8 => (speed * cph) as f64 * 0.9, + 9..=10 => (speed * cph) as f64 * 0.77, + _ => 0 as f64, + } +} + +pub fn working_items_per_minute(speed: u8) -> u32 { + (production_rate_per_hour(speed) / 60 as f64) as u32 +}
Detailed call stack
+By default the stack unwinding will only give something like this:
+thread 'main' panicked at 'index out of bounds: the len is 3 but the index is 99', src/main.rs:4:5
+note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
+Though there is the reason of panic and the line of the code is showing where the panic has occured, sometimes we want to get more info about the call stack.
+-
+
- 🌟 +
## FILL in the blank to display the whole call stack
+## Tips: you can find the clue in the default panic info
+$ __ cargo run
+thread 'main' panicked at 'assertion failed: `(left == right)`
+ left: `[97, 98, 99]`,
+ right: `[96, 97, 98]`', src/main.rs:3:5
+stack backtrace:
+ 0: rust_begin_unwind
+ at /rustc/9d1b2106e23b1abd32fce1f17267604a5102f57a/library/std/src/panicking.rs:498:5
+ 1: core::panicking::panic_fmt
+ at /rustc/9d1b2106e23b1abd32fce1f17267604a5102f57a/library/core/src/panicking.rs:116:14
+ 2: core::panicking::assert_failed_inner
+ 3: core::panicking::assert_failed
+ at /rustc/9d1b2106e23b1abd32fce1f17267604a5102f57a/library/core/src/panicking.rs:154:5
+ 4: study_cargo::main
+ at ./src/main.rs:3:5
+ 5: core::ops::function::FnOnce::call_once
+ at /rustc/9d1b2106e23b1abd32fce1f17267604a5102f57a/library/core/src/ops/function.rs:227:5
+note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace.
+unwinding and abort
+By default, when a panic occurs, the program starts unwinding, which means Rust walks back up the stack and cleans up the data from each function it encounters.
But this walk back and clean up is a lot of work. The alternative is to immediately abort the program without cleaning up.
+If in your project you need to make the resulting binary as small as possible, you can switch from unwinding to aborting by adding below content to Cargo.toml:
[profile.release]
+panic = 'abort'
+++You can find the solutions here(under the solutions path), but only use it when you need it :)
+
result and ?
+Result<T> is an enum to describe possible errors. It has two variants:
-
+
Ok(T): A value T was found
+Err(e): An error was found with a valuee
+
In short words, the expected outcome is Ok, while the unexpected outcome is Err.
-
+
- 🌟🌟 +
++// FILL in the blanks and FIX the errors +use std::num::ParseIntError; + +fn multiply(n1_str: &str, n2_str: &str) -> __ { + let n1 = n1_str.parse::<i32>(); + let n2 = n2_str.parse::<i32>(); + Ok(n1.unwrap() * n2.unwrap()) +} + +fn main() { + let result = multiply("10", "2"); + assert_eq!(result, __); + + let result = multiply("t", "2"); + assert_eq!(result.__, 8); + + println!("Success!"); +}
?
+? is almost exactly equivalent to unwrap, but ? returns instead of panic on Err.
-
+
- 🌟🌟 +
++use std::num::ParseIntError; + +// IMPLEMENT multiply with ? +// DON'T use unwrap here +fn multiply(n1_str: &str, n2_str: &str) -> __ { +} + +fn main() { + assert_eq!(multiply("3", "4").unwrap(), 12); + println!("Success!"); +}
-
+
- 🌟🌟 +
++use std::fs::File; +use std::io::{self, Read}; + +fn read_file1() -> Result<String, io::Error> { + let f = File::open("hello.txt"); + let mut f = match f { + Ok(file) => file, + Err(e) => return Err(e), + }; + + let mut s = String::new(); + match f.read_to_string(&mut s) { + Ok(_) => Ok(s), + Err(e) => Err(e), + } +} + +// FILL in the blanks with one code line +// DON'T change any code lines +fn read_file2() -> Result<String, io::Error> { + let mut s = String::new(); + + __; + + Ok(s) +} + +fn main() { + assert_eq!(read_file1().unwrap_err().to_string(), read_file2().unwrap_err().to_string()); + println!("Success!"); +}
map & and_then
+map and and_then are two common combinators for Result<T, E> (also for Option<T>).
-
+
- 🌟🌟 +
+use std::num::ParseIntError; + +// FILL in the blank in two ways: map, and then +fn add_two(n_str: &str) -> Result<i32, ParseIntError> { + n_str.parse::<i32>().__ +} + +fn main() { + assert_eq!(add_two("4").unwrap(), 6); + + println!("Success!"); +}
-
+
- 🌟🌟🌟 +
+use std::num::ParseIntError; + +// With the return type rewritten, we use pattern matching without `unwrap()`. +// But it's so Verbose... +fn multiply(n1_str: &str, n2_str: &str) -> Result<i32, ParseIntError> { + match n1_str.parse::<i32>() { + Ok(n1) => { + match n2_str.parse::<i32>() { + Ok(n2) => { + Ok(n1 * n2) + }, + Err(e) => Err(e), + } + }, + Err(e) => Err(e), + } +} + +// Rewriting `multiply` to make it succinct +// You should use BOTH of `and_then` and `map` here. +fn multiply1(n1_str: &str, n2_str: &str) -> Result<i32, ParseIntError> { + // IMPLEMENT... +} + +fn print(result: Result<i32, ParseIntError>) { + match result { + Ok(n) => println!("n is {}", n), + Err(e) => println!("Error: {}", e), + } +} + +fn main() { + // This still presents a reasonable answer. + let twenty = multiply1("10", "2"); + print(twenty); + + // The following now provides a much more helpful error message. + let tt = multiply("t", "2"); + print(tt); + + println!("Success!"); +}
Type alias
+Using std::result::Result<T, ParseIntError> everywhere is verbose and tedious, we can use alias for this purpose.
At a module level, creating aliases can be particularly helpful. Errors found in a specific module often has the same Err type, so a single alias can succinctly defined all associated Results. This is so useful even the std library supplies one: io::Result.
-
+
- 🌟 +
+use std::num::ParseIntError; + +// FILL in the blank +type __; + +// Use the above alias to refer to our specific `Result` type. +fn multiply(first_number_str: &str, second_number_str: &str) -> Res<i32> { + first_number_str.parse::<i32>().and_then(|first_number| { + second_number_str.parse::<i32>().map(|second_number| first_number * second_number) + }) +} + +// Here, the alias again allows us to save some space. +fn print(result: Res<i32>) { + match result { + Ok(n) => println!("n is {}", n), + Err(e) => println!("Error: {}", e), + } +} + +fn main() { + print(multiply("10", "2")); + print(multiply("t", "2")); + + println!("Success!"); +}
Using Result in fn main
+Typically the main function will look like this:
+fn main() { + println!("Hello World!"); +}
However main is also able to have a return type of Result. If an error occurs within the main function it will return an error code and print a debug representation of the error( Debug trait ).
The following example shows such a scenario:
+++use std::num::ParseIntError; + +fn main() -> Result<(), ParseIntError> { + let number_str = "10"; + let number = match number_str.parse::<i32>() { + Ok(number) => number, + Err(e) => return Err(e), + }; + println!("{}", number); + Ok(()) +}
++You can find the solutions here(under the solutions path), but only use it when you need it :)
+
Crate and module
+Learning resources:
+-
+
- English: Rust Book Chapter 7 +
- 简体中文: Rust语言圣经 - 包和模块 +
Package and Crate
+A package is a project which you create with Cargo (in most cases), so it contains a Cargo.toml file in it.
-
+
- 🌟 Create a package with below layout: +
.
+├── Cargo.toml
+└── src
+ └── main.rs
+
+1 directory, 2 files
+# in Cargo.toml
+[package]
+name = "hello-package"
+version = "0.1.0"
+edition = "2021"
+++Note! We will use this package across the whole chapter as a practice project.
+
-
+
- 🌟 Create a package with below layout: +
.
+├── Cargo.toml
+└── src
+ └── lib.rs
+
+1 directory, 2 files
+# in Cargo.toml
+[package]
+name = "hello-package1"
+version = "0.1.0"
+edition = "2021"
+++Note! This package could be safely removed due to the first one's existence.
+
-
+
- 🌟 +
+/* FILL in the blank with your ANSWER */ + +// Q: What's the difference between package number 1 and number 2? +// A: __
Crate
+A crate is a binary or library. The crate root is a source file that the Rust compiler starts from and makes up the root module of the crate.
+In package hello-package, there is binary crate with the same name as the package : hello-package, and src/main.rs is the crate root of this binary crate.
Similar to hello-package, hello-package1 also has a crate in it, however, this package doesn't contain a binary crate but a library crate, and src/lib.rs is the crate root.
-
+
- 🌟 +
+/* FILL in the blank with your ANSWER */ + +// Q: What's the name of the library crate in package `hello-package1`? +// A: __
-
+
- 🌟🌟 Add a library crate for
hello-packageand describe it's files tree below:
+
# FILL in the blanks
+.
+├── Cargo.lock
+├── Cargo.toml
+├── src
+│ ├── __
+│ └── __
+After this step, there should be two crates in package hello-package: a binary crate and a library crate, both with the same name as the package.
-
+
- 🌟🌟🌟 A package can contain at most one library crate, but it can contain as many binary crates as you would like by placing files in
src/bindirectory: each file will be a separate binary crate with the same name as the file.
+
# Create a package which contains
+# 1. three binary crates: `hello-package`, `main1` and `main2`
+# 2. one library crate
+# describe the directory tree below
+.
+├── Cargo.toml
+├── Cargo.lock
+├── src
+│ ├── __
+│ ├── __
+│ └── __
+│ └── __
+│ └── __
+├── tests # directory for integrated tests files
+│ └── some_integration_tests.rs
+├── benches # dir for benchmark files
+│ └── simple_bench.rs
+└── examples # dir for example files
+ └── simple_example.rs
+Yep, as you can see, the above package structure is very standard and is widely used in many Rust projects.
+++You can find the solutions here (under the solutions path), but only use it when you need it :)
+
Module
+Modules let us organize the code within a crate into groups for readability and ease of reuse. Module also controls the privacy of items, which is whether an item can be seen by outside code( public ), or is just an internal implementation and not available for outside code( private ).
+We have created a package named hello-package in previous chapter, and it looks like this:
.
+├── Cargo.toml
+├── src
+│ ├── lib.rs
+│ └── main.rs
+Now it's time to create some modules in the library crate and use them in the binary crate, let's start.
+-
+
- 🌟🌟 Implement module
front_of_housebased on the module tree below:
+
library crate root
+ └── front_of_house
+ ├── hosting
+ │ ├── add_to_waitlist
+ │ └── seat_at_table
+ └── serving
+ ├── take_order
+ ├── serve_order
+ ├── take_payment
+ └── complain
++// FILL in the blank +// in __.rs + +mod front_of_house { + // IMPLEMENT this module.. +}
-
+
- 🌟🌟 Let's call
add_to_waitlistfrom a functioneat_at_restaurantwhich is within the library crate root.
+
+// In lib.rs + +// FILL in the blanks and FIX the errors +// You need to make something public with `pub` to provide accessibility for outside code `fn eat_at_restaurant()` +mod front_of_house { + /* ...snip... */ +} + +pub fn eat_at_restaurant() { + // Call add_to_waitlist with **absolute path**: + __.add_to_waitlist(); + + // Call with **relative path** + __.add_to_waitlist(); +}
-
+
- 🌟🌟 You can use
superto import items within the parent module
+
+// In lib.rs + +mod back_of_house { + fn fix_incorrect_order() { + cook_order(); + // FILL in the blank in three ways + //1. using keyword `super` + //2. using absolute path + __.serve_order(); + } + + fn cook_order() {} +}
Separating modules into different files
++// In lib.rs +pub mod front_of_house { + pub mod hosting { + pub fn add_to_waitlist() {} + + pub fn seat_at_table() -> String { + String::from("sit down please") + } + } + + pub mod serving { + pub fn take_order() {} + + pub fn serve_order() {} + + pub fn take_payment() {} + + // Maybe you don't want the guest hearing the your complaining about them + // So just make it private + fn complain() {} + } +} + +pub fn eat_at_restaurant() -> String { + front_of_house::hosting::add_to_waitlist(); + + back_of_house::cook_order(); + + String::from("yummy yummy!") +} + +pub mod back_of_house { + pub fn fix_incorrect_order() { + cook_order(); + crate::front_of_house::serving::serve_order(); + } + + pub fn cook_order() {} +}
-
+
- 🌟🌟🌟🌟 Please separate the modules and codes above into files resident in below dir tree : +
.
+├── Cargo.toml
+├── src
+│ ├── back_of_house.rs
+│ ├── front_of_house
+│ │ ├── hosting.rs
+│ │ ├── mod.rs
+│ │ └── serving.rs
+│ ├── lib.rs
+│ └── main.rs
++// In src/lib.rs + +// IMPLEMENT...
+// In src/back_of_house.rs + +// IMPLEMENT...
+// In src/front_of_house/mod.rs + +// IMPLEMENT...
+// In src/front_of_house/hosting.rs + +// IMPLEMENT...
+// In src/front_of_house/serving.rs + +// IMPLEMENT...
Accessing code in library crate from binary crate
+Please ensure you have completed the 4th exercise before making further progress.
+You should have below structures and the corresponding codes in them when reaching here:
+.
+├── Cargo.toml
+├── src
+│ ├── back_of_house.rs
+│ ├── front_of_house
+│ │ ├── hosting.rs
+│ │ ├── mod.rs
+│ │ └── serving.rs
+│ ├── lib.rs
+│ └── main.rs
+-
+
- 🌟🌟🌟 Now we will call a few library functions from the binary crate. +
+// In src/main.rs + +// FILL in the blank and FIX the errors +fn main() { + assert_eq!(__, "sit down please"); + assert_eq!(__,"yummy yummy!"); +}
++You can find the solutions here (under the solutions path), but only use it when you need it :)
+
Use and pub
+-
+
- 🌟 We can bring two types of the same name into the same scope with use, but you need
askeyword.
+
+use std::fmt::Result; +use std::io::Result; + +fn main() {}
-
+
- 🌟🌟 If we are using multiple items defined in the same crate or module, then listing each item on its own line will take up too much vertical space. +
++// FILL in the blank in two ways +// DON'T add new code line +use std::collections::__; + +fn main() { + let _c1:HashMap<&str, i32> = HashMap::new(); + let mut c2 = BTreeMap::new(); + c2.insert(1, "a"); + let _c3: HashSet<i32> = HashSet::new(); +}
Re-exporting names with pub use
+-
+
- 🌟🌟🌟 In our recently created package
hello-package, add something to make the below code work
+
+fn main() { + assert_eq!(hello_package::hosting::seat_at_table(), "sit down please"); + assert_eq!(hello_package::eat_at_restaurant(),"yummy yummy!"); +}
Pub(in Crate)
+Sometimes we want an item only be public to a certain crate. For this we can use the pub(in Crate) syntax.
Example
++pub mod a { + pub const I: i32 = 3; + + fn semisecret(x: i32) -> i32 { + use self::b::c::J; + x + J + } + + pub fn bar(z: i32) -> i32 { + semisecret(I) * z + } + pub fn foo(y: i32) -> i32 { + semisecret(I) + y + } + + mod b { + pub(in crate::a) mod c { + pub(in crate::a) const J: i32 = 4; + } + } +}
Full Code
+The full code of hello-package is here.
++You can find the solutions here (under the solutions path), but only use it when you need it :)
+
Comments and Docs
+Every program requires comments:
+Comments
+-
+
- Regular comments which are ignored by the compiler:
+
-
+
// Line comment, which goes to the end of the line
+/* Block comment, which goes to the end of the closing delimiter */
+
+
Examples
++fn main() { + // This is an example of a line comment + // There are two slashes at the beginning of the line + // And nothing written inside these will be read by the compiler + + // println!("Hello, world!"); + + // Run it. See? Now try deleting the two slashes, and run it again. + + /* + * This is another type of comment, a block comment. In general, + * line comments are the recommended comment style. But + * block comments are extremely useful for temporarily disabling + * chunks of code. /* Block comments can be /* nested, */ */ + * so it takes only a few keystrokes to comment out everything + * in this main() function. /*/*/* Try it yourself! */*/*/ + */ + + /* + Note: The previous column of `*` was entirely for style. There's + no actual need for it. + */ +}
Exercises
+-
+
- 🌟🌟 +
++/* Make it work, only using comments! */ +fn main() { + todo!(); + unimplemented!(); + + assert_eq!(6, 5 + 3 + 2 + 1 ) +}
Doc Comments
+-
+
- Doc comments which are parsed into HTML and supported
Markdown+-
+
/// Generate library docs for the following item
+//! Generate library docs for the eclosing item
+
+
Before starting, we need to create a new package for practice: cargo new --lib doc-comments.
Line doc comments ///
+Add docs for function add_one
+#![allow(unused)] +fn main() { +// in lib.rs + +/// Add one to the given value and return the value +/// +/// # Examples +/// +/// ``` +/// let arg = 5; +/// let answer = my_crate::add_one(arg); +/// +/// assert_eq!(6, answer); +/// ``` +pub fn add_one(x: i32) -> i32 { + x + 1 +} +}
Cargo doc
+We can use cargo doc --open to generate html files and open them in the browser.
Block doc comments /** ... */
+Add docs for function add_two:
+#![allow(unused)] +fn main() { +/** Add two to the given value and return a new value + +Examples + +let arg = 5; +let answer = my_crate::add_two(arg); + +assert_eq!(7, answer); + +*/ +pub fn add_two(x: i32) -> i32 { + x + 2 +} +}
Doc comments for crate and module
+We can also add doc comments for our crates and modules.
+Firstly, let's add some doc comments for our library crate:
+++Note: We must place crates and module comments at the top of crate root or module file.
+
+#![allow(unused)] +fn main() { +//! # Doc comments +//! +//! A library for showing how to use doc comments + +// in lib.rs +pub mod compute; +}
You can also use block comments to achieve this:
++#![allow(unused)] +fn main() { +/*! # Doc comments + + A library for showing how to use doc comments */ +}
Next, create a new module file src/compute.rs, and add following comments to it:
+#![allow(unused)] +fn main() { +//! //! Do some complicated arithmetic that you can't do by yourself + +// in compute.rs +}
Then run cargo doc --open and see the results.
Doc tests
+The doc comments of add_one and add_two contain two example code blocks.
The examples can not only demonstrate how to use your library, but also running as test with cargo test command.
-
+
- 🌟🌟 But there are errors in the two examples, please fix them, and running with
cargo testto get following result:
+
running 0 tests
+
+test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
+
+ Doc-tests doc-comments
+
+running 2 tests
+test src/lib.rs - add_one (line 11) ... ok
+test src/lib.rs - add_two (line 26) ... ok
+
+test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.55s
+-
+
- 🌟🌟 Sometimes we expect an example to be panic, add following code to
src/compute.rsand make thecargo testpassed.
+
++You can only modify the comments, DON'T modify
+fn div
+#![allow(unused)] +fn main() { +// in src/compute.rs + +/// # Panics +/// +/// The function panics if the second argument is zero. +/// +/// ```rust,should_panic +/// // panics on division by zero +/// doc_comments::compute::div(10, 0); +/// ``` +pub fn div(a: i32, b: i32) -> i32 { + if b == 0 { + panic!("Divide-by-zero error"); + } + + a / b +} +}
-
+
- 🌟🌟 Sometimes we want to hide the doc comments, but keep the doc tests. +
Add following code to src/compute.rs ,
+// in src/compute.rs + +/// ``` +/// # fn try_main() -> Result<(), String> { +/// # let res = doc_comments::compute::try_div(10, 0)?; +/// # Ok(()) // returning from try_main +/// # } +/// # fn main() { +/// # try_main().unwrap(); +/// # +/// # } +/// ``` +pub fn try_div(a: i32, b: i32) -> Result<i32, String> { + if b == 0 { + Err(String::from("Divide-by-zero")) + } else { + Ok(a / b) + } +}
and modify this code to achieve two goals:
+-
+
- The doc comments must not be presented in html files generated by
cargo doc --open
+ - run the tests, you should see results as below: +
running 0 tests
+
+test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
+
+ Doc-tests doc-comments
+
+running 4 tests
+test src/compute.rs - compute::div (line 7) ... ok
+test src/lib.rs - add_two (line 27) ... ok
+test src/lib.rs - add_one (line 11) ... ok
+test src/compute.rs - compute::try_div (line 20) ... ok
+
+test result: ok. 4 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.51s
+Code navigation
+Rust provide a very powerful feature for us, that is code navigation in doc comments.
+Add following code to src/lib.rs:
+#![allow(unused)] +fn main() { +// in lib.rs + +/// Add three to the given value and return a [`Option`] type +pub fn add_three(x: i32) -> Option<i32> { + Some(x + 3) +} +}
Besides jump into the standard library, you can also jump to another module in the package.
++#![allow(unused)] +fn main() { +// in lib.rs + +mod a { + /// Add four to the given value and return a [`Option`] type + /// [`crate::MySpecialFormatter`] + pub fn add_four(x: i32) -> Option<i32> { + Some(x + 4) + } +} + +struct MySpecialFormatter; +}
Doc attributes
+Below are a few examples of the most common #[doc] attributes used with rustdoc.
inline
+Used to inline docs, instead of linking out to separate page.
+#[doc(inline)]
+pub use bar::Bar;
+
+/// bar docs
+mod bar {
+ /// the docs for Bar
+ pub struct Bar;
+}no_inline
+Used to prevent linking out to separate page or anywhere.
+// Example from libcore/prelude
+#[doc(no_inline)]
+pub use crate::mem::drop;hidden
+Using this tells rustdoc not to include this in documentation:
// Example from the futures-rs library
+#[doc(hidden)]
+pub use self::async_await::*;For documentation, rustdoc is widely used by the community. It's what is used to generate the std library docs.
Full Code
+The full code of package doc-comments is here.
Formatted output
++fn main() { + // In general, the `{}` will be automatically replaced with any + // arguments. These will be stringified. + println!("{} days", 31); + + // Without a suffix, 31 becomes an i32. You can change what type 31 is + // by providing a suffix. The number 31i64 for example has the type i64. + + // There are various optional patterns this works with. Positional + // arguments can be used. + println!("{0}, this is {1}. {1}, this is {0}", "Alice", "Bob"); + + // As can named arguments. + println!("{subject} {verb} {object}", + object="the lazy dog", + subject="the quick brown fox", + verb="jumps over"); + + // Special formatting can be specified after a `:`. + println!("{} of {:b} people know binary, the other half doesn't", 1, 2); + + // You can right-align text with a specified width. This will output + // " 1". 5 white spaces and a "1". + println!("{number:>width$}", number=1, width=6); + + // You can pad numbers with extra zeroes. This will output "000001". + println!("{number:0>width$}", number=1, width=6); + + // Rust even checks to make sure the correct number of arguments are + // used. + println!("My name is {0}, {1} {0}", "Bond"); + // FIXME ^ Add the missing argument: "James" + + // Create a structure named `Structure` which contains an `i32`. + #[allow(dead_code)] + struct Structure(i32); + + // However, custom types such as this structure require more complicated + // handling. This will not work. + println!("This struct `{}` won't print...", Structure(3)); + // FIXME ^ Comment out this line. + + // For Rust 1.58 and above, you can directly capture the argument from + // surrounding variable. Just like the above, this will output + // " 1". 5 white spaces and a "1". + let number: f64 = 1.0; + let width: usize = 6; + println!("{number:>width$}"); +}
[std::fmt][fmt] contains many [traits][traits] which govern the display
+of text. The base form of two important ones are listed below:
-
+
fmt::Debug: Uses the{:?}marker. Format text for debugging purposes.
+fmt::Display: Uses the{}marker. Format text in a more elegant, user +friendly fashion.
+
Here, we used fmt::Display because the std library provides implementations
+for these types. To print text for custom types, more steps are required.
Implementing the fmt::Display trait automatically implements the
+[ToString] trait which allows us to [convert] the type to [String][string].
println! and format!
+Printing is handled by a series of [macros][macros] defined in [std::fmt][fmt]
+Some of which include:
-
+
format!: write formatted text to [String][string]
+print!: same asformat!but the text is printed to the console (io::stdout).
+println!: same asprint!but a newline is appended.
+eprint!: same asformat!but the text is printed to the standard error (io::stderr).
+eprintln!: same aseprint!but a newline is appended.
+
All parse text in the same fashion. As a plus, Rust checks format correctness at compile time.
+format!
+1.🌟
+++fn main() { + let s1 = "hello"; + /* Fill in the blank */ + let s = format!(__); + assert_eq!(s, "hello, world!"); +}
print!, println!
+2.🌟
+++fn main() { + /* Fill in the blanks to make it print: + Hello world, I am + Sunface! + */ + __("hello world, "); + __("I am"); + __("Sunface!"); +}
++You can find the solutions here(under the solutions path), but only use it when you need it :)
+
Debug and Display
+All types which want to be printable must implement the std::fmt formatting trait: std::fmt::Debug or std::fmt::Display.
Automatic implementations are only provided for types such as in the std library. All others have to be manually implemented.
Debug
+The implementation of Debug is very straightforward: All types can derive the std::fmt::Debug implementation. This is not true for std::fmt::Display which must be manually implemented.
{:?} must be used to print out the type which has implemented the Debug trait.
+#![allow(unused)] +fn main() { +// This structure cannot be printed either with `fmt::Display` or +// with `fmt::Debug`. +struct UnPrintable(i32); + +// To make this struct printable with `fmt::Debug`, we can derive the automatic implementations provided by Rust +#[derive(Debug)] +struct DebugPrintable(i32); +}
-
+
- 🌟 +
++/* Fill in the blanks and Fix the errors */ +struct Structure(i32); + +fn main() { + // Types in std and Rust have implemented the fmt::Debug trait + println!("__ months in a year.", 12); + + println!("Now __ will print!", Structure(3)); +}
-
+
- 🌟🌟 So
fmt::Debugdefinitely makes one type printable, but sacrifices some elegance. Maybe we can get more elegant by replacing{:?}with something else( but not{}!)
+
+#[derive(Debug)] +struct Person { + name: String, + age: u8 +} + +fn main() { + let person = Person { name: "Sunface".to_string(), age: 18 }; + + /* Make it output: + Person { + name: "Sunface", + age: 18, + } + */ + println!("{:?}", person); +}
-
+
- 🌟🌟 We can also manually implement
Debugtrait for our types
+
++#[derive(Debug)] +struct Structure(i32); + +#[derive(Debug)] +struct Deep(Structure); + + +fn main() { + // The problem with `derive` is there is no control over how + // the results look. What if I want this to just show a `7`? + + /* Make it print: Now 7 will print! */ + println!("Now {:?} will print!", Deep(Structure(7))); +}
Display
+Yeah, Debug is simple and easy to use. But sometimes we want to customize the output appearance of our type. This is where Display really shines.
Unlike Debug, there is no way to derive the implementation of the Display trait, we have to manually implement it.
Another thing to note: the placeholder for Display is {} not {:?}.
-
+
- 🌟🌟 +
++/* Make it work*/ +use std::fmt; + +struct Point2D { + x: f64, + y: f64, +} + +impl fmt::Display for Point2D { + /* Implement.. */ +} + +impl fmt::Debug for Point2D { + /* Implement.. */ +} + +fn main() { + let point = Point2D { x: 3.3, y: 7.2 }; + assert_eq!(format!("{}",point), "Display: 3.3 + 7.2i"); + assert_eq!(format!("{:?}",point), "Debug: Complex { real: 3.3, imag: 7.2 }"); + + println!("Success!"); +}
? operator
+Implementing fmt::Display for a structure whose elements must be handled separately is tricky. The problem is each write! generates a fmt::Result which must be handled in the same place.
Fortunately, Rust provides the ? operator to help us eliminate some unnecessary codes for dealing with fmt::Result.
-
+
- 🌟🌟 +
++/* Make it work */ +use std::fmt; + +struct List(Vec<i32>); + +impl fmt::Display for List { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + // Extract the value using tuple indexing, + // and create a reference to `vec`. + let vec = &self.0; + + write!(f, "[")?; + + // Iterate over `v` in `vec` while enumerating the iteration + // count in `count`. + for (count, v) in vec.iter().enumerate() { + // For every element except the first, add a comma. + // Use the ? operator to return on errors. + if count != 0 { write!(f, ", ")?; } + write!(f, "{}", v)?; + } + + // Close the opened bracket and return a fmt::Result value. + write!(f, "]") + } +} + +fn main() { + let v = List(vec![1, 2, 3]); + assert_eq!(format!("{}",v), "[0: 1, 1: 2, 2: 3]"); + println!("Success!"); +}
++You can find the solutions here(under the solutions path), but only use it when you need it :)
+
Formatting
+Positional arguments
+1.🌟🌟
++/* Fill in the blanks */ +fn main() { + println!("{0}, this is {1}. {1}, this is {0}", "Alice", "Bob"); // => Alice, this is Bob. Bob, this is Alice + assert_eq!(format!("{1}{0}", 1, 2), __); + assert_eq!(format!(__, 1, 2), "2112"); + println!("Success!"); +}
Named arguments
+2.🌟🌟
++fn main() { + println!("{argument}", argument = "test"); // => "test" + + /* Fill in the blanks */ + assert_eq!(format!("{name}{}", 1, __), "21"); + assert_eq!(format!(__,a = "a", b = 'b', c = 3 ), "a 3 b"); + + /* Fix the error */ + // Named argument must be placed after other arguments + println!("{abc} {1}", abc = "def", 2); + + println!("Success!"); +}
Padding with string
+3.🌟🌟 By default, you can pad string with spaces
++fn main() { + // The following two are padding with 5 spaces + println!("Hello {:5}!", "x"); // => "Hello x !" + println!("Hello {:1$}!", "x", 5); // => "Hello x !" + + /* Fill in the blanks */ + assert_eq!(format!("Hello __!", 5, "x"), "Hello x !"); + assert_eq!(format!("Hello __!", "x", width = 5), "Hello x !"); + + println!("Success!"); +}
4.🌟🌟🌟 Left align, right align, pad with specified characters.
++fn main() { + // Left align + println!("Hello {:<5}!", "x"); // => Hello x ! + // Right align + assert_eq!(format!("Hello __!", "x"), "Hello x!"); + // Center align + assert_eq!(format!("Hello __!", "x"), "Hello x !"); + + // Left align, pad with '&' + assert_eq!(format!("Hello {:&<5}!", "x"), __); + + println!("Success!"); +}
5.🌟🌟 You can pad numbers with extra zeros.
++fn main() { + println!("Hello {:5}!", 5); // => Hello 5! + println!("Hello {:+}!", 5); // => Hello +5! + println!("Hello {:05}!", 5); // => Hello 00005! + println!("Hello {:05}!", -5); // => Hello -0005! + + /* Fill in the blank */ + assert!(format!("{number:0>width$}", number=1, width=6) == __); + + println!("Success!") +;}
Precision
+6.🌟🌟 Floating point precision
+++/* Fill in the blanks */ +fn main() { + let v = 3.1415926; + + println!("{:.1$}", v, 4); // same as {:.4} => 3.1416 + + assert_eq!(format!("__", v), "3.14"); + assert_eq!(format!("__", v), "+3.14"); + assert_eq!(format!("__", v), "3"); + + println!("Success!"); +}
7.🌟🌟🌟 String length
++fn main() { + let s = "Hello, world!"; + + println!("{0:.5}", s); // => Hello + + assert_eq!(format!("Hello __!", 3, "abcdefg"), "Hello abc!"); + + println!("Success!"); +}
Binary, octal, hex
+-
+
- format!("{}", foo) -> "3735928559" +
- format!("0x{:X}", foo) -> "0xDEADBEEF" +
- format!("0o{:o}", foo) -> "0o33653337357" +
8.🌟🌟
++fn main() { + assert_eq!(format!("__", 27), "0b11011"); + assert_eq!(format!("__", 27), "0o33"); + assert_eq!(format!("__", 27), "0x1b"); + assert_eq!(format!("__", 27), "0x1B"); + + println!("{:x}!", 27); // Hex with no prefix => 1b + + println!("{:#010b}", 27); // Pad binary with 0, width = 10, => 0b00011011 + + println!("Success!"); +}
Capture the environment
+9.🌟🌟🌟
++fn get_person() -> String { + String::from("sunface") +} + +fn get_format() -> (usize, usize) { + (4, 1) +} + + +fn main() { + let person = get_person(); + println!("Hello, {person}!"); + + let (width, precision) = get_format(); + let scores = [("sunface", 99.12), ("jack", 60.34)]; + /* Make it print: + sunface: 99.1 + jack: 60.3 + */ + for (name, score) in scores { + println!("{name}: __"); + } +}
Others
+Example
++fn main() { + // Exponent + println!("{:2e}", 1000000000); // => 1e9 + println!("{:2E}", 1000000000); // => 1E9 + + // Pointer address + let v= vec![1, 2, 3]; + println!("{:p}", v.as_ptr()); // => 0x600002324050 + + // Escape + println!("Hello {{}}"); // => Hello {} +}
++You can find the solutions here(under the solutions path), but only use it when you need it :)
+
Lifetime
+Learning resources:
+-
+
- English: Rust Book 10.3 +
- 简体中文: Rust语言圣经 - 生命周期 +
Lifetime
+The compiler uses lifetime to ensure all borrows are valid. Typically, a variable's lifetime begins when it is created and ends when it is destroyed.
+The scope of lifetime
+-
+
- 🌟 +
+/* Annotate the lifetime of `i` and `borrow2` */ + +// Lifetimes are annotated below with lines denoting the creation +// and destruction of each variable. +// `i` has the longest lifetime because its scope entirely encloses +// both `borrow1` and `borrow2`. The duration of `borrow1` compared +// to `borrow2` is irrelevant since they are disjoint. +fn main() { + let i = 3; + { + let borrow1 = &i; // `borrow1` lifetime starts. ──┐ + // │ + println!("borrow1: {}", borrow1); // │ + } // `borrow1 ends. ──────────────────────────────────┘ + { + let borrow2 = &i; + + println!("borrow2: {}", borrow2); + } +}
-
+
- 🌟🌟 +
Example
++#![allow(unused)] +fn main() { +{ + let x = 5; // ----------+-- 'b + // | + let r = &x; // --+-- 'a | + // | | + println!("r: {}", r); // | | + // --+ | +} // ----------+ +}
+/* Annotate `r` and `x` as above, and explain why this code fails to compile, in the lifetime aspect. */ + +fn main() { + { + let r; // ---------+-- 'a + // | + { // | + let x = 5; // -+-- 'b | + r = &x; // | | + } // -+ | + // | + println!("r: {}", r); // | + } // ---------+ +}
Lifetime annotating
+The borrow checker uses explicit lifetime annotations to determine how long a reference should be valid.
+But for us users, in most cases, there is no need to annotate the lifetime, because there are several elision rules, before learning these rules, we need to know how to annotate lifetime manually.
+Function
+Ignoring elision rules, lifetimes in function signatures have a few constraints:
+-
+
- Any reference must have an annotated lifetime +
- Any reference being returned must have the same lifetime as one of the inputs or be static +
Example
++// One input reference with lifetime `'a` which must live +// at least as long as the function. +fn print_one<'a>(x: &'a i32) { + println!("`print_one`: x is {}", x); +} + +// Mutable references are possible with lifetimes as well. +fn add_one<'a>(x: &'a mut i32) { + *x += 1; +} + +// Multiple elements with different lifetimes. In this case, it +// would be fine for both to have the same lifetime `'a`, but +// in more complex cases, different lifetimes may be required. +fn print_multi<'a, 'b>(x: &'a i32, y: &'b i32) { + println!("`print_multi`: x is {}, y is {}", x, y); +} + +// Returning references that have been passed in is acceptable. +// However, the correct lifetime must be returned. +fn pass_x<'a, 'b>(x: &'a i32, _: &'b i32) -> &'a i32 { x } + +fn main() { + let x = 7; + let y = 9; + + print_one(&x); + print_multi(&x, &y); + + let z = pass_x(&x, &y); + print_one(z); + + let mut t = 3; + add_one(&mut t); + print_one(&t); +}
-
+
- 🌟 +
+/* Make it work by adding proper lifetime annotation */ +fn longest(x: &str, y: &str) -> &str { + if x.len() > y.len() { + x + } else { + y + } +} + +fn main() {}
-
+
- 🌟🌟🌟 +
+// `'a` must live longer than the function. +// Here, `&String::from("foo")` would create a `String`, followed by a +// reference. Then the data is dropped upon exiting the scope, leaving +// a reference to invalid data to be returned. + +/* Fix the error in three ways */ +fn invalid_output<'a>() -> &'a String { + &String::from("foo") +} + +fn main() { +}
-
+
- 🌟🌟 +
+// `print_refs` takes two references to `i32` which have different +// lifetimes `'a` and `'b`. These two lifetimes must both be at +// least as long as the function `print_refs`. +fn print_refs<'a, 'b>(x: &'a i32, y: &'b i32) { + println!("x is {} and y is {}", x, y); +} + +/* Make it work */ +// A function which takes no arguments, but has a lifetime parameter `'a`. +fn failed_borrow<'a>() { + let _x = 12; + + // ERROR: `_x` does not live long enough + let y: &'a i32 = &_x; + // Attempting to use the lifetime `'a` as an explicit type annotation + // inside the function will fail because the lifetime of `&_x` is shorter + // than `'a` . A short lifetime cannot be coerced into a longer one. +} + +fn main() { + let (four, nine) = (4, 9); + + // Borrows (`&`) of both variables are passed into the function. + print_refs(&four, &nine); + // Any input which is borrowed must outlive the borrower. + // In other words, the lifetime of `four` and `nine` must + // be longer than that of `print_refs`. + + failed_borrow(); + // `failed_borrow` contains no references to force `'a` to be + // longer than the lifetime of the function, but `'a` is longer. + // Because the lifetime is never constrained, it defaults to `'static`. +}
Structs
+-
+
- 🌟 +
+/* Make it work by adding proper lifetime annotation */ + +// A type `Borrowed` which houses a reference to an +// `i32`. The reference to `i32` must outlive `Borrowed`. +#[derive(Debug)] +struct Borrowed(&i32); + +// Similarly, both references here must outlive this structure. +#[derive(Debug)] +struct NamedBorrowed { + x: &i32, + y: &i32, +} + +// An enum which is either an `i32` or a reference to one. +#[derive(Debug)] +enum Either { + Num(i32), + Ref(&i32), +} + +fn main() { + let x = 18; + let y = 15; + + let single = Borrowed(&x); + let double = NamedBorrowed { x: &x, y: &y }; + let reference = Either::Ref(&x); + let number = Either::Num(y); + + println!("x is borrowed in {:?}", single); + println!("x and y are borrowed in {:?}", double); + println!("x is borrowed in {:?}", reference); + println!("y is *not* borrowed in {:?}", number); +}
-
+
- 🌟🌟 +
+/* Make it work */ + +#[derive(Debug)] +struct NoCopyType {} + +#[derive(Debug)] +struct Example<'a, 'b> { + a: &'a u32, + b: &'b NoCopyType +} + +fn main() +{ + /* 'a tied to fn-main stackframe */ + let var_a = 35; + let example: Example; + + { + /* Lifetime 'b tied to new stackframe/scope */ + let var_b = NoCopyType {}; + + /* fixme */ + example = Example { a: &var_a, b: &var_b }; + } + + println!("(Success!) {:?}", example); +}
-
+
- 🌟🌟 +
++#[derive(Debug)] +struct NoCopyType {} + +#[derive(Debug)] +#[allow(dead_code)] +struct Example<'a, 'b> { + a: &'a u32, + b: &'b NoCopyType +} + +/* Fix function signature */ +fn fix_me(foo: &Example) -> &NoCopyType +{ foo.b } + +fn main() +{ + let no_copy = NoCopyType {}; + let example = Example { a: &1, b: &no_copy }; + fix_me(&example); + println!("Success!") +}
Method
+Methods are annotated similarly to functions.
+Example
++struct Owner(i32); + +impl Owner { + // Annotate lifetimes as in a standalone function. + fn add_one<'a>(&'a mut self) { self.0 += 1; } + fn print<'a>(&'a self) { + println!("`print`: {}", self.0); + } +} + +fn main() { + let mut owner = Owner(18); + + owner.add_one(); + owner.print(); +}
-
+
- 🌟🌟 +
+/* Make it work by adding proper lifetime annotations */ +struct ImportantExcerpt { + part: &str, +} + +impl ImportantExcerpt { + fn level(&'a self) -> i32 { + 3 + } +} + +fn main() {}
Elision
+Some lifetime patterns are so common that borrow checker will allow you to omit them to save typing and improve readability.
+This is known as Elision. Elision exist in Rust only because these patterns are common.
+For a more comprehensive understanding of elision, please see lifetime elision in the official book.
+-
+
- 🌟🌟 +
+/* Remove all the lifetimes that can be elided */ + +fn input<'a>(x: &'a i32) { + println!("`annotated_input`: {}", x); +} + +fn pass<'a>(x: &'a i32) -> &'a i32 { x } + +fn longest<'a, 'b>(x: &'a str, y: &'b str) -> &'a str { + x +} + +struct Owner(i32); + +impl Owner { + // Annotate lifetimes as in a standalone function. + fn add_one<'a>(&'a mut self) { self.0 += 1; } + fn print<'a>(&'a self) { + println!("`print`: {}", self.0); + } +} + +struct Person<'a> { + age: u8, + name: &'a str, +} + +enum Either<'a> { + Num(i32), + Ref(&'a i32), +} + +fn main() {}
++You can find the solutions here(under the solutions path), but only use it when you need it :)
+
&'static and T: 'static
+'static is a reserved lifetime name, you might have encountered it several times:
+#![allow(unused)] +fn main() { +// A reference with 'static lifetime: +let s: &'static str = "hello world"; + +// 'static as part of a trait bound: +fn generic<T>(x: T) where T: 'static {} +}
Though they are all 'static, but subtly different.
&'static
+As a reference lifetime, &'static indicates the data pointed to by the reference lives as long as the running program. But it can still be coerced to a shorter lifetime.
-
+
- 🌟🌟 There are several ways to make a variable with
'staticlifetime, two of them are stored in the read-only memory of the binary.
+
++/* Fill in the blank in two ways */ +fn main() { + __; + need_static(v); + + println!("Success!") +} + +fn need_static(r : &'static str) { + assert_eq!(r, "hello"); +}
-
+
- 🌟🌟🌟🌟 Another way to make
'staticlifetime is usingBox::leak
+
+#[derive(Debug)] +struct Config { + a: String, + b: String, +} +static mut config: Option<&mut Config> = None; + +/* Make it work without changing the function signatures of `init`*/ +fn init() -> Option<&'static mut Config> { + Some(&mut Config { + a: "A".to_string(), + b: "B".to_string(), + }) +} + + +fn main() { + unsafe { + config = init(); + + println!("{:?}",config) + } +}
-
+
- 🌟
&'staticonly indicates that the data can live forever, not the reference. The latter one will be constrained by its scope.
+
+fn main() { + { + // Make a `string` literal and print it: + let static_string = "I'm in read-only memory"; + println!("static_string: {}", static_string); + + // When `static_string` goes out of scope, the reference + // can no longer be used, but the data remains in the binary. + } + + println!("static_string reference remains alive: {}", static_string); +}
-
+
&'staticcan be coerced to a shorter lifetime.
+
Example
++// Make a constant with `'static` lifetime. +static NUM: i32 = 18; + +// Returns a reference to `NUM` where its `'static` +// lifetime is coerced to that of the input argument. +fn coerce_static<'a>(_: &'a i32) -> &'a i32 { + &NUM +} + +fn main() { + { + // Make an integer to use for `coerce_static`: + let lifetime_num = 9; + + // Coerce `NUM` to lifetime of `lifetime_num`: + let coerced_static = coerce_static(&lifetime_num); + + println!("coerced_static: {}", coerced_static); + } + + println!("NUM: {} stays accessible!", NUM); +}
T: 'static
+As a trait bound, it means the type does not contain any non-static references. Eg. the receiver can hold on to the type for as long as they want and it will never become invalid until they drop it.
+It's important to understand this means that any owned data always passes a 'static lifetime bound, but a reference to that owned data generally does not.
-
+
- 🌟🌟 +
+/* Make it work */ +use std::fmt::Debug; + +fn print_it<T: Debug + 'static>( input: T) { + println!( "'static value passed in is: {:?}", input ); +} + +fn print_it1( input: impl Debug + 'static ) { + println!( "'static value passed in is: {:?}", input ); +} + + +fn print_it2<T: Debug + 'static>( input: &T) { + println!( "'static value passed in is: {:?}", input ); +} + +fn main() { + // i is owned and contains no references, thus it's 'static: + let i = 5; + print_it(i); + + // oops, &i only has the lifetime defined by the scope of + // main(), so it's not 'static: + print_it(&i); + + print_it1(&i); + + // but this one WORKS ! + print_it2(&i); +}
-
+
- 🌟🌟🌟 +
+use std::fmt::Display; + +fn main() { + let mut string = "First".to_owned(); + + string.push_str(string.to_uppercase().as_str()); + print_a(&string); + print_b(&string); + print_c(&string); // Compilation error + print_d(&string); // Compilation error + print_e(&string); + print_f(&string); + print_g(&string); // Compilation error +} + +fn print_a<T: Display + 'static>(t: &T) { + println!("{}", t); +} + +fn print_b<T>(t: &T) +where + T: Display + 'static, +{ + println!("{}", t); +} + +fn print_c(t: &'static dyn Display) { + println!("{}", t) +} + +fn print_d(t: &'static impl Display) { + println!("{}", t) +} + +fn print_e(t: &(dyn Display + 'static)) { + println!("{}", t) +} + +fn print_f(t: &(impl Display + 'static)) { + println!("{}", t) +} + +fn print_g(t: &'static String) { + println!("{}", t); +}
++You can find the solutions here(under the solutions path), but only use it when you need it :)
+
Advance lifetime
+Trait Bounds
+Just like generic types can be bounded, lifetimes can also be bounded as below:
+-
+
T: 'a，all references inTmust outlive the lifetime'a
+T: Trait + 'a:Tmust implement traitTraitand all references inTmust outlive'a
+
Example
++use std::fmt::Debug; // Trait to bound with. + +#[derive(Debug)] +struct Ref<'a, T: 'a>(&'a T); +// `Ref` contains a reference to a generic type `T` that has +// an unknown lifetime `'a`. `T` is bounded such that any +// *references* in `T` must outlive `'a`. Additionally, the lifetime +// of `Ref` may not exceed `'a`. + +// A generic function which prints using the `Debug` trait. +fn print<T>(t: T) where + T: Debug { + println!("`print`: t is {:?}", t); +} + +// Here a reference to `T` is taken where `T` implements +// `Debug` and all *references* in `T` outlive `'a`. In +// addition, `'a` must outlive the function. +fn print_ref<'a, T>(t: &'a T) where + T: Debug + 'a { + println!("`print_ref`: t is {:?}", t); +} + +fn main() { + let x = 7; + let ref_x = Ref(&x); + + print_ref(&ref_x); + print(ref_x); +}
-
+
- 🌟 +
+/* Annotate struct with lifetime: +1. `r` and `s` must have different lifetimes +2. lifetime of `s` is bigger than that of 'r' +*/ +struct DoubleRef<T> { + r: &T, + s: &T +} +fn main() { + println!("Success!") +}
-
+
- 🌟🌟 +
+/* Adding trait bounds to make it work */ +struct ImportantExcerpt<'a> { + part: &'a str, +} + +impl<'a, 'b> ImportantExcerpt<'a> { + fn announce_and_return_part(&'a self, announcement: &'b str) -> &'b str { + println!("Attention please: {}", announcement); + self.part + } +} + +fn main() { + println!("Success!") +}
-
+
- 🌟🌟 +
+/* Adding trait bounds to make it work */ +fn f<'a, 'b>(x: &'a i32, mut y: &'b i32) { + y = x; + let r: &'b &'a i32 = &&0; +} + +fn main() { + println!("Success!") +}
HRTB(Higher-ranked trait bounds)
+Type bounds may be higher ranked over lifetimes. These bounds specify a bound is true for all lifetimes. For example, a bound such as for<'a> &'a T: PartialEq<i32> would require an implementation like:
+#![allow(unused)] +fn main() { +impl<'a> PartialEq<i32> for &'a T { + // ... +} +}
and could then be used to compare a &'a T with any lifetime to an i32.
Only a higher-ranked bound can be used here, because the lifetime of the reference is shorter than any possible lifetime parameter on the function.
+-
+
- 🌟🌟🌟 +
+/* Adding HRTB to make it work!*/ +fn call_on_ref_zero<'a, F>(f: F) where F: Fn(&'a i32) { + let zero = 0; + f(&zero); +} + +fn main() { + println!("Success!"); +}
NLL (Non-Lexical Lifetime)
+Before explaining NLL, let's see some code first:
++fn main() { + let mut s = String::from("hello"); + + let r1 = &s; + let r2 = &s; + println!("{} and {}", r1, r2); + + let r3 = &mut s; + println!("{}", r3); +}
Based on our current knowledge, this code will cause en error due to violating the borrowing rules in Rust.
+But if you cargo run it, then everything will be ok, so what's going on here?
The ability of the compiler to tell that a reference is no longer used at a point before the end of the scope, is called Non-Lexical Lifetimes (NLL for short).
+With this ability the compiler knows when is the last time that a reference is used and optimizing the borrowing rules based on this knowledge.
++#![allow(unused)] +fn main() { +let mut u = 0i32; +let mut v = 1i32; +let mut w = 2i32; + +// lifetime of `a` = α ∪ β ∪ γ +let mut a = &mut u; // --+ α. lifetime of `&mut u` --+ lexical "lifetime" of `&mut u`,`&mut u`, `&mut w` and `a` +use(a); // | | +*a = 3; // <-----------------+ | +... // | +a = &mut v; // --+ β. lifetime of `&mut v` | +use(a); // | | +*a = 4; // <-----------------+ | +... // | +a = &mut w; // --+ γ. lifetime of `&mut w` | +use(a); // | | +*a = 5; // <-----------------+ <--------------------------+ +}
Reborrow
+After learning NLL, we can easily understand reborrow now.
+Example
++#[derive(Debug)] +struct Point { + x: i32, + y: i32, +} + +impl Point { + fn move_to(&mut self, x: i32, y: i32) { + self.x = x; + self.y = y; + } +} + +fn main() { + let mut p = Point { x: 0, y: 0 }; + let r = &mut p; + // Here comes the reborrow + let rr: &Point = &*r; + + println!("{:?}", rr); // Reborrow ends here, NLL introduced + + // Reborrow is over, we can continue using `r` now + r.move_to(10, 10); + println!("{:?}", r); +}
-
+
- 🌟🌟 +
+/* Make it work by reordering some code */ +fn main() { + let mut data = 10; + let ref1 = &mut data; + let ref2 = &mut *ref1; + + *ref1 += 1; + *ref2 += 2; + + println!("{}", data); +}
Unbound lifetime
+See more info in Nomicon - Unbounded Lifetimes.
+More elision rules
++#![allow(unused)] +fn main() { +impl<'a> Reader for BufReader<'a> { + // 'a is not used in the following methods +} + +// can be written as : +impl Reader for BufReader<'_> { + +} +}
+#![allow(unused)] +fn main() { +// Rust 2015 +struct Ref<'a, T: 'a> { + field: &'a T +} + +// Rust 2018 +struct Ref<'a, T> { + field: &'a T +} +}
A difficult exercise
+-
+
- 🌟🌟🌟🌟 +
+/* Make it work */ +struct Interface<'a> { + manager: &'a mut Manager<'a> +} + +impl<'a> Interface<'a> { + pub fn noop(self) { + println!("interface consumed"); + } +} + +struct Manager<'a> { + text: &'a str +} + +struct List<'a> { + manager: Manager<'a>, +} + +impl<'a> List<'a> { + pub fn get_interface(&'a mut self) -> Interface { + Interface { + manager: &mut self.manager + } + } +} + +fn main() { + let mut list = List { + manager: Manager { + text: "hello" + } + }; + + list.get_interface().noop(); + + println!("Interface should be dropped here and the borrow released"); + + use_list(&list); +} + +fn use_list(list: &List) { + println!("{}", list.manager.text); +}
++You can find the solutions here(under the solutions path), but only use it when you need it :)
+
Functional programing
+Learning resources:
+-
+
- English: Rust Book 13 +
- 简体中文: Rust语言圣经 - 函数式编程：闭包和迭代器 +
Closure
+Closures can capture the enclosing environments. For example we can capture the x variable :
+fn main() { + let x = 1; + let closure = |val| val + x; + assert_eq!(closure(2), 3); +}
From the syntax, we can see that closures are very convenient for on the fly usage. Unlike functions, both the input and return types of a closure can be inferred by the compiler.
++fn main() { + // Increment via closures and functions. + fn function(i: i32) -> i32 { i + 1 } + + // Closures are anonymous, here we are binding them to references + // + // These nameless functions are assigned to appropriately named variables. + let closure_annotated = |i: i32| -> i32 { i + 1 }; + let closure_inferred = |i | i + 1 ; + + let i = 1; + // Call the function and closures. + println!("function: {}", function(i)); + println!("closure_annotated: {}", closure_annotated(i)); + println!("closure_inferred: {}", closure_inferred(i)); + + // A closure taking no arguments which returns an `i32`. + // The return type is inferred. + let one = || 1; + println!("closure returning one: {}", one()); + +}
Capturing
+Closures can capture variables by borrowing or moving. But they prefer to capture by borrowing and only go lower when required:
+-
+
- By reference:
&T
+ - By mutable reference:
&mut T
+ - By value:
T
+
-
+
- 🌟 +
+/* Make it work with least amount of changes*/ +fn main() { + let color = String::from("green"); + + let print = move || println!("`color`: {}", color); + + print(); + print(); + + // `color` can be borrowed immutably again, because the closure only holds + // an immutable reference to `color`. + let _reborrow = &color; + + println!("{}",color); +}
-
+
- 🌟🌟 +
+/* Make it work +- Dont use `_reborrow` and `_count_reborrowed` +- Dont modify `assert_eq` +*/ +fn main() { + let mut count = 0; + + let mut inc = || { + count += 1; + println!("`count`: {}", count); + }; + + inc(); + + + let _reborrow = &count; + + inc(); + + // The closure no longer needs to borrow `&mut count`. Therefore, it is + // possible to reborrow without an error + let _count_reborrowed = &mut count; + + assert_eq!(count, 0); +}
-
+
- 🌟🌟 +
+/* Make it work in two ways, none of them is to remove `take(movable)` away from the code +*/ +fn main() { + let movable = Box::new(3); + + let consume = || { + println!("`movable`: {:?}", movable); + take(movable); + }; + + consume(); + consume(); +} + +fn take<T>(_v: T) {}
For comparison, the following code has no error:
++fn main() { + let movable = Box::new(3); + + let consume = move || { + println!("`movable`: {:?}", movable); + }; + + consume(); + consume(); +}
Type inferred
+The following four closures has no difference in input and return types.
++#![allow(unused)] +fn main() { +fn add_one_v1 (x: u32) -> u32 { x + 1 } +let add_one_v2 = |x: u32| -> u32 { x + 1 }; +let add_one_v3 = |x| { x + 1 }; +let add_one_v4 = |x| x + 1 ; +}
-
+
- 🌟 +
+fn main() { + let example_closure = |x| x; + + let s = example_closure(String::from("hello")); + + /* Make it work, only change the following line */ + let n = example_closure(5); +}
Fn, FnMut, FnOnce
+When taking a closure as an input parameter, the closure's complete type must be annotated using one of the following traits:
+-
+
- Fn: the closure uses the captured value by reference (&T) +
- FnMut: the closure uses the captured value by mutable reference (&mut T) +
- FnOnce: the closure uses the captured value by value (T) +
-
+
- 🌟🌟 +
+/* Make it work by changing the trait bound, in two ways*/ +fn fn_once<F>(func: F) +where + F: FnOnce(usize) -> bool, +{ + println!("{}", func(3)); + println!("{}", func(4)); +} + +fn main() { + let x = vec![1, 2, 3]; + fn_once(|z|{z == x.len()}) +}
-
+
- 🌟🌟 +
+fn main() { + let mut s = String::new(); + + let update_string = |str| s.push_str(str); + + exec(update_string); + + println!("{:?}",s); +} + +/* Fill in the blank */ +fn exec<'a, F: __>(mut f: F) { + f("hello") +}
Which trait does the compiler prefer to use?
+-
+
- Fn: the closure uses the captured value by reference (&T) +
- FnMut: the closure uses the captured value by mutable reference (&mut T) +
- FnOnce: the closure uses the captured value by value (T) +
On a variable-by-variable basis, the compiler will capture variables in the least restrictive manner possible.
+For instance, consider a parameter annotated as FnOnce. This specifies that the closure may capture by &T, &mut T, or T, but the compiler will ultimately choose based on how the captured variables are used in the closure.
+Which trait to use is determined by what the closure does with captured value.
This is because if a move is possible, then any type of borrow should also be possible. Note that the reverse is not true. If the parameter is annotated as Fn, then capturing variables by &mut T or T are not allowed.
-
+
- 🌟🌟 +
+/* Fill in the blank */ + +// A function which takes a closure as an argument and calls it. +// <F> denotes that F is a "Generic type parameter" +fn apply<F>(f: F) where + // The closure takes no input and returns nothing. + F: __ { + + f(); +} + +// A function which takes a closure and returns an `i32`. +fn apply_to_3<F>(f: F) -> i32 where + // The closure takes an `i32` and returns an `i32`. + F: Fn(i32) -> i32 { + + f(3) +} + +fn main() { + use std::mem; + + let greeting = "hello"; + // A non-copy type. + // `to_owned` creates owned data from borrowed one + let mut farewell = "goodbye".to_owned(); + + // Capture 2 variables: `greeting` by reference and + // `farewell` by value. + let diary = || { + // `greeting` is by reference: requires `Fn`. + println!("I said {}.", greeting); + + // Mutation forces `farewell` to be captured by + // mutable reference. Now requires `FnMut`. + farewell.push_str("!!!"); + println!("Then I screamed {}.", farewell); + println!("Now I can sleep. zzzzz"); + + // Manually calling drop forces `farewell` to + // be captured by value. Now requires `FnOnce`. + mem::drop(farewell); + }; + + // Call the function which applies the closure. + apply(diary); + + // `double` satisfies `apply_to_3`'s trait bound + let double = |x| 2 * x; + + println!("3 doubled: {}", apply_to_3(double)); +}
Move closures may still implement Fn or FnMut, even though they capture variables by move. This is because the traits implemented by a closure type are determined by what the closure does with captured values, not how it captures them. The move keyword only specifies the latter.
+fn main() { + let s = String::new(); + + let update_string = move || println!("{}",s); + + exec(update_string); +} + +fn exec<F: FnOnce()>(f: F) { + f() +}
The following code also has no error:
++fn main() { + let s = String::new(); + + let update_string = move || println!("{}",s); + + exec(update_string); +} + +fn exec<F: Fn()>(f: F) { + f() +}
-
+
- 🌟🌟 +
+/* Fill in the blank */ +fn main() { + let mut s = String::new(); + + let update_string = |str| -> String {s.push_str(str); s }; + + exec(update_string); +} + +fn exec<'a, F: __>(mut f: F) { + f("hello"); +}
Input functions
+Since closure can be used as arguments, you might wonder can we use functions as arguments too? And indeed we can.
+-
+
- 🌟🌟 +
++/* Implement `call_me` to make it work */ +fn call_me { + f(); +} + +fn function() { + println!("I'm a function!"); +} + +fn main() { + let closure = || println!("I'm a closure!"); + + call_me(closure); + call_me(function); +}
Closure as return types
+Returning a closure is much harder than you may have thought of.
+-
+
- 🌟🌟 +
+/* Fill in the blank using two approaches, + and fix the error */ +fn create_fn() -> __ { + let num = 5; + + // How does the following closure capture the environment variable `num` + // &T, &mut T, T ? + |x| x + num +} + + +fn main() { + let fn_plain = create_fn(); + fn_plain(1); +}
-
+
- 🌟🌟 +
+/* Fill in the blank and fix the error*/ +fn factory(x:i32) -> __ { + + let num = 5; + + if x > 1{ + move |x| x + num + } else { + move |x| x + num + } +}
Closure in structs
+Example
++struct Cacher<T,E> +where + T: Fn(E) -> E, + E: Copy +{ + query: T, + value: Option<E>, +} + +impl<T,E> Cacher<T,E> +where + T: Fn(E) -> E, + E: Copy +{ + fn new(query: T) -> Cacher<T,E> { + Cacher { + query, + value: None, + } + } + + fn value(&mut self, arg: E) -> E { + match self.value { + Some(v) => v, + None => { + let v = (self.query)(arg); + self.value = Some(v); + v + } + } + } +} +fn main() { + +} + +#[test] +fn call_with_different_values() { + let mut c = Cacher::new(|a| a); + + let v1 = c.value(1); + let v2 = c.value(2); + + assert_eq!(v2, 1); +}
++You can find the solutions here(under the solutions path), but only use it when you need it :)
+
Iterator
+The iterator pattern allows us to perform some tasks on a sequence of items in turn. An iterator is responsible for the logic of iterating over each item and determining when the sequence has finished.
+for and iterator
++fn main() { + let v = vec![1, 2, 3]; + for x in v { + println!("{}",x) + } +}
In the code above, You may consider for as a simple loop, but actually it is iterating over a iterator.
By default for will apply the into_iter to the collection, and change it into a iterator. As a result, the following code is equivalent to previous one:
+fn main() { + let v = vec![1, 2, 3]; + for x in v.into_iter() { + println!("{}",x) + } +}
-
+
- 🌟 +
+/* Refactoring the following code using iterators */ +fn main() { + let arr = [0; 10]; + for i in 0..arr.len() { + println!("{}",arr[i]); + } +}
-
+
- 🌟 One of the easiest ways to create an iterator is to use the range notion:
a..b.
+
+/* Fill in the blank */ +fn main() { + let mut v = Vec::new(); + for n in __ { + v.push(n); + } + + assert_eq!(v.len(), 100); +}
next method
+All iterators implement a trait named Iterator that is defined in the standard library:
+#![allow(unused)] +fn main() { +pub trait Iterator { + type Item; + + fn next(&mut self) -> Option<Self::Item>; + + // Methods with default implementations elided +} +}
And we can call the next method on iterators directly.
-
+
- 🌟🌟 +
+/* Fill the blanks and fix the errors. +Using two ways if possible */ +fn main() { + let v1 = vec![1, 2]; + + assert_eq!(v1.next(), __); + assert_eq!(v1.next(), __); + assert_eq!(v1.next(), __); +}
into_iter, iter and iter_mut
+In the previous section, we have mentioned that for will apply the into_iter to the collection, and change it into a iterator. However, this is not the only way to convert collections into iterators.
into_iter, iter, iter_mut, all of them can convert a collection into iterator, but in different ways.
-
+
into_iterconsumes the collection, once the collection has been consumed, it is no longer available for reuse, because its ownership has been moved within the loop.
+iter, this borrows each element of the collection through each iteration, thus leaving the collection untouched and available for reuse after the loop
+iter_mut, this mutably borrows each element of the collection, allowing for the collection to be modified in place.
+
-
+
- 🌟 +
+/* Make it work */ +fn main() { + let arr = vec![0; 10]; + for i in arr { + println!("{}", i); + } + + println!("{:?}",arr); +}
-
+
- 🌟 +
+/* Fill in the blank */ +fn main() { + let mut names = vec!["Bob", "Frank", "Ferris"]; + + for name in names.__{ + *name = match name { + &mut "Ferris" => "There is a rustacean among us!", + _ => "Hello", + } + } + + println!("names: {:?}", names); +}
-
+
- 🌟🌟 +
+/* Fill in the blank */ +fn main() { + let mut values = vec![1, 2, 3]; + let mut values_iter = values.__; + + if let Some(v) = values_iter.__{ + __ + } + + assert_eq!(values, vec![0, 2, 3]); +}
Creating our own iterator
+We can not only create iterators from collection's types, but also can create iterators by implementing the Iterator trait on our own types.
Example
++struct Counter { + count: u32, +} + +impl Counter { + fn new() -> Counter { + Counter { count: 0 } + } +} + +impl Iterator for Counter { + type Item = u32; + + fn next(&mut self) -> Option<Self::Item> { + if self.count < 5 { + self.count += 1; + Some(self.count) + } else { + None + } + } +} + +fn main() { + let mut counter = Counter::new(); + + assert_eq!(counter.next(), Some(1)); + assert_eq!(counter.next(), Some(2)); + assert_eq!(counter.next(), Some(3)); + assert_eq!(counter.next(), Some(4)); + assert_eq!(counter.next(), Some(5)); + assert_eq!(counter.next(), None); +}
-
+
- 🌟🌟🌟 +
+struct Fibonacci { + curr: u32, + next: u32, +} + +// Implement `Iterator` for `Fibonacci`. +// The `Iterator` trait only requires a method to be defined for the `next` element. +impl Iterator for Fibonacci { + // We can refer to this type using Self::Item + type Item = u32; + + /* Implement next method */ + fn next(&mut self) +} + +// Returns a Fibonacci sequence generator +fn fibonacci() -> Fibonacci { + Fibonacci { curr: 0, next: 1 } +} + +fn main() { + let mut fib = fibonacci(); + assert_eq!(fib.next(), Some(1)); + assert_eq!(fib.next(), Some(1)); + assert_eq!(fib.next(), Some(2)); + assert_eq!(fib.next(), Some(3)); + assert_eq!(fib.next(), Some(5)); +}
Methods that Consume the Iterator
+The Iterator trait has a number of methods with default implementations provided by the standard library.
Consuming adaptors
+Some of these methods call the method nextto use up the iterator, so they are called consuming adaptors.
-
+
- 🌟🌟 +
++/* Fill in the blank and fix the errors */ +fn main() { + let v1 = vec![1, 2, 3]; + + let v1_iter = v1.iter(); + + // The sum method will take the ownership of the iterator and iterates through the items by repeatedly calling next method + let total = v1_iter.sum(); + + assert_eq!(total, __); + + println!("{:?}, {:?}",v1, v1_iter); +}
Collect
+Other than converting a collection into an iterator, we can also collect the result values into a collection, collect will consume the iterator.
-
+
- 🌟🌟 +
+/* Make it work */ +use std::collections::HashMap; +fn main() { + let names = [("sunface",18), ("sunfei",18)]; + let folks: HashMap<_, _> = names.into_iter().collect(); + + println!("{:?}",folks); + + let v1: Vec<i32> = vec![1, 2, 3]; + + let v2 = v1.iter().collect(); + + assert_eq!(v2, vec![1, 2, 3]); +}
Iterator adaptors
+Methods allowing you to change one iterator into another iterator are known as iterator adaptors. You can chain multiple iterator adaptors to perform complex actions in a readable way.
+But because all iterators are lazy, you have to call one of the consuming adapters to get results from calls to iterator adapters.
+-
+
- 🌟🌟 +
+/* Fill in the blanks */ +fn main() { + let v1: Vec<i32> = vec![1, 2, 3]; + + let v2: Vec<_> = v1.iter().__.__; + + assert_eq!(v2, vec![2, 3, 4]); +}
-
+
- 🌟🌟 +
+/* Fill in the blanks */ +use std::collections::HashMap; +fn main() { + let names = ["sunface", "sunfei"]; + let ages = [18, 18]; + let folks: HashMap<_, _> = names.into_iter().__.collect(); + + println!("{:?}",folks); +}
Using closures in iterator adaptors
+-
+
- 🌟🌟 +
+/* Fill in the blanks */ +#[derive(PartialEq, Debug)] +struct Shoe { + size: u32, + style: String, +} + +fn shoes_in_size(shoes: Vec<Shoe>, shoe_size: u32) -> Vec<Shoe> { + shoes.into_iter().__.collect() +} + +fn main() { + let shoes = vec![ + Shoe { + size: 10, + style: String::from("sneaker"), + }, + Shoe { + size: 13, + style: String::from("sandal"), + }, + Shoe { + size: 10, + style: String::from("boot"), + }, + ]; + + let in_my_size = shoes_in_size(shoes, 10); + + assert_eq!( + in_my_size, + vec![ + Shoe { + size: 10, + style: String::from("sneaker") + }, + Shoe { + size: 10, + style: String::from("boot") + }, + ] + ); +}
++You can find the solutions here(under the solutions path), but only use it when you need it :)
+
newtype and Sized
+Newtype
+The orphan rule tells us that we are allowed to implement a trait on a type as long as either the trait or the type are local to our crate.
+The newtype pattern can help us get around this restriction, which involves creating a new type in a tuple struct.
+-
+
- 🌟 +
+use std::fmt; + +/* Define the Wrapper type */ +__; + +// Display is an external trait +impl fmt::Display for Wrapper { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!(f, "[{}]", self.0.join(", ")) + } +} + +fn main() { + // Vec is an external type, so you cannot implement Display trait on Vec type + let w = Wrapper(vec![String::from("hello"), String::from("world")]); + println!("w = {}", w); +}
-
+
- 🌟 Hide the methods of the original type. +
+/* Make it workd */ +struct Meters(u32); + +fn main() { + let i: u32 = 2; + assert_eq!(i.pow(2), 4); + + let n = Meters(i); + // The `pow` method is defined on `u32` type, we can't directly call it + assert_eq!(n.pow(2), 4); +}
-
+
- 🌟🌟 The
newtypeidiom gives compile time guarantees that the right type of value is supplied to a program.
+
+/* Make it work */ +struct Years(i64); + +struct Days(i64); + +impl Years { + pub fn to_days(&self) -> Days { + Days(self.0 * 365) + } +} + + +impl Days { + pub fn to_years(&self) -> Years { + Years(self.0 / 365) + } +} + +// An age verification function that checks age in years, must be given a value of type Years. +fn old_enough(age: &Years) -> bool { + age.0 >= 18 +} + +fn main() { + let age = Years(5); + let age_days = age.to_days(); + println!("Old enough {}", old_enough(&age)); + println!("Old enough {}", old_enough(&age_days)); +}
-
+
- 🌟🌟 +
+use std::ops::Add; +use std::fmt::{self, format}; + +struct Meters(u32); +impl fmt::Display for Meters { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!(f, "There are still {} meters left", self.0) + } +} + +impl Add for Meters { + type Output = Self; + + fn add(self, other: Meters) -> Self { + Self(self.0 + other.0) + } +} +fn main() { + let d = calculate_distance(Meters(10), Meters(20)); + assert_eq!(format!("{}",d), "There are still 30 meters left"); +} + +/* Implement calculate_distance */ +fn calculate_distance
Type alias
+Type alias is important to improve the readability of our code.
++#![allow(unused)] +fn main() { +type Thunk = Box<dyn Fn() + Send + 'static>; + +let f: Thunk = Box::new(|| println!("hi")); + +fn takes_long_type(f: Thunk) { + // --snip-- +} + +fn returns_long_type() -> Thunk { + // --snip-- +} +}
+#![allow(unused)] +fn main() { +type Result<T> = std::result::Result<T, std::io::Error>; +}
And Unlike newtype, type alias don't create new types, so the following code is valid:
++#![allow(unused)] +fn main() { +type Meters = u32; + +let x: u32 = 5; +let y: Meters = 5; + +println!("x + y = {}", x + y); +}
-
+
- 🌟 +
+enum VeryVerboseEnumOfThingsToDoWithNumbers { + Add, + Subtract, +} + +/* Fill in the blank */ +__ + +fn main() { + // We can refer to each variant via its alias, not its long and inconvenient + // name. + let x = Operations::Add; +}
-
+
- 🌟🌟 There are a few preserved aliases in Rust, one of which can be used in
implblocks.
+
+enum VeryVerboseEnumOfThingsToDoWithNumbers { + Add, + Subtract, +} + +impl VeryVerboseEnumOfThingsToDoWithNumbers { + fn run(&self, x: i32, y: i32) -> i32 { + match self { + __::Add => x + y, + __::Subtract => x - y, + } + } +}
DST and unsized type
+These concepts are complicated, so we are not going to explain here, but you can find them in The Book.
+-
+
- 🌟🌟🌟 Array with dynamic length is a Dynamic Sized Type ( DST ), we can't directly use it +
+/* Make it work with const generics */ +fn my_function(n: usize) -> [u32; usize] { + [123; n] +} + +fn main() { + let arr = my_function(); + println!("{:?}",arr); +}
-
+
- 🌟🌟 Slice is unsized type, but the reference of slice is not. +
+/* Make it work with slice references */ +fn main() { + let s: str = "Hello there!"; + + let arr: [u8] = [1, 2, 3]; +}
-
+
- 🌟🌟 Trait is also an unsized type +
+/* Make it work in two ways */ +use std::fmt::Display; +fn foobar(thing: Display) {} + +fn main() { +}
Smart pointers
+Box
+Deref
+Drop
+Rc and Arc
+Cell and RefCell
+Weak and Circle reference
+Self referential
+Threads
+Basic using
+Message passing
+Sync
+Atomic
+Send and Sync
+Global variables
+Errors
+Unsafe todo
+Inline assembly
+Rust provides support for inline assembly via the asm! macro.
+It can be used to embed handwritten assembly in the assembly output generated by the compiler.
+Generally this should not be necessary, but might be where the required performance or timing
+cannot be otherwise achieved. Accessing low level hardware primitives, e.g. in kernel code, may also demand this functionality.
++Note: the examples here are given in x86/x86-64 assembly, but other architectures are also supported.
+
Inline assembly is currently supported on the following architectures:
+-
+
- x86 and x86-64 +
- ARM +
- AArch64 +
- RISC-V +
Basic usage
+Let us start with the simplest possible example:
++#![allow(unused)] +fn main() { +use std::arch::asm; + +unsafe { + asm!("nop"); +} +}
This will insert a NOP (no operation) instruction into the assembly generated by the compiler.
+Note that all asm! invocations have to be inside an unsafe block, as they could insert
+arbitrary instructions and break various invariants. The instructions to be inserted are listed
+in the first argument of the asm! macro as a string literal.
Inputs and outputs
+Now inserting an instruction that does nothing is rather boring. Let us do something that +actually acts on data:
++#![allow(unused)] +fn main() { +use std::arch::asm; + +let x: u64; +unsafe { + asm!("mov {}, 5", out(reg) x); +} +assert_eq!(x, 5); +}
This will write the value 5 into the u64 variable x.
+You can see that the string literal we use to specify instructions is actually a template string.
+It is governed by the same rules as Rust format strings.
+The arguments that are inserted into the template however look a bit different than you may
+be familiar with. First we need to specify if the variable is an input or an output of the
+inline assembly. In this case it is an output. We declared this by writing out.
+We also need to specify in what kind of register the assembly expects the variable.
+In this case we put it in an arbitrary general purpose register by specifying reg.
+The compiler will choose an appropriate register to insert into
+the template and will read the variable from there after the inline assembly finishes executing.
Let us see another example that also uses an input:
++#![allow(unused)] +fn main() { +use std::arch::asm; + +let i: u64 = 3; +let o: u64; +unsafe { + asm!( + "mov {0}, {1}", + "add {0}, 5", + out(reg) o, + in(reg) i, + ); +} +assert_eq!(o, 8); +}
This will add 5 to the input in variable i and write the result to variable o.
+The particular way this assembly does this is first copying the value from i to the output,
+and then adding 5 to it.
The example shows a few things:
+First, we can see that asm! allows multiple template string arguments; each
+one is treated as a separate line of assembly code, as if they were all joined
+together with newlines between them. This makes it easy to format assembly
+code.
Second, we can see that inputs are declared by writing in instead of out.
Third, we can see that we can specify an argument number, or name as in any format string. +For inline assembly templates this is particularly useful as arguments are often used more than once. +For more complex inline assembly using this facility is generally recommended, as it improves +readability, and allows reordering instructions without changing the argument order.
+We can further refine the above example to avoid the mov instruction:
+#![allow(unused)] +fn main() { +use std::arch::asm; + +let mut x: u64 = 3; +unsafe { + asm!("add {0}, 5", inout(reg) x); +} +assert_eq!(x, 8); +}
We can see that inout is used to specify an argument that is both input and output.
+This is different from specifying an input and output separately in that it is guaranteed to assign both to the same register.
It is also possible to specify different variables for the input and output parts of an inout operand:
+#![allow(unused)] +fn main() { +use std::arch::asm; + +let x: u64 = 3; +let y: u64; +unsafe { + asm!("add {0}, 5", inout(reg) x => y); +} +assert_eq!(y, 8); +}
Late output operands
+The Rust compiler is conservative with its allocation of operands. It is assumed that an out
+can be written at any time, and can therefore not share its location with any other argument.
+However, to guarantee optimal performance it is important to use as few registers as possible,
+so they won't have to be saved and reloaded around the inline assembly block.
+To achieve this Rust provides a lateout specifier. This can be used on any output that is
+written only after all inputs have been consumed.
+There is also a inlateout variant of this specifier.
Here is an example where inlateout cannot be used:
+#![allow(unused)] +fn main() { +use std::arch::asm; + +let mut a: u64 = 4; +let b: u64 = 4; +let c: u64 = 4; +unsafe { + asm!( + "add {0}, {1}", + "add {0}, {2}", + inout(reg) a, + in(reg) b, + in(reg) c, + ); +} +assert_eq!(a, 12); +}
Here the compiler is free to allocate the same register for inputs b and c since it knows they have the same value. However it must allocate a separate register for a since it uses inout and not inlateout. If inlateout was used, then a and c could be allocated to the same register, in which case the first instruction to overwrite the value of c and cause the assembly code to produce the wrong result.
However the following example can use inlateout since the output is only modified after all input registers have been read:
+#![allow(unused)] +fn main() { +use std::arch::asm; + +let mut a: u64 = 4; +let b: u64 = 4; +unsafe { + asm!("add {0}, {1}", inlateout(reg) a, in(reg) b); +} +assert_eq!(a, 8); +}
As you can see, this assembly fragment will still work correctly if a and b are assigned to the same register.
Explicit register operands
+Some instructions require that the operands be in a specific register.
+Therefore, Rust inline assembly provides some more specific constraint specifiers.
+While reg is generally available on any architecture, explicit registers are highly architecture specific. E.g. for x86 the general purpose registers eax, ebx, ecx, edx, ebp, esi, and edi among others can be addressed by their name.
+#![allow(unused)] +fn main() { +use std::arch::asm; + +let cmd = 0xd1; +unsafe { + asm!("out 0x64, eax", in("eax") cmd); +} +}
In this example we call the out instruction to output the content of the cmd variable to port 0x64. Since the out instruction only accepts eax (and its sub registers) as operand we had to use the eax constraint specifier.
++Note: unlike other operand types, explicit register operands cannot be used in the template string: you can't use
+{}and should write the register name directly instead. Also, they must appear at the end of the operand list after all other operand types.
Consider this example which uses the x86 mul instruction:
+#![allow(unused)] +fn main() { +use std::arch::asm; + +fn mul(a: u64, b: u64) -> u128 { + let lo: u64; + let hi: u64; + + unsafe { + asm!( + // The x86 mul instruction takes rax as an implicit input and writes + // the 128-bit result of the multiplication to rax:rdx. + "mul {}", + in(reg) a, + inlateout("rax") b => lo, + lateout("rdx") hi + ); + } + + ((hi as u128) << 64) + lo as u128 +} +}
This uses the mul instruction to multiply two 64-bit inputs with a 128-bit result.
+The only explicit operand is a register, that we fill from the variable a.
+The second operand is implicit, and must be the rax register, which we fill from the variable b.
+The lower 64 bits of the result are stored in rax from which we fill the variable lo.
+The higher 64 bits are stored in rdx from which we fill the variable hi.
Clobbered registers
+In many cases inline assembly will modify state that is not needed as an output. +Usually this is either because we have to use a scratch register in the assembly or because instructions modify state that we don't need to further examine. +This state is generally referred to as being "clobbered". +We need to tell the compiler about this since it may need to save and restore this state around the inline assembly block.
++use core::arch::asm; + +fn main() { + // three entries of four bytes each + let mut name_buf = [0_u8; 12]; + // String is stored as ascii in ebx, edx, ecx in order + // Because ebx is reserved, we get a scratch register and move from + // ebx into it in the asm. The asm needs to preserve the value of + // that register though, so it is pushed and popped around the main asm + // (in 64 bit mode for 64 bit processors, 32 bit processors would use ebx) + + unsafe { + asm!( + "push rbx", + "cpuid", + "mov [{0}], ebx", + "mov [{0} + 4], edx", + "mov [{0} + 8], ecx", + "pop rbx", + // We use a pointer to an array for storing the values to simplify + // the Rust code at the cost of a couple more asm instructions + // This is more explicit with how the asm works however, as opposed + // to explicit register outputs such as `out("ecx") val` + // The *pointer itself* is only an input even though it's written behind + in(reg) name_buf.as_mut_ptr(), + // select cpuid 0, also specify eax as clobbered + inout("eax") 0 => _, + // cpuid clobbers these registers too + out("ecx") _, + out("edx") _, + ); + } + + let name = core::str::from_utf8(&name_buf).unwrap(); + println!("CPU Manufacturer ID: {}", name); +}
In the example above we use the cpuid instruction to read the CPU manufacturer ID.
+This instruction writes to eax with the maximum supported cpuid argument and ebx, esx, and ecx with the CPU manufacturer ID as ASCII bytes in that order.
Even though eax is never read we still need to tell the compiler that the register has been modified so that the compiler can save any values that were in these registers before the asm. This is done by declaring it as an output but with _ instead of a variable name, which indicates that the output value is to be discarded.
This code also works around the limitation that ebx is a reserved register by LLVM. That means that LLVM assumes that it has full control over the register and it must be restored to its original state before exiting the asm block, so it cannot be used as an output. To work around this we save the register via push, read from ebx inside the asm block into a temporary register allocated with out(reg) and then restoring ebx to its original state via pop. The push and pop use the full 64-bit rbx version of the register to ensure that the entire register is saved. On 32 bit targets the code would instead use ebx in the push/pop.
This can also be used with a general register class (e.g. reg) to obtain a scratch register for use inside the asm code:
+#![allow(unused)] +fn main() { +use std::arch::asm; + +// Multiply x by 6 using shifts and adds +let mut x: u64 = 4; +unsafe { + asm!( + "mov {tmp}, {x}", + "shl {tmp}, 1", + "shl {x}, 2", + "add {x}, {tmp}", + x = inout(reg) x, + tmp = out(reg) _, + ); +} +assert_eq!(x, 4 * 6); +}
Symbol operands and ABI clobbers
+By default, asm! assumes that any register not specified as an output will have its contents preserved by the assembly code. The clobber_abi argument to asm! tells the compiler to automatically insert the necessary clobber operands according to the given calling convention ABI: any register which is not fully preserved in that ABI will be treated as clobbered. Multiple clobber_abi arguments may be provided and all clobbers from all specified ABIs will be inserted.
+#![allow(unused)] +fn main() { +use std::arch::asm; + +extern "C" fn foo(arg: i32) -> i32 { + println!("arg = {}", arg); + arg * 2 +} + +fn call_foo(arg: i32) -> i32 { + unsafe { + let result; + asm!( + "call *{}", + // Function pointer to call + in(reg) foo, + // 1st argument in rdi + in("rdi") arg, + // Return value in rax + out("rax") result, + // Mark all registers which are not preserved by the "C" calling + // convention as clobbered. + clobber_abi("C"), + ); + result + } +} +}
Register template modifiers
+In some cases, fine control is needed over the way a register name is formatted when inserted into the template string. This is needed when an architecture's assembly language has several names for the same register, each typically being a "view" over a subset of the register (e.g. the low 32 bits of a 64-bit register).
+By default the compiler will always choose the name that refers to the full register size (e.g. rax on x86-64, eax on x86, etc).
This default can be overridden by using modifiers on the template string operands, just like you would with format strings:
++#![allow(unused)] +fn main() { +use std::arch::asm; + +let mut x: u16 = 0xab; + +unsafe { + asm!("mov {0:h}, {0:l}", inout(reg_abcd) x); +} + +assert_eq!(x, 0xabab); +}
In this example, we use the reg_abcd register class to restrict the register allocator to the 4 legacy x86 registers (ax, bx, cx, dx) of which the first two bytes can be addressed independently.
Let us assume that the register allocator has chosen to allocate x in the ax register.
+The h modifier will emit the register name for the high byte of that register and the l modifier will emit the register name for the low byte. The asm code will therefore be expanded as mov ah, al which copies the low byte of the value into the high byte.
If you use a smaller data type (e.g. u16) with an operand and forget the use template modifiers, the compiler will emit a warning and suggest the correct modifier to use.
Memory address operands
+Sometimes assembly instructions require operands passed via memory addresses/memory locations.
+You have to manually use the memory address syntax specified by the target architecture.
+For example, on x86/x86_64 using Intel assembly syntax, you should wrap inputs/outputs in [] to indicate they are memory operands:
+#![allow(unused)] +fn main() { +use std::arch::asm; + +fn load_fpu_control_word(control: u16) { + unsafe { + asm!("fldcw [{}]", in(reg) &control, options(nostack)); + } +} +}
Labels
+Any reuse of a named label, local or otherwise, can result in an assembler or linker error or may cause other strange behavior. Reuse of a named label can happen in a variety of ways including:
+-
+
- explicitly: using a label more than once in one
asm!block, or multiple times across blocks.
+ - implicitly via inlining: the compiler is allowed to instantiate multiple copies of an
asm!block, for example when the function containing it is inlined in multiple places.
+ - implicitly via LTO: LTO can cause code from other crates to be placed in the same codegen unit, and so could bring in arbitrary labels. +
As a consequence, you should only use GNU assembler numeric local labels inside inline assembly code. Defining symbols in assembly code may lead to assembler and/or linker errors due to duplicate symbol definitions.
+Moreover, on x86 when using the default Intel syntax, due to an LLVM bug, you shouldn't use labels exclusively made of 0 and 1 digits, e.g. 0, 11 or 101010, as they may end up being interpreted as binary values. Using options(att_syntax) will avoid any ambiguity, but that affects the syntax of the entire asm! block. (See Options, below, for more on options.)
+#![allow(unused)] +fn main() { +use std::arch::asm; + +let mut a = 0; +unsafe { + asm!( + "mov {0}, 10", + "2:", + "sub {0}, 1", + "cmp {0}, 3", + "jle 2f", + "jmp 2b", + "2:", + "add {0}, 2", + out(reg) a + ); +} +assert_eq!(a, 5); +}
This will decrement the {0} register value from 10 to 3, then add 2 and store it in a.
This example shows a few things:
+-
+
- First, that the same number can be used as a label multiple times in the same inline block. +
- Second, that when a numeric label is used as a reference (as an instruction operand, for example), the suffixes “b” (“backward”) or ”f” (“forward”) should be added to the numeric label. It will then refer to the nearest label defined by this number in this direction. +
Options
+By default, an inline assembly block is treated the same way as an external FFI function call with a custom calling convention: it may read/write memory, have observable side effects, etc. However, in many cases it is desirable to give the compiler more information about what the assembly code is actually doing so that it can optimize better.
+Let's take our previous example of an add instruction:
+#![allow(unused)] +fn main() { +use std::arch::asm; + +let mut a: u64 = 4; +let b: u64 = 4; +unsafe { + asm!( + "add {0}, {1}", + inlateout(reg) a, in(reg) b, + options(pure, nomem, nostack), + ); +} +assert_eq!(a, 8); +}
Options can be provided as an optional final argument to the asm! macro. We specified three options here:
-
+
puremeans that the asm code has no observable side effects and that its output depends only on its inputs. This allows the compiler optimizer to call the inline asm fewer times or even eliminate it entirely.
+nomemmeans that the asm code does not read or write to memory. By default the compiler will assume that inline assembly can read or write any memory address that is accessible to it (e.g. through a pointer passed as an operand, or a global).
+nostackmeans that the asm code does not push any data onto the stack. This allows the compiler to use optimizations such as the stack red zone on x86-64 to avoid stack pointer adjustments.
+
These allow the compiler to better optimize code using asm!, for example by eliminating pure asm! blocks whose outputs are not needed.
See the reference for the full list of available options and their effects.
+macro
+Tests
+Write Tests
+Benchmark
+https://doc.rust-lang.org/unstable-book/library-features/test.html
+Unit and Integration
+Assertions
+Async/Await
+async and await!
+Future
+Pin and Unpin
+Stream
+Stand Library todo
+String
+Fighting with Compiler
+Fighting with compiler is very common in our daily coding, especially for those unfamiliar with Rust.
+This chapter will provide some exercises to help us avoid such cases to lower the steep learning curve.
+Borrowing
+-
+
- 🌟🌟 +
+// FIX the error without removing any code line +struct test { + list: Vec<i32>, + a: i32 +} + +impl test { + pub fn new() -> Self { + test { list:vec![1,2,3,4,5,6,7], a:0 } + } + + pub fn run(&mut self) { + for i in self.list.iter() { + self.do_something(*i) + } + + } + + pub fn do_something(&mut self, n: i32) { + self.a = n; + } +} + +fn main() {}
++ + +You can find the solutions here(under the solutions path), but only use it when you need it :)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/result-panic/panic.html b/result-panic/panic.html
new file mode 100644
index 000000000..373ae357a
--- /dev/null
+++ b/result-panic/panic.html
@@ -0,0 +1,319 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Result and panic
+Learning resources:
+-
+
- English: Rust Book 9.1, 9.2 +
- 简体中文: Rust语言圣经 - 返回值和错误处理 +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/result-panic/result.html b/result-panic/result.html
new file mode 100644
index 000000000..5e1d77767
--- /dev/null
+++ b/result-panic/result.html
@@ -0,0 +1,412 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ panic!
+The simplest error handling mechanism is to use panic. It just prints an error message and starts unwinding the stack, finally exit the current thread:
-
+
- if panic occurred in
mainthread, then the program will be exited.
+ - if in spawned thread, then this thread will be terminated, but the program won't +
-
+
- 🌟🌟 +
++// FILL the blanks +fn drink(beverage: &str) { + if beverage == "lemonade" { + println!("Success!"); + // IMPLEMENT the below code + __ + } + + println!("Exercise Failed if printing out this line!"); +} + +fn main() { + drink(__); + + println!("Exercise Failed if printing out this line!"); +}
common panic cases
+-
+
- 🌟🌟 +
+// MAKE the code work by fixing all panics +fn main() { + assert_eq!("abc".as_bytes(), [96, 97, 98]); + + let v = vec![1, 2, 3]; + let ele = v[3]; + // unwrap may panic when get return a None + let ele = v.get(3).unwrap(); + + // Sometimes, the compiler is unable to find the overflow errors for you in compile time ,so a panic will occur + let v = production_rate_per_hour(2); + + // because of the same reason as above, we have to wrap it in a function to make the panic occur + divide(15, 0); + + println!("Success!") +} + +fn divide(x:u8, y:u8) { + println!("{}", x / y) +} + +fn production_rate_per_hour(speed: u8) -> f64 { + let cph: u8 = 221; + match speed { + 1..=4 => (speed * cph) as f64, + 5..=8 => (speed * cph) as f64 * 0.9, + 9..=10 => (speed * cph) as f64 * 0.77, + _ => 0 as f64, + } +} + +pub fn working_items_per_minute(speed: u8) -> u32 { + (production_rate_per_hour(speed) / 60 as f64) as u32 +}
Detailed call stack
+By default the stack unwinding will only give something like this:
+thread 'main' panicked at 'index out of bounds: the len is 3 but the index is 99', src/main.rs:4:5
+note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
+Though there is the reason of panic and the line of the code is showing where the panic has occured, sometimes we want to get more info about the call stack.
+-
+
- 🌟 +
## FILL in the blank to display the whole call stack
+## Tips: you can find the clue in the default panic info
+$ __ cargo run
+thread 'main' panicked at 'assertion failed: `(left == right)`
+ left: `[97, 98, 99]`,
+ right: `[96, 97, 98]`', src/main.rs:3:5
+stack backtrace:
+ 0: rust_begin_unwind
+ at /rustc/9d1b2106e23b1abd32fce1f17267604a5102f57a/library/std/src/panicking.rs:498:5
+ 1: core::panicking::panic_fmt
+ at /rustc/9d1b2106e23b1abd32fce1f17267604a5102f57a/library/core/src/panicking.rs:116:14
+ 2: core::panicking::assert_failed_inner
+ 3: core::panicking::assert_failed
+ at /rustc/9d1b2106e23b1abd32fce1f17267604a5102f57a/library/core/src/panicking.rs:154:5
+ 4: study_cargo::main
+ at ./src/main.rs:3:5
+ 5: core::ops::function::FnOnce::call_once
+ at /rustc/9d1b2106e23b1abd32fce1f17267604a5102f57a/library/core/src/ops/function.rs:227:5
+note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace.
+unwinding and abort
+By default, when a panic occurs, the program starts unwinding, which means Rust walks back up the stack and cleans up the data from each function it encounters.
But this walk back and clean up is a lot of work. The alternative is to immediately abort the program without cleaning up.
+If in your project you need to make the resulting binary as small as possible, you can switch from unwinding to aborting by adding below content to Cargo.toml:
[profile.release]
+panic = 'abort'
+++ + +You can find the solutions here(under the solutions path), but only use it when you need it :)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/searcher.js b/searcher.js
new file mode 100644
index 000000000..d2b0aeed3
--- /dev/null
+++ b/searcher.js
@@ -0,0 +1,483 @@
+"use strict";
+window.search = window.search || {};
+(function search(search) {
+ // Search functionality
+ //
+ // You can use !hasFocus() to prevent keyhandling in your key
+ // event handlers while the user is typing their search.
+
+ if (!Mark || !elasticlunr) {
+ return;
+ }
+
+ //IE 11 Compatibility from https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith
+ if (!String.prototype.startsWith) {
+ String.prototype.startsWith = function(search, pos) {
+ return this.substr(!pos || pos < 0 ? 0 : +pos, search.length) === search;
+ };
+ }
+
+ var search_wrap = document.getElementById('search-wrapper'),
+ searchbar = document.getElementById('searchbar'),
+ searchbar_outer = document.getElementById('searchbar-outer'),
+ searchresults = document.getElementById('searchresults'),
+ searchresults_outer = document.getElementById('searchresults-outer'),
+ searchresults_header = document.getElementById('searchresults-header'),
+ searchicon = document.getElementById('search-toggle'),
+ content = document.getElementById('content'),
+
+ searchindex = null,
+ doc_urls = [],
+ results_options = {
+ teaser_word_count: 30,
+ limit_results: 30,
+ },
+ search_options = {
+ bool: "AND",
+ expand: true,
+ fields: {
+ title: {boost: 1},
+ body: {boost: 1},
+ breadcrumbs: {boost: 0}
+ }
+ },
+ mark_exclude = [],
+ marker = new Mark(content),
+ current_searchterm = "",
+ URL_SEARCH_PARAM = 'search',
+ URL_MARK_PARAM = 'highlight',
+ teaser_count = 0,
+
+ SEARCH_HOTKEY_KEYCODE = 83,
+ ESCAPE_KEYCODE = 27,
+ DOWN_KEYCODE = 40,
+ UP_KEYCODE = 38,
+ SELECT_KEYCODE = 13;
+
+ function hasFocus() {
+ return searchbar === document.activeElement;
+ }
+
+ function removeChildren(elem) {
+ while (elem.firstChild) {
+ elem.removeChild(elem.firstChild);
+ }
+ }
+
+ // Helper to parse a url into its building blocks.
+ function parseURL(url) {
+ var a = document.createElement('a');
+ a.href = url;
+ return {
+ source: url,
+ protocol: a.protocol.replace(':',''),
+ host: a.hostname,
+ port: a.port,
+ params: (function(){
+ var ret = {};
+ var seg = a.search.replace(/^\?/,'').split('&');
+ var len = seg.length, i = 0, s;
+ for (;i
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Using Result in
+
+
+
+
+ result and ?
+Result<T> is an enum to describe possible errors. It has two variants:
-
+
Ok(T): A value T was found
+Err(e): An error was found with a valuee
+
In short words, the expected outcome is Ok, while the unexpected outcome is Err.
-
+
- 🌟🌟 +
++// FILL in the blanks and FIX the errors +use std::num::ParseIntError; + +fn multiply(n1_str: &str, n2_str: &str) -> __ { + let n1 = n1_str.parse::<i32>(); + let n2 = n2_str.parse::<i32>(); + Ok(n1.unwrap() * n2.unwrap()) +} + +fn main() { + let result = multiply("10", "2"); + assert_eq!(result, __); + + let result = multiply("t", "2"); + assert_eq!(result.__, 8); + + println!("Success!"); +}
?
+? is almost exactly equivalent to unwrap, but ? returns instead of panic on Err.
-
+
- 🌟🌟 +
++use std::num::ParseIntError; + +// IMPLEMENT multiply with ? +// DON'T use unwrap here +fn multiply(n1_str: &str, n2_str: &str) -> __ { +} + +fn main() { + assert_eq!(multiply("3", "4").unwrap(), 12); + println!("Success!"); +}
-
+
- 🌟🌟 +
++use std::fs::File; +use std::io::{self, Read}; + +fn read_file1() -> Result<String, io::Error> { + let f = File::open("hello.txt"); + let mut f = match f { + Ok(file) => file, + Err(e) => return Err(e), + }; + + let mut s = String::new(); + match f.read_to_string(&mut s) { + Ok(_) => Ok(s), + Err(e) => Err(e), + } +} + +// FILL in the blanks with one code line +// DON'T change any code lines +fn read_file2() -> Result<String, io::Error> { + let mut s = String::new(); + + __; + + Ok(s) +} + +fn main() { + assert_eq!(read_file1().unwrap_err().to_string(), read_file2().unwrap_err().to_string()); + println!("Success!"); +}
map & and_then
+map and and_then are two common combinators for Result<T, E> (also for Option<T>).
-
+
- 🌟🌟 +
+use std::num::ParseIntError; + +// FILL in the blank in two ways: map, and then +fn add_two(n_str: &str) -> Result<i32, ParseIntError> { + n_str.parse::<i32>().__ +} + +fn main() { + assert_eq!(add_two("4").unwrap(), 6); + + println!("Success!"); +}
-
+
- 🌟🌟🌟 +
+use std::num::ParseIntError; + +// With the return type rewritten, we use pattern matching without `unwrap()`. +// But it's so Verbose... +fn multiply(n1_str: &str, n2_str: &str) -> Result<i32, ParseIntError> { + match n1_str.parse::<i32>() { + Ok(n1) => { + match n2_str.parse::<i32>() { + Ok(n2) => { + Ok(n1 * n2) + }, + Err(e) => Err(e), + } + }, + Err(e) => Err(e), + } +} + +// Rewriting `multiply` to make it succinct +// You should use BOTH of `and_then` and `map` here. +fn multiply1(n1_str: &str, n2_str: &str) -> Result<i32, ParseIntError> { + // IMPLEMENT... +} + +fn print(result: Result<i32, ParseIntError>) { + match result { + Ok(n) => println!("n is {}", n), + Err(e) => println!("Error: {}", e), + } +} + +fn main() { + // This still presents a reasonable answer. + let twenty = multiply1("10", "2"); + print(twenty); + + // The following now provides a much more helpful error message. + let tt = multiply("t", "2"); + print(tt); + + println!("Success!"); +}
Type alias
+Using std::result::Result<T, ParseIntError> everywhere is verbose and tedious, we can use alias for this purpose.
At a module level, creating aliases can be particularly helpful. Errors found in a specific module often has the same Err type, so a single alias can succinctly defined all associated Results. This is so useful even the std library supplies one: io::Result.
-
+
- 🌟 +
+use std::num::ParseIntError; + +// FILL in the blank +type __; + +// Use the above alias to refer to our specific `Result` type. +fn multiply(first_number_str: &str, second_number_str: &str) -> Res<i32> { + first_number_str.parse::<i32>().and_then(|first_number| { + second_number_str.parse::<i32>().map(|second_number| first_number * second_number) + }) +} + +// Here, the alias again allows us to save some space. +fn print(result: Res<i32>) { + match result { + Ok(n) => println!("n is {}", n), + Err(e) => println!("Error: {}", e), + } +} + +fn main() { + print(multiply("10", "2")); + print(multiply("t", "2")); + + println!("Success!"); +}
Using Result in fn main
+Typically the main function will look like this:
+fn main() { + println!("Hello World!"); +}
However main is also able to have a return type of Result. If an error occurs within the main function it will return an error code and print a debug representation of the error( Debug trait ).
The following example shows such a scenario:
+++use std::num::ParseIntError; + +fn main() -> Result<(), ParseIntError> { + let number_str = "10"; + let number = match number_str.parse::<i32>() { + Ok(number) => number, + Err(e) => return Err(e), + }; + println!("{}", number); + Ok(()) +}
++ + +You can find the solutions here(under the solutions path), but only use it when you need it :)
+