Sean Parsons seanparsons

## Graph.hs
#! /usr/bin/env nix-shell
#! nix-shell -p "haskellPackages.ghcWithPackages (pkgs: with pkgs; [])" -i runhaskell

import qualified Data.Array as A
import           Data.List  (find, inits)

type J r x = (x -> r) -> x

data R = Dist Integer
       | Infinity deriving Eq

## scratch.u
normalPage : Html -> Text
normalPage page =
  use Text ++
  "<!doctype html>" ++ html.toText page

name : Text -> Attribute
name = Attribute "name"

type TaskAttempt
  = { difficulty : Nat, skills : Nat, assets : Nat, effort : Nat }

## gist:da84d5a3b7b3cdd10daa1761358398d1
root@tower /e/nixos (master)# nix-store --debug --verbose --add-fixed sha256 rns_321_linux_x86_64.tar.gz
acquiring write lock on '/nix/var/nix/temproots/276929'
locking path '/nix/store/rkh6ijmm6qr7n8alpkhmzdj6ggrc7rdi-rns_321_linux_x86_64.tar.gz'
lock acquired on '/nix/store/rkh6ijmm6qr7n8alpkhmzdj6ggrc7rdi-rns_321_linux_x86_64.tar.gz.lock'
lock released on '/nix/store/rkh6ijmm6qr7n8alpkhmzdj6ggrc7rdi-rns_321_linux_x86_64.tar.gz.lock'
error: opening file '/nix/store/rkh6ijmm6qr7n8alpkhmzdj6ggrc7rdi-rns_321_linux_x86_64.tar.gz': No such file or directory

## default.nix
{}:

