| *.scala diff=scala |
| #!/usr/bin/env zsh | |
| git show-branch -a \ | |
| | grep '\*' \ | |
| | grep -v `git rev-parse --abbrev-ref HEAD` \ | |
| | head -n1 \ | |
| | sed 's/.*\[\(.*\)\].*/\1/' \ | |
| | sed 's/[\^~].*//' | |
| # How it works: |
| scala> :paste | |
| // Entering paste mode (ctrl-D to finish) | |
| case class A(x: Int)(y: Int) { def toB = B(x, y) } | |
| case class B(x: Int, y: Int) { def toA = A(x)(y) } | |
| // Exiting paste mode, now interpreting. | |
| defined class A | |
| defined class B |
Have you ever had to write code that made a complex series of succesive modifications to a single piece of mutable state? (Almost certainly yes.)
Did you ever wish you could make the compiler tell you if a particular operation on the state was illegal at a given point in the modifications? (If you're a fan of static typing, probably yes.)
If that's the case, the indexed state monad can help!
Motivation
| // Universal quantification is encoded in terms of quantifier-free | |
| // assertions about an "abitrary" type (cp. "all swans are white" vs. | |
| // "the arbitrary swan is white". Inspired by Kit Fine's 1985 "Reasoning | |
| // with Arbitrary Objects", http://philosophy.fas.nyu.edu/object/kitfine. | |
| // | |
| // Possibly also related to Oleg Kiselyov's "Interpreting types as | |
| // abstract values", http://okmij.org/ftp/Computation/index.html#teval. | |
| // What I wouldn't give for kind-polymorphism here ... | |
| import Stream._ | |
| /** A possibly finite stream that repeatedly applies a given function to a start value. | |
| * | |
| * @param start the start value of the stream | |
| * @param f the function that's repeatedly applied | |
| * @return the stream returning the possibly finite sequence of values `start, f(start), f(f(start)), ...` | |
| */ | |
| def iterate[A](f: A => A, a: A): Stream[A] = unfold((x: A) => Some((x, f(x))), a) |
Update 2022: git checkout -p <other-branch> is basically a shortcut for all this.
FYI This was written in 2010, though I guess people still find it useful at least as of 2021. I haven't had to do it ever again, so if it goes out of date I probably won't know.
Example: You have a branch refactor that is quite different from master. You can't merge all of the
commits, or even every hunk in any single commit or master will break, but you have made a lot of
improvements there that you would like to bring over to master.
Note: This will not preserve the original change authors. Only use if necessary, or if you don't mind losing that information, or if you are only merging your own work.
