Exercism: "Grains in Clojure"

This is my solution to the Grains problem in Clojure.

	(ns grains)
	(defn- grains []
	(letfn
	[(f [n]
	(seq [n (fn [] (f (* 2 n)))]))]
	(f 1N)))
	(defn- stream-for-n-steps [stream n]
	(letfn
	[(f [i stream-rest]
	(let
	[pair (stream-rest)]
	(when (not= i 0)
	(cons (first pair)
	(f (- i 1) (second pair))))))]
	(f n stream)))
	(defn square [sqr-num]
	(last (stream-for-n-steps grains sqr-num)))
	(defn total []
	(reduce + 0 (stream-for-n-steps grains 64)))

view raw grains.clj hosted with ❤ by GitHub

This solution is probably not idiomatic at all. I just wanted to use a stream like in my previous Racket solution to see how different would that be in Clojure.

This was the Racket version:

	#lang racket
	(define (grains)
	(letrec
	([f
	(lambda (n)
	(cons n
	(lambda () (f (* 2 n)) )))])
	(f 1)))
	(define (stream-for-n-steps stream n)
	(letrec ([f
	(lambda(i stream-rest)
	(if (= i 0)
	empty
	(cons (car (stream-rest))
	(f (- i 1) (cdr (stream-rest))))))])
	(f n stream)))
	(define (square sqr-num)
	(last (stream-for-n-steps grains sqr-num)))
	(define total-grains
	(lambda ()
	(foldr + 0 (stream-for-n-steps grains 64))))

view raw grains.rkt hosted with ❤ by GitHub

As you see they are quite different.

letfn is somehow equivalent to Racket's letrec.

My biggest problem was with cons because they behave different.

Whereas in Racket you can do:

> (cons 1 2)
'(1 . 2)

in Clojure an exception is raised when you try the same:

user=> (cons 1 2)
IllegalArgumentException 
Don't know how to create ISeq from: 
java.lang.Long  clojure.lang.RT.seqFrom (RT.java:505)

You need to write this instead:

user=> (cons 1 (cons 2 nil))
(1 2)

So in the end I used seq:

user=> (seq [1 2])
(1 2)

Another difference is that you have an integer overflow in Clojure unless you use BigInt, whereas in Racket number can be arbitrarily large.

Well, now that I've tried this. I'll try writing a more idiomatic version.

You can nitpick my solution here or see all the exercises I've done so far in this repository.