give me some scheme

help me out /prog/, give me some programs to write in scheme, practice

implement a tail-recursive uniq

Implement loeb.

>>2
alright

(define repeat?
  (lambda (elem lst)
    (cond ((empty? lst) #f)
          ((= elem (first lst)) #t)
          (else (repeat? elem (rest lst))))))

(define uniq-iter
  (lambda (ret lst)
    (if (empty? lst)
        ret
        (uniq-iter (if (repeat? (first lst) ret)
                       ret
                       (cons (first lst) ret))
                   (rest lst)))))

(define uniq
  (lambda (lst)
    (reverse(uniq-iter (list (first lst)) lst))))

(reverse(uniq-iter (list (first lst)) lst))))

edit: (reverse(uniq-iter (list) lst))))

>>3
what is loeb?

>>6
LOEB LOEB LOEB

>>6
loeb = fix (fmap . flip id =<<)

>>6
It's what Haskell programmers wish their mothers did for them.

>>1
Project Euler. Anything math based, really.

GIVE ME SOME DUBZ

loeb (flip flip)

>>8
How does flip id typecheck? It seems simple enough looking at the definition of flip, but I don't see how the types match up.

loeb, loeb, loeb, loeb, loeb, loeb, loeb, loeb, loeb.
There's nothing you can do that can't be done.
Nothing you can sing that can't be sung.
Nothing you can say but you can learn how to play the game
It's easy.
There's nothing you can make that can't be made.
No one you can save that can't be saved.
Nothing you can do but you can learn how to be you
in time - It's easy.

All you need is loeb, all you need is loeb,
All you need is loeb, loeb, loeb is all you need.
loeb, loeb, loeb, loeb, loeb, loeb, loeb, loeb, loeb.
All you need is loeb, all you need is loeb,
All you need is loeb, loeb, loeb is all you need.
There's nothing you can know that isn't known.
Nothing you can see that isn't shown.
Nowhere you can be that isn't where you're meant to be.
It's easy.
All you need is loeb, all you need is loeb,
All you need is loeb, loeb, loeb is all you need.
All you need is loeb (all together now)
All you need is loeb (everybody)
All you need is loeb, loeb, loeb is all you need.

>>13

flip :: (a -> b -> c) -> b -> a -> c
id :: a -> a
id@a->b :: (a -> b) -> a -> b
flip id@a->b :: a -> (a -> b) -> b

(\f a b -> f b a) id
(\a b -> id b a)
(\a b -> b a) :: a -> (a -> b) -> b

>>13
it's the same as flip ($) or \ x f -> f x.

>>15
Yeah, I figured it out after I posted. I just didn't realize that it would treat id as (a -> b) -> a -> b. Thanks.

>>16
Not really, because id (usually) only takes one argument. That's what was confusing me.

>>17
In Haskell, functions that take multiple arguments are function-returning functions (they are ``curried''). There's a reason for all the arrows in the types. That's why you can treat id as (a -> b) -> a -> b.

>>18
I know that, and I don't see how currying is related unless you're talking about why (a -> b) -> a -> b is the same as (a -> b) -> (a -> b), which I understand. I didn't know that it would substitute a -> b for a in the type signature of id.