PureBasic Forum

Hi All,

I have a request for a future update to PureBasic.
I use both PureBasic, and GLBasic, each for different types of projects.

The most recent major update to GLBasic is a feature I have come to like very much.
It now allows Functions inside of Types.
This allows for a (sort of) OOP approach to organizing code, without added complexity.
I find it allows me to make nice, self contained little code objects, which are very suited to re-usability, and still think and write in a procedural way.

Would it be possible to add such a feature to PureBasic.
I know, OOP is entirely possible with Prototypes, Interfaces, Function Pointers, etc.
This proposed method though, while definitely not adhering to all the concepts of OOP, it borrows just enough to be useful, while not becoming cumbersome for amateurs such as myself.

Here is how such an implementation may look (borrowed directly from the new version of GLBasic, but adapted to PureBasic syntax).



I understand that Fred is not interested in adding full OOP support to PureBasic, and if this idea is not acceptable, I of course fully understand.
I would be very pleased though of course if it is deemed a good idea, and implemented.

Thanks in advance.
Dave

PureBasic-Version is a bit larger
Only as hint:

I prefer the syntax suggested by Aonym
very good idea Aonym


Aonym 15 lines ( 16 with debug line )
ts-soft 22 lines .. hum !

Thank You ts-soft,

I appreciate you time and effort to show me a reasonable solution, and it will certainly be useful to me.
I copied and pasted your sample into a PB template, so I can refer to it later and use this.
It is not quite as tidy as the way GLB handles it, but certainly simple enough compared to other solutions I have seen.

I do still stand by the original request, as I do see some disadvantages to the approach from ts-soft.
For example, in GLB, you may have more than one type(structure) which have internal functions with the same name, yet variations to the code within.
For example, foo\bar may do (x*y)+z, and goo\bar may do (x*y)+z^2.
I do understand that this can also be done, by pointing from members with the same name to procedures with different names.
However, this will still result in much more complex code, while by actually writing the procedures within the structures keeps everything contained, and easily portable IMO.

regards,
Dave

Thanks dobro,

I am glad to know my request would be appreciated by more users than just myself (well one more so far)

regards,
Dave

I too like your idea! It is clean and simple!

I'd vote for that too.

I would like to be able to use such things.

While, to my understanding, it would basically work the same way
as in the current PB way that ts-soft suggested
(thank you ts-soft for giving that example btw.),
I would use aonyn's way if I could.

I would not want to clutter my code with extra prototypes,
extra strangely named procedures and setting references ...
and that even outside of the area,
where those parts really belong too...

This also seems feasible to me.

A nice way to introduce OOP to PB,
without loosing anything.

Thank you for that suggestion, aonyn.

Hi All,

Well I am glad the suggestion seems to be welcomed.

As I said in my first post, this has been done by Gernot at GLBasic, and it is a feature I have come to like very much.
He like Fred is resistant to taking GLBasic far into the realm of OOP.
This solution I think was a compromise with his users who were asking for OOP, and actually was at first a bit controversial on his forums.

In the end, now that it is implemented though, I get the impression that it is a widely liked and used feature.

regards,
Dave

Great topic!
Thanks ts-soft!
Your sample code really opened my eyes to some future simplification in this procedural world.

@aonyn - I also prefer your suggestion.
The prototypes and procedures and "@ assignments" are clumsy and would be neat and tidy in one structure(dare I say Class?) declaration.

I like the idea also.

Simon

I also like Aonym's syntax but I think the variation below is neater.

Nice version, than there is also less risk for huge structures due large procedures inside.
The code better be a easy to read as possible and this is a nice step, but the use of 'Declare' may not really fit perfectly.. maybe a new keyword?

...How is that different than the use of Prototypes in the Structure as ts-soft showed
I think keeping stuff between the Structure(or Class or Module) is more readable.
Maybe this can isolate(Private vs Global) the methods from the rest of the code also.

@[a]kj[67]
I agree with skywalk.
Why request a feature, that is allready there?

The title says it all: Procedures inside Structures.

Besides, the idea, that the code can be where it belongs,
(you seem to disagree with that)
this is the way, you don't need to worry about naming collisions.

With procedures in global space only,
like you suggested and what has allways been that way anyways,
the naming of them is of course also done completely in the global space.

It is different.

"Prototypes" is easier way to call libraries.
"Procedures inside a structure" its a partial way to emulate OOP.