bkase

import simulacrum._

@typeclass trait CanTruthy[A] { self =>
  @op("!!") def truthy(a: A): Boolean
}

object Main extends App {
  import CanTruthy.ops._

  implicit val truthyInt =

bkase

func arity<A,R>(f: A -> R) -> Int {
  return 1
}
func arity<A,B,R>(f: (A, B) -> R) -> Int {
  return 2
}
func arity<A,B,C,R>(f: (A, B, C) -> R) -> Int {
  return 3
}
func arity<A,B,C,D,R>(f: (A, B, C, D) -> R) -> Int {

bkase

I received a great question over email that I want to answer publicly via gist:

At the end [of the Grokking Lazy Sequences and Collections talk], someone asked you if they can just access a lazy collection randomly and it will not run the transform (map for example) on every element in the collection up to the one they chose.

You said that is correct, but I think that it only applies if the Collection is a RandomAccessCollection? Otherwise, access is not random and is sequential instead, so the iterator’s next() method will be called on each element up to the one requested, and that transform will be executed on each one.

Actually, my response is correct! Confusingly, Collection does support subscript random access (with an expected O(1) runtime in fact) if you have an index. RandomAccessCollection conformance implies that you can compute the distance between indicies in O(1) time (aka moving an index is fast).

If yo

bkase

//
//  BKOneOf.h
//  BKOneOf
//

#ifndef BKOneOf_h
#define BKOneOf_h

/*
 * Interface and Implementation separate:

bkase

/*
* A callback-base implementation of effectful computation that defers interpretation
* until after computation is expressed (so you can inject different interpreters
* onto the same computation).
*
* The downside is the results aren't expressed as values. They are callback calls.
* You probably don't actually want to use this, but it seems interesting to think about.
*
* Inspired by "Programming with Algebraic Effects and Handlers" by
* Andrej Bauer and Matija Pretnar 2012

bkase

Optparse-applicative takes an interesting approach to commandline parsing. A parser is data that captures the structure of applicative and monadic combinators so that you can inspect that structure and interpret it later. Modeling this in Swift is hard.

I want to be able to model something like this:

indirect enum Parser<T> {
   case NilP(v: T?)
   case AltP(p1: Parser<T>, p2: Parser<T>)
   case BindP<I>(p: Parser<I>, f: (I) -> Parser<T>)
 /* ... */

bkase

// An exploration of http://okmij.org/ftp/tagless-final/sharing/sharing.pdf
// Specifically focusing on Hashconsing and Sklansky

// See http://swift.sandbox.bluemix.net/#/repl/5940bd55698d8d064dec2b22 for this snippet in a playground

typealias NodeId = Int
enum Node: Equatable, Hashable {
    case nconst(Int)
    case nvar(String)
    case nadd(NodeId, NodeId)

bkase

// SUPER ROUGH ideas about distributive property on Animations
// This is the "current relative time as input" rather than the "0 to 1 as input" (unit) version of the animation 
// this has flaws, but simple to show (or not) the distributive property of sequence and parallel

infix operator <>: AdditionPrecedence
protocol Semigroup {
	static func <>(lhs: Self, rhs: Self) -> Self
}

indirect enum FreeSemigroup<A>: Semigroup {

bkase

module Example {
  type jsProps = {. x: int, y: string };

  type state = ReasonReact.stateless;
  type props = ReasonReact.noRetainedProps;
  type action = ReasonReact.actionless;

  let component = ReasonReact.statelessComponent("Example");
  
  let make = (jsThis: Withjs.thisType) => (~x, ~y) => (_children) => {

bkase

protocol Base { }
extension Base {
	var a: String? { return nil }
	var b: Int? { return nil }
}

protocol A: Base {
	var a: String { get }
}