Pt3 #357

DrBoolean · 2017-12-23T17:11:29Z

@KtorZ Here is the start of pt3 :)

KtorZ · 2017-12-23T17:38:59Z

:D ... Wonderful!

I'll go through it asap and most probably merge it on top of the reviewed exercises & es6.

DrBoolean · 2017-12-23T17:45:17Z

:) I know it's the holidays. Certainly no rush at all. Going for like 3-4 more chapters and calling it a book.

snackycracky · 2017-12-23T18:17:08Z

wow great, that comes under my christmas tree

as02700 · 2017-12-25T05:04:39Z

amazing...

gyzerok · 2017-12-28T15:58:19Z

Best Xmas gift this year!

wayneseymour · 2017-12-28T16:32:37Z

Indeed best XMas gift!!

On Thu, Dec 28, 2017 at 10:58 AM Fedor Nezhivoi ***@***.***> wrote: Best Xmas gift this year! — You are receiving this because you are subscribed to this thread. Reply to this email directly, view it on GitHub <#357 (comment)>, or mute the thread <https://github.com/notifications/unsubscribe-auth/AEogwzD3-QsRaO2gt0vQmZZwBIpX6IErks5tE7qigaJpZM4RLtug> .

-- W. K. Seymour III Software Engineer in Test iHeart Radio Radio Edit Team

KtorZ

A few typos noticed from a first read. Haven't been through exercises or laws in depth yet.

KtorZ · 2017-12-28T12:58:52Z

ch11.md

+  [Identity('bee thousand')]
+```
+
+Until now, we've managed to evade this common scenario with carefully crafted examples, but in practice, as one codes, types tend to tangle themselves up like earbuds in an exercism. If we don't meticulously keep our types organized as we go along, our code will read hairier than a beatnik in a cat café.


'exercism' => not sure if I lack a bit of vocabulary on that one or if it's simply a typo ^.^

Thanks for looking this over @KtorZ!

It's an allusion to the movie "The Exorcist" - my spelling is incorrect indeed

KtorZ · 2017-12-28T18:43:25Z

ch12.md

@@ -0,0 +1,256 @@
+# Chapter 11: Traversing the Stone


^__ Chapter 12

ha. I'm working on like 4 chapters at once here... Good catch

KtorZ · 2017-12-28T18:52:47Z

ch12.md

+
+```js
+// sequence :: (Traversable t, Applicative f) => (a -> f a) -> t (f a) -> f (t a)
+const sequence = (point, x) => x.sequence(point)


Currification forgotten here (unfortunately not by default in JavaScript :'( ...)

const sequence = curry((point, x) => x.sequence(point));

Ah yes. I definitely need that as I use it in the curried form later.

KtorZ · 2017-12-28T19:06:44Z

ch12.md

+}
+```
+
+Ah yes, if our `__value` is a functor (it must be an applicative, in fact), we can simply `map` our constructor to leap frog the type.


What about renaming point to pure ?

Ya know, I thought about that. Perhaps the best one would be of since we've already covered Pointed.

of might be a better idea indeed to maintain consistency with previous chapters. The laws from this chapter also refer to of.

👍

KtorZ · 2017-12-28T19:12:40Z

ch12.md

+// Identity(Right('stuff'))
+```
+
+This should be straight forward. If we place an `Identity` in our functor, then turn it inside out with `sequence` that's the same as just placing it on the outside to begin with. We chose `Right` as our guinea pig as it is easy to try the law and inspect. An arbitrary functor there is normal, however, the use of a concrete functor here, namely `Identity` in the law itself might raise some eyebrows. Remember a [category](ch5.md#category-theory) is defined by morphisms between its objects that have associative composition and identity. When dealing with the category of functors, natural transformations are the morphisms and `Identity` is, well identity. The `Identity` functor is as fundamental in demonstrating laws as our `compose` function. In fact, we should give up the ghost and follow suit with our [Compose](ch8.md#a-spot-of-theory) type:


*straight forward -> straightforward ?

KtorZ · 2017-12-28T19:17:29Z

