| trait Companion[T] { | |
| type C | |
| def apply() : C | |
| } | |
| object Companion { | |
| implicit def companion[T](implicit comp : Companion[T]) = comp() | |
| } | |
| object TestCompanion { |
Locate the section for your github remote in the .git/config file. It looks like this:
[remote "origin"]
fetch = +refs/heads/*:refs/remotes/origin/*
url = git@github.com:joyent/node.git
Now add the line fetch = +refs/pull/*/head:refs/remotes/origin/pr/* to this section. Obviously, change the github url to match your project's URL. It ends up looking like this:
| # Sexy Solarized Bash Prompt, inspired by "Extravagant Zsh Prompt" | |
| # Customized for the Solarized color scheme by Sean O'Neil | |
| if [[ $COLORTERM = gnome-* && $TERM = xterm ]] && infocmp gnome-256color >/dev/null 2>&1; then TERM=gnome-256color; fi | |
| if tput setaf 1 &> /dev/null; then | |
| tput sgr0 | |
| if [[ $(tput colors) -ge 256 ]] 2>/dev/null; then | |
| BASE03=$(tput setaf 234) | |
| BASE02=$(tput setaf 235) | |
| BASE01=$(tput setaf 240) |
| Solarized | |
| #FDF6E3,#EEE8D5,#93A1A1,#FDF6E3,#EEE8D5,#657B83,#2AA198,#DC322F | |
| Solarized Dark | |
| #073642,#002B36,#B58900,#FDF6E3,#CB4B16,#FDF6E3,#2AA198,#DC322F | |
| <RaceCondition> can I use Scalaz to get exhaustion checks when matching on numeric values? Scala obviously doesn't do that | |
| <RaceCondition> ! 1.1 match { case x if 0.0 <= x && x < 0.5 => "bad"; case x if 0.5 <= x && x <= 1.0 => "good" } | |
| <dibblego> doubt it | |
| <multibot_> scala.MatchError: 1.1 (of class java.lang.Double) | |
| <multibot_> ... 38 elided | |
| <dibblego> use types though? | |
| <RaceCondition> wdym? | |
| <dibblego> use a type to note each range | |
| <dibblego> you want a floating-point between 0.0 and 1.0? | |
| <RaceCondition> wouldn't that just move the problem to a different stage? |
PRs are a great way of sharing information, and can help us be aware of the changes that are occuring in our codebase. They are also an excellent way of getting peer review on the work that we do, without the cost of working in direct pairs.
Ultimately though, the primary reason we use PRs is to encourage quality in the commits that are made to our code repositories
Done well, the commits (and their attached messages) contained within tell a story to people examining the code at a later date. If we are not careful to ensure the quality of these commits, we silently lose this ability.
| object Demo { | |
| // A couple of type classes with type members ... | |
| trait Foo[T] { | |
| type A | |
| } | |
| object Foo { | |
| implicit val fooIS = new Foo[Int] { type A = String } | |
| } |
| // | |
| // Disjunction - aka Scalaz Either | |
| // \/[A, B] is an alternative to Either[A, B] | |
| // -\/ is Left (usually represents failure by convention) | |
| // \/- is Right (usually represents success by convention) | |
| // Left or Right - which side of the Disjunction does the "-" appear? | |
| // | |
| // Prefer infix notation to express Disjunction Type v: String \/ Double | |
| // | |
| // References |
First, a bit of terminology. "Macro" in this context refers to the broad strategy of the game. "Micro" is sort of like the opposite, and it refers to the raw mechanics of controlling your character, what abilities to activate when, etc. This guide isn't going to touch on any of that stuff. Instead, we'll be looking at how you judge what to do, when and why (that last one is very important). Most of the information here is surprisingly role-agnostic (i.e. it doesn't matter which character you're playing), but not all. I'll try to call out wherever I'm assuming one role or another.
The minimap is life, love and happiness. There are no words for how important the minimap is. Get in the habit of looking at it all the time. If you don't need to micro-manage your hero at this precise moment (i.e. you're pausing in a bush, waiting for a gank; or maybe sitting behind your minions, laning), then look at the map! Learn to recognize at a glance which hero has what
Miles Sabin recently opened a pull request fixing the infamous SI-2712. First off, this is remarkable and, if merged, will make everyone's life enormously easier. This is a bug that a lot of people hit often without even realizing it, and they just assume that either they did something wrong or the compiler is broken in some weird way. It is especially common for users of scalaz or cats.
But that's not what I wanted to write about. What I want to write about is the exact semantics of Miles's fix, because it does impose some very specific assumptions about the way that type constructors work, and understanding those assumptions is the key to getting the most of it his fix.
For starters, here is the sort of thing that SI-2712 affects:
def foo[F[_], A](fa: F[A]): String = fa.toString