commit 95f15fe53141b1a2770847a7531f39e2e4196fb6 Author: mimu Date: Sat Aug 22 14:49:33 2026 +0200 move diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000..7b84c60 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,10 @@ +FROM ghcr.io/getzola/zola:v0.17.1 as zola + +COPY . /website +WORKDIR /website +RUN ["zola", "build"] + +FROM ghcr.io/static-web-server/static-web-server:2 +WORKDIR / +COPY --from=zola /website/public /public + diff --git a/README.md b/README.md new file mode 100644 index 0000000..1fd62cb --- /dev/null +++ b/README.md @@ -0,0 +1 @@ +# website diff --git a/config.toml b/config.toml new file mode 100644 index 0000000..7d727a7 --- /dev/null +++ b/config.toml @@ -0,0 +1,22 @@ +# The URL the site will be built for +base_url = "/" + +# Whether to automatically compile all Sass files in the sass directory +compile_sass = true + +# Whether to build a search index to be used later on by a JavaScript library +build_search_index = true + +taxonomies = [ + { name = "tags", feed = true }, + { name = "type", feed = false }, +] + +[markdown] +# Whether to do syntax highlighting +# Theme can be customised by setting the `highlight_theme` variable to a theme supported by Zola +highlight_code = true +highlight_theme = "gruvbox-dark" + +[extra] +# Put all your custom variables here diff --git a/content/_index.md b/content/_index.md new file mode 100644 index 0000000..e940f6a --- /dev/null +++ b/content/_index.md @@ -0,0 +1,5 @@ ++++ +sort_by = "date" +transparent = true +title = "Brice Bernard - Software Engineer" ++++ diff --git a/content/about/index.md b/content/about/index.md new file mode 100644 index 0000000..1d09df4 --- /dev/null +++ b/content/about/index.md @@ -0,0 +1,12 @@ ++++ +title = "About" +template = "about.html" +date = "2010-01-01" + +[taxonomies] +type = ["page"] ++++ + +# About + +todo diff --git a/content/blog/_index.md b/content/blog/_index.md new file mode 100644 index 0000000..a40bdb3 --- /dev/null +++ b/content/blog/_index.md @@ -0,0 +1,7 @@ ++++ +title = "Unintented Fraud - Blog" +sort_by = "date" +template = "blog.html" +page_template = "blog_page.html" +transparent = true ++++ diff --git a/content/blog/angularjs/index.md b/content/blog/angularjs/index.md new file mode 100644 index 0000000..4f9b250 --- /dev/null +++ b/content/blog/angularjs/index.md @@ -0,0 +1,262 @@ ++++ +title = "Speed-up angularjs (v1) - remove watchers" +date = 2015-03-12 + +[taxonomies] +tags = ["angularjs", "javascript", "sneaky"] ++++ + +**Note from 2024**: I copying over this post from ages ago because I'm actually quite proud of it even though it was probably a terrible practice if it would have +been used. This was my first "wow" moment. Probably the first time I fixed a real problem I thought was too big or complicated for me, and it +worked so well I thought I broke the entire thing. Changing a list so slow it's literally stuttering to a list so fluid you would think +it's just text without interaction felt really good. + + +-- + +AngularJS is great, easy to use, somewhat easy to learn if you don't believe everything you read online and think a little bit, and most importantly allow you to do some bindings in a very simple way. Everything is updating in real time, you don't have to do anything, it's perfect. + +However it doesn't come without drawbacks, the biggest one being **performance**. +With Angular 1.3 came the "bind once" syntax using the `::` syntax. This is great but sometimes you want to keep all of your bindings set because the values might change, and that can become an issue in long lists (for example an infinite scrolling `ng-repeat`). + +## How to remove / re-add watchers + +First, we need it to be transparent for the user. They need to be able to do whatever they want and don't feel any slowdown. + +The first idea I had was to actually remove the elements outside the viewport, and put them back when needed using `$compile`, but it was **VERY SLOW** to the point that the page was very annoying to use. + +So I decided to **use the debug info** created by default by Angular. It provides a shit load of stuff, including arrays of watchers associated with every elements. The idea was to store the arrays of watchers locally, empty the ones attached to the element, and fill them back when needed. + +It's actually very easy. +An element has 2 kind of watchers associated to it, the ones from its `scope` and the ones from its `isolateScope`, so we need to store both of them. + +* We need an array to store the watchers, we'll call it **wArray**. +* The first element would be another array of 2 elements, the watchers from the the `scope`, the watchers from the `isolateScope` +* Then we will loop through every child element and do the same + +In the end we will have an array like this. + +```js +wArray = [ + [[scope watchers from the element], [isolateScope watchers from the element]], + [[scope watchers from the first child], [isolateScope watchers from the first child]], + ... + [[scope watchers from the last child], [isolateScope watchers from the last child]] +] +``` + +That will allow us to put them back very easily. + +Here is an example code: + +```js +function getElemWatchers(element) { + wArray[i] = []; + wArray[i][0] = getWatchersFromScope(element.data().$isolateScope); + wArray[i][1] = getWatchersFromScope(element.data().$scope); + + angular.forEach(element.children(), function (childElement) { + i++; + getElemWatchers(angular.element(childElement)); + }); +} + + function getWatchersFromScope(scope) { + if (scope) { + var tmp = scope.$$watchers || []; + scope.$$watchers.length = 0; + return tmp; + } else { + return []; + } +} + +getElemWatchers(elem); +``` + + +So we stored the watchers and remove them from the element. What do to when we need to enable them back? +As you probably anticipate, we just have to do the exact same thing in reverse, we have our array with every watchers associated with every child of the element, so we loop through it and put fill the arrays: + +```js +function setElemWatchers(element) { + setWatchersFromScope(element.data().$isolateScope, 0); + setWatchersFromScope(element.data().$scope, 1); + + angular.forEach(element.children(), function(childElement) { + i++; + setElemWatchers(angular.element(childElement)); + }); +} + +function setWatchersFromScope(scope, n) { + if (scope) { + scope.$$watchers = wArray[i][n]; + } +} + +setElemWatchers(elem); +``` + + + +## When to call all of this? + +We can disable and enable the watchers of an element, now we need to be able to do this everytime an element end up in or outside the viewport. + +For that we just listen to the scroll event, and test for each element is it's inside or outise the viewport, and act accordingly. + +A few tips first: + +* Consider adding a **debounce function to your listener**, so you actually do all the watchers thing when the user is done scrolling instead of every time the scrolling event triggers, which is A LOT +* Add a boolean to indicate if the element is hidden or not, so if its status does not change, as it won't for most of the elements, you don't do anything + +With that in mind, we would have something like this as our listener: + +```js +var checkElements = debounce(function() { + scope.$broadcast('dwhCheckElements'); +}, 250); + +document.addEventListener('scroll', checkElements); +``` + +This code is pretty straightforward, every time the user scrolls, we broadcast an event to let the elements know they need to check if their "status/visibility" changed, and disable / enable their watchers. + +So yes there are actually **2 directives** here. +The first one on the parent element, the `ngRepeat`, to handle the scroll listener. The 2nd one of every child element you want to be disabled if invisible. + +I also added a "range of error" of 1000 pixels, which means we consider the viewport to be the viewport itself + 1000 up and down so if an element is half visible it still works. + +## Full code + +You can find the full directives code below or [on github](https://github.com/Mimuuu/Disable-When-Hidden). + +Also this code could probably be better, and if you want to use it you should probably be sure that using it is worth having the debug info in your app. Since 1.3 [you can disable it](https://docs.angularjs.org/guide/production) and I see no reason why you shouldn't. + +```js +(function() { + 'use strict'; + + var app = angular.module('app'); + + // Parent directive + // Broadcast an event to every listening child every time the user is scrolling + app.directive('disableWhenHidden', function() { + return { + restrict: 'A', + + link: function(scope) { + + function debounce(fn, delay) { + var timer = null; + return function () { + var context = this, args = arguments; + clearTimeout(timer); + timer = setTimeout(function () { + fn.apply(context, args); + }, delay); + }; + } + + var checkElements = debounce(function() { + scope.$broadcast('dwhCheckElements'); + }, 250); + + document.addEventListener('scroll', checkElements); + } + }; + }); + + app.directive('dwhElement', function() { + return { + restrict: 'A', + + link: function(scope, element) { + + var m = 1000; // Range of "errors" outside the viewport + var wArray = []; // Array to store all the watchers + var isHidden = false; // Used to prevent useless computation + + // Store and remove the watchers of the element + var disableWatchers = function () { + wArray.length = 0; + leaveHimToDie(element); + isHidden = true; + }; + + // Put the watchers back + var enableWatchers = function () { + bringHimBack(element); + isHidden = false; + }; + + // Listener + scope.$on('dwhCheckElements', function () { + var coordinates = element[0].getBoundingClientRect(); + if (coordinates.bottom > 0 - m && coordinates.top < window.innerHeight + m) { + if (isHidden) { + enableWatchers(); + } + } else if (!isHidden) { + disableWatchers(); + } + }); + + // Remove watchers from the element passed in parameter + var leaveHimToDie = function (elem) { + var i = 0; + + function getElemWatchers(element) { + wArray[i] = []; + wArray[i][0] = getWatchersFromScope(element.data().$isolateScope); + wArray[i][1] = getWatchersFromScope(element.data().$scope); + + angular.forEach(element.children(), function (childElement) { + i++; + getElemWatchers(angular.element(childElement)); + }); + } + + function getWatchersFromScope(scope) { + if (scope) { + var tmp = scope.$$watchers || []; + scope.$$watchers = []; + return tmp; + } else { + return []; + } + } + + getElemWatchers(elem); + }; + + // Enable back watchers to the element passed in parameter + var bringHimBack = function (elem) { + var i = 0; + + function setElemWatchers(element) { + setWatchersFromScope(element.data().$isolateScope, 0); + setWatchersFromScope(element.data().$scope, 1); + + angular.forEach(element.children(), function (childElement) { + i++; + setElemWatchers(angular.element(childElement)); + }); + } + + function setWatchersFromScope(scope, n) { + if (scope) { + scope.$$watchers = wArray[i][n]; + } + } + + // Start the loop + setElemWatchers(elem); + }; + } + }; + }); +})(); +``` + diff --git a/content/blog/draft/bruteforce_algo.md b/content/blog/draft/bruteforce_algo.md new file mode 100644 index 0000000..3259d74 --- /dev/null +++ b/content/blog/draft/bruteforce_algo.md @@ -0,0 +1,5 @@ ++++ +title = "bruteforce algo" ++++ + +make a bruteforce algo and see how it works. Simple one. diff --git a/content/blog/draft/cinema_tbd.md b/content/blog/draft/cinema_tbd.md new file mode 100644 index 0000000..09af6d6 --- /dev/null +++ b/content/blog/draft/cinema_tbd.md @@ -0,0 +1,6 @@ ++++ +title = "cinema tbd name" ++++ + +# todo +either cli or website that shows cinema situation for the day by movies with links to book diff --git a/content/blog/draft/discord_bot.md b/content/blog/draft/discord_bot.md new file mode 100644 index 0000000..ff67ff9 --- /dev/null +++ b/content/blog/draft/discord_bot.md @@ -0,0 +1,6 @@ ++++ +title = "discord bot" ++++ + +# todo +everything diff --git a/content/blog/draft/go_k8s_perf.md b/content/blog/draft/go_k8s_perf.md new file mode 100644 index 0000000..7b7f54f --- /dev/null +++ b/content/blog/draft/go_k8s_perf.md @@ -0,0 +1,9 @@ ++++ +title = "todo" ++++ + +Compare k8s go performance on a 1 cpu when specifying the +env variable GOMAXPROCS and GOMAXMEMORY (or something like that) +using limits.cpu and limits.memory. + +Should be night and day. diff --git a/content/blog/draft/linux_endeavouros.md b/content/blog/draft/linux_endeavouros.md new file mode 100644 index 0000000..c8cf719 --- /dev/null +++ b/content/blog/draft/linux_endeavouros.md @@ -0,0 +1,7 @@ ++++ +title = "configure endeavouros" ++++ + +All configs, files to edit for commong things like +configure volume change, keyboard, luminosity change, mouse / trackpad behaviour, etc. + diff --git a/content/blog/draft/sql_over_partition.md b/content/blog/draft/sql_over_partition.md new file mode 100644 index 0000000..111e2d9 --- /dev/null +++ b/content/blog/draft/sql_over_partition.md @@ -0,0 +1,23 @@ ++++ +title = "sql over partition" ++++ + +write and learn how over partition works + +we had duplicates in our databases, needed to delete all of them except one +so had to query them, groupped together and know which one was a duplicate +so it can be removed safely and keep one occurence of each + +``` +select * from ( + select + row_number() over (partition by column_name order by column_name2 desc) as row_num, + * from table_name + where + type = 'xxx' + and content->'prop_name'->>'prop_name2' = 'xxx' + and column_name3 > now() - interval '12 hours' +) as rn +where row_num > '1' +; +``` diff --git a/content/blog/gocontext/index.md b/content/blog/gocontext/index.md new file mode 100644 index 0000000..e9b1a40 --- /dev/null +++ b/content/blog/gocontext/index.md @@ -0,0 +1,360 @@ ++++ +title = "Understanding Go context" +date = 2024-03-11 + +[taxonomies] +tags = ["go", "learning", "context", "channels"] ++++ + +Go contexts are a good candidate for something you can use without understanding it. When you see that a context is expected +in a function's definition, you can pass the request's context, or `context.Background()` and call it a day. If you're feeling +a little crazy you pass a context with a timeout, and it magically work as expected. Here we will try to see the main usages +of context (timeout and passing values), but also try to implement a function using a context and see how the implementation +look like. + + + +From the official documentation ([https://pkg.go.dev/context](https://pkg.go.dev/context)), we can highlight: + +*"Incoming requests to a server should create a Context, and outgoing calls to servers should accept a Context. +The chain of function calls between them must propagate the Context, optionally replacing it with a derived +Context [...] When a Context is canceled, all Contexts derived from it are also canceled."* + +From this we already understand multiple things: +- requests usually make heavy use of context, probably where they will be encountered the most +- a context can have children +- if a parent is cancelled, the children are too + +If you want to have more details and visualise it, I would recommend this talk: +[The context package internals - Damiano Petrungaro](https://www.youtube.com/watch?v=mfgBhGu5pco). + +Let's see in our own examples how to use context, for timeouts and adding data to a request. + +1. [Overview of our simple server](#1-overview-of-our-simple-server) +2. [Use context to pass request-related data to the endpoint](#2-use-context-to-pass-request-related-data-to-the-endpoint) +3. [Use context for timeout](#3-use-context-for-timeout) +4. [Some tweaked examples](#4-some-tweaked-examples) + +## 1. Overview of our simple server + +Our examples will be requests related so we need a server. Go has a very useful `http` package to do that, I took the liberty +to create a wrapper around it to handle middlewares easier. +```go +type ServerHandler func(http.Handler) http.Handler + +type Server struct {} + +func (s *Server) Handle(addr string, handlers ...ServerHandler) { + http.Handle(addr, handleMiddlewares(handlers)) +} + +func (s *Server) Listen(port int) error { + if err := http.ListenAndServe(fmt.Sprintf(":%d", port), nil); err != nil { + return fmt.Errorf("server broke: %s", err.Error()) + } + + return nil +} + +func handleMiddlewares(handlers []ServerHandler) http.Handler { + var handler http.Handler + + for i := range handlers { + handler = handlers[len(handlers)-1-i](handler) + } + + return handler +} +``` +This allows us to add middlewares in a more readable way than the default. +`http.Handle(path, middleware1, middleware2, handler)` instead of the default +`http.Handle(path, middleware1(middleware2(handler)))`. + +## 2. Use context to pass request-related data to the endpoint + +It is important to note that the doc specify: +*"Use context Values only for request-scoped data that transits processes and APIs, not for passing optional +parameters to functions."* + +My example will technically not do that, but it should highlight the principle. In real life, +I've used it to add user-related data to the request, a third-party API client ready to go, things like that. +I'm sure there are other ways to take advantage of it. + +```go +const PORT = 8080 + +func main() { + server := &Server{} + + server.Handle("/get-value", addValueToContext, handleGetValue) + + if err := server.Listen(PORT); err != nil { + panic(err) + } + fmt.Println("listening on :", PORT) +} +``` + +Here we create our server, have a route `/get-value`, a middleware that will add values to the request's context, and the +route handler that will read from the context and return the values. + +Let's look at the middleware first: + +```go +type ComplexStruct struct { + question string + possibleAnswers []string +} + +func addValueToContext(next http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + // Add simple values + ctx1 := context.WithValue(r.Context(), "number", 420) + ctx2 := context.WithValue(ctx1, "sad_message", "RIP Toriyama :(") + + // Add a more complex one + cs := ComplexStruct{ + question: "What is your favourite Dragon Ball character?", + possibleAnswers: []string{ + "Goku", + "Gohan", + "Vegeta", + "You get the idea", + }, + } + + ctx3 := context.WithValue(ctx2, "complex_struct", cs) + + next.ServeHTTP(w, r.WithContext(ctx3)) + }) +} +``` + + + +Here we store 3 values in the context. I added a number, a string and a custom struct to show that we can store anything +we need. + +If you look closely, you'll notice that we create a new context every time. Context can only contain one value, and all +of their constructor methods expect a context and return a child from that context. + +Here `ctx3` is the "youngest" child, which we pass onto the next step. Below is our route handler: + +```go +func handleGetValue(next http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + n := r.Context().Value("number") + str := r.Context().Value("sad_message") + complex := r.Context().Value("complex_struct") + undefined := r.Context().Value("value does not exist") + + w.Write([]byte(fmt.Sprintf("\n number: [%d]", n))) + w.Write([]byte(fmt.Sprintf("\n message: [%s]", str))) + w.Write([]byte(fmt.Sprintf("\n complex struct: [%+v]", complex))) + w.Write([]byte(fmt.Sprintf("\n undefined value: [%+v] \n", undefined))) + }) +} +``` + +We retrieve the values and write them to the client. +For good measures I added a value that does not exist to see what happens (spoiler: it's `nil`). + +For simplicity, I will just curl our endpoint from the terminal: +``` +curl localhost:8080/get-value + +number: [420] +message: [RIP Toriyama :(] +complex struct: [{question:What is your favourite Dragon Ball character? possibleAnswers:[Goku Gohan Vegeta You get the idea]}] +undefined value: [] +``` + +We get all of our values as expected. + +You may wonder how did we retrieve all of the values, when we passed the youngest context `ctx3` that only contains the +complex struct. This is because instead of seeing contexts as individual object, we should see them as one branch of a tree, +starting at the original one (usually `context.Background()`), all the way down to the context we are interacting with +in our code. Here our full context is really: +``` +context.Background() -> r.Context() -> ctx1 -> ctx2 -> ctx3 +``` +When we query a value, Go will look in the immediate context, and move up one level all the way to the top if +the value is not found. For example, this is what happen when looking up the value "number": +1. check the value "numbers" in `ctx3`, it is not there (it is "complex_struct") +2. check the value "numbers" in `ctx2`, it is not there (it is "message") +3. check the value "numbers" in `ctx1`, found + +If we attached `ctx2` to our request instead of `ctx3`, then the curl would show `nil` for the complex struct, because `ctx3` would not +be checked. + +## 3. Use context for timeout + +Probably the main reason to use context: timeout and deadlines. Making sure we're not hanging somewhere for too long. + +In this example, we'll forget about our context values, and update our route handler to mimic some long operation using +context. The handler looks like this now: +```go +func handleGetValue(next http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + log.Println(t(), "handleGetValue started") + defer log.Println(t(), "handleGetNumber ended") + + ctx, cancelCtx := context.WithTimeout(r.Context(), 2*time.Second) + defer cancelCtx() + + err := someLongAction(ctx) + if err != nil { + w.Write([]byte(fmt.Sprintf("\n%s - Error happened: %s", t(), err.Error()))) + log.Println(t(), "Error happened: ", err) + return + } + + w.Write([]byte(fmt.Sprintf("%s -- operation finished successfully", t()))) + }) +} +``` +First we need to create a new context that include a timeout. What it means internally is that the context will be cancelled +once the timeout duration has been reached. It is up to whoever wants to make use of the context to check and return an error +if that happen. + +In our example, this will be the role of `someLongAction`, it should return an error if the context expires. The function +is defined as: +```go +func someLongAction(ctx context.Context) error { + log.Println("someLongAction started") + defer log.Println("someLongAction ended") + + select { + case err := <-simulatingOperation(): + return err + case <-ctx.Done(): + return ctx.Err() + } +} +``` +We wait for whatever happen first: `simulatingOperation()` to finish, or the `ctx` to be done / expired. + +```go +func simulatingOperation() chan error { + log.Println("simulatingOperation started") + defer log.Println("simulatingOperation ended") + + chanErr := make(chan error, 1) + + go func() { + log.Println("goroutine in simulatingOperation started") + defer log.Println("goroutine in simulatingOperation ended") + + time.Sleep(5 * time.Second) + chanErr <- nil + }() + + return chanErr +} +``` +The `select` statement cases expect a channel, so our function need to return one. We'll return a channel containing 1 +error, as a real function would probably be suject to fail. + +We start a goroutine, sleep for 5 seconds and write the error to the channel at the end. That means that if the timeout +of the context is more than 5 seconds, we will get the result of `simulatingOperation()`, if not we will propagate the +context error. + +Let's see it in action. Remember above that we set our context timeout to 2 seconds. +``` +21:29:57 handleGetValue started +21:29:57 someLongAction started +21:29:57 simulatingOperation started +21:29:57 simulatingOperation ended +21:29:57 goroutine in simulatingOperation started +21:29:59 someLongAction ended +21:29:59 Error happened: context deadline exceeded +21:29:59 handleGetNumber ended +21:30:02 goroutine in simulatingOperation ended +``` +Above are all of server logs, that highlight the execution code in order, with the time on the left to see the effect of +the sleep and the timeouts. + +1. Started request at 29:57 +2. The goroutine started sleeping +3. Some long action ended 2 seconds later +4. The error is `context deadline exceeded` as expected +5. Route handler ends right there +6. The goroutine ends after the sleep as expected. I'm not gonna lie, this surprised me at first, I though it would be +"cancelled" magically, but it does not make sense when you think about it, as it runs concurrently, on its own. Initially +I was afraid of leaking memory or something like that, it didn't feel good that some useless code is still being executed, +but it's just what it is I think. It's the responsibility of the goroutine to not hang forever. + +On our client's side: +``` +curl localhost:8080/get-value + +21:29:59 - Error happened: context deadline exceeded +``` +We can see that we got the correct response, at the right time. + +## 4. Some tweaked examples + +Below are more examples when I tweaked some values, see what happens. + +### 4.1 Increate the timeout to 8 seconds +We should get a successful response after 5 seconds. +```go +func handleGetValue(next http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + // [...] + ctx, cancelCtx := context.WithTimeout(r.Context(), 8*time.Second) + // [...] + }) +} +``` + +Here are our server logs: +``` +22:11:02 handleGetValue started +22:11:02 someLongAction started +22:11:02 simulatingOperation started +22:11:02 simulatingOperation ended +22:11:02 goroutine in simulatingOperation started +22:11:07 goroutine in simulatingOperation ended +22:11:07 someLongAction ended +22:11:07 handleGetNumber ended +``` +And our client: +``` +curl localhost:8080/get-value + +22:11:07 -- operation finished successfully +``` +As expected, we get a successful response 5 seconds after initiating the query, no timeout happened. + +### 4.2 simulatingOperation returns an error +Keeping it as it is now, make the goroutine returns an error instead. +```go +func simulatingOperation() chan error { + // [...] + go func() { + // [...] + chanErr <- fmt.Errorf("something terrible happened, PLEASE HELP!") + }() + // [...] +} +``` +Running it we get: +``` +22:16:53 handleGetValue started +22:16:53 someLongAction started +22:16:53 simlatingOperation started +22:16:53 simlatingOperation ended +22:16:53 goroutine in simulatingOperation started +22:16:58 goroutine in simulatingOperation ended +22:16:58 someLongAction ended +22:16:58 Error happened: something terrible happened, PLEASE HELP! +22:16:58 handleGetNumber ended +``` + +``` +curl localhost:8080/get-value + +22:16:58 - Error happened: something terrible happened, PLEASE HELP! +``` +As expected, we get the error after 5 seconds. diff --git a/content/blog/rustlings/index.md b/content/blog/rustlings/index.md new file mode 100644 index 0000000..b3ed017 --- /dev/null +++ b/content/blog/rustlings/index.md @@ -0,0 +1,1545 @@ ++++ +title = "Rustlings - Solutions" +date = 2024-02-10 + +[taxonomies] +tags = ["rust", "learning"] ++++ + +[Rustlings](https://github.com/rust-lang/rustlings/tree/main) is a nice project presenting you with a serie of small +exercises to learn most of the concept of the languages. From declaring variables to more advances concepts. We are +presented with a failing program and should fix it in order to compile. + + + +Below are my solutions, maybe it'll help someone, possibly future me who knows. + +[intro2.rs](#intro2-rs) + +[variables1.rs](#variables-variables1-rs) +[variables2.rs](#variables-variables2-rs) +[variables3.rs](#variables-variables3-rs) +[variables4.rs](#variables-variables4-rs) +[variables5.rs](#variables-variables5-rs) +[variables6.rs](#variables-variables6-rs) + +[functions1.rs](#functions-functions1-rs) +[functions2.rs](#functions-functions2-rs) +[functions3.rs](#functions-functions3-rs) +[functions4.rs](#functions-functions4-rs) +[functions5.rs](#functions-functions5-rs) + +[if1.rs](#if-if1-rs) +[if2.rs](#if-if2-rs) +[if3.rs](#if-if3-rs) + +[quiz1.rs](#quiz1-rs) + +[primitive_types1.rs](#primitive-types-primitive-types-1-rs) +[primitive_types2.rs](#primitive-types-primitive-types-2-rs) +[primitive_types3.rs](#primitive-types-primitive-types-3-rs) +[primitive_types4.rs](#primitive-types-primitive-types-4-rs) +[primitive_types5.rs](#primitive-types-primitive-types-5-rs) +[primitive_types6.rs](#primitive-types-primitive-types-6-rs) + +[vecs1.rs](#vecs-vecs1-rs) +[vecs2.rs](#vecs-vecs2-rs) + +[move_semantics1.rs](#move-semantics-move-semantics1-rs) +[move_semantics2.rs](#move-semantics-move-semantics2-rs) +[move_semantics3.rs](#move-semantics-move-semantics3-rs) +[move_semantics4.rs](#move-semantics-move-semantics4-rs) +[move_semantics5.rs](#move-semantics-move-semantics5-rs) +[move_semantics6.rs](#move-semantics-move-semantics6-rs) + +[structs1.rs](#structs-structs1-rs) +[structs2.rs](#structs-structs2-rs) +[structs3.rs](#structs-structs3-rs) + +[enums1.rs](#enums-enums1-rs) +[enums2.rs](#enums-enums2-rs) +[enums3.rs](#enums-enums3-rs) + +[strings1.rs](#strings-strings1-rs) +[strings2.rs](#strings-strings2-rs) +[strings3.rs](#strings-strings3-rs) +[strings4.rs](#strings-strings4-rs) + +[modules1.rs](#modules-modules1-rs) +[modules2.rs](#modules-modules2-rs) +[modules3.rs](#modules-modules3-rs) + +[hashmaps1.rs](#hashmaps-hashmaps1-rs) +[hashmaps2.rs](#hashmaps-hashmaps2-rs) +[hashmaps3.rs](#hashmaps-hashmaps3-rs) + +[quiz2.rs](#quiz2-rs) + +[options1.rs](#options-options1-rs) +[options2.rs](#options-options2-rs) +[options3.rs](#options-options3-rs) + +[errors1.rs](#error-handling-errors1-rs) +[errors2.rs](#error-handling-errors2-rs) +[errors3.rs](#error-handling-errors3-rs) +[errors4.rs](#error-handling-errors4-rs) +[errors5.rs](#error-handling-errors5-rs) +[errors6.rs](#error-handling-errors6-rs) + +[generics1](#generics-generics1-rs) +[generics2](#generics-generics2-rs) + +TBC. + +### intro2.rs +Needed to add an argument to the `println` macro. Or remove the expected argument I guess. + +```rs +// Make the code print a greeting to the world. +fn main() { + println!("Hello {}!", "world"); +} +``` + +### variables/variables1.rs +We need to define `x` using `let`. +```rs +// Make me compile +fn main() { + let x = 5; + println!("x has the value {}", x); +} +``` + +### variables/variables2.rs +`x` was not initialized. You can change leave the default type like I did or specify whatever you want (as long as it's +comparable to `10`). +```rs +fn main() { + let x = 0; + if x == 10 { + println!("x is ten!"); + } else { + println!("x is not ten!"); + } +} +``` + +### variables/variables3.rs +`x` needs to be assigned a value before being used. +```rs +fn main() { + let x: i32 = 12; + println!("Number {}", x); +} +``` + +### variables/variables4.rs +Variables are immutable by default, here we want to change the value so we need to initialize the variable as mutable. +```rs +fn main() { + let mut x = 3; + println!("Number {}", x); + x = 5; // don't change this line + println!("Number {}", x); +} +``` + +### variables/variables5.rs +Here we "shadow" `x` by re-declaring another variable with the same name. +```rs +fn main() { + let number = "T-H-R-E-E"; // don't change this line + println!("Spell a Number : {}", number); + let number = 3; + println!("Number plus two is : {}", number + 2); +} +``` + +### variables/variables6.rs +A `const` need to be typed. +```rs +const NUMBER: usize = 3; +fn main() { + println!("Number {}", NUMBER); +} +``` + +### functions/functions1.rs +We need to define the function `call_me` with no arguments and nothing returned. +```rs +fn main() { + call_me(); +} + +fn call_me() { + println!("Call me!"); +} +``` + +### functions/functions2.rs +We need to type the function's argument `num`. Could be any number types. +```rs +fn main() { + call_me(3); +} + +fn call_me(num: i32) { + for i in 0..num { + println!("Ring! Call number {}", i + 1); + } +} +``` + +### functions/functions3.rs +This one is the kind of the reverse, we cannot call a function without passing the expected arguments. +```rs +fn main() { + call_me(4); +} + +fn call_me(num: u32) { + for i in 0..num { + println!("Ring! Call number {}", i + 1); + } +} +``` + +### functions/functions4.rs +Here we are missing the return type of `sale_price`. Have to be the same as the argument given because we are returning +either `price - 10` or `price - 3` which would be the same type as `price`. +```rs +// This store is having a sale where if the price is an even number, you get 10 +// Rustbucks off, but if it's an odd number, it's 3 Rustbucks off. (Don't worry +// about the function bodies themselves, we're only interested in the signatures +// for now. If anything, this is a good way to peek ahead to future exercises!) + +fn main() { + let original_price = 51; + println!("Your sale price is {}", sale_price(original_price)); +} + +fn sale_price(price: i32) -> i32 { + if is_even(price) { + price - 10 + } else { + price - 3 + } +} + +fn is_even(num: i32) -> bool { + num % 2 == 0 +} +``` + +### functions/functions5.rs +Here they probably want us to remove the `;` and therefore returning the statement. I don't like this syntax so let's +just add the `return` keyword like gentlemen. +```rs +fn main() { + let answer = square(3); + println!("The square of 3 is {}", answer); +} + +fn square(num: i32) -> i32 { + return num * num; +} +``` + +### if/if1.rs +```rs +pub fn bigger(a: i32, b: i32) -> i32 { + // Complete this function to return the bigger number! + // Do not use: + // - another function call + // - additional variables + + if a > b { + return a; + } else { + return b; + } +} +``` + +### if/if2.rs +```rs +// Step 1: Make me compile! +// Step 2: Get the bar_for_fuzz and default_to_baz tests passing! +// +pub fn foo_if_fizz(fizzish: &str) -> &str { + if fizzish == "fizz" { + return "foo"; + } else if fizzish == "fuzz" { + return "bar"; + } + + return "baz"; +} +``` + +### if/if3.rs +The `if` statement defining `identifier` was returning different types, which is fine however `identifier` is used +below as comparison to integers, therefore we need to ensure that identifier is an `int` all the time. +```rs +pub fn animal_habitat(animal: &str) -> &'static str { + let identifier = if animal == "crab" { + 1 + } else if animal == "gopher" { + 2 + } else if animal == "snake" { + 3 + } else { + 0 + }; + + // DO NOT CHANGE THIS STATEMENT BELOW + let habitat = if identifier == 1 { + "Beach" + } else if identifier == 2 { + "Burrow" + } else if identifier == 3 { + "Desert" + } else { + "Unknown" + }; + + habitat +} +``` + +### quiz1.rs +```rs +// Mary is buying apples. The price of an apple is calculated as follows: +// - An apple costs 2 rustbucks. +// - If Mary buys more than 40 apples, each apple only costs 1 rustbuck! +// Write a function that calculates the price of an order of apples given the +// quantity bought. +// + +// Put your function here! +fn calculate_price_of_apples(num: i32) -> i32 { + let price_per_apple = if num > 40 { 1 } else { 2 }; + + return num * price_per_apple; +} +``` + +### primitive_types/primitive_types_1.rs +```rs +// Fill in the rest of the line that has code missing! No hints, there's no +// tricks, just get used to typing these :) + +fn main() { + // Booleans (`bool`) + + let is_morning = true; + if is_morning { + println!("Good morning!"); + } + + let is_evening = false; + if is_evening { + println!("Good evening!"); + } +} +``` + +### primitive_types/primitive_types_2.rs +```rs +// Fill in the rest of the line that has code missing! No hints, there's no +// tricks, just get used to typing these :) +fn main() { + // Characters (`char`) + + // Note the _single_ quotes, these are different from the double quotes + // you've been seeing around. + let my_first_initial = 'C'; + if my_first_initial.is_alphabetic() { + println!("Alphabetical!"); + } else if my_first_initial.is_numeric() { + println!("Numerical!"); + } else { + println!("Neither alphabetic nor numeric!"); + } + + // Finish this line like the example! What's your favorite character? + // Try a letter, try a number, try a special character, try a character + // from a different language than your own, try an emoji! + let your_character = '5'; + if your_character.is_alphabetic() { + println!("Alphabetical!"); + } else if your_character.is_numeric() { + println!("Numerical!"); + } else { + println!("Neither alphabetic nor numeric!"); + } +} +``` + +### primitive_types/primitive_types_3.rs +```rs +// Create an array with at least 100 elements in it where the ??? is. +// +fn main() { + let a = ["hello"; 150]; + + if a.len() >= 100 { + println!("Wow, that's a big array!"); + } else { + println!("Meh, I eat arrays like that for breakfast."); + panic!("Array not big enough, more elements needed") + } +} +``` + +### primitive_types/primitive_types_4.rs +```rs +// Get a slice out of Array a where the ??? is so that the test passes. +#[test] +fn slice_out_of_array() { + let a = [1, 2, 3, 4, 5]; + + let nice_slice = &a[1..4]; + + assert_eq!([2, 3, 4], nice_slice) +} +``` + +### primitive_types/primitive_types_5.rs +Note that you can also destructure it directly when declaring cat, and do: +`let (name, age) = ("Furry McFurson", 3.5);`. +```rs +// Destructure the `cat` tuple so that the println will work. +fn main() { + let cat = ("Furry McFurson", 3.5); + let (name, age) = cat; + + println!("{} is {} years old.", name, age); +} +``` + +### primitive_types/primitive_types_6.rs +```rs +// Use a tuple index to access the second element of `numbers`. You can put the +// expression for the second element where ??? is so that the test passes. +// +#[test] +fn indexing_tuple() { + let numbers = (1, 2, 3); + // Replace below ??? with the tuple indexing syntax. + let second = numbers.1; + + assert_eq!(2, second, "This is not the 2nd number in the tuple!") +} +``` + +### vecs/vecs1.rs +```rs +// Your task is to create a `Vec` which holds the exact same elements as in the +// array `a`. +// +// Make me compile and pass the test! +fn array_and_vec() -> ([i32; 4], Vec) { + let a = [10, 20, 30, 40]; // a plain array + let v = Vec::from(a); + + (a, v) +} +``` + +### vecs/vecs2.rs +```rs +// A Vec of even numbers is given. Your task is to complete the loop so that +// each number in the Vec is multiplied by 2. +// +fn vec_loop(mut v: Vec) -> Vec { + for element in v.iter_mut() { + // TODO: Fill this up so that each element in the Vec `v` is + // multiplied by 2. + *element = *element * 2; + } + + // At this point, `v` should be equal to [4, 8, 12, 16, 20]. + v +} + +fn vec_map(v: &Vec) -> Vec { + v.iter() + .map(|element| { + // TODO: Do the same thing as above - but instead of mutating the + // Vec, you can just return the new number! + return element * 2; + }) + .collect() +} +``` + +### move_semantics/move_semantics1.rs +Cannot push to an immutable `Vec`. +Furthermore, as the hint suggest, if we try to access `vec0` in `main` after using `fill_vec`, we get an error +indicating that `vec0` was moved to `fill_vec`. +```rs +// Execute `rustlings hint move_semantics1` or use the `hint` watch subcommand +// for a hint. +#[test] +fn main() { + let vec0 = vec![22, 44, 66]; + + let vec1 = fill_vec(vec0); + + assert_eq!(vec1, vec![22, 44, 66, 88]); +} + +fn fill_vec(vec: Vec) -> Vec { + let mut vec = vec; + + vec.push(88); + + vec +} +``` + +### move_semantics/move_semantics2.rs +We pass a reference to `fill_vec` instead of a value so the ownership does not change, and then `clone` the value to +initiate our vector without issue. +```rs +// Make the test pass by finding a way to keep both Vecs separate! +// +#[test] +fn main() { + let vec0 = vec![22, 44, 66]; + + let mut vec1 = fill_vec(&vec0); + + assert_eq!(vec0, vec![22, 44, 66]); + assert_eq!(vec1, vec![22, 44, 66, 88]); +} + +fn fill_vec(vec: &Vec) -> Vec { + let mut vec = vec.clone(); + + vec.push(88); + + vec +} +``` + +### move_semantics/move_semantics3.rs +We've added `mut` in the argument's definition of `fill_vec` to allow us to push into it. +```rs +// Make me compile without adding new lines -- just changing existing lines! (no +// lines with multiple semicolons necessary!) +// +#[test] +fn main() { + let vec0 = vec![22, 44, 66]; + + let vec1 = fill_vec(vec0); + + assert_eq!(vec1, vec![22, 44, 66, 88]); +} + +fn fill_vec(mut vec: Vec) -> Vec { + vec.push(88); + + vec +} +``` + +### move_semantics/move_semantics4.rs +Simply move the vector initialization to the `fill_vec` function as asked. +```rs +// Refactor this code so that instead of passing `vec0` into the `fill_vec` +// function, the Vector gets created in the function itself and passed back to +// the main function. +// +#[test] +fn main() { + let mut vec1 = fill_vec(); + + assert_eq!(vec1, vec![22, 44, 66, 88]); +} + +// `fill_vec()` no longer takes `vec: Vec` as argument - don't change this! +fn fill_vec() -> Vec { + // Instead, let's create and fill the Vec in here - how do you do that? + let mut vec = vec![22, 44, 66]; + + vec.push(88); + + vec +} +``` + +### move_semantics/move_semantics5.rs +Only one borrow can be active at the same time. In the original order, `y` was unusable once we initialize `z` as it's +borrowing the same original value. We need to make sure to finish everything we want to do with `y` before declaring `z`. +```rs +// Make me compile only by reordering the lines in `main()`, but without adding, +// changing or removing any of them. +// +#[test] +fn main() { + let mut x = 100; + let y = &mut x; + *y += 100; + let z = &mut x; + *z += 1000; + assert_eq!(x, 1200); +} +``` + +### move_semantics/move_semantics6.rs +We had `get_char` take ownership of `data` and `string_uppercase` taking a reference while we need the other way +around. +```rs +// You can't change anything except adding or removing references. +// +fn main() { + let data = "Rust is great!".to_string(); + + get_char(&data); + + string_uppercase(data); +} + +// Should not take ownership +fn get_char(data: &String) -> char { + data.chars().last().unwrap() +} + +// Should take ownership +fn string_uppercase(mut data: String) { + data = data.to_uppercase(); + + println!("{}", data); +} +``` + +### structs/structs1.rs +```rs +// Address all the TODOs to make the tests pass! +// +struct ColorClassicStruct { + red: i32, + green: i32, + blue: i32, +} + +struct ColorTupleStruct(i32, i32, i32); + +#[derive(Debug)] +struct UnitLikeStruct; + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn classic_c_structs() { + // TODO: Instantiate a classic c struct! + let green = ColorClassicStruct { + red: 0, + green: 255, + blue: 0, + }; + + assert_eq!(green.red, 0); + assert_eq!(green.green, 255); + assert_eq!(green.blue, 0); + } + + #[test] + fn tuple_structs() { + // TODO: Instantiate a tuple struct! + let green = (0, 255, 0); + + assert_eq!(green.0, 0); + assert_eq!(green.1, 255); + assert_eq!(green.2, 0); + } + + #[test] + fn unit_structs() { + // TODO: Instantiate a unit-like struct! + let unit_like_struct = UnitLikeStruct; + let message = format!("{:?}s are fun!", unit_like_struct); + + assert_eq!(message, "UnitLikeStructs are fun!"); + } +} +``` + +### structs/structs2.rs +```rs +// Address all the TODOs to make the tests pass! +// +#[derive(Debug)] +struct Order { + name: String, + year: u32, + made_by_phone: bool, + made_by_mobile: bool, + made_by_email: bool, + item_number: u32, + count: u32, +} + +fn create_order_template() -> Order { + Order { + name: String::from("Bob"), + year: 2019, + made_by_phone: false, + made_by_mobile: false, + made_by_email: true, + item_number: 123, + count: 0, + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn your_order() { + let order_template = create_order_template(); + // TODO: Create your own order using the update syntax and template above! + let your_order = Order { + name: String::from("Hacker in Rust"), + count: 1, + ..order_template + }; + assert_eq!(your_order.name, "Hacker in Rust"); + assert_eq!(your_order.year, order_template.year); + assert_eq!(your_order.made_by_phone, order_template.made_by_phone); + assert_eq!(your_order.made_by_mobile, order_template.made_by_mobile); + assert_eq!(your_order.made_by_email, order_template.made_by_email); + assert_eq!(your_order.item_number, order_template.item_number); + assert_eq!(your_order.count, 1); + } +} +``` + +### structs/structs3.rs +```rs +// Structs contain data, but can also have logic. In this exercise we have +// defined the Package struct and we want to test some logic attached to it. +// Make the code compile and the tests pass! +// +// Execute `rustlings hint structs3` or use the `hint` watch subcommand for a +// hint. + +// I AM NOT DONE + +#[derive(Debug)] +struct Package { + sender_country: String, + recipient_country: String, + weight_in_grams: u32, +} + +impl Package { + fn new(sender_country: String, recipient_country: String, weight_in_grams: u32) -> Package { + if weight_in_grams < 10 { + // This is not how you should handle errors in Rust, + // but we will learn about error handling later. + panic!("Can not ship a package with weight below 10 grams.") + } else { + Package { + sender_country, + recipient_country, + weight_in_grams, + } + } + } + + fn is_international(&self) -> bool { + return self.recipient_country != self.sender_country; + } + + fn get_fees(&self, cents_per_gram: u32) -> u32 { + return self.weight_in_grams * cents_per_gram; + } +} +``` + +### enums/enums1.rs +```rs +#[derive(Debug)] +enum Message { + Quit, + Echo, + Move, + ChangeColor, +} + +fn main() { + println!("{:?}", Message::Quit); + println!("{:?}", Message::Echo); + println!("{:?}", Message::Move); + println!("{:?}", Message::ChangeColor); +} +``` + +### enums/enums2.rs +```rs +#[derive(Debug)] +enum Message { + // TODO: define the different variants used below + Move { x: i32, y: i32 }, + Echo(String), + ChangeColor(i32, i32, i32), + Quit, +} + +impl Message { + fn call(&self) { println!("{:?}", self); + } +} + +fn main() { + let messages = [ + Message::Move { x: 10, y: 30 }, + Message::Echo(String::from("hello world")), + Message::ChangeColor(200, 255, 255), + Message::Quit, + ]; + + for message in &messages { + message.call(); + } +} +``` + +### enums/enums3.rs +Here we need to make sure to use `u8` when defining the `ChangeColor` enum, as in the state implementation that's how +color is defined. + +```rs +enum Message { + // TODO + Echo(String), + ChangeColor(u8, u8, u8), + Move(Point), + Quit, +} + +struct Point { + x: u8, + y: u8, +} + +struct State { + color: (u8, u8, u8), + position: Point, + quit: bool, + message: String, +} + +impl State { + fn change_color(&mut self, color: (u8, u8, u8)) { + self.color = color; + } + + fn quit(&mut self) { + self.quit = true; + } + + fn echo(&mut self, s: String) { + self.message = s + } + + fn move_position(&mut self, p: Point) { + self.position = p; + } + + fn process(&mut self, message: Message) { + // TODO: create a match expression to process the different message + // variants + // Remember: When passing a tuple as a function argument, you'll need + // extra parentheses: fn function((t, u, p, l, e)) + + match message { + Message::Quit => self.quit = true, + Message::ChangeColor(r, g, b) => self.change_color((r, g, b)), + Message::Echo(str) => self.echo(str), + Message::Move(p) => self.move_position(p), + } + } +} +``` + +### strings/strings1.rs +```rs +// Make me compile without changing the function signature! +// + +fn main() { + let answer = current_favorite_color(); + println!("My current favorite color is {}", answer); +} + +fn current_favorite_color() -> String { + return String::from("blue"); +} +``` + +### strings/strings2.rs +```rs +// Make me compile without changing the function signature! +// +fn main() { + let word = String::from("green"); // Try not changing this line :) + if is_a_color_word(word.as_str()) { + println!("That is a color word I know!"); + } else { + println!("That is not a color word I know."); + } +} + +fn is_a_color_word(attempt: &str) -> bool { + attempt == "green" || attempt == "blue" || attempt == "red" +} +``` + +### strings/strings3.rs +```rs +fn trim_me(input: &str) -> String { + // TODO: Remove whitespace from both ends of a string! + return input.trim().to_string(); +} + +fn compose_me(input: &str) -> String { + // TODO: Add " world!" to the string! There's multiple ways to do this! + return input.to_owned() + " world!"; + // return format!("{} world!", input); +} + +fn replace_me(input: &str) -> String { + // TODO: Replace "cars" in the string with "balloons"! + return input.replace("cars", "balloons"); +} +``` + +### strings/strings4.rs +```rs +// Ok, here are a bunch of values-- some are `String`s, some are `&str`s. Your +// task is to call one of these two functions on each value depending on what +// you think each value is. That is, add either `string_slice` or `string` +// before the parentheses on each line. If you're right, it will compile! +// +fn string_slice(arg: &str) { + println!("{}", arg); +} +fn string(arg: String) { + println!("{}", arg); +} + +fn main() { + string_slice("blue"); + string("red".to_string()); + string(String::from("hi")); + string("rust is fun!".to_owned()); + string_slice("nice weather".into()); + string(format!("Interpolation {}", "Station")); + string_slice(&String::from("abc")[0..1]); + string_slice(" hello there ".trim()); + string("Happy Monday!".to_string().replace("Mon", "Tues")); + string("mY sHiFt KeY iS sTiCkY".to_lowercase()); +} +``` + +### modules/modules1.rs +Functions in a module are private by default, so here we just need to make `make_sausage` public to be used in the +`main` function. +```rs +mod sausage_factory { + // Don't let anybody outside of this module see this! + fn get_secret_recipe() -> String { + String::from("Ginger") + } + + pub fn make_sausage() { + get_secret_recipe(); + println!("sausage!"); + } +} + +fn main() { + sausage_factory::make_sausage(); +} +``` + +### modules/modules2.rs +We need to two changes here, replace both `???` with the name used in the `main` function (`fruit` and `veggie`). We +also need to make those public in order to be able to use it outside of the module. +```rs +// You can bring module paths into scopes and provide new names for them with +// the 'use' and 'as' keywords. Fix these 'use' statements to make the code +// compile. +mod delicious_snacks { + // TODO: Fix these use statements + pub use self::fruits::PEAR as fruit; + pub use self::veggies::CUCUMBER as veggie; + + mod fruits { + pub const PEAR: &'static str = "Pear"; + pub const APPLE: &'static str = "Apple"; + } + + mod veggies { + pub const CUCUMBER: &'static str = "Cucumber"; + pub const CARROT: &'static str = "Carrot"; + } +} + +fn main() { + println!( + "favorite snacks: {} and {}", + delicious_snacks::fruit, + delicious_snacks::veggie + ); +} +``` + +### modules/modules3.rs +```rs +// You can use the 'use' keyword to bring module paths from modules from +// anywhere and especially from the Rust standard library into your scope. Bring +// SystemTime and UNIX_EPOCH from the std::time module. Bonus style points if +// you can do it with one line! +// +// TODO: Complete this use statement +use std::time::{SystemTime, UNIX_EPOCH}; + +fn main() { + match SystemTime::now().duration_since(UNIX_EPOCH) { + Ok(n) => println!("1970-01-01 00:00:00 UTC was {} seconds ago!", n.as_secs()), + Err(_) => panic!("SystemTime before UNIX EPOCH!"), + } +} +``` + +### hashmaps/hashmaps1.rs +```rs +// A basket of fruits in the form of a hash map needs to be defined. The key +// represents the name of the fruit and the value represents how many of that +// particular fruit is in the basket. You have to put at least three different +// types of fruits (e.g apple, banana, mango) in the basket and the total count +// of all the fruits should be at least five. +// +use std::collections::HashMap; + +fn fruit_basket() -> HashMap { + let mut basket = HashMap::new(); + + // Two bananas are already given for you :) + basket.insert(String::from("banana"), 2); + + // TODO: Put more fruits in your basket here. + basket.insert(String::from("mango"), 6); + basket.insert(String::from("apple"), 9); + + basket +} +``` + +### hashmaps/hashmaps2.rs +Adding `4` of each type of fruit is arbitraty, could be anything, could be randomize, as long as it's more than 11 total +as per the requirement. +```rs +// We're collecting different fruits to bake a delicious fruit cake. For this, +// we have a basket, which we'll represent in the form of a hash map. The key +// represents the name of each fruit we collect and the value represents how +// many of that particular fruit we have collected. Three types of fruits - +// Apple (4), Mango (2) and Lychee (5) are already in the basket hash map. You +// must add fruit to the basket so that there is at least one of each kind and +// more than 11 in total - we have a lot of mouths to feed. You are not allowed +// to insert any more of these fruits! +// +use std::collections::HashMap; + +#[derive(Hash, PartialEq, Eq)] +enum Fruit { + Apple, + Banana, + Mango, + Lychee, + Pineapple, +} + +fn fruit_basket(basket: &mut HashMap) { + let fruit_kinds = vec![ + Fruit::Apple, + Fruit::Banana, + Fruit::Mango, + Fruit::Lychee, + Fruit::Pineapple, + ]; + + for fruit in fruit_kinds { + // basket. Note that you are not allowed to put any type of fruit that's + // already present! + if !basket.contains_key(&fruit) { + basket.insert(fruit, 4); + } + } +} +``` + +### hashmaps/hashmaps3.rs +I extracted the logic of updating the score of a team in a separate function, but you could have duplicated it for +`team_1` and `team_2` in the `build_scores_table` function directly. +```rs +// A list of scores (one per line) of a soccer match is given. Each line is of +// the form : ",,," +// Example: England,France,4,2 (England scored 4 goals, France 2). +// +// You have to build a scores table containing the name of the team, goals the +// team scored, and goals the team conceded. One approach to build the scores +// table is to use a Hashmap. The solution is partially written to use a +// Hashmap, complete it to pass the test. + +use std::collections::HashMap; + +// A structure to store the goal details of a team. +struct Team { + goals_scored: u8, + goals_conceded: u8, +} + +fn build_scores_table(results: String) -> HashMap { + // The name of the team is the key and its associated struct is the value. + let mut scores: HashMap = HashMap::new(); + + for r in results.lines() { + let v: Vec<&str> = r.split(',').collect(); + let team_1_name = v[0].to_string(); + let team_1_score: u8 = v[2].parse().unwrap(); + let team_2_name = v[1].to_string(); + let team_2_score: u8 = v[3].parse().unwrap(); + // TODO: Populate the scores table with details extracted from the + // current line. Keep in mind that goals scored by team_1 + // will be the number of goals conceded from team_2, and similarly + // goals scored by team_2 will be the number of goals conceded by + // team_1. + + add_team_scores( + &mut scores, + team_1_name.to_string(), + team_1_score, + team_2_score, + ); + add_team_scores( + &mut scores, + team_2_name.to_string(), + team_2_score, + team_1_score, + ); + } + scores +} + +fn add_team_scores(scores: &mut HashMap, name: String, scored: u8, conceded: u8) { + let team = scores.entry(name).or_insert(Team { + goals_scored: 0, + goals_conceded: 0, + }); + + team.goals_conceded += conceded; + team.goals_scored += scored; +} +``` + +### quiz2.rs +```rs +// This is a quiz for the following sections: +// - Strings +// - Vecs +// - Move semantics +// - Modules +// - Enums +// +// Let's build a little machine in the form of a function. As input, we're going +// to give a list of strings and commands. These commands determine what action +// is going to be applied to the string. It can either be: +// - Uppercase the string +// - Trim the string +// - Append "bar" to the string a specified amount of times +// The exact form of this will be: +// - The input is going to be a Vector of a 2-length tuple, +// the first element is the string, the second one is the command. +// - The output element is going to be a Vector of strings. + +pub enum Command { + Uppercase, + Trim, + Append(usize), +} + +mod my_module { + use super::Command; + + // TODO: Complete the function signature! + pub fn transformer(input: Vec<(String, Command)>) -> Vec { + // TODO: Complete the output declaration! + let mut output: Vec = vec![]; + for (string, command) in input.iter() { + // TODO: Complete the function body. You can do it! + match command { + Command::Uppercase => { + output.push(string.to_uppercase()); + } + Command::Trim => { + output.push(string.trim().to_string()); + } + Command::Append(n) => { + let bars = "bar".repeat(*n); + output.push(format!("{}{}", string, bars)); + } + } + } + output + } +} + +#[cfg(test)] +mod tests { + // TODO: What do we need to import to have `transformer` in scope? + use super::Command; + use crate::my_module::transformer; + + [...] +} +``` + +### options/options1.rs +In the test, I am not sure if they expected `Some` or something else tbh. +```rs +// This function returns how much icecream there is left in the fridge. +// If it's before 10PM, there's 5 pieces left. At 10PM, someone eats them +// all, so there'll be no more left :( +fn maybe_icecream(time_of_day: u16) -> Option { + // We use the 24-hour system here, so 10PM is a value of 22 and 12AM is a + // value of 0 The Option output should gracefully handle cases where + // time_of_day > 23. + // TODO: Complete the function body - remember to return an Option! + if time_of_day > 23 { + return None; + } + if time_of_day < 22 { + return Some(5); + } + return Some(0); +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn check_icecream() { + assert_eq!(maybe_icecream(9), Some(5)); + assert_eq!(maybe_icecream(10), Some(5)); + assert_eq!(maybe_icecream(23), Some(0)); + assert_eq!(maybe_icecream(22), Some(0)); + assert_eq!(maybe_icecream(25), None); + } + + #[test] + fn raw_value() { + // TODO: Fix this test. How do you get at the value contained in the + // Option? + let icecreams = maybe_icecream(12); + assert_eq!(icecreams, Some(5)); + } +} +``` + +### options/options2.rs +```rs +#[cfg(test)] +mod tests { + #[test] + fn simple_option() { + let target = "rustlings"; + let optional_target = Some(target); + + // TODO: Make this an if let statement whose value is "Some" type + if let Some(word) = optional_target { + assert_eq!(word, target); + } + } + + #[test] + fn layered_option() { + let range = 10; + let mut optional_integers: Vec> = vec![None]; + + for i in 1..(range + 1) { + optional_integers.push(Some(i)); + } + + let mut cursor = range; + + // TODO: make this a while let statement - remember that vector.pop also + // adds another layer of Option. You can stack `Option`s into + // while let and if let. + while let Some(Some(integer)) = optional_integers.pop() { + assert_eq!(integer, cursor); + cursor -= 1; + } + + assert_eq!(cursor, 0); + } +} +``` + +### options/options3.rs +```rs +struct Point { + x: i32, + y: i32, +} + +fn main() { + let y: Option = Some(Point { x: 100, y: 200 }); + + match y { + Some(ref p) => println!("Co-ordinates are {},{} ", p.x, p.y), + _ => panic!("no match!"), + } + y; // Fix without deleting this line. +} +``` + +### error_handling/errors1.rs +```rs +// This function refuses to generate text to be printed on a nametag if you pass +// it an empty string. It'd be nicer if it explained what the problem was, +// instead of just sometimes returning `None`. Thankfully, Rust has a similar +// construct to `Option` that can be used to express error conditions. Let's use +// it! +// +pub fn generate_nametag_text(name: String) -> Result { + if name.is_empty() { + // Empty names aren't allowed. + return Err(String::from("`name` was empty; it must be nonempty.")); + } else { + return Ok(format!("Hi! My name is {}", name)); + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn generates_nametag_text_for_a_nonempty_name() { + assert_eq!( + generate_nametag_text("Beyoncé".into()), + Ok("Hi! My name is Beyoncé".into()) + ); + } + + #[test] + fn explains_why_generating_nametag_text_fails() { + assert_eq!( + generate_nametag_text("".into()), + // Don't change this line + Err("`name` was empty; it must be nonempty.".into()) + ); + } +} +``` + +### error_handling/errors2.rs +I put both solutions in. The `?` feels good though. +```rs +// Say we're writing a game where you can buy items with tokens. All items cost +// 5 tokens, and whenever you purchase items there is a processing fee of 1 +// token. A player of the game will type in how many items they want to buy, and +// the `total_cost` function will calculate the total cost of the tokens. Since +// the player typed in the quantity, though, we get it as a string-- and they +// might have typed anything, not just numbers! +// +// Right now, this function isn't handling the error case at all (and isn't +// handling the success case properly either). What we want to do is: if we call +// the `total_cost` function on a string that is not a number, that function +// will return a `ParseIntError`, and in that case, we want to immediately +// return that error from our function and not try to multiply and add. +// +use std::num::ParseIntError; + +pub fn total_cost(item_quantity: &str) -> Result { + let processing_fee = 1; + let cost_per_item = 5; + + let qty = item_quantity.parse::()?; + Ok(qty * cost_per_item + processing_fee) + + // We could do this instead of the ? + // let qty = item_quantity.parse::(); + // match qty { + // Ok(q) => { + // return Ok(q * cost_per_item + processing_fee); + // } + // Err(err) => { + // return Err(err); + // } + // } +} +``` + +### error_handling/errors3.rs +```rs +// This is a program that is trying to use a completed version of the +// `total_cost` function from the previous exercise. It's not working though! +// Why not? What should we do to fix it? +// +use std::num::ParseIntError; + +fn main() -> Result<(), ParseIntError> { + let mut tokens = 100; + let pretend_user_input = "8"; + + let cost = total_cost(pretend_user_input)?; + + if cost > tokens { + println!("You can't afford that many!"); + } else { + tokens -= cost; + println!("You now have {} tokens.", tokens); + } + + return Ok(()); +} +``` + +### error_handling/errors4.rs +```rs +#[derive(PartialEq, Debug)] +struct PositiveNonzeroInteger(u64); + +#[derive(PartialEq, Debug)] +enum CreationError { + Negative, + Zero, +} + +impl PositiveNonzeroInteger { + fn new(value: i64) -> Result { + // Hmm... Why is this always returning an Ok value? + if value < 0 { + return Err(CreationError::Negative); + } + if value == 0 { + return Err(CreationError::Zero); + } + + return Ok(PositiveNonzeroInteger(value as u64)); + } +} +``` + +### error_handling/errors5.rs +```rs +// This exercise uses some concepts that we won't get to until later in the +// course, like `Box` and the `From` trait. It's not important to understand +// them in detail right now, but you can read ahead if you like. For now, think +// of the `Box` type as an "I want anything that does ???" type, which, +// given Rust's usual standards for runtime safety, should strike you as +// somewhat lenient! +// +// In short, this particular use case for boxes is for when you want to own a +// value and you care only that it is a type which implements a particular +// trait. To do so, The Box is declared as of type Box where Trait is +// the trait the compiler looks for on any value used in that context. For this +// exercise, that context is the potential errors which can be returned in a +// Result. +// +// What can we use to describe both errors? In other words, is there a trait +// which both errors implement? +// +use std::error; +use std::fmt; +use std::num::ParseIntError; + +// TODO: update the return type of `main()` to make this compile. +fn main() -> Result<(), Box> { + let pretend_user_input = "42"; + let x: i64 = pretend_user_input.parse()?; + println!("output={:?}", PositiveNonzeroInteger::new(x)?); + Ok(()) +} +``` + +### error_handling/errors6.rs +```rs +// Using catch-all error types like `Box` isn't recommended +// for library code, where callers might want to make decisions based on the +// error content, instead of printing it out or propagating it further. Here, we +// define a custom error type to make it possible for callers to decide what to +// do next when our function returns an error. +// +use std::num::ParseIntError; + +// This is a custom error type that we will be using in `parse_pos_nonzero()`. +#[derive(PartialEq, Debug)] +enum ParsePosNonzeroError { + Creation(CreationError), + ParseInt(ParseIntError), +} + +impl ParsePosNonzeroError { + fn from_creation(err: CreationError) -> ParsePosNonzeroError { + return ParsePosNonzeroError::Creation(err); + } + // TODO: add another error conversion function here. + fn from_parseint(err: ParseIntError) -> ParsePosNonzeroError { + return ParsePosNonzeroError::ParseInt(err); + } +} + +fn parse_pos_nonzero(s: &str) -> Result { + // TODO: change this to return an appropriate error instead of panicking + // when `parse()` returns an error. + match s.parse() { + Err(e) => { + return Err(ParsePosNonzeroError::from_parseint(e)); + } + Ok(x) => { + return PositiveNonzeroInteger::new(x).map_err(ParsePosNonzeroError::from_creation); + } + } +} +``` + +### generics/generics1.rs +```rs +// This shopping list program isn't compiling! Use your knowledge of generics to +// fix it. +// +fn main() { + let mut shopping_list: Vec<&str> = Vec::new(); + shopping_list.push("milk"); +} +``` + +### generics/generics2.rs +```rs +// This powerful wrapper provides the ability to store a positive integer value. +// Rewrite it using generics so that it supports wrapping ANY type. +// +struct Wrapper { + value: T, +} + +impl Wrapper { + pub fn new(value: T) -> Self { + Wrapper { value } + } +} +``` diff --git a/content/contact/index.md b/content/contact/index.md new file mode 100644 index 0000000..e73e3ba --- /dev/null +++ b/content/contact/index.md @@ -0,0 +1,15 @@ ++++ +title = "Contact" +template = "about.html" +date = "2010-01-01" + +[taxonomies] +type = ["page"] ++++ + +# Contact + +You can contact me on: +- [git](https://git.bricebernard.dev/mimu) +- by email: bricecontact[at]fastmail.com + diff --git a/public/books/3body.jpg b/public/books/3body.jpg new file mode 100644 index 0000000..b99ac8f Binary files /dev/null and b/public/books/3body.jpg differ diff --git a/public/books/silo.jpg b/public/books/silo.jpg new file mode 100644 index 0000000..c7ffe5d Binary files /dev/null and b/public/books/silo.jpg differ diff --git a/public/elasticlunr.min.js b/public/elasticlunr.min.js new file mode 100644 index 0000000..79dad65 --- /dev/null +++ b/public/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.6 + * + * 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;u0&&t.push(e);for(var i in n)"docs"!==i&&"df"!==i&&this.expandToken(e+i,t,n[i]);return t},t.InvertedIndex.prototype.toJSON=function(){return{root:this.root}},t.Configuration=function(e,n){var e=e||"";if(void 0==n||null==n)throw new Error("fields should not be null");this.config={};var i;try{i=JSON.parse(e),this.buildUserConfig(i,n)}catch(o){t.utils.warn("user configuration parse failed, will use default configuration"),this.buildDefaultConfig(n)}},t.Configuration.prototype.buildDefaultConfig=function(e){this.reset(),e.forEach(function(e){this.config[e]={boost:1,bool:"OR",expand:!1}},this)},t.Configuration.prototype.buildUserConfig=function(e,n){var i="OR",o=!1;if(this.reset(),"bool"in e&&(i=e.bool||i),"expand"in e&&(o=e.expand||o),"fields"in e)for(var r in e.fields)if(n.indexOf(r)>-1){var s=e.fields[r],u=o;void 0!=s.expand&&(u=s.expand),this.config[r]={boost:s.boost||0===s.boost?s.boost:1,bool:s.bool||i,expand:u}}else t.utils.warn("field name in user configuration not found in index instance fields");else this.addAllFields2UserConfig(i,o,n)},t.Configuration.prototype.addAllFields2UserConfig=function(e,t,n){n.forEach(function(n){this.config[n]={boost:1,bool:e,expand:t}},this)},t.Configuration.prototype.get=function(){return this.config},t.Configuration.prototype.reset=function(){this.config={}},lunr.SortedSet=function(){this.length=0,this.elements=[]},lunr.SortedSet.load=function(e){var t=new this;return t.elements=e,t.length=e.length,t},lunr.SortedSet.prototype.add=function(){var e,t;for(e=0;e1;){if(r===e)return o;e>r&&(t=o),r>e&&(n=o),i=n-t,o=t+Math.floor(i/2),r=this.elements[o]}return r===e?o:-1},lunr.SortedSet.prototype.locationFor=function(e){for(var t=0,n=this.elements.length,i=n-t,o=t+Math.floor(i/2),r=this.elements[o];i>1;)e>r&&(t=o),r>e&&(n=o),i=n-t,o=t+Math.floor(i/2),r=this.elements[o];return r>e?o:e>r?o+1:void 0},lunr.SortedSet.prototype.intersect=function(e){for(var t=new lunr.SortedSet,n=0,i=0,o=this.length,r=e.length,s=this.elements,u=e.elements;;){if(n>o-1||i>r-1)break;s[n]!==u[i]?s[n]u[i]&&i++:(t.add(s[n]),n++,i++)}return t},lunr.SortedSet.prototype.clone=function(){var e=new lunr.SortedSet;return e.elements=this.toArray(),e.length=e.elements.length,e},lunr.SortedSet.prototype.union=function(e){var t,n,i;this.length>=e.length?(t=this,n=e):(t=e,n=this),i=t.clone();for(var o=0,r=n.toArray();op{margin:0 12px 0 0}} \ No newline at end of file diff --git a/public/movies/heretic.jpg b/public/movies/heretic.jpg new file mode 100644 index 0000000..c93c20c Binary files /dev/null and b/public/movies/heretic.jpg differ diff --git a/public/movies/movie1.jpg b/public/movies/movie1.jpg new file mode 100644 index 0000000..394dc42 Binary files /dev/null and b/public/movies/movie1.jpg differ diff --git a/public/movies/movie2.jpg b/public/movies/movie2.jpg new file mode 100644 index 0000000..ff77a92 Binary files /dev/null and b/public/movies/movie2.jpg differ diff --git a/public/movies/movie3.jpg b/public/movies/movie3.jpg new file mode 100644 index 0000000..cc2b1bb Binary files /dev/null and b/public/movies/movie3.jpg differ diff --git a/public/movies/movie4.jpg b/public/movies/movie4.jpg new file mode 100644 index 0000000..9b66876 Binary files /dev/null and b/public/movies/movie4.jpg differ diff --git a/public/movies/movie5.jpg b/public/movies/movie5.jpg new file mode 100644 index 0000000..485cc6c Binary files /dev/null and b/public/movies/movie5.jpg differ diff --git a/public/palette1.css b/public/palette1.css new file mode 100644 index 0000000..e69de29 diff --git a/public/palette2.css b/public/palette2.css new file mode 100644 index 0000000..e69de29 diff --git a/public/processed_images/3body.66a2504154e51d3e.jpg b/public/processed_images/3body.66a2504154e51d3e.jpg new file mode 100644 index 0000000..a274157 Binary files /dev/null and b/public/processed_images/3body.66a2504154e51d3e.jpg differ diff --git a/public/processed_images/heretic.070068c8c5f28049.jpg b/public/processed_images/heretic.070068c8c5f28049.jpg new file mode 100644 index 0000000..660b09c Binary files /dev/null and b/public/processed_images/heretic.070068c8c5f28049.jpg differ diff --git a/public/processed_images/movie1.7eb57714df0ac7f1.jpg b/public/processed_images/movie1.7eb57714df0ac7f1.jpg new file mode 100644 index 0000000..8b82dde Binary files /dev/null and b/public/processed_images/movie1.7eb57714df0ac7f1.jpg differ diff --git a/public/processed_images/movie2.77c5623711d50449.jpg b/public/processed_images/movie2.77c5623711d50449.jpg new file mode 100644 index 0000000..8f3980e Binary files /dev/null and b/public/processed_images/movie2.77c5623711d50449.jpg differ diff --git a/public/processed_images/movie3.8ce813455ea7ba01.jpg b/public/processed_images/movie3.8ce813455ea7ba01.jpg new file mode 100644 index 0000000..8fa6419 Binary files /dev/null and b/public/processed_images/movie3.8ce813455ea7ba01.jpg differ diff --git a/public/processed_images/movie4.0010a58aec56d560.jpg b/public/processed_images/movie4.0010a58aec56d560.jpg new file mode 100644 index 0000000..2c21a79 Binary files /dev/null and b/public/processed_images/movie4.0010a58aec56d560.jpg differ diff --git a/public/processed_images/movie5.656561563b654f81.jpg b/public/processed_images/movie5.656561563b654f81.jpg new file mode 100644 index 0000000..ebda1c7 Binary files /dev/null and b/public/processed_images/movie5.656561563b654f81.jpg differ diff --git a/public/search_index.en.js b/public/search_index.en.js new file mode 100644 index 0000000..2801aea --- /dev/null +++ b/public/search_index.en.js @@ -0,0 +1 @@ +window.searchIndex = {"fields":["title","body"],"pipeline":["trimmer","stopWordFilter","stemmer"],"ref":"id","version":"0.9.5","index":{"body":{"root":{"docs":{},"df":0,"1":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.4142135623730951}},"df":1,".":{"docs":{},"df":0,"3":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.4142135623730951}},"df":1}},"0":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.4142135623730951}},"df":2,"0":{"docs":{},"df":0,"0":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.4142135623730951}},"df":1}}},"1":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}},"2":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.7320508075688772},"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.7320508075688772}},"df":2,"0":{"docs":{},"df":0,"2":{"docs":{},"df":0,"4":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}}},"9":{"docs":{},"df":0,":":{"docs":{},"df":0,"5":{"docs":{},"df":0,"7":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}}}},"n":{"docs":{},"df":0,"d":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}}},"3":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.4142135623730951},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":2,".":{"docs":{},"df":0,"5":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"4":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":2,".":{"docs":{},"df":0,"1":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1},"2":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}}},"5":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":2.23606797749979}},"df":1},"8":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1},"a":{"docs":{},"df":0,"b":{"docs":{},"df":0,"o":{"docs":{},"df":0,"v":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0},"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.4142135623730951}},"df":2}}},"c":{"docs":{},"df":0,"c":{"docs":{},"df":0,"e":{"docs":{},"df":0,"p":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}},"s":{"docs":{},"df":0,"s":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"o":{"docs":{},"df":0,"m":{"docs":{},"df":0,"p":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{},"df":0,"s":{"docs":{},"df":0,"h":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0}},"df":1}}}}}},"r":{"docs":{},"df":0,"d":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"g":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}}}}}}}}},"t":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1,"i":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.4142135623730951}},"df":1}},"v":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}},"u":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0},"http://127.0.0.1:1111/blog/angularjs/":{"tf":2.23606797749979}},"df":2}}}}},"d":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.4142135623730951},"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.7320508075688772},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.4142135623730951}},"df":3,"d":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.4142135623730951},"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.7320508075688772},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.4142135623730951}},"df":3},"v":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{},"df":0,"c":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1},"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"g":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}}}}}}},"f":{"docs":{},"df":0,"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"i":{"docs":{},"df":0,"d":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}}}}},"g":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":2,"o":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}},"l":{"docs":{},"df":0,"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"w":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.4142135623730951},"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":3}}},"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"d":{"docs":{},"df":0,"i":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}}}}}},"n":{"docs":{},"df":0,"g":{"docs":{},"df":0,"u":{"docs":{},"df":0,"l":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.4142135623730951}},"df":1,"j":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.4142135623730951}},"df":1}}}}}},"n":{"docs":{},"df":0,"o":{"docs":{},"df":0,"y":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}}},"o":{"docs":{},"df":0,"t":{"docs":{},"df":0,"h":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":2}}},"s":{"docs":{},"df":0,"w":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0}},"df":1}}}},"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"c":{"docs":{},"df":0,"i":{"docs":{},"df":0,"p":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}}}}},"y":{"docs":{},"df":0,"m":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0}},"df":1}}},"t":{"docs":{},"df":0,"h":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0},"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.4142135623730951},"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":4}},"w":{"docs":{},"df":0,"a":{"docs":{},"df":0,"y":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0}},"df":1}}}}},"p":{"docs":{},"df":0,"i":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.4142135623730951}},"df":1},"p":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}},"r":{"docs":{},"df":0,"b":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{},"df":0,"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}}}}}},"g":{"docs":{},"df":0,"u":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.4142135623730951}},"df":1,"m":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":2.449489742783178}},"df":1,"'":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}}}}}},"o":{"docs":{},"df":0,"u":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":2}}}},"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"y":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":2.6457513110645907}},"df":1}}}},"s":{"docs":{},"df":0,"k":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":2},"s":{"docs":{},"df":0,"i":{"docs":{},"df":0,"g":{"docs":{},"df":0,"n":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"o":{"docs":{},"df":0,"c":{"docs":{},"df":0,"i":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.7320508075688772}},"df":1}}}}},"t":{"docs":{},"df":0,"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"h":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0},"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":2}}}}}},"b":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"k":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":2.0}},"df":1}},"s":{"docs":{},"df":0,"e":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0}},"df":1}}},"e":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0},"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0},"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":4,"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"m":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}}},"f":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.4142135623730951}},"df":1}}},"h":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.4142135623730951}},"df":1}}}},"l":{"docs":{},"df":0,"i":{"docs":{},"df":0,"e":{"docs":{},"df":0,"v":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0},"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":2}}},"o":{"docs":{},"df":0,"w":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0},"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.4142135623730951},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.4142135623730951}},"df":3}}},"n":{"docs":{},"df":0,"e":{"docs":{},"df":0,"f":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0}},"df":1}}}}},"r":{"docs":{},"df":0,"n":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"d":{"docs":{"http://127.0.0.1:1111/":{"tf":1.0}},"df":1}}}}},"t":{"docs":{},"df":0,"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}}},"w":{"docs":{},"df":0,"e":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}}}}}},"i":{"docs":{},"df":0,"g":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1,"g":{"docs":{},"df":0,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}}}}},"n":{"docs":{},"df":0,"d":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.7320508075688772}},"df":1}},"t":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}},"l":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0}},"df":1}}}}},"o":{"docs":{},"df":0,"g":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0},"http://127.0.0.1:1111/blog/":{"tf":1.0}},"df":2}}},"o":{"docs":{},"df":0,"o":{"docs":{},"df":0,"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}}}}},"r":{"docs":{},"df":0,"r":{"docs":{},"df":0,"o":{"docs":{},"df":0,"w":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.4142135623730951}},"df":1}}}},"t":{"docs":{},"df":0,"h":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.4142135623730951}},"df":2}}},"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{},"df":0,"c":{"docs":{},"df":0,"h":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}}}},"i":{"docs":{},"df":0,"c":{"docs":{},"df":0,"e":{"docs":{"http://127.0.0.1:1111/":{"tf":1.0}},"df":1,"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{},"df":0,"[":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{},"df":0,"]":{"docs":{},"df":0,"f":{"docs":{},"df":0,"a":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"m":{"docs":{},"df":0,"a":{"docs":{},"df":0,"i":{"docs":{},"df":0,"l":{"docs":{},"df":0,".":{"docs":{},"df":0,"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"m":{"docs":{"http://127.0.0.1:1111/contact/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"df":0,"a":{"docs":{},"df":0,"d":{"docs":{},"df":0,"c":{"docs":{},"df":0,"a":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}}}}}},"k":{"docs":{},"df":0,"e":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}}}},"u":{"docs":{},"df":0,"i":{"docs":{},"df":0,"l":{"docs":{},"df":0,"d":{"docs":{},"df":0,"_":{"docs":{},"df":0,"s":{"docs":{},"df":0,"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"_":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}}}}}}}}}}}}},"c":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{},"df":0,"c":{"docs":{},"df":0,"u":{"docs":{},"df":0,"l":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0}},"df":1}}},"l":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.4142135623730951},"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.7320508075688772},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":3,"_":{"docs":{},"df":0,"m":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}}},"m":{"docs":{},"df":0,"e":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}},"n":{"docs":{},"df":0,"c":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":2.23606797749979}},"df":1}}},"d":{"docs":{},"df":0,"i":{"docs":{},"df":0,"d":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}}}},"s":{"docs":{},"df":0,"e":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0},"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":2}},"t":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}},"h":{"docs":{},"df":0,"a":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}},"n":{"docs":{},"df":0,"g":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":2.0},"http://127.0.0.1:1111/blog/rustlings/":{"tf":2.0}},"df":2,"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}}}}}},"n":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.7320508075688772}},"df":1}}}}},"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0}},"df":1}},"c":{"docs":{},"df":0,"k":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0},"http://127.0.0.1:1111/blog/gocontext/":{"tf":2.23606797749979}},"df":2}},"m":{"docs":{},"df":0,"i":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0}},"df":1}}}}}}},"i":{"docs":{},"df":0,"l":{"docs":{},"df":0,"d":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.7320508075688772},"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.4142135623730951}},"df":2,"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.4142135623730951}},"df":1}}}}}}},"l":{"docs":{},"df":0,"a":{"docs":{},"df":0,"s":{"docs":{},"df":0,"s":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0}},"df":1}}},"i":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.7320508075688772}},"df":1,"'":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}}}}},"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,"e":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}},"s":{"docs":{},"df":0,"e":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}}}},"o":{"docs":{},"df":0,"d":{"docs":{},"df":0,"e":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":2.23606797749979},"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.7320508075688772}},"df":2}},"f":{"docs":{},"df":0,"f":{"docs":{},"df":0,"e":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0}},"df":1}}},"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"m":{"docs":{},"df":0,"e":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1},"p":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1,"i":{"docs":{},"df":0,"s":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}}}}},"i":{"docs":{},"df":0,"l":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":2}},"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"x":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.4142135623730951}},"df":1,"_":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"r":{"docs":{},"df":0,"u":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}}}}}}}}},"i":{"docs":{},"df":0,"c":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}}}}},"n":{"docs":{},"df":0,"c":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0}},"df":1}}},"p":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.7320508075688772},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.4142135623730951}},"df":2}}},"u":{"docs":{},"df":0,"r":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}}}},"s":{"docs":{},"df":0,"i":{"docs":{},"df":0,"d":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.4142135623730951}},"df":1}},"t":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1,"r":{"docs":{},"df":0,"u":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}}}}}}}},"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/contact/":{"tf":1.7320508075688772}},"df":1}},"i":{"docs":{},"df":0,"n":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.7320508075688772}},"df":1}}},"e":{"docs":{},"df":0,"x":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":6.708203932499369}},"df":1,".":{"docs":{},"df":0,"b":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"k":{"docs":{},"df":0,"g":{"docs":{},"df":0,"r":{"docs":{},"df":0,"o":{"docs":{},"df":0,"u":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.4142135623730951}},"df":1}}}}}}}}}}}}}},"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0}},"df":1}}}}}},"p":{"docs":{},"df":0,"i":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}},"r":{"docs":{},"df":0,"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}}}}},"u":{"docs":{},"df":0,"p":{"docs":{},"df":0,"l":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0}},"df":1}}}},"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"z":{"docs":{},"df":0,"i":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}}},"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0},"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0},"http://127.0.0.1:1111/blog/gocontext/":{"tf":2.23606797749979}},"df":3}}}},"t":{"docs":{},"df":0,"x":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1,"1":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1},"2":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.4142135623730951}},"df":1},"3":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":2.23606797749979}},"df":1}}},"u":{"docs":{},"df":0,"r":{"docs":{},"df":0,"l":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.4142135623730951}},"df":1}},"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"o":{"docs":{},"df":0,"m":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}}}}}},"d":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{},"df":0,"i":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{},"df":0,"o":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}}}}},"t":{"docs":{},"df":0,"a":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":2.23606797749979},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":2}},"y":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0},"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":2}},"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"d":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.4142135623730951}},"df":1}}}}},"b":{"docs":{},"df":0,"o":{"docs":{},"df":0,"u":{"docs":{},"df":0,"n":{"docs":{},"df":0,"c":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}}}},"u":{"docs":{},"df":0,"g":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.4142135623730951}},"df":1}}},"c":{"docs":{},"df":0,"i":{"docs":{},"df":0,"d":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}},"l":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":2.0}},"df":1}}},"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"s":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0}},"df":1}}}}},"f":{"docs":{},"df":0,"a":{"docs":{},"df":0,"u":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0},"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.4142135623730951},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.7320508075688772}},"df":3}}}},"i":{"docs":{},"df":0,"n":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0},"http://127.0.0.1:1111/blog/rustlings/":{"tf":2.23606797749979}},"df":2,"i":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0},"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":3}}}}},"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"v":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.4142135623730951}},"df":1}}},"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"r":{"docs":{},"df":0,"u":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{},"df":0,"u":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}}}}}}},"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"i":{"docs":{},"df":0,"l":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}}}}},"i":{"docs":{},"df":0,"d":{"docs":{},"df":0,"n":{"docs":{},"df":0,"'":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}}}},"f":{"docs":{},"df":0,"f":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}}},"l":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/about/":{"tf":2.23606797749979}},"df":1}}},"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.4142135623730951}},"df":1,"l":{"docs":{},"df":0,"i":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.4142135623730951}},"df":1}}}}}},"s":{"docs":{},"df":0,"a":{"docs":{},"df":0,"b":{"docs":{},"df":0,"l":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":2.0}},"df":1}}}}},"o":{"docs":{},"df":0,"c":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1,"u":{"docs":{},"df":0,"m":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}}}}}},"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"n":{"docs":{},"df":0,"'":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0},"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":2}}}}},"n":{"docs":{},"df":0,"'":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/about/":{"tf":2.6457513110645907},"http://127.0.0.1:1111/blog/angularjs/":{"tf":2.0},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":3}},"e":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0},"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":2}},"w":{"docs":{},"df":0,"n":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0},"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":2}}},"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"w":{"docs":{},"df":0,"b":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"k":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}}}}}}},"u":{"docs":{},"df":0,"p":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{},"df":0,"c":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}}},"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}}}}},"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"h":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":2}},"s":{"docs":{},"df":0,"i":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.7320508075688772}},"df":1,"e":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}},"l":{"docs":{},"df":0,"i":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}}}}},"f":{"docs":{},"df":0,"f":{"docs":{},"df":0,"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}}},"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"t":{"docs":{},"df":0,"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"s":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0}},"df":1}}}}}}}}}}},"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"m":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":4.242640687119285}},"df":1}}}}}},"m":{"docs":{},"df":0,"a":{"docs":{},"df":0,"i":{"docs":{},"df":0,"l":{"docs":{"http://127.0.0.1:1111/contact/":{"tf":1.0}},"df":1}}},"p":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}}}},"n":{"docs":{},"df":0,"a":{"docs":{},"df":0,"b":{"docs":{},"df":0,"l":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.7320508075688772}},"df":1}}},"c":{"docs":{},"df":0,"a":{"docs":{},"df":0,"p":{"docs":{},"df":0,"s":{"docs":{},"df":0,"u":{"docs":{},"df":0,"l":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0}},"df":1}}}}},"o":{"docs":{},"df":0,"u":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}}}}},"d":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.4142135623730951},"http://127.0.0.1:1111/blog/gocontext/":{"tf":2.0}},"df":2,"p":{"docs":{},"df":0,"o":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.7320508075688772}},"df":1}}}}}},"g":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{"http://127.0.0.1:1111/":{"tf":1.0},"http://127.0.0.1:1111/about/":{"tf":1.0}},"df":2}}},"o":{"docs":{},"df":0,"u":{"docs":{},"df":0,"g":{"docs":{},"df":0,"h":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0}},"df":1}}}},"s":{"docs":{},"df":0,"u":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}}},"u":{"docs":{},"df":0,"m":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1,"s":{"docs":{},"df":0,"/":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"u":{"docs":{},"df":0,"m":{"docs":{},"df":0,"s":{"docs":{},"df":0,"1":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"2":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"3":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}}}}}}}},"1":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"2":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"3":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}}}}}},"r":{"docs":{},"df":0,"r":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0},"http://127.0.0.1:1111/blog/gocontext/":{"tf":3.0},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":3,"_":{"docs":{},"df":0,"h":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"g":{"docs":{},"df":0,"/":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"r":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"s":{"docs":{},"df":0,"1":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"2":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"3":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"4":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"5":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"6":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"df":0,"1":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"2":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"3":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"4":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"5":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"6":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}}}}}}},"t":{"docs":{},"df":0,"c":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0}},"df":1}},"u":{"docs":{},"df":0,"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"k":{"docs":{},"df":0,"a":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0}},"df":1}}}}},"v":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1,"t":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.7320508075688772}},"df":1}},"r":{"docs":{},"df":0,"y":{"docs":{},"df":0,"t":{"docs":{},"df":0,"h":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.4142135623730951},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":2},"i":{"docs":{},"df":0,"m":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}}}}}}},"x":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}},"m":{"docs":{},"df":0,"p":{"docs":{},"df":0,"l":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0},"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.4142135623730951},"http://127.0.0.1:1111/blog/gocontext/":{"tf":3.0}},"df":3}}}},"c":{"docs":{},"df":0,"e":{"docs":{},"df":0,"e":{"docs":{},"df":0,"d":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}}}},"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.4142135623730951}},"df":1}}},"r":{"docs":{},"df":0,"c":{"docs":{},"df":0,"i":{"docs":{},"df":0,"s":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}}}},"i":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}}},"p":{"docs":{},"df":0,"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":3.0},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.7320508075688772}},"df":2}},"r":{"docs":{},"df":0,"i":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.4142135623730951}},"df":1}}},"i":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.4142135623730951}},"df":1}}},"t":{"docs":{},"df":0,"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}}}}}},"f":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.4142135623730951}},"df":1}},"i":{"docs":{},"df":0,"l":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":2}},"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0}},"df":1}}}}},"e":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0},"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0},"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.4142135623730951},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":4}},"l":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}},"w":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}},"i":{"docs":{},"df":0,"l":{"docs":{},"df":0,"l":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.4142135623730951}},"df":1,"_":{"docs":{},"df":0,"v":{"docs":{},"df":0,"e":{"docs":{},"df":0,"c":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":2.23606797749979}},"df":1}}}}}},"n":{"docs":{},"df":0,"d":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1},"e":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1},"i":{"docs":{},"df":0,"s":{"docs":{},"df":0,"h":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":2}}}},"r":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":2.6457513110645907},"http://127.0.0.1:1111/blog/gocontext/":{"tf":2.0}},"df":2}}},"x":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":2}},"l":{"docs":{},"df":0,"u":{"docs":{},"df":0,"i":{"docs":{},"df":0,"d":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}}}},"o":{"docs":{},"df":0,"l":{"docs":{},"df":0,"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"w":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0}},"df":1}}}},"r":{"docs":{},"df":0,"c":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0}},"df":1},"e":{"docs":{},"df":0,"v":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.4142135623730951},"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":2}},"g":{"docs":{},"df":0,"e":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}}}},"u":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.4142135623730951}},"df":1}}}},"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"u":{"docs":{},"df":0,"d":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.4142135623730951},"http://127.0.0.1:1111/blog/":{"tf":1.0},"http://127.0.0.1:1111/contact/":{"tf":1.0}},"df":3}}},"u":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.4142135623730951}},"df":1}}}},"u":{"docs":{},"df":0,"l":{"docs":{},"df":0,"l":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.4142135623730951},"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":2}},"n":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0}},"df":1,"c":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0},"http://127.0.0.1:1111/blog/gocontext/":{"tf":2.449489742783178},"http://127.0.0.1:1111/blog/rustlings/":{"tf":2.8284271247461903}},"df":3,"'":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":2},"s":{"docs":{},"df":0,"/":{"docs":{},"df":0,"f":{"docs":{},"df":0,"u":{"docs":{},"df":0,"n":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,"s":{"docs":{},"df":0,"1":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"2":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"3":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"4":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"5":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}}}}}}}}}}}},"1":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"2":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"3":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"4":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"5":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}}}}}}}}},"r":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}},"t":{"docs":{},"df":0,"h":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"m":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}}}}}}},"t":{"docs":{},"df":0,"u":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}}}},"g":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"c":{"docs":{},"df":0,"s":{"docs":{},"df":0,"/":{"docs":{},"df":0,"g":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"c":{"docs":{},"df":0,"s":{"docs":{},"df":0,"1":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"2":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}}}}}}}}}}},"1":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1},"2":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}}}}},"t":{"docs":{},"df":0,"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"m":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}}}}}},"t":{"docs":{},"df":0,"_":{"docs":{},"df":0,"c":{"docs":{},"df":0,"h":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}}}}}},"i":{"docs":{},"df":0,"t":{"docs":{},"df":0,"h":{"docs":{},"df":0,"u":{"docs":{},"df":0,"b":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0},"http://127.0.0.1:1111/contact/":{"tf":1.0}},"df":2}}}},"v":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}}},"o":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":2.23606797749979}},"df":1,"n":{"docs":{},"df":0,"n":{"docs":{},"df":0,"a":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}}},"o":{"docs":{},"df":0,"d":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0},"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.7320508075688772},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":3}},"r":{"docs":{},"df":0,"o":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":2.23606797749979}},"df":1}}}}}}},"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"d":{"docs":{},"df":0,"e":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0}},"df":1}}},"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0},"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.4142135623730951}},"df":2}}}},"u":{"docs":{},"df":0,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"s":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"i":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.4142135623730951}},"df":1}}}}}},"h":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{},"df":0,"f":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0},"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":2}},"n":{"docs":{},"df":0,"d":{"docs":{},"df":0,"l":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0},"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":2,"e":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":2.449489742783178}},"df":1}}}},"g":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.4142135623730951}},"df":1}},"p":{"docs":{},"df":0,"p":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0},"http://127.0.0.1:1111/blog/gocontext/":{"tf":2.449489742783178}},"df":2}}}},"s":{"docs":{},"df":0,"h":{"docs":{},"df":0,"m":{"docs":{},"df":0,"a":{"docs":{},"df":0,"p":{"docs":{},"df":0,"s":{"docs":{},"df":0,"/":{"docs":{},"df":0,"h":{"docs":{},"df":0,"a":{"docs":{},"df":0,"s":{"docs":{},"df":0,"h":{"docs":{},"df":0,"m":{"docs":{},"df":0,"a":{"docs":{},"df":0,"p":{"docs":{},"df":0,"s":{"docs":{},"df":0,"1":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"2":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"3":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}}}}}}}}}}},"1":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"2":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"3":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}}}}}}}},"v":{"docs":{},"df":0,"e":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0},"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":2}}},"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"v":{"docs":{},"df":0,"i":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}}},"l":{"docs":{},"df":0,"p":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.4142135623730951},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":2}},"r":{"docs":{},"df":0,"e":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.4142135623730951},"http://127.0.0.1:1111/blog/gocontext/":{"tf":2.449489742783178},"http://127.0.0.1:1111/blog/rustlings/":{"tf":2.6457513110645907}},"df":3}}},"i":{"docs":{},"df":0,"d":{"docs":{},"df":0,"d":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}}}},"g":{"docs":{},"df":0,"h":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{},"df":0,"g":{"docs":{},"df":0,"h":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.7320508075688772}},"df":1}}}}},"s":{"docs":{},"df":0,"c":{"docs":{},"df":0,"h":{"docs":{},"df":0,"o":{"docs":{},"df":0,"o":{"docs":{},"df":0,"l":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0}},"df":1}}}}}}}},"n":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"o":{"docs":{},"df":0,"p":{"docs":{},"df":0,"e":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0}},"df":1,"f":{"docs":{},"df":0,"u":{"docs":{},"df":0,"l":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0}},"df":1}}}}}}}},"t":{"docs":{},"df":0,"t":{"docs":{},"df":0,"p":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1,".":{"docs":{},"df":0,"h":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{},"df":0,"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"(":{"docs":{},"df":0,"p":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{},"df":0,"h":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.4142135623730951}},"df":1}}}}}}}}}}}},"s":{"docs":{},"df":0,":":{"docs":{},"df":0,"/":{"docs":{},"df":0,"/":{"docs":{},"df":0,"p":{"docs":{},"df":0,"k":{"docs":{},"df":0,"g":{"docs":{},"df":0,".":{"docs":{},"df":0,"g":{"docs":{},"df":0,"o":{"docs":{},"df":0,".":{"docs":{},"df":0,"d":{"docs":{},"df":0,"e":{"docs":{},"df":0,"v":{"docs":{},"df":0,"/":{"docs":{},"df":0,"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"x":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"df":0,"g":{"docs":{},"df":0,"e":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0}},"df":1}}}},"i":{"docs":{},"df":0,"'":{"docs":{},"df":0,"l":{"docs":{},"df":0,"l":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0}},"df":1}},"m":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.4142135623730951},"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0},"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.4142135623730951}},"df":3},"v":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}},"d":{"docs":{},"df":0,"e":{"docs":{},"df":0,"a":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.4142135623730951}},"df":1},"n":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"f":{"docs":{},"df":0,"i":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.7320508075688772}},"df":1}}}}}}},"f":{"docs":{},"df":0,"/":{"docs":{},"df":0,"i":{"docs":{},"df":0,"f":{"docs":{},"df":0,"1":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"2":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"3":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}}}}},"1":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"2":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"3":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}}},"l":{"docs":{},"df":0,"l":{"docs":{},"df":0,"u":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0}},"df":1}}}}}},"m":{"docs":{},"df":0,"m":{"docs":{},"df":0,"e":{"docs":{},"df":0,"d":{"docs":{},"df":0,"i":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}}},"u":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.4142135623730951}},"df":1}}},"p":{"docs":{},"df":0,"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"m":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.4142135623730951},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":2}}}}}},"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1,"a":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}}}}}}}}}},"n":{"docs":{},"df":0,"c":{"docs":{},"df":0,"l":{"docs":{},"df":0,"u":{"docs":{},"df":0,"d":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0},"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":2}}},"o":{"docs":{},"df":0,"m":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}},"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}}}}},"d":{"docs":{},"df":0,"i":{"docs":{},"df":0,"c":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":2},"v":{"docs":{},"df":0,"i":{"docs":{},"df":0,"d":{"docs":{},"df":0,"u":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}}}}}},"f":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}}}},"o":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.4142135623730951}},"df":1}},"i":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.4142135623730951},"http://127.0.0.1:1111/blog/rustlings/":{"tf":2.23606797749979}},"df":2}}},"s":{"docs":{},"df":0,"i":{"docs":{},"df":0,"d":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}},"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"d":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0},"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0},"http://127.0.0.1:1111/blog/gocontext/":{"tf":2.0},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":4}}},"r":{"docs":{},"df":0,"u":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0}},"df":1}}}}}},"t":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1,"e":{"docs":{},"df":0,"g":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1},"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0},"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":2}}},"n":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.4142135623730951}},"df":1}}},"r":{"docs":{},"df":0,"o":{"docs":{},"df":0,"2":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.4142135623730951}},"df":1}}}}}},"v":{"docs":{},"df":0,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"g":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0}},"df":1}}}}},"i":{"docs":{},"df":0,"s":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}}}},"s":{"docs":{},"df":0,"o":{"docs":{},"df":0,"l":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"p":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.4142135623730951}},"df":1}}}}}}}}},"s":{"docs":{},"df":0,"u":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":2}}},"t":{"docs":{},"df":0,"'":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.7320508075688772},"http://127.0.0.1:1111/blog/angularjs/":{"tf":2.23606797749979},"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.7320508075688772},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.7320508075688772}},"df":4,"l":{"docs":{},"df":0,"l":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":2}}},"s":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{},"df":0,"f":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}}}}}},"k":{"docs":{},"df":0,"e":{"docs":{},"df":0,"e":{"docs":{},"df":0,"p":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0},"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":2}},"y":{"docs":{},"df":0,"w":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"d":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}}}}},"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":2}}},"n":{"docs":{},"df":0,"o":{"docs":{},"df":0,"w":{"docs":{"http://127.0.0.1:1111/about/":{"tf":2.0},"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":3}}}},"l":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{},"df":0,"g":{"docs":{},"df":0,"u":{"docs":{},"df":0,"a":{"docs":{},"df":0,"g":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}}}},"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0},"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":2}}},"z":{"docs":{},"df":0,"i":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0}},"df":1}}},"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"k":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1},"r":{"docs":{},"df":0,"n":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.4142135623730951},"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":3}},"v":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":2}},"f":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}},"t":{"docs":{},"df":0,"'":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.7320508075688772},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":2}},"v":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}}}},"i":{"docs":{},"df":0,"b":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}}}}},"e":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1},"f":{"docs":{},"df":0,"e":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}},"s":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.7320508075688772}},"df":1,"e":{"docs":{},"df":0,"n":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":2.0}},"df":1}}}},"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}},"t":{"docs":{},"df":0,"l":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0},"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":2}}},"v":{"docs":{},"df":0,"e":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0}},"df":1}}},"o":{"docs":{},"df":0,"a":{"docs":{},"df":0,"d":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}},"c":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}}},"g":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.4142135623730951}},"df":1,"i":{"docs":{},"df":0,"c":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"n":{"docs":{},"df":0,"g":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.4142135623730951},"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0},"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.7320508075688772},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.4142135623730951}},"df":4}},"o":{"docs":{},"df":0,"k":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0},"http://127.0.0.1:1111/blog/gocontext/":{"tf":2.449489742783178}},"df":2},"p":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.4142135623730951}},"df":1}},"t":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.4142135623730951},"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":2}}},"m":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"r":{"docs":{},"df":0,"o":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"g":{"docs":{},"df":0,"i":{"docs":{},"df":0,"c":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.4142135623730951}},"df":1}}},"i":{"docs":{},"df":0,"n":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.4142135623730951},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.7320508075688772}},"df":2}},"k":{"docs":{},"df":0,"e":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":2.23606797749979},"http://127.0.0.1:1111/blog/rustlings/":{"tf":2.0}},"df":2,"_":{"docs":{},"df":0,"s":{"docs":{},"df":0,"a":{"docs":{},"df":0,"u":{"docs":{},"df":0,"s":{"docs":{},"df":0,"a":{"docs":{},"df":0,"g":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}}}}}}}},"n":{"docs":{},"df":0,"i":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.4142135623730951}},"df":1}},"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0}},"df":1}}}},"y":{"docs":{},"df":0,"b":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"c":{"docs":{},"df":0,"f":{"docs":{},"df":0,"u":{"docs":{},"df":0,"r":{"docs":{},"df":0,"s":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}}}}}},"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0},"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0},"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.4142135623730951}},"df":3},"s":{"docs":{},"df":0,"u":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}}}},"m":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0},"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":2}}}},"s":{"docs":{},"df":0,"s":{"docs":{},"df":0,"a":{"docs":{},"df":0,"g":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}}}},"t":{"docs":{},"df":0,"h":{"docs":{},"df":0,"o":{"docs":{},"df":0,"d":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}}}}},"i":{"docs":{},"df":0,"d":{"docs":{},"df":0,"d":{"docs":{},"df":0,"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"w":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":2.0}},"df":1,"e":{"docs":{},"df":0,"1":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1,"(":{"docs":{},"df":0,"m":{"docs":{},"df":0,"i":{"docs":{},"df":0,"d":{"docs":{},"df":0,"d":{"docs":{},"df":0,"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"w":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"2":{"docs":{},"df":0,"(":{"docs":{},"df":0,"h":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{},"df":0,"l":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}},"2":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}}}}}}}}},"m":{"docs":{},"df":0,"i":{"docs":{},"df":0,"c":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}}},"n":{"docs":{},"df":0,"d":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}},"s":{"docs":{},"df":0,"s":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"o":{"docs":{},"df":0,"d":{"docs":{},"df":0,"u":{"docs":{},"df":0,"l":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.4142135623730951}},"df":1,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"/":{"docs":{},"df":0,"m":{"docs":{},"df":0,"o":{"docs":{},"df":0,"d":{"docs":{},"df":0,"u":{"docs":{},"df":0,"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"1":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"2":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"3":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}}}}}}}}}},"1":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"2":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"3":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}}}}}}},"m":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.4142135623730951},"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":2}}}},"r":{"docs":{},"df":0,"e":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":2.0},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.4142135623730951}},"df":2}},"v":{"docs":{},"df":0,"e":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.4142135623730951}},"df":2,"_":{"docs":{},"df":0,"s":{"docs":{},"df":0,"e":{"docs":{},"df":0,"m":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"c":{"docs":{},"df":0,"s":{"docs":{},"df":0,"/":{"docs":{},"df":0,"m":{"docs":{},"df":0,"o":{"docs":{},"df":0,"v":{"docs":{},"df":0,"e":{"docs":{},"df":0,"_":{"docs":{},"df":0,"s":{"docs":{},"df":0,"e":{"docs":{},"df":0,"m":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"c":{"docs":{},"df":0,"s":{"docs":{},"df":0,"1":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"2":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"3":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"4":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"5":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"6":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}},"1":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"2":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"3":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"4":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"5":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"6":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}},"u":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"p":{"docs":{},"df":0,"l":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}}}}},"t":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1,"a":{"docs":{},"df":0,"b":{"docs":{},"df":0,"l":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}}}},"y":{"docs":{},"df":0,"s":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{},"df":0,"f":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0}},"df":1}}}}}},"n":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{},"df":0,"e":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.7320508075688772}},"df":2}}},"e":{"docs":{},"df":0,"e":{"docs":{},"df":0,"d":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.4142135623730951},"http://127.0.0.1:1111/blog/angularjs/":{"tf":3.0},"http://127.0.0.1:1111/blog/gocontext/":{"tf":2.0},"http://127.0.0.1:1111/blog/rustlings/":{"tf":3.7416573867739413}},"df":4}},"w":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.4142135623730951}},"df":1},"x":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}}},"g":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1,"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"p":{"docs":{},"df":0,"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}}}}}}},"i":{"docs":{},"df":0,"c":{"docs":{},"df":0,"e":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}},"l":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.4142135623730951}},"df":1}},"o":{"docs":{},"df":0,"t":{"docs":{},"df":0,"e":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0},"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":3},"h":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1},"i":{"docs":{},"df":0,"c":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}}},"w":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0},"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0},"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.4142135623730951}},"df":3}},"u":{"docs":{},"df":0,"m":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1,"b":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":2.23606797749979},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":2}}}}}},"o":{"docs":{},"df":0,"b":{"docs":{},"df":0,"j":{"docs":{},"df":0,"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}}}}},"f":{"docs":{},"df":0,"f":{"docs":{},"df":0,"i":{"docs":{},"df":0,"c":{"docs":{},"df":0,"i":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}}}}},"n":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0},"http://127.0.0.1:1111/blog/angularjs/":{"tf":2.449489742783178},"http://127.0.0.1:1111/blog/gocontext/":{"tf":2.23606797749979},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.4142135623730951}},"df":4,"c":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0},"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0},"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":4},"l":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}}},"t":{"docs":{},"df":0,"o":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}}},"p":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}},"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.4142135623730951}},"df":1,"s":{"docs":{},"df":0,"/":{"docs":{},"df":0,"o":{"docs":{},"df":0,"p":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,"s":{"docs":{},"df":0,"1":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"2":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"3":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}}}}}}}}}},"1":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"2":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"3":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}}}}}}}},"r":{"docs":{},"df":0,"d":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0},"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.7320508075688772}},"df":3}}},"i":{"docs":{},"df":0,"g":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.4142135623730951}},"df":2}}}}},"u":{"docs":{},"df":0,"t":{"docs":{},"df":0,"g":{"docs":{},"df":0,"o":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}},"i":{"docs":{},"df":0,"s":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}},"s":{"docs":{},"df":0,"i":{"docs":{},"df":0,"d":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.4142135623730951},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":2}}}}},"v":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1,"v":{"docs":{},"df":0,"i":{"docs":{},"df":0,"e":{"docs":{},"df":0,"w":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.4142135623730951}},"df":1}}}}}}},"w":{"docs":{},"df":0,"n":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"s":{"docs":{},"df":0,"h":{"docs":{},"df":0,"i":{"docs":{},"df":0,"p":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.4142135623730951}},"df":1}}}}}}}}},"p":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"k":{"docs":{},"df":0,"a":{"docs":{},"df":0,"g":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.4142135623730951}},"df":1}}}},"g":{"docs":{},"df":0,"e":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}},"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{},"df":0,"e":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}}}},"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0},"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":2}}},"t":{"docs":{},"df":0,"i":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}}},"s":{"docs":{},"df":0,"s":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":2.8284271247461903},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.4142135623730951}},"df":2}}},"e":{"docs":{},"df":0,"o":{"docs":{},"df":0,"p":{"docs":{},"df":0,"l":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0}},"df":1}}},"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1,"f":{"docs":{},"df":0,"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0},"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":2}}},"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"m":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}}}}},"t":{"docs":{},"df":0,"r":{"docs":{},"df":0,"u":{"docs":{},"df":0,"n":{"docs":{},"df":0,"g":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"o":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}}}}}}}}},"i":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{},"df":0,"u":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0}},"df":1}}}},"x":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}}}},"l":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"e":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0}},"df":1}}}},"o":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}}},"s":{"docs":{},"df":0,"s":{"docs":{},"df":0,"i":{"docs":{},"df":0,"b":{"docs":{},"df":0,"l":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":2}}}},"t":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0},"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":2}}},"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"c":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0},"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":2}}}}},"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.4142135623730951}},"df":1}}}},"t":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}}}},"i":{"docs":{},"df":0,"c":{"docs":{},"df":0,"e":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.7320508075688772}},"df":1}},"m":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"v":{"docs":{},"df":0,"e":{"docs":{},"df":0,"_":{"docs":{},"df":0,"t":{"docs":{},"df":0,"y":{"docs":{},"df":0,"p":{"docs":{},"df":0,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"/":{"docs":{},"df":0,"p":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"m":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"v":{"docs":{},"df":0,"e":{"docs":{},"df":0,"_":{"docs":{},"df":0,"t":{"docs":{},"df":0,"y":{"docs":{},"df":0,"p":{"docs":{},"df":0,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"_":{"docs":{},"df":0,"1":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"2":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"3":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"4":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"5":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"6":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}}},"1":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"2":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"3":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"4":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"5":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"6":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}},"n":{"docs":{},"df":0,"c":{"docs":{},"df":0,"i":{"docs":{},"df":0,"p":{"docs":{},"df":0,"l":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}}}},"t":{"docs":{},"df":0,"l":{"docs":{},"df":0,"n":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}}},"v":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}}},"o":{"docs":{},"df":0,"b":{"docs":{},"df":0,"a":{"docs":{},"df":0,"b":{"docs":{},"df":0,"l":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0},"http://127.0.0.1:1111/blog/angularjs/":{"tf":2.23606797749979},"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.7320508075688772},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":4}}},"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"m":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}}}},"c":{"docs":{},"df":0,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"s":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0},"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":2}}}},"g":{"docs":{},"df":0,"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}}},"j":{"docs":{},"df":0,"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}}},"p":{"docs":{},"df":0,"a":{"docs":{},"df":0,"g":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.4142135623730951}},"df":1}}},"u":{"docs":{},"df":0,"d":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}},"v":{"docs":{},"df":0,"i":{"docs":{},"df":0,"d":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}}}}},"u":{"docs":{},"df":0,"b":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{},"df":0,"c":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.4142135623730951}},"df":1}}}},"s":{"docs":{},"df":0,"h":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.4142135623730951}},"df":1}},"t":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.4142135623730951},"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.7320508075688772},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":3}}},"q":{"docs":{},"df":0,"u":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.4142135623730951}},"df":1}}},"i":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1},"z":{"docs":{},"df":0,"1":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.4142135623730951}},"df":1}}},"2":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.4142135623730951}},"df":1}}}}}}},"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{},"df":0,"o":{"docs":{},"df":0,"m":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"g":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}}},"e":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0},"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":3,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"h":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}},"d":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0},"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":2,"a":{"docs":{},"df":0,"b":{"docs":{},"df":0,"l":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}}},"i":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}},"l":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.4142135623730951},"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.4142135623730951}},"df":2,"l":{"docs":{},"df":0,"i":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0},"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":2}}},"s":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0},"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0},"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":3}}}},"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"m":{"docs":{},"df":0,"m":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}}}}}}},"f":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.4142135623730951}},"df":1}}},"l":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":2.0}},"df":1}}},"m":{"docs":{},"df":0,"e":{"docs":{},"df":0,"m":{"docs":{},"df":0,"b":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.4142135623730951},"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":2}}},"o":{"docs":{},"df":0,"v":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":2.0},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.4142135623730951}},"df":2}}},"p":{"docs":{},"df":0,"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}}},"l":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":2}}}},"q":{"docs":{},"df":0,"u":{"docs":{},"df":0,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":3.1622776601683795}},"df":1,"'":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.4142135623730951}},"df":1}}}},"i":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}}},"s":{"docs":{},"df":0,"p":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,"s":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":2.0}},"df":1}}}},"u":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}}}},"t":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"e":{"docs":{},"df":0,"v":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.4142135623730951}},"df":1}}}},"u":{"docs":{},"df":0,"r":{"docs":{},"df":0,"n":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":2.8284271247461903},"http://127.0.0.1:1111/blog/rustlings/":{"tf":2.449489742783178}},"df":2}}}},"v":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"s":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":2}}}}},"i":{"docs":{},"df":0,"d":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0}},"df":1},"g":{"docs":{},"df":0,"h":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0},"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.4142135623730951}},"df":2}}}},"o":{"docs":{},"df":0,"l":{"docs":{},"df":0,"e":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}},"u":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":2.23606797749979}},"df":1}}},"u":{"docs":{},"df":0,"n":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.4142135623730951}},"df":1},"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"l":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.4142135623730951}},"df":1}}}}},"s":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"_":{"docs":{},"df":0,"p":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"c":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}}}}}},"m":{"docs":{},"df":0,"e":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0},"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.4142135623730951},"http://127.0.0.1:1111/blog/rustlings/":{"tf":2.23606797749979}},"df":3}}},"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"p":{"docs":{},"df":0,"e":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.4142135623730951},"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":2}},"r":{"docs":{},"df":0,"e":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"r":{"docs":{},"df":0,"o":{"docs":{},"df":0,"l":{"docs":{},"df":0,"l":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":2.449489742783178}},"df":1}}}}},"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.7320508075688772},"http://127.0.0.1:1111/blog/gocontext/":{"tf":2.8284271247461903}},"df":2}}}},"e":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0},"http://127.0.0.1:1111/blog/gocontext/":{"tf":3.3166247903554}},"df":2},"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}}}},"n":{"docs":{},"df":0,"s":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}},"p":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"r":{"docs":{},"df":0,"i":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1},"v":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":2.8284271247461903}},"df":1}}}},"t":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0},"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":2}},"h":{"docs":{},"df":0,"a":{"docs":{},"df":0,"d":{"docs":{},"df":0,"o":{"docs":{},"df":0,"w":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}}},"e":{"docs":{},"df":0,"e":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0}},"df":1}}},"i":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}},"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"t":{"docs":{},"df":0,"c":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0}},"df":1}}}}},"u":{"docs":{},"df":0,"l":{"docs":{},"df":0,"d":{"docs":{},"df":0,"n":{"docs":{},"df":0,"'":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}}}}}},"w":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.4142135623730951}},"df":1}}},"i":{"docs":{},"df":0,"d":{"docs":{},"df":0,"e":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}},"m":{"docs":{},"df":0,"p":{"docs":{},"df":0,"l":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0},"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0},"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.4142135623730951}},"df":3,"i":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1,"c":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}}}},"u":{"docs":{},"df":0,"l":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"g":{"docs":{},"df":0,"o":{"docs":{},"df":0,"p":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.7320508075688772}},"df":1}}}}}}}}}}}}},"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"e":{"docs":{},"df":0,"p":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":2.0}},"df":1}}},"o":{"docs":{},"df":0,"w":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.4142135623730951}},"df":1,"d":{"docs":{},"df":0,"o":{"docs":{},"df":0,"w":{"docs":{},"df":0,"n":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}}}}}}},"m":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{},"df":0,"l":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}}},"o":{"docs":{},"df":0,"f":{"docs":{},"df":0,"t":{"docs":{},"df":0,"w":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/":{"tf":1.0},"http://127.0.0.1:1111/about/":{"tf":1.0}},"df":2}}}}},"l":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.7320508075688772},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.7320508075688772}},"df":2}}},"m":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,"g":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}}}}}}},"o":{"docs":{},"df":0,"n":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}},"t":{"docs":{},"df":0,"h":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0},"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.4142135623730951},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":3},"i":{"docs":{},"df":0,"m":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}}},"w":{"docs":{},"df":0,"h":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}},"e":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}}}}}}},"p":{"docs":{},"df":0,"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"i":{"docs":{},"df":0,"f":{"docs":{},"df":0,"i":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":2}}}},"e":{"docs":{},"df":0,"d":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}}},"o":{"docs":{},"df":0,"i":{"docs":{},"df":0,"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}}}}}},"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":2.0}},"df":1}},"t":{"docs":{},"df":0,"e":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1,"m":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.4142135623730951}},"df":2}}}}},"u":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1,"s":{"docs":{},"df":0,"/":{"docs":{},"df":0,"v":{"docs":{},"df":0,"i":{"docs":{},"df":0,"s":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}}}}}}}},"e":{"docs":{},"df":0,"p":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}},"i":{"docs":{},"df":0,"l":{"docs":{},"df":0,"l":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0},"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":2}}},"o":{"docs":{},"df":0,"p":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0}},"df":1},"r":{"docs":{},"df":0,"e":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":2.0},"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.4142135623730951}},"df":2}}},"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"i":{"docs":{},"df":0,"g":{"docs":{},"df":0,"h":{"docs":{},"df":0,"t":{"docs":{},"df":0,"f":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"w":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"d":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}}}}}}}}}}}},"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"g":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1,"_":{"docs":{},"df":0,"u":{"docs":{},"df":0,"p":{"docs":{},"df":0,"p":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"c":{"docs":{},"df":0,"a":{"docs":{},"df":0,"s":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}}}}}}}},"s":{"docs":{},"df":0,"/":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"g":{"docs":{},"df":0,"s":{"docs":{},"df":0,"1":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"2":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"3":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"4":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}}}}}}}}}},"1":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"2":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"3":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"4":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}}}}}},"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,"g":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0}},"df":1}}},"u":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.7320508075688772}},"df":1,"s":{"docs":{},"df":0,"/":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"r":{"docs":{},"df":0,"u":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{},"df":0,"s":{"docs":{},"df":0,"1":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"2":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"3":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}}}}}}}}}},"1":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"2":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"3":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}}}}}}},"u":{"docs":{},"df":0,"f":{"docs":{},"df":0,"f":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}},"t":{"docs":{},"df":0,"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}}}}}},"u":{"docs":{},"df":0,"c":{"docs":{},"df":0,"c":{"docs":{},"df":0,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"s":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.4142135623730951}},"df":1}}}},"h":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.4142135623730951}},"df":1}},"g":{"docs":{},"df":0,"g":{"docs":{},"df":0,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}}}},"j":{"docs":{},"df":0,"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}}}},"r":{"docs":{},"df":0,"e":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0},"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.4142135623730951},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.7320508075688772}},"df":3},"p":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"s":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}}}}}},"y":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"x":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.4142135623730951},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":2}}}}}},"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"k":{"docs":{},"df":0,"e":{"docs":{"http://127.0.0.1:1111/about/":{"tf":2.0},"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.4142135623730951}},"df":3}},"l":{"docs":{},"df":0,"k":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}},"s":{"docs":{},"df":0,"k":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0}},"df":1}}},"b":{"docs":{},"df":0,"c":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1},"h":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}},"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1,"_":{"docs":{},"df":0,"1":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1},"2":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}}},"c":{"docs":{},"df":0,"h":{"docs":{},"df":0,"n":{"docs":{},"df":0,"i":{"docs":{},"df":0,"c":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}}}}},"r":{"docs":{},"df":0,"m":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}}},"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"b":{"docs":{},"df":0,"l":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}}}}},"s":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":2}},"x":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}}},"h":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{},"df":0,"'":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":2}}},"e":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0}},"df":1}}},"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"f":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.4142135623730951}},"df":1}}}}}},"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"g":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.7320508075688772},"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.7320508075688772},"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.4142135623730951}},"df":3},"k":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.7320508075688772},"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.4142135623730951},"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.4142135623730951}},"df":3}},"r":{"docs":{},"df":0,"d":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}}},"o":{"docs":{},"df":0,"s":{"docs":{},"df":0,"e":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":2}},"u":{"docs":{},"df":0,"g":{"docs":{},"df":0,"h":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0},"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":3,"t":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.4142135623730951}},"df":1}}}}},"r":{"docs":{},"df":0,"o":{"docs":{},"df":0,"u":{"docs":{},"df":0,"g":{"docs":{},"df":0,"h":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.4142135623730951}},"df":1}}}}}},"i":{"docs":{},"df":0,"m":{"docs":{},"df":0,"e":{"docs":{"http://127.0.0.1:1111/about/":{"tf":2.6457513110645907},"http://127.0.0.1:1111/blog/angularjs/":{"tf":2.0},"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.7320508075688772},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.4142135623730951}},"df":4,"o":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":3.605551275463989}},"df":1}}}}},"p":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}},"o":{"docs":{},"df":0,"o":{"docs":{},"df":0,"k":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0},"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":2}},"p":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1,"i":{"docs":{},"df":0,"c":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0}},"df":1}}},"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"u":{"docs":{},"df":0,"c":{"docs":{},"df":0,"h":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0}},"df":1}}}},"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{},"df":0,"s":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}},"p":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}}}}}},"e":{"docs":{},"df":0,"e":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}},"i":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.4142135623730951},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":2,"g":{"docs":{},"df":0,"g":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}}}}},"u":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0}},"df":1}}}},"w":{"docs":{},"df":0,"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"k":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.7320508075688772}},"df":1}}},"o":{"docs":{"http://127.0.0.1:1111/about/":{"tf":2.0},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":2}},"y":{"docs":{},"df":0,"p":{"docs":{},"df":0,"e":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":2.8284271247461903}},"df":1}}}},"u":{"docs":{},"df":0,"8":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1},"n":{"docs":{},"df":0,"d":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{"http://127.0.0.1:1111/about/":{"tf":2.449489742783178},"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.7320508075688772}},"df":2}}}}}}}},"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"s":{"docs":{},"df":0,"i":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0}},"df":1}}}},"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/":{"tf":1.0}},"df":1,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.4142135623730951},"http://127.0.0.1:1111/contact/":{"tf":1.0}},"df":2}}}}}},"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"l":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0}},"df":1}}},"u":{"docs":{},"df":0,"s":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"p":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.7320508075688772},"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.7320508075688772}},"df":2,"d":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0},"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":3}}}},"s":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0},"http://127.0.0.1:1111/blog/angularjs/":{"tf":2.8284271247461903},"http://127.0.0.1:1111/blog/gocontext/":{"tf":3.7416573867739413},"http://127.0.0.1:1111/blog/rustlings/":{"tf":2.8284271247461903}},"df":4,"a":{"docs":{},"df":0,"g":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}},"e":{"docs":{},"df":0,"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"s":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}}}},"r":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.7320508075688772},"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":2}},"u":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.4142135623730951}},"df":1}}}}},"v":{"docs":{},"df":0,"1":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1},"a":{"docs":{},"df":0,"l":{"docs":{},"df":0,"u":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0},"http://127.0.0.1:1111/blog/gocontext/":{"tf":4.358898943540674},"http://127.0.0.1:1111/blog/rustlings/":{"tf":2.23606797749979}},"df":3}},"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"a":{"docs":{},"df":0,"b":{"docs":{},"df":0,"l":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":2.0}},"df":1,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"/":{"docs":{},"df":0,"v":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"a":{"docs":{},"df":0,"b":{"docs":{},"df":0,"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"1":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"2":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"3":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"4":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"5":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"6":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}}}}}}}}}}}},"1":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"2":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"3":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"4":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"5":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"6":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}}}}}}}}}},"e":{"docs":{},"df":0,"c":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1,"0":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.4142135623730951}},"df":1},"s":{"docs":{},"df":0,"/":{"docs":{},"df":0,"v":{"docs":{},"df":0,"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"s":{"docs":{},"df":0,"1":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"2":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}}}}}}},"1":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"2":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}}},"t":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.4142135623730951}},"df":1}}}},"g":{"docs":{},"df":0,"g":{"docs":{},"df":0,"i":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}},"r":{"docs":{},"df":0,"i":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":2.23606797749979},"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":2}}},"i":{"docs":{},"df":0,"e":{"docs":{},"df":0,"w":{"docs":{},"df":0,"p":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":2.23606797749979}},"df":1}}}}}},"s":{"docs":{},"df":0,"i":{"docs":{},"df":0,"b":{"docs":{},"df":0,"l":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}}},"u":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{},"df":0,"s":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}}}}}}}},"w":{"docs":{},"df":0,"a":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}},"n":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":2.0},"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0},"http://127.0.0.1:1111/blog/rustlings/":{"tf":2.0}},"df":3}},"r":{"docs":{},"df":0,"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"y":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}}}},"t":{"docs":{},"df":0,"c":{"docs":{},"df":0,"h":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":3.605551275463989}},"df":1}}}},"e":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.4142135623730951}},"df":1}}},"y":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0},"http://127.0.0.1:1111/blog/gocontext/":{"tf":2.0},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":3}},"e":{"docs":{},"df":0,"'":{"docs":{},"df":0,"l":{"docs":{},"df":0,"l":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0},"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.4142135623730951}},"df":2}},"r":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1},"v":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}},"l":{"docs":{},"df":0,"l":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0},"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":2}}},"h":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"v":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0},"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":3}}}},"o":{"docs":{},"df":0,"e":{"docs":{},"df":0,"v":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}}}}}},"i":{"docs":{},"df":0,"t":{"docs":{},"df":0,"h":{"docs":{},"df":0,"o":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.4142135623730951},"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0},"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.4142135623730951}},"df":3}}}}}},"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,"'":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0},"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":2}},"d":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}}}},"r":{"docs":{},"df":0,"k":{"docs":{"http://127.0.0.1:1111/about/":{"tf":2.0},"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.4142135623730951},"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":3},"t":{"docs":{},"df":0,"h":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}}},"w":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}},"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"p":{"docs":{},"df":0,"p":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}}}}},"i":{"docs":{},"df":0,"t":{"docs":{},"df":0,"e":{"docs":{"http://127.0.0.1:1111/about/":{"tf":2.0},"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.4142135623730951}},"df":2}}}}},"x":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0},"http://127.0.0.1:1111/blog/rustlings/":{"tf":2.0}},"df":2},"y":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.4142135623730951}},"df":1,"e":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1,"a":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.4142135623730951}},"df":1}}},"o":{"docs":{},"df":0,"u":{"docs":{},"df":0,"'":{"docs":{},"df":0,"l":{"docs":{},"df":0,"l":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}},"r":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}},"n":{"docs":{},"df":0,"g":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0}},"df":1,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.4142135623730951}},"df":1}}}}}}}},"z":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.4142135623730951}},"df":1}}},"title":{"root":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{},"df":0,"g":{"docs":{},"df":0,"u":{"docs":{},"df":0,"l":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"j":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}}}}}}}},"b":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"n":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"d":{"docs":{"http://127.0.0.1:1111/":{"tf":1.0}},"df":1}}}}}},"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"g":{"docs":{"http://127.0.0.1:1111/blog/":{"tf":1.0}},"df":1}}},"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"c":{"docs":{},"df":0,"e":{"docs":{"http://127.0.0.1:1111/":{"tf":1.0}},"df":1}}}}},"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/contact/":{"tf":1.0}},"df":1}}},"e":{"docs":{},"df":0,"x":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}}}}}}},"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"g":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{"http://127.0.0.1:1111/":{"tf":1.0}},"df":1}}}}},"f":{"docs":{},"df":0,"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"u":{"docs":{},"df":0,"d":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0},"http://127.0.0.1:1111/blog/":{"tf":1.0},"http://127.0.0.1:1111/contact/":{"tf":1.0}},"df":3}}}}},"g":{"docs":{},"df":0,"o":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}},"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"m":{"docs":{},"df":0,"o":{"docs":{},"df":0,"v":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}}}},"u":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"l":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}}}},"s":{"docs":{},"df":0,"o":{"docs":{},"df":0,"f":{"docs":{},"df":0,"t":{"docs":{},"df":0,"w":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/":{"tf":1.0}},"df":1}}}}},"l":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/rustlings/":{"tf":1.0}},"df":1}}}},"p":{"docs":{},"df":0,"e":{"docs":{},"df":0,"e":{"docs":{},"df":0,"d":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}}}}},"u":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{"http://127.0.0.1:1111/blog/gocontext/":{"tf":1.0}},"df":1}}}}}}}},"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"http://127.0.0.1:1111/blog/":{"tf":1.0}},"df":1,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{"http://127.0.0.1:1111/about/":{"tf":1.0},"http://127.0.0.1:1111/contact/":{"tf":1.0}},"df":2}}}}}}},"p":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}},"v":{"docs":{},"df":0,"1":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}},"w":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{},"df":0,"c":{"docs":{},"df":0,"h":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"http://127.0.0.1:1111/blog/angularjs/":{"tf":1.0}},"df":1}}}}}}}}}},"documentStore":{"save":true,"docs":{"http://127.0.0.1:1111/":{"body":"","id":"http://127.0.0.1:1111/","title":"Brice Bernard - Software Engineer"},"http://127.0.0.1:1111/about/":{"body":"Why unintended fraud?\nIt's a fun name.\nIt encapsulates a concept I believe we are all guilty of from time to time, where we would take\na shortcut in order to accomplish (or get rid of) a task faster, instead of truly understand the concept behind it. The reasons\nbehind it could be many: not having time, being lazy, thinking it'll take forever, etc. Many times it leaves you\nwith an uneasy feeling of \"I know this works but I don't know why\", possibly coupled with a touch of \"I don't like the fact\nthat I don't take time to understand the thing, but I won't right now anyway\".\nIt is my experience that a lot of the times, it takes two seconds to actually learn it. Two seconds of works after 10 years of \"should I do it or not\".\nI have the perfect example to illustrate it: dilution.\nJust in case, dilution is \"the process of decreasing the concentration of a solute in a solution\". Like when people put water in their coffee\nwhen it's too strong.\nPicture young me in highschool, in chemistry class. We learned about dilution, from theory to practice. I mastered calculating how diluted X is based.\nI blindly followed the experiences' instructions. My grades were looking great however if you asked me the definition of dilution I don't think\nI would have been able to answer you. Until one day, at least a year and a half later, as I was putting water in some solution I had\nan eureka moment. Such a long time to understand such a simple concept, yet it took forever.\nYou could argue that I don't need to understand it as long as I can use it, but I'll argue the contrary. The fact is once you\nunderstand it you don't need to remember anything, you know how it works you can re-create it effortlessly, it doesn't live in\nthe same place in you, it's not a memory thing anymore.\nI think those moment happen a lot in software engineering.\nHopefully this blog will help me stop for a second or two when I'm guilty of the above to investigate a topic. I'm hoping forcing myself to write\nabout it will have two huge benefits:\n\nif I cannot write the post, it probably means I don't understand the thing well enough\nwriting will help me remember (we all know that's how it works from writing cheat sheets)\n\n","id":"http://127.0.0.1:1111/about/","title":"About - Unintended Fraud"},"http://127.0.0.1:1111/blog/":{"body":"","id":"http://127.0.0.1:1111/blog/","title":"Unintented Fraud - Blog"},"http://127.0.0.1:1111/blog/angularjs/":{"body":"Note from 2024: I copying over this post from ages ago because I'm actually quite proud of it even though it was probably a terrible practice if it would have\nbeen used. This was my first \"wow\" moment. Probably the first time I fixed a real problem I thought was too big or complicated for me, and it\nworked so well I thought I broke the entire thing. Changing a list so slow it's literally stuttering to a list so fluid you would think\nit's just text without interaction felt really good.\n\n--\nAngularJS is great, easy to use, somewhat easy to learn if you don't believe everything you read online and think a little bit, and most importantly allow you to do some bindings in a very simple way. Everything is updating in real time, you don't have to do anything, it's perfect.\nHowever it doesn't come without drawbacks, the biggest one being performance.\nWith Angular 1.3 came the \"bind once\" syntax using the :: syntax. This is great but sometimes you want to keep all of your bindings set because the values might change, and that can become an issue in long lists (for example an infinite scrolling ng-repeat).\nHow to remove / re-add watchers\nFirst, we need it to be transparent for the user. They need to be able to do whatever they want and don't feel any slowdown.\nThe first idea I had was to actually remove the elements outside the viewport, and put them back when needed using $compile, but it was VERY SLOW to the point that the page was very annoying to use.\nSo I decided to use the debug info created by default by Angular. It provides a shit load of stuff, including arrays of watchers associated with every elements. The idea was to store the arrays of watchers locally, empty the ones attached to the element, and fill them back when needed.\nIt's actually very easy.\nAn element has 2 kind of watchers associated to it, the ones from its scope and the ones from its isolateScope, so we need to store both of them.\n\nWe need an array to store the watchers, we'll call it wArray.\nThe first element would be another array of 2 elements, the watchers from the the scope, the watchers from the isolateScope\nThen we will loop through every child element and do the same\n\nIn the end we will have an array like this.\n\nThat will allow us to put them back very easily.\nHere is an example code:\n\nSo we stored the watchers and remove them from the element. What do to when we need to enable them back?\nAs you probably anticipate, we just have to do the exact same thing in reverse, we have our array with every watchers associated with every child of the element, so we loop through it and put fill the arrays:\n\nWhen to call all of this?\nWe can disable and enable the watchers of an element, now we need to be able to do this everytime an element end up in or outside the viewport.\nFor that we just listen to the scroll event, and test for each element is it's inside or outise the viewport, and act accordingly.\nA few tips first:\n\nConsider adding a debounce function to your listener, so you actually do all the watchers thing when the user is done scrolling instead of every time the scrolling event triggers, which is A LOT\nAdd a boolean to indicate if the element is hidden or not, so if its status does not change, as it won't for most of the elements, you don't do anything\n\nWith that in mind, we would have something like this as our listener:\n\nThis code is pretty straightforward, every time the user scrolls, we broadcast an event to let the elements know they need to check if their \"status/visibility\" changed, and disable / enable their watchers.\nSo yes there are actually 2 directives here.\nThe first one on the parent element, the ngRepeat, to handle the scroll listener. The 2nd one of every child element you want to be disabled if invisible.\nI also added a \"range of error\" of 1000 pixels, which means we consider the viewport to be the viewport itself + 1000 up and down so if an element is half visible it still works.\nFull code\nYou can find the full directives code below or on github.\nAlso this code could probably be better, and if you want to use it you should probably be sure that using it is worth having the debug info in your app. Since 1.3 you can disable it and I see no reason why you shouldn't.\n\n","id":"http://127.0.0.1:1111/blog/angularjs/","title":"Speed-up angularjs (v1) - remove watchers"},"http://127.0.0.1:1111/blog/gocontext/":{"body":"Go contexts are a good candidate for something you can use without understanding it. When you see that a context is expected\nin a function's definition, you can pass the request's context, or context.Background() and call it a day. If you're feeling\na little crazy you pass a context with a timeout, and it magically work as expected. Here we will try to see the main usages\nof context (timeout and passing values), but also try to implement a function using a context and see how the implementation\nlook like.\n\nFrom the official documentation (https://pkg.go.dev/context), we can highlight:\n\"Incoming requests to a server should create a Context, and outgoing calls to servers should accept a Context.\nThe chain of function calls between them must propagate the Context, optionally replacing it with a derived\nContext [...] When a Context is canceled, all Contexts derived from it are also canceled.\"\nFrom this we already understand multiple things:\n\nrequests usually make heavy use of context, probably where they will be encountered the most\na context can have children\nif a parent is cancelled, the children are too\n\nIf you want to have more details and visualise it, I would recommend this talk:\nThe context package internals - Damiano Petrungaro.\nLet's see in our own examples how to use context, for timeouts and adding data to a request.\n\nOverview of our simple server\nUse context to pass request-related data to the endpoint\nUse context for timeout\nSome tweaked examples\n\n1. Overview of our simple server\nOur examples will be requests related so we need a server. Go has a very useful http package to do that, I took the liberty\nto create a wrapper around it to handle middlewares easier.\n\nThis allows us to add middlewares in a more readable way than the default.\nhttp.Handle(path, middleware1, middleware2, handler) instead of the default\nhttp.Handle(path, middleware1(middleware2(handler))).\n2. Use context to pass request-related data to the endpoint\nIt is important to note that the doc specify:\n\"Use context Values only for request-scoped data that transits processes and APIs, not for passing optional\nparameters to functions.\"\nMy example will technically not do that, but it should highlight the principle. In real life,\nI've used it to add user-related data to the request, a third-party API client ready to go, things like that.\nI'm sure there are other ways to take advantage of it.\n\nHere we create our server, have a route /get-value, a middleware that will add values to the request's context, and the\nroute handler that will read from the context and return the values.\nLet's look at the middleware first:\n\nHere we store 3 values in the context. I added a number, a string and a custom struct to show that we can store anything\nwe need.\nIf you look closely, you'll notice that we create a new context every time. Context can only contain one value, and all\nof their constructor methods expect a context and return a child from that context.\nHere ctx3 is the \"youngest\" child, which we pass onto the next step. Below is our route handler:\n\nWe retrieve the values and write them to the client.\nFor good measures I added a value that does not exist to see what happens (spoiler: it's nil).\nFor simplicity, I will just curl our endpoint from the terminal:\n\nWe get all of our values as expected.\nYou may wonder how did we retrieve all of the values, when we passed the youngest context ctx3 that only contains the\ncomplex struct. This is because instead of seeing contexts as individual object, we should see them as one branch of a tree,\nstarting at the original one (usually context.Background()), all the way down to the context we are interacting with\nin our code. Here our full context is really:\n\nWhen we query a value, Go will look in the immediate context, and move up one level all the way to the top if\nthe value is not found. For example, this is what happen when looking up the value \"number\":\n\ncheck the value \"numbers\" in ctx3, it is not there (it is \"complex_struct\")\ncheck the value \"numbers\" in ctx2, it is not there (it is \"message\")\ncheck the value \"numbers\" in ctx1, found\n\nIf we attached ctx2 to our request instead of ctx3, then the curl would show nil for the complex struct, because ctx3 would not\nbe checked.\n3. Use context for timeout\nProbably the main reason to use context: timeout and deadlines. Making sure we're not hanging somewhere for too long.\nIn this example, we'll forget about our context values, and update our route handler to mimic some long operation using\ncontext. The handler looks like this now:\n\nFirst we need to create a new context that include a timeout. What it means internally is that the context will be cancelled\nonce the timeout duration has been reached. It is up to whoever wants to make use of the context to check and return an error\nif that happen.\nIn our example, this will be the role of someLongAction, it should return an error if the context expires. The function\nis defined as:\n\nWe wait for whatever happen first: simulatingOperation() to finish, or the ctx to be done / expired.\n\nThe select statement cases expect a channel, so our function need to return one. We'll return a channel containing 1\nerror, as a real function would probably be suject to fail.\nWe start a goroutine, sleep for 5 seconds and write the error to the channel at the end. That means that if the timeout\nof the context is more than 5 seconds, we will get the result of simulatingOperation(), if not we will propagate the\ncontext error.\nLet's see it in action. Remember above that we set our context timeout to 2 seconds.\n\nAbove are all of server logs, that highlight the execution code in order, with the time on the left to see the effect of\nthe sleep and the timeouts.\n\nStarted request at 29:57\nThe goroutine started sleeping\nSome long action ended 2 seconds later\nThe error is context deadline exceeded as expected\nRoute handler ends right there\nThe goroutine ends after the sleep as expected. I'm not gonna lie, this surprised me at first, I though it would be\n\"cancelled\" magically, but it does not make sense when you think about it, as it runs concurrently, on its own. Initially\nI was afraid of leaking memory or something like that, it didn't feel good that some useless code is still being executed,\nbut it's just what it is I think. It's the responsibility of the goroutine to not hang forever.\n\nOn our client's side:\n\nWe can see that we got the correct response, at the right time.\n4. Some tweaked examples\nBelow are more examples when I tweaked some values, see what happens.\n4.1 Increate the timeout to 8 seconds\nWe should get a successful response after 5 seconds.\n\nHere are our server logs:\n\nAnd our client:\n\nAs expected, we get a successful response 5 seconds after initiating the query, no timeout happened.\n4.2 simulatingOperation returns an error\nKeeping it as it is now, make the goroutine returns an error instead.\n\nRunning it we get:\n\n\nAs expected, we get the error after 5 seconds.\n","id":"http://127.0.0.1:1111/blog/gocontext/","title":"Understanding Go context"},"http://127.0.0.1:1111/blog/rustlings/":{"body":"Rustlings is a nice project presenting you with a serie of small\nexercises to learn most of the concept of the languages. From declaring variables to more advances concepts. We are\npresented with a failing program and should fix it in order to compile.\n\nBelow are my solutions, maybe it'll help someone, possibly future me who knows.\nintro2.rs\nvariables1.rs\nvariables2.rs\nvariables3.rs\nvariables4.rs\nvariables5.rs\nvariables6.rs\nfunctions1.rs\nfunctions2.rs\nfunctions3.rs\nfunctions4.rs\nfunctions5.rs\nif1.rs\nif2.rs\nif3.rs\nquiz1.rs\nprimitive_types1.rs\nprimitive_types2.rs\nprimitive_types3.rs\nprimitive_types4.rs\nprimitive_types5.rs\nprimitive_types6.rs\nvecs1.rs\nvecs2.rs\nmove_semantics1.rs\nmove_semantics2.rs\nmove_semantics3.rs\nmove_semantics4.rs\nmove_semantics5.rs\nmove_semantics6.rs\nstructs1.rs\nstructs2.rs\nstructs3.rs\nenums1.rs\nenums2.rs\nenums3.rs\nstrings1.rs\nstrings2.rs\nstrings3.rs\nstrings4.rs\nmodules1.rs\nmodules2.rs\nmodules3.rs\nhashmaps1.rs\nhashmaps2.rs\nhashmaps3.rs\nquiz2.rs\noptions1.rs\noptions2.rs\noptions3.rs\nerrors1.rs\nerrors2.rs\nerrors3.rs\nerrors4.rs\nerrors5.rs\nerrors6.rs\ngenerics1\ngenerics2\nTBC.\nintro2.rs\nNeeded to add an argument to the println macro. Or remove the expected argument I guess.\n\nvariables/variables1.rs\nWe need to define x using let.\n\nvariables/variables2.rs\nx was not initialized. You can change leave the default type like I did or specify whatever you want (as long as it's\ncomparable to 10).\n\nvariables/variables3.rs\nx needs to be assigned a value before being used.\n\nvariables/variables4.rs\nVariables are immutable by default, here we want to change the value so we need to initialize the variable as mutable.\n\nvariables/variables5.rs\nHere we \"shadow\" x by re-declaring another variable with the same name.\n\nvariables/variables6.rs\nA const need to be typed.\n\nfunctions/functions1.rs\nWe need to define the function call_me with no arguments and nothing returned.\n\nfunctions/functions2.rs\nWe need to type the function's argument num. Could be any number types.\n\nfunctions/functions3.rs\nThis one is the kind of the reverse, we cannot call a function without passing the expected arguments.\n\nfunctions/functions4.rs\nHere we are missing the return type of sale_price. Have to be the same as the argument given because we are returning\neither price - 10 or price - 3 which would be the same type as price.\n\nfunctions/functions5.rs\nHere they probably want us to remove the ; and therefore returning the statement. I don't like this syntax so let's\njust add the return keyword like gentlemen.\n\nif/if1.rs\n\nif/if2.rs\n\nif/if3.rs\nThe if statement defining identifier was returning different types, which is fine however identifier is used\nbelow as comparison to integers, therefore we need to ensure that identifier is an int all the time.\n\nquiz1.rs\n\nprimitive_types/primitive_types_1.rs\n\nprimitive_types/primitive_types_2.rs\n\nprimitive_types/primitive_types_3.rs\n\nprimitive_types/primitive_types_4.rs\n\nprimitive_types/primitive_types_5.rs\nNote that you can also destructure it directly when declaring cat, and do:\nlet (name, age) = (\"Furry McFurson\", 3.5);.\n\nprimitive_types/primitive_types_6.rs\n\nvecs/vecs1.rs\n\nvecs/vecs2.rs\n\nmove_semantics/move_semantics1.rs\nCannot push to an immutable Vec.\nFurthermore, as the hint suggest, if we try to access vec0 in main after using fill_vec, we get an error\nindicating that vec0 was moved to fill_vec.\n\nmove_semantics/move_semantics2.rs\nWe pass a reference to fill_vec instead of a value so the ownership does not change, and then clone the value to\ninitiate our vector without issue.\n\nmove_semantics/move_semantics3.rs\nWe've added mut in the argument's definition of fill_vec to allow us to push into it.\n\nmove_semantics/move_semantics4.rs\nSimply move the vector initialization to the fill_vec function as asked.\n\nmove_semantics/move_semantics5.rs\nOnly one borrow can be active at the same time. In the original order, y was unusable once we initialize z as it's\nborrowing the same original value. We need to make sure to finish everything we want to do with y before declaring z.\n\nmove_semantics/move_semantics6.rs\nWe had get_char take ownership of data and string_uppercase taking a reference while we need the other way\naround.\n\nstructs/structs1.rs\n\nstructs/structs2.rs\n\nstructs/structs3.rs\n\nenums/enums1.rs\n\nenums/enums2.rs\n\nenums/enums3.rs\nHere we need to make sure to use u8 when defining the ChangeColor enum, as in the state implementation that's how\ncolor is defined.\n\nstrings/strings1.rs\n\nstrings/strings2.rs\n\nstrings/strings3.rs\n\nstrings/strings4.rs\n\nmodules/modules1.rs\nFunctions in a module are private by default, so here we just need to make make_sausage public to be used in the\nmain function.\n\nmodules/modules2.rs\nWe need to two changes here, replace both ??? with the name used in the main function (fruit and veggie). We\nalso need to make those public in order to be able to use it outside of the module.\n\nmodules/modules3.rs\n\nhashmaps/hashmaps1.rs\n\nhashmaps/hashmaps2.rs\nAdding 4 of each type of fruit is arbitraty, could be anything, could be randomize, as long as it's more than 11 total\nas per the requirement.\n\nhashmaps/hashmaps3.rs\nI extracted the logic of updating the score of a team in a separate function, but you could have duplicated it for\nteam_1 and team_2 in the build_scores_table function directly.\n\nquiz2.rs\n\noptions/options1.rs\nIn the test, I am not sure if they expected Some or something else tbh.\n\noptions/options2.rs\n\noptions/options3.rs\n\nerror_handling/errors1.rs\n\nerror_handling/errors2.rs\nI put both solutions in. The ? feels good though.\n\nerror_handling/errors3.rs\n\nerror_handling/errors4.rs\n\nerror_handling/errors5.rs\n\nerror_handling/errors6.rs\n\ngenerics/generics1.rs\n\ngenerics/generics2.rs\n\n","id":"http://127.0.0.1:1111/blog/rustlings/","title":"Rustlings - Solutions"},"http://127.0.0.1:1111/contact/":{"body":"Contact\nYou can contact me on:\n\ngithub\nby email: bricecontact[at]fastmail.com\n\n","id":"http://127.0.0.1:1111/contact/","title":"Contact - Unintended Fraud"}},"docInfo":{"http://127.0.0.1:1111/":{"body":0,"title":4},"http://127.0.0.1:1111/about/":{"body":208,"title":2},"http://127.0.0.1:1111/blog/":{"body":0,"title":3},"http://127.0.0.1:1111/blog/angularjs/":{"body":385,"title":6},"http://127.0.0.1:1111/blog/gocontext/":{"body":629,"title":3},"http://127.0.0.1:1111/blog/rustlings/":{"body":451,"title":2},"http://127.0.0.1:1111/contact/":{"body":5,"title":3}},"length":7},"lang":"English"} \ No newline at end of file diff --git a/sass/main.scss b/sass/main.scss new file mode 100644 index 0000000..8c89a14 --- /dev/null +++ b/sass/main.scss @@ -0,0 +1,352 @@ +$columnleft: 190px; +$columnright: 1000px; +$gap: 30px; + +$dark: #0b0b0b; +$grey: #a1a1a1; + +$orange: #F39F5A; +$pink: #AE445A; +$bordeaux: #662549; +$purple: #451952; + +$mainBg: #232323; +$defaultColor: #c9c9c9; + +body { + margin: 0; + padding: 12px 12px 12px 0; + background-color: $mainBg; + min-height: 100vh; + box-sizing: border-box; + font-family: "Helvetica Neue", Helvetica, Arial, sans-serif; + color: $defaultColor; + padding-bottom: 100px; + + a, + p, + h1, + h2, + h3, + h4 { + padding: 0; + margin: 0; + } + + a, + p { + line-height: 1.5em; + margin: 12px 0; + } + + + a { + color: $orange; + } + + ul, ol { + margin: 12px 0; + + li { + margin: 6px 0; + margin-bottom: 8px; + } + } + + .contact { + color: $pink; + } + .contact-middle { + color: $bordeaux; + } + + // --- Main page --- + + .main { + max-width: 1000px; + margin: 50px auto 0 auto; + padding-left: 12px; + + .top { + text-align: center; + + h1.name { + font-size: 72px; + margin-bottom: 8px; + + .firstname { + color: $orange; + } + + .lastname { + color: $pink; + } + } + + h2 { + font-size: 2em; + color: $defaultColor; + margin-bottom: 8px; + } + + .skills { + color: $defaultColor; + } + } + + + h3 { + color: rgba($defaultColor, 0.6); + margin-bottom: 12px; + margin-top: 70px; + font-weight: 600; + } + + a { + color: $orange; + display: inline-block; + + &.main-link { + font-size: 1.3em; + margin-left: 18px; + margin-right: 18px; + } + } + + .movie { + display: flex; + flex-direction: row; + align-items: center; + justify-content: flex-start; + margin-top: 36px; + + p { + margin: 0; + } + + img { + margin-right: 12px; + + &.mobile { + display: none; + } + } + + a { + color: $orange; + font-size: 0.9em; + opacity: 0.5; + } + + h4 { + margin-right: 12px; + } + + .movie-title { + margin-bottom: 6px; + display: flex; + flex-direction: row; + align-items: center; + + h4 { + font-size: 1.2em; + font-weight: 600; + } + } + + } + } + + @media (max-width: 600px) { + .main { + .top h1.name { + font-size: 3em; + } + + .movie { + img { + display: none; + + &.mobile { + display: block; + margin: 0 auto 12px auto; + } + } + + .movie-title { + flex-direction: column; + // align-items: flex-start; + } + } + } + } + + // --- Blog --- + + pre { + padding: 12px; + border-radius: 4px; + overflow: auto; + + code { + padding: 0; + background: none; + } + } + + code { + padding: 2px 4px; + background: #383838; + font-size: 1.1em; + line-height: 1.8em; + color: $grey; + } + + a { + text-decoration: none; + + &:hover { + text-decoration: underline; + } + } + + .header { + margin-left: $columnleft + $gap; + margin-bottom: 24px; + + a { + margin-right: 32px; + } + } + + .logo { + display: block; + width: $columnleft; + padding: 5px; + box-sizing: border-box; + text-align: right; + color: $orange; + font-weight: 600; + font-size: 20px; + + a { + .firstname { + color: $orange; + } + + .lastname { + color: $pink; + } + + &:hover { + text-decoration: none; + } + } + } + + .blog { + margin-top: 24px; + max-width: 1200px; + + p.tag-link { + color: rgba($orange, 0.6); + margin-top: 4px; + } + + .entry { + display: flex; + flex-direction: row; + align-items: flex-start; + margin-bottom: 36px; + + .column-left { + color: $grey; + margin-top: 4px; + display: flex; + flex-direction: column; + align-items: flex-end; + min-width: $columnleft; + margin-right: $gap; + line-height: 0; + + p { + margin: 0 0 6px 0; + } + } + + .column-right { + .mobile { + display: none; + } + + h1 { + font-size: 1.5em; + margin-bottom: 6px; + + a { + color: $defaultColor; + } + } + + + &.post { + min-width: 0; + + h1 { + font-size: 2.2em; + margin-bottom: 24px; + } + + h2, + h3 { + margin-top: 48px; + } + } + } + } + } + + @media (max-width: 600px) { + padding-left: 12px; + + p { + margin: 12px 0; + } + + .header { + margin-left: 0; + } + + .logo { + text-align: left; + width: auto; + padding: 0; + } + + .blog { + .entry { + display: block; + + .column-left { + display: none; + } + + .column-right { + .mobile { + display: block; + + .tags { + display: flex; + flex-direction: row; + margin-bottom: 12px; + + > p { + margin: 0 12px 0 0; + } + } + } + } + } + } + } +} diff --git a/sass/palette1.scss b/sass/palette1.scss new file mode 100644 index 0000000..ce1519a --- /dev/null +++ b/sass/palette1.scss @@ -0,0 +1,20 @@ +/* Color Theme Swatches in Hex */ +$Travel-1-hex: #101a26; +$Travel-2-hex: #f2ba52; +$Travel-3-hex: #f29849; +$Travel-4-hex: #bf5934; +$Travel-5-hex: #8c4535; + +/* Color Theme Swatches in RGBA */ +$Travel-1-rgba: rgba(16, 25, 38, 1); +$Travel-2-rgba: rgba(242, 186, 82, 1); +$Travel-3-rgba: rgba(242, 151, 72, 1); +$Travel-4-rgba: rgba(191, 88, 51, 1); +$Travel-5-rgba: rgba(140, 69, 53, 1); + +/* Color Theme Swatches in HSLA */ +$Travel-1-hsla: hsla(213, 40, 10, 1); +$Travel-2-hsla: hsla(39, 86, 63, 1); +$Travel-3-hsla: hsla(28, 86, 61, 1); +$Travel-4-hsla: hsla(16, 57, 47, 1); +$Travel-5-hsla: hsla(11, 44, 37, 1); diff --git a/sass/palette2.scss b/sass/palette2.scss new file mode 100644 index 0000000..c7a35ab --- /dev/null +++ b/sass/palette2.scss @@ -0,0 +1,20 @@ +/* Color Theme Swatches in Hex */ +$Fashion-1-hex: #d9ad77; +$Fashion-2-hex: #260f01; +$Fashion-3-hex: #bf6f41; +$Fashion-4-hex: #59220e; +$Fashion-5-hex: #bf6341; + +/* Color Theme Swatches in RGBA */ +$Fashion-1-rgba: rgba(216, 172, 119, 1); +$Fashion-2-rgba: rgba(38, 14, 0, 1); +$Fashion-3-rgba: rgba(191, 111, 65, 1); +$Fashion-4-rgba: rgba(89, 34, 14, 1); +$Fashion-5-rgba: rgba(191, 98, 65, 1); + +/* Color Theme Swatches in HSLA */ +$Fashion-1-hsla: hsla(33, 56, 65, 1); +$Fashion-2-hsla: hsla(22, 96, 7, 1); +$Fashion-3-hsla: hsla(22, 49, 50, 1); +$Fashion-4-hsla: hsla(16, 72, 20, 1); +$Fashion-5-hsla: hsla(16, 49, 50, 1); diff --git a/static/books/3body.jpg b/static/books/3body.jpg new file mode 100644 index 0000000..b99ac8f Binary files /dev/null and b/static/books/3body.jpg differ diff --git a/static/books/silo.jpg b/static/books/silo.jpg new file mode 100644 index 0000000..c7ffe5d Binary files /dev/null and b/static/books/silo.jpg differ diff --git a/static/favicon.png b/static/favicon.png new file mode 100644 index 0000000..7802af2 Binary files /dev/null and b/static/favicon.png differ diff --git a/static/movies/heretic.jpg b/static/movies/heretic.jpg new file mode 100644 index 0000000..c93c20c Binary files /dev/null and b/static/movies/heretic.jpg differ diff --git a/static/movies/movie1.jpg b/static/movies/movie1.jpg new file mode 100644 index 0000000..394dc42 Binary files /dev/null and b/static/movies/movie1.jpg differ diff --git a/static/movies/movie2.jpg b/static/movies/movie2.jpg new file mode 100644 index 0000000..ff77a92 Binary files /dev/null and b/static/movies/movie2.jpg differ diff --git a/static/movies/movie3.jpg b/static/movies/movie3.jpg new file mode 100644 index 0000000..cc2b1bb Binary files /dev/null and b/static/movies/movie3.jpg differ diff --git a/static/movies/movie4.jpg b/static/movies/movie4.jpg new file mode 100644 index 0000000..9b66876 Binary files /dev/null and b/static/movies/movie4.jpg differ diff --git a/static/movies/movie5.jpg b/static/movies/movie5.jpg new file mode 100644 index 0000000..485cc6c Binary files /dev/null and b/static/movies/movie5.jpg differ diff --git a/static/processed_images/3body.66a2504154e51d3e.jpg b/static/processed_images/3body.66a2504154e51d3e.jpg new file mode 100644 index 0000000..a274157 Binary files /dev/null and b/static/processed_images/3body.66a2504154e51d3e.jpg differ diff --git a/static/processed_images/heretic.070068c8c5f28049.jpg b/static/processed_images/heretic.070068c8c5f28049.jpg new file mode 100644 index 0000000..660b09c Binary files /dev/null and b/static/processed_images/heretic.070068c8c5f28049.jpg differ diff --git a/static/processed_images/movie1.7eb57714df0ac7f1.jpg b/static/processed_images/movie1.7eb57714df0ac7f1.jpg new file mode 100644 index 0000000..8b82dde Binary files /dev/null and b/static/processed_images/movie1.7eb57714df0ac7f1.jpg differ diff --git a/static/processed_images/movie2.77c5623711d50449.jpg b/static/processed_images/movie2.77c5623711d50449.jpg new file mode 100644 index 0000000..8f3980e Binary files /dev/null and b/static/processed_images/movie2.77c5623711d50449.jpg differ diff --git a/static/processed_images/movie3.8ce813455ea7ba01.jpg b/static/processed_images/movie3.8ce813455ea7ba01.jpg new file mode 100644 index 0000000..8fa6419 Binary files /dev/null and b/static/processed_images/movie3.8ce813455ea7ba01.jpg differ diff --git a/static/processed_images/movie4.0010a58aec56d560.jpg b/static/processed_images/movie4.0010a58aec56d560.jpg new file mode 100644 index 0000000..2c21a79 Binary files /dev/null and b/static/processed_images/movie4.0010a58aec56d560.jpg differ diff --git a/static/processed_images/movie5.656561563b654f81.jpg b/static/processed_images/movie5.656561563b654f81.jpg new file mode 100644 index 0000000..ebda1c7 Binary files /dev/null and b/static/processed_images/movie5.656561563b654f81.jpg differ diff --git a/templates/about.html b/templates/about.html new file mode 100644 index 0000000..8415142 --- /dev/null +++ b/templates/about.html @@ -0,0 +1,10 @@ +{% extends "base.html" %} + +{% block content %} +
+
+
+ {{ page.content | safe }} +
+
+{% endblock content %} diff --git a/templates/base.html b/templates/base.html new file mode 100644 index 0000000..12a9031 --- /dev/null +++ b/templates/base.html @@ -0,0 +1,37 @@ + + + + + + + + + {% if section.title %} + {{ section.title }} + {% elif page.title %} + {{ page.title }} + {% else %} + Blog + {% endif %} + + + +
+ home + blog + contact +
+ + + + +
{% block content %} {% endblock %}
+ + + diff --git a/templates/blog.html b/templates/blog.html new file mode 100644 index 0000000..9ba9e6d --- /dev/null +++ b/templates/blog.html @@ -0,0 +1,49 @@ +{% extends "base.html" %} + +{% block content %} + +{% for page in section.pages %} + +{% if page.taxonomies.type %} + {% set pageType = page.taxonomies.type | first %} + {% if pageType == "page" %} + {% continue %} + {% endif %} +{% endif %} + +
+
+

