emiller

#!/bin/bash
#
# git-mv-with-history -- move/rename file or folder, with history.
#
# Moving a file in git doesn't track history, so the purpose of this
# utility is best explained from the kernel wiki:
#
#   Git has a rename command git mv, but that is just for convenience.
#   The effect is indistinguishable from removing the file and adding another
#   with different name and the same content.

tpolecat

Hi, looking for scalac flags?

This gist has been upgraded to a blog post here.

puffnfresh

module AlaCarte where

-- Control.Monad.Free

data Free f a = Free (f (Free f a)) | Pure a

instance Functor f => Monad (Free f) where
    Pure a >>= f = f a
    Free r >>= f = Free (fmap (>>= f) r)
    return = Pure

markhibberd

So what I understand to be your questions:

1. What is a coherency problem?
2. What does over constained code look like / cause?
3. How do you lose your "desired" instance?

A way to step through understanding this problem:

• Oh shit, If I have local type classes, I have to handle crazy wacky cases in my implementation, this will likely have performance and correctness implications (see Coherency.scala)
• What happens if I close over constraint on construction? Oops if I close over it, I end up with OverConstrained code (see OverConstrainedCode.scala) and worse I still have coherency issues, and the ability to lose my intended behavious (LosingAnInstance.scala)
• Oh wow, if I just don't do local type classes, by never define conflicting implicits, and ascribe a single type to each behaviour, everything is simple and just works.

runarorama

sealed trait Interact[A]

case class Ask(prompt: String)
  extends Interact[String]

case class Tell(msg: String)
  extends Interact[Unit]

trait Monad[M[_]] {
  def pure[A](a: A): M[A]

pchiusano

object tee {

  /**
   * Convert a `Tee` to a `Process1` by feeding the same input to both sides of the `Tee`.
   * Named after the 'diamond' shape this creates in the dataflow graph.
   */
  def diamond[A,B](t: Tee[A,A,B]): Process1[A,B] = Process.suspend {
    // todo: there's a more complex impl that performs better when branches
    // have vastly different rates of processing
    val (hd, tl) = t.unemit

DamienCassou

{ config, pkgs, ... }:

let
  hostname = "luz3";
in {
  imports =
    [ # Include the results of the hardware scan.
      ./hardware-configuration.nix

      # I use VirtualBox to connect to Windows and Linux guests

thorhop

# Edit this configuration file to define what should be installed on
# your system.  Help is available in the configuration.nix(5) man page
# and in the NixOS manual (accessible by running ‘nixos-help’).

{ config, pkgs, ... }:

{
  imports =
    [ # Include the results of the hardware scan.
      ./hardware-configuration.nix

neel-krishnaswami

(* -*- mode: ocaml; -*- *)

module type FUNCTOR = sig
  type 'a t
  val map : ('a -> 'b) -> 'a t -> 'b t
end

type 'a monoid = {unit : 'a ; join : 'a -> 'a -> 'a}

type var = string

pchiusano

-- A port of: http://semantic-domain.blogspot.com/2015/03/abstract-binding-trees.html

{-# LANGUAGE DeriveFunctor #-}

module ABT where

import qualified Data.Foldable as Foldable
import Data.Foldable (Foldable)
import Data.Set (Set)
import qualified Data.Set as Set