ch12.md

+
+## In summary
+
+*Traversable* is a poweful interface that gives us the ability to rearrange our types with the ease of a telekinetic interior decorator. We can achieve different effects with different order as well as iron out those nasty type wrinkles that keep us from `join` them down. Next, we'll take a bit of a detour to see one of the most powerful interfaces of functional programming and perhaps even algebra itself: [Monoids bring it all together](ch13.md)


*poweful -> powerful

*different order -> different orders

*join -> joining

KtorZ · 2017-12-28T19:22:13Z

I haven't got time to go through exercises nor to apply the airbnb style yet. I'll on Saturday, and will also fix some of the typos I found on a first read (unless you do it in the meantime ^.^ ...)

Hopefully merged somewhere before next year.

DrBoolean · 2017-12-29T01:09:57Z

Thank ya sir! Again, no rush at all and I'll try to get to it if I have time myself.

evilsoft · 2017-12-29T03:39:34Z

ch12.md

+
+Ah yes, if our `__value` is a functor (it must be an applicative, in fact), we can simply `map` our constructor to leap frog the type.
+
+You may have noticed that we've ignored the `point` entirely. It is passed in for the occasion where mapping is futile, as is the case with `Left`:


HA. there is a way to set up the there. "ignored the point entirely" is way to good not to capitalize on.

I think there's a word missing in your comment, if not, I am not sure to understand what you meant :s ..

Wow. maybe like a few words, goodness!

Should read like:
"HA. I am sure there is a way to set up a pun here. "ignored the point entirely" is way to good not to capitalize on.

evilsoft · 2017-12-29T03:43:44Z

ch12.md

+
+```js
+// sequence :: (Traversable t, Applicative f) => (a -> f a) -> t (f a) -> f (t a)
+const sequence = (point, x) => x.sequence(point)


So glad you went with the pointed function over TypeRep of an Applicative. I find this interface a lot more handy and natural.

:) Thanks for looking this over, btw!

KtorZ

Some suggestions on the laws of the chapter 12.

KtorZ · 2017-12-29T09:25:55Z

ch12.md

+
+comp2(Right, Array)(Identity(Right([true])))
+// Compose(Right([Id(true)]))
+```


Very small thing here but Identity is referred as Id in the comments. I suggest to stick with Identity for consistency.

Ha, yeah. Copied from a local js file and missed that rename.

KtorZ · 2017-12-29T09:35:51Z

ch12.md

+
+```js
+const comp1 = compose(sequence(Compose.of), map(Compose.of))
+const comp2 = (point1, point2) => compose(Compose.of, map(sequence(point2)), sequence(point1))


What do you think of:

showing a quick recap of Compose

using f and g instead of point1 and point2 to make the parallel with Compose a bit more obvious

mentioning that f and g (or point1 and point2) need to be Traversable (even though implied by the use of sequence) ?

Great ideas!

KtorZ · 2017-12-29T12:12:01Z

ch12.md

+
+```js
+const natLaw1 = (point, nt) => compose(nt, sequence(p))
+const natLaw2 = (point, nt) => compose(sequence(p), map(nt))


Same consideration from above about using f instead of point (or p with the typo ^.^).

evilsoft · 2017-12-29T17:42:13Z

ch12.md

+
+So far, in our cirque du conteneur, you've seen us tame the ferocious [functor](ch8.md#my-first-functor), bending it to our will to perform any operation that strikes our fancy. You've been dazzled by the juggling of many dangerous effects at once using function [application](ch10.md) to collect the results. Sat there in amazement as containers vanished in thin air by [joining](ch9.md) them together. At the side effect sideshow, we've seen them [composed](ch8.md#a-spot-of-theory) into one. And most recently, we've ventured beyond what's natural and [transformed](ch11.md) one type into another before your very eyes.
+
+And now for our next trick, we'll look at traversals. We'll watch types soar over one another as if they were trapeze artists holding our value in tact. We'll reorder effects like the trolleys in a tilt-a-whirl. When our containers get intertwined like the limbs of a contortionist, we can use this interface to straighten things out. We'll witness different effects with different orderings. Fetch me my pantaloons and slide whistle, let's get started.