{{ page.date }}

+ + {% if page.taxonomies.tags %} + {% for t in page.taxonomies.tags %} +

+ #{{ t }} +

+
+ {% endfor %} + {% endif %} + +
+
+

{{ page.title }}

+ +
+

{{ page.date }}

+
+ {% if page.taxonomies.tags %} + {% for t in page.taxonomies.tags %} +

+ #{{ t }} +

+
+ {% endfor %} + {% endif %} +
+
+ +

{{ page.summary | safe }}

+
+ +{% endfor %} +{% endblock content %} diff --git a/templates/blog_page.html b/templates/blog_page.html new file mode 100644 index 0000000..0a21dde --- /dev/null +++ b/templates/blog_page.html @@ -0,0 +1,24 @@ +{% extends "base.html" %} + +{% block content %} +
+
+

{{ page.date }}

+ + {% if page.taxonomies.tags %} + {% for t in page.taxonomies.tags %} +

+ #{{ t }} +

+
+ {% endfor %} + {% endif %} +
+ +
+

{{ page.title }}

+ {{ page.content | safe }} +
+
+ +{% endblock content %} diff --git a/templates/index.html b/templates/index.html new file mode 100644 index 0000000..8563955 --- /dev/null +++ b/templates/index.html @@ -0,0 +1,156 @@ + + + + + + + + + {{ section.title }} + + + +
+
+

