Jean-Baptiste G. jbgi

I started writing this polemic to answer your question, but I ended up touching on most of my gripes with Haskell in general, not just in a corporate context.

GHC

GHC is a modern compiler with an amazing RTS and tons of features, but I have some issues with it.

Monolithic and Hard to Contribute To

Balaji Sivaraman @balajisivaraman_twitter

Hi all, I need some help understanding a piece of Doobie code from the examples. It is the StreamingCopy one: (https://github.com/tpolecat/doobie/blob/series/0.4.x/yax/example/src/main/scala/example/StreamingCopy.scala). I am using a modified version of the fuseMap2 example from that file. Here’s how I’ve modified it for my requirements:

  def fuseMap[F[_]: Catchable: Monad, A, B](
      source: Process[ConnectionIO, A],
      sink: Vector[A] => ConnectionIO[B],
      delete: ConnectionIO[Unit]
  )(
 sourceXA: Transactor[F],

Laws

A law is a group of two or more expressions which are required to be the same. The expressions will usually involve one or more typed holes ("inputs") which vary.

Some examples:

x.map(id) === x

	package scalaworld.interpreters

	/*
	This file shows a simple language, an interpreter, and two
	partial evaluators for that language, along with a profiling suite.
	*/

	trait Expr // denotes a Vector[Double] => Vector[Double]

	object Expr {

	with builtins;

	rec {
	pkgs = import <nixpkgs> {};

	testGHC = pkgs.haskellPackages.ghcWithPackages (p: with p; [
	base base-orphans bifunctors comonad contravariant distributive
	tagged transformers
	]);

	{-# LANGUAGE TemplateHaskell #-}
	{-# LANGUAGE TypeFamilies #-}
	{-# LANGUAGE FlexibleInstances #-}
	{-# LANGUAGE MultiParamTypeClasses #-}
	{-# LANGUAGE DeriveFunctor #-}

	import Control.Lens
	import Prelude hiding (readFile, writeFile, print)
	import qualified Prelude as Prelude(readFile, writeFile, print)

	/**
	* In this version of `Traverse`, sequencing always goes through `List` (or some other canonical sequence type),
	* which can be done in a stack-safe manner using a balanced fold as in https://gist.github.com/pchiusano/7667597.
	* It's quite nice that `sequence` and `traverse` are now derived functions.
	*/
	trait Traverse[F[_]] extends Functor[F] {
	/** Inefficient but correct implementation of `toList` in terms of `mapAccumulate`. */
	def toList[A](f: F[A]): List[A] = mapAccumulate(f, List())((a, rbuf) => (a, a :: rbuf))._2.reverse

	/** The only function that must be implemented. Must be consistent with `map`. */

	// These lines go in ~/.sbt/0.13/global.sbt
	watchSources ++= (
	(baseDirectory.value * "*.sbt").get
	++ (baseDirectory.value / "project" * "*.scala").get
	++ (baseDirectory.value / "project" * "*.sbt").get
	)

	addCommandAlias("rtu", "; reload ; test:update")
	addCommandAlias("rtc", "; reload ; test:compile")
	addCommandAlias("ru", "; reload ; update")

	import java.util
	import java.util.Map.Entry

	import akka.http.scaladsl.model.HttpHeader
	import io.opentracing.propagation.TextMap

	import scala.collection.JavaConverters.asJavaIteratorConverter

	/**
	* Used to extract an iterator of Entry[String, String] to the

	# This is free and unencumbered software released into the public domain.

	# Anyone is free to copy, modify, publish, use, compile, sell, or
	# distribute this software, either in source code form or as a compiled
	# binary, for any purpose, commercial or non-commercial, and by any
	# means.

	# In jurisdictions that recognize copyright laws, the author or authors
	# of this software dedicate any and all copyright interest in the
	# software to the public domain. We make this dedication for the benefit