Beginner's question.

Beginner's question.

[Alexander A. Vlasov]

Hello.

I'm making my first steps in OCaml and trying (just for expirience) to
implement a simple function which applies given function to all elements
of given list.
I successfully did it using if/then/else

let rec map func lst =
        if lst = [] then []
        else (func (List.hd lst)) :: (map func (List.tl lst))
;;

But I can't do it using pattern matching -- following function doesn't
work

let rec mapm func lst = function
        | ( _, [] ) -> []
        | ( _, head::tail ) -> (func head) :: (mapm func tail)
;;

I get type mismatch error: characters 39-55:
This expression has type 'a * 'b list -> 'c list but is here used with
type  'c list

But wait, ``map func (List.tl lst)''  in first example has the same
type, isn't it?
Both right parts in first and second example are, say, transformers from
a tuple ( something, list-of-something-else ) to list-of-something-else.

I understand that I missed something, so please tell me what.
and... thank you for your patience 8)



-- 
Best regards,
Alexander A. Vlasov.

Re: [Caml-list] Beginner's question.

[Luc Maranget]

> Hello.
> 
> I'm making my first steps in OCaml and trying (just for expirience) to
> implement a simple function which applies given function to all elements
> of given list.
> I successfully did it using if/then/else
> 
> let rec map func lst =
>         if lst = [] then []
>         else (func (List.hd lst)) :: (map func (List.tl lst))
> ;;
> 
> But I can't do it using pattern matching -- following function doesn't
> work
> 
> let rec mapm func lst = function
>         | ( _, [] ) -> []
>         | ( _, head::tail ) -> (func head) :: (mapm func tail)
> ;;
> 
> I get type mismatch error: characters 39-55:
> This expression has type 'a * 'b list -> 'c list but is here used with
> type  'c list
> 
> But wait, ``map func (List.tl lst)''  in first example has the same
> type, isn't it?
> Both right parts in first and second example are, say, transformers from
> a tuple ( something, list-of-something-else ) to list-of-something-else.
> 

Basically no, your function is defined as taking three arguments
func, lst and one anonymous argument to be matched,
where, in fact, you want to match over 'lst'.


I sugest that, to begin with caml, you stick to explict
match constructs, avoiding matchings introduced by function

 let rec mapm func lst = match lst with
         | [] -> []
         | head::tail -> (func head) :: (mapm func tail)
 ;;


Oh well, and with function :

let rec mapm func = function 
         | [] -> []
         | head::tail -> (func head) :: (mapm func tail)
 ;;
> 
> 
> 
> -- 
> Best regards,
> Alexander A. Vlasov.
> 
> _______________________________________________
> Caml-list mailing list. Subscription management:
> http://yquem.inria.fr/cgi-bin/mailman/listinfo/caml-list
> Archives: http://caml.inria.fr
> Beginner's list: http://groups.yahoo.com/group/ocaml_beginners
> Bug reports: http://caml.inria.fr/bin/caml-bugs

-- 
Luc Maranget

Re: [Caml-list] Beginner's question.

[Damien Doligez]

On Oct 27, 2005, at 15:41, Luc Maranget wrote:

> I sugest that, to begin with caml, you stick to explict
> match constructs, avoiding matchings introduced by function

As a seasoned OCaml programmer that's what I do anyway, because it
makes my life easier when using the debugger...

-- Damien

Re: [Caml-list] Beginner's question.

[Jean-Christophe Filliatre]

Alexander A. Vlasov writes:
 > I'm making my first steps in OCaml and trying (just for expirience) to
 > implement a simple function which applies given function to all elements
 > of given list.
 > 
 > But I can't do it using pattern matching -- following function doesn't
 > work
 > 
 > let rec mapm func lst = function
 >         | ( _, [] ) -> []
 >         | ( _, head::tail ) -> (func head) :: (mapm func tail)

"function"  defines a  function over  an anonymous  argument  which is
immediatly  filtered  by the  patterns.   So  your  function mapm  has
actually  3 arguments,  the 3rd  of which  is a  pattern. I  guess you
intended  to do some  pattern matching  on the  two arguments  of your
function, which would be

	let rec mapm func list = match func, list with
	  | _, [] -> []
	  | _, head :: tail -> func head :: mapm func tail

but there is no need to do some pattern matching on the function, so

	let rec mapm func = function
	  | [] -> []
	  | head : :tail -> func head :: mapm func tail

would equally  do, which is  (regardless of the evaluation  order) the
code of List.map that you can find in the ocaml standard library.

I you don't mind  a comment: I think there is also  a mailing list for
ocaml beginners.

Best regards,
-- 
Jean-Christophe Filliâtre (http://www.lri.fr/~filliatr)