as if they were trapeze artists holding our value in tact.

Should in tact be intact. Or are you making reference to the heated debate all over the internets about the etymology.

evilsoft · 2017-12-29T17:47:14Z

ch11.md

+const findUser = x => x > 0 ? Task.of(Either.of({id: x, name: 'userface'})) : Task.of(new Left('not found'))
+
+// eitherToTask :: Either a b -> Task a b
+const eitherToTask = either(Task.rejected, Task.of)


either is not defined.
Did you want to bring it in or should it have been created with exercise 1?

It's part of support.js and we use it in the exercises somewhere. I think we should just add the type signature in a comment at the top or something...

I can't believe how "old school" the module system with globals and such are in the code itself. Might be a better way to actually link to the function from here.

This is going to change with the upcoming restructuring update 👍

gilligan · 2017-12-29T21:42:16Z

ch11.md

+const arrayToMaybe = x => Maybe.of(x[0])
+```
+
+See the idea? We're just changing one functor to another. We are permitted to lose information along the way so long as the value we'll `map` doesn't get lost in the shape shift shuffle. That is the thing here, remember, `map` must carry on after the transformation according to our defining law.


That is the thing here, remember, map must carry on after the transformation according to our defining law.

Entirely possible that this is just because i'm not a native speaker but i have read the sentence several times now and I still find it confusing - I know what you are saying but the sentence structure is weird to me ;-)

Maybe some punctuation will help, also by moving ahead the end of the sentence. Something like:

That is the thing here, remember. Map must carry on, according to our definition, even after the transformation.

i dig that!

evilsoft · 2017-12-29T18:21:27Z

ch12.md

+}
+```
+
+We'd like the types to always end up in the same arrangement, therefore it is necessary for types like `Left` who don't actually hold our inner applicative to get a little help in doing so. The *Applicative* interface requires that we first have a *Pointed Functor* so we'll always have a `point` to pass in. In a language with a type system, the outer type can be inferred from the signature and does not need to be explicitly given.


actually hold our inner applicative

Should this be Applicative?
Or is it correct as is because it references an actual Applicative instance?

I think both are correct depending on the context. My own interpretation is that Applicative refers to the concept / interface whereas applicative refers to an instance of that concept. I'll suggest to keep it with an uppercase as well as other terminologies of the same kind (Monad, Functor, Natural Transformation etc.) ?

Yeah, was trying to keep it to the instance/class definition like "this applicative is and instance of Applicative". I don't think i'm consistent though... Caps for everything is fine by me

evilsoft · 2017-12-29T18:22:25Z

ch12.md

+}
+```
+
+Ah yes, if our `__value` is a functor (it must be an applicative, in fact), we can simply `map` our constructor to leap frog the type.


(it must be an applicative, in fact)

Should this be Applicative?

evilsoft · 2017-12-29T21:40:43Z

ch12.md

+As a natural consequence of the above law, we get the ability to fuse traversals:
+
+```js
+traverse(compose(Compose.of, map(compose(f , g)))) = compose(Compose.of, map(traverse(of, f)), traverse(of, g))


The left traverse seems to be missing the constructor for it's first.

should this be something like:

traverse(Compose.of, compose(Compose.of, map(compose(f , g)))) = compose(Compose.of, map(traverse(of, f)), traverse(of, g))

edit @KtorZ: removed emojis from message

Indeed. Plus, I believe the law is erroneous. Let's switch to PureScript to lose some verbosity and gain some expressiveness, we currently have this:

traverse (Compose . map (f . g)) = Compose . map (traverse f) . traverse g

On the left, it suggests that:

g :: a -> b f :: b -> f c Compose :: h (f c) -> Compose h f c

and on the right:

g :: a -> g b f :: b -> f c Compose :: g (f c) -> Compose g f c

which doesn't hold well. I believe it would rather be:

