Hans Höglund hanshoglund

Finally Free

{-# LANGUAGE RankNTypes, DeriveFunctor, TypeOperators, KindSignatures, GADTs, DataKinds, MultiParamTypeClasses, FlexibleContexts, FlexibleInstances #-}
import Control.Applicative
import Data.Semigroup(Semigroup(..))

If you've programmed in Haskell you may have come across free construcions: free monoids, free monads, free applicatives and so on. But what does it actually mean for an object to be "free"?

See also https://en.wikibooks.org/wiki/Haskell

HS excercises

Basics

GHC CLI & Repl. Stack. Standard (strict) compiler flags to use.
1. Create a reproducible shell environment containing the packages network and warp using Stack (LTS, using astack.yaml file) or Nix (HEAD, using ghcWithPackages).
2. Start a REPL session (using ghci or stack repl) and import Warp in the REPL session.
3. Write and compile a Hello World program using ghc Hello.hs in the above environment

Import Warp and write a web server printing Hello, World! on localhost:SOMEPORT

	data Bar (xs :: [k]) where
	N :: Bar '[]
	C :: Bar (x : xs)
	class Foo xs where
	foo :: Bar xs

	Some instances for base:

	```haskell
	-- MonoidFromApplicative
	-- Example: undoing the Const applicative
	-- Takes [] to naturals with (+)
	newtype MFA f = MFA (f ())
	-- or?
	newtype MFA f = MFA (forall x . f x)
	instance Applicative f => Monoid (MFA f)

	- Connection: TCP
	- Framing/Call-Resp: HTTP1.1/2
	- Encryption: TLS
	- Auth
	- Server: TLS certificate
	- Client: JWT

	- Serialization: JSON?
	- Method name: Header/JSON frame
	- Errors: Header/JSON frame


	{-
	> :t PrimInt
	PrimInt :: Schema Integer

	> :t list PrimInt
	list PrimInt
	:: Schema
	(Fix
	(("Nil" ~~~ Const (Rec '[]))

	{-# LANGUAGE
	FunctionalDependencies,
	RankNTypes,
	NoMonomorphismRestriction,
	TypeOperators,
	TypeFamilies,
	TypeFamilyDependencies,
	TypeApplications,
	InstanceSigs,
	PolyKinds,

	> let f = fmap > :t (f f f f) (f f) (f f) (f f f f)
	> let f = flip > :t (f f f f) (f f) (f f) (f f f f)
	> let f = (.) > :t (f f f f) (f f) (f f) (f f f f)

	Prelude> let k = const
	Prelude> let f = flip
	Prelude> k f k k k k f k k k k f k k k $ 2
	?


	---
	Prelude> :t k
	k :: a -> b -> a
	Prelude> :t k k