Marty Stumpf thealmarty

Software engineer. Loves FP Haskell Coq Agda PLT. Always learning. Prior: Economist. Vegan, WOC in solidarity with POC.

thealmarty / fact_s.hs

Last active January 28, 2019 23:56

Factorial function in Haskell.

	--Factorial function, short/standard version.

	fact 0 = 1
	fact n = n * fact (n - 1)

	main = do
	print (fact 5)

thealmarty / fact.hs

Created January 24, 2019 23:34

The factoria function using hylomorphism in Haskell.

	import Data.List --To enable unfoldr.
	fact n =
	foldr
	(*) --Function input
	1 --Base case
	(unfoldr --List input
	(\n -> if n==0 then Nothing else Just (n, n-1))
	n)

	--Print out example results of the fact fn.

thealmarty / fact.ml

Last active January 24, 2019 23:00

The factorial function using hylomorphism in OCaml.

	let rec unfold p g b =
	if p b then [] else
	(match g b with (a, bprime) ->
	a :: unfold p g bprime)

	let fact n =
	List.fold_right
	(* The fold's function input is the times function.*)
	(fun x y -> x * y)
	(* The fold's list input is the result of this unfold. *)

thealmarty / zip3.ml

Created January 1, 2019 23:28

zip3 function in OCaml.

	(* Define the unfold function that takes 3 inputs.*)
	let rec unfold p g b1 b2 b3 =
	if p b1 b2 b3 then [] else
	(match g b1 b2 b3 with (a, (b1prime, b2prime, b3prime)) ->
	a :: unfold p g b1prime b2prime b3prime)
	;;

	(* Define the zip3 function.*)
	let zip3 = unfold
	(* Define p.*)

thealmarty / zip_sum.ml

Created January 1, 2019 23:14

A modified zip function in OCaml that sums up the two elements of the input lists in the second item of the output tuple.

	(* Define the unfold function.*)
	let rec unfold p g b1 b2 =
	if p b1 b2 then [] else
	(match g b1 b2 with (a, (b1prime, b2prime)) ->
	a :: unfold p g b1prime b2prime)
	;;

	(* Define the zip_sum function.*)
	let zip_sum = unfold
	(* Define p.*)

thealmarty / zip_repeat_input2.ml

Created January 1, 2019 23:06

A modified zip function in OCaml that output a list with the second input list's element repeated.

	(* Define the unfold function.*)
	let rec unfold p g b1 b2 =
	if p b1 b2 then [] else
	(match g b1 b2 with (a, (b1prime, b2prime)) ->
	a :: unfold p g b1prime b2prime)
	;;

	(* Define the zip_repeat_input2 function.*)
	let zip_repeat_input2 = unfold
	(* Define p.*)

thealmarty / zip_no_zero.ml

Created January 1, 2019 22:45

A zip function in OCaml that stops zipping when any of the input lists' first element is zero, or when any of the input list is empty.

	(* Define the unfold function.*)
	let rec unfold p g b1 b2 =
	if p b1 b2 then [] else
	(match g b1 b2 with (a, (b1prime, b2prime)) ->
	a :: unfold p g b1prime b2prime)
	;;

	(* Define the zip_no_zero function.*)
	let zip_no_zero = unfold
	(* Define p.*)

thealmarty / zip.ml

Last active January 3, 2019 19:57

The zip function in OCaml, defined with unfold.

	(* Define the unfold function.*)
	let rec unfold p g b1 b2 =
	if p b1 b2 then [] else
	(match g b1 b2 with (a, (b1prime, b2prime)) ->
	a :: unfold p g b1prime b2prime)
	;;

	(* Define the zip function.*)
	let zip = unfold
	(* Define p.*)

thealmarty / zip_sum.hs

Created January 1, 2019 19:14

A modified zip function in Haskell that sums up the two elements of the input lists in the second item of the output tuple.

	--As modified from the Prelude:
	zip_sum ::(Num a, Eq a)=> [a] -> [a] -> [(a,a)]
	zip_sum [] _bs = []
	zip_sum _as [] = []
	zip_sum (a:as) (b:bs) = (a, (a + b) ) : zip_sum as bs

	main = do
	print (zip_sum [0,1,2] [1,2,3])
	print (zip_sum [1,2,3,4,0,5,6] [1,2,3,4,5,6,0])

thealmarty / zip_repeat_input2.hs

Created January 1, 2019 18:57

A modified zip function in Haskell that output a list with the second input list's element repeated.

	--As modified from the Prelude:
	zip_repeat_input2 ::(Num a, Eq a, Num b, Eq b)=> [a] -> [b] -> [(a,b,b)]
	zip_repeat_input2 [] _bs = []
	zip_repeat_input2 _as [] = []
	zip_repeat_input2 (a:as) (b:bs) = (a,b,b) : zip_repeat_input2 as bs

	main = do
	print (zip_repeat_input2 [0,1,2] [1,2,3])
	print (zip_repeat_input2 [1,2,3,4,0,5,6] [1,2,3,4,5,6,0])