traverse (Compose . map f . g) = Compose . map (traverse f) . traverse g -- or even, to have (Compose f g) instead of (Compose g f) traverse (Compose . map g . f) = Compose . map (traverse g) . traverse f

and, translated to the js version:

traverse(Compose.of, compose(Compose.of, map(g), f)) === compose(Compose.of, map(traverse(of$2, g)), traverse(of$1, f)) // where: // of$1 :: a -> f a // of$2 :: b -> g b

@DrBoolean, do you confirm ?

Ahh, yes, sorry. That one was never verified, just loosely translated in a hurry. Nice work on the Purs proof ;)

So i translated the fusion law from https://www.cs.ox.ac.uk/jeremy.gibbons/publications/iterator.pdf

NO CLUE WHERE I GOT THE map?! wtf.

Just provided a link here instead of writing it out.

Indeed:

Also confirmed with hackage's description of Traversable ^.^

evilsoft · 2017-12-30T07:13:00Z

ch12.md

+### Composition
+
+```js
+const comp1 = compose(sequence(Compose.of), map(Compose.of))


Oh gosh, I agree with @KtorZ for dat recap.
Also I know this is a REALLY big can of worms (like how does one implement really implement Compose.of without a type system), BUT maybe showing ap and Compose.of implementations (I know that could be its own huge section.). Although it may point out some of the shortcomings that surround traversals in JS and take a lot of focus away from the point here.

That is tricky.

Also should this be:

const comp1 = compose(sequence(Compose.of), map(Compose))

wouldn't that Compose.of throw in a F(G(F(G(x))))
I did not code it out yet though so I am probably wrong.

Also coming with the restructuring. These implementation details are now provided in an appendix. Compose.of is a bit tricky to define though in JavaScript. Ideally, we would need to specify the 2 underlying functors' constructors but we can't change the signature of of (it will defy its entire purpose, even though being, imo, acceptable for this edge case). The way @DrBoolean solved it in the examples was to directly provide a value nested in 2 functors:

Compose.of(Identity.of(Either.of(true)));

However, we would ideally like to do is something like:

Compose.of(true); // Identity(Right(true))

Yet, for the same reasons sequence and traverse have an extra argument, we can't write this as such in JavaScript like we would in Haskell. We could go for a "factory-like" method as such:

class Compose { static getOf(f, g) { return x => new this(f(g(x))); } constructor(x) { this.$value = x; } } const of = Compose.getOf(Identity.of, Either.of); of(true); // Compose(Identity(Right(true)))

or simply use optional arguments to provide constructors in that case:

class Compose { static of(x, f=Identity.of, g=Identity.of) { return new Compose(f(g(x))); } constructor(x) { this.$value = x; } } Compose.of(true, Identity.of, Either.of); // Compose(Identity(Right(true)))

There's also a closure approach:

const createCompose = (F, G) => { return class Compose { static of(x) { return new Compose(F(G(x))); } constructor(x) { this.$value = x; } } } const Compose = createCompose(Id, Either) Compose.of(true, Identity.of, Either.of); // Compose(Identity(Right(true)))

I like the closure approach better and will stick with that for the upcoming appendix 👍

evilsoft · 2017-12-30T07:59:31Z

ch12.md

+
+// test with a random natural transformation and our friendly Identity/Right functors.
+
+// maybeToEither :: Identity a -> Either () a


Looks like there may be some artifacts from copy/pasting

should it look something like:

const natLaw1 = (p, nt) => compose(nt, sequence(p)) const natLaw2 = (p, nt) => compose(sequence(p), map(nt)) // maybeToEither :: Maybe a -> Either () a const maybeToEither = m => m.either(Left, Right) natLaw1(Maybe.of, maybeToEither)(Identity(Maybe.of('barlow one'))) // Right(Identity('barlow one')) natLaw2(Either.of, maybeToEither)(Identity(Maybe.of('barlow one'))) // Right(Identity('barlow one'))

edit @KtorZ: removed emojis from message

I believe there's indeed some copy/pasting issues here ^.^ ... though m.either doesn't make much sense since we have m :: Maybe a. I would rather go for:

const natLaw1 = (of, nt) => compose(nt, sequence(of)) const natLaw2 = (of, nt) => compose(sequence(of), map(nt)) // test with a random natural transformation and our friendly Identity/Right functors. // maybeToEither :: Maybe a -> Either () a const maybeToEither = x => x.__value ? Right(x.__value) : Left() natLaw1(Maybe.of, maybeToEither)(Identity.of(Maybe.of('barlow one'))) // Right(Identity('barlow one')) natLaw2(Either.of, maybeToEither)(Identity.of(Maybe.of('barlow one'))) // Right(Identity('barlow one'))

Ha, yeah, that should be either(Left, Right, m), but i like yours better.

Yeah sorry that was an artifact from my crocks lib when I was giving it a play. mah bad.

evilsoft · 2017-12-30T08:05:34Z

ch12.md

+// Right(Identity('barlow one'))
+```
+
+This is similar to our identity law. If we first swing the types around then run a natural transformation on the outside, that should equal mapping a natural transformation, then flipping the types. The natural transformation to ensures our structure does not fiddle with its contents or fall apart on us during traversal.


