larsenwork

* {
  -webkit-font-smoothing: antialiased;
  -webkit-font-feature-settings: "liga" on, "calt" on;
}

atom-text-editor .cursor-line {
  -webkit-font-feature-settings: "liga" off, "calt" off;
}

CodaFi

indirect enum Formula : CustomStringConvertible {
  case Var(String)
  case Or(Formula, Formula)
  case And(Formula, Formula)
  case Imply(Formula, Formula)
  case BiImply(Formula, Formula)
  case Negate(Formula)

  var description : String {
    switch self {

drewcrawford

This, is actually the wrong conclusion. The entire purpose of the “inner class” is to provide value semantics while maintaining effeciency of implementation.

Is that an opinion? Or was there a meeting when the "entire purpose" of inner classes was established and I wasn't invited? Sure, they can be used for efficiency, but they can also be used for other purposes, including inner mutation.

Just for starters, Mike Ash seems to have uncovered that inner classes are used inside the standard library to provide destructors:

Destruction can be solved by using a class, which provides deinit. The pointer can be destroyed there. class doesn't have value semantics, but we can solve this by using class for the implementation of the struct, and exposing the struct as the external interface to the array.

So to say that the "entire purpose" of inner classes is efficiency is I think plainly false; they are used for many reasons. E

NickJosevski

public class FSharpOptionConverter : JsonConverter
{
    private static MethodInfo _getInnerValue = typeof (FSharpOptionConverter).GetMethod("GetInnerValue",
                                                                                        BindingFlags.Instance |
                                                                                        BindingFlags.NonPublic);
    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        if (value != null)
        {
            var optionValueType = value.GetType().GetGenericArguments().Single();

chriseidhof

import Cocoa

struct Person {
    var name: String = "John"
    var age: Int = 50
    var dutch: Bool = false
    var address: Address? = Address(street: "Market St.")
}

struct Address {

mikeash

import Foundation


protocol Serializable {
    static func deserializeInto(bytePtr: UnsafeMutablePointer<UInt8>, bytes: ArraySlice<UInt8>) -> ArraySlice<UInt8>
}

extension Serializable {
    typealias WorkaroundSelf = Self
    

chriseidhof

protocol OptionalType {
    typealias T
    var optional: T? { get }
}

extension Optional : OptionalType {
    var optional: T? { return self }
}

extension SequenceType where Generator.Element: OptionalType {

ohanhi

Learning FP the hard way: Experiences on the Elm language

by Ossi Hanhinen, @ohanhi

with the support of Futurice 💚.

Licensed under CC BY 4.0.

Editorial note

soffes

import Foundation

@objc protocol Foo {
    optional func say() -> String
}

class Doesnt: NSObject, Foo {
}

class Does: NSObject, Foo {

chantastic

Hi Nicholas,

I saw you tweet about JSX yesterday. It seemed like the discussion devolved pretty quickly but I wanted to share our experience over the last year. I understand your concerns. I've made similar remarks about JSX. When we started using it Planning Center, I led the charge to write React without it. I don't imagine I'd have much to say that you haven't considered but, if it's helpful, here's a pattern that changed my opinion:

The idea that "React is the V in MVC" is disingenuous. It's a good pitch but, for many of us, it feels like in invitation to repeat our history of coupled views. In practice, React is the V and the C. Dan Abramov describes the division as Smart and Dumb Components. At our office, we call them stateless and container components (view-controllers if we're Flux). The idea is pretty simple: components can't