FP intro night (my Scheme stuff)

[Strike]

In honor of what became sort of the ad hoc "Functional Programming night" in #coderforums, I decided to do all the stuff that ink and Vince and I were working out in Haskell .. in Scheme as well :) I actually even got one function done in Scheme that we haven't worked out how to do in Haskell yet. Anyway, here are the snippets for:
* factorial - a tail-recursive implementation
* mymap - a map rewrite
* mult - basically the equivalent of "folding" the multiplication operator a cross a list
* myfilter - a filter rewrite (Scheme only, so far)

factorial.scm

(define (factorial x)
(if (= x 0)
1
(* x (factorial (- x 1)))))


mymap.scm

(define (mymap func ls)
(if (null? ls)
'()
(cons (func (car ls)) (mymap func (cdr ls)))))


mult.scm

(define (mult ls)
(cond
((null? ls)
1)
((= 1 (length ls))
(car ls))
(#t
(* (car ls) (mult (cdr ls))))))


myfilter.scm

(define (myfilter test? ls)
(cond
((null? ls)
'())
(else
(if (test? (car ls))
(cons (car ls) (myfilter test? (cdr ls)))
(myfilter test? (cdr ls))))))


This was a lot of fun. Kind of like XP's "Pair programming" in a way, except we had 3 people. We all had varying levels of familiarity, and they played off of each other well. I'd love to do this again some other time.

[GnuVince]

Definitly should do it again. I'll do these scheme examples in O'Caml today

[GnuVince]

OK, I got the functions, here they are:


let rec fact n =
if n <= 1 then 1
else n * fact (n-1);;

let rec my_map func lst = match lst with
| [] -> []
| h::t -> (func h)::(my_map func t);;

let rec mult lst = match lst with
| [] -> 1
| h::t -> h * mult t;;

let rec my_filter cond lst = match lst with
| [] -> []
| h::t -> if cond h then h::my_filter cond t else my_filter cond t;;

[bwkaz]

Even though I wasn't there, I'd volunteer to do these all in Common Lisp. Except for the fact that that would be trivially easy, considering Scheme and clisp are so close -- what I would come up with is only slightly syntactically different from the Scheme stuff here...

Ah well.

[inkedmn]

Strike, Vince:

thanks again for all your help and for taking the time to explain things to me REPEATEDLY :)

i'm thinking we could do it again either tonight or tomorrow night...

same time, same place? ;)

[GnuVince]

Oh, here's uniq:


let rec uniq lst = match lst with
| [] -> []
| h::t -> if (List.mem h t) then
h::uniq (List.filter ((<>) h) t)
else
h::uniq t;;

[GnuVince]

What time was it again? We're in 3 different time zones... But yeah, I'd do it again tonight. You could try to write foldl and foldr functions

[GnuVince]

My very own fold left and fold right functions:

let rec foldl f acc lst = match lst with
| [] -> acc
| h::t -> foldl f (f acc h) t;;

let rec foldr f lst acc = match lst with
| [] -> acc
| h::t -> f h (foldr f t acc);;

[jamessan]

I just had to write foldl and foldr functions for my scheme class, although the foldr function could recurse on the function itself. Instead you had to use 'let'.

[PrBacterio]

Originally posted by Strike
* factorial - a tail-recursive implementation

So - where is it? Come on don`t tease us - show it to us :)

[GnuVince]

PrBacterio: ;) I'll make mine in O'Caml tail-recursive


let fact n =
let fact_aux acc n =
if n <= 1 then acc else fact_aux (n*acc) (n-1)
in
fact_aux 1 n;;

[PrBacterio]

Originally posted by GnuVince
PrBacterio: ;) I'll make mine in O'Caml tail-recursive

That`s better 8)

Here it is in Scheme for completeness´ sake:
(define (factorial n)
(let iter ((r 1) (n n))
(if (> n 1)
(iter (* r n) (- n 1))
r)))

Also, there`s nobody in #coderforums (on irc.openprojects.net, right?), I`m all alone in there right now :(

[GnuVince]

We switched servers. We're on #coderforums on irc.oftc.net

[Strike]

Ah yeah, I didn't make it tail-recursive though I'd planned on it. Whoops. Tyop.

[Strike]

Okay, using the filter function from above (renamed to just filter since that's not a built-in):
uniq

(load "filter.scm")

(define (not-equal num)
(lambda (num2)
(not (equal? num num2))))

(define (uniq ls)
(cond
((null? ls)
'())
(else
(cons (car ls) (uniq (filter (not-equal (car ls)) (cdr ls)))))))

I could selectively apply the filter by using member? (thanks, jamessan), but I was lazy :)

(edit) code tags are good