1. Sequences - parameter checking responsibility
- Posted by d a edmunds <dae at PACLINK.COM> Jun 30, 1997
- 647 views
I would like some opinions on coding style. Assume a global function which takes a sequence as a parameter, i.e., global function xyz (seq s) --- code end function Because a sequence is so generic, any sequence will pass type checking without necessarily being in the the correct form for that function. Should the responsibility beyond type checking belong to the function or to programmer who calls it? On the one hand, I like to see functions that are 'bullet-proof' -- if I pass the right 'type' of parameter to it, I want the function to handle all situations. On the other hand, with sequences, there can be an awful lot of checking that must be done, which can slow down the function. If the responsiblity is on the programmer who calls the function, where should the function writer store the information, so the programmer can code the sequence correctly? In my real-life example the sequence passed as the parameter must contain at least one, but may contain multiple sequences. Also the sequences within sequences must be composed of atoms, not other sequences. Thus these are all acceptable: xyz {"2"} xyz {"2", "5", "99"} xyz {"2", "5", "99", "20220"} A sequence containing atoms, is not acceptable xzy { 3, 4, "6"} -- not valid And this is not valid: xzy ( {"345, "567"}, "567"} -- not valid As far a type checking goes, the outer most brackets define both the valid and invalid parameters as 'sequences', so both pass through type checking. Also, if there were some terminology developed to describe these situations better, documentation would be clearer and less wordy. Comments? Suggestions? --dae at paclink.com--
2. Re: Sequences - parameter checking responsibility
- Posted by Ralf Nieuwenhuijsen <nieuwen at POP.XS4ALL.NL> Jun 30, 1997
- 629 views
- Last edited Jul 01, 1997
> Because a sequence is so generic, any sequence will pass type > checking without necessarily being in the > the correct form for that function. So make a type... > Should the responsibility beyond type checking belong > to the function or to programmer who calls it? That should be optional... If you use a type the programmer has a choice.. ..in developping time have type_check on. ..when your program is finished turn it off. If type_check is on, it will generate an error if the value passed is wrong. The advantage is you know you it's because of wrong arguments and not a bug in the routine... For speed, turn type check off when you KNOW you program will not give any errors. Setting type_check makes sure you get the right error message. A program isn't finished until there are no errors in it.. so.... here's your solution. BTW You should only check the value passed when it will produce an error if it's wrong. That's the rule... all values that do NOT generate an error should be allowed, you never know where you can use your function for later on. > On the other hand, with sequences, there can be an awful > lot of checking that must be done, which can slow down the > function. Yeah..but in design time...speed is not needed and when its finished put a without type_check on top of your program. > If the responsiblity is on the programmer who calls the > function, where should the function writer store the > information, so the programmer can code the sequence > correctly? Well, it will always generate an error the programmer should deal with, if its a type_check error you know that you gave bad values to your function. > In my real-life example the sequence passed as the parameter > must contain at least one, but may contain multiple sequences. > Also the sequences within sequences must be composed of atoms, > not other sequences. You mean 2D-sequences ? (Like images and stuff) I guess so... Here is what it should look like: In your program type: "with type_check" to turn it on (all calls after this will have their values checked.) "without type_check" to turn it off (all calls after this allow all objects) ----------- Code begins here: --------------------------------------- type 2D_Sequence (sequence s) for j = 1 to length(s) if sequence (s[j]) then return 0 end if end if return 1 -- Value ok end type global function xyz ( 2D_Sequence s ) -- code end function ------------------------------ Code ends here --------------------
3. Re: Sequences - parameter checking responsibility
- Posted by Lucius L Hilley III <luciuslhilleyiii at JUNO.COM> Jun 30, 1997
- 660 views
On Mon, 30 Jun 1997 12:58:49 -0700 d a edmunds <dae at PACLINK.COM> writes: >Thus these are all acceptable: > >xyz {"2"} >xyz {"2", "5", "99"} >xyz {"2", "5", "99", "20220"} > >A sequence containing atoms, is not acceptable >xzy { 3, 4, "6"} -- not valid > >And this is not valid: >xzy ( {"345, "567"}, "567"} -- not valid > >As far a type checking goes, the outer most brackets define both >the valid and invalid parameters as 'sequences', so both >pass through type checking. > >Also, if there were some terminology developed to describe these >situations better, documentation would be clearer and less >wordy. > >Comments? Suggestions? >--dae at paclink.com-- > If the programmer handles it then this code will take care of it. function xyz(sequence s) integer bad -- this loop checks for validity. bad = -1 for a = 1 to length(s) do if sequence(s[a]) then if sequence(s[a][1]) then return bad end if else return bad end if end for --(Your code goes here) return 0 end function sequence s --if good print 0 --if bad print -1 ? xyz ({"2"}) ? xyz ({"2", "5", "99"}) ? xyz ({"2", "5", "99", "20220"}) --A sequence containing atoms, is not acceptable ? xzy ({ 3, 4, "6"}) -- not valid --And this is not valid: ? xzy ({{"345, "567"}, "567"}) -- not valid
4. Re: Sequences - parameter checking responsibility
- Posted by Anders Eurenius <c96aes at OXE.CS.UMU.SE> Jul 01, 1997
- 697 views
> > In my real-life example the sequence passed as the parameter > > must contain at least one, but may contain multiple sequences. ^^^^^^^^^- I almost missed that... > > Also the sequences within sequences must be composed of atoms, > > not other sequences. ^^^^^^^^^^^^^^^^^^^ You missed this part, Ralf... > Here is what it should look like: > In your program type: If it looks like that, { {"345, "567"}, "567"} will pass... > ----------- Code begins here: --------------------------------------- > > type 2D_Sequence (sequence s) atom len len=length(s) if len<1 then return(0) end if > for j = 1 to length(s) if atom(s[j]) then return(0) end if for i= 1 to length(s[j]) do if sequence(s[j][i]) then return(0) end if end for > end for > return 1 -- Value ok > end type > > global function xyz ( 2D_Sequence s ) > -- code > end function > ------------------------------ Code ends here -------------------- I've been to lazy to write this for myself, but now I have it... >> Edmunds > Ralf Anders -------------------------------------------------------------- Anders Eurenius <c96aes at cs.umu.se> ICQ UIN:1453793 Computer Science/Engineering student at the university of Umea --------------------------------------------------------------