2020-12-25 14:16:02 +00:00
<!DOCTYPE HTML>
< html lang = "en" class = "sidebar-visible no-js light" >
< head >
<!-- Book generated using mdBook -->
< meta charset = "UTF-8" >
2021-02-09 09:07:07 +00:00
< title > Deref and DerefMut - Easy Rust< / title >
2020-12-25 14:16:02 +00:00
<!-- Custom HTML head -->
< meta content = "text/html; charset=utf-8" http-equiv = "Content-Type" >
< meta name = "description" content = "" >
< meta name = "viewport" content = "width=device-width, initial-scale=1" >
< meta name = "theme-color" content = "#ffffff" / >
< link rel = "icon" href = "favicon.svg" >
< link rel = "shortcut icon" href = "favicon.png" >
< link rel = "stylesheet" href = "css/variables.css" >
< link rel = "stylesheet" href = "css/general.css" >
< link rel = "stylesheet" href = "css/chrome.css" >
< link rel = "stylesheet" href = "css/print.css" media = "print" >
<!-- Fonts -->
< link rel = "stylesheet" href = "FontAwesome/css/font-awesome.css" >
< link rel = "stylesheet" href = "fonts/fonts.css" >
<!-- Highlight.js Stylesheets -->
< link rel = "stylesheet" href = "highlight.css" >
< link rel = "stylesheet" href = "tomorrow-night.css" >
< link rel = "stylesheet" href = "ayu-highlight.css" >
<!-- Custom theme stylesheets -->
< / head >
< body >
<!-- Provide site root to javascript -->
< script type = "text/javascript" >
var path_to_root = "";
var default_theme = window.matchMedia("(prefers-color-scheme: dark)").matches ? "navy" : "light";
< / script >
<!-- Work around some values being stored in localStorage wrapped in quotes -->
< script type = "text/javascript" >
try {
var theme = localStorage.getItem('mdbook-theme');
var sidebar = localStorage.getItem('mdbook-sidebar');
if (theme.startsWith('"') & & theme.endsWith('"')) {
localStorage.setItem('mdbook-theme', theme.slice(1, theme.length - 1));
}
if (sidebar.startsWith('"') & & sidebar.endsWith('"')) {
localStorage.setItem('mdbook-sidebar', sidebar.slice(1, sidebar.length - 1));
}
} catch (e) { }
< / script >
<!-- Set the theme before any content is loaded, prevents flash -->
< script type = "text/javascript" >
var theme;
try { theme = localStorage.getItem('mdbook-theme'); } catch(e) { }
if (theme === null || theme === undefined) { theme = default_theme; }
var html = document.querySelector('html');
html.classList.remove('no-js')
html.classList.remove('light')
html.classList.add(theme);
html.classList.add('js');
< / script >
<!-- Hide / unhide sidebar before it is displayed -->
< script type = "text/javascript" >
var html = document.querySelector('html');
var sidebar = 'hidden';
if (document.body.clientWidth >= 1080) {
try { sidebar = localStorage.getItem('mdbook-sidebar'); } catch(e) { }
sidebar = sidebar || 'visible';
}
html.classList.remove('sidebar-visible');
html.classList.add("sidebar-" + sidebar);
< / script >
< nav id = "sidebar" class = "sidebar" aria-label = "Table of contents" >
< div class = "sidebar-scrollbox" >
2021-02-09 09:07:07 +00:00
< ol class = "chapter" > < li class = "chapter-item expanded " > < a href = "Chapter_0.html" > < strong aria-hidden = "true" > 1.< / strong > Update< / a > < / li > < li class = "chapter-item expanded " > < a href = "Chapter_1.html" > < strong aria-hidden = "true" > 2.< / strong > Introduction< / a > < / li > < li class = "chapter-item expanded " > < a href = "Chapter_2.html" > < strong aria-hidden = "true" > 3.< / strong > Who am I?< / a > < / li > < li class = "chapter-item expanded " > < a href = "Chapter_3.html" > < strong aria-hidden = "true" > 4.< / strong > Writing Rust in Easy English< / a > < / li > < li class = "chapter-item expanded " > < a href = "Chapter_4.html" > < strong aria-hidden = "true" > 5.< / strong > Rust Playground< / a > < / li > < li class = "chapter-item expanded " > < a href = "Chapter_5.html" > < strong aria-hidden = "true" > 6.< / strong > 🚧 and ⚠️< / a > < / li > < li class = "chapter-item expanded " > < a href = "Chapter_6.html" > < strong aria-hidden = "true" > 7.< / strong > Comments< / a > < / li > < li class = "chapter-item expanded " > < a href = "Chapter_7.html" > < strong aria-hidden = "true" > 8.< / strong > Types< / a > < / li > < li class = "chapter-item expanded " > < a href = "Chapter_8.html" > < strong aria-hidden = "true" > 9.< / strong > Type inference< / a > < / li > < li class = "chapter-item expanded " > < a href = "Chapter_9.html" > < strong aria-hidden = "true" > 10.< / strong > Printing 'hello, world!'< / a > < / li > < li class = "chapter-item expanded " > < a href = "Chapter_10.html" > < strong aria-hidden = "true" > 11.< / strong > Display and debug< / a > < / li > < li class = "chapter-item expanded " > < a href = "Chapter_11.html" > < strong aria-hidden = "true" > 12.< / strong > Mutability (changing)< / a > < / li > < li class = "chapter-item expanded " > < a href = "Chapter_12.html" > < strong aria-hidden = "true" > 13.< / strong > The stack, the heap, and pointers< / a > < / li > < li class = "chapter-item expanded " > < a href = "Chapter_13.html" > < strong aria-hidden = "true" > 14.< / strong > More about printing< / a > < / li > < li class = "chapter-item expanded " > < a href = "Chapter_14.html" > < strong aria-hidden = "true" > 15.< / strong > Strings< / a > < / li > < li class = "chapter-item expanded " > < a href = "Chapter_15.html" > < strong aria-hidden = "true" > 16.< / strong > const and static< / a > < / li > < li class = "chapter-item expanded " > < a href = "Chapter_16.html" > < strong aria-hidden = "true" > 17.< / strong > More on references< / a > < / li > < li class = "chapter-item expanded " > < a href = "Chapter_17.html" > < strong aria-hidden = "true" > 18.< / strong > Mutable references< / a > < / li > < li class = "chapter-item expanded " > < a href = "Chapter_18.html" > < strong aria-hidden = "true" > 19.< / strong > Giving references to functions< / a > < / li > < li class = "chapter-item expanded " > < a href = "Chapter_19.html" > < strong aria-hidden = "true" > 20.< / strong > Copy types< / a > < / li > < li class = "chapter-item expanded " > < a href = "Chapter_20.html" > < strong aria-hidden = "true" > 21.< / strong > Collection types< / a > < / li > < li class = "chapter-item expanded " > < a href = "Chapter_21.html" > < strong aria-hidden = "true" > 22.< / strong > Vectors< / a > < / li > < li class = "chapter-item expanded " > < a href = "Chapter_22.html" > < strong aria-hidden = "true" > 23.< / strong > Tuples< / a > < / li > < li class = "chapter-item expanded " > < a href = "Chapter_23.html" > < strong aria-hidden = "true" > 24.< / strong > Control flow< / a > < / li > < li class = "chapter-item expanded " > < a href = "Chapter_24.html" > < strong aria-hidden = "true" > 25.< / strong > Structs< / a > < / li > < li class = "chapter-item expanded " > < a href = "Chapter_25.html" > < strong aria-hidden = "true" > 26.< / strong > Enums< / a > < / li > < li class = "chapter-item expanded " > < a href = "Chapter_26.html" > < strong aria-hidden = "true" > 27.< / strong > Loops< / a > < / li > < li class = "chapter-item expanded " > < a href = "Chapter_27.html" > < strong aria-hidden = "true" > 28.< / strong > Implementing structs and enums< / a > < / li > < li class = "chapter-item expanded " > < a href = "Chapter_28.html" > < strong aria-hidden = "true" > 29.< / strong > Destructuring< / a > < / li > < li class = "chapter-item expanded " > < a href = "Chapter_29.html" > < strong aria-hidden = "true" > 30.< / strong > References and the dot operator< / a > < / li > < li class = "chapter-item expanded " > < a href = "Chapter_30.html" > < strong aria-hidden = "true" > 31.< / strong > Generics< / a > < / li > < li class = "chapter-item expanded " > < a href = "Chapter_31.html" > < strong aria-hidden = "true" > 32.< / strong > Option and Result< / a > < / li > < li class = "chapter-item expanded " > < a href = "Chapter_32.html" > < strong aria-hi
2020-12-25 14:16:02 +00:00
< / div >
< div id = "sidebar-resize-handle" class = "sidebar-resize-handle" > < / div >
< / nav >
< div id = "page-wrapper" class = "page-wrapper" >
< div class = "page" >
< div id = "menu-bar-hover-placeholder" > < / div >
< div id = "menu-bar" class = "menu-bar sticky bordered" >
< div class = "left-buttons" >
< button id = "sidebar-toggle" class = "icon-button" type = "button" title = "Toggle Table of Contents" aria-label = "Toggle Table of Contents" aria-controls = "sidebar" >
< i class = "fa fa-bars" > < / i >
< / button >
< button id = "theme-toggle" class = "icon-button" type = "button" title = "Change theme" aria-label = "Change theme" aria-haspopup = "true" aria-expanded = "false" aria-controls = "theme-list" >
< i class = "fa fa-paint-brush" > < / i >
< / button >
< ul id = "theme-list" class = "theme-popup" aria-label = "Themes" role = "menu" >
< li role = "none" > < button role = "menuitem" class = "theme" id = "light" > Light (default)< / button > < / li >
< li role = "none" > < button role = "menuitem" class = "theme" id = "rust" > Rust< / button > < / li >
< li role = "none" > < button role = "menuitem" class = "theme" id = "coal" > Coal< / button > < / li >
< li role = "none" > < button role = "menuitem" class = "theme" id = "navy" > Navy< / button > < / li >
< li role = "none" > < button role = "menuitem" class = "theme" id = "ayu" > Ayu< / button > < / li >
< / ul >
< button id = "search-toggle" class = "icon-button" type = "button" title = "Search. (Shortkey: s)" aria-label = "Toggle Searchbar" aria-expanded = "false" aria-keyshortcuts = "S" aria-controls = "searchbar" >
< i class = "fa fa-search" > < / i >
< / button >
< / div >
< h1 class = "menu-title" > Easy Rust< / h1 >
< div class = "right-buttons" >
< a href = "print.html" title = "Print this book" aria-label = "Print this book" >
< i id = "print-button" class = "fa fa-print" > < / i >
< / a >
< / div >
< / div >
< div id = "search-wrapper" class = "hidden" >
< form id = "searchbar-outer" class = "searchbar-outer" >
< input type = "search" name = "search" id = "searchbar" name = "searchbar" placeholder = "Search this book ..." aria-controls = "searchresults-outer" aria-describedby = "searchresults-header" >
< / form >
< div id = "searchresults-outer" class = "searchresults-outer hidden" >
< div id = "searchresults-header" class = "searchresults-header" > < / div >
< ul id = "searchresults" >
< / ul >
< / div >
< / div >
<!-- Apply ARIA attributes after the sidebar and the sidebar toggle button are added to the DOM -->
< script type = "text/javascript" >
document.getElementById('sidebar-toggle').setAttribute('aria-expanded', sidebar === 'visible');
document.getElementById('sidebar').setAttribute('aria-hidden', sidebar !== 'visible');
Array.from(document.querySelectorAll('#sidebar a')).forEach(function(link) {
link.setAttribute('tabIndex', sidebar === 'visible' ? 0 : -1);
});
< / script >
< div id = "content" class = "content" >
< main >
2021-02-24 06:13:19 +00:00
< h2 id = "deref-and-derefmut" > < a class = "header" href = "#deref-and-derefmut" > Deref and DerefMut< / a > < / h2 >
2021-02-09 09:07:07 +00:00
< p > < code > Deref< / code > is the trait that lets you use < code > *< / code > to dereference something. We know that a reference is not the same as a value:< / p >
< pre > < pre class = "playground" > < code class = "language-rust" > // ⚠️
2020-12-25 14:16:02 +00:00
fn main() {
2021-02-09 09:07:07 +00:00
let value = 7; // This is an i32
let reference = & 7; // This is a & i32
println!(" {}" , value == reference);
2020-12-25 14:16:02 +00:00
}
< / code > < / pre > < / pre >
2021-02-09 09:07:07 +00:00
< p > And Rust won't even give a < code > false< / code > because it won't even compare the two.< / p >
< pre > < code class = "language-text" > error[E0277]: can't compare `{integer}` with `& {integer}`
--> src\main.rs:4:26
|
4 | println!(" {}" , value == reference);
| ^^ no implementation for `{integer} == & {integer}`
< / code > < / pre >
< p > Of course, the solution here is < code > *< / code > . So this will print < code > true< / code > :< / p >
2020-12-25 14:16:02 +00:00
< pre > < pre class = "playground" > < code class = "language-rust" > fn main() {
2021-02-09 09:07:07 +00:00
let value = 7;
let reference = & 7;
println!(" {}" , value == *reference);
}
< / code > < / pre > < / pre >
< p > Now let's imagine a simple type that just holds a number. It will be like a < code > Box< / code > , and we have some ideas for some extra functions for it. But if we just give it a number, it won't be able to do much with it.< / p >
< p > We can't use < code > *< / code > like we can with < code > Box< / code > :< / p >
< pre > < pre class = "playground" > < code class = "language-rust" > // ⚠️
struct HoldsANumber(u8);
fn main() {
let my_number = HoldsANumber(20);
println!(" {}" , *my_number + 20);
2020-12-25 14:16:02 +00:00
}
< / code > < / pre > < / pre >
2021-02-09 09:07:07 +00:00
< p > The error is:< / p >
< pre > < code class = "language-text" > error[E0614]: type `HoldsANumber` cannot be dereferenced
--> src\main.rs:24:22
|
24 | println!(" {:?}" , *my_number + 20);
< / code > < / pre >
< p > We can of course do this: < code > println!(" {:?}" , my_number.0 + 20);< / code > . But then we are just adding a separate < code > u8< / code > to the 20. It would be nice if we could just add them together. The message < code > cannot be dereferenced< / code > gives us a clue: we need to implement < code > Deref< / code > . Something simple that implements < code > Deref< / code > is sometimes called a " smart pointer" . A smart pointer can point to its item, has information about it, and can use its methods. Because right now we can add < code > my_number.0< / code > , which is a < code > u8< / code > , but we can't do much else with a < code > HoldsANumber< / code > : all it has so far is < code > Debug< / code > .< / p >
< p > Interesting fact: < code > String< / code > is actually a smart pointer to < code > & str< / code > and < code > Vec< / code > is a smart pointer to array (or other types). So we have actually been using smart pointers since the beginning.< / p >
< p > Implementing < code > Deref< / code > is not too hard and the examples in the standard library are easy. < a href = "https://doc.rust-lang.org/std/ops/trait.Deref.html" > Here's the sample code from the standard library< / a > :< / p >
2021-04-12 02:48:40 +00:00
< pre > < pre class = "playground" > < code class = "language-rust" > use std::ops::Deref;
2021-02-09 09:07:07 +00:00
struct DerefExample< T> {
value: T
2020-12-25 14:16:02 +00:00
}
2021-02-09 09:07:07 +00:00
impl< T> Deref for DerefExample< T> {
type Target = T;
fn deref(& self) -> & Self::Target {
& self.value
}
}
2021-04-12 02:48:40 +00:00
fn main() {
let x = DerefExample { value: 'a' };
assert_eq!('a', *x);
}
< / code > < / pre > < / pre >
2021-02-09 09:07:07 +00:00
< p > So we follow that and now our < code > Deref< / code > looks like this:< / p >
< pre > < pre class = "playground" > < code class = "language-rust" >
< span class = "boring" > #![allow(unused)]
< / span > < span class = "boring" > fn main() {
< / span > // 🚧
impl Deref for HoldsANumber {
type Target = u8; // Remember, this is the " associated type" : the type that goes together.
// You have to use the right type Target = (the type you want to return)
fn deref(& self) -> & Self::Target { // Rust calls .deref() when you use *. We just defined Target as a u8 so this is easy to understand
& self.0 // We chose & self.0 because it's a tuple struct. In a named struct it would be something like " & self.number"
}
}
< span class = "boring" > }
< / span > < / code > < / pre > < / pre >
< p > So now we can do this with < code > *< / code > :< / p >
< pre > < pre class = "playground" > < code class = "language-rust" > use std::ops::Deref;
#[derive(Debug)]
struct HoldsANumber(u8);
impl Deref for HoldsANumber {
type Target = u8;
fn deref(& self) -> & Self::Target {
& self.0
}
}
fn main() {
let my_number = HoldsANumber(20);
println!(" {:?}" , *my_number + 20);
}
< / code > < / pre > < / pre >
< p > So that will print < code > 40< / code > and we didn't need to write < code > my_number.0< / code > . That means we get the methods of < code > u8< / code > and we can write our own methods for < code > HoldsANumber< / code > . We will add our own simple method and use another method we get from < code > u8< / code > called < code > .checked_sub()< / code > . The < code > .checked_sub()< / code > method is a safe subtraction that returns an < code > Option< / code > . If it can do the subtraction then it gives it to you inside < code > Some< / code > , and if it can't do it then it gives a < code > None< / code > . Remember, a < code > u8< / code > can't be negative so it's safer to do < code > .checked_sub()< / code > so we don't panic.< / p >
< pre > < pre class = "playground" > < code class = "language-rust" > use std::ops::Deref;
struct HoldsANumber(u8);
impl HoldsANumber {
fn prints_the_number_times_two(& self) {
println!(" {}" , self.0 * 2);
}
}
impl Deref for HoldsANumber {
type Target = u8;
fn deref(& self) -> & Self::Target {
& self.0
}
}
fn main() {
let my_number = HoldsANumber(20);
println!(" {:?}" , my_number.checked_sub(100)); // This method comes from u8
my_number.prints_the_number_times_two(); // This is our own method
}
< / code > < / pre > < / pre >
< p > This prints:< / p >
< pre > < code class = "language-text" > None
40
2020-12-25 14:16:02 +00:00
< / code > < / pre >
2021-02-09 09:07:07 +00:00
< p > We can also implement < code > DerefMut< / code > so we can change the values through < code > *< / code > . It looks almost the same. You need < code > Deref< / code > before you can implement < code > DerefMut< / code > .< / p >
< pre > < pre class = "playground" > < code class = "language-rust" > use std::ops::{Deref, DerefMut};
struct HoldsANumber(u8);
impl HoldsANumber {
fn prints_the_number_times_two(& self) {
println!(" {}" , self.0 * 2);
}
}
impl Deref for HoldsANumber {
type Target = u8;
fn deref(& self) -> & Self::Target {
& self.0
}
}
impl DerefMut for HoldsANumber { // You don't need type Target = u8; here because it already knows thanks to Deref
fn deref_mut(& mut self) -> & mut Self::Target { // Everything else is the same except it says mut everywhere
& mut self.0
}
}
fn main() {
let mut my_number = HoldsANumber(20);
*my_number = 30; // DerefMut lets us do this
println!(" {:?}" , my_number.checked_sub(100));
my_number.prints_the_number_times_two();
}
< / code > < / pre > < / pre >
< p > So you can see that < code > Deref< / code > gives your type a lot of power.< / p >
< p > This is also why the standard library says: < code > Deref should only be implemented for smart pointers to avoid confusion< / code > . That's because you can do some strange things with < code > Deref< / code > for a complicated type. Let's imagine a really confusing example to understand what they mean. We'll start with < code > Character< / code > struct for a game. A new < code > Character< / code > needs some stats like intelligence and strength. So here is our first character:< / p >
< pre > < pre class = "playground" > < code class = "language-rust" > struct Character {
name: String,
strength: u8,
dexterity: u8,
health: u8,
intelligence: u8,
wisdom: u8,
charm: u8,
hit_points: i8,
alignment: Alignment,
}
impl Character {
fn new(
name: String,
strength: u8,
dexterity: u8,
health: u8,
intelligence: u8,
wisdom: u8,
charm: u8,
hit_points: i8,
alignment: Alignment,
) -> Self {
Self {
name,
strength,
dexterity,
health,
intelligence,
wisdom,
charm,
hit_points,
alignment,
}
}
}
enum Alignment {
Good,
Neutral,
Evil,
}
fn main() {
let billy = Character::new(" Billy" .to_string(), 9, 8, 7, 10, 19, 19, 5, Alignment::Good);
2020-12-25 14:16:02 +00:00
}
< / code > < / pre > < / pre >
2021-02-09 09:07:07 +00:00
< p > Now let's imagine that we want to keep character hit points in a big vec. Maybe we'll put monster data in there too, and keep it all together. Since < code > hit_points< / code > is an < code > i8< / code > , we implement < code > Deref< / code > so we can do all sorts of math on it. But look at how strange it looks in our < code > main()< / code > function now:< / p >
< pre > < pre class = "playground" > < code class = "language-rust" > use std::ops::Deref;
// All the other code is the same until after the enum Alignment
struct Character {
name: String,
strength: u8,
dexterity: u8,
health: u8,
intelligence: u8,
wisdom: u8,
charm: u8,
hit_points: i8,
alignment: Alignment,
2020-12-25 14:16:02 +00:00
}
2021-02-09 09:07:07 +00:00
impl Character {
fn new(
name: String,
strength: u8,
dexterity: u8,
health: u8,
intelligence: u8,
wisdom: u8,
charm: u8,
hit_points: i8,
alignment: Alignment,
) -> Self {
Self {
name,
strength,
dexterity,
health,
intelligence,
wisdom,
charm,
hit_points,
alignment,
2020-12-25 14:16:02 +00:00
}
}
}
2021-02-09 09:07:07 +00:00
enum Alignment {
Good,
Neutral,
Evil,
}
impl Deref for Character { // impl Deref for Character. Now we can do any integer math we want!
type Target = i8;
fn deref(& self) -> & Self::Target {
& self.hit_points
}
}
2020-12-25 14:16:02 +00:00
fn main() {
2021-02-09 09:07:07 +00:00
let billy = Character::new(" Billy" .to_string(), 9, 8, 7, 10, 19, 19, 5, Alignment::Good); // Create two characters, billy and brandy
let brandy = Character::new(" Brandy" .to_string(), 9, 8, 7, 10, 19, 19, 5, Alignment::Good);
let mut hit_points_vec = vec![]; // Put our hit points data in here
hit_points_vec.push(*billy); // Push *billy?
hit_points_vec.push(*brandy); // Push *brandy?
println!(" {:?}" , hit_points_vec);
2020-12-25 14:16:02 +00:00
}
< / code > < / pre > < / pre >
2021-02-09 09:07:07 +00:00
< p > This just prints < code > [5, 5]< / code > . Our code is now very strange for someone to read. We can read < code > Deref< / code > just above < code > main()< / code > and figure out that < code > *billy< / code > means < code > i8< / code > , but what if there was a lot of code? Maybe our code is 2000 lines long, and suddenly we have to figure out why we are < code > .push()< / code > ing < code > *billy< / code > . < code > Character< / code > is certainly more than just a smart pointer for < code > i8< / code > .< / p >
< p > Of course, it is not illegal to write < code > hit_points_vec.push(*billy)< / code > , but it makes the code look very strange. Probably a simple < code > .get_hp()< / code > method would be much better, or another struct that holds the characters. Then you could iterate through and push the < code > hit_points< / code > for each one. < code > Deref< / code > gives a lot of power but it's good to make sure that the code is logical.< / p >
2020-12-25 14:16:02 +00:00
< / main >
< nav class = "nav-wrapper" aria-label = "Page navigation" >
<!-- Mobile navigation buttons -->
< a rel = "prev" href = "Chapter_55.html" class = "mobile-nav-chapters previous" title = "Previous chapter" aria-label = "Previous chapter" aria-keyshortcuts = "Left" >
< i class = "fa fa-angle-left" > < / i >
< / a >
< a rel = "next" href = "Chapter_57.html" class = "mobile-nav-chapters next" title = "Next chapter" aria-label = "Next chapter" aria-keyshortcuts = "Right" >
< i class = "fa fa-angle-right" > < / i >
< / a >
< div style = "clear: both" > < / div >
< / nav >
< / div >
< / div >
< nav class = "nav-wide-wrapper" aria-label = "Page navigation" >
< a rel = "prev" href = "Chapter_55.html" class = "nav-chapters previous" title = "Previous chapter" aria-label = "Previous chapter" aria-keyshortcuts = "Left" >
< i class = "fa fa-angle-left" > < / i >
< / a >
< a rel = "next" href = "Chapter_57.html" class = "nav-chapters next" title = "Next chapter" aria-label = "Next chapter" aria-keyshortcuts = "Right" >
< i class = "fa fa-angle-right" > < / i >
< / a >
< / nav >
< / div >
< script type = "text/javascript" >
window.playground_copyable = true;
< / script >
< script src = "elasticlunr.min.js" type = "text/javascript" charset = "utf-8" > < / script >
< script src = "mark.min.js" type = "text/javascript" charset = "utf-8" > < / script >
< script src = "searcher.js" type = "text/javascript" charset = "utf-8" > < / script >
< script src = "clipboard.min.js" type = "text/javascript" charset = "utf-8" > < / script >
< script src = "highlight.js" type = "text/javascript" charset = "utf-8" > < / script >
< script src = "book.js" type = "text/javascript" charset = "utf-8" > < / script >
<!-- Custom JS scripts -->
< / body >
< / html >
