tfausak

Invertible syntax descriptions

An "invertible syntax description" is something that can be used to both parse and generate a syntax. For example, instead of defining separate toJson and fromJson functions for a given data type, an invertible syntax description could be used to provide both. There are many Haskell libraries that provide this functionality or something close to it. As far as I can tell most of them are at least inspired by Invertible syntax descriptions by Tillmann Rendel and Klaus Ostermann.

Personally I am interested in using these for HTTP routing. I frequently want to be able to define a route such as /episodes/:id.json, dispatch based on that route, and generate links to that route. Doing so manually is tedious and error prone.

CodaFi

//: Foreword
//:
//: This playground is the culmination of a week of digging around
//: for the oldest papers I could find about (Lisp) macros and their evolution.
//: I found this paper particularly enlightening as it is the place where Scheme
//: and Rust-style "Macro-by-Example" macros first came into their own.  In
//: addition, this paper discusses the implementation challenges faced by
//: previous macro systems and Kohlbecker's first go at MBEs.
//:
//: I have re-typeset this paper because [the one hosted by IU](ftp://www.cs.indiana.edu/pub/techreports/TR206.pdf)

nicklockwood

// Swift's untyped errors are a goddam PiTA. Here's the pattern I use to try to work around this.
// The goal is basically to try to guarantee that every throwing function in the app throws an
// ApplicationError instead of some unknown error type. We can't actually enforce this statically
// But by following this convention we can simplify error handling

enum ApplicationError: Error, CustomStringConvertible {
    
  // These are application-specific errors that may need special treatment
  case specificError1
  case specificError2(SomeType)

Catfish-Man

#import <Foundation/Foundation.h>
#import <time.h>
#import <os/lock.h>

#define ITERS 2000
#define NSEC_PER_ITER(time) (((double)time * (double)NSEC_PER_SEC) / (double)ITERS)

#define TEST(body, name) do {\
    start = [NSDate date];\
    for (int i = 0; i < ITERS; i++) {\

CodaFi

#!/bin/sh

set -e

if [ -z "${SWIFTPM_CONFIGURATION}" ]; then
  SWIFTPM_CONFIGURATION=.bootstrap/lib/swift/pm/4
fi

if [ -z "${CONFIGURATION}" ]; then
    CONFIGURATION=release

beala

{-
In this file I:
- Define a binary tree.
- Define a type level predicate for right rotation of a tree. That is, this type
  can only be instantiated for trees that can be right rotated.
- Prove that it's decidable if a tree can be right-rotated or not.
- Prove that right-rotating a tree preserves in-order traversal.
-}

-- A binary tree.

CodaFi

/// Playground - noun: a place where people can play
/// FileCheck yourself before you wreck yourself

import Foundation
#if os(Linux)
	import Glibc

	typealias NSRegularExpression = RegularExpression
#else
	import Darwin

djspiewak

data Free f a =
  Return a |
  forall e . Bind (Free f e) (e -> Free f a) |
  LiftF (f a)

instance Monad (Free f) where
  return = Return
  (>>=) = Bind

liftF :: f a -> Free f a

jpmartha

Dates	Conferences	Venues	CfPs
January 27	dotSwift	Paris, France	Closed
February 7-8	Mac Admin & Developer Conference UK	London, UK
February 23-24	Playgrounds	Melbourne, Australia	Closed
March 2	Forward Swift	San Francisco, CA
March 2-4	try! Swift Tokyo 2017	Tokyo, Japan	Closed
March 16-17	Appdevcon 2017	Amsterdam	Closed
March 20-23	Yosemite, by CocoaConf	Yosemite National Park, CA, USA
March 30-31	iOSCon 2017	London	Closed

jdegoes

sealed trait Free[F[_], A] { self =>
  final def map[B](ab: A => B): Free[F, B] = Free.flatMap(self, ab andThen (Free.point[F, B](_)))
  final def flatMap[B](afb: A => Free[F, B]): Free[F, B] = Free.flatMap(self, afb)
  final def interpret[G[_]: Monad](fg: F ~> G): G[A] = self match {
    case Free.Point(a0) => a0().point[G]
    case Free.Effect(fa) => fg(fa)
    case fm : Free.FlatMap[F, A] =>
    	val ga0 = fm.fa.interpret[G](fg)
    	ga0.flatMap(a0 => fm.afb(a0).interpret[G](fg))
  }