+ Brice + Bernard +

+

Software Engineer

+ + git + + blog + + linkedin + +
+ +

#about

+

+ Software engineer using mostly Go and Typescript. +

+

+ Coming from a frontend background, I became fullstack in the past 5 years and really enjoy it. My current goal is to + expand my backend knowledge and even non-web related topics! +

+

+ You can contact me at: bricecontact[at]fastmail.com +

+

+ Below are a few things I like, in a throwback of what old-school blog were before. + Hopefully you'll find something you didn't know you would like! +

+ +

#what you should watch

+

Here's 5 movies I enjoyed recently, check them out!

+ +
+ {% set image = resize_image(path="/static/movies/heretic.jpg", width=80, op="fit_width") %} + +
+
+

Heretic

+ see on letterboxd +
+ +

"Two young missionaries are forced to prove their faith when they knock on the wrong door and are + greeted by a diabolical Mr. Reed." +
+ The first hour of Heretic is one of the best piece of cinema I've experienced. It's a long discussion + between the three protagonist +

+
+
+ + +
+ {% set image = resize_image(path="/static/movies/movie4.jpg", width=80, op="fit_width") %} + +
+
+

Station Eleven

+ see on letterboxd +
+ +

"A post apocalyptic saga spanning multiple timelines telling the stories of survivors of a devastating flu + as they attempt to rebuild and reimagine the world anew while holding on to the best of what’s been lost." +
+ Despite what it sounds like, it has nothing to do with covid, it's from a book by Emily St. John Mandel - which I have + not read -. The serie is very poetic, there are so many beautiful and emotionnal moments I cannot count them, it is + one of the best show I've seen in recent times. At the end I only wish I could erase my memory and watch it again. +

