Yiorgos Michokostas gmichokostas

My Vim-related gists

Long-form

Rich Already Answered That!

A list of commonly asked questions, design decisions, reasons why Clojure is the way it is as they were answered directly by Rich (even when from many years ago, those answers are pretty much valid today!). Feel free to point friends and colleagues here next time they ask (again). Answers are pasted verbatim (I've made small adjustments for readibility, but never changed a sentence) from mailing lists, articles, chats.

How to use:

The link in the table of content jumps at the copy of the answer on this page.
The link on the answer itself points back at the original post.

Table of Content

Getting Started in Scala

This is my attempt to give Scala newcomers a quick-and-easy rundown to the prerequisite steps they need to a) try Scala, and b) get a standard project up and running on their machine. I'm not going to talk about the language at all; there are plenty of better resources a google search away. This is just focused on the prerequisite tooling and machine setup. I will not be assuming you have any background in JVM languages. So if you're coming from Python, Ruby, JavaScript, Haskell, or anywhere… I hope to present the information you need without assuming anything.

Disclaimer It has been over a decade since I was new to Scala, and when I was new to Scala, I was coming from a Java and Ruby background. This has probably caused me to unknowingly make some assumptions. Please feel free to call me out in comments/tweets!

One assumption I'm knowingly making is that you're on a Unix-like platform. Sorry, Windows users.

Getting the JVM

Applied Functional Programming with Scala - Notes

1. Mastering Functions

A function is a mapping from one set, called a domain, to another set, called the codomain. A function associates every element in the domain with exactly one element in the codomain. In Scala, both domain and codomain are types.

val square : Int => Int = x => x * x

101> h().
81: bitstring_to_list(D)

	REQUEST_URI = ARGV[0] \|\| "http://0.0.0.0/"
	REQUEST_OPTS = {
	'REMOTE_ADDR' => "127.0.0.1",
	'HTTP_HOST' => '0.0.0.0'
	}
	ARGV.clear

	require "actionview_precompiler"
	require "flamegraph"
	require "./config/environment"

	#!/bin/sh
	#_(

	#_DEPS is same format as deps.edn. Multiline is okay.
	DEPS='
	{:deps {clj-time {:mvn/version "0.14.2"}}}
	'

	#_You can put other options here
	OPTS='

	require 'pg'
	PGDB = PG.connect(host: '/tmp', dbname: 'mydb')
	PGDB.type_map_for_results = PG::BasicTypeMapForResults.new(PGDB)

	class Hash
	def symbolize_keys
	inject({}) { \|m, kv\| v = kv[1];
	m[kv[0].to_sym] = v.is_a?(Hash) ? v.symbolize_keys : v; m }
	end
	end

	(ns net.thegeez.advent.spec-parsing
	(:require [clojure.string :as str]
	[clojure.spec :as s]
	[clojure.spec.gen :as gen]
	[clojure.test.check.generators :as tgen]))
	;; Dependencies:
	;; [org.clojure/clojure "1.9.0-alpha14"]
	;; [org.clojure/test.check "0.9.0"]

	;; Advent of Code is a series of code challenges in the form of an advent

	The question was asked why I (as a programmer who prefers dynamic languages) don't consider static types "worth it". Here
	is a short list of what I would need from a type system for it to be truely useful to me:

	1) Full type inference. I would really prefer to be able to write:

	(defn concat-names [person]
	(assoc person :full-name (str (:first-name person)
	(:second-name person))))

	And have the compiler know that whatever type required and produced from this function was acceptible as long as the