The natural transformation to ensures our structure

Think there may be an extra word or two in there

DrBoolean · 2017-12-30T18:15:09Z

Haha, k! This is awesome. How about i make the changes today, then we open new issues for anything past this?

KtorZ · 2017-12-30T19:15:32Z

Agreed. I wasn't really expecting these amount of reactions ^.^, but let's do as we've always done so far: open small issues for small changes / typos / revisions etc.

Let me know once pushed 👍, I'll at least merge it as is and later on add the ES6/ES7 and restructuring revisions on top shortly after but at least, people would be able to read the chapters properly in the meantime!

DrBoolean · 2017-12-30T21:02:39Z

Pushed!

KtorZ

👍

evilsoft · 2017-12-30T21:18:07Z

HAHA sorry about that.
But do not sweat it. I will cease at this point.
I have a rule to NEVER provide 👀 on a project that edits comments, unless it breaks COC.
So this project has violated that, which is a REAL bummer.

crusoexia · 2017-12-31T07:02:46Z

Cheers! I love this book very much!

DrBoolean · 2017-12-31T17:19:00Z

@evilsoft I'm confused and want to make it not a bummer. What did you mean by "edits comments"? Also, holy smokes we do need a CoC!

KtorZ · 2017-12-31T17:28:18Z

@DrBoolean , It seems that @evilsoft has a kind of plugin that automatically replace text with emojis when "appropriated". Therefore, I did edit a couple of his comments (leaving an explicit note: "Edited by KtorZ: removed inserted emojis") as I judged that

"Looks like there may be some artifacts from copy/pasting"

is much more readable than

"Looks like there may be some artifacts from 👮y/🍝e"

Following @evilsoft's remark, I've opened #358 to make sure we define a CoC in the future.

DrBoolean · 2017-12-31T17:40:41Z

Ahh, haha okay I see now. I feel like that was an innocent move and I really value @evilsoft's help. Maybe we can disable the plugin and agree not to edit? I do find it fun despite being cryptic - i'll have to use that in my work slack :)

KtorZ · 2017-12-31T17:48:26Z

I do agree that the move may appear a bit like a anti-emojis-nazi kind of move, and was really not the intention in a first place. I really don't mind emojis when they aren't harmful to readability. Point taken though @evilsoft, I guess we just need to have that stated in a CoC.

Brian Lonsdorf added 3 commits December 21, 2017 07:06

start ch11 and 12

bbe55a5

exercises

d488dae

traversable exercises

30728ce

Fabs mentioned this pull request Dec 28, 2017

Plans for part 3 #245

Closed

KtorZ reviewed Dec 28, 2017

View reviewed changes

evilsoft reviewed Dec 29, 2017

View reviewed changes

KtorZ reviewed Dec 29, 2017

View reviewed changes

evilsoft reviewed Dec 29, 2017

View reviewed changes

MostlyAdequate deleted a comment from DrBoolean Dec 29, 2017

