Re: [Caml-list] Frustrated Beginner

[Tyler Eaves <tyler@ml1.net>]

[-- Attachment #1: Type: text/plain, Size: 1857 bytes --]


On Dec 23, 2003, at 1:53 AM, Dustin Sallings wrote:

>
> On Dec 22, 2003, at 22:26, Tyler Eaves wrote:
>
> (I'm sending this back to the list because, as you pointed out, there 
> were a few problems with that example, so here's one for the 
> archives).
>
>> Okay, so far so good. I take it that in O'Caml the overhead of a 
>> function call is much less than in, say, C? Otherwise this approach 
>> would seem to be rather inefficient.
>
> 	Well, the short answer is that that's not a function call.  :)  See 
> tail-recursion.
>
> 	It's also not the best example since it was so simple and didn't 
> return anything useful.  Consider this implementation of fold (roughly 
> translating it in this email from a scheme version I wrote on my 
> palm):
>
> let rec fold f init lst =
>     match lst with
>           [] -> init
>         | h::t -> fold f (f init h) t
> ;;
>
> 	If you're not familiar with fold, here's an example:
>
> fold (fun v c -> c + v) 0 [1;2;3;4;5;6;7;8;9;10]
>
> 	That invocation returns 55.  Basically, the function is called for 
> each value in the list (v) and the current value is passed in along 
> with the current value during the calculation (c).  When it gets to 
> the end (list is []), you return the init value.  Otherwise, you apply 
> the function.
>
> 	Note that this function could also be written as follows (and 
> probably would be):
>
> let rec fold f init = function
>       [] -> init
>     | h::t -> fold f (f init h) t
> ;;

This makes since in general. I'm guess h and t correspond to the head 
and tail of the lift. It'll probably make more sense tomorrow. It's 
2:11 here, and I'd planned to be asleep two hours ago. The replies have 
kept me up ;)

Based on what I've learned, I've tried to write a simple prime number 
finder. It doesn't actually *work* or anything (Syntax Error on line 
23, can't figu

[-- Attachment #2: primes.ml --]
[-- Type: application/octet-stream, Size: 690 bytes --]

(*  primes.ml
    build a list of prime numbers.
    Tyler Eaves <tyler@ml1.net> 
    Very naive and stupid algortihmn.
    It tries taking the modulo of each
    known prime with the test number.
    If modulo = 0 for any number, the
    test is not prime.
    *)
   
let primes = [2];;

(* Modulo tester *)
let fmod x y = x mod y;;

let rec isprime n = (
  let test = List.map (fmod n) primes;
  let testa = Array.of_list test;
  let testa = Array.sort compare testa;
  if testa.(0) = 0 then
    (* Not prime *)
    Printf.printf "%d is not prime.\n" n
    else 
    begin
    Printf.printf "%d IS PRIME!!\n" n;
    let primes = n :: primes 
    end
   );
  isprime n+1
  ;;

isprime 3;;

[-- Attachment #3: Type: text/plain, Size: 100 bytes --]

re out why...), but I think I've figured some of this stuff out, kinda. 
I'm encouraged at least :)