chriseidhof

Accessing an API using CoreData's NSIncrementalStore

Note: the original location of this article is on my blog, however, it is posted here too for better readability.

In this article, we will see how to use Core Data for accessing your API. We will use the Bandcamp API as our running example. I've only been experimenting with this code for a few days, so there might be mistakes in there.

mpilquist

object RWS extends App {

  trait Pointed[P[_]] {
    def point[A](a: A): P[A]
  }

  trait PointedFunctor[PF[_]] extends Pointed[PF] with Functor[PF]

  implicit def listIsMonoid[A]: Monoid[List[A]] = new Monoid[List[A]] {
    def id: List[A] = Nil

groundwater

object Put extends Controller {
  def index = DecodeProtobuf(classOf[MyProtobuf]) { stack :MyProtobuf =>
    Action {
      // do something with stack
    }
  }
}

svetlyak40wt

nnoremap <Leader>r :set keymap=russian-jcuken<CR>                                                                                            
nnoremap <Leader>e :set keymap=<CR>                                                                                                                                                                                                      
inoremap <Leader>r <ESC>:set keymap=russian-jcuken<CR>a                                                                                      
inoremap <Leader>e <ESC>:set keymap=<CR>a

gre

  import org.apache.commons.codec.binary.Base64
  val base64 = "data:([a-z]+);base64,(.*)".r
  def decodeBase64 (src: String): Option[(String, Array[Byte])] = {
    src match {
      case base64(mimetype, data) => Some( (mimetype, Base64.decodeBase64(data.getBytes("utf-8"))) )
      case _ => None
    }
  }

ethul

.*swp
.*un~

pthariensflame

The Indexed State Monad in Haskell, Scala, and C#

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

frederik-jacques

- (void)enumerateFonts {
    NSLog(@"--Start enumerating font--");
    for (NSString *fontFamilyStrings in [UIFont familyNames]) {
        NSLog(@"Font family: %@", fontFamilyStrings);
        
        for (NSString *fontStrings in [UIFont fontNamesForFamilyName:fontFamilyStrings]) {
            NSLog(@"-- Font: %@", fontStrings);
        }
    }
    NSLog(@"--End enumerating font--");

quchen

13:15 <xQuasar>      | HASKELL IS FOR FUCKIN FAGGOTS. YOU'RE ALL A BUNCH OF 
                     | FUCKIN PUSSIES
13:15 <xQuasar>      | JAVASCRIPT FOR LIFE FAGS
13:16 <luite>        | hello
13:16 <ChongLi>      | somebody has a mental illness!
13:16 <merijn>       | Wow...I suddenly see the error of my ways and feel 
                     | compelled to write Node.js!
13:16 <genisage>     | hi
13:16 <luite>        | you might be pleased to learn that you can compile 
                     | haskell to javascript now

jroper

class MyManagedResource extends ResourceController[String] {
  def index = Action(Ok("index"))

  def newScreen = Action(Ok("new"))

  def create = Action {
    Redirect(MyInjectableResource.reverseRoutes.index())
  }

  def show(id: String) = Action(Ok("Show " + id))