let
  config = {
    allowUnfree = true;
  };
  bootstrap = import <nixpkgs> { };
  nixpkgs = builtins.fromJSON (builtins.readFile ./nixpkgs.json);
  nixpkgssrc = bootstrap.fetchFromGitHub {
    owner = "NixOS";

## gist:e80f2c65a3cbc8c36c21632a0eaeed88
It suffers from similar problems to Scala, where it tries to blend OO concepts in with FP concepts.
Variance is where this flares up terribly because it doesn't provide any explicit support for covariance or contravariance.
You end up with invariance and subtyping in a bunch of places which is not a nice combination.

Protocols like Equatable and Hashable are implemented with compiler magic for arrays and tuples.
Which means that you run into trouble with generic functions that say accept two instances of the same type which is Equatable if you pass an array of ints.
You can't say "for a List if the elements are Equatable the List is equatable" IIRC.
This one annoys me no end as we've had to fudge our way around it several times on the same project.

For some reason that eludes me, Optional<T> is given all sorts of special case syntax ("if let" and "guard let") which is like a crap version of "for yield" from Scala or do notation in Haskell that only works on that.

## keybase.md

      
              1 file
            
          
              0 forks
            
          
                0 comments
              
            
              0 stars
            
          
                seanparsons
                / keybase.md
            
            
              Created
              October 10, 2017 16:37
            
          
    Keybase proof

I hereby claim:

I am seanparsons on github.
I am seanparsons (https://keybase.io/seanparsons) on keybase.
I have a public key whose fingerprint is B38A 94B9 204E 4D58 8085  71EE 0577 F744 BE6D 8619

To claim this, I am signing this object:

  
## pifromrandomnumbers.hs
#!/usr/bin/env stack
-- stack --resolver lts-8.5 --nix runghc --package random
-- Requires the Haskell build tool Stack to be installed: https://docs.haskellstack.org/en/stable/README/
-- Create this file and make it executable using "chmod u+x pifromrandomnumbers.hs"
-- and run it with "./pifromrandomnumbers.hs" from a terminal.
{-# LANGUAGE StrictData #-}
{-# LANGUAGE Strict #-}

import System.Random

## Error output
  Could not match type

    { "third" :: Map t0 t1
    | t2
    }

  with type

    Model


## servant-cookie.hs
type Cookie = Maybe Text

-- 'myAppExecutor' is the brains of the server where all the magic happens.
serverMonadToHandler' :: ServerResources -> Cookie -> forall a. ServerMonad a -> Handler a
serverMonadToHandler' resources cookie serverMonad = foldFree (myAppExecutor resources cookie) serverMonad

serverMonadToHandler :: ServerResources -> Cookie -> ServerMonad :~> Handler
serverMonadToHandler resources cookie = Nat $ serverMonadToHandler' resources cookie

-- 'MyAppApi' is the type that represents the endpoints handled by this server.

## shell.nix
let
  pkgs = import <nixpkgs> {};
  name = "test";
in pkgs.myEnvFun {
  buildInputs = [
  	pkgs.haskell.packages.ghcjs.ghcWithPackages(p: with p; [ ghcjs-base ghcjs-dom lens text ])
  	pkgs.nodejs
  ];
  inherit name;
}
	#! /usr/bin/env nix-shell
	#! nix-shell -p "haskellPackages.ghcWithPackages (pkgs: with pkgs; [])" -i runhaskell

	import qualified Data.Array as A
	import Data.List (find, inits)

	type J r x = (x -> r) -> x

	data R = Dist Integer
	\| Infinity deriving Eq
	normalPage : Html -> Text
	normalPage page =
	use Text ++
	"<!doctype html>" ++ html.toText page

	name : Text -> Attribute
	name = Attribute "name"

	type TaskAttempt
	= { difficulty : Nat, skills : Nat, assets : Nat, effort : Nat }
	root@tower /e/nixos (master)# nix-store --debug --verbose --add-fixed sha256 rns_321_linux_x86_64.tar.gz
	acquiring write lock on '/nix/var/nix/temproots/276929'
	locking path '/nix/store/rkh6ijmm6qr7n8alpkhmzdj6ggrc7rdi-rns_321_linux_x86_64.tar.gz'
	lock acquired on '/nix/store/rkh6ijmm6qr7n8alpkhmzdj6ggrc7rdi-rns_321_linux_x86_64.tar.gz.lock'
	lock released on '/nix/store/rkh6ijmm6qr7n8alpkhmzdj6ggrc7rdi-rns_321_linux_x86_64.tar.gz.lock'
	error: opening file '/nix/store/rkh6ijmm6qr7n8alpkhmzdj6ggrc7rdi-rns_321_linux_x86_64.tar.gz': No such file or directory
	{}:

	let
	config = {
	allowUnfree = true;
	};
	bootstrap = import <nixpkgs> { };
	nixpkgs = builtins.fromJSON (builtins.readFile ./nixpkgs.json);
	nixpkgssrc = bootstrap.fetchFromGitHub {
	owner = "NixOS";
	It suffers from similar problems to Scala, where it tries to blend OO concepts in with FP concepts.
	Variance is where this flares up terribly because it doesn't provide any explicit support for covariance or contravariance.
	You end up with invariance and subtyping in a bunch of places which is not a nice combination.

	Protocols like Equatable and Hashable are implemented with compiler magic for arrays and tuples.
	Which means that you run into trouble with generic functions that say accept two instances of the same type which is Equatable if you pass an array of ints.
	You can't say "for a List if the elements are Equatable the List is equatable" IIRC.
	This one annoys me no end as we've had to fudge our way around it several times on the same project.

	For some reason that eludes me, Optional<T> is given all sorts of special case syntax ("if let" and "guard let") which is like a crap version of "for yield" from Scala or do notation in Haskell that only works on that.
	#!/usr/bin/env stack
	-- stack --resolver lts-8.5 --nix runghc --package random
	-- Requires the Haskell build tool Stack to be installed: https://docs.haskellstack.org/en/stable/README/
	-- Create this file and make it executable using "chmod u+x pifromrandomnumbers.hs"
	-- and run it with "./pifromrandomnumbers.hs" from a terminal.
	{-# LANGUAGE StrictData #-}
	{-# LANGUAGE Strict #-}

	import System.Random
	Could not match type

	{ "third" :: Map t0 t1
	\| t2
	}

	with type

	Model
	let
	pkgs = import <nixpkgs> {};
	name = "test";
	in pkgs.myEnvFun {
	buildInputs = [
	pkgs.haskell.packages.ghcjs.ghcWithPackages(p: with p; [ ghcjs-base ghcjs-dom lens text ])
	pkgs.nodejs
	];
	inherit name;
	}