+
+
+ +
+ {% set image = resize_image(path="/static/movies/movie2.jpg", width=80, op="fit_width") %} + +
+
+

Miss Sloane

+ see on letterboxd +
+ +

A battle between a genius lobbyist fighting for the people vs. the powerful gun lobby. A classic setup and overall + a classic sequence of events. However the movie is extremely well made and well acted which makes it a must-see if you enjoy the + genre. The ending is one of the most satisfying thing I've seen in a while even though you expect it to happen (which + speak even more to the quality of the film I think).

+
+
+ +
+ {% set image = resize_image(path="/static/movies/movie3.jpg", width=80, op="fit_width") %} + +
+
+

Maestro

+ see on letterboxd +
+ +

I watched Maestro during a sneak preview session (one of the best thing ever created). A movie clearly made for the oscars (long, black + and white, main theme around what it takes to create amazing art, etc), it stays intense the entire time, both Bradley Cooper and + Carey Mulligan are amazing. You'll be moved or you may be a robot.

+
+
+ +
+ {% set image = resize_image(path="/static/movies/movie5.jpg", width=80, op="fit_width") %} + +
+
+

Columbus

+ see on letterboxd +
+ +

This is just the last quality movie of a genre I really loved for some reason, aka well directed, beautiful cinematography and + a very slow movie where not much happens. Just regular people living and talking. I don't know why but every time those movies + make me feel so good and relaxed. If you're the same or if you're curious, Columbus is a sure bet.