gilligan reviewed Dec 29, 2017

View reviewed changes

evilsoft reviewed Dec 30, 2017

View reviewed changes

KtorZ self-assigned this Dec 30, 2017

Brian Lonsdorf added 4 commits December 30, 2017 11:59

spelling fix

8853f8a

update ch number

05fb31b

curry sequence

6135f4b

various updates from initial feedback

c690e9f

KtorZ approved these changes Dec 30, 2017

View reviewed changes

KtorZ merged commit c058358 into master Dec 30, 2017

KtorZ mentioned this pull request Dec 30, 2017

Code of Conduct & Contributing #358

Open

KtorZ deleted the pt3 branch January 3, 2018 18:47


		## In summary

		Traversable is a poweful interface that gives us the ability to rearrange our types with the ease of a telekinetic interior decorator. We can achieve different effects with different order as well as iron out those nasty type wrinkles that keep us from `join` them down. Next, we'll take a bit of a detour to see one of the most powerful interfaces of functional programming and perhaps even algebra itself: [Monoids bring it all together](ch13.md)


		Ah yes, if our `__value` is a functor (it must be an applicative, in fact), we can simply `map` our constructor to leap frog the type.

		You may have noticed that we've ignored the `point` entirely. It is passed in for the occasion where mapping is futile, as is the case with `Left`:


		So far, in our cirque du conteneur, you've seen us tame the ferocious [functor](ch8.md#my-first-functor), bending it to our will to perform any operation that strikes our fancy. You've been dazzled by the juggling of many dangerous effects at once using function [application](ch10.md) to collect the results. Sat there in amazement as containers vanished in thin air by [joining](ch9.md) them together. At the side effect sideshow, we've seen them [composed](ch8.md#a-spot-of-theory) into one. And most recently, we've ventured beyond what's natural and [transformed](ch11.md) one type into another before your very eyes.

		And now for our next trick, we'll look at traversals. We'll watch types soar over one another as if they were trapeze artists holding our value in tact. We'll reorder effects like the trolleys in a tilt-a-whirl. When our containers get intertwined like the limbs of a contortionist, we can use this interface to straighten things out. We'll witness different effects with different orderings. Fetch me my pantaloons and slide whistle, let's get started.


		// test with a random natural transformation and our friendly Identity/Right functors.

		// maybeToEither :: Identity a -> Either () a

Pt3 #357

Pt3 #357

Conversation

DrBoolean commented Dec 23, 2017

KtorZ commented Dec 23, 2017

DrBoolean commented Dec 23, 2017

snackycracky commented Dec 23, 2017

as02700 commented Dec 25, 2017

gyzerok commented Dec 28, 2017

wayneseymour commented Dec 28, 2017 via email

KtorZ left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

KtorZ commented Dec 28, 2017

DrBoolean commented Dec 29, 2017

Choose a reason for hiding this comment

Choose a reason for hiding this comment

evilsoft Dec 29, 2017 • edited

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

KtorZ left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

KtorZ Dec 30, 2017 • edited

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

evilsoft Dec 29, 2017 • edited by KtorZ

Choose a reason for hiding this comment

KtorZ Dec 30, 2017 • edited

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

evilsoft Dec 30, 2017 • edited by KtorZ

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

DrBoolean commented Dec 30, 2017

KtorZ commented Dec 30, 2017 • edited

DrBoolean commented Dec 30, 2017

KtorZ left a comment

Choose a reason for hiding this comment

evilsoft commented Dec 30, 2017

crusoexia commented Dec 31, 2017

DrBoolean commented Dec 31, 2017

KtorZ commented Dec 31, 2017 • edited

evilsoft Dec 29, 2017 •

edited

KtorZ Dec 30, 2017 •

edited

evilsoft Dec 29, 2017 •

edited by KtorZ

KtorZ Dec 30, 2017 •

edited

evilsoft Dec 30, 2017 •

edited by KtorZ

KtorZ commented Dec 30, 2017 •

edited

KtorZ commented Dec 31, 2017 •

edited