Let's just say that in Red datatype of a "variable" is uniquely determined by value to which it refers.
actually in this case it would be of type block, if i use the raw datatype like num: integer! it is of type data type. I can just use a comment if that is all we have. But It would be nice if I could just declare it so that when I type help myobject I can get the correct datatype even if it has no initial value
And if you don't explicitly "point"
word! value to anything, it still points to a "default" value of type unset!.
So you can't "point" it to
none! value and say "point to none but report it as an integer!".
Ah ok, awesome! thanks @greggirwin! I haven't gone through the Red/System documentation yet
I don't necessarily want to initialize it. when I say none, I mean some representation of no initialized value ( like NULL ) not necessarily the Red type none!. I just figured out a ghetto solution other than comments is to go ahead and assign the variable the type I want it to be so that when I probe person it at least lists the type. Then I'll just set it to the appropriate type when I create the object
@phillvancejr adding clues that way is fine, just be aware that it doesn't provide any real protection, and you'll probably find other ways to achieve your goal as you get more familiar with Red.
for sure. In this instance I don't need it to actually type check anything. I just want to annotate the code so that if I take a break from the project I can come back to it and figure out what I was doing easier. When i want to check the types when creating objects, I just use a factory function
*value
@nedzadarek if you're going that way, then
>> of: make op! func ['word value] [reflect get value word]
== make op! [['word value]]
>> words of system
== [version build words platform catalog state modules codecs schemes ports locale options script standard lexer console view reactivity]
though, isn't it a bug that the second argument is also passed as a word?
@giesse It's a known bug.
Musings on of:
of: make op! function ['word 'value] [
either any [
attempt [out: reflect get value word]
attempt [out: reflect value word]
attempt [
type!: get to-word head change back tail to-string word #"!"
out: parse value compose/deep [
collect any [keep (type!) | skip]
]
]
][out][
cause-error 'user 'message ["Bad arguments!"]
]
]
;== make op! [['word 'value /local out type!]]
words of system
;== [version build words platform catalog state modules codecs schemes ports locale ;options script standard lexer console view reactivity]
body of collect
;== [
; keep: func [v /only] [either only [append/only collected v] [append collected v] v]
; unless collected [collected: make block! 16]
; parse body rule: [
; ...
spec of find
;== [{Returns the series where a value is found, or NONE}
; series [series! bitset! typeset! any-object! map! none!]
; value [any-type!]
; /part "Limit the lengt...
values of #(a 1 b 2 c: 3.0)
;== [1 2 3.0]
words of [a 1 b 2 c: 3.0]
;== [a b]
set-words of [a 1 b 2 c: 3.0]
;== [c:]
integers of [a 1 b 2 c: 3.0]
;== [1 2]
spec of [a 1 b 2 c: 3.0]
;*** User Error: "Bad arguments!"
Improved:
of: make op! function ['word 'value] [
either any [
attempt [out: reflect get value word]
attempt [out: reflect value word]
attempt [
type!: get to-word head change back tail to-string word #"!"
rule: compose/deep [collect any [keep (type!) | skip]]
out: parse value rule
]
attempt [out: parse get value rule]
][out][
cause-error 'user 'message ["Bad arguments!"]
]
]
@giesse It was just to show general syntax (word (without
') + of + value). I haven't made it safe nor implemented all X-of. Yes, something like reflect can be good - if reflect will add something, then it will be "automatically implemented". We can go deeper with other values, like @toomasv has done ( :clap: )
@toomasv
ps. I don't what you are doing with the
ps. I don't what you are doing with the
type! so, for simplicity, I added another attempt. We can add support for typeset!s as well : of: make op! function ['word 'value] [
either any [
attempt [out: reflect get value word]
attempt [out: reflect value word]
attempt [
if all [
typeset? t: get word
block? value
][
out: parse value [collect any [keep t | skip]]
]
]
attempt [
type!: get to-word head change back tail to-string word #"!"
rule: compose/deep [collect any [keep (type!) | skip]]
out: parse value rule
]
attempt [out: parse get value rule]
][out][
cause-error 'user 'message ["Bad arguments!"]
]
]
; make op! [['word 'value /local out t type! rule]]
t: make typeset! [integer! float!]
; make typeset! [integer! float!]
t of [1 2.3 "foo" <ba> 3 4.4 <f>]
; [1 2.3 3 4.4]
@nedzadarek Did you try it first? In former (little-bit improved) version:
>> scalars of [#"a" 1 3.0 a :g 5%]
== [#"a" 1 3.0 5%]
And reflection regained:
of: make op! func [rule source] [
either any [object? :source map? :source any-function? :source] [
reflect :source rule
][
parse source [collect any [keep rule | skip]]
]
]
'words of system
;== [version build words platform catalog state modules codecs schemes ports locale options script standar...
'words of #(a 1 b 2)
;== [a b]
'spec of :collect
;== [{Collect in a new block all the values passed to KEEP function from the body block}
body [block!...
number! of [1 a 3.0 b]
;== [1 3.0]
@endo64 not until this red/red#3344 issue is closed. Making an infix variant of
reflect is one thing, but making a mish-mash of Parse, reflection and what-not is another (which I personally do not support).