+
+
+ +

#what you should read

+

Same as above with books although this is probably more what I last read as I read (way) less than I watch movies. (._.)

+ +
+ {% set image = resize_image(path="/static/books/3body.jpg", width=80, op="fit_width") %} + +
+
+

The Three-Body Problem Series (Liu Cixin)

+
+ +

I saw this book recommended many times until I finally tried it. It took me a while to really get into it but + after the mid-way mark of book one I was completely hooked. I couldn't stop reading. The book touches so many + different science-fiction concepts, theories, spanning across millions if not billions of years, it's like a guided + meditation in your imagination and intellect. So many times the book ask a seemingly impossible question and explore how to solve it, + it truly is fascinating. Plus the author managed to write the story in a way that makes you feel the full size and weight + of the entire universe. Masterpiece.

+
+
+
+ + + + diff --git a/templates/taxonomy_list.html b/templates/taxonomy_list.html new file mode 100644 index 0000000..57631f4 --- /dev/null +++ b/templates/taxonomy_list.html @@ -0,0 +1 @@ +

Taxonomyyy

diff --git a/templates/taxonomy_single.html b/templates/taxonomy_single.html new file mode 100644 index 0000000..5c5b18d --- /dev/null +++ b/templates/taxonomy_single.html @@ -0,0 +1 @@ +

taxonomy single