Back to Questions
1.0k
views2
comments
Only simple variable patterns can be bound in 'let rec' constructs
f#

I'm trying to use the below code to read an Integer from a List of Chars, but it gives me the error mentioned in the subject. Can someone please explain to me:

  1. What the "Only simple variable patterns can be bound in 'let rec' constructs" means
  2. Possible changes I can make to the below function to handle my problem more eligantly

  3. Other ways of extracting Itegers from Char Lists that might be more appropriate.
    [Note: Int.Parse doesn't work for me becuase it will fail if

    there is garbage at the end of the integer to be parsed

    i.e. "385)" will cause System.Int64.Parse to fail.

1
2
3
4
5
6
7
8
9
10
11
12
13
14

let rec readInteger l, ?curVal : int64 = 
    match l with 
    | [] -> 0L
    | c :: rest -> 
        let curValCopy = defaultArg curVal 0L
        if System.Char.IsDigit(c) then
            let curDigitVal = System.Int64.Parse(c.ToString())
            let curIncrement = curValCopy + curDigitVal
            if System.Char.IsDigit(rest.Head) then                
                readInteger(rest, curIncrement*10)
            else
                curIncrement
        else
            0L

Best,

Boger83
Note:
I had to repost this in a Virtualized Copy of FireFox 3.5.9 on OpenSuSE 11.2 with Win XP Pro as host, because there appears to be a Win XP Pro Chome bug that is stripping spaces from code that is posted to this forum.

.

There are several things wrong with your code. The specific error that you're getting is because your declaration is malformed; you want to do either "let readInteger l ?curVal ..." or "let readInteger (l, ?curVal) ...", but your current placement of the comma won't work.

However, once you try these alternatives you'll see that neither of them will work either. Optional parameters shouldn't be tupled, so the second possibility won't work. However, even in the first case, optional parameters can only be used with members of types, not with let-bound functions, so that also won't work.

There are at least a few other issues; 10 is an integer literal, not an int64 literal, so you want to use 10L instead. Also, in the case where the list contains exactly one character, "rest" is an empty list, so calling rest.Head will throw. Instead, I think it would make more sense to make the recursive call no matter what, but to have the empty list case return currVal instead of 0L.

Here's how I'd write the function: 

1
2
3
4

let readInteger s =
  s
  |> Seq.takeWhile System.Char.IsDigit
  |> Seq.fold (fun n c -> n*10L + (int64 c - int64 '0')) 0L
By on 5/2/2010 1:53 PM ()

The specific error that you're getting is because your declaration is malformed; you want to do either "let readInteger l ?curVal ..." or "let readInteger (l, ?curVal) ...", but your current placement of the comma won't work.

Thanks Man!!! I completely misunderstood the format of parameter passing.

"let readInteger l curVal" works well for me except that curVal isn't optional anymore, but that isn't a significant issue for me.

However, once you try these alternatives you'll see that neither of them will work either. Optional parameters shouldn't be tupled, so the second possibility won't work. However, even in the first case, optional parameters can only be used with members of types, not with let-bound functions, so that also won't work.

kvb is that Man!!! I just observed what you described tonight. Thanks for the tip!!!

10 is an integer literal, not an int64 literal, so you want to use 10L instead.

Ooops!!! Thanks for pointing this out!

Also, in the case where the list contains exactly one character, "rest" is an empty list, so calling rest.Head will throw.

Very Good Point!!! I have put in a hack to protect my function. I simply put in another ugly if statement to check to make sure "rest" isn't empty before I dereference it.

Instead, I think it would make more sense to make the recursive call no matter what, but to have the empty list case return currVal instead of 0L.

It probably would but my tiny brain never figured that out, so I used your other ideas and moved on. I ran a few "unit" like tests and the function seems to be behaving as expected.

Here's how I'd write the function: 

1
2
3
4

let readInteger s =
  s
  |> Seq.takeWhile System.Char.IsDigit
  |> Seq.fold (fun n c -> n*10L + (int64 c - int64 '0')) 0L

That is breathtakingly beautiful!!! I seemed to have forgotten how "fold" works. It's use certainly makes your solution much more aesthetic than mine!

KVB is the Man!!!

By on 5/3/2010 7:57 PM ()

    Topic tags

    IntelliFactory Offices Copyright (c) 2011-2012 IntelliFactory. All rights reserved.
    Home | Products | Consulting | Trainings | Blogs | Jobs | Contact Us | Terms of Use | Privacy Policy | Cookie Policy     		Built with WebSharper