Alex Peitsinis alexpeits

Externs Inference

Integrating third party JavaScript libraries not written with Google Closure Compiler in mind continues to both be a source of error for users when going to production, and significant vigilance and effort for the the broader community (CLJSJS libraries must provide up-to-date and accurate externs).

In truth writing externs is far simpler than most users imagine. You only need externs for the parts of the library you actually intend to use from ClojureScript. However this isn't so easy to determine from Closure's own documentation. Still in the process of writing your code it's easy to miss a case. In production you will see the much dreaded error that some mangled name does not exist. Fortunately it's possible to enable some compiler flags :pretty-print true :pseudo-names true to generate an advanced build with human readable names. However debugging missing externs means compiling your production build for each missed case. So much time wasted for such simple mistakes damages our sen

http://www.cs.ox.ac.uk/people/bob.coecke/AbrNikos.pdf

Why study categories—what are they good for? We can offer a range of answers for readers coming from different backgrounds:

For mathematicians: category theory organises your previous mathematical experience in a new and powerful way, revealing new connections and structure, and allows you to “think bigger thoughts”.
For computer scientists: category theory gives a precise handle on important notions such as compositionality, abstraction, representationindependence, genericity and more. Otherwise put, it provides the fundamental mathematical structures underpinning many key programming concepts.
For logicians: category theory gives a syntax-independent view of the fundamental structures of logic, and opens up new kinds of models and interpretations.
For philosophers: category theory opens up a fresh approach to structuralist foundations of mathematics and science; and an alternative to the traditional focus on set theory
For **p

	{-# LANGUAGE CPP #-}
	{-# LANGUAGE ScopedTypeVariables #-}
	{-# LANGUAGE FlexibleInstances, FlexibleContexts #-}
	{-# LANGUAGE DataKinds, GADTs, KindSignatures, TypeOperators, UndecidableInstances #-}

	#if __GLASGOW_HASKELL__ < 708
	#error "requires GHC 7.10 or newer"
	#endif
	module Main (main) where

	Control.Arrow
	=============
	"compose/arr" forall f g .
	(arr f) . (arr g) = arr (f . g)
	"first/arr" forall f .
	first (arr f) = arr (first f)
	"second/arr" forall f .
	second (arr f) = arr (second f)
	"product/arr" forall f g .
	arr f * arr g = arr (f * g)

	{-# LANGUAGE GADTs #-}
	{-# LANGUAGE PolyKinds #-}
	{-# LANGUAGE FunctionalDependencies #-}
	{-# LANGUAGE MultiParamTypeClasses #-}
	{-# LANGUAGE TypeOperators #-}
	{-# LANGUAGE DataKinds #-}
	{-# LANGUAGE KindSignatures #-}
	{-# LANGUAGE TemplateHaskell #-}
	{-# LANGUAGE FlexibleInstances #-}
	{-# LANGUAGE OverloadedLabels #-}

	{-# LANGUAGE GADTs, TypeInType, DataKinds, TypeFamilies #-}
	{-# LANGUAGE TypeOperators #-}
	{-# LANGUAGE TypeApplications #-}

	import GHC.TypeLits
	import GHC.Types
	import Data.Singletons
	import Data.Singletons.Prelude

	data Format = Lit Symbol \| Str \| Shown Type

	# Use envFrom to load Secrets and ConfigMaps into environment variables

	apiVersion: apps/v1beta2
	kind: Deployment
	metadata:
	name: mans-not-hot
	labels:
	app: mans-not-hot
	spec:
	replicas: 1

	-- stack --resolver lts-10.0 script
	{-# LANGUAGE DeriveGeneric #-}
	{-# LANGUAGE FlexibleContexts #-}
	import qualified Data.Aeson as Json
	import Data.Aeson.Encode.Pretty (encodePretty)
	import Data.ByteString (ByteString)
	import Data.ByteString.Lazy (writeFile)
	import Data.Colour.SRGB (sRGB24)
	import qualified Data.CSV.Conduit as Csv
	import qualified Data.CSV.Conduit.Conversion as Csv

	{-\|
	- Example of using free constructions to build a flexible little compiler.
	-
	- The goal here is not necessarily efficiency but readability and flexibility.
	-
	- The language grammar is represented by an ADT; however, instead of
	- recursively referring to itself it instead references a type variable.
	-
	- We derive instances of 'Functor' and 'Traversable' for this type.
	-